harness-wingman 0.8.0 → 0.8.2

package/apps/cli/dist/main.js

@@ -7757,11 +7757,11 @@ function isPatchState(value) {
   const patch = value;
   return typeof patch.patchFile === "string" && typeof patch.original === "object" && patch.original !== null && typeof patch.original.existed === "boolean" && (patch.original.bytesBase64 === void 0 || typeof patch.original.bytesBase64 === "string");
 }
-async function readState(paths) {
-  const buffer = await readIfExists(paths.stateFile);
+async function readState(paths3) {
+  const buffer = await readIfExists(paths3.stateFile);
   if (buffer === void 0)
     return void 0;
-  const state = JSON.parse(decodeUtf8Strict(buffer, paths.stateFile));
+  const state = JSON.parse(decodeUtf8Strict(buffer, paths3.stateFile));
   if (typeof state !== "object" || state === null || state.version !== 1 && state.version !== 2) {
     throw new Error("\u672A\u77E5\u7684\u63A5\u7EBF\u72B6\u6001\u7248\u672C,\u4E0D\u731C");
   }
@@ -7770,18 +7770,18 @@ async function readState(paths) {
   }
   return state;
 }
-async function writeState(paths, state) {
-  await mkdir(dirname(paths.stateFile), { recursive: true });
-  await writeFile(paths.stateFile, `${JSON.stringify(state, void 0, 2)}
+async function writeState(paths3, state) {
+  await mkdir(dirname(paths3.stateFile), { recursive: true });
+  await writeFile(paths3.stateFile, `${JSON.stringify(state, void 0, 2)}
 `, "utf8");
 }
-function backupDirectory(paths) {
-  return join(paths.backupsRoot, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
+function backupDirectory(paths3) {
+  return join(paths3.backupsRoot, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
 }
-async function backupPatchFile(paths, backupDir, file, bytes) {
-  const fromProfiles = relative(paths.profilesDir, file);
+async function backupPatchFile(paths3, backupDir, file, bytes) {
+  const fromProfiles = relative(paths3.profilesDir, file);
   let safeRelative;
-  if (file === paths.patchFile) {
+  if (file === paths3.patchFile) {
     safeRelative = join("home", "cordis.patch.yml");
   } else if (!fromProfiles.startsWith("..") && !isAbsolute(fromProfiles)) {
     safeRelative = join("profiles", fromProfiles);
@@ -7793,15 +7793,15 @@ async function backupPatchFile(paths, backupDir, file, bytes) {
   await mkdir(dirname(target), { recursive: true });
   await writeFile(target, bytes);
 }
-async function writeOwnedFiles(paths, url) {
-  await mkdir(dirname(paths.hooksConfigFile), { recursive: true });
-  await writeFile(paths.forwarderFile, FORWARDER_SOURCE, "utf8");
-  await writeFile(paths.hooksConfigFile, buildHooksConfig(paths.forwarderFile, url), "utf8");
+async function writeOwnedFiles(paths3, url) {
+  await mkdir(dirname(paths3.hooksConfigFile), { recursive: true });
+  await writeFile(paths3.forwarderFile, FORWARDER_SOURCE, "utf8");
+  await writeFile(paths3.hooksConfigFile, buildHooksConfig(paths3.forwarderFile, url), "utf8");
 }
-async function listProfiles(paths, environment) {
+async function listProfiles(paths3, environment) {
   let entries;
   try {
-    entries = await readdir(paths.profilesDir, { withFileTypes: true });
+    entries = await readdir(paths3.profilesDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT")
       entries = [];
@@ -7813,12 +7813,12 @@ async function listProfiles(paths, environment) {
     if (entry.name === "node_modules")
       continue;
     try {
-      if (!(await stat(join(paths.profilesDir, entry.name))).isDirectory())
+      if (!(await stat(join(paths3.profilesDir, entry.name))).isDirectory())
         continue;
     } catch {
       continue;
     }
-    const manifest = join(paths.profilesDir, entry.name, "package.json");
+    const manifest = join(paths3.profilesDir, entry.name, "package.json");
     if (await readIfExists(manifest) !== void 0)
       names.push(entry.name);
   }
@@ -7830,12 +7830,12 @@ async function listProfiles(paths, environment) {
   const selectedNames = selected === void 0 || selected === "" ? names : [selected];
   const inspected = [];
   for (const name of selectedNames) {
-    const dir = join(paths.profilesDir, name);
+    const dir = join(paths3.profilesDir, name);
     const missingPackages = [];
     for (const packageName of REQUIRED_PACKAGES) {
       const parts = packageName.split("/");
       const localManifest = join(dir, "node_modules", ...parts, "package.json");
-      const parentManifest = join(paths.profilesDir, "node_modules", ...parts, "package.json");
+      const parentManifest = join(paths3.profilesDir, "node_modules", ...parts, "package.json");
       if (await readIfExists(localManifest) === void 0 && await readIfExists(parentManifest) === void 0) {
         missingPackages.push(packageName);
       }
@@ -7852,7 +7852,7 @@ async function listProfiles(paths, environment) {
 function installCommand(profile) {
   return `dsh plugin --profile ${profile} add ${DSH_HOOKS_PACKAGE}@${DSH_PINNED_VERSION} ${DSH_HOOK_PROTOCOL_PACKAGE}@${DSH_PINNED_VERSION}`;
 }
-async function profileIsWired(profile, paths) {
+async function profileIsWired(profile, paths3) {
   if (profile.missingPackages.length > 0)
     return false;
   const buffer = await readIfExists(profile.patchFile);
@@ -7869,18 +7869,18 @@ async function profileIsWired(profile, paths) {
   const entries = tryParsePatchEntries(text, profile.patchFile);
   if (entries === void 0 || !hasWingmanRow(entries))
     return false;
-  return await readIfExists(paths.hooksConfigFile) !== void 0;
+  return await readIfExists(paths3.hooksConfigFile) !== void 0;
 }
 async function dshHookInstallReport(options, environment = process.env) {
-  const paths = resolveDshHookPaths(options);
-  const profiles = await listProfiles(paths, environment);
+  const paths3 = resolveDshHookPaths(options);
+  const profiles = await listProfiles(paths3, environment);
   const reports = [];
   for (const profile of profiles) {
     const missingPackages = [...profile.missingPackages];
     const blockPresent = hasLiveHooksBlock(await readIfExists(profile.patchFile));
     const report = {
       profile: profile.name,
-      wired: await profileIsWired(profile, paths),
+      wired: await profileIsWired(profile, paths3),
       blockPresent,
       missingPackages
     };
@@ -7890,16 +7890,16 @@ async function dshHookInstallReport(options, environment = process.env) {
   }
   return { profiles: reports };
 }
-function prepareInstalledProfile(profile, paths, before, previous) {
+function prepareInstalledProfile(profile, paths3, before, previous) {
   const currentText = before === void 0 ? void 0 : decodeUtf8Strict(before, profile.patchFile);
   const surgicalText = currentText === void 0 ? void 0 : stripLiveHooksBlocks(currentText, profile.patchFile);
   const entriesBefore = surgicalText === void 0 ? [] : parsePatchEntries(surgicalText, profile.patchFile);
   if (hasWingmanRow(entriesBefore)) {
     throw new Error(`\u62D2\u5199:${profile.patchFile} \u5DF2\u6709\u672A\u5E26 wingman \u6807\u8BB0\u7684 ${DSH_HOOK_ROW_ID} \u6761\u76EE(\u7591\u624B\u5DE5\u6284\u5165),\u8BF7\u5148\u624B\u5DE5\u79FB\u9664`);
   }
-  const composed = composeInstalledText(surgicalText, entriesBefore.length, buildPatchBlock(paths.hooksConfigFile));
+  const composed = composeInstalledText(surgicalText, entriesBefore.length, buildPatchBlock(paths3.hooksConfigFile));
   const composedEntries = parsePatchEntries(composed, profile.patchFile);
-  const expected = [...entriesBefore, expectedEntry(paths.hooksConfigFile)];
+  const expected = [...entriesBefore, expectedEntry(paths3.hooksConfigFile)];
   if (JSON.stringify(composedEntries) !== JSON.stringify(expected)) {
     throw new Error(`\u62D2\u5199:${profile.patchFile} \u8FFD\u52A0\u540E\u5F62\u72B6\u6821\u9A8C\u5931\u8D25(\u539F\u6587\u4EF6\u5F62\u6001\u65E0\u6CD5\u5B89\u5168\u8FFD\u52A0),\u4E0D\u731C`);
   }
@@ -7951,13 +7951,13 @@ function restoredFromSnapshot(after, state) {
     return false;
   return after.equals(Buffer2.from(state.original.bytesBase64, "base64"));
 }
-async function applyMutations(paths, mutations) {
+async function applyMutations(paths3, mutations) {
   if (mutations.length === 0)
     return;
-  const backupDir = backupDirectory(paths);
+  const backupDir = backupDirectory(paths3);
   for (const mutation of mutations) {
     if (mutation.before !== void 0) {
-      await backupPatchFile(paths, backupDir, mutation.file, mutation.before);
+      await backupPatchFile(paths3, backupDir, mutation.file, mutation.before);
     }
   }
   for (const mutation of mutations) {
@@ -7970,22 +7970,22 @@ async function applyMutations(paths, mutations) {
   }
 }
 async function retireLegacyDshHomeHooks(options) {
-  const paths = resolveDshHookPaths(options);
+  const paths3 = resolveDshHookPaths(options);
   try {
-    const before = await readIfExists(paths.patchFile);
+    const before = await readIfExists(paths3.patchFile);
     if (!hasLiveHooksBlock(before))
       return { removed: false, restored: "none" };
-    const state = await readState(paths);
+    const state = await readState(paths3);
     const candidate = state?.version === 1 ? { patchFile: state.patchFile, original: state.original } : state?.legacyHome;
-    const legacyState = candidate?.patchFile === paths.patchFile ? candidate : void 0;
-    const mutation = prepareRemoval(paths.patchFile, before, legacyState);
+    const legacyState = candidate?.patchFile === paths3.patchFile ? candidate : void 0;
+    const mutation = prepareRemoval(paths3.patchFile, before, legacyState);
     if (mutation === void 0)
       return { removed: false, restored: "none" };
-    await applyMutations(paths, [mutation]);
+    await applyMutations(paths3, [mutation]);
     return {
       removed: true,
       restored: restoredFromSnapshot(mutation.after, legacyState) ? "byte-identical" : "surgical",
-      path: paths.patchFile
+      path: paths3.patchFile
     };
   } catch {
     return {
@@ -7997,9 +7997,9 @@ async function installDshHooks(port, options, environment = process.env) {
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
     throw new Error(`\u975E\u6CD5\u7AEF\u53E3:${String(port)}`);
   }
-  const paths = resolveDshHookPaths(options);
-  const profiles = await listProfiles(paths, environment);
-  const previousState = await readState(paths);
+  const paths3 = resolveDshHookPaths(options);
+  const profiles = await listProfiles(paths3, environment);
+  const previousState = await readState(paths3);
   const previousProfiles = previousState?.version === 2 ? previousState.profiles : {};
   const nextProfiles = { ...previousProfiles };
   const mutations = [];
@@ -8007,7 +8007,7 @@ async function installDshHooks(port, options, environment = process.env) {
   for (const profile of profiles) {
     const before = await readIfExists(profile.patchFile);
     if (profile.missingPackages.length === 0) {
-      const prepared = prepareInstalledProfile(profile, paths, before, previousProfiles[profile.name]);
+      const prepared = prepareInstalledProfile(profile, paths3, before, previousProfiles[profile.name]);
       nextProfiles[profile.name] = prepared.state;
       if (prepared.mutation !== void 0)
         mutations.push(prepared.mutation);
@@ -8021,19 +8021,19 @@ async function installDshHooks(port, options, environment = process.env) {
     }
   }
   let legacyHome = previousState?.version === 2 ? previousState.legacyHome : previousState?.version === 1 ? { patchFile: previousState.patchFile, original: previousState.original } : void 0;
-  const legacyBefore = await readIfExists(paths.patchFile);
+  const legacyBefore = await readIfExists(paths3.patchFile);
   let migratedThisRun = false;
   if (hasLiveHooksBlock(legacyBefore)) {
-    const legacyText = decodeUtf8Strict(legacyBefore, paths.patchFile);
-    parsePatchEntries(legacyText, paths.patchFile);
-    const surgical = stripLiveHooksBlocks(legacyText, paths.patchFile);
-    const surgicalEntries = parsePatchEntries(surgical, paths.patchFile);
+    const legacyText = decodeUtf8Strict(legacyBefore, paths3.patchFile);
+    parsePatchEntries(legacyText, paths3.patchFile);
+    const surgical = stripLiveHooksBlocks(legacyText, paths3.patchFile);
+    const surgicalEntries = parsePatchEntries(surgical, paths3.patchFile);
     legacyHome ??= {
-      patchFile: paths.patchFile,
+      patchFile: paths3.patchFile,
       original: { existed: true }
     };
-    const after = resolveRestoredBytes(surgical, surgicalEntries, legacyHome, paths.patchFile);
-    mutations.push({ file: paths.patchFile, before: legacyBefore, after });
+    const after = resolveRestoredBytes(surgical, surgicalEntries, legacyHome, paths3.patchFile);
+    mutations.push({ file: paths3.patchFile, before: legacyBefore, after });
     migratedThisRun = true;
   }
   const nextState = {
@@ -8046,38 +8046,38 @@ async function installDshHooks(port, options, environment = process.env) {
   const hasState = hasManagedProfiles || legacyHome !== void 0;
   const url = `http://127.0.0.1:${port}/hook?harness=dsh`;
   if (hasManagedProfiles) {
-    await writeOwnedFiles(paths, url);
+    await writeOwnedFiles(paths3, url);
     if (hasState)
-      await writeState(paths, nextState);
+      await writeState(paths3, nextState);
     else
-      await rm(paths.stateFile, { force: true });
-    await applyMutations(paths, mutations);
+      await rm(paths3.stateFile, { force: true });
+    await applyMutations(paths3, mutations);
   } else {
-    await applyMutations(paths, mutations);
-    await rm(paths.hooksConfigFile, { force: true });
-    await rm(paths.forwarderFile, { force: true });
+    await applyMutations(paths3, mutations);
+    await rm(paths3.hooksConfigFile, { force: true });
+    await rm(paths3.forwarderFile, { force: true });
     if (hasState)
-      await writeState(paths, nextState);
+      await writeState(paths3, nextState);
     else
-      await rm(paths.stateFile, { force: true });
+      await rm(paths3.stateFile, { force: true });
   }
   return { migratedThisRun, removedProfiles };
 }
 async function uninstallDshHooks(options, environment = process.env) {
-  const paths = resolveDshHookPaths(options);
-  const state = await readState(paths);
+  const paths3 = resolveDshHookPaths(options);
+  const state = await readState(paths3);
   const stateProfiles = state?.version === 2 ? state.profiles : {};
   const selected = environment.WINGMAN_DSH_PROFILE;
   const inspectionEnvironment = { ...environment };
   delete inspectionEnvironment.WINGMAN_DSH_PROFILE;
-  const inspected = await listProfiles(paths, inspectionEnvironment);
+  const inspected = await listProfiles(paths3, inspectionEnvironment);
   if (selected !== void 0 && selected !== "" && !inspected.some((profile) => profile.name === selected) && stateProfiles[selected] === void 0) {
     throw new Error(`dsh profile \u4E0D\u5B58\u5728\u6216\u7F3A package.json:${selected}`);
   }
   const targetNames = selected === void 0 || selected === "" ? [.../* @__PURE__ */ new Set([...inspected.map((profile) => profile.name), ...Object.keys(stateProfiles)])] : [selected];
   const remainingProfiles = { ...stateProfiles };
   for (const profile of inspected) {
-    if (!targetNames.includes(profile.name) && await profileIsWired(profile, paths)) {
+    if (!targetNames.includes(profile.name) && await profileIsWired(profile, paths3)) {
       remainingProfiles[profile.name] ??= {
         patchFile: profile.patchFile,
         original: { existed: true }
@@ -8088,10 +8088,10 @@ async function uninstallDshHooks(options, environment = process.env) {
   const results = [];
   for (const name of targetNames) {
     const profileState = stateProfiles[name];
-    const file = profileState?.patchFile ?? join(paths.profilesDir, name, "cordis.patch.yml");
+    const file = profileState?.patchFile ?? join(paths3.profilesDir, name, "cordis.patch.yml");
     const before = await readIfExists(file);
     const inspectedProfile = inspected.find((profile) => profile.name === name);
-    const wired = inspectedProfile === void 0 ? false : await profileIsWired(inspectedProfile, paths);
+    const wired = inspectedProfile === void 0 ? false : await profileIsWired(inspectedProfile, paths3);
     const removal = prepareRemoval(file, before, profileState);
     if (removal !== void 0) {
       mutations.push(removal);
@@ -8105,31 +8105,31 @@ async function uninstallDshHooks(options, environment = process.env) {
     delete remainingProfiles[name];
   }
   const legacyState = state?.version === 1 ? { patchFile: state.patchFile, original: state.original } : state?.legacyHome;
-  const legacyFile = legacyState?.patchFile ?? paths.patchFile;
+  const legacyFile = legacyState?.patchFile ?? paths3.patchFile;
   const legacyRemoval = prepareRemoval(legacyFile, await readIfExists(legacyFile), legacyState);
   if (legacyRemoval !== void 0)
     mutations.push(legacyRemoval);
-  await applyMutations(paths, mutations);
+  await applyMutations(paths3, mutations);
   if (Object.keys(remainingProfiles).length > 0) {
-    await writeState(paths, {
+    await writeState(paths3, {
       version: 2,
       port: state?.port ?? 7333,
       profiles: remainingProfiles
     });
   } else {
-    await rm(paths.hooksConfigFile, { force: true });
-    await rm(paths.forwarderFile, { force: true });
-    await rm(paths.stateFile, { force: true });
+    await rm(paths3.hooksConfigFile, { force: true });
+    await rm(paths3.forwarderFile, { force: true });
+    await rm(paths3.stateFile, { force: true });
   }
   return { profiles: results };
 }
 async function detectDshLiveWiring(options, environment = process.env) {
-  const paths = resolveDshHookPaths(options);
+  const paths3 = resolveDshHookPaths(options);
   const inspectionEnvironment = { ...environment };
   delete inspectionEnvironment.WINGMAN_DSH_PROFILE;
-  const profiles = await listProfiles(paths, inspectionEnvironment);
+  const profiles = await listProfiles(paths3, inspectionEnvironment);
   for (const profile of profiles) {
-    if (await profileIsWired(profile, paths))
+    if (await profileIsWired(profile, paths3))
       return true;
   }
   return false;
@@ -8193,17 +8193,19 @@ var init_feedback_url = __esm({
 
 // packages/core/dist/plan-protocol.js
 import { createHash as createHash2 } from "node:crypto";
-function planProtocolBlockStart(version = PLAN_PROTOCOL_VERSION) {
-  return `<!-- >>> wingman plan protocol v${version} >>> -->`;
+function planProtocolBlockStart(version = PLAN_PROTOCOL_VERSION, scope = "project") {
+  return `<!-- >>> wingman plan protocol ${scope === "user" ? "user " : ""}v${version} >>> -->`;
 }
-function buildPlanProtocolBlock(version = PLAN_PROTOCOL_VERSION, text) {
-  let body = normalizeMarkdownLineEndings(text ?? KNOWN_PROTOCOL_TEXT.get(version) ?? "");
+function buildPlanProtocolBlock(version = PLAN_PROTOCOL_VERSION, text, scope = "project") {
+  const known = scope === "user" ? KNOWN_USER_PROTOCOL_TEXT : KNOWN_PROTOCOL_TEXT;
+  let body = normalizeMarkdownLineEndings(text ?? known.get(version) ?? "");
   if (body === "")
     throw new Error(`\u672A\u77E5 Plan Protocol \u7248\u672C v${version}\uFF0C\u4E14\u672A\u63D0\u4F9B\u6B63\u6587`);
   if (!body.endsWith("\n"))
     body += "\n";
-  return `${planProtocolBlockStart(version)}
-${body}${PLAN_PROTOCOL_BLOCK_END}
+  const end = scope === "user" ? PLAN_PROTOCOL_USER_BLOCK_END : PLAN_PROTOCOL_BLOCK_END;
+  return `${planProtocolBlockStart(version, scope)}
+${body}${end}
 `;
 }
 function decodeUtf8Strict2(bytes, sourcePath = "<memory>") {
@@ -8224,9 +8226,17 @@ function preferredMarkdownLineEnding(text) {
   const hasBareLf = text.replaceAll("\r\n", "").includes("\n");
   return hasCrlf && !hasBareLf ? "\r\n" : "\n";
 }
-function splitPlanProtocolBlock(text, sourcePath = "<memory>") {
-  const starts = [...text.matchAll(BLOCK_START)];
-  const ends = allIndexesOf(text, PLAN_PROTOCOL_BLOCK_END);
+function splitPlanProtocolBlock(text, sourcePath = "<memory>", scope = "project") {
+  const startPattern = scope === "user" ? USER_BLOCK_START : BLOCK_START;
+  const endMarker = scope === "user" ? PLAN_PROTOCOL_USER_BLOCK_END : PLAN_PROTOCOL_BLOCK_END;
+  const starts = [...text.matchAll(startPattern)];
+  const ends = allIndexesOf(text, endMarker);
+  if (scope === "user") {
+    const unrecognized = text.replace(startPattern, "").replaceAll(endMarker, "");
+    if (/<!--\s*(?:>>>|<<<)\s*wingman plan protocol user\b/u.test(unrecognized)) {
+      throw new Error(`wingman plan protocol user \u672A\u77E5\u6807\u8BB0\u683C\u5F0F(${sourcePath})`);
+    }
+  }
   if (starts.length === 0 && ends.length === 0) {
     return { before: text, after: "", remainder: text };
   }
@@ -8238,7 +8248,7 @@ function splitPlanProtocolBlock(text, sourcePath = "<memory>") {
   if (start === void 0 || endMark === void 0 || endMark < start.index) {
     throw new Error(`wingman plan protocol \u6807\u8BB0\u5757\u6B8B\u7F3A(${sourcePath})`);
   }
-  let end = endMark + PLAN_PROTOCOL_BLOCK_END.length;
+  let end = endMark + endMarker.length;
   if (text.startsWith("\r\n", end))
     end += 2;
   else if (text[end] === "\n")
@@ -8253,15 +8263,17 @@ function splitPlanProtocolBlock(text, sourcePath = "<memory>") {
     version: Number(start[1])
   };
 }
-function inspectPlanProtocolBlock(block) {
+function inspectPlanProtocolBlock(block, scope = "project") {
   const normalized = normalizeMarkdownLineEndings(block);
-  const split = splitPlanProtocolBlock(normalized);
+  const split = splitPlanProtocolBlock(normalized, "<memory>", scope);
   const version = split.version;
-  const knownText = version === void 0 ? void 0 : KNOWN_PROTOCOL_TEXT.get(version);
-  const knownBlock = version === void 0 || knownText === void 0 ? void 0 : buildPlanProtocolBlock(version, knownText);
+  const currentVersion = scope === "user" ? PLAN_PROTOCOL_USER_VERSION : PLAN_PROTOCOL_VERSION;
+  const knownTexts = scope === "user" ? KNOWN_USER_PROTOCOL_TEXT : KNOWN_PROTOCOL_TEXT;
+  const knownText = version === void 0 ? void 0 : knownTexts.get(version);
+  const knownBlock = version === void 0 || knownText === void 0 ? void 0 : buildPlanProtocolBlock(version, knownText, scope);
   const known = split.before === "" && split.after === "" && normalized === knownBlock;
   return {
-    kind: known && version === PLAN_PROTOCOL_VERSION ? "current" : known ? "legacy" : "modified",
+    kind: known && version === currentVersion ? "current" : known ? "outdated" : "modified",
     ...version !== void 0 ? { version } : {},
     sha256: sha256Hex(normalized)
   };
@@ -8272,7 +8284,7 @@ function inspectPlanProtocolFile(bytes, sourcePath = "<memory>") {
   for (const [version, text] of KNOWN_PROTOCOL_TEXT) {
     if (sha256 === sha256Hex(text)) {
       return {
-        kind: version === PLAN_PROTOCOL_VERSION ? "current" : "legacy",
+        kind: version === PLAN_PROTOCOL_VERSION ? "current" : "outdated",
         version,
         sha256
       };
@@ -8287,12 +8299,37 @@ function allIndexesOf(text, needle) {
   }
   return indexes;
 }
-var PLAN_PROTOCOL_VERSION, PLAN_PROTOCOL_TEXT, PLAN_PROTOCOL_BLOCK_END, LEGACY_PLAN_PROTOCOL_TEXT, KNOWN_PROTOCOL_TEXT, BLOCK_START;
+function mergePlanProtocolBlock(text, block, sourcePath = "<memory>", scope = "project") {
+  const split = splitPlanProtocolBlock(text, sourcePath, scope);
+  const lineEnding = preferredMarkdownLineEnding(text);
+  const normalizedBlock = normalizeMarkdownLineEndings(block).replaceAll("\n", lineEnding);
+  if (split.block !== void 0)
+    return split.before + normalizedBlock + split.after;
+  if (text === "")
+    return normalizedBlock;
+  let before = text;
+  if (!before.endsWith("\n"))
+    before += lineEnding;
+  if (!before.endsWith(`${lineEnding}${lineEnding}`))
+    before += lineEnding;
+  return before + normalizedBlock;
+}
+var PLAN_PROTOCOL_VERSION, PLAN_PROTOCOL_USER_VERSION, PLAN_PROTOCOL_TEXT, PLAN_PROTOCOL_TEXT_USER, PLAN_PROTOCOL_TEXT_V1, PLAN_PROTOCOL_TEXT_USER_V1, PLAN_PROTOCOL_USER_BLOCK_END, PLAN_PROTOCOL_BLOCK_END, LEGACY_PLAN_PROTOCOL_TEXT, KNOWN_PROTOCOL_TEXT, KNOWN_USER_PROTOCOL_TEXT, BLOCK_START, USER_BLOCK_START;
 var init_plan_protocol = __esm({
   "packages/core/dist/plan-protocol.js"() {
     "use strict";
-    PLAN_PROTOCOL_VERSION = 1;
-    PLAN_PROTOCOL_TEXT = `Wingman plan protocol v1 \u2014 a behavioral convention, not a gate. Wingman only reads; it never replies to you.
+    PLAN_PROTOCOL_VERSION = 2;
+    PLAN_PROTOCOL_USER_VERSION = 2;
+    PLAN_PROTOCOL_TEXT = `Wingman plan protocol v2 \u2014 a behavioral convention, not a gate. Wingman only reads; it never replies to you.
+- The project root is the directory that contains this instruction file (for Claude Code: the parent of \`.claude/\`).
+- Before starting work, read \`<project root>/.wingman/plan.md\`. If it does not exist, create it: a \`# Title\` line, immediately followed by \`\u76EE\u6807: <one sentence, what done looks like>\` (or \`Goal:\`), then a nested checkbox tree of steps; add an indented \`Verify:\` line to the steps whose completion a person would want to check; not every step needs one.
+- As soon as the scope is clear (after any clarifying questions), create the plan file before doing the first step. Mark a step \`[/]\` right before you start it and \`[x]\` right after it is done; do not write the whole plan as finished afterwards. Add sub-steps under your current step as you learn more. Mark abandoned steps \`[-]\` and steps that need the user's decision \`[?]\`.
+- Re-read the file before every write; change only your own lines; never reorder or rewrite other entries. Use your file-editing tool, not shell redirection.
+- Keep your in-session todo list as sub-steps of the \`[/]\` step; do not copy the whole file into it.
+- Never put secrets, credentials, or personal data in the plan.
+`;
+    PLAN_PROTOCOL_TEXT_USER = PLAN_PROTOCOL_TEXT.replace(/^- The project root .*$/mu, "- The project root is the nearest git root containing the current working directory, or the current working directory when there is no git root. If the current working directory is the user\u2019s home directory, you MUST NOT create a plan file. Only multi-step tasks use the plan workflow below; single-turn questions do not create or update a plan file.");
+    PLAN_PROTOCOL_TEXT_V1 = `Wingman plan protocol v1 \u2014 a behavioral convention, not a gate. Wingman only reads; it never replies to you.
 - The project root is the directory that contains this instruction file (for Claude Code: the parent of \`.claude/\`).
 - Before starting work, read \`<project root>/.wingman/plan.md\`. If it does not exist, create it: a \`# Title\` line, then a nested checkbox tree of steps, each step with an indented \`Verify:\` line describing how it will be checked.
 - Mark the step you are working on \`[/]\` and add sub-steps under it as you learn more. Mark finished steps \`[x]\`, abandoned steps \`[-]\`, and steps that need the user's decision \`[?]\`.
@@ -8300,13 +8337,169 @@ var init_plan_protocol = __esm({
 - Keep your in-session todo list as sub-steps of the \`[/]\` step; do not copy the whole file into it.
 - Never put secrets, credentials, or personal data in the plan.
 `;
+    PLAN_PROTOCOL_TEXT_USER_V1 = PLAN_PROTOCOL_TEXT_V1.replace(/^- The project root .*$/mu, "- The project root is the nearest git root containing the current working directory, or the current working directory when there is no git root. If the current working directory is the user\u2019s home directory, you MUST NOT create a plan file. Only multi-step tasks use the plan workflow below; single-turn questions do not create or update a plan file.");
+    PLAN_PROTOCOL_USER_BLOCK_END = "<!-- <<< wingman plan protocol user <<< -->";
     PLAN_PROTOCOL_BLOCK_END = "<!-- <<< wingman plan protocol <<< -->";
     LEGACY_PLAN_PROTOCOL_TEXT = "Wingman plan protocol v0 \u2014 legacy fixture text.\n";
     KNOWN_PROTOCOL_TEXT = /* @__PURE__ */ new Map([
       [0, LEGACY_PLAN_PROTOCOL_TEXT],
+      [1, PLAN_PROTOCOL_TEXT_V1],
       [PLAN_PROTOCOL_VERSION, PLAN_PROTOCOL_TEXT]
     ]);
+    KNOWN_USER_PROTOCOL_TEXT = /* @__PURE__ */ new Map([
+      [1, PLAN_PROTOCOL_TEXT_USER_V1],
+      [PLAN_PROTOCOL_USER_VERSION, PLAN_PROTOCOL_TEXT_USER]
+    ]);
     BLOCK_START = /<!-- >>> wingman plan protocol v(\d+) >>> -->/gu;
+    USER_BLOCK_START = /<!-- >>> wingman plan protocol user v(\d+) >>> -->/gu;
+  }
+});
+
+// packages/core/dist/plan-protocol-user.js
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename as basename2, dirname as dirname2, join as join2 } from "node:path";
+function readTarget(targetPath2) {
+  if (!existsSync(targetPath2))
+    return void 0;
+  const bytes = readFileSync(targetPath2);
+  decodeUtf8Strict2(bytes, targetPath2);
+  const text = bytes.toString("utf8");
+  const split = splitPlanProtocolBlock(text, targetPath2, "user");
+  const identity = split.block === void 0 ? void 0 : inspectPlanProtocolBlock(split.block, "user");
+  return { bytes, text, split, identity };
+}
+function statusPlanProtocolUser(targetPath2) {
+  try {
+    const identity = readTarget(targetPath2)?.identity;
+    return {
+      targetPath: targetPath2,
+      state: identity === void 0 ? "missing" : identity.kind === "current" ? "installed" : identity.kind,
+      ...identity?.version !== void 0 ? { version: identity.version } : {},
+      ...identity?.kind === "modified" ? { reason: "\u7528\u6237\u7EA7\u53D7\u7BA1\u5757\u5DF2\u88AB\u4FEE\u6539" } : {}
+    };
+  } catch (error) {
+    return { targetPath: targetPath2, state: "modified", reason: error.message };
+  }
+}
+function installPlanProtocolUser(paths3) {
+  const existing = readTarget(paths3.targetPath);
+  assertKnown(existing, paths3.targetPath);
+  const before = existing?.text ?? "";
+  if (existing?.identity?.kind === "current") {
+    return result(paths3.targetPath, "install", "installed", before, before, true, false);
+  }
+  const statePath2 = snapshotPath(paths3);
+  const prior = readSnapshot(statePath2, paths3.targetPath);
+  const outdated = existing?.identity?.kind === "outdated";
+  const block = buildPlanProtocolBlock(PLAN_PROTOCOL_USER_VERSION, void 0, "user");
+  const after = mergePlanProtocolBlock(before, block, paths3.targetPath, "user");
+  const backupDir = nextBackupDir(paths3.homeDir);
+  if (!paths3.dryRun) {
+    backupTarget(backupDir, paths3.targetPath, existing?.bytes);
+    const snapshot = {
+      version: 1,
+      targetPath: paths3.targetPath,
+      installedRemainderSha256: sha256Hex(splitPlanProtocolBlock(after, paths3.targetPath, "user").remainder),
+      original: existing === void 0 || outdated && existing.split.remainder === "" ? { existed: false } : {
+        existed: true,
+        base64: (outdated ? Buffer.from(existing.split.remainder) : existing.bytes).toString("base64")
+      }
+    };
+    if (!outdated || prior === void 0) {
+      mkdirSync(dirname2(statePath2), { recursive: true });
+      writeFileSync(statePath2, `${JSON.stringify(snapshot, null, 2)}
+`);
+    }
+    mkdirSync(dirname2(paths3.targetPath), { recursive: true });
+    writeFileSync(paths3.targetPath, after);
+  }
+  return {
+    ...result(paths3.targetPath, "install", outdated ? "outdated" : "missing", before, after, true, true),
+    state: "installed",
+    version: PLAN_PROTOCOL_USER_VERSION,
+    backupDir
+  };
+}
+function uninstallPlanProtocolUser(paths3) {
+  const existing = readTarget(paths3.targetPath);
+  assertKnown(existing, paths3.targetPath);
+  const before = existing?.text ?? "";
+  if (existing?.identity === void 0) {
+    return result(paths3.targetPath, "uninstall", "missing", before, before, existing !== void 0, false);
+  }
+  const statePath2 = snapshotPath(paths3);
+  const snapshot = readSnapshot(statePath2, paths3.targetPath);
+  const canRestore = snapshot !== void 0 && sha256Hex(existing.split.remainder) === snapshot.installedRemainderSha256;
+  const restored = canRestore && snapshot.original.existed ? Buffer.from(snapshot.original.base64 ?? "", "base64") : void 0;
+  const afterExists = canRestore ? snapshot.original.existed : existing.split.remainder !== "";
+  const after = afterExists ? restored?.toString("utf8") ?? existing.split.remainder : "";
+  const backupDir = nextBackupDir(paths3.homeDir);
+  if (!paths3.dryRun) {
+    backupTarget(backupDir, paths3.targetPath, existing.bytes);
+    if (afterExists)
+      writeFileSync(paths3.targetPath, restored ?? after);
+    else
+      rmSync(paths3.targetPath);
+    rmSync(statePath2, { force: true });
+  }
+  return {
+    ...result(paths3.targetPath, "uninstall", existing.identity.kind === "outdated" ? "outdated" : "installed", before, after, afterExists, true),
+    state: "missing",
+    backupDir,
+    restoredOriginal: canRestore
+  };
+}
+function assertKnown(existing, targetPath2) {
+  if (existing?.identity?.kind === "modified") {
+    throw new Error(`${targetPath2}: \u7528\u6237\u7EA7\u53D7\u7BA1\u5757\u5DF2\u88AB\u4FEE\u6539\u6216\u7248\u672C\u672A\u77E5\uFF0C\u62D2\u5199\u5E76\u4FDD\u7559\u7528\u6237\u5185\u5BB9`);
+  }
+}
+function result(targetPath2, operation, previousState, before, after, afterExists, changed) {
+  return {
+    targetPath: targetPath2,
+    operation,
+    previousState,
+    state: previousState,
+    before,
+    after,
+    afterExists,
+    changed,
+    effectiveAt: "next_session",
+    totalBytes: Buffer.byteLength(after)
+  };
+}
+function snapshotPath(paths3) {
+  return join2(paths3.homeDir, ".wingman", "state", `plan-protocol-user-${sha256Hex(paths3.targetPath)}.json`);
+}
+function readSnapshot(statePath2, targetPath2) {
+  if (!existsSync(statePath2))
+    return void 0;
+  try {
+    const value = JSON.parse(readFileSync(statePath2, "utf8"));
+    if (value.version === 1 && value.targetPath === targetPath2 && typeof value.installedRemainderSha256 === "string" && /^[a-f0-9]{64}$/u.test(value.installedRemainderSha256) && typeof value.original?.existed === "boolean" && (value.original.existed ? typeof value.original.base64 === "string" && Buffer.from(value.original.base64, "base64").toString("base64") === value.original.base64 : value.original.base64 === void 0)) {
+      return value;
+    }
+  } catch {
+  }
+  throw new Error(`\u7528\u6237\u7EA7\u534F\u8BAE\u5FEB\u7167\u683C\u5F0F\u672A\u77E5(${statePath2})\uFF0C\u62D2\u5199\u5E76\u4FDD\u7559\u7528\u6237\u5185\u5BB9`);
+}
+function nextBackupDir(homeDir) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
+  const root = join2(homeDir, ".wingman", "backups");
+  let dir = join2(root, stamp);
+  for (let n = 2; existsSync(dir); n += 1)
+    dir = join2(root, `${stamp}-${n}`);
+  return dir;
+}
+function backupTarget(backupDir, targetPath2, bytes) {
+  mkdirSync(backupDir, { recursive: true });
+  if (bytes !== void 0)
+    writeFileSync(join2(backupDir, basename2(targetPath2)), bytes);
+}
+var init_plan_protocol_user = __esm({
+  "packages/core/dist/plan-protocol-user.js"() {
+    "use strict";
+    init_plan_protocol();
   }
 });
 
@@ -8492,6 +8685,7 @@ var init_dist = __esm({
     "use strict";
     init_feedback_url();
     init_plan_protocol();
+    init_plan_protocol_user();
     init_refscan();
     SLOT_IDS = ["base", "rules", "skills", "tools", "gates", "history"];
     HARNESS_IDS = ["cc", "codex", "dsh"];
@@ -8521,7 +8715,7 @@ var init_dist = __esm({
 import { Buffer as Buffer3 } from "node:buffer";
 import { randomBytes } from "node:crypto";
 import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, relative as relative2 } from "node:path";
 function buildToggleBlock(instanceId, flags) {
   const lines2 = [`${TOGGLE_BEGIN_PREFIX}${instanceId}${TOGGLE_BEGIN_SUFFIX}`];
   if (flags.fileCreated)
@@ -8782,15 +8976,15 @@ async function planDshToggle(action, dump, options) {
   if (row.id === DSH_HOOK_ROW_ID && row.name === DSH_HOOKS_PACKAGE) {
     throw new Error(`\u300C${row.name}\u300D(${row.id})\u7531 Wingman \u5B9E\u51B5\u63A5\u7EBF(live hooks \u5757)\u5F15\u5165,\u8BF7\u7528 \`wingman hook uninstall dsh\` \u7BA1\u7406,\u4E0D\u8D70\u5F00\u5173`);
   }
-  const paths = resolveDshHookPaths(options);
-  const buffer = await readIfExists(paths.patchFile);
-  const text = buffer === void 0 ? void 0 : decodeUtf8Strict(buffer, paths.patchFile);
-  const blocks = text === void 0 ? [] : findToggleBlocks(text, paths.patchFile);
+  const paths3 = resolveDshHookPaths(options);
+  const buffer = await readIfExists(paths3.patchFile);
+  const text = buffer === void 0 ? void 0 : decodeUtf8Strict(buffer, paths3.patchFile);
+  const blocks = text === void 0 ? [] : findToggleBlocks(text, paths3.patchFile);
   const myBlock = blocks.find((b) => b.instanceId === row.id);
-  const entriesAll = text === void 0 ? [] : parsePatchEntries(text, paths.patchFile);
+  const entriesAll = text === void 0 ? [] : parsePatchEntries(text, paths3.patchFile);
   const outsideToggle = text === void 0 ? "" : stripAllToggleBlocks(text, blocks);
-  const entriesOutsideToggle = text === void 0 ? [] : parsePatchEntries(outsideToggle, paths.patchFile);
-  const entriesUser = text === void 0 ? [] : parsePatchEntries(stripHooksBlocks(outsideToggle), paths.patchFile);
+  const entriesOutsideToggle = text === void 0 ? [] : parsePatchEntries(outsideToggle, paths3.patchFile);
+  const entriesUser = text === void 0 ? [] : parsePatchEntries(stripHooksBlocks(outsideToggle), paths3.patchFile);
   const refInUser = referencesInstanceId(entriesUser, row.id);
   const refInHooks = !refInUser && referencesInstanceId(entriesOutsideToggle, row.id);
   if (refInHooks) {
@@ -8802,36 +8996,36 @@ async function planDshToggle(action, dump, options) {
       throw new Error(`\u300C${row.name}\u300D(${row.id})\u5DF2\u7531 Wingman \u5173\u95ED(dsh \u4E0B\u6B21\u542F\u52A8\u751F\u6548);\u5982\u9700\u6062\u590D\u8BF7 toggle on`);
     }
     if (refInUser) {
-      throw new Error(`${paths.patchFile} \u5DF2\u6709\u7528\u6237\u81EA\u5DF1\u7684 ${row.id} \u6761\u76EE,\u4E0D\u731C\u5408\u5E76:\u8BF7\u624B\u5DE5\u5904\u7406\u8BE5\u6761\u76EE\u540E\u518D\u8BD5`);
+      throw new Error(`${paths3.patchFile} \u5DF2\u6709\u7528\u6237\u81EA\u5DF1\u7684 ${row.id} \u6761\u76EE,\u4E0D\u731C\u5408\u5E76:\u8BF7\u624B\u5DE5\u5904\u7406\u8BE5\u6761\u76EE\u540E\u518D\u8BD5`);
     }
     if (row.disabled === true) {
       throw new Error(`\u300C${row.name}\u300D(${row.id})\u5DF2\u5728 ${item.source} \u5C42\u88AB\u7981\u7528(\u539F\u751F\u7981\u7528\u975E Wingman \u6240\u8F96),\u65E0\u9700\u518D\u5173`);
     }
     const composed = composeToggleOff(text, row.id, entriesAll.length);
     const expected = JSON.stringify([...entriesAll, { id: row.id, disabled: true }]);
-    if (JSON.stringify(parsePatchEntries(composed.after, paths.patchFile)) !== expected) {
-      throw new Error(`\u62D2\u5199:${paths.patchFile} \u8FFD\u52A0\u540E\u5F62\u72B6\u6821\u9A8C\u5931\u8D25(\u539F\u6587\u4EF6\u5F62\u6001\u65E0\u6CD5\u5B89\u5168\u8FFD\u52A0),\u4E0D\u731C`);
+    if (JSON.stringify(parsePatchEntries(composed.after, paths3.patchFile)) !== expected) {
+      throw new Error(`\u62D2\u5199:${paths3.patchFile} \u8FFD\u52A0\u540E\u5F62\u72B6\u6821\u9A8C\u5931\u8D25(\u539F\u6587\u4EF6\u5F62\u6001\u65E0\u6CD5\u5B89\u5168\u8FFD\u52A0),\u4E0D\u731C`);
     }
-    change = composed.kind === "create" || text === void 0 ? { file: paths.patchFile, kind: "create", after: composed.after } : { file: paths.patchFile, kind: "modify", before: text, after: composed.after };
+    change = composed.kind === "create" || text === void 0 ? { file: paths3.patchFile, kind: "create", after: composed.after } : { file: paths3.patchFile, kind: "modify", before: text, after: composed.after };
   } else {
     if (myBlock === void 0 || text === void 0) {
       if (refInUser) {
-        throw new Error(`${paths.patchFile} \u5DF2\u6709\u7528\u6237\u81EA\u5DF1\u7684 ${row.id} \u6761\u76EE,\u4E0D\u731C\u5408\u5E76:\u8BF7\u624B\u5DE5\u5904\u7406\u8BE5\u6761\u76EE\u540E\u518D\u8BD5`);
+        throw new Error(`${paths3.patchFile} \u5DF2\u6709\u7528\u6237\u81EA\u5DF1\u7684 ${row.id} \u6761\u76EE,\u4E0D\u731C\u5408\u5E76:\u8BF7\u624B\u5DE5\u5904\u7406\u8BE5\u6761\u76EE\u540E\u518D\u8BD5`);
       }
       if (row.disabled === true) {
         throw new Error(`\u300C${row.name}\u300D(${row.id})\u5728 ${item.source} \u5C42\u88AB\u539F\u751F\u7981\u7528,\u975E Wingman \u6240\u8F96:\u8BF7\u5230\u8BE5\u5C42(bundle/profile \u914D\u7F6E)\u4FEE\u6539`);
       }
       throw new Error(`\u300C${row.name}\u300D(${row.id})\u5DF2\u662F\u542F\u7528\u72B6\u6001,\u65E0\u9700 toggle on`);
     }
-    const composed = composeToggleOn(text, myBlock, paths.patchFile);
-    change = composed.kind === "delete" || composed.after === void 0 ? { file: paths.patchFile, kind: "delete", before: text } : { file: paths.patchFile, kind: "modify", before: text, after: composed.after };
+    const composed = composeToggleOn(text, myBlock, paths3.patchFile);
+    change = composed.kind === "delete" || composed.after === void 0 ? { file: paths3.patchFile, kind: "delete", before: text } : { file: paths3.patchFile, kind: "modify", before: text, after: composed.after };
   }
   return {
     harness: "dsh",
     action: toggle,
     writes: [change],
-    backupDir: join2(paths.backupsRoot, backupDirName()),
-    references: scanDshReferences(paths.patchFile, text, dump, row),
+    backupDir: join3(paths3.backupsRoot, backupDirName()),
+    references: scanDshReferences(paths3.patchFile, text, dump, row),
     // 生效时机:patch 层在 boot 时组装(composeProfile),保证下次启动生效;钉定版本
     // 还会 watchUserPatches 热重载家目录层,但该监听失败被静默吞掉(suppressShutdownError)
     // 且热拔插行为无兼容承诺 → 按宪法取保守值 next_session,如实不夸大。
@@ -8864,39 +9058,39 @@ function validatePlanShape(plan, patchFile, backupsRoot) {
 }
 async function applyDshToggle(plan, options) {
   try {
-    const paths = resolveDshHookPaths(options);
-    const { change } = validatePlanShape(plan, paths.patchFile, paths.backupsRoot);
-    const buffer = await readIfExists(paths.patchFile);
+    const paths3 = resolveDshHookPaths(options);
+    const { change } = validatePlanShape(plan, paths3.patchFile, paths3.backupsRoot);
+    const buffer = await readIfExists(paths3.patchFile);
     if (change.kind === "create") {
       if (buffer !== void 0) {
         return {
           ok: false,
-          error: `${paths.patchFile} \u5728 plan \u4E4B\u540E\u88AB\u521B\u5EFA,\u4E0E plan \u524D\u63D0\u4E0D\u7B26:\u8BF7\u91CD\u65B0 plan`
+          error: `${paths3.patchFile} \u5728 plan \u4E4B\u540E\u88AB\u521B\u5EFA,\u4E0E plan \u524D\u63D0\u4E0D\u7B26:\u8BF7\u91CD\u65B0 plan`
         };
       }
     } else {
       if (buffer === void 0) {
         return {
           ok: false,
-          error: `${paths.patchFile} \u5728 plan \u4E4B\u540E\u88AB\u5220\u9664,\u4E0E plan \u524D\u63D0\u4E0D\u7B26:\u8BF7\u91CD\u65B0 plan`
+          error: `${paths3.patchFile} \u5728 plan \u4E4B\u540E\u88AB\u5220\u9664,\u4E0E plan \u524D\u63D0\u4E0D\u7B26:\u8BF7\u91CD\u65B0 plan`
         };
       }
       if (!buffer.equals(Buffer3.from(change.before ?? "", "utf8"))) {
         return {
           ok: false,
-          error: `${paths.patchFile} \u5728 plan \u4E4B\u540E\u88AB\u6539\u52A8,\u4E0E plan \u5FEB\u7167\u4E0D\u4E00\u81F4:\u8BF7\u91CD\u65B0 plan`
+          error: `${paths3.patchFile} \u5728 plan \u4E4B\u540E\u88AB\u6539\u52A8,\u4E0E plan \u5FEB\u7167\u4E0D\u4E00\u81F4:\u8BF7\u91CD\u65B0 plan`
         };
       }
     }
     await mkdir2(plan.backupDir, { recursive: true });
     if (buffer !== void 0) {
-      await writeFile2(join2(plan.backupDir, "cordis.patch.yml"), buffer);
+      await writeFile2(join3(plan.backupDir, "cordis.patch.yml"), buffer);
     }
     if (change.kind === "delete") {
-      await rm2(paths.patchFile);
+      await rm2(paths3.patchFile);
     } else {
-      await mkdir2(dirname2(paths.patchFile), { recursive: true });
-      await writeFile2(paths.patchFile, change.after ?? "", "utf8");
+      await mkdir2(dirname3(paths3.patchFile), { recursive: true });
+      await writeFile2(paths3.patchFile, change.after ?? "", "utf8");
     }
     return { ok: true, backupDir: plan.backupDir };
   } catch (error) {
@@ -8925,55 +9119,55 @@ var init_toggle = __esm({
 
 // packages/adapter-dsh/dist/protocol.js
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename2, dirname as dirname3, join as join3, resolve } from "node:path";
+import { basename as basename3, dirname as dirname4, join as join4, resolve } from "node:path";
 function protocolStatusDsh(options) {
-  const paths = resolveOptions(options);
-  if (!existsSync(paths.targetPath))
-    return status(paths.targetPath, "not_installed", options);
+  const paths3 = resolveOptions(options);
+  if (!existsSync2(paths3.targetPath))
+    return status(paths3.targetPath, "not_installed", options);
   try {
-    const file = readAgents(paths.targetPath);
+    const file = readAgents(paths3.targetPath);
     if (file.identity === void 0)
-      return status(paths.targetPath, "not_installed", options);
+      return status(paths3.targetPath, "not_installed", options);
     const state = stateForIdentity(file.identity);
-    return status(paths.targetPath, state, options, file.identity);
+    return status(paths3.targetPath, state, options, file.identity);
   } catch (error) {
-    return status(paths.targetPath, "invalid", options, void 0, error.message);
+    return status(paths3.targetPath, "invalid", options, void 0, error.message);
   }
 }
 function installProtocolDsh(options) {
-  const paths = resolveOptions(options);
-  const existing = existsSync(paths.targetPath) ? readAgents(paths.targetPath) : void 0;
+  const paths3 = resolveOptions(options);
+  const existing = existsSync2(paths3.targetPath) ? readAgents(paths3.targetPath) : void 0;
   const previousState = stateForIdentity(existing?.identity);
   if (previousState === "installed") {
-    return overlayLoadState(result(paths.targetPath, "install", false, previousState, existing?.text ?? "", true), options);
+    return overlayLoadState(result2(paths3.targetPath, "install", false, previousState, existing?.text ?? "", true), options);
   }
   if (previousState === "modified")
-    throw modifiedError(paths.targetPath, "\u5B89\u88C5");
+    throw modifiedError(paths3.targetPath, "\u5B89\u88C5");
   const before = existing?.text ?? "";
   const lineEnding = preferredMarkdownLineEnding(before);
   const block = buildPlanProtocolBlock().replaceAll("\n", lineEnding);
   const after = existing?.split.block ? existing.split.before + block + existing.split.after : appendBlock(before, block, lineEnding);
-  const installedRemainder = splitPlanProtocolBlock(after, paths.targetPath).remainder;
-  const backupDir = nextBackupDir(paths.homeDir);
-  if (!paths.dryRun) {
-    const prior = readState2(paths.statePath, paths.targetPath);
-    backupTarget(backupDir, paths.targetPath, existing?.bytes);
-    writeState2(paths.statePath, {
+  const installedRemainder = splitPlanProtocolBlock(after, paths3.targetPath).remainder;
+  const backupDir = nextBackupDir2(paths3.homeDir);
+  if (!paths3.dryRun) {
+    const prior = readState2(paths3.statePath, paths3.targetPath);
+    backupTarget2(backupDir, paths3.targetPath, existing?.bytes);
+    writeState2(paths3.statePath, {
       version: 1,
-      projectDir: paths.projectDir,
-      targetPath: paths.targetPath,
+      projectDir: paths3.projectDir,
+      targetPath: paths3.targetPath,
       protocolVersion: PLAN_PROTOCOL_VERSION,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
       backupDir,
-      installedRemainderSha256: sha256Hex(installedRemainder),
+      installedRemainderSha256: previousState === "outdated" && prior !== void 0 ? prior.installedRemainderSha256 : sha256Hex(installedRemainder),
       original: prior?.original ?? (existing === void 0 ? { existed: false } : { existed: true, base64: existing.bytes.toString("base64") })
     });
-    writeFileSync(paths.targetPath, after);
+    writeFileSync2(paths3.targetPath, after);
   }
   return overlayLoadState({
-    ...result(paths.targetPath, "install", true, previousState, before, true),
+    ...result2(paths3.targetPath, "install", true, previousState, before, true),
     state: "installed",
     version: PLAN_PROTOCOL_VERSION,
     after,
@@ -8982,33 +9176,33 @@ function installProtocolDsh(options) {
   }, options);
 }
 function uninstallProtocolDsh(options) {
-  const paths = resolveOptions(options);
-  if (!existsSync(paths.targetPath)) {
-    return result(paths.targetPath, "uninstall", false, "not_installed", "", false);
+  const paths3 = resolveOptions(options);
+  if (!existsSync2(paths3.targetPath)) {
+    return result2(paths3.targetPath, "uninstall", false, "not_installed", "", false);
   }
-  const existing = readAgents(paths.targetPath);
+  const existing = readAgents(paths3.targetPath);
   if (existing.identity === void 0) {
-    return result(paths.targetPath, "uninstall", false, "not_installed", existing.text, true);
+    return result2(paths3.targetPath, "uninstall", false, "not_installed", existing.text, true);
   }
   const previousState = stateForIdentity(existing.identity);
   if (previousState === "modified")
-    throw modifiedError(paths.targetPath, "\u5378\u8F7D");
-  const state = readState2(paths.statePath, paths.targetPath);
+    throw modifiedError(paths3.targetPath, "\u5378\u8F7D");
+  const state = readState2(paths3.statePath, paths3.targetPath);
   const canRestore = state !== void 0 && sha256Hex(existing.split.remainder) === state.installedRemainderSha256;
   const restored = canRestore ? originalBytes(state) : void 0;
   const deleteTarget = canRestore ? state?.original.existed === false : existing.split.remainder.trim() === "";
   const after = deleteTarget ? "" : restored?.toString("utf8") ?? existing.split.remainder;
-  const backupDir = nextBackupDir(paths.homeDir);
-  if (!paths.dryRun) {
-    backupTarget(backupDir, paths.targetPath, existing.bytes);
+  const backupDir = nextBackupDir2(paths3.homeDir);
+  if (!paths3.dryRun) {
+    backupTarget2(backupDir, paths3.targetPath, existing.bytes);
     if (deleteTarget)
-      rmSync(paths.targetPath, { force: true });
+      rmSync2(paths3.targetPath, { force: true });
     else
-      writeFileSync(paths.targetPath, restored ?? existing.split.remainder);
-    rmSync(paths.statePath, { force: true });
+      writeFileSync2(paths3.targetPath, restored ?? existing.split.remainder);
+    rmSync2(paths3.statePath, { force: true });
   }
   return {
-    ...result(paths.targetPath, "uninstall", true, previousState, existing.text, !deleteTarget),
+    ...result2(paths3.targetPath, "uninstall", true, previousState, existing.text, !deleteTarget),
     state: "not_installed",
     message: canRestore ? `${SHARED_MESSAGE}\uFF1B\u5378\u8F7D\u540C\u65F6\u5F71\u54CD Codex \u4E0E dsh` : `${SHARED_MESSAGE}\uFF1B\u5378\u8F7D\u540C\u65F6\u5F71\u54CD Codex \u4E0E dsh\uFF1B\u5DF2\u4FDD\u7559\u7528\u6237\u6539\u52A8`,
     after,
@@ -9020,18 +9214,19 @@ function uninstallProtocolDsh(options) {
 function resolveOptions(options) {
   const homeDir = resolve(options?.homeDir ?? homedir2());
   const projectDir = resolve(options?.projectDir ?? process.cwd());
-  const targetPath2 = join3(projectDir, "AGENTS.md");
+  const targetPath2 = join4(projectDir, "AGENTS.md");
   return {
     homeDir,
     projectDir,
     targetPath: targetPath2,
-    statePath: join3(homeDir, ".wingman", "state", `plan-protocol-agents-${sha256Hex(projectDir)}.json`),
+    statePath: join4(homeDir, ".wingman", "state", `plan-protocol-agents-${sha256Hex(projectDir)}.json`),
     dryRun: options?.dryRun ?? false
   };
 }
 function readAgents(targetPath2) {
-  const bytes = readFileSync(targetPath2);
-  const text = decodeUtf8Strict2(bytes, targetPath2);
+  const bytes = readFileSync2(targetPath2);
+  decodeUtf8Strict2(bytes, targetPath2);
+  const text = bytes.toString("utf8");
   let split;
   try {
     split = splitPlanProtocolBlock(text, targetPath2);
@@ -9060,7 +9255,7 @@ function stateForIdentity(identity) {
     return "not_installed";
   if (identity.kind === "current")
     return "installed";
-  if (identity.kind === "legacy")
+  if (identity.kind === "outdated")
     return "outdated";
   return "modified";
 }
@@ -9078,7 +9273,7 @@ function status(targetPath2, state, options, identity, reason) {
     ...reason !== void 0 ? { reason } : {}
   };
 }
-function result(targetPath2, operation, changed, previousState, before, afterExists) {
+function result2(targetPath2, operation, changed, previousState, before, afterExists) {
   return {
     harness: "dsh",
     state: previousState,
@@ -9112,7 +9307,7 @@ function agentInstructionsDisabled(options) {
     if (options?.dumpConfigText !== void 0)
       text = options.dumpConfigText;
     else if (options?.dumpConfigPath !== void 0)
-      text = readFileSync(options.dumpConfigPath, "utf8");
+      text = readFileSync2(options.dumpConfigPath, "utf8");
     else {
       text = execFileSync("dsh", ["--profile", options?.profile ?? "web", "--dump-config"], {
         encoding: "utf8",
@@ -9129,38 +9324,41 @@ function agentInstructionsDisabled(options) {
 function modifiedError(targetPath2, operation) {
   return new Error(`${targetPath2}: \u53D7\u7BA1\u5757\u5DF2\u88AB\u4FEE\u6539\uFF0C\u62D2\u7EDD${operation}\u5E76\u4FDD\u7559\u7528\u6237\u5185\u5BB9`);
 }
-function nextBackupDir(homeDir) {
+function nextBackupDir2(homeDir) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  const root = join3(homeDir, ".wingman", "backups");
-  let dir = join3(root, stamp);
-  for (let n = 2; existsSync(dir); n += 1)
-    dir = join3(root, `${stamp}-${n}`);
+  const root = join4(homeDir, ".wingman", "backups");
+  let dir = join4(root, stamp);
+  for (let n = 2; existsSync2(dir); n += 1)
+    dir = join4(root, `${stamp}-${n}`);
   return dir;
 }
-function backupTarget(backupDir, targetPath2, bytes) {
-  mkdirSync(backupDir, { recursive: true });
+function backupTarget2(backupDir, targetPath2, bytes) {
+  mkdirSync2(backupDir, { recursive: true });
   if (bytes !== void 0)
-    writeFileSync(join3(backupDir, basename2(targetPath2)), bytes);
+    writeFileSync2(join4(backupDir, basename3(targetPath2)), bytes);
 }
 function readState2(statePath2, targetPath2) {
-  if (!existsSync(statePath2))
+  if (!existsSync2(statePath2))
     return void 0;
   try {
-    const value = JSON.parse(readFileSync(statePath2, "utf8"));
+    const value = JSON.parse(readFileSync2(statePath2, "utf8"));
     return value.version === 1 && value.targetPath === targetPath2 ? value : void 0;
   } catch {
     return void 0;
   }
 }
 function writeState2(statePath2, state) {
-  mkdirSync(dirname3(statePath2), { recursive: true });
-  writeFileSync(statePath2, `${JSON.stringify(state, null, 2)}
+  mkdirSync2(dirname4(statePath2), { recursive: true });
+  writeFileSync2(statePath2, `${JSON.stringify(state, null, 2)}
 `);
 }
 function originalBytes(state) {
   return state.original.existed ? Buffer.from(state.original.base64 ?? "", "base64") : void 0;
 }
-var SHARED_MESSAGE, DISABLED_MESSAGE;
+function protocolStatusDshUser(_options) {
+  return { unsupported: "dsh \u6CA1\u6709\u7528\u6237\u7EA7\u6307\u4EE4\u6587\u4EF6,\u8BF7\u6309\u9879\u76EE\u5B89\u88C5" };
+}
+var SHARED_MESSAGE, DISABLED_MESSAGE, installProtocolDshUser, uninstallProtocolDshUser;
 var init_protocol = __esm({
   "packages/adapter-dsh/dist/protocol.js"() {
     "use strict";
@@ -9168,6 +9366,8 @@ var init_protocol = __esm({
     init_dump_config();
     SHARED_MESSAGE = "\u6B64 AGENTS.md \u534F\u8BAE\u5757\u7531 Codex \u4E0E dsh \u5171\u7528";
     DISABLED_MESSAGE = "dsh \u6307\u4EE4\u52A0\u8F7D\u63D2\u4EF6\u5DF2\u7981\u7528\uFF0C\u89C1\u63A7\u5236\u9875\u5F00\u5173";
+    installProtocolDshUser = protocolStatusDshUser;
+    uninstallProtocolDshUser = protocolStatusDshUser;
   }
 });
 
@@ -9183,18 +9383,21 @@ __export(dist_exports, {
   hasManagedHooks: () => hasManagedHooks,
   installDshHooks: () => installDshHooks,
   installProtocolDsh: () => installProtocolDsh,
+  installProtocolDshUser: () => installProtocolDshUser,
   parseDumpConfig: () => parseDumpConfig,
   protocolStatusDsh: () => protocolStatusDsh,
+  protocolStatusDshUser: () => protocolStatusDshUser,
   resolveDshHome: () => resolveDshHome,
   resolveDshHookPaths: () => resolveDshHookPaths,
   retireLegacyDshHomeHooks: () => retireLegacyDshHomeHooks,
   uninstallDshHooks: () => uninstallDshHooks,
-  uninstallProtocolDsh: () => uninstallProtocolDsh
+  uninstallProtocolDsh: () => uninstallProtocolDsh,
+  uninstallProtocolDshUser: () => uninstallProtocolDshUser
 });
 import { execFile } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { promisify } from "node:util";
 async function execVersionViaPath() {
   const { stdout } = await execFileAsync("dsh", ["-V"], {
@@ -9267,7 +9470,7 @@ function createAdapter(options = {}) {
     // 检测与 CC/Codex 同构:探用户 dsh 家目录(homeDir/.dsh → $DSH_HOME → ~/.dsh)是否存在。
     // 版本尽力:PATH 上 `dsh -V`,3 秒超时;失败不影响 installed 判定。
     async detect(options2) {
-      if (!existsSync2(resolveDshHome(options2)))
+      if (!existsSync3(resolveDshHome(options2)))
         return { installed: false };
       const version = await loadVersion();
       return version !== void 0 ? { installed: true, version } : { installed: true };
@@ -9300,7 +9503,7 @@ function createAdapter(options = {}) {
     },
     async planAction(action, options2) {
       const text = await loadDumpText();
-      const file = dumpConfigPath ?? join4(resolveDshHookPaths(options2).dshHome, `dump-config(${profile})`);
+      const file = dumpConfigPath ?? join5(resolveDshHookPaths(options2).dshHome, `dump-config(${profile})`);
       return await planDshToggle(action, { text, file }, options2);
     },
     async applyAction(plan, options2) {
@@ -9331,7 +9534,7 @@ var init_dist2 = __esm({
 
 // packages/adapter-cc/dist/walk.js
 import { readdirSync } from "node:fs";
-import { join as join8, parse as parse2, resolve as resolve2 } from "node:path";
+import { join as join9, parse as parse2, resolve as resolve2 } from "node:path";
 function newWalkStats(entryBudget = MAX_WALK_ENTRIES) {
   return { unknownErrors: 0, truncated: false, entriesLeft: entryBudget };
 }
@@ -9358,7 +9561,7 @@ function walkFiles(dir, fileName, stats = newWalkStats()) {
         return;
       }
       stats.entriesLeft -= 1;
-      const p = join8(d, entry.name);
+      const p = join9(d, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || SKIP_DIR_NAMES.has(entry.name))
           continue;
@@ -9375,7 +9578,7 @@ function walkFiles(dir, fileName, stats = newWalkStats()) {
   return found;
 }
 function listMdFiles(dir, stats) {
-  return safeReaddir(dir, stats).map((e) => e.name).filter((n) => n.endsWith(".md")).sort().map((n) => join8(dir, n));
+  return safeReaddir(dir, stats).map((e) => e.name).filter((n) => n.endsWith(".md")).sort().map((n) => join9(dir, n));
 }
 function isBareProjectDir(projectDir, homeDir) {
   const r = resolve2(projectDir);
@@ -9393,21 +9596,21 @@ var init_walk = __esm({
 });
 
 // packages/adapter-cc/dist/detect.js
-import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function probeVersion(homeDir, stats = newWalkStats()) {
-  const root = join9(homeDir, ".claude", "projects");
+  const root = join10(homeDir, ".claude", "projects");
   let latest;
   for (const entry of safeReaddir(root, stats)) {
     if (!entry.isDirectory())
       continue;
-    const dir = join9(root, entry.name);
+    const dir = join10(root, entry.name);
     for (const sub of safeReaddir(dir, stats)) {
       const name = sub.name;
       if (!name.endsWith(".jsonl"))
         continue;
-      const file = join9(dir, name);
+      const file = join10(dir, name);
       let mtimeMs;
       try {
         mtimeMs = statSync(file).mtimeMs;
@@ -9423,7 +9626,7 @@ function probeVersion(homeDir, stats = newWalkStats()) {
     return void 0;
   let lines2;
   try {
-    lines2 = readFileSync4(latest.file, "utf8").split("\n");
+    lines2 = readFileSync5(latest.file, "utf8").split("\n");
   } catch (error) {
     recordWalkError(error, stats);
     return void 0;
@@ -9443,7 +9646,7 @@ function probeVersion(homeDir, stats = newWalkStats()) {
 }
 async function detectCc(options) {
   const homeDir = options?.homeDir ?? homedir5();
-  const installed = existsSync4(join9(homeDir, ".claude")) || existsSync4(join9(homeDir, ".claude.json"));
+  const installed = existsSync5(join10(homeDir, ".claude")) || existsSync5(join10(homeDir, ".claude.json"));
   if (!installed)
     return { installed: false };
   const version = probeVersion(homeDir);
@@ -9458,11 +9661,11 @@ var init_detect = __esm({
 
 // packages/adapter-cc/dist/scan.js
 import { Buffer as Buffer4 } from "node:buffer";
-import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync2 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { basename as basename3, dirname as dirname6, join as join10, resolve as resolve3, sep } from "node:path";
+import { basename as basename4, dirname as dirname7, join as join11, resolve as resolve3, sep } from "node:path";
 function readJsonFile(file) {
-  const text = readFileSync5(file, "utf8");
+  const text = readFileSync6(file, "utf8");
   try {
     return JSON.parse(text);
   } catch (e) {
@@ -9478,13 +9681,13 @@ function recordField(v, key) {
 }
 function readSettingsChain(homeDir, projectDir) {
   const chain = [
-    { file: join10(homeDir, ".claude", "settings.json"), source: "user" },
-    { file: join10(projectDir, ".claude", "settings.json"), source: "project" },
-    { file: join10(projectDir, ".claude", "settings.local.json"), source: "local" }
+    { file: join11(homeDir, ".claude", "settings.json"), source: "user" },
+    { file: join11(projectDir, ".claude", "settings.json"), source: "project" },
+    { file: join11(projectDir, ".claude", "settings.local.json"), source: "local" }
   ];
   const out = [];
   for (const { file, source } of chain) {
-    if (!existsSync5(file))
+    if (!existsSync6(file))
       continue;
     const data = asRecord(readJsonFile(file));
     if (!data)
@@ -9527,7 +9730,7 @@ function ruleItem(file, source, stats) {
     return {
       id: "",
       slot: "rules",
-      nativeName: basename3(file),
+      nativeName: basename4(file),
       nativePath: file,
       tokens: estimateTokens(statSync2(file).size),
       residency: "resident",
@@ -9547,20 +9750,20 @@ function buildRules(homeDir, projectDir, stats) {
     if (item !== void 0)
       items.push(item);
   };
-  const userClaudeMd = join10(homeDir, ".claude", "CLAUDE.md");
-  if (existsSync5(userClaudeMd))
+  const userClaudeMd = join11(homeDir, ".claude", "CLAUDE.md");
+  if (existsSync6(userClaudeMd))
     append(userClaudeMd, "user");
-  for (const f of listMdFiles(join10(homeDir, ".claude", "rules"), stats))
+  for (const f of listMdFiles(join11(homeDir, ".claude", "rules"), stats))
     append(f, "user");
   if (isBareProjectDir(projectDir, homeDir)) {
-    const direct = join10(projectDir, "CLAUDE.md");
-    if (existsSync5(direct))
+    const direct = join11(projectDir, "CLAUDE.md");
+    if (existsSync6(direct))
       append(direct, "project");
   } else {
     for (const f of walkFiles(projectDir, "CLAUDE.md", stats))
       append(f, "project");
   }
-  for (const f of listMdFiles(join10(projectDir, ".claude", "rules"), stats)) {
+  for (const f of listMdFiles(join11(projectDir, ".claude", "rules"), stats)) {
     append(f, "project");
   }
   return items;
@@ -9583,14 +9786,14 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 function buildSkills(homeDir, projectDir, overrides, stats) {
-  const userRoot = join10(homeDir, ".claude", "skills");
-  const syncedRoot = join10(userRoot, "synced");
+  const userRoot = join11(homeDir, ".claude", "skills");
+  const syncedRoot = join11(userRoot, "synced");
   const roots = [
     { root: userRoot, source: "user", exclude: syncedRoot },
     // projectDir 为家目录时,项目 skills 根与 user 根是同一目录,再走一遍会把每个
     // skill 重复列为 project 层;bare root 无项目上下文 → 不设项目 skills 根
-    ...isBareProjectDir(projectDir, homeDir) ? [] : [{ root: join10(projectDir, ".claude", "skills"), source: "project" }],
-    { root: join10(homeDir, ".claude", "plugins"), source: "plugin" },
+    ...isBareProjectDir(projectDir, homeDir) ? [] : [{ root: join11(projectDir, ".claude", "skills"), source: "project" }],
+    { root: join11(homeDir, ".claude", "plugins"), source: "plugin" },
     { root: syncedRoot, source: "synced" }
   ];
   const items = [];
@@ -9599,8 +9802,8 @@ function buildSkills(homeDir, projectDir, overrides, stats) {
       if (exclude && (skillFile === exclude || skillFile.startsWith(exclude + sep)))
         continue;
       try {
-        const fm = parseSkillFrontmatter(readFileSync5(skillFile, "utf8"));
-        const name = fm.name ?? basename3(dirname6(skillFile));
+        const fm = parseSkillFrontmatter(readFileSync6(skillFile, "utf8"));
+        const name = fm.name ?? basename4(dirname7(skillFile));
         const size = statSync2(skillFile).size;
         items.push({
           id: "",
@@ -9624,9 +9827,9 @@ function buildSkills(homeDir, projectDir, overrides, stats) {
 }
 function buildTools(homeDir, projectDir) {
   const items = [];
-  const claudeJsonPath = join10(homeDir, ".claude.json");
+  const claudeJsonPath = join11(homeDir, ".claude.json");
   let claudeJson;
-  if (existsSync5(claudeJsonPath))
+  if (existsSync6(claudeJsonPath))
     claudeJson = asRecord(readJsonFile(claudeJsonPath));
   const projectEntry = recordField(claudeJson?.projects, resolve3(projectDir));
   const disabledRaw = projectEntry?.disabledMcpServers;
@@ -9650,8 +9853,8 @@ function buildTools(homeDir, projectDir) {
   for (const name of Object.keys(localServers).sort()) {
     items.push(mcpItem(name, "local", claudeJsonPath));
   }
-  const mcpJsonPath = join10(projectDir, ".mcp.json");
-  if (existsSync5(mcpJsonPath)) {
+  const mcpJsonPath = join11(projectDir, ".mcp.json");
+  if (existsSync6(mcpJsonPath)) {
     const projectServers = recordField(readJsonFile(mcpJsonPath), "mcpServers") ?? {};
     for (const name of Object.keys(projectServers).sort()) {
       items.push(mcpItem(name, "project", mcpJsonPath));
@@ -9697,7 +9900,7 @@ function lastContextTotal(file, stats) {
   let total;
   let text;
   try {
-    text = readFileSync5(file, "utf8");
+    text = readFileSync6(file, "utf8");
   } catch (error) {
     recordWalkError(error, stats);
     return void 0;
@@ -9725,10 +9928,10 @@ function lastContextTotal(file, stats) {
   return total;
 }
 function buildHistory(homeDir, projectDir, stats) {
-  const dir = join10(homeDir, ".claude", "projects", projectSlug(projectDir));
+  const dir = join11(homeDir, ".claude", "projects", projectSlug(projectDir));
   const items = [];
   for (const name of safeReaddir(dir, stats).map((e) => e.name).filter((n) => n.endsWith(".jsonl")).sort()) {
-    const file = join10(dir, name);
+    const file = join11(dir, name);
     const total = lastContextTotal(file, stats);
     if (total === void 0)
       continue;
@@ -9839,9 +10042,9 @@ var init_scan = __esm({
 });
 
 // packages/adapter-cc/dist/actions.js
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename4, dirname as dirname7, join as join11, resolve as resolve4 } from "node:path";
+import { basename as basename5, dirname as dirname8, join as join12, resolve as resolve4 } from "node:path";
 function asRecord2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
 }
@@ -9865,10 +10068,10 @@ function deepEqual(a, b) {
 }
 function backupDirPath(homeDir) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  const root = join11(homeDir, ".wingman", "backups");
-  let dir = join11(root, ts);
-  for (let n = 2; existsSync6(dir); n++)
-    dir = join11(root, `${ts}-${n}`);
+  const root = join12(homeDir, ".wingman", "backups");
+  let dir = join12(root, ts);
+  for (let n = 2; existsSync7(dir); n++)
+    dir = join12(root, `${ts}-${n}`);
   return dir;
 }
 function decodeUtf8Strict3(buffer, file) {
@@ -9880,15 +10083,15 @@ function decodeUtf8Strict3(buffer, file) {
 }
 function readSettingsSnapshots(homeDir, projectDir) {
   const files = [
-    join11(homeDir, ".claude", "settings.json"),
-    join11(projectDir, ".claude", "settings.json"),
-    join11(projectDir, ".claude", "settings.local.json")
+    join12(homeDir, ".claude", "settings.json"),
+    join12(projectDir, ".claude", "settings.json"),
+    join12(projectDir, ".claude", "settings.local.json")
   ];
   const out = [];
   for (const file of files) {
-    if (!existsSync6(file))
+    if (!existsSync7(file))
       continue;
-    const raw = decodeUtf8Strict3(readFileSync6(file), file);
+    const raw = decodeUtf8Strict3(readFileSync7(file), file);
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -9911,7 +10114,7 @@ function overridesRecord(s) {
   return rec;
 }
 function skillTargetFile(item, homeDir, projectDir) {
-  return item.source === "project" ? join11(projectDir, ".claude", "settings.json") : join11(homeDir, ".claude", "settings.json");
+  return item.source === "project" ? join12(projectDir, ".claude", "settings.json") : join12(homeDir, ".claude", "settings.json");
 }
 function planSkillToggle(item, enable, homeDir, projectDir) {
   const name = item.nativeName;
@@ -9964,11 +10167,11 @@ function planSkillToggle(item, enable, homeDir, projectDir) {
   });
 }
 function planMcpToggle(name, enable, homeDir, projectDir) {
-  const file = join11(homeDir, ".claude.json");
-  if (!existsSync6(file)) {
+  const file = join12(homeDir, ".claude.json");
+  if (!existsSync7(file)) {
     throw new Error(`\u62D2\u7EDD:\u627E\u4E0D\u5230 ${file}(MCP \u8FDE\u63A5\u5F00\u5173\u6309\u9879\u76EE\u5B58\u653E\u4E8E\u8BE5\u6587\u4EF6)`);
   }
-  const raw = readFileSync6(file, "utf8");
+  const raw = readFileSync7(file, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -10042,24 +10245,24 @@ function collectRefSources(homeDir, projectDir, exclude) {
     sources.push({ file, text });
   };
   const pushFile = (file) => {
-    if (!seen.has(file) && existsSync6(file))
-      push(file, readFileSync6(file, "utf8"));
+    if (!seen.has(file) && existsSync7(file))
+      push(file, readFileSync7(file, "utf8"));
   };
   const bareRoot = isBareProjectDir(projectDir, homeDir);
-  pushFile(join11(homeDir, ".claude", "CLAUDE.md"));
-  for (const f of listMdFiles(join11(homeDir, ".claude", "rules")))
+  pushFile(join12(homeDir, ".claude", "CLAUDE.md"));
+  for (const f of listMdFiles(join12(homeDir, ".claude", "rules")))
     pushFile(f);
   if (bareRoot)
-    pushFile(join11(projectDir, "CLAUDE.md"));
+    pushFile(join12(projectDir, "CLAUDE.md"));
   else
     for (const f of walkFiles(projectDir, "CLAUDE.md"))
       pushFile(f);
-  for (const f of listMdFiles(join11(projectDir, ".claude", "rules")))
+  for (const f of listMdFiles(join12(projectDir, ".claude", "rules")))
     pushFile(f);
   const skillRoots = [
-    join11(homeDir, ".claude", "skills"),
-    ...bareRoot ? [] : [join11(projectDir, ".claude", "skills")],
-    join11(homeDir, ".claude", "plugins")
+    join12(homeDir, ".claude", "skills"),
+    ...bareRoot ? [] : [join12(projectDir, ".claude", "skills")],
+    join12(homeDir, ".claude", "plugins")
   ];
   for (const root of skillRoots) {
     for (const f of walkFiles(root, "SKILL.md")) {
@@ -10068,20 +10271,20 @@ function collectRefSources(homeDir, projectDir, exclude) {
     }
   }
   for (const dir of [
-    join11(homeDir, ".claude", "agents"),
-    join11(projectDir, ".claude", "agents"),
-    join11(homeDir, ".claude", "commands"),
-    join11(projectDir, ".claude", "commands")
+    join12(homeDir, ".claude", "agents"),
+    join12(projectDir, ".claude", "agents"),
+    join12(homeDir, ".claude", "commands"),
+    join12(projectDir, ".claude", "commands")
   ]) {
     for (const f of listMdFiles(dir))
       pushFile(f);
   }
   for (const s of readSettingsSnapshots(homeDir, projectDir))
     push(s.file, s.raw);
-  for (const file of [join11(projectDir, ".mcp.json"), join11(homeDir, ".claude.json")]) {
-    if (seen.has(file) || !existsSync6(file))
+  for (const file of [join12(projectDir, ".mcp.json"), join12(homeDir, ".claude.json")]) {
+    if (seen.has(file) || !existsSync7(file))
       continue;
-    const raw = readFileSync6(file, "utf8");
+    const raw = readFileSync7(file, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -10188,14 +10391,14 @@ async function applyActionCc(plan, _options) {
   const currentByFile = /* @__PURE__ */ new Map();
   for (const w of plan.writes) {
     if (w.kind === "create") {
-      if (existsSync6(w.file)) {
+      if (existsSync7(w.file)) {
         return { ok: false, error: `\u62D2\u7EDD\u6267\u884C:${w.file} \u5728 plan \u540E\u88AB\u521B\u5EFA,\u8BF7\u91CD\u65B0 plan` };
       }
     } else {
-      if (!existsSync6(w.file)) {
+      if (!existsSync7(w.file)) {
         return { ok: false, error: `\u62D2\u7EDD\u6267\u884C:${w.file} \u5DF2\u4E0D\u5B58\u5728(plan \u540E\u88AB\u6539\u52A8),\u8BF7\u91CD\u65B0 plan` };
       }
-      const currentRaw = readFileSync6(w.file);
+      const currentRaw = readFileSync7(w.file);
       if (!currentRaw.equals(Buffer.from(w.before, "utf8"))) {
         return { ok: false, error: `\u62D2\u7EDD\u6267\u884C:${w.file} \u5728 plan \u540E\u88AB\u6539\u8FC7,\u8BF7\u91CD\u65B0 plan` };
       }
@@ -10203,15 +10406,15 @@ async function applyActionCc(plan, _options) {
     }
   }
   const toBackup = plan.writes.filter((w) => w.kind !== "create");
-  mkdirSync3(plan.backupDir, { recursive: true });
+  mkdirSync4(plan.backupDir, { recursive: true });
   const manifestFiles = toBackup.map((w, i) => ({
-    backup: `${i}-${basename4(w.file)}`,
+    backup: `${i}-${basename5(w.file)}`,
     target: w.file
   }));
   toBackup.forEach((w, i) => {
-    writeFileSync4(join11(plan.backupDir, `${i}-${basename4(w.file)}`), currentByFile.get(w.file));
+    writeFileSync5(join12(plan.backupDir, `${i}-${basename5(w.file)}`), currentByFile.get(w.file));
   });
-  writeFileSync4(join11(plan.backupDir, "manifest.json"), serialize({
+  writeFileSync5(join12(plan.backupDir, "manifest.json"), serialize({
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     harness: "cc",
     action: plan.action,
@@ -10221,10 +10424,10 @@ async function applyActionCc(plan, _options) {
   try {
     for (const w of plan.writes) {
       if (w.kind === "delete") {
-        rmSync2(w.file);
+        rmSync3(w.file);
       } else {
-        mkdirSync3(dirname7(w.file), { recursive: true });
-        writeFileSync4(w.file, w.after ?? "");
+        mkdirSync4(dirname8(w.file), { recursive: true });
+        writeFileSync5(w.file, w.after ?? "");
       }
       written.push(w);
     }
@@ -10233,9 +10436,9 @@ async function applyActionCc(plan, _options) {
     for (const w of written) {
       try {
         if (w.kind === "create")
-          rmSync2(w.file, { force: true });
+          rmSync3(w.file, { force: true });
         else
-          writeFileSync4(w.file, w.before ?? "");
+          writeFileSync5(w.file, w.before ?? "");
       } catch {
         failures.push(w.file);
       }
@@ -10244,12 +10447,12 @@ async function applyActionCc(plan, _options) {
     return { ok: false, error: `\u5199\u5165\u5931\u8D25:${e.message};${rollbackNote}` };
   }
   for (const w of plan.writes) {
-    if (basename4(w.file) !== ".claude.json" || w.kind !== "modify" || w.after === void 0) {
+    if (basename5(w.file) !== ".claude.json" || w.kind !== "modify" || w.after === void 0) {
       continue;
     }
     let verified = false;
     try {
-      verified = deepEqual(JSON.parse(readFileSync6(w.file, "utf8")), JSON.parse(w.after));
+      verified = deepEqual(JSON.parse(readFileSync7(w.file, "utf8")), JSON.parse(w.after));
     } catch {
       verified = false;
     }
@@ -10275,9 +10478,9 @@ var init_actions = __esm({
 });
 
 // packages/adapter-cc/dist/hooks.js
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync8, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, join as join12 } from "node:path";
+import { dirname as dirname9, join as join13 } from "node:path";
 function wingmanUrl(port) {
   return `http://127.0.0.1:${port}${SIGNATURE}`;
 }
@@ -10289,18 +10492,18 @@ function isWingmanHandler(h) {
   return rec?.type === "http" && typeof rec.url === "string" && rec.url.includes(SIGNATURE);
 }
 function wingmanRoot(homeDir) {
-  return join12(homeDir, ".wingman");
+  return join13(homeDir, ".wingman");
 }
 function statePath(homeDir) {
-  return join12(wingmanRoot(homeDir), "state", "cc-hooks.json");
+  return join13(wingmanRoot(homeDir), "state", "cc-hooks.json");
 }
 function readState3(homeDir) {
   const file = statePath(homeDir);
-  if (!existsSync7(file))
+  if (!existsSync8(file))
     return void 0;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync7(file, "utf8"));
+    parsed = JSON.parse(readFileSync8(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -10321,23 +10524,23 @@ function readState3(homeDir) {
 }
 function writeState3(homeDir, state) {
   const file = statePath(homeDir);
-  mkdirSync4(dirname8(file), { recursive: true });
-  writeFileSync5(file, `${JSON.stringify(state, null, 2)}
+  mkdirSync5(dirname9(file), { recursive: true });
+  writeFileSync6(file, `${JSON.stringify(state, null, 2)}
 `);
 }
 function makeBackupDir(homeDir) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  const root = join12(wingmanRoot(homeDir), "backups");
-  let dir = join12(root, ts);
-  for (let n = 2; existsSync7(dir); n++)
-    dir = join12(root, `${ts}-${n}`);
-  mkdirSync4(dir, { recursive: true });
+  const root = join13(wingmanRoot(homeDir), "backups");
+  let dir = join13(root, ts);
+  for (let n = 2; existsSync8(dir); n++)
+    dir = join13(root, `${ts}-${n}`);
+  mkdirSync5(dir, { recursive: true });
   return dir;
 }
-function readTarget(target) {
-  if (!existsSync7(target))
+function readTarget2(target) {
+  if (!existsSync8(target))
     return { bytes: null, settings: {} };
-  const bytes = readFileSync7(target, "utf8");
+  const bytes = readFileSync8(target, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(bytes);
@@ -10440,13 +10643,13 @@ function deepEqual2(a, b) {
   return false;
 }
 function targetPath(homeDir) {
-  return join12(homeDir, ".claude", "settings.json");
+  return join13(homeDir, ".claude", "settings.json");
 }
 async function installHooksCc(port, options) {
   const homeDir = options?.homeDir ?? homedir8();
   const target = targetPath(homeDir);
   const url = wingmanUrl(port);
-  const { bytes, settings } = readTarget(target);
+  const { bytes, settings } = readTarget2(target);
   if (isFullyWired(settings, url))
     return;
   if (settings.hooks !== void 0 && !asRecord3(settings.hooks)) {
@@ -10462,7 +10665,7 @@ async function installHooksCc(port, options) {
   }
   const backupDir = makeBackupDir(homeDir);
   if (bytes !== null)
-    writeFileSync5(join12(backupDir, "settings.json"), bytes);
+    writeFileSync6(join13(backupDir, "settings.json"), bytes);
   const prev = readState3(homeDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   writeState3(homeDir, prev ? { ...prev, port, installedAt: now } : { target, original: bytes, backupDir, port, installedAt: now });
@@ -10474,44 +10677,44 @@ async function installHooksCc(port, options) {
     groups.push({ hooks: [{ type: "http", url }] });
     hooks[event] = groups;
   }
-  mkdirSync4(dirname8(target), { recursive: true });
-  writeFileSync5(target, `${JSON.stringify(settings, null, 2)}
+  mkdirSync5(dirname9(target), { recursive: true });
+  writeFileSync6(target, `${JSON.stringify(settings, null, 2)}
 `);
 }
 async function uninstallHooksCc(options) {
   const homeDir = options?.homeDir ?? homedir8();
   const target = targetPath(homeDir);
   const state = readState3(homeDir);
-  if (!existsSync7(target)) {
-    rmSync3(statePath(homeDir), { force: true });
+  if (!existsSync8(target)) {
+    rmSync4(statePath(homeDir), { force: true });
     return;
   }
-  const { bytes, settings } = readTarget(target);
+  const { bytes, settings } = readTarget2(target);
   const changed = removeWingmanEntries(settings);
   if (!changed) {
-    rmSync3(statePath(homeDir), { force: true });
+    rmSync4(statePath(homeDir), { force: true });
     return;
   }
   const backupDir = makeBackupDir(homeDir);
   if (bytes !== null)
-    writeFileSync5(join12(backupDir, "settings.json"), bytes);
+    writeFileSync6(join13(backupDir, "settings.json"), bytes);
   if (state && state.original !== null) {
     const originalParsed = asRecord3(JSON.parse(state.original));
     if (originalParsed && deepEqual2(normalizeForCompare(settings), normalizeForCompare(originalParsed))) {
-      writeFileSync5(target, state.original);
-      rmSync3(statePath(homeDir), { force: true });
+      writeFileSync6(target, state.original);
+      rmSync4(statePath(homeDir), { force: true });
       return;
     }
   } else if (state && state.original === null) {
     if (deepEqual2(normalizeForCompare(settings), {})) {
-      rmSync3(target, { force: true });
-      rmSync3(statePath(homeDir), { force: true });
+      rmSync4(target, { force: true });
+      rmSync4(statePath(homeDir), { force: true });
       return;
     }
   }
-  writeFileSync5(target, `${JSON.stringify(settings, null, 2)}
+  writeFileSync6(target, `${JSON.stringify(settings, null, 2)}
 `);
-  rmSync3(statePath(homeDir), { force: true });
+  rmSync4(statePath(homeDir), { force: true });
 }
 var WIRED_EVENTS, SIGNATURE;
 var init_hooks2 = __esm({
@@ -10532,60 +10735,60 @@ var init_hooks2 = __esm({
 });
 
 // packages/adapter-cc/dist/protocol.js
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync8, rmdirSync, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync2, readFileSync as readFileSync9, rmdirSync, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { basename as basename5, dirname as dirname9, join as join13, resolve as resolve5 } from "node:path";
+import { basename as basename6, dirname as dirname10, join as join14, resolve as resolve5 } from "node:path";
 function protocolStatusCc(options) {
-  const paths = resolveOptions2(options);
-  if (!existsSync8(paths.targetPath)) {
-    return { harness: "cc", state: "not_installed", targetPath: paths.targetPath };
+  const paths3 = resolveOptions2(options);
+  if (!existsSync9(paths3.targetPath)) {
+    return { harness: "cc", state: "not_installed", targetPath: paths3.targetPath };
   }
   try {
-    return statusFromIdentity(paths.targetPath, inspectPlanProtocolFile(readFileSync8(paths.targetPath), paths.targetPath));
+    return statusFromIdentity(paths3.targetPath, inspectPlanProtocolFile(readFileSync9(paths3.targetPath), paths3.targetPath));
   } catch (error) {
     return {
       harness: "cc",
       state: "invalid",
-      targetPath: paths.targetPath,
+      targetPath: paths3.targetPath,
       reason: error.message
     };
   }
 }
 function installProtocolCc(options) {
-  const paths = resolveOptions2(options);
-  const existing = readExisting(paths.targetPath);
+  const paths3 = resolveOptions2(options);
+  const existing = readExisting(paths3.targetPath);
   const previousState = stateForIdentity2(existing?.identity);
   if (previousState === "installed") {
-    return result2(paths.targetPath, "install", false, previousState, existing?.text ?? "", true);
+    return result3(paths3.targetPath, "install", false, previousState, existing?.text ?? "", true);
   }
   if (previousState === "modified")
-    throw modifiedError2(paths.targetPath, "\u5B89\u88C5");
+    throw modifiedError2(paths3.targetPath, "\u5B89\u88C5");
   const before = existing?.text ?? "";
-  const backupDir = nextBackupDir2(paths.homeDir);
+  const backupDir = nextBackupDir3(paths3.homeDir);
   const installedSha256 = sha256Hex(PLAN_PROTOCOL_TEXT);
-  if (!paths.dryRun) {
-    const claudeDir = join13(paths.projectDir, ".claude");
-    const rulesDir = dirname9(paths.targetPath);
-    const prior = readState4(paths.statePath);
-    backupTarget2(backupDir, paths.targetPath, existing?.bytes);
-    writeState4(paths.statePath, {
+  if (!paths3.dryRun) {
+    const claudeDir = join14(paths3.projectDir, ".claude");
+    const rulesDir = dirname10(paths3.targetPath);
+    const prior = readState4(paths3.statePath);
+    backupTarget3(backupDir, paths3.targetPath, existing?.bytes);
+    writeState4(paths3.statePath, {
       version: 1,
       harness: "cc",
-      projectDir: paths.projectDir,
-      targetPath: paths.targetPath,
+      projectDir: paths3.projectDir,
+      targetPath: paths3.targetPath,
       protocolVersion: PLAN_PROTOCOL_VERSION,
       installedSha256,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
       backupDir,
       original: prior?.original ?? (existing === void 0 ? { existed: false } : { existed: true, base64: existing.bytes.toString("base64") }),
-      createdClaudeDir: prior?.createdClaudeDir ?? !existsSync8(claudeDir),
-      createdRulesDir: prior?.createdRulesDir ?? !existsSync8(rulesDir)
+      createdClaudeDir: prior?.createdClaudeDir ?? !existsSync9(claudeDir),
+      createdRulesDir: prior?.createdRulesDir ?? !existsSync9(rulesDir)
     });
-    mkdirSync5(rulesDir, { recursive: true });
-    writeFileSync6(paths.targetPath, PLAN_PROTOCOL_TEXT);
+    mkdirSync6(rulesDir, { recursive: true });
+    writeFileSync7(paths3.targetPath, PLAN_PROTOCOL_TEXT);
   }
   return {
-    ...result2(paths.targetPath, "install", true, previousState, before, true),
+    ...result3(paths3.targetPath, "install", true, previousState, before, true),
     state: "installed",
     version: PLAN_PROTOCOL_VERSION,
     sha256: installedSha256,
@@ -10595,31 +10798,31 @@ function installProtocolCc(options) {
   };
 }
 function uninstallProtocolCc(options) {
-  const paths = resolveOptions2(options);
-  const existing = readExisting(paths.targetPath);
+  const paths3 = resolveOptions2(options);
+  const existing = readExisting(paths3.targetPath);
   if (existing === void 0) {
-    return result2(paths.targetPath, "uninstall", false, "not_installed", "", false);
+    return result3(paths3.targetPath, "uninstall", false, "not_installed", "", false);
   }
   const previousState = stateForIdentity2(existing.identity);
   if (previousState === "modified")
-    throw modifiedError2(paths.targetPath, "\u5378\u8F7D");
-  const state = readState4(paths.statePath);
+    throw modifiedError2(paths3.targetPath, "\u5378\u8F7D");
+  const state = readState4(paths3.statePath);
   const restored = restoredOriginal(state);
   const after = restored?.toString("utf8") ?? "";
   const afterExists = restored !== void 0;
-  const backupDir = nextBackupDir2(paths.homeDir);
-  if (!paths.dryRun) {
-    backupTarget2(backupDir, paths.targetPath, existing.bytes);
+  const backupDir = nextBackupDir3(paths3.homeDir);
+  if (!paths3.dryRun) {
+    backupTarget3(backupDir, paths3.targetPath, existing.bytes);
     if (restored === void 0)
-      rmSync4(paths.targetPath, { force: true });
+      rmSync5(paths3.targetPath, { force: true });
     else
-      writeFileSync6(paths.targetPath, restored);
+      writeFileSync7(paths3.targetPath, restored);
     if (restored === void 0)
-      removeCreatedEmptyDirs(paths, state);
-    rmSync4(paths.statePath, { force: true });
+      removeCreatedEmptyDirs(paths3, state);
+    rmSync5(paths3.statePath, { force: true });
   }
   return {
-    ...result2(paths.targetPath, "uninstall", true, previousState, existing.text, afterExists),
+    ...result3(paths3.targetPath, "uninstall", true, previousState, existing.text, afterExists),
     state: "not_installed",
     after,
     backupDir,
@@ -10629,20 +10832,20 @@ function uninstallProtocolCc(options) {
 function resolveOptions2(options) {
   const homeDir = resolve5(options?.homeDir ?? homedir9());
   const projectDir = resolve5(options?.projectDir ?? process.cwd());
-  const targetPath2 = join13(projectDir, ".claude", "rules", "wingman-plan-protocol.md");
+  const targetPath2 = join14(projectDir, ".claude", "rules", "wingman-plan-protocol.md");
   const projectHash = sha256Hex(projectDir);
   return {
     homeDir,
     projectDir,
     dryRun: options?.dryRun ?? false,
     targetPath: targetPath2,
-    statePath: join13(homeDir, ".wingman", "state", `plan-protocol-cc-${projectHash}.json`)
+    statePath: join14(homeDir, ".wingman", "state", `plan-protocol-cc-${projectHash}.json`)
   };
 }
 function readExisting(targetPath2) {
-  if (!existsSync8(targetPath2))
+  if (!existsSync9(targetPath2))
     return void 0;
-  const bytes = readFileSync8(targetPath2);
+  const bytes = readFileSync9(targetPath2);
   const identity = inspectPlanProtocolFile(bytes, targetPath2);
   return { bytes, text: bytes.toString("utf8"), identity };
 }
@@ -10651,7 +10854,7 @@ function stateForIdentity2(identity) {
     return "not_installed";
   if (identity.kind === "current")
     return "installed";
-  if (identity.kind === "legacy")
+  if (identity.kind === "outdated")
     return "outdated";
   return "modified";
 }
@@ -10665,7 +10868,7 @@ function statusFromIdentity(targetPath2, identity) {
     ...identity.kind === "modified" ? { reason: "\u53D7\u7BA1\u534F\u8BAE\u6587\u4EF6\u5DF2\u88AB\u4FEE\u6539" } : {}
   };
 }
-function result2(targetPath2, operation, changed, previousState, before, afterExists) {
+function result3(targetPath2, operation, changed, previousState, before, afterExists) {
   return {
     harness: "cc",
     operation,
@@ -10683,32 +10886,32 @@ function result2(targetPath2, operation, changed, previousState, before, afterEx
 function modifiedError2(targetPath2, operation) {
   return new Error(`\u53D7\u7BA1\u534F\u8BAE\u6587\u4EF6\u5DF2\u88AB\u4FEE\u6539(${targetPath2})\uFF0C\u62D2\u7EDD${operation}\u5E76\u4FDD\u7559\u7528\u6237\u5185\u5BB9`);
 }
-function nextBackupDir2(homeDir) {
+function nextBackupDir3(homeDir) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  const root = join13(homeDir, ".wingman", "backups");
-  let dir = join13(root, stamp);
-  for (let n = 2; existsSync8(dir); n += 1)
-    dir = join13(root, `${stamp}-${n}`);
+  const root = join14(homeDir, ".wingman", "backups");
+  let dir = join14(root, stamp);
+  for (let n = 2; existsSync9(dir); n += 1)
+    dir = join14(root, `${stamp}-${n}`);
   return dir;
 }
-function backupTarget2(backupDir, targetPath2, bytes) {
-  mkdirSync5(backupDir, { recursive: true });
+function backupTarget3(backupDir, targetPath2, bytes) {
+  mkdirSync6(backupDir, { recursive: true });
   if (bytes !== void 0)
-    writeFileSync6(join13(backupDir, basename5(targetPath2)), bytes);
+    writeFileSync7(join14(backupDir, basename6(targetPath2)), bytes);
 }
 function readState4(statePath2) {
-  if (!existsSync8(statePath2))
+  if (!existsSync9(statePath2))
     return void 0;
   try {
-    const state = JSON.parse(readFileSync8(statePath2, "utf8"));
+    const state = JSON.parse(readFileSync9(statePath2, "utf8"));
     return state.version === 1 && state.harness === "cc" && typeof state.targetPath === "string" ? state : void 0;
   } catch {
     return void 0;
   }
 }
 function writeState4(statePath2, state) {
-  mkdirSync5(dirname9(statePath2), { recursive: true });
-  writeFileSync6(statePath2, `${JSON.stringify(state, null, 2)}
+  mkdirSync6(dirname10(statePath2), { recursive: true });
+  writeFileSync7(statePath2, `${JSON.stringify(state, null, 2)}
 `);
 }
 function restoredOriginal(state) {
@@ -10716,13 +10919,13 @@ function restoredOriginal(state) {
     return void 0;
   return Buffer.from(state.original.base64 ?? "", "base64");
 }
-function removeCreatedEmptyDirs(paths, state) {
-  const rulesDir = dirname9(paths.targetPath);
-  const claudeDir = dirname9(rulesDir);
-  if (state?.createdRulesDir && existsSync8(rulesDir) && readdirSync2(rulesDir).length === 0) {
+function removeCreatedEmptyDirs(paths3, state) {
+  const rulesDir = dirname10(paths3.targetPath);
+  const claudeDir = dirname10(rulesDir);
+  if (state?.createdRulesDir && existsSync9(rulesDir) && readdirSync2(rulesDir).length === 0) {
     rmdirSync(rulesDir);
   }
-  if (state?.createdClaudeDir && existsSync8(claudeDir) && readdirSync2(claudeDir).length === 0) {
+  if (state?.createdClaudeDir && existsSync9(claudeDir) && readdirSync2(claudeDir).length === 0) {
     rmdirSync(claudeDir);
   }
 }
@@ -10733,6 +10936,33 @@ var init_protocol2 = __esm({
   }
 });
 
+// packages/adapter-cc/dist/protocol-user.js
+import { homedir as homedir10 } from "node:os";
+import { join as join15, resolve as resolve6 } from "node:path";
+function paths(options) {
+  const homeDir = resolve6(options?.homeDir ?? homedir10());
+  return {
+    homeDir,
+    targetPath: join15(homeDir, ".claude", "CLAUDE.md"),
+    dryRun: options?.dryRun ?? false
+  };
+}
+function protocolStatusCcUser(options) {
+  return { harness: "cc", ...statusPlanProtocolUser(paths(options).targetPath) };
+}
+function installProtocolCcUser(options) {
+  return { harness: "cc", ...installPlanProtocolUser(paths(options)) };
+}
+function uninstallProtocolCcUser(options) {
+  return { harness: "cc", ...uninstallPlanProtocolUser(paths(options)) };
+}
+var init_protocol_user = __esm({
+  "packages/adapter-cc/dist/protocol-user.js"() {
+    "use strict";
+    init_dist();
+  }
+});
+
 // packages/adapter-cc/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
@@ -10740,8 +10970,11 @@ __export(dist_exports2, {
   createAdapter: () => createAdapter2,
   feedbackSignals: () => feedbackSignalsCc,
   installProtocolCc: () => installProtocolCc,
+  installProtocolCcUser: () => installProtocolCcUser,
   protocolStatusCc: () => protocolStatusCc,
-  uninstallProtocolCc: () => uninstallProtocolCc
+  protocolStatusCcUser: () => protocolStatusCcUser,
+  uninstallProtocolCc: () => uninstallProtocolCc,
+  uninstallProtocolCcUser: () => uninstallProtocolCcUser
 });
 function createAdapter2(_options) {
   return {
@@ -10764,6 +10997,7 @@ var init_dist3 = __esm({
     init_hooks2();
     init_protocol2();
     init_scan();
+    init_protocol_user();
   }
 });
 
@@ -11476,15 +11710,15 @@ var init_dist4 = __esm({
 });
 
 // packages/adapter-codex/dist/shared.js
-import { homedir as homedir10 } from "node:os";
-import { join as join14 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join16 } from "node:path";
 function resolvePaths(options) {
-  const homeDir = options?.homeDir ?? homedir10();
+  const homeDir = options?.homeDir ?? homedir11();
   const projectDir = options?.projectDir ?? process.cwd();
-  return { homeDir, projectDir, codexHome: join14(homeDir, ".codex") };
+  return { homeDir, projectDir, codexHome: join16(homeDir, ".codex") };
 }
-function wingmanStateRoot(paths) {
-  return join14(paths.homeDir, ".wingman");
+function wingmanStateRoot(paths3) {
+  return join16(paths3.homeDir, ".wingman");
 }
 function isTable(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
@@ -11793,26 +12027,26 @@ var init_toml_edit = __esm({
 });
 
 // packages/adapter-codex/dist/actions.js
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename6, dirname as dirname10, join as join15 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync3, writeFileSync as writeFileSync8 } from "node:fs";
+import { basename as basename7, dirname as dirname11, join as join17 } from "node:path";
 async function planAction(action, options) {
-  const paths = resolvePaths(options);
-  const resolved = resolveToggle(action, paths);
+  const paths3 = resolvePaths(options);
+  const resolved = resolveToggle(action, paths3);
   return {
     harness: "codex",
     action,
     writes: [
       { file: resolved.file, kind: "modify", before: resolved.before, after: resolved.after }
     ],
-    backupDir: nextBackupDir3(paths),
-    references: scanReferences(collectCorpus(paths), resolved.bareName),
+    backupDir: nextBackupDir4(paths3),
+    references: scanReferences(collectCorpus(paths3), resolved.bareName),
     // §4b 地面真值:config.toml 启动时读,外改对运行中会话不生效 → 如实报 next_session
     effectiveAt: "next_session"
   };
 }
 async function applyAction(plan, options) {
   try {
-    const paths = resolvePaths(options);
+    const paths3 = resolvePaths(options);
     if (plan.harness !== "codex") {
       return { ok: false, error: `plan.harness=${String(plan.harness)} \u4E0D\u662F codex,\u62D2\u7EDD\u6267\u884C` };
     }
@@ -11823,38 +12057,38 @@ async function applyAction(plan, options) {
         error: "plan.writes \u4E0D\u662F\u672C adapter \u4EA7\u51FA\u7684\u5F62\u72B6(\u5E94\u6070\u4E3A\u4E00\u5904 modify),\u62D2\u7EDD\u6267\u884C"
       };
     }
-    const backupsRoot = join15(wingmanStateRoot(paths), "backups");
-    if (dirname10(plan.backupDir) !== backupsRoot) {
+    const backupsRoot = join17(wingmanStateRoot(paths3), "backups");
+    if (dirname11(plan.backupDir) !== backupsRoot) {
       return { ok: false, error: `backupDir \u4E0D\u5728 wingman \u5907\u4EFD\u6839(${backupsRoot})\u4E0B,\u62D2\u7EDD\u6267\u884C` };
     }
-    const currentRaw = readFileSync9(write.file);
+    const currentRaw = readFileSync10(write.file);
     if (!currentRaw.equals(Buffer.from(write.before, "utf8"))) {
       return { ok: false, error: `\u6587\u4EF6\u5728 plan \u4E4B\u540E\u88AB\u4FEE\u6539(${write.file}),\u62D2\u7EDD\u6267\u884C;\u8BF7\u91CD\u65B0 plan` };
     }
-    const resolved = resolveToggle(plan.action, paths);
+    const resolved = resolveToggle(plan.action, paths3);
     if (resolved.file !== write.file) {
       return { ok: false, error: "plan.writes \u7684\u76EE\u6807\u6587\u4EF6\u4E0E itemId \u5BF9\u4E0D\u4E0A,\u62D2\u7EDD\u6267\u884C" };
     }
     if (resolved.after !== write.after) {
       return { ok: false, error: "plan \u4E0E\u672C adapter \u7684\u63A8\u6F14\u4E0D\u4E00\u81F4,\u62D2\u7EDD\u6267\u884C;\u8BF7\u91CD\u65B0 plan" };
     }
-    mkdirSync6(plan.backupDir, { recursive: true });
-    writeFileSync7(join15(plan.backupDir, basename6(write.file)), currentRaw);
-    writeFileSync7(write.file, write.after);
+    mkdirSync7(plan.backupDir, { recursive: true });
+    writeFileSync8(join17(plan.backupDir, basename7(write.file)), currentRaw);
+    writeFileSync8(write.file, write.after);
     return { ok: true, backupDir: plan.backupDir };
   } catch (error) {
     return { ok: false, error: error.message };
   }
 }
-function nextBackupDir3(paths) {
+function nextBackupDir4(paths3) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  const base = join15(wingmanStateRoot(paths), "backups");
-  let dir = join15(base, stamp);
-  for (let n = 1; existsSync9(dir); n += 1)
-    dir = join15(base, `${stamp}-${n}`);
+  const base = join17(wingmanStateRoot(paths3), "backups");
+  let dir = join17(base, stamp);
+  for (let n = 1; existsSync10(dir); n += 1)
+    dir = join17(base, `${stamp}-${n}`);
   return dir;
 }
-function resolveToggle(action, paths) {
+function resolveToggle(action, paths3) {
   if (action.kind !== "toggle") {
     throw new Error(`\u672A\u77E5\u52A8\u4F5C\u79CD\u7C7B:${String(action.kind)}(v1 \u4EC5 toggle \u8D70 plan\u2192apply)`);
   }
@@ -11865,10 +12099,10 @@ function resolveToggle(action, paths) {
   const slot = m[1];
   const source = m[2];
   const nativeName = m[3];
-  const file = source === "user" ? join15(paths.codexHome, "config.toml") : join15(paths.projectDir, ".codex", "config.toml");
-  if (!existsSync9(file))
+  const file = source === "user" ? join17(paths3.codexHome, "config.toml") : join17(paths3.projectDir, ".codex", "config.toml");
+  if (!existsSync10(file))
     throw new Error(`itemId \u627E\u4E0D\u5230:\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728(${file})`);
-  const before = readFileSync9(file, "utf8");
+  const before = readFileSync10(file, "utf8");
   let table;
   try {
     table = parse3(before);
@@ -12089,15 +12323,15 @@ function verifyEdit(table, edit, file) {
     throw new Error(`\u7F16\u8F91\u7ED3\u679C\u4E0E\u671F\u671B\u7684\u6700\u5C0F\u53D8\u66F4\u4E0D\u4E00\u81F4,\u62D2\u7EDD\u5199\u5165(${file})`);
   }
 }
-function collectCorpus(paths) {
+function collectCorpus(paths3) {
   const candidates = [
-    join15(paths.codexHome, "AGENTS.md"),
-    join15(paths.projectDir, "AGENTS.md"),
-    join15(paths.codexHome, "config.toml"),
-    join15(paths.projectDir, ".codex", "config.toml"),
-    join15(paths.codexHome, "hooks.json"),
-    join15(paths.projectDir, ".codex", "hooks.json"),
-    ...listFilesRecursive(join15(paths.codexHome, "prompts"))
+    join17(paths3.codexHome, "AGENTS.md"),
+    join17(paths3.projectDir, "AGENTS.md"),
+    join17(paths3.codexHome, "config.toml"),
+    join17(paths3.projectDir, ".codex", "config.toml"),
+    join17(paths3.codexHome, "hooks.json"),
+    join17(paths3.projectDir, ".codex", "hooks.json"),
+    ...listFilesRecursive(join17(paths3.codexHome, "prompts"))
   ];
   const sources = [];
   for (const file of candidates) {
@@ -12107,7 +12341,7 @@ function collectCorpus(paths) {
     } catch {
       continue;
     }
-    sources.push({ file, text: readFileSync9(file, "utf8") });
+    sources.push({ file, text: readFileSync10(file, "utf8") });
   }
   return sources;
 }
@@ -12120,7 +12354,7 @@ function listFilesRecursive(dir) {
   }
   const files = [];
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const path = join15(dir, entry.name);
+    const path = join17(dir, entry.name);
     if (entry.isDirectory())
       files.push(...listFilesRecursive(path));
     else if (entry.isFile())
@@ -12187,17 +12421,17 @@ var init_actions2 = __esm({
 
 // packages/adapter-codex/dist/hooks.js
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync10, realpathSync, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename7, dirname as dirname11, join as join16 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync11, realpathSync, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { basename as basename8, dirname as dirname12, join as join18 } from "node:path";
 async function installHooks(port, options) {
   if (!Number.isInteger(port) || port <= 0 || port > 65535) {
     throw new Error(`\u975E\u6CD5\u7AEF\u53E3:${port}`);
   }
-  const paths = resolvePaths(options);
-  const root = wingmanStateRoot(paths);
-  const scriptPath = join16(root, FORWARD_SCRIPT_NAME);
-  const configPath = join16(paths.codexHome, "config.toml");
-  const raw = existsSync10(configPath) ? readFileSync10(configPath) : void 0;
+  const paths3 = resolvePaths(options);
+  const root = wingmanStateRoot(paths3);
+  const scriptPath = join18(root, FORWARD_SCRIPT_NAME);
+  const configPath = join18(paths3.codexHome, "config.toml");
+  const raw = existsSync11(configPath) ? readFileSync11(configPath) : void 0;
   const text = raw?.toString("utf8") ?? "";
   const { before, after, remainder, block } = splitManagedBlock(text, configPath);
   const lineEnding = preferredLineEnding(text);
@@ -12206,8 +12440,8 @@ async function installHooks(port, options) {
   if (block !== void 0 && knownBlock === void 0) {
     throw new Error(`Wingman Codex hook \u53D7\u7BA1\u5757\u5DF2\u88AB\u4FEE\u6539\u6216\u6B8B\u7F3A(${configPath}),\u62D2\u7EDD\u8C0E\u62A5\u63A5\u7EBF\u6210\u529F;\u8BF7\u5148\u4ECE <wingman\u6839>/backups/ \u6062\u590D\u5B8C\u6574\u5757,\u6216\u4EBA\u5DE5\u6838\u5BF9\u540E\u79FB\u9664\u8BE5\u53D7\u7BA1\u5757\u518D\u91CD\u65B0\u5B89\u88C5\u5E76\u4FE1\u4EFB`);
   }
-  mkdirSync7(root, { recursive: true });
-  writeFileSync8(scriptPath, FORWARD_SCRIPT);
+  mkdirSync8(root, { recursive: true });
+  writeFileSync9(scriptPath, FORWARD_SCRIPT);
   const statePath2 = hooksStatePath(root);
   const prior = readState5(statePath2);
   if (knownBlock !== void 0 && knownBlock.state === void 0) {
@@ -12236,7 +12470,7 @@ async function installHooks(port, options) {
       ...backupDir !== void 0 ? { backupDir } : {}
     });
     const state = hasStateOutsideBlock ? "" : knownBlock.state;
-    writeFileSync8(configPath, before + knownBlock.managedBlock + state + after);
+    writeFileSync9(configPath, before + knownBlock.managedBlock + state + after);
     return;
   }
   const original = prior?.original ?? (raw === void 0 ? { existed: false } : { existed: true, base64: raw.toString("base64") });
@@ -12252,17 +12486,17 @@ async function installHooks(port, options) {
   let base = remainder;
   if (base !== "" && !base.endsWith("\n"))
     base += lineEnding;
-  mkdirSync7(paths.codexHome, { recursive: true });
-  writeFileSync8(configPath, base + newBlock);
+  mkdirSync8(paths3.codexHome, { recursive: true });
+  writeFileSync9(configPath, base + newBlock);
 }
 async function uninstallHooks(options) {
-  const paths = resolvePaths(options);
-  const root = wingmanStateRoot(paths);
-  const scriptPath = join16(root, FORWARD_SCRIPT_NAME);
+  const paths3 = resolvePaths(options);
+  const root = wingmanStateRoot(paths3);
+  const scriptPath = join18(root, FORWARD_SCRIPT_NAME);
   const statePath2 = hooksStatePath(root);
-  const configPath = join16(paths.codexHome, "config.toml");
+  const configPath = join18(paths3.codexHome, "config.toml");
   const state = readState5(statePath2);
-  const raw = existsSync10(configPath) ? readFileSync10(configPath) : void 0;
+  const raw = existsSync11(configPath) ? readFileSync11(configPath) : void 0;
   if (raw !== void 0) {
     const text = raw.toString("utf8");
     const { before, after, remainder, block } = splitManagedBlock(text, configPath);
@@ -12275,34 +12509,34 @@ async function uninstallHooks(options) {
       const preservedState = hasHooksState(remainder) ? "" : knownBlock.state ?? "";
       const restored = restoreTarget(before + preservedState + after, state);
       if (restored === null)
-        rmSync5(configPath);
+        rmSync6(configPath);
       else
-        writeFileSync8(configPath, restored);
+        writeFileSync9(configPath, restored);
     }
   }
-  rmSync5(scriptPath, { force: true });
-  rmSync5(statePath2, { force: true });
+  rmSync6(scriptPath, { force: true });
+  rmSync6(statePath2, { force: true });
 }
-function hasManagedHooks2(paths) {
-  const configPath = join16(paths.codexHome, "config.toml");
-  if (!existsSync10(configPath))
+function hasManagedHooks2(paths3) {
+  const configPath = join18(paths3.codexHome, "config.toml");
+  if (!existsSync11(configPath))
     return false;
   try {
-    const { block } = splitManagedBlock(readFileSync10(configPath, "utf8"), configPath);
-    return block !== void 0 && inspectManagedBlock(block, join16(wingmanStateRoot(paths), FORWARD_SCRIPT_NAME)) !== void 0;
+    const { block } = splitManagedBlock(readFileSync11(configPath, "utf8"), configPath);
+    return block !== void 0 && inspectManagedBlock(block, join18(wingmanStateRoot(paths3), FORWARD_SCRIPT_NAME)) !== void 0;
   } catch {
     return false;
   }
 }
 function feedbackSignalsCodex(options) {
-  const paths = resolvePaths(options);
-  const configPath = join16(paths.codexHome, "config.toml");
+  const paths3 = resolvePaths(options);
+  const configPath = join18(paths3.codexHome, "config.toml");
   const wiredEvents = [];
-  if (existsSync10(configPath)) {
+  if (existsSync11(configPath)) {
     try {
-      const { block } = splitManagedBlock(readFileSync10(configPath, "utf8"), configPath);
+      const { block } = splitManagedBlock(readFileSync11(configPath, "utf8"), configPath);
       if (block !== void 0) {
-        const knownBlock = inspectManagedBlock(block, join16(wingmanStateRoot(paths), FORWARD_SCRIPT_NAME));
+        const knownBlock = inspectManagedBlock(block, join18(wingmanStateRoot(paths3), FORWARD_SCRIPT_NAME));
         const hooks = knownBlock === void 0 ? void 0 : parse3(normalizeLineEndings(knownBlock.managedBlock)).hooks;
         if (isTable(hooks)) {
           for (const [event, groups] of Object.entries(hooks)) {
@@ -12343,7 +12577,7 @@ function restoreTarget(remainder, state) {
 }
 function resolveNodeExecutable(probe = {}) {
   const execPath = probe.execPath ?? process.execPath;
-  const exists = probe.exists ?? existsSync10;
+  const exists = probe.exists ?? existsSync11;
   let executable = isNodeExecutable(execPath) ? execPath : void 0;
   if (executable === void 0) {
     const loginShellWhich = probe.loginShellWhich ?? defaultLoginShellWhich;
@@ -12390,13 +12624,13 @@ function defaultRealpath(path) {
   }
 }
 function defaultLoginShellWhich(shell) {
-  const result4 = spawnSync(shell, ["-lc", "command -v node"], {
+  const result5 = spawnSync(shell, ["-lc", "command -v node"], {
     encoding: "utf8",
     timeout: 3e3
   });
-  if (result4.error !== void 0)
+  if (result5.error !== void 0)
     return void 0;
-  return result4.stdout.trim() || void 0;
+  return result5.stdout.trim() || void 0;
 }
 function buildManagedBlock(scriptPath, nodeExecutable = "node") {
   return buildManagedBlockForCommand(`${nodeExecutable} "${scriptPath}"`);
@@ -12548,28 +12782,28 @@ function hasHooksState(text) {
 }
 function backupFile(root, filePath, contents) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  let dir = join16(root, "backups", stamp);
-  for (let n = 1; existsSync10(dir); n += 1)
-    dir = join16(root, "backups", `${stamp}-${n}`);
-  mkdirSync7(dir, { recursive: true });
-  writeFileSync8(join16(dir, basename7(filePath)), contents);
+  let dir = join18(root, "backups", stamp);
+  for (let n = 1; existsSync11(dir); n += 1)
+    dir = join18(root, "backups", `${stamp}-${n}`);
+  mkdirSync8(dir, { recursive: true });
+  writeFileSync9(join18(dir, basename8(filePath)), contents);
   return dir;
 }
 function hooksStatePath(root) {
-  return join16(root, "state", "codex-hooks.json");
+  return join18(root, "state", "codex-hooks.json");
 }
 function readState5(statePath2) {
-  if (!existsSync10(statePath2))
+  if (!existsSync11(statePath2))
     return void 0;
   try {
-    return JSON.parse(readFileSync10(statePath2, "utf8"));
+    return JSON.parse(readFileSync11(statePath2, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writeState5(statePath2, state) {
-  mkdirSync7(dirname11(statePath2), { recursive: true });
-  writeFileSync8(statePath2, `${JSON.stringify(state, null, 2)}
+  mkdirSync8(dirname12(statePath2), { recursive: true });
+  writeFileSync9(statePath2, `${JSON.stringify(state, null, 2)}
 `);
 }
 function deepEqual3(a, b) {
@@ -12725,15 +12959,15 @@ process.stdin.on('end', async () => {
 });
 
 // packages/adapter-codex/dist/scan.js
-import { existsSync as existsSync11, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync4 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute3, join as join17, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync4 } from "node:fs";
+import { dirname as dirname13, isAbsolute as isAbsolute3, join as join19, resolve as resolve7 } from "node:path";
 async function detect(options) {
   const { codexHome } = resolvePaths(options);
-  return { installed: existsSync11(codexHome) };
+  return { installed: existsSync12(codexHome) };
 }
 async function scan(options) {
-  const paths = resolvePaths(options);
-  const layers = loadConfigLayers(paths);
+  const paths3 = resolvePaths(options);
+  const layers = loadConfigLayers(paths3);
   const slots = {
     base: [],
     rules: [],
@@ -12742,14 +12976,14 @@ async function scan(options) {
     gates: [],
     history: []
   };
-  collectRules(slots.rules, paths, layers);
+  collectRules(slots.rules, paths3, layers);
   for (const layer of layers) {
     collectBase(slots.base, layer);
     collectSkills(slots.skills, layer);
     collectTools(slots.tools, layer);
     collectGates(slots.gates, layer);
   }
-  collectHistory(slots.history, paths, layers);
+  collectHistory(slots.history, paths3, layers);
   assertUniqueIds(slots);
   return {
     harness: "codex",
@@ -12759,21 +12993,21 @@ async function scan(options) {
     // actions:M3 起 toggle(plan→apply)/scan_references(命中随 plan)已落地;
     // open_editor 是面板用 nativePath 跳转的即时动作,无需 adapter 方法
     capabilities: {
-      live: hasManagedHooks2(paths) ? "push" : "none",
+      live: hasManagedHooks2(paths3) ? "push" : "none",
       actions: ["toggle", "open_editor", "scan_references"]
     }
   };
 }
-function loadConfigLayers(paths) {
+function loadConfigLayers(paths3) {
   const candidates = [
-    ["user", join17(paths.codexHome, "config.toml")],
-    ["project", join17(paths.projectDir, ".codex", "config.toml")]
+    ["user", join19(paths3.codexHome, "config.toml")],
+    ["project", join19(paths3.projectDir, ".codex", "config.toml")]
   ];
   const layers = [];
   for (const [source, path] of candidates) {
     if (fileSize(path) === void 0)
       continue;
-    const text = readFileSync11(path, "utf8");
+    const text = readFileSync12(path, "utf8");
     try {
       layers.push({ source, path, table: parse3(text) });
     } catch (error) {
@@ -12782,10 +13016,10 @@ function loadConfigLayers(paths) {
   }
   return layers;
 }
-function collectRules(out, paths, layers) {
+function collectRules(out, paths3, layers) {
   const agentsChain = [
-    ["user", join17(paths.codexHome, "AGENTS.md")],
-    ["project", join17(paths.projectDir, "AGENTS.md")]
+    ["user", join19(paths3.codexHome, "AGENTS.md")],
+    ["project", join19(paths3.projectDir, "AGENTS.md")]
   ];
   for (const [source, file] of agentsChain) {
     const size = fileSize(file);
@@ -12820,7 +13054,7 @@ function collectRules(out, paths, layers) {
     }
     const instructionsFile = layer.table.model_instructions_file;
     if (typeof instructionsFile === "string") {
-      const filePath = isAbsolute3(instructionsFile) ? instructionsFile : resolve6(dirname12(layer.path), instructionsFile);
+      const filePath = isAbsolute3(instructionsFile) ? instructionsFile : resolve7(dirname13(layer.path), instructionsFile);
       const item = {
         id: `codex:rules:${layer.source}:model_instructions_file`,
         slot: "rules",
@@ -12919,8 +13153,8 @@ function collectGates(out, layer) {
     });
   }
 }
-function collectHistory(out, paths, layers) {
-  const historyFile = join17(paths.codexHome, "history.jsonl");
+function collectHistory(out, paths3, layers) {
+  const historyFile = join19(paths3.codexHome, "history.jsonl");
   const historyBytes = fileSize(historyFile);
   if (historyBytes !== void 0) {
     out.push({
@@ -12935,7 +13169,7 @@ function collectHistory(out, paths, layers) {
     });
   }
   const configured = layers.find((layer) => layer.source === "user")?.table.log_dir;
-  const logDir = typeof configured === "string" ? expandPath(configured, paths) : join17(paths.codexHome, "log");
+  const logDir = typeof configured === "string" ? expandPath(configured, paths3) : join19(paths3.codexHome, "log");
   if (isDirectory(logDir)) {
     out.push({
       id: "codex:history:user:log_dir",
@@ -12949,10 +13183,10 @@ function collectHistory(out, paths, layers) {
     });
   }
 }
-function expandPath(value, paths) {
+function expandPath(value, paths3) {
   if (value === "~" || value.startsWith("~/"))
-    return join17(paths.homeDir, value.slice(2));
-  return isAbsolute3(value) ? value : resolve6(paths.codexHome, value);
+    return join19(paths3.homeDir, value.slice(2));
+  return isAbsolute3(value) ? value : resolve7(paths3.codexHome, value);
 }
 function assertUniqueIds(slots) {
   const seen = /* @__PURE__ */ new Set();
@@ -12983,7 +13217,7 @@ function isDirectory(path) {
 function directoryBytes(dir) {
   let total = 0;
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const entryPath = join17(dir, entry.name);
+    const entryPath = join19(dir, entry.name);
     if (entry.isDirectory())
       total += directoryBytes(entryPath);
     else if (entry.isFile())
@@ -13005,54 +13239,54 @@ var init_scan2 = __esm({
 });
 
 // packages/adapter-codex/dist/protocol.js
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { basename as basename8, dirname as dirname13, join as join18, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename9, dirname as dirname14, join as join20, resolve as resolve8 } from "node:path";
 function protocolStatusCodex(options) {
-  const paths = resolveOptions3(options);
-  if (!existsSync12(paths.targetPath))
-    return status2(paths.targetPath, "not_installed");
+  const paths3 = resolveOptions3(options);
+  if (!existsSync13(paths3.targetPath))
+    return status2(paths3.targetPath, "not_installed");
   try {
-    const file = readAgents2(paths.targetPath);
+    const file = readAgents2(paths3.targetPath);
     if (file.identity === void 0)
-      return status2(paths.targetPath, "not_installed");
+      return status2(paths3.targetPath, "not_installed");
     const state = stateForIdentity3(file.identity);
-    return status2(paths.targetPath, state, file.identity);
+    return status2(paths3.targetPath, state, file.identity);
   } catch (error) {
-    return status2(paths.targetPath, "invalid", void 0, error.message);
+    return status2(paths3.targetPath, "invalid", void 0, error.message);
   }
 }
 function installProtocolCodex(options) {
-  const paths = resolveOptions3(options);
-  const existing = existsSync12(paths.targetPath) ? readAgents2(paths.targetPath) : void 0;
+  const paths3 = resolveOptions3(options);
+  const existing = existsSync13(paths3.targetPath) ? readAgents2(paths3.targetPath) : void 0;
   const previousState = stateForIdentity3(existing?.identity);
   if (previousState === "installed") {
-    return result3(paths.targetPath, "install", false, previousState, existing?.text ?? "", true);
+    return result4(paths3.targetPath, "install", false, previousState, existing?.text ?? "", true);
   }
   if (previousState === "modified")
-    throw modifiedError3(paths.targetPath, "\u5B89\u88C5");
+    throw modifiedError3(paths3.targetPath, "\u5B89\u88C5");
   const before = existing?.text ?? "";
   const lineEnding = preferredMarkdownLineEnding(before);
   const block = buildPlanProtocolBlock().replaceAll("\n", lineEnding);
   const after = existing?.split.block ? existing.split.before + block + existing.split.after : appendBlock2(before, block, lineEnding);
-  const installedRemainder = splitPlanProtocolBlock(after, paths.targetPath).remainder;
-  const backupDir = nextBackupDir4(paths.homeDir);
-  if (!paths.dryRun) {
-    const prior = readState6(paths.statePath, paths.targetPath);
-    backupTarget3(backupDir, paths.targetPath, existing?.bytes);
-    writeState6(paths.statePath, {
+  const installedRemainder = splitPlanProtocolBlock(after, paths3.targetPath).remainder;
+  const backupDir = nextBackupDir5(paths3.homeDir);
+  if (!paths3.dryRun) {
+    const prior = readState6(paths3.statePath, paths3.targetPath);
+    backupTarget4(backupDir, paths3.targetPath, existing?.bytes);
+    writeState6(paths3.statePath, {
       version: 1,
-      projectDir: paths.projectDir,
-      targetPath: paths.targetPath,
+      projectDir: paths3.projectDir,
+      targetPath: paths3.targetPath,
       protocolVersion: PLAN_PROTOCOL_VERSION,
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
       backupDir,
-      installedRemainderSha256: sha256Hex(installedRemainder),
+      installedRemainderSha256: previousState === "outdated" && prior !== void 0 ? prior.installedRemainderSha256 : sha256Hex(installedRemainder),
       original: prior?.original ?? (existing === void 0 ? { existed: false } : { existed: true, base64: existing.bytes.toString("base64") })
     });
-    writeFileSync9(paths.targetPath, after);
+    writeFileSync10(paths3.targetPath, after);
   }
   return {
-    ...result3(paths.targetPath, "install", true, previousState, before, true),
+    ...result4(paths3.targetPath, "install", true, previousState, before, true),
     state: "installed",
     version: PLAN_PROTOCOL_VERSION,
     after,
@@ -13061,33 +13295,33 @@ function installProtocolCodex(options) {
   };
 }
 function uninstallProtocolCodex(options) {
-  const paths = resolveOptions3(options);
-  if (!existsSync12(paths.targetPath)) {
-    return result3(paths.targetPath, "uninstall", false, "not_installed", "", false);
+  const paths3 = resolveOptions3(options);
+  if (!existsSync13(paths3.targetPath)) {
+    return result4(paths3.targetPath, "uninstall", false, "not_installed", "", false);
   }
-  const existing = readAgents2(paths.targetPath);
+  const existing = readAgents2(paths3.targetPath);
   if (existing.identity === void 0) {
-    return result3(paths.targetPath, "uninstall", false, "not_installed", existing.text, true);
+    return result4(paths3.targetPath, "uninstall", false, "not_installed", existing.text, true);
   }
   const previousState = stateForIdentity3(existing.identity);
   if (previousState === "modified")
-    throw modifiedError3(paths.targetPath, "\u5378\u8F7D");
-  const state = readState6(paths.statePath, paths.targetPath);
+    throw modifiedError3(paths3.targetPath, "\u5378\u8F7D");
+  const state = readState6(paths3.statePath, paths3.targetPath);
   const canRestore = state !== void 0 && sha256Hex(existing.split.remainder) === state.installedRemainderSha256;
   const restored = canRestore ? originalBytes2(state) : void 0;
   const deleteTarget = canRestore ? state?.original.existed === false : existing.split.remainder.trim() === "";
   const after = deleteTarget ? "" : restored?.toString("utf8") ?? existing.split.remainder;
-  const backupDir = nextBackupDir4(paths.homeDir);
-  if (!paths.dryRun) {
-    backupTarget3(backupDir, paths.targetPath, existing.bytes);
+  const backupDir = nextBackupDir5(paths3.homeDir);
+  if (!paths3.dryRun) {
+    backupTarget4(backupDir, paths3.targetPath, existing.bytes);
     if (deleteTarget)
-      rmSync6(paths.targetPath, { force: true });
+      rmSync7(paths3.targetPath, { force: true });
     else
-      writeFileSync9(paths.targetPath, restored ?? existing.split.remainder);
-    rmSync6(paths.statePath, { force: true });
+      writeFileSync10(paths3.targetPath, restored ?? existing.split.remainder);
+    rmSync7(paths3.statePath, { force: true });
   }
   return {
-    ...result3(paths.targetPath, "uninstall", true, previousState, existing.text, !deleteTarget),
+    ...result4(paths3.targetPath, "uninstall", true, previousState, existing.text, !deleteTarget),
     state: "not_installed",
     message: canRestore ? SHARED_MESSAGE2 : `${SHARED_MESSAGE2}\uFF1B\u5DF2\u79FB\u9664\u5757\u5E76\u4FDD\u7559\u7528\u6237\u6539\u52A8`,
     after,
@@ -13098,15 +13332,16 @@ function uninstallProtocolCodex(options) {
 }
 function resolveOptions3(options) {
   const base = resolvePaths(options);
-  const homeDir = resolve7(base.homeDir);
-  const projectDir = resolve7(base.projectDir);
-  const targetPath2 = join18(projectDir, "AGENTS.md");
-  const statePath2 = join18(wingmanStateRoot({ ...base, homeDir, projectDir }), "state", `plan-protocol-agents-${sha256Hex(projectDir)}.json`);
+  const homeDir = resolve8(base.homeDir);
+  const projectDir = resolve8(base.projectDir);
+  const targetPath2 = join20(projectDir, "AGENTS.md");
+  const statePath2 = join20(wingmanStateRoot({ ...base, homeDir, projectDir }), "state", `plan-protocol-agents-${sha256Hex(projectDir)}.json`);
   return { homeDir, projectDir, targetPath: targetPath2, statePath: statePath2, dryRun: options?.dryRun ?? false };
 }
 function readAgents2(targetPath2) {
-  const bytes = readFileSync12(targetPath2);
-  const text = decodeUtf8Strict2(bytes, targetPath2);
+  const bytes = readFileSync13(targetPath2);
+  decodeUtf8Strict2(bytes, targetPath2);
+  const text = bytes.toString("utf8");
   let split;
   try {
     split = splitPlanProtocolBlock(text, targetPath2);
@@ -13135,7 +13370,7 @@ function stateForIdentity3(identity) {
     return "not_installed";
   if (identity.kind === "current")
     return "installed";
-  if (identity.kind === "legacy")
+  if (identity.kind === "outdated")
     return "outdated";
   return "modified";
 }
@@ -13150,7 +13385,7 @@ function status2(targetPath2, state, identity, reason) {
     ...reason !== void 0 ? { reason } : {}
   };
 }
-function result3(targetPath2, operation, changed, previousState, before, afterExists) {
+function result4(targetPath2, operation, changed, previousState, before, afterExists) {
   return {
     ...status2(targetPath2, previousState),
     operation,
@@ -13166,32 +13401,32 @@ function result3(targetPath2, operation, changed, previousState, before, afterEx
 function modifiedError3(targetPath2, operation) {
   return new Error(`${targetPath2}: \u53D7\u7BA1\u5757\u5DF2\u88AB\u4FEE\u6539\uFF0C\u62D2\u7EDD${operation}\u5E76\u4FDD\u7559\u7528\u6237\u5185\u5BB9`);
 }
-function nextBackupDir4(homeDir) {
+function nextBackupDir5(homeDir) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
-  const root = join18(homeDir, ".wingman", "backups");
-  let dir = join18(root, stamp);
-  for (let n = 2; existsSync12(dir); n += 1)
-    dir = join18(root, `${stamp}-${n}`);
+  const root = join20(homeDir, ".wingman", "backups");
+  let dir = join20(root, stamp);
+  for (let n = 2; existsSync13(dir); n += 1)
+    dir = join20(root, `${stamp}-${n}`);
   return dir;
 }
-function backupTarget3(backupDir, targetPath2, bytes) {
-  mkdirSync8(backupDir, { recursive: true });
+function backupTarget4(backupDir, targetPath2, bytes) {
+  mkdirSync9(backupDir, { recursive: true });
   if (bytes !== void 0)
-    writeFileSync9(join18(backupDir, basename8(targetPath2)), bytes);
+    writeFileSync10(join20(backupDir, basename9(targetPath2)), bytes);
 }
 function readState6(statePath2, targetPath2) {
-  if (!existsSync12(statePath2))
+  if (!existsSync13(statePath2))
     return void 0;
   try {
-    const value = JSON.parse(readFileSync12(statePath2, "utf8"));
+    const value = JSON.parse(readFileSync13(statePath2, "utf8"));
     return value.version === 1 && value.targetPath === targetPath2 ? value : void 0;
   } catch {
     return void 0;
   }
 }
 function writeState6(statePath2, state) {
-  mkdirSync8(dirname13(statePath2), { recursive: true });
-  writeFileSync9(statePath2, `${JSON.stringify(state, null, 2)}
+  mkdirSync9(dirname14(statePath2), { recursive: true });
+  writeFileSync10(statePath2, `${JSON.stringify(state, null, 2)}
 `);
 }
 function originalBytes2(state) {
@@ -13207,6 +13442,33 @@ var init_protocol3 = __esm({
   }
 });
 
+// packages/adapter-codex/dist/protocol-user.js
+import { homedir as homedir12 } from "node:os";
+import { join as join21, resolve as resolve9 } from "node:path";
+function paths2(options) {
+  const homeDir = resolve9(options?.homeDir ?? homedir12());
+  return {
+    homeDir,
+    targetPath: join21(homeDir, ".codex", "AGENTS.md"),
+    dryRun: options?.dryRun ?? false
+  };
+}
+function protocolStatusCodexUser(options) {
+  return { harness: "codex", ...statusPlanProtocolUser(paths2(options).targetPath) };
+}
+function installProtocolCodexUser(options) {
+  return { harness: "codex", ...installPlanProtocolUser(paths2(options)) };
+}
+function uninstallProtocolCodexUser(options) {
+  return { harness: "codex", ...uninstallPlanProtocolUser(paths2(options)) };
+}
+var init_protocol_user2 = __esm({
+  "packages/adapter-codex/dist/protocol-user.js"() {
+    "use strict";
+    init_dist();
+  }
+});
+
 // packages/adapter-codex/dist/index.js
 var dist_exports3 = {};
 __export(dist_exports3, {
@@ -13214,9 +13476,12 @@ __export(dist_exports3, {
   createAdapter: () => createAdapter3,
   feedbackSignals: () => feedbackSignalsCodex,
   installProtocolCodex: () => installProtocolCodex,
+  installProtocolCodexUser: () => installProtocolCodexUser,
   protocolStatusCodex: () => protocolStatusCodex,
+  protocolStatusCodexUser: () => protocolStatusCodexUser,
   resolveNodeExecutable: () => resolveNodeExecutable,
-  uninstallProtocolCodex: () => uninstallProtocolCodex
+  uninstallProtocolCodex: () => uninstallProtocolCodex,
+  uninstallProtocolCodexUser: () => uninstallProtocolCodexUser
 });
 function createAdapter3(_options) {
   return {
@@ -13237,23 +13502,24 @@ var init_dist5 = __esm({
     init_scan2();
     init_hooks3();
     init_protocol3();
+    init_protocol_user2();
   }
 });
 
 // apps/cli/dist/main.js
 init_dist2();
 init_dist();
-import { readFileSync as readFileSync18 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname19, resolve as resolve12 } from "node:path";
+import { readFileSync as readFileSync19 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { dirname as dirname20, resolve as resolve14 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/fixtures/dist/index.js
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname5, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
-var fixturesRoot = join5(dirname4(dirname4(fileURLToPath(import.meta.url))), "data");
+var fixturesRoot = join6(dirname5(dirname5(fileURLToPath(import.meta.url))), "data");
 function fixturePath(...segments) {
-  return join5(fixturesRoot, ...segments);
+  return join6(fixturesRoot, ...segments);
 }
 
 // packages/live/dist/receiver.js
@@ -13373,7 +13639,7 @@ function isHookPayload(value) {
 }
 var HOOK_BODY_LIMIT = 1024 * 1024;
 function readBody(req) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve15, reject) => {
     const chunks = [];
     let size = 0;
     req.on("data", (chunk) => {
@@ -13385,7 +13651,7 @@ function readBody(req) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve13(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve15(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -13400,9 +13666,9 @@ function sendText(res, status3, body) {
 
 // apps/cli/dist/license.js
 import { verify } from "node:crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var OFFLINE_GRACE_DAYS = 14;
 var PROD_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAyU4yO0SJcflt/CV77wqVxIwCkM52CYGC6qrPGP8dMME=\n-----END PUBLIC KEY-----\n";
 function checkLicense(options = {}) {
@@ -13416,7 +13682,7 @@ function licenseStatus(options = {}) {
   const home = options.homeDir ?? homedir3();
   let raw;
   try {
-    raw = readFileSync2(join6(home, ".wingman", "license.json"), "utf8");
+    raw = readFileSync3(join7(home, ".wingman", "license.json"), "utf8");
   } catch {
     return { state: "none", detail: "\u672A\u5B89\u88C5 license(anatomy \u4E0E\u5B9E\u51B5\u514D\u8D39\u53EF\u7528;\u5199\u52A8\u4F5C\u9700\u8BA2\u9605)" };
   }
@@ -13483,7 +13749,7 @@ function verifyEntitlement(raw, now, publicKeyPem) {
 function nextLicenseBackupPath(licensePath, now) {
   const base = `${licensePath}.bak-${now.toISOString().replaceAll(":", "-")}`;
   let candidate = base;
-  for (let index = 2; existsSync3(candidate); index++)
+  for (let index = 2; existsSync4(candidate); index++)
     candidate = `${base}-${index}`;
   return candidate;
 }
@@ -13504,13 +13770,13 @@ function installLicense(raw, options = {}) {
       return { ok: false, error: status3.detail };
     }
   }
-  const dir = join6(options.homeDir ?? homedir3(), ".wingman");
-  const licensePath = join6(dir, "license.json");
-  const tmpPath = join6(dir, `.license.json.tmp-${process.pid}`);
+  const dir = join7(options.homeDir ?? homedir3(), ".wingman");
+  const licensePath = join7(dir, "license.json");
+  const tmpPath = join7(dir, `.license.json.tmp-${process.pid}`);
   try {
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync2(tmpPath, raw);
-    if (existsSync3(licensePath)) {
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync3(tmpPath, raw);
+    if (existsSync4(licensePath)) {
       renameSync(licensePath, nextLicenseBackupPath(licensePath, options.now ?? /* @__PURE__ */ new Date()));
     }
     renameSync(tmpPath, licensePath);
@@ -13522,17 +13788,17 @@ function installLicense(raw, options = {}) {
 }
 
 // apps/cli/dist/license-refresh.js
-import { copyFileSync, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { copyFileSync, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { dirname as dirname6, join as join8 } from "node:path";
 var DEFAULT_LICENSE_SERVER = "https://api.getwingman.dev";
 async function refreshLicense(options = {}) {
   const home = options.homeDir ?? homedir4();
   const baseUrl = options.baseUrl ?? process.env.WINGMAN_LICENSE_SERVER ?? DEFAULT_LICENSE_SERVER;
-  const licensePath = join7(home, ".wingman", "license.json");
+  const licensePath = join8(home, ".wingman", "license.json");
   let raw;
   try {
-    raw = readFileSync3(licensePath, "utf8");
+    raw = readFileSync4(licensePath, "utf8");
   } catch {
     return {
       ok: false,
@@ -13602,7 +13868,7 @@ async function refreshLicense(options = {}) {
     }
   }
   try {
-    if (readFileSync3(licensePath, "utf8") !== raw) {
+    if (readFileSync4(licensePath, "utf8") !== raw) {
       return {
         ok: false,
         message: "\u5237\u65B0\u671F\u95F4\u672C\u673A\u6388\u6743\u5DF2\u88AB\u66F4\u6362;\u5DF2\u4FDD\u7559\u8F83\u65B0\u7684\u6587\u4EF6,\u8BF7\u518D\u70B9\u4E00\u6B21\u5237\u65B0",
@@ -13616,9 +13882,9 @@ async function refreshLicense(options = {}) {
       reason: "changed"
     };
   }
-  const tmpPath = join7(dirname5(licensePath), `.license.json.tmp-${process.pid}`);
+  const tmpPath = join8(dirname6(licensePath), `.license.json.tmp-${process.pid}`);
   try {
-    writeFileSync3(tmpPath, next);
+    writeFileSync4(tmpPath, next);
     copyFileSync(licensePath, nextLicenseBackupPath(licensePath, options.now ?? /* @__PURE__ */ new Date()));
     renameSync2(tmpPath, licensePath);
   } catch (error) {
@@ -13646,7 +13912,7 @@ init_dist5();
 init_dist2();
 init_dist();
 import { readdir as readdir2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, join as join22, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join25, resolve as resolve11 } from "node:path";
 
 // packages/narrative/dist/attribute.js
 function extractSteps(lines2) {
@@ -13671,13 +13937,13 @@ function extractSteps(lines2) {
         byToolUseId.set(block.id, step);
       }
     } else if (line.kind === "user") {
-      for (const result4 of line.toolResults) {
-        const step = byToolUseId.get(result4.toolUseId);
+      for (const result5 of line.toolResults) {
+        const step = byToolUseId.get(result5.toolUseId);
         if (step === void 0)
           continue;
         if (line.timestamp !== void 0)
           step.endTs = line.timestamp;
-        if (result4.isError)
+        if (result5.isError)
           step.isError = true;
       }
     }
@@ -13849,17 +14115,17 @@ function parseResponseItem(payload, timestamp) {
     return call;
   }
   if (payload !== void 0 && (payloadType === "function_call_output" || payloadType === "custom_tool_call_output")) {
-    const result4 = { kind: "tool_result", resultType: payloadType };
-    assignString(result4, "timestamp", timestamp);
-    assignString(result4, "callId", optionalString(payload.call_id));
-    assignString(result4, "itemId", optionalString(payload.id));
-    assignString(result4, "turnId", extractTurnId(payload));
+    const result5 = { kind: "tool_result", resultType: payloadType };
+    assignString(result5, "timestamp", timestamp);
+    assignString(result5, "callId", optionalString(payload.call_id));
+    assignString(result5, "itemId", optionalString(payload.id));
+    assignString(result5, "turnId", extractTurnId(payload));
     if (payload.output !== void 0) {
-      result4.output = payload.output;
+      result5.output = payload.output;
       if (codexToolResultIsError(payload.output))
-        result4.isError = true;
+        result5.isError = true;
     }
-    return result4;
+    return result5;
   }
   return otherLine("response_item", payload, timestamp);
 }
@@ -14041,13 +14307,13 @@ function parseUser(raw, common) {
       if (!isRecord3(block))
         continue;
       if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
-        const result4 = {
+        const result5 = {
           toolUseId: block.tool_use_id,
           // 实测:成功结果常无 is_error 字段;仅显式 true 视为失败
           isError: block.is_error === true,
           content: block.content
         };
-        line.toolResults.push(result4);
+        line.toolResults.push(result5);
       } else if (block.type === "text" && typeof block.text === "string") {
         texts.push(block.text);
       }
@@ -14570,11 +14836,11 @@ function buildTaskCreateResultIndex(lines2) {
   for (const line of lines2) {
     if (line.kind !== "user")
       continue;
-    const result4 = line.toolUseResult;
-    if (!isRecord3(result4) || !isRecord3(result4.task) || typeof result4.task.id !== "string")
+    const result5 = line.toolUseResult;
+    if (!isRecord3(result5) || !isRecord3(result5.task) || typeof result5.task.id !== "string")
       continue;
     for (const toolResult of line.toolResults)
-      index.set(toolResult.toolUseId, result4.task.id);
+      index.set(toolResult.toolUseId, result5.task.id);
   }
   return index;
 }
@@ -14708,7 +14974,7 @@ function turnUsage(line) {
   if (inputTokens === void 0 || cacheCreationInputTokens === void 0 || cacheReadInputTokens === void 0 || outputTokens === void 0) {
     return void 0;
   }
-  const result4 = {
+  const result5 = {
     inputTokens,
     cacheCreationInputTokens,
     cacheReadInputTokens,
@@ -14723,11 +14989,11 @@ function turnUsage(line) {
     const fiveMinute = finiteNumber(breakdown.ephemeral_5m_input_tokens);
     const oneHour = finiteNumber(breakdown.ephemeral_1h_input_tokens);
     if (fiveMinute !== void 0)
-      result4.cacheCreation5mTokens = fiveMinute;
+      result5.cacheCreation5mTokens = fiveMinute;
     if (oneHour !== void 0)
-      result4.cacheCreation1hTokens = oneHour;
+      result5.cacheCreation1hTokens = oneHour;
   }
-  return result4;
+  return result5;
 }
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -15101,9 +15367,9 @@ function fromTool(harness, name, input, source, at) {
     return [];
   if (harness === "codex" && name === "exec") {
     const inputText = toolText(input, ["input"]);
-    const paths = codexExecPatchPaths(inputText);
-    if (paths.length > 0) {
-      return paths.map((path) => fileObservation(path, "codex apply_patch via exec", source, false, at));
+    const paths3 = codexExecPatchPaths(inputText);
+    if (paths3.length > 0) {
+      return paths3.map((path) => fileObservation(path, "codex apply_patch via exec", source, false, at));
     }
   }
   if (name === "Bash" || name === "exec") {
@@ -15145,13 +15411,13 @@ function fileObservation(path, method, source, wholeFile, at) {
 function patchPaths(patch) {
   if (patch === void 0)
     return [];
-  const paths = [];
+  const paths3 = [];
   for (const line of patch.split("\n")) {
     const match = /^\*\*\* (?:Update|Add) File: (.+?)\s*$/u.exec(line);
     if (match?.[1] !== void 0 && isPlanPath(match[1]))
-      paths.push(match[1]);
+      paths3.push(match[1]);
   }
-  return paths;
+  return paths3;
 }
 function codexExecPatchPaths(input) {
   if (input === void 0 || !input.includes("*** Begin Patch"))
@@ -15212,22 +15478,29 @@ function isRecord5(value) {
 
 // apps/cli/dist/project-index.js
 import { lstat, readFile as readFile3, realpath, stat as stat3 } from "node:fs/promises";
-import { dirname as dirname14, isAbsolute as isAbsolute4, join as join19, relative as relative3, resolve as resolve8 } from "node:path";
+import { dirname as dirname15, isAbsolute as isAbsolute4, join as join22, relative as relative3, resolve as resolve10 } from "node:path";
 var PROJECT_ROOT_MAX_DIRECTORIES = 8;
 var PROJECT_PLAN_POLL_MS = 2e3;
 async function resolveProjectRoot(cwd, options) {
-  const root = resolve8(cwd);
-  const homeDir = resolve8(options.homeDir);
-  const boundaryDir = options.boundaryDir === void 0 ? void 0 : resolve8(options.boundaryDir);
+  const root = resolve10(cwd);
+  const homeDir = resolve10(options.homeDir);
+  const boundaryDir = options.boundaryDir === void 0 ? void 0 : resolve10(options.boundaryDir);
   const [rootIdentity, homeIdentity, boundaryIdentity] = await Promise.all([
     pathIdentity(root),
     pathIdentity(homeDir),
     boundaryDir === void 0 ? void 0 : pathIdentity(boundaryDir)
   ]);
-  const wingmanHomeIdentity = await pathIdentity(join19(homeIdentity, ".wingman"));
-  const planPathIdentity = await pathIdentity(join19(rootIdentity, ".wingman", "plan.md"));
+  const wingmanHomeIdentity = await pathIdentity(join22(homeIdentity, ".wingman"));
+  const planPathIdentity = await pathIdentity(join22(rootIdentity, ".wingman", "plan.md"));
   if (rootIdentity === homeIdentity || rootIdentity === wingmanHomeIdentity || boundaryIdentity !== void 0 && !isWithin(boundaryIdentity, rootIdentity)) {
-    return { root, rootIdentity, planPathIdentity, lookedUp: [], higherPlanPaths: [] };
+    return {
+      root,
+      rootIdentity,
+      planPathIdentity,
+      lookedUp: [],
+      higherPlanPaths: [],
+      ...rootIdentity === homeIdentity ? { isHome: true } : {}
+    };
   }
   const lookedUp = [];
   const found = [];
@@ -15239,7 +15512,7 @@ async function resolveProjectRoot(cwd, options) {
       break;
     if (boundaryIdentity !== void 0 && !isWithin(boundaryIdentity, currentIdentity))
       break;
-    const planPath = join19(current, ".wingman", "plan.md");
+    const planPath = join22(current, ".wingman", "plan.md");
     lookedUp.push(planPath);
     try {
       await lstat(planPath);
@@ -15251,7 +15524,7 @@ async function resolveProjectRoot(cwd, options) {
       });
     } catch {
     }
-    const parent = dirname14(current);
+    const parent = dirname15(current);
     if (parent === current)
       break;
     current = parent;
@@ -15329,7 +15602,7 @@ function watchProjectPlan(planPath, options) {
   };
 }
 async function pathIdentity(path) {
-  const resolved = resolve8(path);
+  const resolved = resolve10(path);
   try {
     return normalizedPath(await realpath(resolved));
   } catch {
@@ -15344,7 +15617,7 @@ async function pathsReferToSameLocation(left, right) {
   return relative3(leftIdentity, rightIdentity) === "";
 }
 function normalizedPath(path) {
-  const resolved = resolve8(path);
+  const resolved = resolve10(path);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function isWithin(parent, child) {
@@ -15354,17 +15627,17 @@ function isWithin(parent, child) {
 
 // apps/cli/dist/project-roots.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync13, renameSync as renameSync3, rmSync as rmSync7, statSync as statSync5, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname15, isAbsolute as isAbsolute5, join as join20 } from "node:path";
+import { closeSync, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync14, renameSync as renameSync3, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname16, isAbsolute as isAbsolute5, join as join23 } from "node:path";
 var PROJECT_ROOTS_MAX_ENTRIES = 200;
 function projectRootsPath(homeDir) {
-  return join20(homeDir, ".wingman", "state", "projects.json");
+  return join23(homeDir, ".wingman", "state", "projects.json");
 }
 function readProjectRoots(homeDir) {
   const path = projectRootsPath(homeDir);
   let raw;
   try {
-    raw = readFileSync13(path, "utf8");
+    raw = readFileSync14(path, "utf8");
   } catch (error) {
     if (isErrno(error, "ENOENT"))
       return { version: 1, roots: {} };
@@ -15404,7 +15677,7 @@ function pruneProjectRoots(homeDir) {
     return current;
   const roots = Object.fromEntries(Object.entries(current.roots).filter(([, entry]) => {
     try {
-      statSync5(join20(entry.root, ".wingman", "plan.md"));
+      statSync5(join23(entry.root, ".wingman", "plan.md"));
       return true;
     } catch (error) {
       return !isErrno(error, "ENOENT") && !isErrno(error, "ENOTDIR");
@@ -15428,12 +15701,12 @@ function limitRoots(roots) {
 }
 function writeProjectRoots(homeDir, state) {
   const path = projectRootsPath(homeDir);
-  const tempPath = join20(dirname15(path), `.projects-${randomBytes2(8).toString("hex")}.tmp`);
+  const tempPath = join23(dirname16(path), `.projects-${randomBytes2(8).toString("hex")}.tmp`);
   let fd;
   try {
-    mkdirSync9(dirname15(path), { recursive: true, mode: 448 });
+    mkdirSync10(dirname16(path), { recursive: true, mode: 448 });
     fd = openSync(tempPath, "wx", 384);
-    writeFileSync10(fd, `${JSON.stringify(state)}
+    writeFileSync11(fd, `${JSON.stringify(state)}
 `, "utf8");
     closeSync(fd);
     fd = void 0;
@@ -15446,7 +15719,7 @@ function writeProjectRoots(homeDir, state) {
       }
     }
     try {
-      rmSync7(tempPath, { force: true });
+      rmSync8(tempPath, { force: true });
     } catch {
     }
     throw error;
@@ -15475,16 +15748,16 @@ function isErrno(error, code) {
 
 // apps/cli/dist/task-overlay.js
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { closeSync as closeSync2, mkdirSync as mkdirSync10, openSync as openSync2, readFileSync as readFileSync14, renameSync as renameSync4, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname16, join as join21 } from "node:path";
+import { closeSync as closeSync2, mkdirSync as mkdirSync11, openSync as openSync2, readFileSync as readFileSync15, renameSync as renameSync4, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname17, join as join24 } from "node:path";
 function taskOverlayPath(homeDir) {
-  return join21(homeDir, ".wingman", "state", "task-overlay.json");
+  return join24(homeDir, ".wingman", "state", "task-overlay.json");
 }
 function readTaskOverlay(homeDir) {
   const path = taskOverlayPath(homeDir);
   let raw;
   try {
-    raw = readFileSync14(path, "utf8");
+    raw = readFileSync15(path, "utf8");
   } catch (error) {
     if (isErrno2(error, "ENOENT"))
       return { version: 1, entries: {} };
@@ -15536,12 +15809,12 @@ function patchTaskOverlay(homeDir, key, patch, now) {
 }
 function writeTaskOverlay(homeDir, overlay) {
   const path = taskOverlayPath(homeDir);
-  const tempPath = join21(dirname16(path), `.task-overlay-${randomBytes3(8).toString("hex")}.tmp`);
+  const tempPath = join24(dirname17(path), `.task-overlay-${randomBytes3(8).toString("hex")}.tmp`);
   let fd;
   try {
-    mkdirSync10(dirname16(path), { recursive: true, mode: 448 });
+    mkdirSync11(dirname17(path), { recursive: true, mode: 448 });
     fd = openSync2(tempPath, "wx", 384);
-    writeFileSync11(fd, `${JSON.stringify(overlay)}
+    writeFileSync12(fd, `${JSON.stringify(overlay)}
 `, "utf8");
     closeSync2(fd);
     fd = void 0;
@@ -15554,7 +15827,7 @@ function writeTaskOverlay(homeDir, overlay) {
       }
     }
     try {
-      rmSync8(tempPath, { force: true });
+      rmSync9(tempPath, { force: true });
     } catch {
     }
     throw error;
@@ -15587,7 +15860,7 @@ function errorMessage(error) {
 }
 
 // apps/cli/dist/version.js
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 function resolveWingmanVersion({ defined, moduleUrl = import.meta.url, readPackage }) {
   if (typeof defined === "string" && defined.trim() !== "")
     return defined;
@@ -15606,10 +15879,10 @@ function resolveWingmanVersion({ defined, moduleUrl = import.meta.url, readPacka
   return void 0;
 }
 function wingmanVersion() {
-  const defined = false ? void 0 : "0.8.0";
+  const defined = false ? void 0 : "0.8.2";
   return resolveWingmanVersion({
     defined,
-    readPackage: (url) => JSON.parse(readFileSync15(url, "utf8"))
+    readPackage: (url) => JSON.parse(readFileSync16(url, "utf8"))
   });
 }
 
@@ -15692,6 +15965,9 @@ function createNarrativeService(options = {}) {
       generation: 0,
       lines: [],
       codexLines: [],
+      instructionSeq: 0,
+      sessionPlanSeq: 0,
+      hookInstructions: [],
       pendingPlanWrites: [],
       confirmedPlanWrites: [],
       nonPlanToolSteps: 0,
@@ -15725,6 +16001,8 @@ function createNarrativeService(options = {}) {
       if (closed || session.cwd !== cwd)
         return;
       session.projectResolution = resolution;
+      if (resolution.isHome)
+        session.label = "\u65E0\u9879\u76EE\u76EE\u5F55(\u5BB6\u76EE\u5F55)";
       seenProjectRoots.add(resolution.rootIdentity);
       rememberResolution(resolution);
       watchResolution(resolution);
@@ -15778,7 +16056,7 @@ function createNarrativeService(options = {}) {
   function watchResolution(resolution) {
     if (resolution.lookedUp.length === 0)
       return;
-    const planPath = resolution.planPath ?? join22(resolution.root, ".wingman", "plan.md");
+    const planPath = resolution.planPath ?? join25(resolution.root, ".wingman", "plan.md");
     const planPathIdentity = resolution.planPathIdentity;
     if (projectWatchers.has(planPathIdentity))
       return;
@@ -15867,7 +16145,7 @@ function createNarrativeService(options = {}) {
       for (const session of sessions.values()) {
         const resolution = session.projectResolution;
         if (resolution?.planPathIdentity === planPathIdentity) {
-          const planPath = resolution.planPath ?? join22(resolution.root, ".wingman", "plan.md");
+          const planPath = resolution.planPath ?? join25(resolution.root, ".wingman", "plan.md");
           void applyPendingPlanWrites(session, planPath, planPathIdentity).then(() => {
             session.dirty = true;
             notify(harness);
@@ -15912,7 +16190,7 @@ function createNarrativeService(options = {}) {
     }
     const resolution = session.projectResolution;
     if (resolution !== void 0) {
-      const planPath = resolution.planPath ?? join22(resolution.root, ".wingman", "plan.md");
+      const planPath = resolution.planPath ?? join25(resolution.root, ".wingman", "plan.md");
       void applyPendingPlanWrites(session, planPath, resolution.planPathIdentity).then(() => {
         session.dirty = true;
         notify(harness);
@@ -15942,12 +16220,12 @@ function createNarrativeService(options = {}) {
         at: observation.at ?? versions.current.info.mtime,
         nonPlanStepsBefore: pending.nonPlanStepsBefore
       });
-      const result4 = attributePlanWrite(before, after, observation);
-      if ("attachedTo" in result4) {
-        session.planAttachment = result4;
+      const result5 = attributePlanWrite(before, after, observation);
+      if ("attachedTo" in result5) {
+        session.planAttachment = result5;
         session.planUnattachedReason = void 0;
       } else {
-        session.planUnattachedReason = result4.reason;
+        session.planUnattachedReason = result5.reason;
       }
     }
     session.pendingPlanWrites = remaining;
@@ -16002,8 +16280,13 @@ function createNarrativeService(options = {}) {
     session.lines = [];
     session.codexLines = [];
     session.hookIntervals = [];
-    session.hookPrompt = void 0;
-    session.hookPromptAt = void 0;
+    if (session.transcriptPath !== void 0) {
+      session.hookPrompt = void 0;
+      session.hookPromptAt = void 0;
+      session.hookInstructions = [];
+    }
+    session.instructionSeq = 0;
+    session.sessionPlanSeq = 0;
     session.mockNote = void 0;
     session.transcriptPath = path;
     session.dirty = true;
@@ -16040,7 +16323,7 @@ function createNarrativeService(options = {}) {
     const sessionDir = transcriptPath.replace(/\.jsonl$/, "");
     if (sessionDir === transcriptPath)
       return;
-    const subagentsDir = join22(sessionDir, "subagents");
+    const subagentsDir = join25(sessionDir, "subagents");
     const generation = session.generation;
     const poll = async () => {
       try {
@@ -16050,7 +16333,7 @@ function createNarrativeService(options = {}) {
         }
         for (const entry of entries) {
           if (/^agent-.*\.jsonl$/.test(entry)) {
-            startFollowing(harness, session, join22(subagentsDir, entry), generation);
+            startFollowing(harness, session, join25(subagentsDir, entry), generation);
           }
         }
       } catch {
@@ -16073,7 +16356,7 @@ function createNarrativeService(options = {}) {
     if (cwd !== void 0) {
       anchorCwd(event.harness, session, cwd);
       const base = pathBasename(cwd);
-      if (base !== "")
+      if (base !== "" && !session.projectResolution?.isHome)
         session.label = base;
     }
     recordToolObservations(event.harness, session, extractToolObservations(event.harness, [{ ...payload, received_at: event.received_at }]));
@@ -16086,11 +16369,17 @@ function createNarrativeService(options = {}) {
         }
       }
     }
-    if (name === "UserPromptSubmit" && typeof payload.prompt === "string") {
-      const prompt = payload.prompt.trim();
-      if (prompt !== "" && !isHarnessSystemNotice(prompt)) {
-        session.hookPrompt = truncate(prompt, DETAIL_LIMIT);
-        session.hookPromptAt = event.received_at;
+    if (name === "UserPromptSubmit") {
+      const prompt = typeof payload.prompt === "string" ? payload.prompt.trim() : void 0;
+      if (prompt === void 0 || prompt !== "" && !isHarnessSystemNotice(prompt)) {
+        session.hookInstructions.push({
+          at: event.received_at,
+          ...prompt === void 0 ? {} : { text: prompt }
+        });
+        if (prompt !== void 0) {
+          session.hookPrompt = truncate(prompt, DETAIL_LIMIT);
+          session.hookPromptAt = event.received_at;
+        }
       }
     }
     if (name === "SubagentStart") {
@@ -16176,7 +16465,7 @@ function createNarrativeService(options = {}) {
       if (cwd !== void 0) {
         anchorCwd(harness, session2, cwd);
         const base = pathBasename(cwd);
-        if (base !== "")
+        if (base !== "" && !session2.projectResolution?.isHome)
           session2.label = base;
       }
       session2.dirty = true;
@@ -16203,7 +16492,7 @@ function createNarrativeService(options = {}) {
       if (typeof cwd === "string") {
         anchorCwd(harness, session, cwd);
         const base = pathBasename(cwd);
-        if (base !== "")
+        if (base !== "" && !session.projectResolution?.isHome)
           session.label = base;
         break;
       }
@@ -16291,7 +16580,7 @@ function createNarrativeService(options = {}) {
     let state;
     if (observed.state === "installed_not_loaded")
       state = "installed_not_loaded";
-    else if (observed.state === "installed") {
+    else if (observed.state === "installed" || observed.state === "outdated") {
       state = planMtime === void 0 ? "installed" : "plan_present";
     } else
       state = "not_installed";
@@ -16345,7 +16634,7 @@ function createNarrativeService(options = {}) {
       for (const session of sessions.values()) {
         if (session.cwd === void 0)
           continue;
-        const rootIdentity = session.projectResolution?.rootIdentity ?? resolve9(session.cwd);
+        const rootIdentity = session.projectResolution?.rootIdentity ?? resolve11(session.cwd);
         const group = grouped.get(rootIdentity);
         if (group === void 0) {
           grouped.set(rootIdentity, {
@@ -16365,8 +16654,8 @@ function createNarrativeService(options = {}) {
     for (const [rootIdentity, group] of grouped) {
       const { members } = group;
       const resolution = members.find((member) => member.session.projectResolution !== void 0)?.session.projectResolution ?? group.resolution;
-      const root = resolution?.root ?? resolve9(members[0]?.session.cwd ?? "");
-      const planPath = resolution?.planPath ?? join22(root, ".wingman", "plan.md");
+      const root = resolution?.root ?? resolve11(members[0]?.session.cwd ?? "");
+      const planPath = resolution?.planPath ?? join25(root, ".wingman", "plan.md");
       const runtime = projectFiles.get(resolution?.planPathIdentity ?? planPath);
       const parsed = runtime?.missing === true ? void 0 : runtime?.parsed;
       const planMtime = parsed?.availability === "available" ? runtime?.current?.info.mtime : void 0;
@@ -16384,12 +16673,13 @@ function createNarrativeService(options = {}) {
         const verification = state?.taskWorkflow?.verification;
         const attachedTitle = session.planAttachment?.attachedTo.split(" > ").at(-1);
         const instructionTitle = state?.taskWorkflow?.latestInstruction?.text;
+        const planInstruction = state?.taskWorkflow?.plan.availability === "available" ? session.sessionPlanInstruction : void 0;
         return {
           harness,
           id: session.id,
           label,
           ended: info?.ended ?? false,
-          title: attachedTitle !== void 0 ? { text: attachedTitle, source: "plan.md \u6B65\u9AA4" } : instructionTitle !== void 0 ? { text: truncate(instructionTitle, DETAIL_LIMIT), source: "\u6700\u65B0\u6307\u4EE4" } : { text: label, source: "\u5DE5\u4F5C\u76EE\u5F55" },
+          title: attachedTitle !== void 0 ? { text: attachedTitle, source: "plan.md \u6B65\u9AA4" } : planInstruction !== void 0 ? { text: truncate(planInstruction, DETAIL_LIMIT), source: "\u8BA1\u5212\u6240\u5C5E\u6307\u4EE4" } : instructionTitle !== void 0 ? { text: truncate(instructionTitle, DETAIL_LIMIT), source: "\u6700\u65B0\u6307\u4EE4" } : { text: label, source: "\u5DE5\u4F5C\u76EE\u5F55" },
           user: {
             ...userEntry?.title === void 0 ? {} : { title: userEntry.title },
             pinned: userEntry?.pinned ?? false,
@@ -16434,14 +16724,14 @@ function createNarrativeService(options = {}) {
         id: `${session.harness}:${session.id}`,
         ...session.attachedTo === void 0 ? {} : { attachedTo: session.attachedTo },
         ended: session.ended,
-        ...session.sessionPlan?.availability === "available" && session.sessionPlan.steps.length > 0 ? {
+        ...session.sessionPlan?.availability === "available" && session.sessionPlan.forInstruction === "current" && session.sessionPlan.steps.length > 0 ? {
           sessionPlanAllCompleted: session.sessionPlan.steps.every((step) => step.status === "completed")
         } : {},
         ...session.attachedBy?.at === void 0 ? {} : { wrotePlanAt: session.attachedBy.at }
       })), now().toISOString());
       const lastWriter = [...sessionViews].filter((session) => typeof session.attachedBy?.at === "string").sort((left, right) => right.attachedBy.at.localeCompare(left.attachedBy.at))[0];
-      const titleText = parsed?.availability === "available" && parsed.title !== void 0 ? parsed.title : pathBasename(root) || root;
-      const titleSource = parsed?.availability === "available" && parsed.title !== void 0 ? ".wingman/plan.md H1" : "\u5DE5\u4F5C\u76EE\u5F55";
+      const titleText = resolution?.isHome ? "\u65E0\u9879\u76EE\u76EE\u5F55(\u5BB6\u76EE\u5F55)" : parsed?.availability === "available" && parsed.title !== void 0 ? parsed.title : pathBasename(root) || root;
+      const titleSource = resolution?.isHome ? "\u5DE5\u4F5C\u76EE\u5F55 = \u5BB6\u76EE\u5F55" : parsed?.availability === "available" && parsed.title !== void 0 ? ".wingman/plan.md H1" : "\u5DE5\u4F5C\u76EE\u5F55";
       let plan;
       if (parsed?.availability === "available") {
         plan = {
@@ -16680,8 +16970,8 @@ function extractRawToolObservations(harness, rawLine) {
 }
 function resolveObservedPath(path, cwd) {
   if (isAbsolute6(path))
-    return resolve9(path);
-  return cwd === void 0 ? void 0 : resolve9(cwd, path);
+    return resolve11(path);
+  return cwd === void 0 ? void 0 : resolve11(cwd, path);
 }
 function agentIdOf(payload) {
   const id = payload.agent_id ?? payload.agentId;
@@ -16745,9 +17035,9 @@ function derive(harness, session, nowIso) {
   const attributed = attributeSteps(steps, timeline, intervals);
   const results = collectResults(lines2);
   const resultBriefs = /* @__PURE__ */ new Map();
-  for (const [toolUseId, result4] of results) {
-    if (result4.brief !== void 0)
-      resultBriefs.set(toolUseId, result4.brief);
+  for (const [toolUseId, result5] of results) {
+    if (result5.brief !== void 0)
+      resultBriefs.set(toolUseId, result5.brief);
   }
   const checks = deriveCheckStats(allSteps, resultBriefs);
   const todoChecks = deriveTodoCheckStats(attributed);
@@ -16856,11 +17146,16 @@ function derive(harness, session, nowIso) {
   const activeTodos = todos.filter((todo) => todo.status === "in_progress");
   const activeTodo = activeTodos.length === 1 ? activeTodos[0] : void 0;
   const activeChecks = activeTodo === void 0 ? void 0 : todoChecks.get(activeTodo.id);
-  const plan = workflowBase.plan;
+  scopeSessionPlan(harness, session, lines2);
+  const plan = workflowBase.plan.availability === "available" ? {
+    ...workflowBase.plan,
+    forInstruction: session.sessionPlanSeq === session.instructionSeq ? "current" : "previous"
+  } : workflowBase.plan;
   const taskWorkflow = {
     ...workflowBase,
+    plan,
     verification: {
-      agentMarkedComplete: plan.availability === "available" && plan.steps.length > 0 && plan.steps.every((step) => step.status === "completed"),
+      agentMarkedComplete: plan.availability === "available" && plan.forInstruction === "current" && plan.steps.length > 0 && plan.steps.every((step) => step.status === "completed"),
       checks: { ...checks, source: CHECK_STATS_SOURCE },
       ...activeTodo === void 0 ? {} : {
         currentStep: {
@@ -16880,7 +17175,7 @@ function derive(harness, session, nowIso) {
     ...session.cwd === void 0 ? {} : { cwd: session.cwd },
     ...session.cwd === void 0 ? {} : {
       project: {
-        root: session.projectResolution?.root ?? resolve9(session.cwd),
+        root: session.projectResolution?.root ?? resolve11(session.cwd),
         ...session.planAttachment === void 0 ? {} : { attachedTo: session.planAttachment.attachedTo }
       }
     },
@@ -16898,6 +17193,92 @@ function derive(harness, session, nowIso) {
     updatedAt: nowIso
   };
 }
+function scopeSessionPlan(harness, session, lines2) {
+  const observations = [];
+  const seenUsers = /* @__PURE__ */ new Set();
+  const taskIds = /* @__PURE__ */ new Set();
+  const resultLines = /* @__PURE__ */ new Map();
+  for (const line of lines2) {
+    if (line.kind === "user") {
+      for (const result5 of line.toolResults)
+        resultLines.set(result5.toolUseId, line);
+    }
+  }
+  let at;
+  for (const line of lines2) {
+    if (line.kind === "unknown" || line.agentId !== void 0 || line.isSidechain === true) {
+      continue;
+    }
+    at = line.timestamp ?? at;
+    const timestamp = at === void 0 ? {} : { at };
+    if (line.kind === "user" && line.toolResults.length === 0) {
+      const text = line.text?.trim();
+      if (text === void 0 || text === "" || isHarnessSystemNotice(text))
+        continue;
+      if (line.uuid !== void 0) {
+        if (seenUsers.has(line.uuid))
+          continue;
+        seenUsers.add(line.uuid);
+      }
+      observations.push({ kind: "instruction", source: "transcript", text, ...timestamp });
+    } else if (line.kind === "assistant") {
+      for (const block of line.blocks) {
+        if (block.kind !== "tool_use")
+          continue;
+        if (harness === "codex" && block.name === "update_plan") {
+          observations.push({ kind: "plan", ...timestamp });
+        } else if (harness === "cc") {
+          if (block.name === "TaskCreate" || block.name === "TodoWrite") {
+            const result5 = resultLines.get(block.id);
+            const snapshot = extractTodoSnapshots([
+              { ...line, blocks: [block] },
+              ...result5 === void 0 ? [] : [result5]
+            ]).at(-1);
+            if (snapshot === void 0)
+              continue;
+            if (block.name === "TodoWrite")
+              taskIds.clear();
+            for (const todo of snapshot.todos)
+              taskIds.add(todo.id);
+          } else if (block.name === "TaskUpdate") {
+            const taskId = block.input.taskId;
+            if (typeof taskId !== "string" || !taskIds.has(taskId))
+              continue;
+            if (block.input.status === "deleted")
+              taskIds.delete(taskId);
+          } else {
+            continue;
+          }
+          observations.push({ kind: "plan", ...timestamp });
+        }
+      }
+    }
+  }
+  for (const hook of session.hookInstructions) {
+    observations.push({ kind: "instruction", source: "hook", ...hook });
+  }
+  observations.sort((a, b) => (a.at ?? "").localeCompare(b.at ?? ""));
+  session.instructionSeq = 0;
+  session.sessionPlanSeq = 0;
+  const instructions = /* @__PURE__ */ new Map();
+  let unpaired;
+  for (const observation of observations) {
+    if (observation.kind === "plan") {
+      session.sessionPlanSeq = session.instructionSeq;
+      unpaired = void 0;
+    } else if (unpaired !== void 0 && unpaired.source !== observation.source && (unpaired.text === void 0 || observation.text === void 0 || unpaired.text === observation.text)) {
+      if (observation.text !== void 0)
+        instructions.set(session.instructionSeq, observation.text);
+      unpaired = void 0;
+    } else {
+      session.instructionSeq += 1;
+      if (observation.text !== void 0)
+        instructions.set(session.instructionSeq, observation.text);
+      unpaired = observation;
+    }
+  }
+  session.sessionPlanInstruction = instructions.get(session.sessionPlanSeq);
+}
 function todoInProgressAt(timeline, ts) {
   const active = timeline.filter((entry) => entry.spans.some((span) => span.status === "in_progress" && span.from !== void 0 && span.from <= ts && (span.to === void 0 || ts < span.to)));
   const only = active[0];
@@ -17053,18 +17434,18 @@ function collectResults(lines2) {
   for (const line of lines2) {
     if (line.kind !== "user")
       continue;
-    for (const result4 of line.toolResults) {
-      if (result4.content === void 0)
+    for (const result5 of line.toolResults) {
+      if (result5.content === void 0)
         continue;
       const info = {};
       try {
-        info.bytes = Buffer.byteLength(JSON.stringify(result4.content), "utf8");
+        info.bytes = Buffer.byteLength(JSON.stringify(result5.content), "utf8");
       } catch {
       }
-      const brief = errorBrief(result4.content);
+      const brief = errorBrief(result5.content);
       if (brief !== void 0)
         info.brief = brief;
-      results.set(result4.toolUseId, info);
+      results.set(result5.toolUseId, info);
     }
   }
   return results;
@@ -17370,16 +17751,22 @@ function errorBrief(content) {
 init_dist3();
 init_dist5();
 init_dist2();
+import { homedir as homedir13 } from "node:os";
 import { createInterface } from "node:readline/promises";
 var ProtocolUsageError = class extends Error {
 };
-async function runProtocolCli(args) {
+async function runProtocolCli(args, options = { homeDir: homedir13() }) {
   const parsed = parseProtocolArgs(args);
+  if (parsed.user && parsed.harness === "dsh") {
+    throw new ProtocolUsageError(protocolStatusDshUser(options).unsupported);
+  }
   if (parsed.action === "status") {
-    printStatus(getStatus(parsed.harness, parsed.projectDir));
+    const user = getUserStatus(parsed.harness, options.homeDir);
+    printStatus(user, "\u7528\u6237\u7EA7");
+    printStatus(getStatus(parsed.harness, parsed.projectDir, options.homeDir), "\u9879\u76EE\u7EA7");
     return 0;
   }
-  const preview = mutate(parsed.action, parsed.harness, parsed.projectDir, true);
+  const preview = mutate(parsed, options.homeDir, true);
   printPreview(preview);
   if (!preview.changed)
     return 0;
@@ -17389,7 +17776,7 @@ async function runProtocolCli(args) {
     process.stdout.write("wingman:\u5DF2\u53D6\u6D88\uFF0C\u672A\u5199\u5165\u4EFB\u4F55\u6587\u4EF6\u3002\n");
     return 0;
   }
-  const applied = mutate(parsed.action, parsed.harness, parsed.projectDir, false);
+  const applied = mutate(parsed, options.homeDir, false);
   process.stdout.write(`wingman:${parsed.harness} protocol ${parsed.action} \u5B8C\u6210
 state: ${applied.state}
 backupDir: ${applied.backupDir ?? "(no backup)"}
@@ -17401,12 +17788,15 @@ ${applied.message ?? ""}${applied.message === void 0 ? "" : "\n"}`);
 function parseProtocolArgs(args) {
   const [actionText, harnessText, ...tail] = args;
   if (actionText !== "install" && actionText !== "uninstall" && actionText !== "status") {
-    throw new ProtocolUsageError("protocol \u7528\u6CD5:wingman protocol install|uninstall|status <cc|codex|dsh> [--project <dir>] [--dry-run] [--yes]");
+    throw new ProtocolUsageError("protocol \u7528\u6CD5:wingman protocol install|uninstall|status <cc|codex|dsh> [--project <dir> | --user] [--dry-run] [--yes]");
   }
   if (harnessText !== "cc" && harnessText !== "codex" && harnessText !== "dsh") {
     throw new ProtocolUsageError(`protocol \u9700\u8981 harness \u2208 cc|codex|dsh,\u5F97\u5230 ${harnessText ?? "(\u7F3A\u53C2)"}`);
   }
   let projectDir = process.cwd();
+  let user = false;
+  let project = false;
+  let fixtures = false;
   let dryRun = false;
   let yes = false;
   const rest = [...tail];
@@ -17414,9 +17804,14 @@ function parseProtocolArgs(args) {
     const arg = rest.shift();
     if (arg === "--project") {
       const value = rest.shift();
-      if (value === void 0)
+      if (value === void 0 || value.startsWith("--"))
         throw new ProtocolUsageError("--project \u9700\u8981\u76EE\u5F55\u8DEF\u5F84,\u5F97\u5230(\u7F3A\u53C2)");
+      project = true;
       projectDir = value;
+    } else if (arg === "--user") {
+      user = true;
+    } else if (arg === "--fixtures") {
+      fixtures = true;
     } else if (arg === "--dry-run") {
       dryRun = true;
     } else if (arg === "--yes") {
@@ -17425,36 +17820,57 @@ function parseProtocolArgs(args) {
       throw new ProtocolUsageError(`protocol \u4E0D\u8BA4\u8BC6\u53C2\u6570:${arg}`);
     }
   }
-  return { action: actionText, harness: harnessText, projectDir, dryRun, yes };
+  if (user && project)
+    throw new ProtocolUsageError("--user \u4E0E --project \u4E92\u65A5");
+  if (fixtures && user)
+    throw new ProtocolUsageError("fixtures \u6A21\u5F0F\u62D2\u7EDD --user\uFF0C\u4E0D\u80FD\u8BBF\u95EE\u7528\u6237\u7EA7\u6307\u4EE4\u6587\u4EF6");
+  if (fixtures)
+    throw new ProtocolUsageError("protocol \u4E0D\u652F\u6301 --fixtures");
+  return { action: actionText, harness: harnessText, projectDir, user, dryRun, yes };
 }
-function getStatus(harness, projectDir) {
+function getStatus(harness, projectDir, homeDir) {
   switch (harness) {
     case "cc":
-      return protocolStatusCc({ projectDir });
+      return protocolStatusCc({ projectDir, homeDir });
     case "codex":
-      return protocolStatusCodex({ projectDir });
+      return protocolStatusCodex({ projectDir, homeDir });
     case "dsh":
-      return protocolStatusDsh({ projectDir });
+      return protocolStatusDsh({ projectDir, homeDir });
   }
 }
-function mutate(action, harness, projectDir, dryRun) {
+function getUserStatus(harness, homeDir) {
   switch (harness) {
     case "cc":
-      return action === "install" ? installProtocolCc({ projectDir, dryRun }) : uninstallProtocolCc({ projectDir, dryRun });
+      return protocolStatusCcUser({ homeDir });
     case "codex":
-      return action === "install" ? installProtocolCodex({ projectDir, dryRun }) : uninstallProtocolCodex({ projectDir, dryRun });
+      return protocolStatusCodexUser({ homeDir });
     case "dsh":
-      return action === "install" ? installProtocolDsh({ projectDir, dryRun }) : uninstallProtocolDsh({ projectDir, dryRun });
+      return protocolStatusDshUser({ homeDir });
   }
 }
-function printStatus(value) {
-  process.stdout.write(`harness: ${value.harness}
-target: ${value.targetPath}
-state: ${value.state}
-${value.version === void 0 ? "" : `version: ${value.version}
-`}${value.message === void 0 ? "" : `${value.message}
-`}${value.reason === void 0 ? "" : `reason: ${value.reason}
-`}`);
+function mutate(parsed, homeDir, dryRun) {
+  const { action, harness, projectDir, user } = parsed;
+  switch (harness) {
+    case "cc":
+      return action === "install" ? (user ? installProtocolCcUser : installProtocolCc)({ projectDir, homeDir, dryRun }) : (user ? uninstallProtocolCcUser : uninstallProtocolCc)({ projectDir, homeDir, dryRun });
+    case "codex":
+      return action === "install" ? (user ? installProtocolCodexUser : installProtocolCodex)({ projectDir, homeDir, dryRun }) : (user ? uninstallProtocolCodexUser : uninstallProtocolCodex)({
+        projectDir,
+        homeDir,
+        dryRun
+      });
+    case "dsh":
+      return action === "install" ? installProtocolDsh({ projectDir, homeDir, dryRun }) : uninstallProtocolDsh({ projectDir, homeDir, dryRun });
+  }
+}
+function printStatus(value, scope) {
+  if ("unsupported" in value) {
+    process.stdout.write(`${scope}: unsupported \u2014 ${value.unsupported}
+`);
+    return;
+  }
+  process.stdout.write(`${scope}: ${value.state} | target: ${value.targetPath} | state: ${value.state}${value.version === void 0 ? "" : ` | version: ${value.version}`}${value.message === void 0 ? "" : ` | ${value.message}`}${value.reason === void 0 ? "" : ` | reason: ${value.reason}`}
+`);
 }
 function printPreview(value) {
   process.stdout.write(`${unifiedDiff(value.targetPath, value.before, value.after)}
@@ -17504,8 +17920,8 @@ async function confirmWrite() {
 }
 
 // apps/cli/dist/registry.js
-import { existsSync as existsSync13 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
+import { existsSync as existsSync14 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
 async function importHarnessModule(harness) {
   const mod = await importAdapterModule(harness);
   if (typeof mod.createAdapter !== "function") {
@@ -17527,7 +17943,7 @@ function importAdapterModule(harness) {
   }
 }
 function fixtureScanOptions(harness) {
-  if (!existsSync13(fixturePath())) {
+  if (!existsSync14(fixturePath())) {
     throw new Error("--fixtures \u9700\u8981\u4ED3\u5E93\u5185\u7684 packages/fixtures \u6570\u636E;\u53D1\u5E03\u5B89\u88C5\u5305/npx \u4EA7\u7269\u4E0D\u5305\u542B\u6837\u4F8B");
   }
   switch (harness) {
@@ -17548,16 +17964,16 @@ async function loadHarness(harness, mode) {
   return {
     harness,
     adapter,
-    scanOptions: mode.fixtures ? fixtureScanOptions(harness) : { homeDir: homedir11() },
+    scanOptions: mode.fixtures ? fixtureScanOptions(harness) : { homeDir: homedir14() },
     feedbackSignals
   };
 }
 
 // apps/cli/dist/runtime-state.js
 import { randomBytes as randomBytes4 } from "node:crypto";
-import { closeSync as closeSync3, mkdirSync as mkdirSync11, openSync as openSync3, readFileSync as readFileSync16, renameSync as renameSync5, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { dirname as dirname17, join as join23 } from "node:path";
+import { closeSync as closeSync3, mkdirSync as mkdirSync12, openSync as openSync3, readFileSync as readFileSync17, renameSync as renameSync5, rmSync as rmSync10, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { dirname as dirname18, join as join26 } from "node:path";
 function createHookToken() {
   return randomBytes4(32).toString("base64url");
 }
@@ -17568,15 +17984,15 @@ function writeServeRuntimeState(port, token, options = {}) {
   const pid = options.pid ?? process.pid;
   const suffix = randomBytes4(8).toString("base64url");
   const owner = `serve-${startedAtMs}-${pid}-${suffix}`;
-  const path = join23(options.homeDir ?? homedir12(), ".wingman", "state", "serve", `${owner}.json`);
-  const tempPath = join23(dirname17(path), `.${owner}.tmp`);
+  const path = join26(options.homeDir ?? homedir15(), ".wingman", "state", "serve", `${owner}.json`);
+  const tempPath = join26(dirname18(path), `.${owner}.tmp`);
   const contents = Buffer.from(`${JSON.stringify({ version: 2, owner, pid, port, startedAtMs, token })}
 `, "utf8");
   let fd;
   try {
-    mkdirSync11(dirname17(path), { recursive: true, mode: 448 });
+    mkdirSync12(dirname18(path), { recursive: true, mode: 448 });
     fd = openSync3(tempPath, "wx", 384);
-    writeFileSync12(fd, contents);
+    writeFileSync13(fd, contents);
     closeSync3(fd);
     fd = void 0;
     renameSync5(tempPath, path);
@@ -17589,7 +18005,7 @@ function writeServeRuntimeState(port, token, options = {}) {
       }
     }
     try {
-      rmSync9(tempPath, { force: true });
+      rmSync10(tempPath, { force: true });
     } catch {
     }
     warn(`Codex hook \u8FD0\u884C\u6001\u5199\u5165\u5931\u8D25,\u9762\u677F\u7EE7\u7EED\u8FD0\u884C:${errorMessage2(error)}`);
@@ -17600,9 +18016,9 @@ function removeServeRuntimeState(registration) {
   if (registration === void 0)
     return;
   try {
-    const current = readFileSync16(registration.path);
+    const current = readFileSync17(registration.path);
     if (current.equals(registration.contents))
-      rmSync9(registration.path, { force: true });
+      rmSync10(registration.path, { force: true });
   } catch {
   }
 }
@@ -17623,17 +18039,20 @@ async function scanValidated(adapter, options) {
 }
 
 // apps/cli/dist/server.js
+init_dist3();
+init_dist5();
 init_dist();
 import { execFile as execFile2 } from "node:child_process";
 import { createHmac, timingSafeEqual } from "node:crypto";
 import { readFile as readFile4 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { extname, resolve as resolve11, sep as sep2 } from "node:path";
+import { hostname } from "node:os";
+import { extname, relative as relative4, resolve as resolve13, sep as sep2 } from "node:path";
 
 // apps/cli/dist/return-target.js
 import { randomBytes as randomBytes5 } from "node:crypto";
-import { closeSync as closeSync4, copyFileSync as copyFileSync2, mkdirSync as mkdirSync12, openSync as openSync4, readFileSync as readFileSync17, renameSync as renameSync6, rmSync as rmSync10, statSync as statSync6, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname18, join as join24, resolve as resolve10 } from "node:path";
+import { closeSync as closeSync4, copyFileSync as copyFileSync2, mkdirSync as mkdirSync13, openSync as openSync4, readFileSync as readFileSync18, renameSync as renameSync6, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname19, join as join27, resolve as resolve12 } from "node:path";
 var BUNDLES = [
   ["Terminal", "Terminal.app"],
   ["iTerm", "iTerm.app"],
@@ -17644,11 +18063,11 @@ var BUNDLES = [
   ["kitty", "kitty.app"],
   ["VS Code", "Visual Studio Code.app"]
 ];
-function detectReturnTargets(homeDir, roots = ["/Applications", join24(homeDir, "Applications")]) {
+function detectReturnTargets(homeDir, roots = ["/Applications", join27(homeDir, "Applications")]) {
   const available = [];
   for (const [name, bundle] of BUNDLES) {
-    for (const root of new Set(roots.map((root2) => resolve10(root2)))) {
-      const bundlePath = join24(root, bundle);
+    for (const root of new Set(roots.map((root2) => resolve12(root2)))) {
+      const bundlePath = join27(root, bundle);
       try {
         if (statSync6(bundlePath).isDirectory())
           available.push({ name, bundlePath });
@@ -17659,12 +18078,12 @@ function detectReturnTargets(homeDir, roots = ["/Applications", join24(homeDir,
   return available;
 }
 function settingsPath(homeDir) {
-  return join24(homeDir, ".wingman", "state", "settings.json");
+  return join27(homeDir, ".wingman", "state", "settings.json");
 }
 function readReturnTargetSettings(homeDir) {
   let raw;
   try {
-    raw = readFileSync17(settingsPath(homeDir), "utf8");
+    raw = readFileSync18(settingsPath(homeDir), "utf8");
   } catch (error) {
     if (isRecord8(error) && error.code === "ENOENT")
       return { version: 1 };
@@ -17685,10 +18104,10 @@ function saveReturnTarget(homeDir, bundlePath) {
     return current;
   const settings = { version: 1, returnTarget: { bundlePath } };
   const path = settingsPath(homeDir);
-  const tempPath = join24(dirname18(path), `.settings-${randomBytes5(8).toString("hex")}.tmp`);
+  const tempPath = join27(dirname19(path), `.settings-${randomBytes5(8).toString("hex")}.tmp`);
   let fd;
   try {
-    mkdirSync12(dirname18(path), { recursive: true, mode: 448 });
+    mkdirSync13(dirname19(path), { recursive: true, mode: 448 });
     try {
       copyFileSync2(path, `${path}.bak`);
     } catch (error) {
@@ -17696,7 +18115,7 @@ function saveReturnTarget(homeDir, bundlePath) {
         throw error;
     }
     fd = openSync4(tempPath, "wx", 384);
-    writeFileSync13(fd, `${JSON.stringify(settings)}
+    writeFileSync14(fd, `${JSON.stringify(settings)}
 `, "utf8");
     closeSync4(fd);
     fd = void 0;
@@ -17712,7 +18131,7 @@ function saveReturnTarget(homeDir, bundlePath) {
       }
     }
     try {
-      rmSync10(tempPath, { force: true });
+      rmSync11(tempPath, { force: true });
     } catch {
     }
   }
@@ -18037,8 +18456,18 @@ async function handle(req, res, options, warn, runtime) {
   }
   if (url.pathname === "/api/anatomy") {
     const configs = await scanAll(options.harnesses, warn);
+    const anatomy = configs.map((config) => {
+      const scanOptions = options.harnesses.find((entry) => entry.harness === config.harness)?.scanOptions;
+      const homeDir = scanOptions?.homeDir ?? options.homeDir;
+      if (homeDir === void 0)
+        throw new Error("anatomy \u9700\u8981\u663E\u5F0F homeDir");
+      const user = config.harness === "cc" ? protocolStatusCcUser({ homeDir }).state : config.harness === "codex" ? protocolStatusCodexUser({ homeDir }).state : "unsupported";
+      const projectDir = scanOptions?.projectDir;
+      const project = projectDir === void 0 ? "not_installed" : config.harness === "cc" ? protocolStatusCc({ homeDir, projectDir }).state : protocolStatusCodex({ homeDir, projectDir }).state;
+      return { ...config, planProtocol: { user, project } };
+    });
     res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-    res.end(JSON.stringify(configs));
+    res.end(JSON.stringify(anatomy));
     return;
   }
   if (url.pathname === "/api/version") {
@@ -18157,6 +18586,10 @@ async function handleActionPlan(req, res, options) {
     sendJson2(res, 400, { error: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F\u5408\u6CD5 JSON" });
     return;
   }
+  if (isProtocolUserRequest(body)) {
+    handleProtocolUserAction(body, res, options);
+    return;
+  }
   const { harness, action } = body;
   const loaded = pickHarness(options, harness);
   if (!loaded) {
@@ -18188,6 +18621,10 @@ async function handleActionApply(req, res, options, runtime) {
     sendJson2(res, 400, { error: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u662F\u5408\u6CD5 JSON" });
     return;
   }
+  if (isProtocolUserRequest(body)) {
+    handleProtocolUserAction(body, res, options, runtime);
+    return;
+  }
   const { harness, plan } = body;
   const loaded = pickHarness(options, harness);
   if (!loaded) {
@@ -18199,15 +18636,68 @@ async function handleActionApply(req, res, options, runtime) {
     return;
   }
   try {
-    const result4 = await loaded.adapter.applyAction(plan, loaded.scanOptions);
-    if (result4.ok) {
+    const result5 = await loaded.adapter.applyAction(plan, loaded.scanOptions);
+    if (result5.ok) {
       runtime.anatomy = null;
     }
-    sendJson2(res, 200, result4);
+    sendJson2(res, 200, result5);
   } catch (error) {
     sendJson2(res, 400, { error: errorMessage3(error) });
   }
 }
+function isProtocolUserRequest(body) {
+  return isRecord9(body) && (body.kind === "protocol_user_install" || body.kind === "protocol_user_uninstall");
+}
+function handleProtocolUserAction(body, res, options, runtime) {
+  if (options.readonlyActions) {
+    sendJson2(res, 403, { error: "fixtures \u6A21\u5F0F\u53EA\u8BFB:\u4E0D\u9884\u89C8\u6216\u5199\u5165\u7528\u6237\u7EA7\u534F\u8BAE" });
+    return;
+  }
+  if (body.harness === "dsh") {
+    sendJson2(res, 400, { error: "unsupported: dsh \u65E0\u7528\u6237\u7EA7\u6307\u4EE4\u6587\u4EF6\uFF0C\u8BF7\u6309\u9879\u76EE\u5B89\u88C5\u8BA1\u5212\u534F\u8BAE" });
+    return;
+  }
+  const loaded = pickHarness(options, body.harness);
+  if (!loaded || body.harness !== "cc" && body.harness !== "codex") {
+    sendJson2(res, 400, { error: "\u7528\u6237\u7EA7\u8BA1\u5212\u534F\u8BAE harness \u9700\u8981 cc|codex" });
+    return;
+  }
+  const homeDir = loaded.scanOptions.homeDir ?? options.homeDir;
+  if (homeDir === void 0) {
+    sendJson2(res, 500, { error: "\u7528\u6237\u7EA7\u8BA1\u5212\u534F\u8BAE\u9700\u8981\u663E\u5F0F homeDir" });
+    return;
+  }
+  const install = body.kind === "protocol_user_install";
+  const operation = body.harness === "cc" ? install ? installProtocolCcUser : uninstallProtocolCcUser : install ? installProtocolCodexUser : uninstallProtocolCodexUser;
+  try {
+    const result5 = operation({ homeDir, dryRun: runtime === void 0 });
+    if (runtime === void 0) {
+      const before = splitPlanProtocolBlock(result5.before, result5.targetPath, "user");
+      const after = splitPlanProtocolBlock(result5.after, result5.targetPath, "user");
+      const block = install ? after.block : before.block;
+      sendJson2(res, 200, {
+        kind: body.kind,
+        harness: body.harness,
+        targetPath: body.harness === "cc" ? "~/.claude/CLAUDE.md" : "~/.codex/AGENTS.md",
+        hasBlock: before.block !== void 0,
+        ...install && before.version !== void 0 && after.version !== void 0 && before.version < after.version ? { fromVersion: before.version, toVersion: after.version } : {},
+        blockBytes: Buffer.byteLength(block ?? ""),
+        backupDir: "~/.wingman/backups/<ISO \u65F6\u95F4\u6233>\uFF08\u91CD\u540D\u8FFD\u52A0 -N\uFF09",
+        hostname: hostname()
+      });
+    } else {
+      runtime.anatomy = null;
+      const user = body.harness === "cc" ? protocolStatusCcUser({ homeDir }).state : protocolStatusCodexUser({ homeDir }).state;
+      sendJson2(res, 200, {
+        ok: true,
+        planProtocol: { user },
+        ...result5.backupDir === void 0 ? {} : { backupDir: `~/${relative4(homeDir, result5.backupDir).split(sep2).join("/")}` }
+      });
+    }
+  } catch (error) {
+    sendJson2(res, 400, { error: errorSummary(error) });
+  }
+}
 async function handleReturn(req, res, options, activate) {
   if (req.method !== "POST" && (activate || req.method !== "GET")) {
     sendText2(res, 405, "method not allowed");
@@ -18283,12 +18773,12 @@ async function handleTaskOverlay(req, res, options) {
     return;
   }
   const key = `${body.harness}:${body.sessionId}`;
-  const result4 = patchTaskOverlay(options.homeDir, key, body.patch, /* @__PURE__ */ new Date());
-  if ("unavailable" in result4) {
-    sendJson2(res, 409, { error: result4.unavailable });
+  const result5 = patchTaskOverlay(options.homeDir, key, body.patch, /* @__PURE__ */ new Date());
+  if ("unavailable" in result5) {
+    sendJson2(res, 409, { error: result5.unavailable });
     return;
   }
-  sendJson2(res, 200, { key, entry: result4.entry });
+  sendJson2(res, 200, { key, entry: result5.entry });
 }
 var LICENSE_BODY_LIMIT = 64 * 1024;
 async function handleLicenseInstall(req, res, options) {
@@ -18297,12 +18787,12 @@ async function handleLicenseInstall(req, res, options) {
     sendJson2(res, 400, { error: "license \u6587\u4EF6\u8D85\u8FC7 64KB \u4E0A\u9650\u6216\u8BFB\u53D6\u5931\u8D25" });
     return;
   }
-  const result4 = installLicense(raw, options.licenseOptions);
-  if (!result4.ok) {
-    sendJson2(res, 400, { error: result4.error });
+  const result5 = installLicense(raw, options.licenseOptions);
+  if (!result5.ok) {
+    sendJson2(res, 400, { error: result5.error });
     return;
   }
-  sendJson2(res, 200, publicLicenseStatus(result4.status));
+  sendJson2(res, 200, publicLicenseStatus(result5.status));
 }
 async function handleLicenseRefresh(res, options) {
   const homeDir = options.licenseRefreshOptions?.homeDir ?? options.licenseOptions?.homeDir;
@@ -18314,11 +18804,11 @@ async function handleLicenseRefresh(res, options) {
     ...publicKeyPem === void 0 ? {} : { publicKeyPem },
     ...now === void 0 ? {} : { now }
   };
-  const result4 = await refreshLicense(refreshOptions);
-  if (!result4.ok) {
+  const result5 = await refreshLicense(refreshOptions);
+  if (!result5.ok) {
     sendJson2(res, 400, {
-      error: result4.message,
-      canSubscribe: result4.reason === "inactive"
+      error: result5.message,
+      canSubscribe: result5.reason === "inactive"
     });
     return;
   }
@@ -18330,7 +18820,7 @@ async function handleLicenseRefresh(res, options) {
   };
   sendJson2(res, 200, {
     ...publicLicenseStatus(licenseStatus(statusOptions)),
-    message: result4.message
+    message: result5.message
   });
 }
 function publicLicenseStatus(status3) {
@@ -18425,8 +18915,8 @@ async function serveStatic(pathname, res, panelDistDir) {
     return;
   }
   const rel = decoded === "/" ? "/index.html" : decoded;
-  const distDir = resolve11(panelDistDir);
-  const filePath = resolve11(distDir, `.${rel}`);
+  const distDir = resolve13(panelDistDir);
+  const filePath = resolve13(distDir, `.${rel}`);
   if (filePath !== distDir && !filePath.startsWith(distDir + sep2)) {
     sendText2(res, 403, "forbidden");
     return;
@@ -18463,8 +18953,8 @@ var HELP = `wingman \u2014 Not your copilot. Your wingman.
   wingman hook install <harness> [--port 7333]        \u5B9E\u51B5\u63A5\u7EBF(\u5199\u524D\u5907\u4EFD,\u5E42\u7B49)
                 [--profile <p>]                       dsh:\u53EA\u5904\u7406\u6307\u5B9A profile
   wingman hook uninstall <harness> [--profile <p>]    \u89E3\u7EBF(\u914D\u7F6E\u6062\u590D,\u5E42\u7B49)
-  wingman protocol install|uninstall|status <harness> \u6309\u9879\u76EE\u7BA1\u7406 Plan Protocol
-                [--project <dir>] [--dry-run] [--yes]
+  wingman protocol install|uninstall|status <harness> \u7BA1\u7406\u7528\u6237\u7EA7 / \u9879\u76EE\u7EA7 Plan Protocol
+                [--project <dir> | --user] [--dry-run] [--yes]
   wingman license status                              \u67E5\u770B\u8BA2\u9605\u72B6\u6001(\u5199\u52A8\u4F5C\u7684\u95F8)
   wingman license refresh                             \u8054\u7F51\u5411\u7B7E\u53D1\u7AEF\u6362\u65B0 license(\u7EED\u671F)
   wingman --version | -v | version                    \u663E\u793A\u7248\u672C
@@ -18493,7 +18983,7 @@ async function main(argv) {
     case "hook":
       return runHook(rest);
     case "protocol":
-      return runProtocolCli(rest);
+      return runProtocolCli(rest, { homeDir: homedir16() });
     case "license": {
       if (rest[0] === "status") {
         const status3 = licenseStatus();
@@ -18502,10 +18992,10 @@ async function main(argv) {
         return 0;
       }
       if (rest[0] === "refresh") {
-        const result4 = await refreshLicense();
-        process.stdout.write(`${result4.message}
+        const result5 = await refreshLicense();
+        process.stdout.write(`${result5.message}
 `);
-        if (!result4.ok)
+        if (!result5.ok)
           return 1;
         const status3 = licenseStatus();
         process.stdout.write(`${status3.state}:${status3.detail}
@@ -18544,7 +19034,7 @@ ${counts}
 }
 async function runServe(args) {
   const { port, fixtures, panelDist } = parseServeArgs(args);
-  const homeDir = fixtures ? fixturesRoot : homedir13();
+  const homeDir = fixtures ? fixturesRoot : homedir16();
   const hookToken = createHookToken();
   let dshRetirementNotice;
   if (!fixtures) {
@@ -18579,7 +19069,7 @@ async function runServe(args) {
 `);
     }
   }
-  const panelDistDir = panelDist === void 0 ? resolve12(dirname19(fileURLToPath2(import.meta.url)), "../../panel/dist") : resolve12(panelDist);
+  const panelDistDir = panelDist === void 0 ? resolve14(dirname20(fileURLToPath2(import.meta.url)), "../../panel/dist") : resolve14(panelDist);
   const narrative = createNarrativeService({
     followTranscripts: !fixtures,
     homeDir,
@@ -18592,7 +19082,7 @@ async function runServe(args) {
   });
   if (fixtures) {
     try {
-      const raw = readFileSync18(fixturePath("cc", "sessions", "session-todos.jsonl"), "utf8");
+      const raw = readFileSync19(fixturePath("cc", "sessions", "session-todos.jsonl"), "utf8");
       narrative.seedFixture("cc", raw.split("\n"), "MOCK \u2014 fixtures \u6F14\u793A:\u53D9\u4E8B\u6570\u636E\u6765\u81EA packages/fixtures \u7684 session-todos.jsonl \u6837\u4F8B\u4F1A\u8BDD,\u975E\u672C\u673A\u771F\u5B9E transcript\u3002");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -18666,8 +19156,8 @@ async function runHook(args) {
     const { adapter, scanOptions } = await loadHarness(harness, { fixtures: false });
     if (action === "install") {
       if (harness === "dsh") {
-        const result4 = await installDshHooks(port, scanOptions);
-        writeDshInstallReport(await dshHookInstallReport(scanOptions), result4);
+        const result5 = await installDshHooks(port, scanOptions);
+        writeDshInstallReport(await dshHookInstallReport(scanOptions), result5);
         process.stdout.write(`wingman:dsh profile \u63A5\u7EBF\u5904\u7406\u5B8C\u6210(POST http://127.0.0.1:${port}/hook?harness=dsh)\u3002
 \u5199\u524D\u5DF2\u5907\u4EFD;\u91CD\u590D\u6267\u884C\u5E42\u7B49;\u89E3\u7EBF:wingman hook uninstall dsh
 `);
@@ -18681,14 +19171,14 @@ async function runHook(args) {
 `);
       }
     } else if (harness === "dsh") {
-      const result4 = await uninstallDshHooks(scanOptions);
+      const result5 = await uninstallDshHooks(scanOptions);
       const messages = {
         unwired: "\u5DF2\u89E3\u7EBF",
         state: "\u5DF2\u6062\u590D",
         removed: "\u5DF2\u79FB\u9664\u6B8B\u7559\u5757",
         cleared: "\u5DF2\u6E05\u7406\u8BB0\u5F55"
       };
-      for (const profile2 of result4.profiles) {
+      for (const profile2 of result5.profiles) {
         process.stdout.write(`${profile2.profile}:${messages[profile2.restored]}
 `);
       }
@@ -18709,16 +19199,16 @@ function writeDshInstallReport(report, installResult) {
     process.stdout.write("\u672A\u53D1\u73B0\u542B package.json \u7684 dsh profile\u3002\n");
     return;
   }
-  for (const result4 of report.profiles) {
-    if (result4.wired) {
-      process.stdout.write(`${result4.profile}:\u5DF2\u63A5\u7EBF
+  for (const result5 of report.profiles) {
+    if (result5.wired) {
+      process.stdout.write(`${result5.profile}:\u5DF2\u63A5\u7EBF
 `);
-    } else if (result4.missingPackages.length > 0) {
-      const removed = installResult.removedProfiles.includes(result4.profile) ? "\u5DF2\u79FB\u9664\u65E7\u63A5\u7EBF\u5757," : "";
-      process.stdout.write(`${result4.profile}:\u672A\u63A5\u7EBF,${removed}\u7F3A ${result4.missingPackages.join("\u3001")} \u2192 ${result4.installCommand ?? ""}
+    } else if (result5.missingPackages.length > 0) {
+      const removed = installResult.removedProfiles.includes(result5.profile) ? "\u5DF2\u79FB\u9664\u65E7\u63A5\u7EBF\u5757," : "";
+      process.stdout.write(`${result5.profile}:\u672A\u63A5\u7EBF,${removed}\u7F3A ${result5.missingPackages.join("\u3001")} \u2192 ${result5.installCommand ?? ""}
 `);
     } else {
-      process.stdout.write(`${result4.profile}:\u672A\u63A5\u7EBF
+      process.stdout.write(`${result5.profile}:\u672A\u63A5\u7EBF
 `);
     }
   }
@@ -18798,7 +19288,7 @@ main(process.argv.slice(2)).then((code) => {
     process.stderr.write(`
 ${HELP}`);
   }
-  process.exitCode = 1;
+  process.exitCode = error instanceof ProtocolUsageError ? 2 : 1;
 });
 /*! Bundled license information: