dsh-ledger-memory 0.2.0 → 0.3.0

package/README.md

@@ -70,8 +70,27 @@ dsh plugin add dsh-ledger-memory
 /ledger log        查活动日志
 /ledger handoff    写一份交接单
 /ledger mode       看/切换压缩模式（steady / surgical）
+/ledger lock       把本场对话锁到某个项目目录（总工作区里用）
 ```
 
+### 对话建在总工作区时：锁定到子项目
+
+有时对话是建在**装着多个项目的总工作区**上的。那时插件无从判断"这次说的是哪个项目"，
+默认就都落在当前目录。解决办法是**锁**：
+
+```
+/ledger lock 20-DSH插件/04-其余插件/10.项目台账
+```
+
+锁定后，本场对话的**所有**工具调用都落在那个目录上，不必每次再指定。
+`/ledger lock` 不带参数看当前状态，`/ledger lock off` 解锁。
+会话第一轮弹的那张卡片里也有这个选项。
+
+> ★ 这个锁**只存在内存里**：不建注册表、不在你的目录里留任何标记、**一个文件都不写**，
+> 换一场对话就回到默认。它只影响"这次往哪儿记"，不改你磁盘上的任何东西。
+>
+> ★ 若当前目录**自己就有台账**，仍以当前目录为准 —— 锁只接管"没有台账"的目录。
+
 ### 设置面板
 
 **设置 → 项目台账（台账 / 压缩 / 日志）**，可调十三项：**压缩模式**、回合末卡片开关、
@@ -102,7 +121,7 @@ dsh plugin add dsh-ledger-memory
 
 切换：设置面板里选，或 `/ledger mode steady` / `/ledger mode surgical`（只影响当前项目）。
 
-## 十三个工具
+## 十四个工具
 
 AI 在对话里调用，你也可以让它调用：
 
@@ -119,6 +138,7 @@ AI 在对话里调用，你也可以让它调用：
 | `ledger_log_write` | 追加一条回合小结 |
 | `ledger_handoff` | 写交接单，供下一个会话接手 |
 | `ledger_triage` | 把阶段性产出分成「留 / 落 / 丢」三个桶（「反复追究」模式用） |
+| `ledger_lock` | 把本场对话锁到某个项目目录（只存内存，不写任何文件） |
 | `ledger_compact` | 请求一次高保真压缩 |
 | `ledger_checkpoint` | 把这一刻的选择交给用户（记台账 / 记+压缩 / 记+交接 / 跳过） |
 

package/lib/client.js

@@ -149,15 +149,40 @@ window.__ModuleLoader__.load({
         const n = Number(uiValue);
         return { [spec.key]: Number.isFinite(n) ? n : undefined };
       }
+      // ★ `choice` 就是**字符串**。走下面那条兜底本来也对 —— 但显式写出来，
+      //   是为了让"这个类型的值是什么形状"一眼可见（免得下一个人又按 boolean 猜）。
+      if (spec.kind === "choice") {
+        return { [spec.key]: typeof uiValue === "string" && uiValue !== "" ? uiValue : undefined };
+      }
       return { [spec.key]: uiValue };
     }
 
-    /** 从当前设置里取出某个控件要显示的初值。 */
+    /**
+     * 从当前设置里取出某个控件要显示的初值。
+     *
+     * ★★★ 2026-10-10 修（用户报的真 bug）：
+     *   *"那个压缩模式为什么我选择之后不能保存，然后关掉再打开之后即使已经选择了，
+     *     它依旧是空白的。两个模式都是未选择状态。"*
+     *
+     *   根因就是这里的**兜底**：原来最后一行是 `return v === true;` —— 那是给
+     *   **boolean** 写的兜底，而 `choice` 没有自己的分支 ⇒ 也掉进这一行。
+     *   于是已存 `"surgical"` 被读成 `false`，两个单选按钮**都不选中**。
+     *   ★ 而且坏的不只是显示：`buildDraft` 用它造草稿 ⇒ 草稿初值是 `false` ⇒
+     *     用户点完选项、`diffPatch` 一比对"没变化" ⇒ **patch 是空的、什么都没提交**。
+     *     ⇒ 一个兜底同时造成"显示不出来"与"保存不上"，两半是同一个根因。
+     *
+     * 教训（比这个 bug 值钱）：断言只验了"选项渲染出来了"，**没验"选中值能不能往返"**
+     *   —— 渲染断言对"选不中"完全无感。**一个新控件类型必须测它的值往返**。
+     */
     function settingsToUi(spec, settings) {
       const v = settings === undefined ? undefined : settings[spec.key];
       if (spec.kind === "tiers") return formatTiers(v);
       if (spec.kind === "levels") return v === undefined || v === null ? {} : v;
       if (spec.kind === "number") return v === undefined || v === null ? "" : String(v);
+      // ★ `choice`：原样把字符串交给控件（它自己按 options 比对谁被选中）。
+      //   没设过就返回 `""`（而不是 undefined）—— 与 number 的 `""` 同一条口径：
+      //   控件拿到的一定是**同一种类型**，不必每处再判 undefined。
+      if (spec.kind === "choice") return typeof v === "string" ? v : "";
       return v === true;
     }
 

package/lib/index.js

@@ -504,6 +504,70 @@ function currentSettings() {
   return activeSettings ?? settingDefaults();
 }
 
+/**
+ * ★★★ 2026-10-10（用户拍板）：sid → **本会话锁定的项目根**。
+ *
+ * **用户原话**：*"因为总的工作区是有需要读的东西的，所以有时候会把对话建在总的
+ * 工作区下面，这种时候的话，这个项目的锁定就应该考虑到可以让用户和AI说之后AI调用，
+ * 或者说把项目注册到对应的文件夹上，以后各种工具的使用都在那个文件夹上。"*
+ *
+ * 以及他对我提出的"要不要落个注册表文件"的**否决**：
+ * *"让模型拥有把插件锁定在对应或者说本次项目新建的文件夹中。而不是去动工作区的东西。
+ * 不应该有这个权利。最开始的提示卡片就可以有这样的选择。"*
+ *
+ * ⇒ 三条硬约束（都是他给的）：
+ *   ① **只在内存里** —— 绝不往工作区（或任何地方）写"注册表"。
+ *      模型没有"往用户工作区里登记东西"这个权利。这与他早先那条
+ *      「没登记就不往项目里写任何东西」是同一条纪律的延伸。
+ *   ② **只在这场对话内** —— 用 sid 做键，会话一换就没了。这是有意的：
+ *      对话建在总工作区是**这一次**的事，不该变成磁盘上的持久事实。
+ *   ③ **首轮卡片就给这个选择** —— 见 `FIRST_TURN_OPTIONS`。
+ *
+ * ★ 为什么用**模块级 Map** 而不是放进 `state`：
+ *   `projectRootOf(agent)` 只有 `agent` 一个入参，而它被 **9 处**调用，
+ *   其中 `rootFromExec` 那条链**根本拿不到 state**。把锁放进 state 就得改 9 个签名。
+ *   而"一个 profile 只装一份本插件"⇒ 模块级在这里是**真话**（与 `activeSettings`
+ *   同样的理由，见它上面的注释）。
+ * ★ 键是 sid ⇒ 天然满足约束②；`Map` 只在内存 ⇒ 天然满足约束①。
+ */
+const sessionProjectLock = new Map();
+
+/** 取某场会话锁定的项目根（没锁 ⇒ undefined）。 */
+function lockedRootOf(agent) {
+  const sid = agent?.session?.header?.id;
+  if (typeof sid !== "string" || sid === "") return undefined;
+  return sessionProjectLock.get(sid);
+}
+
+/** 锁定 / 解锁 / 查询（`ledger_lock` 与首轮卡片共用这一处，避免两处口径分叉）。 */
+function setProjectLock(agent, root) {
+  const sid = agent?.session?.header?.id;
+  if (typeof sid !== "string" || sid === "") {
+    return { ok: false, reason: "拿不到会话编号，锁不了（锁是按会话记的）。" };
+  }
+  if (root === undefined || root === null) {
+    const had = sessionProjectLock.delete(sid);
+    return { ok: true, locked: false, wasLocked: had };
+  }
+  const abs = path.resolve(String(root));
+  let isDir = false;
+  try {
+    isDir = fs.statSync(abs).isDirectory();
+  } catch {
+    isDir = false;
+  }
+  if (!isDir) {
+    return {
+      ok: false,
+      reason:
+        `\`${abs}\` 不是一个存在的目录，锁不了。` +
+        "★ 锁的目标**必须已经存在** —— 本插件不替你创建它（也不该由它来决定项目在哪）。",
+    };
+  }
+  sessionProjectLock.set(sid, abs);
+  return { ok: true, locked: true, root: abs };
+}
+
 
 /** 指针清单文件名（项目根，相对路径）。 */
 const MANIFEST_REL = ".dsh-ledger.json";
