dsh-memory-evolve — Usage Scenario Guide

> In one sentence: Give the AI inside DSH long-term cross-session memory, help you manage todos and skills, and let you orchestrate a team of AI sessions and external AI agents working together — the more you use it, the more it understands you, and switching sessions never loses context. > > This guide is organized around real workflows. Each scenario explains "who it's for, what it can do, how to use it, and what you get." > > Related docs: [Detailed feature guide](README-详细说明.md) · [Memory sync](docs/记忆同步.md) · [Changelog](docs/CHANGELOG.en.md) · 中文

---

Quick Start (Installation)

The plugin ships its own cordis.patch.yml (declared via dsh.bundle.patch), so after dsh plugin add the host side registers automatically — no manual configuration needed. Using the web profile as an example, two steps:

# 1. Install into the profile (use link: for a local directory; git/registry
#    package addresses also work)
dsh plugin --profile web add github:csyangwen/dsh-memory-evolve

# 2. Restart dsh web — done

> ⚠️ Do NOT manually insert this plugin into ~/.dsh/profiles/web/cordis.patch.yml: the bundle patch already registers it; a duplicate insert with the same id crashes the loader with a duplicate loader entry id error. See the [detailed guide](README-详细说明.md) "标准安装" section for the full story.

Changing default config (e.g. turning on per-turn memory review): override by id in the profile's cordis.patch.yml (top-level form, not an insert):

- id: dsh-memory-evolve
  config:
    reviewEnabled: true      # enable per-turn memory review (off by default)
    reviewInterval: 10       # review every 10 user turns

Temporarily disabling the plugin when it breaks DSH startup (until the fix lands): add one line to the profile's cordis.patch.yml — no uninstall needed:

- id: dsh-memory-evolve
  disabled: true

Upgrading from an older version: if you previously inserted this plugin manually per older docs, delete that insert block from your profile patch (it now duplicates the bundle registration).

To uninstall: dsh plugin --profile web remove dsh-memory-evolve. Everything is cleaned up automatically.

---

Meet It (30 Seconds)

After installing the plugin, open any session and you'll get a row of capability tabs: Memory · Skills · Todos · Infinite Canvas · COI Scheduling · Session Broadcast · Prompts · Memory Sync · Model Settings · Bookmarks · Session Review · Web UI Settings · Memory Evolve Settings. On the AI side, you get a batch of tools: memory read/write, todos, skill management, local file search, session orchestration, session broadcast, external-AI dispatch, prompt injection, model query, and more.

In one sentence: let the AI remember you, manage for you, do for you, and work together for you.

> Tip: Many plugin capabilities are off by default (so they don't bloat the AI's tool list). Turn them on in "Memory Evolve Settings" when needed. Most scenarios below are combination plays — turn on all the related features to assemble a complete pipeline.

---

Scenario 1: Let the AI Truly Remember You (Long-Term Memory)

Who it's for: Everyone. This is the plugin's core and the foundation of everything else.

An AI's conversation is "one-shot": switch projects, wait a few days, or open a new session, and it forgets who you are. The plugin's five-track memory gives the AI cross-session long-term working memory:

• User profile: your preferences, company, communication habits — the AI sees these every turn;
• Global facts: long-term knowledge about environments, tools, and conventions;
• Project key memory: the current project's conventions, decisions, architecture, and gotchas, auto-injected into context; important conclusions can be tagged to apply only on a specific git branch;
• Project log / daily log: progress is auto-recorded every turn, read on demand, history traceable.

How to use it:

1. Just talk to the AI normally — at the end of each turn it automatically writes progress into the project log and daily log; 2. When you hit an important fact, say "Note this down: this project's deployment port is 8080" — it writes to project key memory, effective only after you confirm — the AI never writes to memory on its own; 3. Days later, in another session, just ask "Check memory: what architecture decision did we settle on last time?" — it picks up seamlessly; 4. Once memory grows, tell the AI to "archive that XX memory entry" — archived entries no longer get injected into context and can be restored anytime; 5. Emotion feedback log: your evaluation of work results (e.g. "great!" or "why isn't it fixed yet?") is recorded into the daily and project logs (a 【feedback】 line with emotion, task category, and your exact words) — accumulated over time, you can ask the AI to "analyze what I've been dissatisfied with recently" and judge where it does well or poorly by task type.

What you get: the AI goes from a conversation machine that "goes amnesiac every session" to a long-term partner that understands your whole workflow — continue development the next day and it directly cites yesterday's conclusions without you repeating them.

---

Scenario: Share Project Memory Across Computers (Memory Sync)

Who it's for: People working on two computers (office + home) or collaborating with colleagues on the same project — who don't want to re-explain important conclusions on every machine.

How to use it (see [Memory sync](docs/记忆同步.md) for details):

1. In "Memory Evolve Settings → Config", turn on the Memory Sync module switch (this only makes the feature visible); 2. In the project session's Memory Sync tab, turn on Sync this project — click "Start sync" (the remote memory defaults to your code repo, auto-stored in a dedicated branch without polluting code), then click "Sync and push" to finish the first push; code is public (e.g. open-source on GitHub) but you want memory private? Fill in a shared memory repo address — one repo holds all projects' memory (one dedicated branch per project), keeping memory fully isolated from code; 3. On the other computer, clone the project and open it — it auto-recognizes (same repo URL = same project), pull it down and continue; 4. Write memory as usual (real-time flush, zero latency), accumulate a batch and click "Sync" once; a conflict only appears when both machines edited the same entry — in the tab choose "take local / take remote / keep both".

What you get: project key memory, project logs, archives, and project todos stay consistent across devices; with a shared memory repo filled in, global memory (user profile / daily log / todos) also syncs across devices (four independent track switches — sync only what you turn on) — switch computers without switching memory. Projects with sync off are completely unaffected (stay purely local).

---

Scenario 2: Multi-Project Parallel Development, Nothing Falls Through (Todos + Project Log + Local Search)

Who it's for: Developers juggling multiple projects who keep getting stuck on "how was that earlier approach decided?"

• Four-track todos: Life / Work / Project / Daily. The "Project" track is isolated by working directory — switching directories doesn't interfere. Say "Remember: before Friday, deploy the second-level panel to the mobile-access instance" and it becomes a project todo (with important/urgent flags and due date); at the end of each day the AI reminds you of due todos;
• Project log: each project's progress is settled in isolation by directory, logs auto-tagged with [git main] branch markers for traceability;
• Local file search: tell the AI "search my machine for anything similar I've written before" — finds docs by filename (extensible to all types); also content search: "which doc mentions XX" directly returns the matching file and snippets.

How to use it:

1. Start a new project and just start chatting — the project log auto-creates; 2. Ideas that pop up, say "remember" to the AI — they enter the pending-confirmation queue — adopt or reject in "Todos", you call the shots; 3. When you can't recall, ask "a doc mentioned XX before".

What you get: juggling 3 projects at once stays tidy — each project's memory, todos, and doc clues go to their own directories, recoverable with one question.

---

Scenario 3: One Person Directing a Team of AIs (Internal Team)

Who it's for: People who want to use AI as a "team" — one main session directing designer, frontend, backend, and test sub-sessions.

How to use it:

1. Assemble the team: tell the main session's AI "Create 4 sessions: designer handles site visuals, frontend handles pages, backend handles APIs, test handles acceptance, and pull them into one collaboration room" — it immediately creates 4 standard sessions (appearing in the left list, ready to take over anytime), automatically inheriting your model and working directory; you can specify an Agent preset when creating (e.g. "create the frontend session in code mode") to decide that session's tool surface and personality; 2. Collaborative communication: once the room is built, who changed what and who finished is visible to all; member status changes (generating / idle) auto-trigger a "room activity" notification; room messages can carry images — paste a screenshot into the group, and the receiving AI gets the image file path via read, can read the image, and can forward it to an IM channel; 3. Dispatch and nudge: ask the AI "who's working now and who's idle?" and it checks each session's status; for an idle session say "tell frontend to send the results over" and the AI auto-wakes it and dispatches work — no batch auto-waking, everything is consciously directed by you (or your main session); 4. Conflict prevention: when multiple sessions edit code in parallel on the same project, tell the AI before starting "declare which files you'll modify" — others (and their AIs) can see "who's changing what"; on a real collision the writer gets a conflict warning, plus "workspace activity" notifications (separately pushed on parallel start/end and member changes) keep you informed who's running and doing what; 5. Result handoff: each member posts results back to the room, and you aggregate and confirm.