@@ -2986,9 +3050,36 @@ function renderAfterCompaction(info, capsule, meta) {
  * （`6.会话工作区用途\lib\index.js:454-460` 用的同一条；
  *   上下文查看器 `7.上下文查看器\lib\index.js:998` 也是 `s.header?.cwd`）。
  */
+/**
+ * 本会话的**项目根**。
+ *
+ * ★★★ 2026-10-10（用户拍板）加了「项目锁」：用户说的
+ *   *"把对话建在总的工作区下面…或者说把项目注册到对应的文件夹上，
+ *     以后各种工具的使用都在那个文件夹上"*。
+ *   ⇒ 锁生效时，**所有**工具都落在那个文件夹上（这条函数是 9 处调用的唯一出口，
+ *     所以在这里改一处就够 —— 这也是它值得保持"唯一出口"的理由）。
+ *
+ * ★★ 优先级：**cwd 自己有台账 > 锁 > cwd**（用户选的"只在这场对话内接管"）。
+ *   为什么不无条件以锁为准：用户说得很明确 ——
+ *   锁是给"cwd 没有台账（典型：建在总工作区）"这种情况用的**接管**手段；
+ *   若当前目录本来就是一个有台账的项目，那它自己就是答案，锁不该压过它。
+ *   ⇒ 这条判据让"锁"**只会扩大能用的情况，不会改变已有情况**（与 D49 默认 steady
+ *     同一条思路：新能力不许悄悄改掉旧行为）。
+ *
+ * ★ 代价（如实记下）：这里多了一次 `readManifest`（只读一个小 JSON）。
+ *   它只在**真的锁了**的时候才走，没锁的会话行为与以前**逐字节相同**。
+ *
+ * @param {object} agent
+ * @returns {string|undefined} 绝对路径；拿不到 cwd 且没锁 ⇒ undefined
+ */
 function projectRootOf(agent) {
   const cwd = agent?.session?.header?.cwd;
-  return typeof cwd === "string" && cwd !== "" ? path.resolve(cwd) : undefined;
+  const here = typeof cwd === "string" && cwd !== "" ? path.resolve(cwd) : undefined;
+  const locked = lockedRootOf(agent);
+  if (locked === undefined) return here; // 没锁 ⇒ 与以前完全一致
+  // 锁了：当前目录**自己有台账**就以它为准（锁只接管"没有台账"的情况）。
+  if (here !== undefined && readManifest(here) !== undefined) return here;
+  return locked;
 }
 
 /** 读指针清单（不存在 ⇒ undefined）。 */
@@ -4719,6 +4810,19 @@ const FIRST_TURN_OPTIONS = [
     description: "一次性的事（排查/调研）。用 ledger_note 记一份有终点的记录。",
   },
   { label: "暂时不用记", description: "这次什么都不留，直接继续。" },
+  {
+    // ★★★ 2026-10-10 用户拍板加的这一项。他的原话：
+    //   *"因为总的工作区是有需要读的东西的，所以有时候会把对话建在总的工作区下面…
+    //     把项目注册到对应的文件夹上，以后各种工具的使用都在那个文件夹上。"*
+    //   以及 *"最开始的提示卡片就可以有这样的选择。"*
+    // ★ 为什么这一项必须出现在**第一张**卡片上，而不是等 AI 想起来问：
+    //   有 104/112 场会话的 cwd 就是容器根（实测）。也就是说"对话建在总工作区"
+    //   是**常态而非边角**，而那种情况下每一条工具调用都需要知道"到底在说哪个项目"。
+    label: "锁定到某个子项目",
+    description:
+      "这个目录是总工作区（装着多个项目）时用：指定一个子文件夹，本场对话的工具都落在那里。" +
+      "只在本次对话内有效，不写任何文件。",
+  },
 ];
 
 /**
@@ -4751,6 +4855,11 @@ function conformChoiceOf(label) {
 /** 「建项目 or 不建」的选项标签 → 内部动作。 */
 function firstTurnChoiceOf(label) {
   const s = typeof label === "string" ? label : "";
+  // ★ 顺序要紧：`锁定` 那条的说明里**含**"建"字吗？不含 —— 但"建项目"那条含。
+  //   所以先判"锁定"（更具体），再判"建项目"。反过来的话"锁定到某个子项目"
+  //   不会误中，但将来若有人把标签写成"建/锁到子项目"就会串。
+  //   ⇒ 判据一律**先具体后笼统**（与 `conformChoiceOf` 同一条纪律）。
+  if (s.includes("锁定")) return "lock";
   if (s.includes("建项目")) return "project";
   if (s.includes("问题记录")) return "note";
   if (s.includes("不用记")) return "none";
@@ -4784,7 +4893,9 @@ function firstTurnNext(choice, info, received) {
         `用户选了「建项目」，但本会话工作目录是**容器工作区**（\`${info.projectRoot}\`），` +
         "这里**不能**建台账。请**先问用户是哪个子项目**，然后在那个子目录里初始化：" +
         "要么让用户把会话工作目录切过去，要么给 `ledger_init` 传 `root` 点名它。" +
-        "**不要**在当前目录 `git init`。"
+        "**不要**在当前目录 `git init`。" +
+        "\n★ 也可以顺手用 `ledger_lock` 把本场对话锁到那个子项目上 —— 之后所有工具都落在那里，" +
+        "不必每次再传 `root`。"
       );
     }
     return (
@@ -4794,6 +4905,18 @@ function firstTurnNext(choice, info, received) {
       "并建议一并传 `logDir` 启用活动日志。做完向用户简报一句文件名与结构。"
     );
   }
+  // ★★★ 2026-10-10 用户拍板加的这一条（首轮卡片第四项）。
+  if (choice === "lock") {
+    return (
+      "用户选了「锁定到某个子项目」。**先问清是哪个子文件夹**（不要自己猜 —— " +
+      `当前目录 \`${info.projectRoot}\` 是容器工作区，底下可能有几十个项目，猜错就是把台账写进别人的项目）。` +
+      "拿到目录后调 `ledger_lock`（传 `root`）把本场对话锁过去。\n" +
+      "★ 锁**只存内存、只在本场对话内有效、不写任何文件** —— 可以放心告诉用户这一点，" +
+      "他不会因此在自己工作区里多出东西。\n" +
+      "★ 锁好之后：那个目录若还没有台账，问用户要不要 `ledger_init` 建一套；" +
+      "此后本会话的所有工具调用都会落在那个目录上，**不需要再传 `root`**。"
+    );
+  }
   return `用户的选择没有对上三个选项（收到：${received ?? ""}）。请按最稳妥的方式继续：**先问用户**这个目录要不要建项目台账。`;
 }
 
@@ -7078,6 +7201,112 @@ function defineHandoffTool() {
   };
 }
 
+/**
+ * ⑦之三 `ledger_lock` —— 把**本场会话**锁到某个项目目录上。
+ *
+ * **用户原话（2026-10-10）**：
+ *   *"因为总的工作区是有需要读的东西的，所以有时候会把对话建在总的工作区下面，
+ *     这种时候的话，这个项目的锁定就应该考虑到可以让用户和AI说之后AI调用，
+ *     或者说把项目注册到对应的文件夹上，以后各种工具的使用都在那个文件夹上。"*
+ *
+ * 以及他**否决**"落一份注册表文件"时的原话：
+ *   *"让模型拥有把插件锁定在对应或者说本次项目新建的文件夹中。而不是去动工作区的东西。
+ *     不应该有这个权利。最开始的提示卡片就可以有这样的选择。"*
+ *
+ * ⇒ 三条硬约束（他给的，逐条对应到实现）：
+ *   ① **不碰工作区**：锁只存在内存里（`sessionProjectLock`），**一个字节都不落盘**。
+ *      工具描述里也**明说**这一点 —— 免得 AI 以为"锁了会留痕"而不敢用。
+ *   ② **只在这场对话内**：键是 sid，会话一换即失效（有意的）。
+ *   ③ **首轮卡片也要给**：见 `FIRST_TURN_OPTIONS` 的第四项。
+ *
+ * ★ 为什么做成**工具**而不是让插件自己猜项目：
+ *   "哪个子目录是这个会话要干的活"是**人的意图**，插件无从推断（总工作区里有几十个
+ *   子项目，猜错就是把台账写到别人项目里）。让 AI 明确调用、并在调用前问用户，
+ *   与 `ledger_note` / `ledger_handoff` 是同一套分工：**判断归 AI，流程归插件**。
+ */
+function defineLockTool() {
+  return {
+    name: "ledger_lock",
+    description:
+      "Pin THIS conversation to one project directory, so every later tool call resolves against " +
+      "it instead of the session's cwd. Use it when the conversation was started in a container " +
+      "workspace (a folder holding several sub-projects) and the user wants the ledger work to land " +
+      "on one specific sub-project. In memory ONLY for the current conversation: it writes nothing " +
+      "to disk (no registry file, no marker, nothing inside the target), and it is gone when the " +
+      "conversation ends. Pass no `root` to release the lock. Precedence: if the cwd itself already " +
+      "has a ledger, that wins and the lock only takes over directories that have none.",
+    parameters: {
+      type: "object",
+      properties: {
+        root: ROOT_PARAM,
+        release: {
+          type: "boolean",
+          description: "Set true to release the lock instead of setting one. Same as omitting `root`.",
+        },
+      },
+      additionalProperties: false,
+    },
+    output: { schema: OK_SCHEMA, render: renderResult },
+    async execute(args, exec) {
+      const agent = exec?.agent;
+      const release = args?.release === true || (typeof args?.root !== "string" || args.root.trim() === "");
+      const cur = lockedRootOf(agent);
+
+      if (release) {
+        const r = setProjectLock(agent, undefined);
+        return {
+          ok: true,
+          locked: false,
+          wasLocked: cur ?? null,
+          note:
+            cur === undefined
+              ? "本来就没有锁 —— 什么都没变（工具调用一律按会话工作目录解析）。"
+              : `已解锁（原锁定：\`${cur}\`）。此后按会话工作目录解析。`,
+          // ★ 明说"没有落盘"，免得 AI/用户以为要清理什么残留。
+          written: null,
+          persists: false,
+        };
+      }
+
+      const raw = String(args.root).trim();
+      const base = projectRootOf(agent);
+      const abs = path.resolve(base ?? process.cwd(), raw);
+      const r = setProjectLock(agent, abs);
+      if (r.ok !== true) {
+        return { ok: false, reason: r.reason, written: null, persists: false };
+      }
+      const info = inspect(abs);
+      return {
+        ok: true,
+        locked: true,
+        root: abs,
+        // ★ 如实告诉它这个目录**是什么**：有台账 / 是容器 / 是空目录。
+        //   锁到一个没有台账的目录**不是错误**（下一步就 `ledger_init` 建），
+        //   但锁到一个**容器工作区**通常是搞错了（那是"装着项目的地方"，不是项目）。
+        hasLedger: info.activeRel !== undefined,
+        active: info.activeRel ?? null,
+        isGitRepo: info.isGitRepo,
+        containerWorkspace:
+          info.isGitRepo !== true && (info.containerMarker !== undefined || info.nestedRepo !== undefined)
+            ? info.containerMarker ?? info.nestedRepo ?? "?"
+            : null,
+        note:
+          info.activeRel !== undefined
+            ? `已锁定到 \`${abs}\`（这个目录有台账：\`${info.activeRel}\`）。此后本会话的工具都落在这里。`
+            : `已锁定到 \`${abs}\`（它还没有台账 —— 要让这个项目有台账，接着调 \`ledger_init\`）。` +
+              "此后本会话的工具都落在这里。",
+        // ★★★ 三句都必须说，否则用户会担心"是不是又往我工作区写东西了"。
+        written: null,
+        persists: false,
+        scope: "仅本场对话（存内存，会话结束即失效）",
+        hint:
+          "★ 本次锁定**没有写任何文件**：不建注册表、不在目标目录留标记。" +
+          "换一场对话就回到默认（按会话工作目录解析）。",
+      };
+    },
+  };
+}
+
 /**
  * ⑦之二 `ledger_triage` —— 「反复追究」模式下的**分流单**（用户说的"划分"）。
  *
@@ -7466,6 +7695,14 @@ const LEDGER_SUBCOMMANDS = [
       "（压缩前由 AI 分流：留上下文 / 落进项目 `_stash/` / 丢掉）之间切换。" +
       "★ 写进**这个项目**的 `.dsh-ledger.json`，只影响本项目；不带参数则只报当前模式。",
   },
+  {
+    sub: "lock",
+    label: "把本场对话锁到某个项目目录",
+    description:
+      "对话建在**总工作区**（装着多个项目）时用：`/ledger lock 子项目路径` ⇒ " +
+      "此后本会话所有工具都落在那个目录上，不必每次传 `root`。" +
+      "★ 只存**内存**、只在**本场对话**内有效、**不写任何文件**；`/ledger lock` 不带参数 = 解锁。",
+  },
   {
     sub: "handoff",
     label: "写交接单（给下一场会话）",
@@ -7833,6 +8070,50 @@ async function runLedgerSub(ctx, invocation, state, sub, capsule, argument) {
     };
   }
 
+  // ── `/ledger lock [子项目路径]` —— 把本场对话锁到一个项目目录（2026-10-10）──
+  //
+  // ★ 用户原话：*"可以让用户和AI说之后AI调用，或者说把项目注册到对应的文件夹上，
+  //   以后各种工具的使用都在那个文件夹上。"* + *"最开始的提示卡片就可以有这样的选择。"*
+  // ★ 与 `ledger_lock` 工具**共用** `setProjectLock` / `lockedRootOf` ——
+  //   命令与工具走同一条路（本文件反复强调：两个入口必须后果一模一样）。
+  // ★ 不带参数 = 报当前锁定状态（若已锁则解锁？不 —— 那太危险）。
+  //   这里是**只读报告**；要解锁得明确说 `/ledger lock off` 或 `none`。
+  if (sub === "lock") {
+    const want = typeof argument === "string" ? argument.trim() : "";
+    const cur = lockedRootOf(invocation?.agent);
+    const show = (extra) =>
+      ({
+        kind: "success",
+        text:
+          extra +
+          `\n**当前锁定**：${cur === undefined ? "（无 —— 按会话工作目录解析）" : `\`${cur}\``}\n\n` +
+          "用法：\n" +
+          "· `/ledger lock <路径>` —— 锁到那个目录（相对路径按当前工作目录解析）\n" +
+          "· `/ledger lock off` —— 解锁，回到按会话工作目录解析\n\n" +
+          "★ 这个锁**只存内存、只在本次对话内有效、不写任何文件** —— " +
+          "不会在你的工作区里多出任何东西。",
+      });
+
+    if (want === "") return show("**锁定状态（只读）**：这条命令不带参数时什么都不改。\n");
+    if (["off", "none", "clear", "unlock", "-"].includes(want.toLowerCase())) {
+      const r = setProjectLock(invocation?.agent, undefined);
+      return show(r.wasLocked === true ? "已**解锁**。" : "本来就**没有锁** —— 什么都没变。");
+    }
+
+    const base = projectRootOf(invocation?.agent);
+    const abs = path.resolve(base ?? process.cwd(), want);
+    const r = setProjectLock(invocation?.agent, abs);
+    if (r.ok !== true) return { kind: "error", text: r.reason };
+    const info = inspect(abs);
+    return show(
+      `已锁定到 \`${abs}\`。\n\n` +
+        (info.activeRel !== undefined
+          ? `这个目录有台账：\`${info.activeRel}\`。`
+          : "⚠️ 这个目录**还没有台账** —— 要让它有，接着让 AI 调 `ledger_init`。") +
+        "\n"
+    );
+  }
+
   if (sub === "log") {
     const info = inspect(root);
     if (info.logRel === undefined) {
@@ -8654,6 +8935,7 @@ export function apply(ctx, config) {
     ["ledger_note", defineNoteTool],
     ["ledger_handoff", defineHandoffTool],
     ["ledger_triage", () => defineTriageTool(state)],
+    ["ledger_lock", defineLockTool],
     ["ledger_conform", defineConformTool],
     ["ledger_compact", () => defineCompactTool(ctx, state, capsule)],
     [CHECKPOINT_TOOL, () => defineCheckpointTool(ctx, state)],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-ledger-memory",
-  "version": "0.2.0",
-  "description": "台账记忆（Ledger Memory）：为 DSH 提供工程化的项目记忆 —— 台账的检测/注入/归档/Git 配合，活动日志（L0–L4），三层上下文压缩与逐字胶囊落盘，两种压缩模式（正常推进 / 反复追究），以及跨会话的交接单闭环。可回溯、可追查。",
+  "version": "0.3.0",
+  "description": "台账记忆（Ledger Memory）：为 DSH 提供工程化的项目记忆 —— 台账的检测/注入/归档/Git 配合，活动日志（L0–L4），三层上下文压缩与逐字胶囊落盘，两种压缩模式（正常推进 / 反复追究），把会话锁定到某个项目目录，以及跨会话的交接单闭环。可回溯、可追查。",
   "keywords": [
     "dsh",
     "dsh-plugin",