Sustained operation (key): the main session keeps running itself, so it can wake any resting (idle) session at any time to continue work — nudge, collect results, dispatch the next round; even away from the computer, the team pushes forward to results. The only prerequisite is the DSH process hosting the main session keeps running; if the main session goes idle or DSH is closed, the wake chain stops — you need to come back and send a message for the team to restart.

What you get: one person's dev output becomes a small team's throughput. Task handoff, waking, and conflict warnings are automated end-to-end, with room messages traceable.

---

Scenario 4: Hand Heavy Work to External AI Agents (External Help)

Who it's for: Users who need to hand big tasks (visual redesign, code review, full feature development) to dedicated AI agents (Kimi / Codex / Grok / Hermes) — without being blocked, and without missing results.

How to use it:

1. Tell the AI "dispatch this task to grok: mobile adaptation refactor" — it runs async in the background, returns a task ID immediately, doesn't block the current session, and you can keep chatting; 2. Ask anytime "how's the task going?" or watch the real-time log stream in "COI Scheduling"; 3. When dispatching, the AI can choose to carry your project memory along — the external agent also "understands project conventions"; 4. Dispatch with images: tell the AI "send this screenshot to grok for analysis" — attachments support local path / remote URL / current-session image (the image you pasted in the input box); codex/kimi/hermes can actually see images (grok reads via prompt; zcode is text-only and rejects explicitly); 5. On completion the result summary auto-writes into the project log and daily log — dispatched work automatically becomes your memory asset.

What you get: AI dispatches work to AI, and you only handle confirmation and acceptance. Visual redesign, deep code review, batch refactoring — these "heavy jobs" can all be offloaded, keeping the main session light.

---

Scenario 5: Inside + Outside Working Together — One Team, Two Kinds of Troops

Who it's for: People whose tasks are too big for one side alone. This is the full form of the plugin's collaboration: internal sessions handle work needing context and back-and-forth polishing; external agents handle one-shot heavy work; memory, rooms, and prompts chain them into a pipeline.

A complete real flow (product visual redesign):

1. Divide work: the main session spawns frontend and test internal sessions and pulls them into a room; meanwhile it dispatches "full-site visual redesign" to the external agent Kimi; 2. External leads: Kimi runs the redesign in the background (occupying no session); meanwhile the internal frontend session builds the data layer and page structure without idling; 3. Handoff: Kimi finishes, and the summary auto-settles into project memory — the main session posts the design conclusion to the room, and the frontend session reads memory to get the design spec and starts integrating; 4. Escalation: a weird styling bug appears during integration and the frontend session gets stuck — the main session dispatches the bug to Grok for deep digging, the conclusion returns to the room, and the frontend session fixes it accordingly; 5. Acceptance: the test session runs the acceptance flow, posts results to the room, and you confirm at the end.

Four collaboration joints, freely combinable:

• Task relay: external agents' output (summaries/conclusions) auto-enters memory → internal sessions relay and execute — external does the heavy work, internal does integration and polish;
• Escalation: internal sessions hit a hard problem → the main session dispatches it to an external agent to dig deep → the conclusion returns to the room — internal iterates fast, external does slow careful work;
• Unified standards: when dispatching to external agents, inject your accumulated prompts (like "code review checklist" or "PRD spec") — external agents work by your process, not by luck;
• Status sync: who's running and who's done is visible anytime via room + workspace activity + notifications — you don't have to be a human dispatcher.

What you get: a complete pipeline of "external leads → internal integrates → test accepts → you confirm." Big tasks are no longer carried by one person (or one AI), but split between an internal and external team.

---

Scenario 6: The AI's Self-Discipline — Prompt Injection

Who it's for: People who want to settle "good working methods" and make every AI (including external agents) work by the same process.

The prompt library is an instruction-paradigm asset library: code review, debugging, PRD, test strategy… solidify commonly used working methods into prompts (categorizable, searchable, enable/disable-able).

How to use it:

1. The AI picks and injects on its own: when the AI thinks a certain process fits the current task, it checks the prompt library itself, picks the right prompt, and injects it into itself — "proceed by the code review checklist"; next turn it follows automatically, without interrupting the current reply; it can also "inject immediately" to take effect this turn; 2. You inject with one click: in "Prompt Injection", select one and click "Inject once / Continuously inject / Inject immediately" — continuous injection means "remind the AI to work by this discipline every turn"; 3. Temporary injection: without creating a prompt, directly type a requirement to inject — it's auto-saved into the library for reuse; 4. Dispatch with discipline: when dispatching to sub-sessions or external agents, have the AI carry the corresponding prompt along — the whole team uses the same standard.

What you get: good methods no longer live only in your head or a single conversation — they become a reusable "team playbook" the AI follows on its own, while you only maintain the playbook's quality.

---

Scenario 7: Sessions Too Long, Too Expensive, Easy to Blur — Bookmarks and Branches

Who it's for: Heavy users sensitive to context cost whose single sessions routinely run hundreds of turns.

• Session bookmarks: star (☆) any turn, "Bookmarks" lists all bookmarks (name / turn / time / summary, searchable), one click jumps back to any turn — star it when you discover "this conclusion matters";
• Branch from any turn: officially you can only branch from the last turn; this plugin takes over the branch entry for any middle turn — click "Branch" in the bookmark list (or click the official branch button, and a middle turn pops a confirmation), creating a new session through the official branch channel and entering the official branch genealogy;
• Context usage reminder: the input-box ring shows context usage in real time — ≥30% turns yellow, ≥40% turns red, reminding you it's time to bookmark, branch, or open a new session.

How to use it:

1. In exploratory sessions, star key turns and name the bookmark (e.g. "Plan A review conclusion"); 2. To fork a new line from a middle decision point, click "Branch" in the bookmark list; 3. When the ring turns red, bookmark the current session and open a new session to continue.

What you get: context is no longer a rope you can only scroll from start to end, but a timeline with anchors, branches, and jumps — every turn's exploration can be precisely reused, and you no longer have to abandon good middle conclusions just because "the session got too long."

---

Scenario 8: Use It Away from the Computer (Mobile Access + Session Filtering + Notifications)

Who it's for: People who want to keep collaborating with AI away from the computer, or who open too many sessions to watch.

• Mobile browser access: the DSH UI is adapted for phones — conversation area / message bubbles full-width, input bar "⋯" pulls up the collapsed toolbar and model selection; mobile operation matches desktop;
• Session list filtering: the left list can show only "active sessions", one screen to see who's working — desktop too;
• Channel notification (de_notify): tell the AI "notify me via Feishu when the task finishes" — important results pushed to Feishu/QQ/WeChat/WeCom, known immediately at the computer or on the phone (notifications carry a "this is a notification" tag and can attach images/files);
• Web in-site notification (de_notify channels=web): tell the AI "send me an in-site notification" — it lands directly on the bell at the top-right of the web page — unread count badge + popup list, showing "which session sent what", click the subject to jump to that session, long content click "view details" for a large popup; the bell is freely draggable and snaps to the left/right screen edge (position remembered). Sending to web and to Feishu etc. is the same sentence, just a different destination (channels web, or all to send both);
• Channel direct-send (de_channel_send): the AI proactively sends text/images/files to your IM channel anytime (no notification tag) — the "send me the generated image/document" scenario; all four channels (Feishu/QQ/WeChat/WeCom) supported, attachment sources can be local path / remote URL / inline base64 / current-session image (sessionImage=true directly forwards the image you pasted/drag

…