mancode 0.5.1 → 0.5.3

package/dist/cli.js

@@ -134,7 +134,7 @@ import {
   stageV3AdapterUpgradeFiles,
   v3AdapterTargetPath,
   v3AdapterVersionsFromStatuses
-} from "./chunk-SOZ5OUAG.js";
+} from "./chunk-2JOKDC3X.js";
 
 // src/cli.ts
 import { Option, program } from "commander";
@@ -9883,7 +9883,7 @@ async function activateLegacyMigration(input) {
       for (const action of payload.actions.filter(
         (action2) => action2.kind === "v3_adapter_file"
       )) {
-        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-CRSQO3XW.js");
+        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-DBVEX5H5.js");
         await applyV3AdapterFilePlan2(root, action);
       }
       journal = await completeActivationStep(
@@ -13739,7 +13739,7 @@ async function upgradeV3Adapters(input) {
   if (unfinished.length > 0) {
     throw new Error("MANCODE_ADAPTER_UPGRADE_OPERATION_PENDING");
   }
-  const actualVersions = await import("./v3-adapter-CRSQO3XW.js").then(
+  const actualVersions = await import("./v3-adapter-DBVEX5H5.js").then(
     ({ inspectV3AdapterVersions: inspectV3AdapterVersions2 }) => inspectV3AdapterVersions2(
       root,
       managedAdapterNames(project.manifest.managedAdapters)
@@ -14341,6 +14341,7 @@ var SCOUT_AGENT = {
 - \u53EA\u5217\u5BF9\u5B9E\u65BD\u6709\u7528\u7684\u4FE1\u606F
 - \u627E\u5230\u98CE\u9669\u70B9\u8981\u6807\u6CE8\uFF08\u26A0\uFE0F\uFF09
 - \u4E0D\u786E\u5B9A\u7684\u8981\u660E\u8BF4\uFF0C\u4E0D\u731C
+- \u5B58\u5728 \`.mancode/shared/context/glossary.json\` \u65F6\uFF0C\u62A5\u544A\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u672F\u8BED\uFF1B\u53D1\u73B0\u65B0\u7684\u9AD8\u9891\u9886\u57DF\u8BCD\u53EF\u5728\u62A5\u544A\u4E2D\u5217\u4E3A\u5EFA\u8BAE\u8BCD\u6761\uFF08\u4EC5\u5EFA\u8BAE\uFF0C\u4E0D\u5199\u5165\u672F\u8BED\u8868\uFF09
 - \u5F15\u7528\u6587\u4EF6\u7528 \`path:line\` \u683C\u5F0F\uFF0C\u8BA9 Head Coach \u4E00\u79D2\u8DF3\u8FC7\u53BB
 
 ## \u4F60\u4E0D\u662F\u51B3\u7B56\u8005
@@ -14453,7 +14454,7 @@ var PLAN_COACH_AGENT = {
   tools: ["Read", "Grep", "Glob"],
   body: `\u4F60\u662F mancode \u6559\u7EC3\u7EC4\u7684 Plan Coach\uFF08\u8BA1\u5212\u6559\u7EC3\uFF09\u3002
 
-\u4F60\u7684\u804C\u8D23\uFF1A\u5148\u68C0\u67E5\u9700\u6C42\u662F\u5426\u8DB3\u591F\u652F\u6491\u8BA1\u5212\uFF0C\u518D\u5728\u7528\u6237\u786E\u8BA4\u524D\u628A Scout Report\u3001\u7ED3\u6784\u5316 requirements \u548C\u56E2\u961F\u4E0A\u4E0B\u6587\u6574\u7406\u6210\u53EF\u6267\u884C plan\u3002
+\u4F60\u7684\u804C\u8D23\uFF1A\u5148\u68C0\u67E5\u9700\u6C42\u662F\u5426\u8DB3\u591F\u652F\u6491\u8BA1\u5212\uFF0C\u518D\u5728\u7528\u6237\u786E\u8BA4\u524D\u628A Scout Report\u3001\u7ED3\u6784\u5316 requirements \u548C\u56E2\u961F\u4E0A\u4E0B\u6587\u6574\u7406\u6210\u53EF\u6267\u884C plan\u3002\u5B58\u5728 \`.mancode/shared/context/glossary.json\` \u65F6\uFF0C\u8BA1\u5212\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u672F\u8BED\uFF1B\u53D1\u73B0\u65B0\u7684\u9AD8\u9891\u9886\u57DF\u8BCD\u53EF\u5728\u8BA1\u5212\u4E2D\u5217\u4E3A\u5EFA\u8BAE\u8BCD\u6761\uFF08\u4EC5\u5EFA\u8BAE\uFF0C\u4E0D\u5199\u5165\u672F\u8BED\u8868\uFF09\u3002
 
 ## \u786C\u7EA6\u675F
 
@@ -15321,7 +15322,7 @@ var MAN_SKILL = {
 
 ### Step 1: Scout \u8C03\u7814
 
-\u8C03\u7528 \`scout\`\uFF0C\u5199 \`scout-report.md\`\u3002\u62A5\u544A\u5FC5\u987B\u5305\u542B\u201C**\u4E0D\u786E\u5B9A\u7684\u5730\u65B9**\u201D\uFF0C\u5E76\u6309\u53EF\u9A8C\u8BC1\u4E8B\u5B9E\u8865\u5145 Current Behavior Evidence\u3001Candidate Semantic Owner\u3001Source of Truth\u3001Historical / Compatibility Impact\uFF1B\u5B57\u6BB5\u4E0D\u76F8\u5173\u6216\u65E0\u6CD5\u9A8C\u8BC1\u65F6\u53EF\u4EE5\u7701\u7565\uFF0C\u4E0D\u80FD\u7F16\u9020\u3002Current Behavior Evidence \u81F3\u5C11\u6709\u4E00\u4E2A\u53EF\u590D\u73B0\u89C2\u5BDF\u548C\u4ED3\u5E93\u8DEF\u5F84\u3001\u6D4B\u8BD5\u6216\u547D\u4EE4\u8BC1\u636E\uFF1Bowner \u5199\u7F6E\u4FE1\u5EA6\u4E0E\u51B2\u7A81\uFF1Bsource of truth \u533A\u5206 authority \u548C derived copy\uFF1B\u517C\u5BB9\u5F71\u54CD\u8986\u76D6\u65E7 workflow\u3001legacy fixture\u3001transport\u3001\u8FC1\u79FB\u548C rollback\u3002\u8FD0\u884C \`mancode workflow update <taskId> --step 2\`\u3002
+\u5148\u8BFB \`.mancode/shared/context/glossary.json\`\uFF08\u82E5\u5B58\u5728\uFF09\uFF0C\u8C03\u7814\u3001\u62A5\u544A\u4E0E\u540E\u7EED\u6C9F\u901A\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u5DF2\u786E\u8BA4\u672F\u8BED\u3002\u8C03\u7528 \`scout\`\uFF0C\u5199 \`scout-report.md\`\u3002\u62A5\u544A\u5FC5\u987B\u5305\u542B\u201C**\u4E0D\u786E\u5B9A\u7684\u5730\u65B9**\u201D\uFF0C\u5E76\u6309\u53EF\u9A8C\u8BC1\u4E8B\u5B9E\u8865\u5145 Current Behavior Evidence\u3001Candidate Semantic Owner\u3001Source of Truth\u3001Historical / Compatibility Impact\uFF1B\u5B57\u6BB5\u4E0D\u76F8\u5173\u6216\u65E0\u6CD5\u9A8C\u8BC1\u65F6\u53EF\u4EE5\u7701\u7565\uFF0C\u4E0D\u80FD\u7F16\u9020\u3002Current Behavior Evidence \u81F3\u5C11\u6709\u4E00\u4E2A\u53EF\u590D\u73B0\u89C2\u5BDF\u548C\u4ED3\u5E93\u8DEF\u5F84\u3001\u6D4B\u8BD5\u6216\u547D\u4EE4\u8BC1\u636E\uFF1Bowner \u5199\u7F6E\u4FE1\u5EA6\u4E0E\u51B2\u7A81\uFF1Bsource of truth \u533A\u5206 authority \u548C derived copy\uFF1B\u517C\u5BB9\u5F71\u54CD\u8986\u76D6\u65E7 workflow\u3001legacy fixture\u3001transport\u3001\u8FC1\u79FB\u548C rollback\u3002\u8FD0\u884C \`mancode workflow update <taskId> --step 2\`\u3002
 
 ### Step 2: \u9700\u6C42\u6F84\u6E05
 
@@ -15388,7 +15389,7 @@ Plan Coach \u5FC5\u987B\u8BC1\u660E\u6240\u6709\u9009\u9879\u89E3\u51B3\u540C\u4
 2. remediation \u4F1A\u4F7F\u65E7\u9A8C\u8BC1\u6574\u6279\u5931\u6548\u3002\u5728 Step 9 \u91CD\u8DD1\u5168\u90E8 required \u9A8C\u6536\uFF0C\u5E76\u901A\u8FC7 verify record/require-manual/confirm-manual \u91CD\u65B0\u767B\u8BB0\u8BC1\u636E\uFF1B\u672A\u91CD\u65B0\u5168\u90E8\u901A\u8FC7\u4E0D\u80FD completed\u3002\u4E0D\u91CD\u65B0\u8FD0\u884C\u5DF2\u5B8C\u6210\u7684 reviewer\u3002\u4FEE\u590D\u82E5\u5F15\u5165\u65B0\u7684\u9AD8\u98CE\u9669\u9762\u5219\u6807\u8BB0 blocked\uFF0C\u4E0D\u80FD\u5F00\u542F\u65E0\u754C review \u5FAA\u73AF\u3002
 3. \u5199 \`summary.md\`\uFF1A\u6539\u52A8\u3001\u65B0\u5EFA\u3001\u590D\u7528\u3001\u9A8C\u8BC1\u3001\u5BA1\u67E5\u6DF1\u5EA6\u3001findings \u5904\u7F6E\u3001\u8DF3\u8FC7\u6B65\u9AA4\u548C\u6B8B\u4F59\u98CE\u9669\u3002
 4. CLI \u786E\u8BA4\u6240\u9700\u5BA1\u67E5\u9886\u57DF\u5B8C\u6210\u4E14 blocker \u6E05\u96F6\u540E\u624D\u5199 \`completed\`\uFF1B\u5426\u5219\u7528 \`--status blocked --blocking-reason "<\u539F\u56E0>"\`\u3002
-5. \u5173\u952E\u51B3\u7B56 appendTeamDecision \u5230 \`decisions.md\`\uFF0C\u66F4\u65B0 Active Plans\u3002
+5. \u5173\u952E\u51B3\u7B56 appendTeamDecision \u5230 \`decisions.md\`\uFF0C\u66F4\u65B0 Active Plans\u3002\u53D1\u73B0\u65B0\u7684\u9AD8\u9891\u9886\u57DF\u8BCD\u65F6\u5411\u7528\u6237\u63D0\u8BAE\uFF0C\u7ECF\u7528\u6237\u786E\u8BA4\u540E\u7528 \`mancode context glossary add\` \u767B\u8BB0\uFF0C\u4E0D\u5F97\u672A\u7ECF\u786E\u8BA4\u5199\u5165\u672F\u8BED\u8868\u3002
 6. worktree \u5408\u5E76\u524D\u53D6\u5F97\u7528\u6237\u786E\u8BA4\uFF1B\u7EC8\u6001\u5199\u5165\u6210\u529F\u540E state \u56DE solo \u5E76\u6E05\u7A7A workflow \u6307\u9488\u3002
 
 \u4EFB\u4F55 step/status/outcome/planVersion \u53D8\u5316\u90FD\u5FC5\u987B\u7ECF\u8FC7 workflow CLI\uFF1BCLI \u62D2\u7EDD\u65F6\u4FDD\u7559\u5F53\u524D state \u5E76\u62A5\u544A\u539F\u56E0\uFF0C\u4E0D\u53EF\u7ED5\u8FC7\u6821\u9A8C\u76F4\u63A5\u6539 metadata.json\u3002
@@ -15615,7 +15616,7 @@ var MANSOLO_SKILL = {
   description: "Switch back to solo mode. Clears the current workflow state and returns to lightweight daily-practice mode.",
   body: `# mancode \xB7 /mansolo (Back to Practice)
 
-\u7528\u6237\u7528 \`/mansolo\` \u89E6\u53D1\u4F60\u3002\u8FD9\u662F**\u5207\u56DE solo \u6A21\u5F0F**\u7684\u547D\u4EE4\u3002
+\u7528\u6237\u7528 \`/mansolo\` \u89E6\u53D1\u4F60\u3002\u8FD9\u662F**\u5207\u56DE solo \u6A21\u5F0F**\u7684\u547D\u4EE4\u3002\u5B58\u5728 \`.mancode/shared/context/glossary.json\` \u65F6\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u672F\u8BED\u3002
 
 ## \u4F60\u8981\u505A\u7684
 
@@ -15673,7 +15674,7 @@ var MANTEAM_SKILL = {
   description: "Team workflow for shared repositories. Adds contributor context, coordination notes, commit discipline, and hand-off summaries to the full /man flow.",
   body: `# mancode \xB7 /manteam (Team Game)
 
-\u7528\u6237\u7528 \`/manteam <task>\` \u89E6\u53D1\u4F60\u3002\u8FD9\u662F\u591A\u4EBA\u534F\u4F5C\u7248\u7684\u5B8C\u6574\u5DE5\u4F5C\u6D41\uFF1A\u5148\u7406\u89E3\u56E2\u961F\u4E0A\u4E0B\u6587\uFF0C\u518D\u6309 /man \u7684 9 \u6B65\u6D41\u7A0B\u63A8\u8FDB\u3002
+\u7528\u6237\u7528 \`/manteam <task>\` \u89E6\u53D1\u4F60\u3002\u8FD9\u662F\u591A\u4EBA\u534F\u4F5C\u7248\u7684\u5B8C\u6574\u5DE5\u4F5C\u6D41\uFF1A\u5148\u7406\u89E3\u56E2\u961F\u4E0A\u4E0B\u6587\uFF0C\u518D\u6309 /man \u7684 9 \u6B65\u6D41\u7A0B\u63A8\u8FDB\u3002\u5B58\u5728 \`.mancode/shared/context/glossary.json\` \u65F6\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u672F\u8BED\u3002
 
 \u7528 \`mancode workflow create manteam "<task>" --json\` \u521B\u5EFA workflow\uFF0C\u5E76\u5C06 state \u6307\u5411\u8FD4\u56DE\u7684 taskId\u3002\u540E\u7EED step/status/planVersion/skippedSteps \u5168\u90E8\u4F7F\u7528 \`mancode workflow update\`\uFF1B\u4E0D\u5F97\u76F4\u63A5\u6539 metadata.json\u3002\u82E5\u5DF2\u6709 active workflow\uFF0C\u5148\u8BA9\u7528\u6237\u9009\u62E9\u6062\u590D\u6216\u653E\u5F03\uFF0C\u4E0D\u80FD\u6E05\u7A7A\u65E7\u6307\u9488\u3002
 
@@ -18122,7 +18123,7 @@ function commandClient(value) {
 }
 function printV3Result(json, result2) {
   if (json) {
-    console.log(JSON.stringify(result2, null, 2));
+    console.log(JSON.stringify(result2));
   } else {
     console.log(JSON.stringify(result2, null, 2));
   }
@@ -18131,7 +18132,7 @@ function printV3Result(json, result2) {
 function printV3Error(json, code, message, exitCode = EXIT_V3_BLOCKED) {
   const result2 = { schemaVersion: 1, error: { code, message } };
   if (json) {
-    console.log(JSON.stringify(result2, null, 2));
+    console.log(JSON.stringify(result2));
   } else {
     console.error(`\u2717  ${code}`);
     console.error(`   ${message}`);
@@ -18235,9 +18236,263 @@ function selectUpgradePlatforms(options) {
   return options.all === true ? [...V3_ADAPTER_PLATFORMS] : selectStatusPlatforms(options.platform);
 }
 
-// src/context/publish-promote.ts
-import { lstat as lstat12, mkdir as mkdir27, rename as rename9, rm as rm14, writeFile as writeFile33 } from "fs/promises";
+// src/context/glossary.ts
+import { mkdir as mkdir27, readFile as readFile30, rename as rename9, rm as rm14, writeFile as writeFile33 } from "fs/promises";
 import path37 from "path";
+var GLOSSARY_TERM_MAX_LENGTH = 64;
+var GLOSSARY_DEFINITION_MAX_LENGTH = 500;
+var GLOSSARY_MAX_ENTRIES = 200;
+var GLOSSARY_LOCK_KEY = "glossary:project";
+function emptyProjectGlossary() {
+  return { schemaVersion: 1, revision: 0, entries: [] };
+}
+function parseProjectGlossary(value) {
+  assertRecord(value, "project glossary");
+  assertKnownKeys(
+    value,
+    ["schemaVersion", "revision", "entries"],
+    "project glossary"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("project glossary schemaVersion must be 1");
+  }
+  const revision = value.revision;
+  if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0) {
+    throw new Error("project glossary revision must be a non-negative integer");
+  }
+  if (!Array.isArray(value.entries)) {
+    throw new Error("project glossary entries must be an array");
+  }
+  if (value.entries.length > GLOSSARY_MAX_ENTRIES) {
+    throw new Error("MANCODE_GLOSSARY_ENTRY_LIMIT_EXCEEDED");
+  }
+  const entries = value.entries.map((entry) => parseGlossaryEntry(entry));
+  assertGlobalTermUniqueness(entries);
+  return { schemaVersion: 1, revision, entries };
+}
+function parseGlossaryEntry(value) {
+  assertRecord(value, "glossary entry");
+  assertKnownKeys(
+    value,
+    ["term", "definition", "aliases", "sourceTaskRef", "confirmedAt"],
+    "glossary entry"
+  );
+  const term = parseGlossaryText(
+    value.term,
+    "glossary term",
+    GLOSSARY_TERM_MAX_LENGTH
+  );
+  const definition2 = parseGlossaryText(
+    value.definition,
+    "glossary definition",
+    GLOSSARY_DEFINITION_MAX_LENGTH
+  );
+  if (!Array.isArray(value.aliases)) {
+    throw new Error("glossary entry aliases must be an array");
+  }
+  const aliases = value.aliases.map(
+    (alias) => parseGlossaryText(alias, "glossary alias", GLOSSARY_TERM_MAX_LENGTH)
+  );
+  const localKeys = /* @__PURE__ */ new Set([termKey(term)]);
+  for (const alias of aliases) {
+    const key = termKey(alias);
+    if (localKeys.has(key)) {
+      throw new Error(`MANCODE_GLOSSARY_TERM_CONFLICT: ${alias}`);
+    }
+    localKeys.add(key);
+  }
+  const sourceTaskRef = value.sourceTaskRef === null ? null : parseTaskRefValue(value.sourceTaskRef);
+  if (sourceTaskRef?.namespace === "local") {
+    throw new Error("MANCODE_GLOSSARY_LOCAL_TASK_FORBIDDEN");
+  }
+  return {
+    term,
+    definition: definition2,
+    aliases,
+    sourceTaskRef,
+    confirmedAt: parseTimestamp12(value.confirmedAt, "glossary confirmedAt")
+  };
+}
+function projectGlossaryPath(projectRoot) {
+  return path37.join(
+    path37.resolve(projectRoot),
+    ".mancode",
+    "shared",
+    "context",
+    "glossary.json"
+  );
+}
+async function readProjectGlossary(projectRoot) {
+  try {
+    return parseProjectGlossary(
+      JSON.parse(await readFile30(projectGlossaryPath(projectRoot), "utf8"))
+    );
+  } catch (error) {
+    if (isNotFound20(error)) return emptyProjectGlossary();
+    if (error instanceof SyntaxError) {
+      throw new Error(
+        "MANCODE_CONTEXT_ENTITY_CORRUPT: shared/context/glossary.json"
+      );
+    }
+    throw error;
+  }
+}
+function findGlossaryEntry(glossary, term) {
+  const key = termKey(term);
+  return glossary.entries.find(
+    (entry) => termKey(entry.term) === key || entry.aliases.some((alias) => termKey(alias) === key)
+  ) ?? null;
+}
+async function addGlossaryEntry(projectRoot, store, expectedRevision, input) {
+  return mutateProjectGlossary(
+    projectRoot,
+    store,
+    expectedRevision,
+    (glossary) => {
+      if (findGlossaryEntry(glossary, input.term) !== null) {
+        throw new Error(`MANCODE_GLOSSARY_TERM_EXISTS: ${input.term}`);
+      }
+      if (glossary.entries.length >= GLOSSARY_MAX_ENTRIES) {
+        throw new Error("MANCODE_GLOSSARY_ENTRY_LIMIT_EXCEEDED");
+      }
+      return [
+        ...glossary.entries,
+        {
+          term: input.term,
+          definition: input.definition,
+          aliases: input.aliases ?? [],
+          sourceTaskRef: input.sourceTaskRef ?? null,
+          confirmedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+    }
+  );
+}
+async function updateGlossaryEntry(projectRoot, store, expectedRevision, input) {
+  return mutateProjectGlossary(
+    projectRoot,
+    store,
+    expectedRevision,
+    (glossary) => {
+      const key = termKey(input.term);
+      const index = glossary.entries.findIndex(
+        (entry) => termKey(entry.term) === key
+      );
+      if (index === -1) {
+        throw new Error(`MANCODE_GLOSSARY_TERM_NOT_FOUND: ${input.term}`);
+      }
+      const previous = glossary.entries[index];
+      const next = {
+        term: previous.term,
+        definition: input.definition ?? previous.definition,
+        aliases: input.aliases ?? previous.aliases,
+        sourceTaskRef: input.sourceTaskRef === void 0 ? previous.sourceTaskRef : input.sourceTaskRef,
+        confirmedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
+      };
+      return glossary.entries.map(
+        (entry, position) => position === index ? next : entry
+      );
+    }
+  );
+}
+async function removeGlossaryEntry(projectRoot, store, expectedRevision, term) {
+  return mutateProjectGlossary(
+    projectRoot,
+    store,
+    expectedRevision,
+    (glossary) => {
+      const key = termKey(term);
+      const remaining = glossary.entries.filter(
+        (entry) => termKey(entry.term) !== key
+      );
+      if (remaining.length === glossary.entries.length) {
+        throw new Error(`MANCODE_GLOSSARY_TERM_NOT_FOUND: ${term}`);
+      }
+      return remaining;
+    }
+  );
+}
+async function mutateProjectGlossary(projectRoot, store, expectedRevision, mutate) {
+  if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+    throw new Error(
+      "MANCODE_GLOSSARY_EXPECTED_REVISION_INVALID: expected revision must be a non-negative integer"
+    );
+  }
+  const lock = await acquireLocalLock(store, {
+    operationId: createUlid(),
+    entityLockKey: GLOSSARY_LOCK_KEY
+  });
+  try {
+    const current = await readProjectGlossary(projectRoot);
+    if (current.revision !== expectedRevision) {
+      throw new Error(
+        `MANCODE_GLOSSARY_REVISION_CONFLICT: expected ${expectedRevision}, found ${current.revision}`
+      );
+    }
+    const next = parseProjectGlossary({
+      schemaVersion: 1,
+      revision: current.revision + 1,
+      entries: mutate(current)
+    });
+    await writeGlossaryFile(projectRoot, next);
+    return next;
+  } finally {
+    await lock.release().catch(() => void 0);
+  }
+}
+async function writeGlossaryFile(projectRoot, glossary) {
+  const target = projectGlossaryPath(projectRoot);
+  await mkdir27(path37.dirname(target), { recursive: true });
+  const temporary = path37.join(
+    path37.dirname(target),
+    `.${path37.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    await writeFile33(temporary, `${JSON.stringify(glossary, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    await rename9(temporary, target);
+  } finally {
+    await rm14(temporary, { force: true }).catch(() => void 0);
+  }
+}
+function assertGlobalTermUniqueness(entries) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    for (const candidate of [entry.term, ...entry.aliases]) {
+      const key = termKey(candidate);
+      if (keys.has(key)) {
+        throw new Error(`MANCODE_GLOSSARY_TERM_CONFLICT: ${candidate}`);
+      }
+      keys.add(key);
+    }
+  }
+}
+function termKey(value) {
+  return value.trim().toLowerCase();
+}
+function parseGlossaryText(value, label, maxLength) {
+  if (typeof value !== "string" || !value.trim() || value.includes("\0") || value.length > maxLength) {
+    throw new Error(`${label} is invalid`);
+  }
+  assertSharedTextSafe(value, label);
+  return value;
+}
+function parseTimestamp12(value, label) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new Error(`${label} must be an ISO timestamp`);
+  }
+  return value;
+}
+function isNotFound20(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/context/publish-promote.ts
+import { lstat as lstat12, mkdir as mkdir28, rename as rename10, rm as rm15, writeFile as writeFile34 } from "fs/promises";
+import path38 from "path";
 
 // src/context/task-mutation.ts
 function markTaskReviewStale(previous, operationId, updatedAt) {
@@ -18969,15 +19224,15 @@ async function stageDestinationAuthority(projectRoot, destinationTaskRef, operat
   const target = taskRootPath(projectRoot, destinationTaskRef);
   const parent = await ensureSafeTaskParent2(projectRoot, destinationTaskRef);
   await assertPathAbsent(target, "MANCODE_PROMOTION_DESTINATION_EXISTS");
-  const staging = path37.join(
+  const staging = path38.join(
     parent,
     `.${destinationTaskRef.taskId}.${operationId}.staging`
   );
   await assertPathAbsent(staging, "MANCODE_PROMOTION_STAGING_CONFLICT");
-  await mkdir27(staging);
+  await mkdir28(staging);
   try {
     for (const [fileName, content] of Object.entries(contents)) {
-      await writeFile33(path37.join(staging, fileName), content, {
+      await writeFile34(path38.join(staging, fileName), content, {
         encoding: "utf8",
         flag: "wx"
       });
@@ -18985,7 +19240,7 @@ async function stageDestinationAuthority(projectRoot, destinationTaskRef, operat
     await assertSafeDirectory3(staging);
     return staging;
   } catch (error) {
-    await rm14(staging, { recursive: true, force: true });
+    await rm15(staging, { recursive: true, force: true });
     throw error;
   }
 }
@@ -18993,11 +19248,11 @@ async function ensureSafeTaskParent2(projectRoot, taskRef) {
   await assertSafeDirectory3(projectRoot);
   let current = projectRoot;
   for (const segment of [".mancode", taskRef.namespace, "workflows"]) {
-    current = path37.join(current, segment);
+    current = path38.join(current, segment);
     const existing = await lstatOrNull2(current);
     if (existing === null) {
       try {
-        await mkdir27(current);
+        await mkdir28(current);
         continue;
       } catch (error) {
         if (!isAlreadyExists16(error)) throw error;
@@ -19014,7 +19269,7 @@ async function publishStagedDestination(projectRoot, destinationTaskRef, staging
   const target = taskRootPath(projectRoot, destinationTaskRef);
   await assertSafeDirectory3(staging);
   await assertPathAbsent(target, "MANCODE_PROMOTION_DESTINATION_EXISTS");
-  await rename9(staging, target);
+  await rename10(staging, target);
   await assertSafeDirectory3(target);
 }
 async function assertDestinationAbsent(projectRoot, destinationHomeStore, destinationTaskRef) {
@@ -19169,7 +19424,7 @@ async function handlePromotionFailure(source, primaryStore, journal, stagingDire
   } catch {
   } finally {
     if (stagingDirectory !== null) {
-      await rm14(stagingDirectory, { recursive: true, force: true });
+      await rm15(stagingDirectory, { recursive: true, force: true });
     }
   }
 }
@@ -19178,41 +19433,41 @@ async function renewPromotionLocks(source) {
 }
 async function writePromotionQuarantine(projectRoot, operationId, candidate, contents) {
   const directory = publishStagingDirectory(projectRoot, operationId);
-  const parent = path37.dirname(directory);
-  await mkdir27(parent, { recursive: true });
+  const parent = path38.dirname(directory);
+  await mkdir28(parent, { recursive: true });
   await assertSafeDirectory3(parent);
   await assertPathAbsent(directory, "MANCODE_PROMOTION_QUARANTINE_CONFLICT");
-  await mkdir27(directory);
+  await mkdir28(directory);
   try {
-    await writeFile33(
-      path37.join(directory, "candidate.json"),
+    await writeFile34(
+      path38.join(directory, "candidate.json"),
       serializeTaskAuthority(candidate),
       { encoding: "utf8", flag: "wx" }
     );
     for (const [fileName, content] of Object.entries(contents)) {
-      await writeFile33(path37.join(directory, fileName), content, {
+      await writeFile34(path38.join(directory, fileName), content, {
         encoding: "utf8",
         flag: "wx"
       });
     }
   } catch (error) {
-    await rm14(directory, { recursive: true, force: true });
+    await rm15(directory, { recursive: true, force: true });
     throw error;
   }
 }
 async function rewritePromotionQuarantine(projectRoot, operationId, candidate) {
   const directory = publishStagingDirectory(projectRoot, operationId);
   await assertSafeDirectory3(directory);
-  const target = path37.join(directory, "candidate.json");
-  const temporary = path37.join(
+  const target = path38.join(directory, "candidate.json");
+  const temporary = path38.join(
     directory,
     `.candidate.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile33(temporary, serializeTaskAuthority(candidate), {
+  await writeFile34(temporary, serializeTaskAuthority(candidate), {
     encoding: "utf8",
     flag: "wx"
   });
-  await rename9(temporary, target);
+  await rename10(temporary, target);
 }
 function completeOperationStep2(steps, stepId) {
   const index = steps.findIndex((step) => step.id === stepId);
@@ -19254,11 +19509,11 @@ async function lstatOrNull2(target) {
   try {
     return await lstat12(target);
   } catch (error) {
-    if (isNotFound20(error)) return null;
+    if (isNotFound21(error)) return null;
     throw error;
   }
 }
-function isNotFound20(error) {
+function isNotFound21(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExists16(error) {
@@ -20026,7 +20281,7 @@ function compareUtf89(left, right) {
 
 // src/context/task-head-reconcile.ts
 import { execFile as execFileCallback4 } from "child_process";
-import path39 from "path";
+import path40 from "path";
 import { promisify as promisify4 } from "util";
 
 // src/team/conflicts.ts
@@ -20226,9 +20481,9 @@ function unique(values) {
 
 // src/team/git-ref-transport.ts
 import { execFile as execFileCallback3 } from "child_process";
-import { mkdtemp, rm as rm15, writeFile as writeFile34 } from "fs/promises";
+import { mkdtemp, rm as rm16, writeFile as writeFile35 } from "fs/promises";
 import { tmpdir } from "os";
-import path38 from "path";
+import path39 from "path";
 import { promisify as promisify3 } from "util";
 var execFile3 = promisify3(execFileCallback3);
 var TEAM_REF = "refs/mancode/team";
@@ -20251,7 +20506,7 @@ async function resolveGitRefRemoteIdentityHash(projectRoot, remote) {
   }
   let configured = remote;
   try {
-    const output = await runGit2(path38.resolve(projectRoot), [
+    const output = await runGit2(path39.resolve(projectRoot), [
       "remote",
       "get-url",
       "--all",
@@ -20301,7 +20556,7 @@ var GitRefTeamManifestStore = class {
       "git-ref configRevision"
     );
     parseOptionalDigest(options.configDigest, "git-ref configDigest");
-    this.projectRoot = path38.resolve(options.projectRoot);
+    this.projectRoot = path39.resolve(options.projectRoot);
     this.remote = options.remote;
     this.workspaceId = options.workspaceId;
     this.expectedHeader = {
@@ -21023,7 +21278,7 @@ function parseGitRefTeamManifest(value) {
       parseGitRefRemoteMutationReceipt
     ).sort(compareReceipts),
     lastMutation: normalized.lastMutation === null ? null : parseGitRefRemoteMutationReceipt(normalized.lastMutation),
-    updatedAt: parseTimestamp12(
+    updatedAt: parseTimestamp13(
       normalized.updatedAt,
       "git-ref team manifest updatedAt"
     )
@@ -21078,7 +21333,7 @@ function parseGitRefOwnershipFence(value) {
       "git-ref ownership fence remoteRevision"
     ),
     lastOperationId: value.lastOperationId,
-    updatedAt: parseTimestamp12(
+    updatedAt: parseTimestamp13(
       value.updatedAt,
       "git-ref ownership fence updatedAt"
     )
@@ -21141,7 +21396,7 @@ function parseGitRefTaskBundle(value) {
       value.bundleDigest,
       "git-ref task bundle bundleDigest"
     ),
-    createdAt: parseTimestamp12(value.createdAt, "git-ref task bundle createdAt")
+    createdAt: parseTimestamp13(value.createdAt, "git-ref task bundle createdAt")
   };
   assertTaskBundleConsistency(bundle);
   const { bundleDigest: _digest, ...body } = bundle;
@@ -21197,7 +21452,7 @@ function parseGitRefRemoteMutationReceipt(value) {
     ),
     ownershipEpoch,
     entityDigests: parseReceiptEntityDigests(value.entityDigests),
-    committedAt: parseTimestamp12(
+    committedAt: parseTimestamp13(
       value.committedAt,
       "git-ref mutation receipt committedAt"
     )
@@ -21231,7 +21486,7 @@ function parseGitRefAuthorityTombstone(value) {
       "git-ref authority tombstone successorEpoch"
     ),
     operationId: value.operationId,
-    tombstonedAt: parseTimestamp12(
+    tombstonedAt: parseTimestamp13(
       value.tombstonedAt,
       "git-ref authority tombstone tombstonedAt"
     )
@@ -21265,7 +21520,7 @@ function parseGitRefAuthorityFreeze(value) {
       "git-ref authority freeze successorEpoch"
     ),
     operationId: value.operationId,
-    frozenAt: parseTimestamp12(
+    frozenAt: parseTimestamp13(
       value.frozenAt,
       "git-ref authority freeze frozenAt"
     )
@@ -22007,17 +22262,17 @@ function upsertActorProfile(profiles, profile) {
 }
 async function writeManifestCommit(projectRoot, parent, manifest, now) {
   const temporaryDirectory = await mkdtemp(
-    path38.join(tmpdir(), "mancode-git-ref-")
+    path39.join(tmpdir(), "mancode-git-ref-")
   );
-  const manifestPath = path38.join(temporaryDirectory, "manifest.json");
-  const indexPath = path38.join(temporaryDirectory, "index");
+  const manifestPath = path39.join(temporaryDirectory, "manifest.json");
+  const indexPath = path39.join(temporaryDirectory, "index");
   try {
     const serialized = `${JSON.stringify(manifest, null, 2)}
 `;
     if (Buffer.byteLength(serialized, "utf8") > MAX_MANIFEST_BYTES) {
       throw new Error("MANCODE_TRANSPORT_MANIFEST_TOO_LARGE");
     }
-    await writeFile34(manifestPath, serialized);
+    await writeFile35(manifestPath, serialized);
     const blob = (await runGit2(projectRoot, ["hash-object", "-w", manifestPath])).trim();
     const environment = { ...process.env, GIT_INDEX_FILE: indexPath };
     await runGit2(projectRoot, ["read-tree", "--empty"], environment);
@@ -22049,7 +22304,7 @@ async function writeManifestCommit(projectRoot, parent, manifest, now) {
       commitEnvironment
     )).trim();
   } finally {
-    await rm15(temporaryDirectory, { recursive: true, force: true });
+    await rm16(temporaryDirectory, { recursive: true, force: true });
   }
 }
 async function pushWithLease(projectRoot, remote, expectedCommit, commit3) {
@@ -22131,7 +22386,7 @@ function normalizeRemoteIdentity(projectRoot, value) {
     url.pathname = url.pathname.replace(/\/+$/g, "");
     return url.toString();
   } catch {
-    return path38.resolve(projectRoot, value).replaceAll("\\", "/");
+    return path39.resolve(projectRoot, value).replaceAll("\\", "/");
   }
 }
 function parseBundleCodeRef(value) {
@@ -22203,7 +22458,7 @@ function parseVersion(value, label) {
   }
   return value;
 }
-function parseTimestamp12(value, label) {
+function parseTimestamp13(value, label) {
   if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
     throw new Error(`${label} must be an ISO timestamp`);
   }
@@ -22505,8 +22760,8 @@ function injectAfterReconcileStep(stepId) {
   throwIfOperationCrashInjected("task_head_reconcile", stepId);
 }
 async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
-  const relativeTaskRoot = path39.relative(projectRoot, taskRoot2);
-  if (!relativeTaskRoot || path39.isAbsolute(relativeTaskRoot) || relativeTaskRoot.split(path39.sep).some((part) => part === "..")) {
+  const relativeTaskRoot = path40.relative(projectRoot, taskRoot2);
+  if (!relativeTaskRoot || path40.isAbsolute(relativeTaskRoot) || relativeTaskRoot.split(path40.sep).some((part) => part === "..")) {
     throw new Error("MANCODE_TASK_UNAVAILABLE");
   }
   const authorityFiles = [
@@ -22514,7 +22769,7 @@ async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
     "requirements.json",
     "review-ledger.json",
     "verification-ledger.json"
-  ].map((file) => path39.join(relativeTaskRoot, file));
+  ].map((file) => path40.join(relativeTaskRoot, file));
   try {
     await execFile4("git", ["rev-parse", "--verify", "HEAD^{commit}"], {
       cwd: projectRoot,
@@ -22738,12 +22993,12 @@ var BETA_PLATFORMS = [
 ];
 
 // src/runtime/retention.ts
-import { lstat as lstat13, readFile as readFile30, readdir as readdir14, rm as rm16 } from "fs/promises";
-import path40 from "path";
+import { lstat as lstat13, readFile as readFile31, readdir as readdir14, rm as rm17 } from "fs/promises";
+import path41 from "path";
 var TERMINAL_JOURNAL_RETENTION_DAYS = 30;
 var RETAINED_NON_MILESTONE_CHECKPOINTS = 10;
 async function planContextCompaction(input) {
-  const root = path40.resolve(input.projectRoot);
+  const root = path41.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const store = new V3ContextStore(root);
   const [project, runtime] = await Promise.all([
@@ -22816,7 +23071,7 @@ async function planLocalOverlayRetention(root, store, taskRefs, localRawArtifact
     if (taskRef.namespace !== "shared") continue;
     const task = await store.readTaskSnapshot(taskRef);
     if (!isTerminalTaskStatus(task.metadata.status)) continue;
-    const directory = path40.join(
+    const directory = path41.join(
       root,
       ".mancode",
       "local",
@@ -22825,7 +23080,7 @@ async function planLocalOverlayRetention(root, store, taskRefs, localRawArtifact
       "artifacts"
     );
     for (const entry of await readDirectoryOrEmpty(directory)) {
-      const target = path40.join(directory, entry);
+      const target = path41.join(directory, entry);
       const metadata = await regularFileMetadataOrNull(target);
       if (metadata === null || metadata.mtimeMs >= threshold) continue;
       candidates.push({
@@ -22842,7 +23097,7 @@ async function planLocalOverlayRetention(root, store, taskRefs, localRawArtifact
 }
 async function planLocalCacheRetention(root, localCacheDays, now) {
   const threshold = now.getTime() - localCacheDays * 864e5;
-  const directory = path40.join(root, ".mancode", "local", "cache");
+  const directory = path41.join(root, ".mancode", "local", "cache");
   const candidates = [];
   for (const target of await listRegularFilesRecursively(directory)) {
     const metadata = await regularFileMetadataOrNull(target);
@@ -22905,7 +23160,7 @@ async function planCheckpointCompaction(store, coordinationStore, taskRefs, prot
       }
       candidates.push({
         kind: "checkpoint",
-        target: path40.join(
+        target: path41.join(
           task.location.taskRoot,
           "checkpoints",
           `${checkpoint.checkpointId}.json`
@@ -22919,13 +23174,13 @@ async function planCheckpointCompaction(store, coordinationStore, taskRefs, prot
   return { candidates, skippedReferencedCheckpoints };
 }
 async function planCompletedSessionRetention(root, completedSessionDays, now, protectedSessionIds) {
-  const directory = path40.join(root, ".mancode", "local", "sessions");
+  const directory = path41.join(root, ".mancode", "local", "sessions");
   const entries = await readDirectoryOrEmpty(directory);
   const threshold = now.getTime() - completedSessionDays * 864e5;
   const candidates = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const target = path40.join(directory, entry);
+    const target = path41.join(directory, entry);
     const session = parseSessionState(
       JSON.parse(await readRegularFile(target))
     );
@@ -22951,7 +23206,7 @@ async function planOperationRetention(stores, now) {
     const entries = await readDirectoryOrEmpty(directory);
     for (const entry of entries) {
       if (!entry.endsWith(".json")) continue;
-      const target = path40.join(directory, entry);
+      const target = path41.join(directory, entry);
       const journal = parseOperationJournal(
         JSON.parse(await readRegularFile(target))
       );
@@ -23030,7 +23285,7 @@ function isTerminalTaskStatus(status2) {
 async function listTaskRefs(root) {
   const refs = [];
   for (const namespace of ["local", "shared"]) {
-    const directory = path40.join(root, ".mancode", namespace, "workflows");
+    const directory = path41.join(root, ".mancode", namespace, "workflows");
     for (const entry of await readDirectoryOrEmpty(directory)) {
       if (!/^[0-9A-HJKMNP-TV-Z]{26}$/.test(entry)) continue;
       refs.push({ namespace, taskId: entry });
@@ -23043,12 +23298,12 @@ async function listTaskRefs(root) {
   );
 }
 async function listTaskCheckpoints(taskRoot2, taskRef) {
-  const directory = path40.join(taskRoot2, "checkpoints");
+  const directory = path41.join(taskRoot2, "checkpoints");
   const checkpoints = [];
   for (const entry of await readDirectoryOrEmpty(directory)) {
     if (!entry.endsWith(".json")) continue;
     const checkpoint = parseCheckpoint(
-      JSON.parse(await readRegularFile(path40.join(directory, entry)))
+      JSON.parse(await readRegularFile(path41.join(directory, entry)))
     );
     if (!sameTaskRef(checkpoint.taskRef, taskRef) || entry !== `${checkpoint.checkpointId}.json`) {
       throw new Error("MANCODE_RETENTION_CHECKPOINT_CORRUPT");
@@ -23080,14 +23335,14 @@ async function readDirectoryOrEmpty(directory) {
       (left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"))
     );
   } catch (error) {
-    if (isNotFound21(error)) return [];
+    if (isNotFound22(error)) return [];
     throw error;
   }
 }
 async function listRegularFilesRecursively(directory) {
   const files = [];
   for (const entry of await readDirectoryOrEmpty(directory)) {
-    const target = path40.join(directory, entry);
+    const target = path41.join(directory, entry);
     const metadata = await lstatOrNull3(target);
     if (metadata === null) continue;
     if (metadata.isSymbolicLink()) {
@@ -23110,7 +23365,7 @@ async function readRegularFile(target) {
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_RETENTION_PATH_UNSAFE");
   }
-  const content = await readFile30(target, "utf8");
+  const content = await readFile31(target, "utf8");
   const after = await lstat13(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_RETENTION_PATH_UNSAFE");
@@ -23119,14 +23374,14 @@ async function readRegularFile(target) {
 }
 async function removeRegularFile(target) {
   await readRegularFile(target);
-  await rm16(target);
+  await rm17(target);
 }
 async function regularFileExists(target) {
   try {
     await readRegularFile(target);
     return true;
   } catch (error) {
-    if (isNotFound21(error)) return false;
+    if (isNotFound22(error)) return false;
     throw error;
   }
 }
@@ -23142,17 +23397,17 @@ async function lstatOrNull3(target) {
   try {
     return await lstat13(target);
   } catch (error) {
-    if (isNotFound21(error)) return null;
+    if (isNotFound22(error)) return null;
     throw error;
   }
 }
-function isNotFound21(error) {
+function isNotFound22(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/git-ref-cache.ts
-import { lstat as lstat14, mkdir as mkdir28, readFile as readFile31, writeFile as writeFile35 } from "fs/promises";
-import path41 from "path";
+import { lstat as lstat14, mkdir as mkdir29, readFile as readFile32, writeFile as writeFile36 } from "fs/promises";
+import path42 from "path";
 var DEFAULT_GIT_REF_FRESHNESS_TTL_MS = 5 * 60 * 1e3;
 async function writeGitRefTeamCache(projectRoot, config, snapshot) {
   const remote = gitRefRemote(config);
@@ -23168,11 +23423,11 @@ async function writeGitRefTeamCache(projectRoot, config, snapshot) {
   });
   const directory = await ensureSafeCacheDirectory(projectRoot);
   const target = gitRefCachePath(projectRoot);
-  const temporary = path41.join(
+  const temporary = path42.join(
     directory,
     `.snapshot.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile35(temporary, `${JSON.stringify(cache, null, 2)}
+  await writeFile36(temporary, `${JSON.stringify(cache, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -23190,7 +23445,7 @@ async function readGitRefTeamCache(projectRoot, config) {
       throw new Error("MANCODE_TRANSPORT_CACHE_UNSAFE");
     }
     const cache = parseGitRefTeamCache(
-      JSON.parse(await readFile31(target, "utf8"))
+      JSON.parse(await readFile32(target, "utf8"))
     );
     const after = await lstat14(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
@@ -23201,7 +23456,7 @@ async function readGitRefTeamCache(projectRoot, config) {
     }
     return cache;
   } catch (error) {
-    if (isNotFound22(error)) return null;
+    if (isNotFound23(error)) return null;
     if (error instanceof SyntaxError) {
       throw new Error("MANCODE_TRANSPORT_CACHE_CORRUPT");
     }
@@ -23262,7 +23517,7 @@ function parseGitRefTeamCache(value) {
     value.transportEpoch,
     "git-ref cache transportEpoch"
   );
-  const fetchedAt = parseTimestamp13(value.fetchedAt, "git-ref cache fetchedAt");
+  const fetchedAt = parseTimestamp14(value.fetchedAt, "git-ref cache fetchedAt");
   const commit3 = parseCommitOrNull(value.commit);
   const receipt = parseReceiptOrNull(value.receipt);
   const manifest = value.manifest === null ? null : parseGitRefTeamManifest(value.manifest);
@@ -23284,11 +23539,11 @@ function parseGitRefTeamCache(value) {
   };
 }
 function gitRefCachePath(projectRoot) {
-  return path41.join(gitRefCacheDirectory(projectRoot), "snapshot.json");
+  return path42.join(gitRefCacheDirectory(projectRoot), "snapshot.json");
 }
 function gitRefCacheDirectory(projectRoot) {
-  return path41.join(
-    path41.resolve(projectRoot),
+  return path42.join(
+    path42.resolve(projectRoot),
     ".mancode",
     "local",
     "cache",
@@ -23313,7 +23568,7 @@ function parsePositiveInteger4(value, label) {
   }
   return value;
 }
-function parseTimestamp13(value, label) {
+function parseTimestamp14(value, label) {
   if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
     throw new Error(`${label} must be an ISO timestamp`);
   }
@@ -23334,12 +23589,12 @@ function parseReceiptOrNull(value) {
   return value;
 }
 async function ensureSafeCacheDirectory(projectRoot) {
-  const root = path41.resolve(projectRoot);
+  const root = path42.resolve(projectRoot);
   let current = root;
   for (const segment of [".mancode", "local", "cache", "git-ref"]) {
-    current = path41.join(current, segment);
+    current = path42.join(current, segment);
     try {
-      await mkdir28(current);
+      await mkdir29(current);
     } catch (error) {
       if (!isAlreadyExists17(error)) throw error;
     }
@@ -23348,9 +23603,9 @@ async function ensureSafeCacheDirectory(projectRoot) {
   return current;
 }
 async function assertSafeCacheDirectory(projectRoot) {
-  let current = path41.resolve(projectRoot);
+  let current = path42.resolve(projectRoot);
   for (const segment of [".mancode", "local", "cache", "git-ref"]) {
-    current = path41.join(current, segment);
+    current = path42.join(current, segment);
     await assertDirectoryNotLinked(current);
   }
 }
@@ -23360,7 +23615,7 @@ async function assertDirectoryNotLinked(directory) {
     throw new Error("MANCODE_TRANSPORT_CACHE_UNSAFE");
   }
 }
-function isNotFound22(error) {
+function isNotFound23(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExists17(error) {
@@ -23368,24 +23623,24 @@ function isAlreadyExists17(error) {
 }
 
 // src/team/git-ref-workflow-repair.ts
-import { lstat as lstat18, mkdir as mkdir32, readFile as readFile35, readdir as readdir17, writeFile as writeFile39 } from "fs/promises";
-import path45 from "path";
+import { lstat as lstat18, mkdir as mkdir33, readFile as readFile36, readdir as readdir17, writeFile as writeFile40 } from "fs/promises";
+import path46 from "path";
 
 // src/team/git-ref-materialization.ts
 import {
   lstat as lstat17,
-  mkdir as mkdir31,
-  readFile as readFile34,
+  mkdir as mkdir32,
+  readFile as readFile35,
   readdir as readdir16,
   unlink as unlink2,
-  writeFile as writeFile38
+  writeFile as writeFile39
 } from "fs/promises";
-import path44 from "path";
+import path45 from "path";
 
 // src/team/git-ref-bundle.ts
 import { execFile as execFileCallback5 } from "child_process";
-import { lstat as lstat15, mkdir as mkdir29, readFile as readFile32, readdir as readdir15, writeFile as writeFile36 } from "fs/promises";
-import path42 from "path";
+import { lstat as lstat15, mkdir as mkdir30, readFile as readFile33, readdir as readdir15, writeFile as writeFile37 } from "fs/promises";
+import path43 from "path";
 import { promisify as promisify5 } from "util";
 var execFile5 = promisify5(execFileCallback5);
 function createGitRefTaskBundle(input) {
@@ -23448,7 +23703,7 @@ async function assertGitRefBundleCodeReachable(projectRoot, bundle) {
       "git",
       ["cat-file", "-e", `${parsed.codeRef.head}^{commit}`],
       {
-        cwd: path42.resolve(projectRoot),
+        cwd: path43.resolve(projectRoot),
         windowsHide: true
       }
     );
@@ -23461,8 +23716,8 @@ async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
     throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
   }
   const parsed = parseGitRefTaskBundle(bundle);
-  const directory = path42.join(
-    path42.resolve(projectRoot),
+  const directory = path43.join(
+    path43.resolve(projectRoot),
     ".mancode",
     "local",
     "quarantine",
@@ -23478,9 +23733,9 @@ async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
     parsed.taskRef.taskId,
     String(remoteRevision)
   ]);
-  const target = path42.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
+  const target = path43.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
   try {
-    await writeFile36(target, `${JSON.stringify(parsed, null, 2)}
+    await writeFile37(target, `${JSON.stringify(parsed, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -23495,8 +23750,8 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
     throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
   }
   const parsedTaskRef = parseTaskRefValue(taskRef);
-  const directory = path42.join(
-    path42.resolve(projectRoot),
+  const directory = path43.join(
+    path43.resolve(projectRoot),
     ".mancode",
     "local",
     "quarantine",
@@ -23516,19 +23771,19 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
     ]);
     entries = await readdir15(directory);
   } catch (error) {
-    if (isNotFound23(error)) return null;
+    if (isNotFound24(error)) return null;
     throw error;
   }
   const matches = [];
   for (const entry of entries.sort()) {
     if (!/^[a-f0-9]{64}\.json$/.test(entry)) continue;
-    const target = path42.join(directory, entry);
+    const target = path43.join(directory, entry);
     const before = await lstat15(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     const bundle = parseGitRefTaskBundle(
-      JSON.parse(await readFile32(target, "utf8"))
+      JSON.parse(await readFile33(target, "utf8"))
     );
     const after = await lstat15(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
@@ -23559,11 +23814,11 @@ function parseCodeRef(value) {
   return { branch: value.branch, head: value.head };
 }
 async function ensureFixedDirectory(projectRoot, segments) {
-  let current = path42.resolve(projectRoot);
+  let current = path43.resolve(projectRoot);
   for (const segment of segments) {
-    current = path42.join(current, segment);
+    current = path43.join(current, segment);
     try {
-      await mkdir29(current);
+      await mkdir30(current);
     } catch (error) {
       if (!isAlreadyExists18(error)) throw error;
     }
@@ -23574,9 +23829,9 @@ async function ensureFixedDirectory(projectRoot, segments) {
   }
 }
 async function assertFixedDirectory(projectRoot, segments) {
-  let current = path42.resolve(projectRoot);
+  let current = path43.resolve(projectRoot);
   for (const segment of segments) {
-    current = path42.join(current, segment);
+    current = path43.join(current, segment);
     const entry = await lstat15(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -23586,13 +23841,13 @@ async function assertFixedDirectory(projectRoot, segments) {
 function isAlreadyExists18(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound23(error) {
+function isNotFound24(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/git-ref-task-base.ts
-import { lstat as lstat16, mkdir as mkdir30, readFile as readFile33, writeFile as writeFile37 } from "fs/promises";
-import path43 from "path";
+import { lstat as lstat16, mkdir as mkdir31, readFile as readFile34, writeFile as writeFile38 } from "fs/promises";
+import path44 from "path";
 async function readGitRefTaskRemoteBase(projectRoot, taskRef) {
   const parsedTaskRef = parseTaskRefValue(taskRef);
   const runtime = await readProjectRuntimeContext(projectRoot);
@@ -23604,7 +23859,7 @@ async function readGitRefTaskRemoteBase(projectRoot, taskRef) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     const state = parseGitRefTaskRemoteBase(
-      JSON.parse(await readFile33(target, "utf8"))
+      JSON.parse(await readFile34(target, "utf8"))
     );
     const after = await lstat16(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
@@ -23615,7 +23870,7 @@ async function readGitRefTaskRemoteBase(projectRoot, taskRef) {
     }
     return state;
   } catch (error) {
-    if (isNotFound24(error)) return null;
+    if (isNotFound25(error)) return null;
     if (error instanceof SyntaxError) {
       throw new Error("MANCODE_TRANSPORT_CACHE_CORRUPT");
     }
@@ -23635,11 +23890,11 @@ async function recordGitRefTaskRemoteBase(projectRoot, remoteRevision, bundle) {
   });
   const directory = await ensureRemoteBaseDirectory(projectRoot);
   const target = remoteBasePath(projectRoot, parsedBundle.taskRef);
-  const temporary = path43.join(
+  const temporary = path44.join(
     directory,
     `.${parsedBundle.taskRef.taskId}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile37(temporary, `${JSON.stringify(state, null, 2)}
+  await writeFile38(temporary, `${JSON.stringify(state, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -23672,7 +23927,7 @@ function parseGitRefTaskRemoteBase(value) {
   };
 }
 async function ensureRemoteBaseDirectory(projectRoot) {
-  let current = path43.resolve(projectRoot);
+  let current = path44.resolve(projectRoot);
   for (const segment of [
     ".mancode",
     "local",
@@ -23680,9 +23935,9 @@ async function ensureRemoteBaseDirectory(projectRoot) {
     "git-ref",
     "remote-bases"
   ]) {
-    current = path43.join(current, segment);
+    current = path44.join(current, segment);
     try {
-      await mkdir30(current);
+      await mkdir31(current);
     } catch (error) {
       if (!isAlreadyExists19(error)) throw error;
     }
@@ -23694,7 +23949,7 @@ async function ensureRemoteBaseDirectory(projectRoot) {
   return current;
 }
 async function assertRemoteBaseDirectory(projectRoot) {
-  let current = path43.resolve(projectRoot);
+  let current = path44.resolve(projectRoot);
   for (const segment of [
     ".mancode",
     "local",
@@ -23702,7 +23957,7 @@ async function assertRemoteBaseDirectory(projectRoot) {
     "git-ref",
     "remote-bases"
   ]) {
-    current = path43.join(current, segment);
+    current = path44.join(current, segment);
     const entry = await lstat16(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -23711,8 +23966,8 @@ async function assertRemoteBaseDirectory(projectRoot) {
 }
 function remoteBasePath(projectRoot, taskRef) {
   const parsed = parseTaskRefValue(taskRef);
-  return path43.join(
-    path43.resolve(projectRoot),
+  return path44.join(
+    path44.resolve(projectRoot),
     ".mancode",
     "local",
     "cache",
@@ -23730,13 +23985,13 @@ function positiveInteger2(value) {
 function isAlreadyExists19(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound24(error) {
+function isNotFound25(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/git-ref-materialization.ts
 async function materializeGitRefTaskBundle(input) {
-  const projectRoot = path44.resolve(input.projectRoot);
+  const projectRoot = path45.resolve(input.projectRoot);
   const remoteRevision = positiveInteger3(
     input.remoteRevision,
     "git-ref materialization remoteRevision"
@@ -24042,7 +24297,7 @@ async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, pred
   const target = safeTaskPath(taskRoot2, relativePath2);
   await ensureSafeDirectory(
     taskRoot2,
-    path44.dirname(relativePath2).split(path44.sep)
+    path45.dirname(relativePath2).split(path45.sep)
   );
   const current = await readSafeFileOrNull(target);
   if (contentMatches(relativePath2, current, targetContent)) return;
@@ -24052,11 +24307,11 @@ async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, pred
   if (current === null && (predecessorContent !== null || alternatePredecessorContent !== null) && relativePath2 !== "summary.md") {
     throw new Error("MANCODE_SPLIT_BRAIN");
   }
-  const temporary = path44.join(
-    path44.dirname(target),
-    `.${path44.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path45.join(
+    path45.dirname(target),
+    `.${path45.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile38(temporary, targetContent, { encoding: "utf8", flag: "wx" });
+  await writeFile39(temporary, targetContent, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 function contentMatches(relativePath2, current, expected) {
@@ -24110,27 +24365,27 @@ async function readSafeFileOrNull(target) {
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
-    const content = await readFile34(target, "utf8");
+    const content = await readFile35(target, "utf8");
     const after = await lstat17(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     return content;
   } catch (error) {
-    if (isNotFound25(error)) return null;
+    if (isNotFound26(error)) return null;
     throw error;
   }
 }
 async function ensureSafeDirectory(root, segments) {
-  let current = path44.resolve(root);
+  let current = path45.resolve(root);
   for (const segment of segments) {
     if (!segment || segment === ".") continue;
     if (segment === ".." || segment.includes("/") || segment.includes("\\")) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
-    current = path44.join(current, segment);
+    current = path45.join(current, segment);
     try {
-      await mkdir31(current);
+      await mkdir32(current);
     } catch (error) {
       if (!isAlreadyExists20(error)) throw error;
     }
@@ -24141,9 +24396,9 @@ async function ensureSafeDirectory(root, segments) {
   }
 }
 function safeTaskPath(taskRoot2, relativePath2) {
-  const target = path44.resolve(taskRoot2, relativePath2);
-  const relative = path44.relative(taskRoot2, target);
-  if (!relative || relative.startsWith("..") || path44.isAbsolute(relative)) {
+  const target = path45.resolve(taskRoot2, relativePath2);
+  const relative = path45.relative(taskRoot2, target);
+  if (!relative || relative.startsWith("..") || path45.isAbsolute(relative)) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   return target;
@@ -24155,7 +24410,7 @@ async function createJournal(projectRoot, journal) {
     "journals",
     "git-ref-materialize"
   ]);
-  await writeFile38(
+  await writeFile39(
     journalPath(projectRoot, journal.operationId),
     serialize11(journal),
     {
@@ -24166,11 +24421,11 @@ async function createJournal(projectRoot, journal) {
 }
 async function replaceJournal(projectRoot, journal) {
   const target = journalPath(projectRoot, journal.operationId);
-  const temporary = path44.join(
-    path44.dirname(target),
+  const temporary = path45.join(
+    path45.dirname(target),
     `.${journal.operationId}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile38(temporary, serialize11(journal), {
+  await writeFile39(temporary, serialize11(journal), {
     encoding: "utf8",
     flag: "wx"
   });
@@ -24178,7 +24433,7 @@ async function replaceJournal(projectRoot, journal) {
 }
 async function readJournal(target) {
   try {
-    const raw = JSON.parse(await readFile34(target, "utf8"));
+    const raw = JSON.parse(await readFile35(target, "utf8"));
     return parseJournal(raw);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -24193,13 +24448,13 @@ async function listJournals(projectRoot) {
   try {
     entries = await readdir16(directory);
   } catch (error) {
-    if (isNotFound25(error)) return [];
+    if (isNotFound26(error)) return [];
     throw error;
   }
   const journals = [];
   for (const entry of entries.sort()) {
     if (!entry.endsWith(".json")) continue;
-    journals.push(await readJournal(path44.join(directory, entry)));
+    journals.push(await readJournal(path45.join(directory, entry)));
   }
   return journals;
 }
@@ -24265,8 +24520,8 @@ function result(status2, bundle, localJournalPath, taskHeadFence) {
   };
 }
 function journalDirectory(projectRoot) {
-  return path44.join(
-    path44.resolve(projectRoot),
+  return path45.join(
+    path45.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -24275,7 +24530,7 @@ function journalDirectory(projectRoot) {
 }
 function journalPath(projectRoot, operationId) {
   assertUlid(operationId, "git-ref materialization operationId");
-  return path44.join(journalDirectory(projectRoot), `${operationId}.json`);
+  return path45.join(journalDirectory(projectRoot), `${operationId}.json`);
 }
 function serialize11(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -24298,20 +24553,20 @@ async function pathExists3(target) {
     await lstat17(target);
     return true;
   } catch (error) {
-    if (isNotFound25(error)) return false;
+    if (isNotFound26(error)) return false;
     throw error;
   }
 }
 function isAlreadyExists20(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound25(error) {
+function isNotFound26(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/git-ref-workflow-repair.ts
 async function prepareGitRefWorkflowRepair(input) {
-  const root = path45.resolve(input.projectRoot);
+  const root = path46.resolve(input.projectRoot);
   const prepared2 = parsePrepared(input.prepared);
   const pendingMetadata = parseWorkflowMetadata(input.pendingMetadata);
   assertPendingMetadata2(prepared2, pendingMetadata);
@@ -24346,7 +24601,7 @@ async function prepareGitRefWorkflowRepair(input) {
 }
 async function recoverGitRefWorkflowRepair(projectRoot, operationId, transportReceipt = null, options = {}) {
   assertUlid(operationId, "git-ref workflow repair operationId");
-  const root = path45.resolve(projectRoot);
+  const root = path46.resolve(projectRoot);
   let journal = await requireJournal(root, operationId);
   await assertRecoveryAuthorized(root, journal, options);
   if (journal.state === "committed" || journal.state === "aborted") {
@@ -24713,7 +24968,7 @@ async function createJournal2(projectRoot, journal) {
   await ensureJournalDirectory(projectRoot);
   const target = gitRefWorkflowRepairJournalPath(projectRoot, journal.operationId);
   try {
-    await writeFile39(target, serialize12(journal), {
+    await writeFile40(target, serialize12(journal), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -24734,10 +24989,10 @@ async function replaceJournal2(projectRoot, journal) {
 async function requireJournal(projectRoot, operationId) {
   try {
     return parseJournal2(
-      JSON.parse(await readFile35(gitRefWorkflowRepairJournalPath(projectRoot, operationId), "utf8"))
+      JSON.parse(await readFile36(gitRefWorkflowRepairJournalPath(projectRoot, operationId), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound26(error)) {
+    if (error instanceof SyntaxError || isNotFound27(error)) {
       throw new Error("MANCODE_REMOTE_WORKFLOW_REPAIR_JOURNAL_NOT_FOUND");
     }
     throw error;
@@ -24753,14 +25008,14 @@ function metadataFromBundle(bundle) {
   return parseWorkflowMetadata(artifact2.content);
 }
 function metadataPath2(projectRoot, taskRef) {
-  return path45.join(taskRootPath(projectRoot, taskRef), "metadata.json");
+  return path46.join(taskRootPath(projectRoot, taskRef), "metadata.json");
 }
 async function readSafeFile(target) {
   const before = await lstat18(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const content = await readFile35(target, "utf8");
+  const content = await readFile36(target, "utf8");
   const after = await lstat18(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -24768,19 +25023,19 @@ async function readSafeFile(target) {
   return content;
 }
 async function atomicWrite(target, content) {
-  const temporary = path45.join(
-    path45.dirname(target),
-    `.${path45.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path46.join(
+    path46.dirname(target),
+    `.${path46.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile39(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile40(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory(projectRoot) {
-  let current = path45.resolve(projectRoot);
+  let current = path46.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-workflow"]) {
-    current = path45.join(current, segment);
+    current = path46.join(current, segment);
     try {
-      await mkdir32(current);
+      await mkdir33(current);
     } catch (error) {
       if (!isAlreadyExists21(error)) throw error;
     }
@@ -24812,7 +25067,7 @@ function serialize12(value) {
 function isAlreadyExists21(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound26(error) {
+function isNotFound27(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -25416,6 +25671,106 @@ async function contextReconcileTaskHead(rootDir, task, options) {
     );
   }
 }
+async function contextGlossary(rootDir, action, options) {
+  if (action !== "list" && action !== "add" && action !== "update" && action !== "remove") {
+    return printV3Error(
+      options.json,
+      "MANCODE_GLOSSARY_ACTION_INVALID",
+      "Use: context glossary <list|add|update|remove>.",
+      EXIT_V3_INVALID_ARGUMENT
+    );
+  }
+  if (action === "list") {
+    try {
+      const project = await readV3CommandProject(rootDir);
+      const glossary = await readProjectGlossary(project.projectRoot);
+      return printV3Result(options.json, { schemaVersion: 1, glossary });
+    } catch (error) {
+      return printV3Error(
+        options.json,
+        v3ErrorCode(error, "MANCODE_GLOSSARY_LIST_FAILED"),
+        error instanceof Error ? error.message : "Unable to read the project glossary."
+      );
+    }
+  }
+  if (options.term === void 0) {
+    return printV3Error(
+      options.json,
+      "MANCODE_GLOSSARY_TERM_REQUIRED",
+      `context glossary ${action} requires --term <term>.`,
+      EXIT_V3_INVALID_ARGUMENT
+    );
+  }
+  const expectedRevision = parseGlossaryExpectedRevision(
+    options.expectedRevision
+  );
+  if (expectedRevision === null) {
+    return printV3Error(
+      options.json,
+      "MANCODE_GLOSSARY_EXPECTED_REVISION_REQUIRED",
+      "context glossary mutations require --expected-revision <n> (0 for an empty glossary).",
+      EXIT_V3_INVALID_ARGUMENT
+    );
+  }
+  if (action === "add" && options.definition === void 0) {
+    return printV3Error(
+      options.json,
+      "MANCODE_GLOSSARY_DEFINITION_REQUIRED",
+      "context glossary add requires --definition <text>.",
+      EXIT_V3_INVALID_ARGUMENT
+    );
+  }
+  if (action === "update" && options.definition === void 0 && (options.alias === void 0 || options.alias.length === 0) && options.task === void 0) {
+    return printV3Error(
+      options.json,
+      "MANCODE_GLOSSARY_UPDATE_EMPTY",
+      "context glossary update requires --definition, --alias, or --task.",
+      EXIT_V3_INVALID_ARGUMENT
+    );
+  }
+  try {
+    const project = await readV3CommandProject(rootDir);
+    await resolveV3CommandSession(project, options);
+    const store = resolveCoordinationEntityHomeStore(
+      project.runtime.entityHomeStoreContext
+    );
+    const sourceTaskRef = options.task === void 0 ? void 0 : parseTaskRef(options.task);
+    const aliases = options.alias === void 0 || options.alias.length === 0 ? void 0 : options.alias;
+    const glossary = action === "add" ? await addGlossaryEntry(project.projectRoot, store, expectedRevision, {
+      term: options.term,
+      definition: options.definition,
+      ...aliases === void 0 ? {} : { aliases },
+      ...sourceTaskRef === void 0 ? {} : { sourceTaskRef }
+    }) : action === "update" ? await updateGlossaryEntry(
+      project.projectRoot,
+      store,
+      expectedRevision,
+      {
+        term: options.term,
+        ...options.definition === void 0 ? {} : { definition: options.definition },
+        ...aliases === void 0 ? {} : { aliases },
+        ...sourceTaskRef === void 0 ? {} : { sourceTaskRef }
+      }
+    ) : await removeGlossaryEntry(
+      project.projectRoot,
+      store,
+      expectedRevision,
+      options.term
+    );
+    return printV3Result(options.json, { schemaVersion: 1, glossary });
+  } catch (error) {
+    return printV3Error(
+      options.json,
+      v3ErrorCode(error, "MANCODE_GLOSSARY_MUTATION_FAILED"),
+      error instanceof Error ? error.message : "Unable to change the project glossary."
+    );
+  }
+}
+function parseGlossaryExpectedRevision(value) {
+  if (value === void 0 || !/^(0|[1-9][0-9]*)$/.test(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
 async function resolveContext(project, session, request) {
   const resolver = new ContextResolver({
     projectRoot: project.projectRoot,
@@ -25522,20 +25877,20 @@ function parseExpectedRevision2(value) {
 }
 
 // src/commands/design.ts
-import { readFile as readFile37, stat as stat4 } from "fs/promises";
-import path47 from "path";
+import { readFile as readFile38, stat as stat4 } from "fs/promises";
+import path48 from "path";
 import process2 from "process";
 
 // src/context/design-policy.ts
 import {
   lstat as lstat19,
-  mkdir as mkdir33,
-  readFile as readFile36,
+  mkdir as mkdir34,
+  readFile as readFile37,
   realpath as realpath2,
-  rm as rm17,
-  writeFile as writeFile40
+  rm as rm18,
+  writeFile as writeFile41
 } from "fs/promises";
-import path46 from "path";
+import path47 from "path";
 var DEFAULT_DESIGN_POLICY = {
   schemaVersion: 1,
   revision: 0,
@@ -25549,8 +25904,8 @@ var DEFAULT_DESIGN_POLICY = {
   updatedAt: "1970-01-01T00:00:00.000Z"
 };
 function designPolicyPath(projectRoot) {
-  return path46.join(
-    path46.resolve(projectRoot),
+  return path47.join(
+    path47.resolve(projectRoot),
     ".mancode",
     "shared",
     "context",
@@ -25621,10 +25976,10 @@ function parseDesignPolicy(value) {
 async function readDesignPolicy(projectRoot) {
   try {
     return parseDesignPolicy(
-      JSON.parse(await readFile36(designPolicyPath(projectRoot), "utf8"))
+      JSON.parse(await readFile37(designPolicyPath(projectRoot), "utf8"))
     );
   } catch (error) {
-    if (isNotFound27(error)) return null;
+    if (isNotFound28(error)) return null;
     if (error instanceof SyntaxError) {
       throw new Error(
         "MANCODE_CONTEXT_ENTITY_CORRUPT: shared/context/design-policy.json"
@@ -25638,7 +25993,7 @@ async function configureDesignPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   assertUlid(operationId, "design policy operationId");
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path46.resolve(input.projectRoot);
+  const root = path47.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -25693,12 +26048,12 @@ function isDesignBrowserValidation(value) {
 }
 async function writeDesignPolicy(projectRoot, policy) {
   const target = designPolicyPath(projectRoot);
-  await mkdir33(path46.dirname(target), { recursive: true });
-  const temporary = path46.join(
-    path46.dirname(target),
-    `.${path46.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  await mkdir34(path47.dirname(target), { recursive: true });
+  const temporary = path47.join(
+    path47.dirname(target),
+    `.${path47.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile40(temporary, `${JSON.stringify(policy, null, 2)}
+  await writeFile41(temporary, `${JSON.stringify(policy, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -25706,17 +26061,17 @@ async function writeDesignPolicy(projectRoot, policy) {
   try {
     await replaceFileAtomically(temporary, target);
   } finally {
-    await rm17(temporary, { force: true }).catch(() => void 0);
+    await rm18(temporary, { force: true }).catch(() => void 0);
   }
 }
 async function assertDesignPolicyPathSafe(projectRoot) {
-  const root = path46.resolve(projectRoot);
+  const root = path47.resolve(projectRoot);
   const policyPath = designPolicyPath(root);
-  const contextDir = path46.dirname(policyPath);
+  const contextDir = path47.dirname(policyPath);
   try {
     for (const directory of [
-      path46.join(root, ".mancode"),
-      path46.join(root, ".mancode", "shared"),
+      path47.join(root, ".mancode"),
+      path47.join(root, ".mancode", "shared"),
       contextDir
     ]) {
       const info = await lstat19(directory);
@@ -25728,8 +26083,8 @@ async function assertDesignPolicyPathSafe(projectRoot) {
       realpath2(root),
       realpath2(contextDir)
     ]);
-    const relative = path46.relative(resolvedRoot, resolvedContextDir);
-    if (path46.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path46.sep}`)) {
+    const relative = path47.relative(resolvedRoot, resolvedContextDir);
+    if (path47.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path47.sep}`)) {
       throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
     }
     try {
@@ -25738,7 +26093,7 @@ async function assertDesignPolicyPathSafe(projectRoot) {
         throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
       }
     } catch (error) {
-      if (!isNotFound27(error)) throw error;
+      if (!isNotFound28(error)) throw error;
     }
   } catch (error) {
     if (error instanceof Error && error.message === "MANCODE_DESIGN_POLICY_PATH_UNSAFE") {
@@ -25755,7 +26110,7 @@ function assertNonNegativeRevision(value) {
 function isPositiveInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 }
-function isNotFound27(error) {
+function isNotFound28(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -25972,8 +26327,8 @@ async function readProfile(rootDir, kind) {
   }
   try {
     return JSON.parse(
-      await readFile37(
-        path47.join(rootDir, ".mancode", "project-profile.json"),
+      await readFile38(
+        path48.join(rootDir, ".mancode", "project-profile.json"),
         "utf8"
       )
     );
@@ -25982,9 +26337,9 @@ async function readProfile(rootDir, kind) {
   }
 }
 async function readStyleSummary(rootDir, kind) {
-  const cachePath = kind === "continuity" ? path47.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path47.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
+  const cachePath = kind === "continuity" ? path48.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path48.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
   try {
-    const raw = JSON.parse(await readFile37(cachePath, "utf8"));
+    const raw = JSON.parse(await readFile38(cachePath, "utf8"));
     return sanitizeStyleSummary(rootDir, raw);
   } catch {
     return emptyStyleSummary();
@@ -26023,7 +26378,7 @@ async function styleFreshness(rootDir, scopeRoot, lastScanned, sourceFiles) {
   const scannedAt = Date.parse(lastScanned);
   for (const file of sourceFiles) {
     try {
-      const info = await stat4(path47.resolve(rootDir, scopeRoot, file));
+      const info = await stat4(path48.resolve(rootDir, scopeRoot, file));
       if (info.mtimeMs > scannedAt) return "stale";
     } catch {
       return "stale";
@@ -26093,10 +26448,10 @@ function emptyStyleSummary() {
   };
 }
 async function initializedKind(rootDir) {
-  if (await exists(path47.join(rootDir, ".mancode", "schema.json"))) {
+  if (await exists(path48.join(rootDir, ".mancode", "schema.json"))) {
     return "continuity";
   }
-  if (await exists(path47.join(rootDir, ".mancode", "state.json")))
+  if (await exists(path48.join(rootDir, ".mancode", "state.json")))
     return "legacy";
   return null;
 }
@@ -26161,7 +26516,7 @@ function safeShortText(value) {
   return typeof value === "string" && value.length <= 100 && /^[A-Za-z0-9@/_. -]+$/.test(value) ? value : null;
 }
 function isSafeRelativeFile(value) {
-  return value.length <= 240 && !path47.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
+  return value.length <= 240 && !path48.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
 }
 function parseNonNegativeInteger2(value) {
   if (value === void 0 || !/^\d+$/.test(value)) return null;
@@ -26169,7 +26524,7 @@ function parseNonNegativeInteger2(value) {
   return Number.isSafeInteger(parsed) ? parsed : null;
 }
 function relativePath(rootDir, target) {
-  return path47.relative(path47.resolve(rootDir), target).split(path47.sep).join("/");
+  return path48.relative(path48.resolve(rootDir), target).split(path48.sep).join("/");
 }
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -26201,12 +26556,12 @@ function errorCode3(error, fallback) {
 // src/commands/init.ts
 import { promises as fs4 } from "fs";
 import os from "os";
-import path53 from "path";
+import path54 from "path";
 import process6 from "process";
 
 // src/installers/platform-status.ts
 import { promises as fs } from "fs";
-import path48 from "path";
+import path49 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
@@ -26223,13 +26578,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path48.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path49.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path48.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path48.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+        path49.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path49.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -26245,7 +26600,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path48.join(rootDir, ".cursor", "rules", file)
+        (file) => path49.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -26260,13 +26615,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path48.join(rootDir, ".cursor", "rules", file)
+          (file) => path49.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path48.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path49.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -26279,7 +26634,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path48.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path49.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -26296,9 +26651,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".agents", "skills");
+    const skillsDir = path49.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -26310,7 +26665,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -26330,9 +26685,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".agents", "skills");
+    const skillsDir = path49.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -26344,7 +26699,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "kimi-code") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       KIMI_MANCODE_START_MARKER,
       KIMI_MANCODE_END_MARKER
     );
@@ -26364,9 +26719,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path48.join(rootDir, ".agents", "skills");
+    const skillsDir = path49.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -26378,7 +26733,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "qoder") {
     const hasBlock2 = await fileHasManagedBlock(
-      path48.join(rootDir, "AGENTS.md"),
+      path49.join(rootDir, "AGENTS.md"),
       QODER_MANCODE_START_MARKER,
       QODER_MANCODE_END_MARKER
     );
@@ -26398,9 +26753,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const commandsDir = path48.join(rootDir, ".qoder", "commands");
+    const commandsDir = path49.join(rootDir, ".qoder", "commands");
     const hasCommands = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(commandsDir, `${mode}.md`)),
+      MODE_NAMES.map((mode) => path49.join(commandsDir, `${mode}.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -26411,7 +26766,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   const hasBlock = await fileHasManagedBlock(
-    path48.join(rootDir, ".github", "copilot-instructions.md")
+    path49.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -26422,9 +26777,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path48.join(rootDir, ".github", "prompts");
+    const promptsDir = path49.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path48.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path49.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -26457,13 +26812,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path48.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path49.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path48.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path49.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -26491,7 +26846,7 @@ async function fileHasAnyMarker(filePath, needles) {
 async function isPlatformMinimal(rootDir, platform) {
   try {
     const raw = await fs.readFile(
-      path48.join(rootDir, ".mancode", "config.json"),
+      path49.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -26513,7 +26868,7 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 async function claudeHooksRegistered(rootDir) {
   try {
     const raw = await fs.readFile(
-      path48.join(rootDir, ".claude", "settings.json"),
+      path49.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -26556,7 +26911,7 @@ function isRecord7(value) {
 // src/system/detect-team.ts
 import { execFile as execFile6 } from "child_process";
 import { access as access2 } from "fs/promises";
-import path49 from "path";
+import path50 from "path";
 import process3 from "process";
 import { promisify as promisify6 } from "util";
 var execFileAsync = promisify6(execFile6);
@@ -26666,7 +27021,7 @@ async function anyPathExists(projectRoot, candidates) {
   const results = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access2(path49.join(projectRoot, candidate));
+        await access2(path50.join(projectRoot, candidate));
         return true;
       } catch {
         return false;
@@ -26707,7 +27062,7 @@ async function detectSystemDeps(env = process4.env) {
 // src/system/init-onboarding.ts
 import { execFileSync } from "child_process";
 import { promises as fs2 } from "fs";
-import path50 from "path";
+import path51 from "path";
 import process5 from "process";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
@@ -26812,7 +27167,7 @@ async function detectPlatformHints(rootDir, environment = process5.env) {
     hints.add("copilot");
   const exists2 = async (relative) => {
     try {
-      await fs2.access(path50.join(rootDir, relative));
+      await fs2.access(path51.join(rootDir, relative));
       return true;
     } catch {
       return false;
@@ -26889,7 +27244,7 @@ function createTerminalPrompter() {
 
 // src/system/scan-aesthetics.ts
 import { promises as fs3 } from "fs";
-import path51 from "path";
+import path52 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
@@ -26925,7 +27280,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists5(path51.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists5(path52.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -26951,7 +27306,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path51.join(projectRoot, name);
+    const absPath = path52.join(projectRoot, name);
     if (await pathExists5(absPath)) {
       return { absPath, relPath: name };
     }
@@ -27178,7 +27533,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path51.join(projectRoot, relRoot);
+    const absRoot = path52.join(projectRoot, relRoot);
     if (!await pathExists5(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -27198,7 +27553,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path51.join(dir, entry);
+    const abs = path52.join(dir, entry);
     let info;
     try {
       info = await fs3.lstat(abs);
@@ -27219,7 +27574,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path51.basename(dir);
+      base = path52.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -27241,7 +27596,7 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path51.join(projectRoot, relPath);
+    const absPath = path52.join(projectRoot, relPath);
     if (!await pathExists5(absPath)) continue;
     const content = await fs3.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
@@ -27287,7 +27642,7 @@ function toPascalCase(value) {
 async function hasTailwindDep(projectRoot) {
   try {
     const raw = await fs3.readFile(
-      path51.join(projectRoot, "package.json"),
+      path52.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -27313,14 +27668,14 @@ async function pathExists5(p) {
 // src/context/greenfield-init.ts
 import {
   lstat as lstat20,
-  mkdir as mkdir34,
-  readFile as readFile38,
-  rename as rename10,
-  rm as rm18,
-  writeFile as writeFile41
+  mkdir as mkdir35,
+  readFile as readFile39,
+  rename as rename11,
+  rm as rm19,
+  writeFile as writeFile42
 } from "fs/promises";
-import path52 from "path";
-var JOURNAL_RELATIVE_DIRECTORY = path52.join(
+import path53 from "path";
+var JOURNAL_RELATIVE_DIRECTORY = path53.join(
   "local",
   "runtime",
   "initialization"
@@ -27343,7 +27698,7 @@ async function stageGreenfieldInitialization(input) {
     normalized.operationId
   );
   try {
-    await mkdir34(stagingRoot);
+    await mkdir35(stagingRoot);
   } catch (error) {
     if (isAlreadyExists22(error)) {
       throw new Error("MANCODE_GREENFIELD_STAGING_EXISTS");
@@ -27369,7 +27724,7 @@ async function stageGreenfieldInitialization(input) {
     operationId: normalized.operationId,
     workspaceId: normalized.workspaceId,
     state: "staged",
-    stagingDirectoryName: path52.basename(stagingRoot),
+    stagingDirectoryName: path53.basename(stagingRoot),
     targetDirectoryName: ".mancode",
     manifestDigest: digestCanonicalJson(manifest),
     configDigest: digestCanonicalJson(config),
@@ -27400,7 +27755,7 @@ async function stageGreenfieldInitialization(input) {
   return journal;
 }
 async function publishGreenfieldInitialization(input) {
-  const root = path52.resolve(input.projectRoot);
+  const root = path53.resolve(input.projectRoot);
   assertUlid(input.operationId, "greenfield operationId");
   const stagingRoot = greenfieldStagingPath(root, input.operationId);
   const targetRoot = greenfieldTargetPath(root);
@@ -27418,7 +27773,7 @@ async function publishGreenfieldInitialization(input) {
   if (await lstatOrNull4(targetRoot) !== null) {
     throw new Error("MANCODE_V3_TARGET_EXISTS");
   }
-  await rename10(stagingRoot, targetRoot);
+  await rename11(stagingRoot, targetRoot);
   throwIfOperationCrashInjected("greenfield_initialize", "publish-v3-root");
   return finishPublishedInitialization(
     { ...input, projectRoot: root },
@@ -27435,10 +27790,10 @@ async function initializeGreenfield(input, publication) {
 }
 function greenfieldStagingPath(projectRoot, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path52.join(path52.resolve(projectRoot), `.mancode.init-${operationId}`);
+  return path53.join(path53.resolve(projectRoot), `.mancode.init-${operationId}`);
 }
 function greenfieldTargetPath(projectRoot) {
-  return path52.join(path52.resolve(projectRoot), ".mancode");
+  return path53.join(path53.resolve(projectRoot), ".mancode");
 }
 function parseGreenfieldInitializationJournal(value) {
   assertRecord(value, "greenfield initialization journal");
@@ -27509,8 +27864,8 @@ function parseGreenfieldInitializationJournal(value) {
     ),
     adapterPlans: parseAdapterPlans(value.adapterPlans),
     bindingRegistered: value.bindingRegistered,
-    createdAt: parseTimestamp14(value.createdAt, "createdAt"),
-    updatedAt: parseTimestamp14(value.updatedAt, "updatedAt")
+    createdAt: parseTimestamp15(value.createdAt, "createdAt"),
+    updatedAt: parseTimestamp15(value.updatedAt, "updatedAt")
   };
 }
 async function finishPublishedInitialization(input, stagedJournal) {
@@ -27574,7 +27929,7 @@ async function finishPublishedInitialization(input, stagedJournal) {
     activatedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
   };
   assertSchemaManifestTransition(manifest, activeManifest);
-  await writeJson(path52.join(targetRoot, "schema.json"), activeManifest);
+  await writeJson(path53.join(targetRoot, "schema.json"), activeManifest);
   throwIfOperationCrashInjected(
     "greenfield_initialize",
     "activate-v3-manifest"
@@ -27590,46 +27945,46 @@ async function finishPublishedInitialization(input, stagedJournal) {
 }
 async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, projectFacts, journal) {
   await Promise.all([
-    mkdir34(path52.join(stagingRoot, "shared", "context"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, "shared", "memory", "decisions"), {
+    mkdir35(path53.join(stagingRoot, "shared", "context"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, "shared", "memory", "decisions"), {
       recursive: true
     }),
-    mkdir34(path52.join(stagingRoot, "shared", "team", "actors"), {
+    mkdir35(path53.join(stagingRoot, "shared", "team", "actors"), {
       recursive: true
     }),
-    mkdir34(path52.join(stagingRoot, "shared", "team", "handoffs"), {
+    mkdir35(path53.join(stagingRoot, "shared", "team", "handoffs"), {
       recursive: true
     }),
-    mkdir34(path52.join(stagingRoot, "shared", "team", "events"), {
+    mkdir35(path53.join(stagingRoot, "shared", "team", "events"), {
       recursive: true
     }),
-    mkdir34(path52.join(stagingRoot, "shared", "team", "transport"), {
+    mkdir35(path53.join(stagingRoot, "shared", "team", "transport"), {
       recursive: true
     }),
-    mkdir34(path52.join(stagingRoot, "local", "sessions"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
+    mkdir35(path53.join(stagingRoot, "local", "sessions"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
       recursive: true
     }),
-    mkdir34(path52.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, "local", "overlays"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, "local", "quarantine"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, "local", "publish"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, "local", "cache"), { recursive: true }),
-    mkdir34(path52.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
+    mkdir35(path53.join(stagingRoot, "local", "workflows"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, "local", "overlays"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, "local", "quarantine"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, "local", "publish"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, "local", "cache"), { recursive: true }),
+    mkdir35(path53.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
       recursive: true
     })
   ]);
   await Promise.all([
-    writeJson(path52.join(stagingRoot, "schema.json"), manifest),
-    writeJson(path52.join(stagingRoot, "shared", "config.json"), config),
-    writeJson(path52.join(stagingRoot, "shared", "team", "policy.json"), policy),
+    writeJson(path53.join(stagingRoot, "schema.json"), manifest),
+    writeJson(path53.join(stagingRoot, "shared", "config.json"), config),
+    writeJson(path53.join(stagingRoot, "shared", "team", "policy.json"), policy),
     writeJson(
-      path52.join(stagingRoot, "shared", "context", "project.json"),
+      path53.join(stagingRoot, "shared", "context", "project.json"),
       projectFacts
     ),
     writeJson(journalPath2(stagingRoot, journal.operationId), journal),
-    writeFile41(
-      path52.join(stagingRoot, ".gitignore"),
+    writeFile42(
+      path53.join(stagingRoot, ".gitignore"),
       `${V3_IGNORE.join("\n")}
 `,
       { encoding: "utf8", flag: "wx" }
@@ -27638,14 +27993,14 @@ async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, proj
 }
 async function readGreenfieldJournal(root, operationId) {
   try {
-    const raw = await readFile38(journalPath2(root, operationId), "utf8");
+    const raw = await readFile39(journalPath2(root, operationId), "utf8");
     const journal = parseGreenfieldInitializationJournal(JSON.parse(raw));
     if (journal.operationId !== operationId) {
       throw new Error("MANCODE_GREENFIELD_JOURNAL_CORRUPT");
     }
     return journal;
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound28(error)) {
+    if (error instanceof SyntaxError || isNotFound29(error)) {
       throw new Error("MANCODE_GREENFIELD_JOURNAL_CORRUPT");
     }
     throw error;
@@ -27654,10 +28009,10 @@ async function readGreenfieldJournal(root, operationId) {
 async function readManifest(root) {
   try {
     return parseSchemaManifest(
-      JSON.parse(await readFile38(path52.join(root, "schema.json"), "utf8"))
+      JSON.parse(await readFile39(path53.join(root, "schema.json"), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound28(error)) {
+    if (error instanceof SyntaxError || isNotFound29(error)) {
       throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
     }
     throw error;
@@ -27692,7 +28047,7 @@ async function readConfig(root) {
   try {
     config = parseProjectConfig(
       JSON.parse(
-        await readFile38(path52.join(root, "shared", "config.json"), "utf8")
+        await readFile39(path53.join(root, "shared", "config.json"), "utf8")
       )
     );
   } catch (error) {
@@ -27708,8 +28063,8 @@ async function readPolicy(root) {
   try {
     policy = parseTeamPolicy(
       JSON.parse(
-        await readFile38(
-          path52.join(root, "shared", "team", "policy.json"),
+        await readFile39(
+          path53.join(root, "shared", "team", "policy.json"),
           "utf8"
         )
       )
@@ -27726,14 +28081,14 @@ async function readProjectFactsAt(root) {
   try {
     return parseProjectFacts(
       JSON.parse(
-        await readFile38(
-          path52.join(root, "shared", "context", "project.json"),
+        await readFile39(
+          path53.join(root, "shared", "context", "project.json"),
           "utf8"
         )
       )
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound28(error)) {
+    if (error instanceof SyntaxError || isNotFound29(error)) {
       throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
     }
     throw error;
@@ -27766,7 +28121,7 @@ function normalizeInput(input) {
   parseSchemaManifest(manifest);
   return {
     ...input,
-    projectRoot: path52.resolve(input.projectRoot),
+    projectRoot: path53.resolve(input.projectRoot),
     projectConfig: config,
     teamPolicy: policy,
     projectFacts: input.projectFacts === void 0 ? void 0 : parseProjectFacts(input.projectFacts)
@@ -27864,21 +28219,21 @@ function initializationProjectFacts(input, now) {
 }
 function journalPath2(root, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path52.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
+  return path53.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
 }
 async function writeJson(target, value) {
-  const directory = path52.dirname(target);
-  await mkdir34(directory, { recursive: true });
-  const temporary = path52.join(
+  const directory = path53.dirname(target);
+  await mkdir35(directory, { recursive: true });
+  const temporary = path53.join(
     directory,
-    `.${path52.basename(target)}.${process.pid}.${Date.now()}.tmp`
+    `.${path53.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile41(temporary, `${JSON.stringify(value, null, 2)}
+  await writeFile42(temporary, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
   });
-  await rename10(temporary, target);
+  await rename11(temporary, target);
 }
 function parseDigest6(value, label) {
   if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value)) {
@@ -27886,7 +28241,7 @@ function parseDigest6(value, label) {
   }
   return value;
 }
-function parseTimestamp14(value, label) {
+function parseTimestamp15(value, label) {
   if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
     throw new Error(`greenfield initialization journal ${label} is invalid`);
   }
@@ -27899,11 +28254,11 @@ async function lstatOrNull4(target) {
   try {
     return await lstat20(target);
   } catch (error) {
-    if (isNotFound28(error)) return null;
+    if (isNotFound29(error)) return null;
     throw error;
   }
 }
-function isNotFound28(error) {
+function isNotFound29(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExists22(error) {
@@ -27991,9 +28346,9 @@ async function init(rootDir = process6.cwd(), options = {}) {
     return EXIT_INIT_FAILED;
   }
   const authority = resolveInitAuthority(options);
-  const mancodeDir = path53.join(rootDir, ".mancode");
-  const stateFile = path53.join(mancodeDir, "state.json");
-  const v3SchemaFile = path53.join(mancodeDir, "schema.json");
+  const mancodeDir = path54.join(rootDir, ".mancode");
+  const stateFile = path54.join(mancodeDir, "state.json");
+  const v3SchemaFile = path54.join(mancodeDir, "schema.json");
   const wasInitialized = await pathExists6(stateFile);
   let mutationSnapshots = [];
   let directorySnapshots = [];
@@ -28061,7 +28416,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
     }
     return initializeV3(rootDir, options);
   }
-  const isGitRepo = await pathExists6(path53.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path54.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   let isGenericProject = false;
   if (!isGitRepo && !hasManifest) {
@@ -28179,8 +28534,8 @@ async function init(rootDir = process6.cwd(), options = {}) {
     const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
     mutationSnapshots = await snapshotFiles(managedFiles);
     directorySnapshots = await snapshotDirectories(managedFiles, [
-      path53.join(mancodeDir, "workflows"),
-      path53.join(mancodeDir, "preseason-reports")
+      path54.join(mancodeDir, "workflows"),
+      path54.join(mancodeDir, "preseason-reports")
     ]);
     const team = await detectTeamStatus(rootDir);
     const platformMinimal = Object.fromEntries(
@@ -28241,7 +28596,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
 `;
     await fs4.writeFile(stateFile, stateContent, "utf-8");
     await fs4.writeFile(
-      path53.join(mancodeDir, "project-profile.json"),
+      path54.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -28278,7 +28633,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
         )
       );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path53.join(
+      const tokensPath = path54.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
@@ -28442,7 +28797,7 @@ async function initializeV3(rootDir, options) {
     );
     return EXIT_INIT_FAILED;
   }
-  const schemaPath = path53.join(rootDir, ".mancode", "schema.json");
+  const schemaPath = path54.join(rootDir, ".mancode", "schema.json");
   let existingV3 = false;
   let registeredAdapters = /* @__PURE__ */ new Set();
   if (await pathExists6(schemaPath)) {
@@ -28545,7 +28900,7 @@ function printV3InitError(error) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path53.join(mancodeDir, "config.json");
+  const configPath = path54.join(mancodeDir, "config.json");
   let config = {};
   try {
     config = JSON.parse(await fs4.readFile(configPath, "utf-8"));
@@ -28578,7 +28933,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir) {
   try {
     const config = JSON.parse(
-      await fs4.readFile(path53.join(mancodeDir, "config.json"), "utf-8")
+      await fs4.readFile(path54.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {
       platforms: Array.isArray(config.platforms) ? config.platforms.filter(
@@ -28644,13 +28999,13 @@ async function selectInitPlatforms(input) {
 }
 async function hasProjectManifest(rootDir) {
   for (const name of PROJECT_MANIFESTS) {
-    if (await pathExists6(path53.join(rootDir, name))) return true;
+    if (await pathExists6(path54.join(rootDir, name))) return true;
   }
   return false;
 }
 async function canInitializeGenericProject(rootDir) {
-  const resolved = path53.resolve(rootDir);
-  if (resolved === path53.parse(resolved).root || resolved === path53.resolve(os.homedir())) {
+  const resolved = path54.resolve(rootDir);
+  if (resolved === path54.parse(resolved).root || resolved === path54.resolve(os.homedir())) {
     return { ok: false, reason: "unsafe" };
   }
   try {
@@ -28664,11 +29019,11 @@ async function canInitializeGenericProject(rootDir) {
   }
 }
 async function validateV3CliProjectBoundary(rootDir, options, locale, legacyInitialized) {
-  const isGitRepo = await pathExists6(path53.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path54.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   if (isGitRepo || hasManifest) return null;
   const v3Initialized = await pathExists6(
-    path53.join(rootDir, ".mancode", "schema.json")
+    path54.join(rootDir, ".mancode", "schema.json")
   );
   const legacyAuthorityPresent = legacyInitialized || (await scanLegacyAuthority(rootDir)).authorityPresent;
   const genericSafety = await canInitializeGenericProject(rootDir);
@@ -28803,7 +29158,7 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.github/prompts/${mode}.prompt.md`);
     }
   }
-  return [...new Set(files.map((file) => path53.join(rootDir, file)))];
+  return [...new Set(files.map((file) => path54.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
@@ -28822,10 +29177,10 @@ async function snapshotFiles(filePaths) {
 async function snapshotDirectories(filePaths, additionalDirectories = []) {
   const directories = new Set(additionalDirectories);
   for (const filePath of filePaths) {
-    let current = path53.dirname(filePath);
-    while (current !== path53.dirname(current)) {
+    let current = path54.dirname(filePath);
+    while (current !== path54.dirname(current)) {
       directories.add(current);
-      current = path53.dirname(current);
+      current = path54.dirname(current);
     }
   }
   return Promise.all(
@@ -28841,7 +29196,7 @@ async function restoreFiles(snapshots) {
       await fs4.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs4.mkdir(path53.dirname(snapshot.filePath), { recursive: true });
+    await fs4.mkdir(path54.dirname(snapshot.filePath), { recursive: true });
     await fs4.writeFile(snapshot.filePath, snapshot.content, "utf-8");
   }
 }
@@ -28918,15 +29273,15 @@ async function pathExists6(p) {
 
 // src/commands/install.ts
 import { promises as fs5 } from "fs";
-import path54 from "path";
+import path55 from "path";
 import process7 from "process";
 var EXIT_OK3 = 0;
 var EXIT_NOT_INITIALIZED2 = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;
 var EXIT_INSTALL_FAILED = 3;
 async function install(rootDir = process7.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path54.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path54.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path55.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path55.join(rootDir, ".mancode", "schema.json");
   if (await pathExists7(v3SchemaFile)) {
     return installV3(rootDir, platform, options);
   }
@@ -29087,7 +29442,7 @@ function printUnsupportedPlatform(platform) {
   }
 }
 async function readConfig2(rootDir) {
-  const configPath = path54.join(rootDir, ".mancode", "config.json");
+  const configPath = path55.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
@@ -29102,7 +29457,7 @@ function isNodeError7(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path54.join(rootDir, ".mancode", "config.json");
+  const configPath = path55.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
   await fs5.writeFile(configPath, content, "utf-8");
@@ -29138,7 +29493,7 @@ function readConfiguredMinimal(value, platform) {
 async function readStatePlatform(rootDir) {
   try {
     const raw = await fs5.readFile(
-      path54.join(rootDir, ".mancode", "state.json"),
+      path55.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -29161,11 +29516,11 @@ function isRecord9(value) {
 
 // src/commands/list-platforms.ts
 import { promises as fs6 } from "fs";
-import path55 from "path";
+import path56 from "path";
 import process8 from "process";
 var EXIT_OK4 = 0;
 async function listPlatforms(rootDir = process8.cwd()) {
-  if (await pathExists8(path55.join(rootDir, ".mancode", "schema.json"))) {
+  if (await pathExists8(path56.join(rootDir, ".mancode", "schema.json"))) {
     return listV3Platforms(rootDir);
   }
   const installed = new Set(await readInstalledPlatforms(rootDir));
@@ -29201,7 +29556,7 @@ async function listV3Platforms(rootDir) {
 async function readInstalledPlatforms(rootDir) {
   try {
     const raw = await fs6.readFile(
-      path55.join(rootDir, ".mancode", "config.json"),
+      path56.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -29233,8 +29588,8 @@ function describePlatform(platform) {
 }
 
 // src/commands/manps.ts
-import { access as access4, readFile as readFile40 } from "fs/promises";
-import path57 from "path";
+import { access as access4, readFile as readFile41 } from "fs/promises";
+import path58 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
@@ -29244,13 +29599,13 @@ import { existsSync, readFileSync } from "fs";
 import {
   access as access3,
   lstat as lstat21,
-  mkdir as mkdir35,
-  readFile as readFile39,
+  mkdir as mkdir36,
+  readFile as readFile40,
   readdir as readdir18,
-  rename as rename11,
-  writeFile as writeFile42
+  rename as rename12,
+  writeFile as writeFile43
 } from "fs/promises";
-import path56 from "path";
+import path57 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -29330,10 +29685,10 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   const needsFiles = normalizedArea === "all" || normalizedArea === "dead-code" || normalizedArea === "config";
   const files = needsFiles ? await listProjectFiles(projectRoot) : [];
   const issues = (await scanArea(projectRoot, normalizedArea, pkg, files)).slice(0, 20);
-  const storageRoot = options.storageRoot ?? path56.join(projectRoot, ".mancode");
-  const reportDir = path56.join(storageRoot, "preseason-reports");
-  await mkdir35(reportDir, { recursive: true });
-  const issueDbPath = path56.join(storageRoot, "preseason-issues.json");
+  const storageRoot = options.storageRoot ?? path57.join(projectRoot, ".mancode");
+  const reportDir = path57.join(storageRoot, "preseason-reports");
+  await mkdir36(reportDir, { recursive: true });
+  const issueDbPath = path57.join(storageRoot, "preseason-issues.json");
   const reportPath = await allocateReportPath(
     reportDir,
     `${generatedAt.replace(/[:.]/g, "-")}-${normalizedArea}`
@@ -29347,9 +29702,9 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
     issueDbPath
   };
   const database = await buildIssueDatabase(projectRoot, report);
-  await writeFile42(reportPath, renderPreseasonReport(report), "utf-8");
-  await writeFile42(
-    path56.join(storageRoot, "preseason-report.md"),
+  await writeFile43(reportPath, renderPreseasonReport(report), "utf-8");
+  await writeFile43(
+    path57.join(storageRoot, "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -29357,7 +29712,7 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = options.issueDbPath ?? path56.join(projectRoot, ".mancode", "preseason-issues.json");
+  const issueDbPath = options.issueDbPath ?? path57.join(projectRoot, ".mancode", "preseason-issues.json");
   const database = await readIssueDatabase(issueDbPath);
   const keys = new Set(issues.map((issue) => issueKey(issue)));
   const targets = database.issues.filter(
@@ -29435,7 +29790,7 @@ async function runPreseasonRemediation(projectRoot, issues, options = {}) {
     write2("   Decision: skipped.");
   }
   database.updatedAt = now;
-  await writeFile42(
+  await writeFile43(
     issueDbPath,
     `${JSON.stringify(database, null, 2)}
 `,
@@ -29467,7 +29822,7 @@ async function scanArea(projectRoot, area, pkg, files) {
 async function allocateReportPath(reportDir, baseName) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
-    const candidate = path56.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path57.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -29516,8 +29871,8 @@ async function walk(root, current, results, depth) {
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path56.join(current, entry);
-    const rel = path56.relative(root, abs);
+    const abs = path57.join(current, entry);
+    const rel = path57.relative(root, abs);
     let info;
     try {
       info = await lstat21(abs);
@@ -29527,7 +29882,7 @@ async function walk(root, current, results, depth) {
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path56.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path57.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -29535,7 +29890,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile39(path56.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile40(path57.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -29628,7 +29983,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path56.join(projectRoot, file);
+    const abs = path57.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -29669,7 +30024,7 @@ function scanTestGaps(files) {
   if (sourceFiles.length === 0) return [];
   const tests = new Set(files.filter((file) => file.startsWith("tests/")));
   const missing = sourceFiles.filter((file) => {
-    const base = path56.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path57.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -29678,13 +30033,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path56.basename(file)}.`,
+    detail: `No matching test file was found for ${path57.basename(file)}.`,
     recommendation: "Add focused coverage for the public behavior or document why this module is exercised indirectly."
   }));
 }
 function scanConfig(projectRoot, files) {
   const issues = [];
-  if (!files.includes(".gitignore") && !pathExistsSync(path56.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path57.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -29695,7 +30050,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path56.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path57.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -29714,7 +30069,7 @@ function scanAestheticDrift(projectRoot, files, pkg) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path56.join(projectRoot, file));
+      content = readFileSyncSafe(path57.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -29765,7 +30120,7 @@ function detectedIconSystems(pkg) {
   return systems.filter(([, pattern]) => packages.some((name) => pattern.test(name))).map(([name]) => name);
 }
 async function scanArchitecture(projectRoot) {
-  const localBinary = path56.join(
+  const localBinary = path57.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -29813,7 +30168,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists9(path56.join(projectRoot, file)))
+    files.map((file) => pathExists9(path57.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -29919,9 +30274,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path56.relative(projectRoot, report.reportPath);
+  const reportRef = path57.relative(projectRoot, report.reportPath);
   const run = {
-    id: path56.basename(report.reportPath, ".md"),
+    id: path57.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -29963,7 +30318,7 @@ async function buildIssueDatabase(projectRoot, report) {
 async function readIssueDatabase(issueDbPath) {
   let raw;
   try {
-    raw = await readFile39(issueDbPath, "utf-8");
+    raw = await readFile40(issueDbPath, "utf-8");
   } catch (err) {
     if (isNodeError8(err) && err.code === "ENOENT") {
       return emptyIssueDatabase();
@@ -29984,9 +30339,9 @@ async function readIssueDatabase(issueDbPath) {
 }
 async function writeJsonAtomic3(file, value) {
   const tmp = `${file}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await writeFile42(tmp, `${JSON.stringify(value, null, 2)}
+  await writeFile43(tmp, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
-  await rename11(tmp, file);
+  await rename12(tmp, file);
 }
 function emptyIssueDatabase() {
   return {
@@ -30027,20 +30382,20 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path56.join(projectRoot, ".gitignore");
+    const gitignorePath = path57.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
-    await writeFile42(gitignorePath, `${DEFAULT_GITIGNORE}
+    await writeFile43(gitignorePath, `${DEFAULT_GITIGNORE}
 `, "utf-8");
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path56.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path57.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
-    await writeFile42(editorconfigPath, `${DEFAULT_EDITORCONFIG}
+    await writeFile43(editorconfigPath, `${DEFAULT_EDITORCONFIG}
 `, "utf-8");
     return { applied: true, action: "created .editorconfig" };
   }
@@ -30076,10 +30431,10 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path56.join(projectRoot, "package.json");
+  const packagePath = path57.join(projectRoot, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile39(packagePath, "utf-8"));
+    pkg = JSON.parse(await readFile40(packagePath, "utf-8"));
   } catch {
     return false;
   }
@@ -30089,7 +30444,7 @@ async function addPackageScript(projectRoot, scriptName, script) {
     ...scripts,
     [scriptName]: script
   };
-  await writeFile42(packagePath, `${JSON.stringify(pkg, null, 2)}
+  await writeFile43(packagePath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
   return true;
 }
@@ -30189,7 +30544,7 @@ var EXIT_NOT_INITIALIZED3 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  const v3SchemaPath = path57.join(rootDir, ".mancode", "schema.json");
+  const v3SchemaPath = path58.join(rootDir, ".mancode", "schema.json");
   const v3Activation = await readV3ActivationState(v3SchemaPath);
   if (v3Activation !== null && v3Activation !== "v3_active" && v3Activation !== "dual_read") {
     const message = `manps is unavailable while mancode activation is ${v3Activation}`;
@@ -30202,7 +30557,7 @@ async function manps(rootDir, area = "all", options = {}) {
     return EXIT_SCAN_FAILED;
   }
   const v3Initialized = v3Activation === "v3_active";
-  const initialized = v3Initialized || await pathExists10(path57.join(rootDir, ".mancode", "state.json"));
+  const initialized = v3Initialized || await pathExists10(path58.join(rootDir, ".mancode", "state.json"));
   if (!initialized) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
@@ -30215,7 +30570,7 @@ async function manps(rootDir, area = "all", options = {}) {
   let report;
   try {
     report = await runPreseasonScan(rootDir, area, {
-      storageRoot: v3Initialized ? path57.join(rootDir, ".mancode", "local") : void 0
+      storageRoot: v3Initialized ? path58.join(rootDir, ".mancode", "local") : void 0
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -30284,8 +30639,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path57.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path57.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path58.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path58.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -30301,7 +30656,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path57.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path58.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK5;
@@ -30362,7 +30717,7 @@ async function readV3ActivationState(schemaPath) {
   if (!await pathExists10(schemaPath)) return null;
   try {
     const manifest = parseSchemaManifest(
-      JSON.parse(await readFile40(schemaPath, "utf8"))
+      JSON.parse(await readFile41(schemaPath, "utf8"))
     );
     return manifest.activationState;
   } catch {
@@ -30371,8 +30726,8 @@ async function readV3ActivationState(schemaPath) {
 }
 
 // src/commands/migrate.ts
-import { readFile as readFile41 } from "fs/promises";
-import path58 from "path";
+import { readFile as readFile42 } from "fs/promises";
+import path59 from "path";
 var EXIT_OK6 = 0;
 var EXIT_INVALID_ARG2 = 2;
 var EXIT_MIGRATION_BLOCKED = 3;
@@ -30498,14 +30853,14 @@ async function readScopeFile(rootDir, file) {
   if (!file.trim() || file.includes("\0")) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
-  const resolved = path58.resolve(rootDir, file);
-  const relative = path58.relative(path58.resolve(rootDir), resolved);
-  if (relative === ".." || relative.startsWith(`..${path58.sep}`) || path58.isAbsolute(relative)) {
+  const resolved = path59.resolve(rootDir, file);
+  const relative = path59.relative(path59.resolve(rootDir), resolved);
+  if (relative === ".." || relative.startsWith(`..${path59.sep}`) || path59.isAbsolute(relative)) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
   try {
     return JSON.parse(
-      await readFile41(resolved, "utf8")
+      await readFile42(resolved, "utf8")
     );
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -30605,12 +30960,12 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
 }
 
 // src/context/project-policy-upgrade.ts
-import { lstat as lstat22, mkdir as mkdir36, readFile as readFile42, rm as rm19, writeFile as writeFile43 } from "fs/promises";
-import path59 from "path";
+import { lstat as lstat22, mkdir as mkdir37, readFile as readFile43, rm as rm20, writeFile as writeFile44 } from "fs/promises";
+import path60 from "path";
 var UPGRADE_OPERATION = "project_policy_upgrade";
 async function dryRunProjectPolicyUpgrade(input) {
   assertPolicyVersion(input.policyVersion);
-  const root = path59.resolve(input.projectRoot);
+  const root = path60.resolve(input.projectRoot);
   const project = await new V3ContextStore(root).readProjectSnapshot();
   const beforeDigest = digestManifest(project.manifest);
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -30654,7 +31009,7 @@ async function dryRunProjectPolicyUpgrade(input) {
 async function upgradeProjectPolicy(input) {
   assertPolicyVersion(input.policyVersion);
   assertUlid(input.sessionId, "project policy upgrade sessionId");
-  const root = path59.resolve(input.projectRoot);
+  const root = path60.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const operationId = input.operationId;
   if (operationId === void 0) {
@@ -30908,24 +31263,24 @@ function buildV2Manifest(manifest, operationId) {
   return candidate;
 }
 async function readSchemaContent(root) {
-  return readFile42(path59.join(root, ".mancode", "schema.json"), "utf8");
+  return readFile43(path60.join(root, ".mancode", "schema.json"), "utf8");
 }
 async function writeSchemaContent(root, operationId, content) {
-  const directory = path59.join(root, ".mancode");
-  const target = path59.join(directory, "schema.json");
+  const directory = path60.join(root, ".mancode");
+  const target = path60.join(directory, "schema.json");
   const stat5 = await lstat22(target);
   if (!stat5.isFile() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const temporary = path59.join(
+  const temporary = path60.join(
     directory,
     `.schema.json.${operationId}.${process.pid}.tmp`
   );
-  await writeFile43(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile44(temporary, content, { encoding: "utf8", flag: "wx" });
   try {
     await replaceFileAtomically(temporary, target);
   } catch (error) {
-    await rm19(temporary, { force: true });
+    await rm20(temporary, { force: true });
     throw error;
   }
 }
@@ -30993,15 +31348,15 @@ async function releaseLocks3(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
 function projectUpgradePreviewRoot(root, operationId) {
-  return path59.join(root, ".mancode", "staging", "project-upgrade", operationId);
+  return path60.join(root, ".mancode", "staging", "project-upgrade", operationId);
 }
 async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
   const directory = projectUpgradePreviewRoot(root, receipt.operationId);
-  const receiptPath = path59.join(directory, "preview.json");
-  const manifestPath = path59.join(directory, "schema.json");
-  await mkdir36(path59.dirname(directory), { recursive: true });
+  const receiptPath = path60.join(directory, "preview.json");
+  const manifestPath = path60.join(directory, "schema.json");
+  await mkdir37(path60.dirname(directory), { recursive: true });
   try {
-    await mkdir36(directory);
+    await mkdir37(directory);
   } catch (error) {
     if (isAlreadyExists23(error)) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_EXISTS");
@@ -31009,25 +31364,25 @@ async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
     throw error;
   }
   try {
-    await writeFile43(receiptPath, `${JSON.stringify(receipt, null, 2)}
+    await writeFile44(receiptPath, `${JSON.stringify(receipt, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
-    await writeFile43(manifestPath, manifestContent, {
+    await writeFile44(manifestPath, manifestContent, {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
-    await rm19(directory, { recursive: true, force: true });
+    await rm20(directory, { recursive: true, force: true });
     throw error;
   }
 }
 async function assertProjectPolicyUpgradePreview(root, operationId, project) {
   const directory = projectUpgradePreviewRoot(root, operationId);
   const [receiptContent, manifestContent] = await Promise.all([
-    readSafePreviewFile(path59.join(directory, "preview.json")),
-    readSafePreviewFile(path59.join(directory, "schema.json"))
+    readSafePreviewFile(path60.join(directory, "preview.json")),
+    readSafePreviewFile(path60.join(directory, "schema.json"))
   ]);
   let receipt;
   try {
@@ -31054,9 +31409,9 @@ async function readSafePreviewFile(target) {
     if (!stat5.isFile() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_INVALID");
     }
-    return readFile42(target, "utf8");
+    return readFile43(target, "utf8");
   } catch (error) {
-    if (isNotFound29(error)) {
+    if (isNotFound30(error)) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_REQUIRED");
     }
     throw error;
@@ -31089,7 +31444,7 @@ function parseProjectPolicyUpgradePreviewReceipt(value) {
     createdAt: record.createdAt
   };
 }
-function isNotFound29(error) {
+function isNotFound30(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExists23(error) {
@@ -31143,16 +31498,16 @@ async function projectUpgrade(rootDir, options) {
 // src/commands/refresh-project.ts
 import { randomUUID } from "crypto";
 import { promises as fs7 } from "fs";
-import path60 from "path";
+import path61 from "path";
 import process9 from "process";
 var EXIT_OK7 = 0;
 var EXIT_NOT_INITIALIZED4 = 1;
 var EXIT_CORRUPT_STATE = 2;
 var EXIT_REFRESH_FAILED = 3;
 async function refreshProject(rootDir = process9.cwd()) {
-  const mancodeDir = path60.join(rootDir, ".mancode");
-  const statePath = path60.join(mancodeDir, "state.json");
-  if (await pathExists11(path60.join(mancodeDir, "schema.json"))) {
+  const mancodeDir = path61.join(rootDir, ".mancode");
+  const statePath = path61.join(mancodeDir, "state.json");
+  if (await pathExists11(path61.join(mancodeDir, "schema.json"))) {
     return refreshV3Project(rootDir);
   }
   if (!await pathExists11(statePath)) {
@@ -31171,12 +31526,12 @@ async function refreshProject(rootDir = process9.cwd()) {
     const [profile, team, hasGit, hasManifest] = await Promise.all([
       detectProjectProfile(rootDir),
       detectTeamStatus(rootDir),
-      pathExists11(path60.join(rootDir, ".git")),
+      pathExists11(path61.join(rootDir, ".git")),
       hasProjectManifest2(rootDir)
     ]);
     const uiLibrary = primaryUiLibrary(profile);
     const stack = [...profile.languages, ...profile.frameworks];
-    const config = await readJson2(path60.join(mancodeDir, "config.json"));
+    const config = await readJson2(path61.join(mancodeDir, "config.json"));
     const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
     const nextState = {
       ...state,
@@ -31188,7 +31543,7 @@ async function refreshProject(rootDir = process9.cwd()) {
     };
     await writeProjectFacts2(
       statePath,
-      path60.join(mancodeDir, "project-profile.json"),
+      path61.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(nextState, null, 2)}
 `,
       `${JSON.stringify(profile, null, 2)}
@@ -31255,7 +31610,7 @@ async function refreshV3Project(rootDir) {
 }
 async function hasProjectManifest2(rootDir) {
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists11(path60.join(rootDir, manifest))) return true;
+    if (await pathExists11(path61.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -31321,9 +31676,9 @@ async function readOptionalText(filePath) {
   }
 }
 function temporaryPath(filePath) {
-  return path60.join(
-    path60.dirname(filePath),
-    `.${path60.basename(filePath)}.${process9.pid}.${randomUUID()}.tmp`
+  return path61.join(
+    path61.dirname(filePath),
+    `.${path61.basename(filePath)}.${process9.pid}.${randomUUID()}.tmp`
   );
 }
 async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
@@ -31393,7 +31748,7 @@ async function pathExists11(filePath) {
 
 // src/commands/refresh-style.ts
 import { promises as fs8 } from "fs";
-import path61 from "path";
+import path62 from "path";
 import process10 from "process";
 var EXIT_OK8 = 0;
 var EXIT_NOT_INITIALIZED5 = 1;
@@ -31404,8 +31759,8 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
     console.error("\u2717  style scan root must stay inside the project root.");
     return EXIT_V3_REFRESH_FAILED;
   }
-  const stateFile = path61.join(rootDir, ".mancode", "state.json");
-  if (await pathExists12(path61.join(rootDir, ".mancode", "schema.json"))) {
+  const stateFile = path62.join(rootDir, ".mancode", "state.json");
+  if (await pathExists12(path62.join(rootDir, ".mancode", "schema.json"))) {
     return refreshV3Style(rootDir, scanTarget.root, scanTarget.scopeRoot);
   }
   if (!await pathExists12(stateFile)) {
@@ -31415,7 +31770,7 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
   }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path61.join(rootDir, ".mancode", "project-profile.json");
+  const profilePath = path62.join(rootDir, ".mancode", "project-profile.json");
   await fs8.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
@@ -31442,13 +31797,13 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
     uiLibraryHint,
     scanTarget.scopeRoot
   );
-  const tokensPath = path61.join(
+  const tokensPath = path62.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs8.mkdir(path61.dirname(tokensPath), { recursive: true });
+  await fs8.mkdir(path62.dirname(tokensPath), { recursive: true });
   await fs8.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
@@ -31521,7 +31876,7 @@ async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
     console.log(
       `   \u7C7B\u578B: ${profile.projectKind} | UI: ${profile.uiAssets} | \u6D4F\u89C8\u5668: ${profile.browserAutomation}`
     );
-    const tokensPath = path61.join(
+    const tokensPath = path62.join(
       rootDir,
       ".mancode",
       "local",
@@ -31538,7 +31893,7 @@ async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
     }
     console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
     const tokens = await scanAesthetics(scanRoot, uiLibraryHint, scopeRoot);
-    await fs8.mkdir(path61.dirname(tokensPath), { recursive: true });
+    await fs8.mkdir(path62.dirname(tokensPath), { recursive: true });
     await fs8.writeFile(
       tokensPath,
       `${JSON.stringify(tokens, null, 2)}
@@ -31572,7 +31927,7 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path61.join(rootDir, ".mancode", "state.json");
+  const statePath = path62.join(rootDir, ".mancode", "state.json");
   try {
     const state = JSON.parse(await fs8.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
@@ -31596,7 +31951,7 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 async function readInstalledPlatforms2(rootDir) {
   try {
     const raw = await fs8.readFile(
-      path61.join(rootDir, ".mancode", "config.json"),
+      path62.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -31616,30 +31971,30 @@ async function pathExists12(p) {
   }
 }
 async function resolveScanTarget(rootDir, requestedRoot) {
-  const projectRoot = await fs8.realpath(path61.resolve(rootDir)).catch(() => null);
+  const projectRoot = await fs8.realpath(path62.resolve(rootDir)).catch(() => null);
   if (projectRoot === null) return null;
   if (requestedRoot === void 0 || requestedRoot === ".") {
     return { root: projectRoot, scopeRoot: "." };
   }
-  if (path61.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
+  if (path62.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
     return null;
   }
-  const candidate = await fs8.realpath(path61.resolve(projectRoot, requestedRoot)).catch(() => null);
+  const candidate = await fs8.realpath(path62.resolve(projectRoot, requestedRoot)).catch(() => null);
   if (candidate === null) return null;
-  const relative = path61.relative(projectRoot, candidate);
-  if (relative.startsWith(`..${path61.sep}`) || relative === ".." || path61.isAbsolute(relative)) {
+  const relative = path62.relative(projectRoot, candidate);
+  if (relative.startsWith(`..${path62.sep}`) || relative === ".." || path62.isAbsolute(relative)) {
     return null;
   }
   return {
     root: candidate,
-    scopeRoot: relative.split(path61.sep).join("/") || "."
+    scopeRoot: relative.split(path62.sep).join("/") || "."
   };
 }
 
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs9 } from "fs";
-import path62 from "path";
+import path63 from "path";
 import process11 from "process";
 
 // src/team/assessment.ts
@@ -31795,8 +32150,8 @@ var EXIT_OK9 = 0;
 var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_CORRUPT_STATE2 = 2;
 async function status(rootDir = process11.cwd(), options = {}) {
-  const stateFile = path62.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path62.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path63.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path63.join(rootDir, ".mancode", "schema.json");
   if (await pathExists13(v3SchemaFile)) {
     return statusV3(rootDir, options);
   }
@@ -32041,10 +32396,10 @@ async function readV3StatusSession(rootDir) {
 }
 async function shouldRefreshProject(rootDir, state) {
   if (state.projectMode !== "generic") return false;
-  const hasGit = await pathExists13(path62.join(rootDir, ".git"));
+  const hasGit = await pathExists13(path63.join(rootDir, ".git"));
   if (hasGit) return true;
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists13(path62.join(rootDir, manifest))) return true;
+    if (await pathExists13(path63.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -32088,19 +32443,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs9.readFile(path62.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path63.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path62.basename(rootDir);
+  return path63.basename(rootDir);
 }
 async function readConfig3(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path62.join(rootDir, ".mancode", "config.json"),
+      path63.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32128,9 +32483,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists13(path62.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists13(path63.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
     pathExists13(
-      path62.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      path63.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -32139,7 +32494,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path62.join(rootDir, ".claude", "settings.json"),
+      path63.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -32168,7 +32523,7 @@ function hasHookCommand2(value, needle) {
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path62.join(
+  const hookPath = path63.join(
     rootDir,
     ".mancode",
     "hooks",
@@ -33665,8 +34020,8 @@ function assertPositiveRevision2(value, label) {
 }
 
 // src/team/git-ref-handoff-repair.ts
-import { lstat as lstat23, mkdir as mkdir37, readFile as readFile43, readdir as readdir19, writeFile as writeFile44 } from "fs/promises";
-import path63 from "path";
+import { lstat as lstat23, mkdir as mkdir38, readFile as readFile44, readdir as readdir19, writeFile as writeFile45 } from "fs/promises";
+import path64 from "path";
 
 // src/team/git-ref-operation.ts
 import { execFile as execFileCallback6 } from "child_process";
@@ -36244,7 +36599,7 @@ async function recoverGitRefHandoffRepairs(projectRoot) {
 }
 async function recoverGitRefHandoffRepair(projectRoot, operationId, transportReceipt) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  const root = path63.resolve(projectRoot);
+  const root = path64.resolve(projectRoot);
   let journal = await requireJournal2(root, operationId);
   if (journal.state === "committed" || journal.state === "aborted") {
     return recoveryResult2(journal);
@@ -36323,7 +36678,7 @@ async function recoverGitRefHandoffRepair(projectRoot, operationId, transportRec
   }
 }
 async function prepareHandoffRepairWhileTaskLocked(projectRoot, rawPrepared) {
-  const root = path63.resolve(projectRoot);
+  const root = path64.resolve(projectRoot);
   const prepared2 = parsePrepared2(rawPrepared);
   const runtime = await readProjectRuntimeContext(root);
   const previousMetadata = bundleMetadata2(prepared2.predecessorBundle);
@@ -36386,7 +36741,7 @@ async function restorePredecessorMetadata2(projectRoot, journal) {
   );
 }
 async function replaceMetadataVerified(projectRoot, expected, targetMetadata, alternateExpected) {
-  const target = path63.join(
+  const target = path64.join(
     taskRootPath(projectRoot, targetMetadata.taskRef),
     "metadata.json"
   );
@@ -36504,15 +36859,15 @@ function parseJournal3(value) {
     pendingMetadata,
     remoteReceipt,
     transportReceipt: value.transportReceipt,
-    createdAt: parseTimestamp15(value.createdAt),
-    updatedAt: parseTimestamp15(value.updatedAt)
+    createdAt: parseTimestamp16(value.createdAt),
+    updatedAt: parseTimestamp16(value.updatedAt)
   };
 }
 async function createJournal3(projectRoot, journal) {
   await ensureJournalDirectory2(projectRoot);
   const target = journalPath3(projectRoot, journal.operationId);
   try {
-    await writeFile44(target, serialize13(journal), {
+    await writeFile45(target, serialize13(journal), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -36531,10 +36886,10 @@ async function replaceJournal3(projectRoot, journal) {
 async function requireJournal2(projectRoot, operationId) {
   try {
     return parseJournal3(
-      JSON.parse(await readFile43(journalPath3(projectRoot, operationId), "utf8"))
+      JSON.parse(await readFile44(journalPath3(projectRoot, operationId), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound30(error)) {
+    if (error instanceof SyntaxError || isNotFound31(error)) {
       throw new Error("MANCODE_HANDOFF_REPAIR_JOURNAL_NOT_FOUND");
     }
     throw error;
@@ -36545,7 +36900,7 @@ async function listJournals2(projectRoot) {
   try {
     entries = await readdir19(journalDirectory2(projectRoot));
   } catch (error) {
-    if (isNotFound30(error)) return [];
+    if (isNotFound31(error)) return [];
     throw error;
   }
   const journals = [];
@@ -36554,8 +36909,8 @@ async function listJournals2(projectRoot) {
     journals.push(
       parseJournal3(
         JSON.parse(
-          await readFile43(
-            path63.join(journalDirectory2(projectRoot), entry),
+          await readFile44(
+            path64.join(journalDirectory2(projectRoot), entry),
             "utf8"
           )
         )
@@ -36569,7 +36924,7 @@ async function readSafeFile2(target) {
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const content = await readFile43(target, "utf8");
+  const content = await readFile44(target, "utf8");
   const after = await lstat23(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -36577,19 +36932,19 @@ async function readSafeFile2(target) {
   return content;
 }
 async function atomicWrite2(target, content) {
-  const temporary = path63.join(
-    path63.dirname(target),
-    `.${path63.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path64.join(
+    path64.dirname(target),
+    `.${path64.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile44(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile45(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory2(projectRoot) {
-  let current = path63.resolve(projectRoot);
+  let current = path64.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-handoff"]) {
-    current = path63.join(current, segment);
+    current = path64.join(current, segment);
     try {
-      await mkdir37(current);
+      await mkdir38(current);
     } catch (error) {
       if (!isAlreadyExists24(error)) throw error;
     }
@@ -36600,8 +36955,8 @@ async function ensureJournalDirectory2(projectRoot) {
   }
 }
 function journalDirectory2(projectRoot) {
-  return path63.join(
-    path63.resolve(projectRoot),
+  return path64.join(
+    path64.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -36610,13 +36965,13 @@ function journalDirectory2(projectRoot) {
 }
 function journalPath3(projectRoot, operationId) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  return path63.join(journalDirectory2(projectRoot), `${operationId}.json`);
+  return path64.join(journalDirectory2(projectRoot), `${operationId}.json`);
 }
 function serialize13(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
-function parseTimestamp15(value) {
+function parseTimestamp16(value) {
   if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
     throw new Error("MANCODE_HANDOFF_REPAIR_JOURNAL_CORRUPT");
   }
@@ -36625,7 +36980,7 @@ function parseTimestamp15(value) {
 function isAlreadyExists24(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound30(error) {
+function isNotFound31(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -36709,8 +37064,8 @@ function parseReceipt(value) {
 }
 
 // src/team/policy-operation.ts
-import { lstat as lstat24, mkdir as mkdir38, readdir as readdir20, unlink as unlink3, writeFile as writeFile45 } from "fs/promises";
-import path64 from "path";
+import { lstat as lstat24, mkdir as mkdir39, readdir as readdir20, unlink as unlink3, writeFile as writeFile46 } from "fs/promises";
+import path65 from "path";
 async function updateTeamPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   const eventId = createUlid();
@@ -36721,7 +37076,7 @@ async function updateTeamPolicy(input) {
     throw new Error("MANCODE_TEAM_POLICY_INVALID");
   }
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path64.resolve(input.projectRoot);
+  const root = path65.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -36802,7 +37157,7 @@ async function applyTeamTransportSet(input, write2) {
   }
   const remote = transportRemote(input.mode, input.remote);
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path64.resolve(input.projectRoot);
+  const root = path65.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -36935,9 +37290,9 @@ async function assertTransportAuthorityEmpty(projectRoot, store) {
     listClaims(store),
     listHandoffs(store),
     directoryHasEntries(taskHeadDirectory(store)),
-    directoryHasEntries(path64.join(store.root, "transport-migrations")),
+    directoryHasEntries(path65.join(store.root, "transport-migrations")),
     directoryHasEntries(
-      path64.join(projectRoot, ".mancode", "shared", "team", "transport")
+      path65.join(projectRoot, ".mancode", "shared", "team", "transport")
     ),
     pathExists14(gitRefCachePath(projectRoot))
   ]);
@@ -36967,21 +37322,21 @@ function assertPositiveRevision5(value, label) {
   }
 }
 function teamPolicyPath(projectRoot) {
-  return path64.join(projectRoot, ".mancode", "shared", "team", "policy.json");
+  return path65.join(projectRoot, ".mancode", "shared", "team", "policy.json");
 }
 function projectConfigPath(projectRoot) {
-  return path64.join(projectRoot, ".mancode", "shared", "config.json");
+  return path65.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function writeJsonAtomic4(target, value) {
-  await mkdir38(path64.dirname(target), { recursive: true });
-  await assertPlainDirectory(path64.dirname(target));
+  await mkdir39(path65.dirname(target), { recursive: true });
+  await assertPlainDirectory(path65.dirname(target));
   await assertPlainFileOrMissing(target);
-  const temporary = path64.join(
-    path64.dirname(target),
-    `.${path64.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  const temporary = path65.join(
+    path65.dirname(target),
+    `.${path65.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile45(temporary, `${JSON.stringify(value, null, 2)}
+    await writeFile46(temporary, `${JSON.stringify(value, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -37005,7 +37360,7 @@ async function assertPlainFileOrMissing(target) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   } catch (error) {
-    if (isNotFound31(error)) return;
+    if (isNotFound32(error)) return;
     throw error;
   }
 }
@@ -37017,7 +37372,7 @@ async function directoryHasEntries(target) {
     }
     return (await readdir20(target)).length > 0;
   } catch (error) {
-    if (isNotFound31(error)) return false;
+    if (isNotFound32(error)) return false;
     throw error;
   }
 }
@@ -37026,28 +37381,28 @@ async function pathExists14(target) {
     await lstat24(target);
     return true;
   } catch (error) {
-    if (isNotFound31(error)) return false;
+    if (isNotFound32(error)) return false;
     throw error;
   }
 }
 async function releaseLocks4(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
-function isNotFound31(error) {
+function isNotFound32(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/transport-migration-adapters.ts
 import {
   lstat as lstat25,
-  mkdir as mkdir39,
-  readFile as readFile44,
+  mkdir as mkdir40,
+  readFile as readFile45,
   readdir as readdir21,
-  rename as rename12,
+  rename as rename13,
   unlink as unlink4,
-  writeFile as writeFile46
+  writeFile as writeFile47
 } from "fs/promises";
-import path65 from "path";
+import path66 from "path";
 
 // src/team/transport-migration.ts
 var DIGEST_PATTERN7 = /^sha256:[a-f0-9]{64}$/;
@@ -37871,7 +38226,7 @@ function parseTransportMigrationManifest(value) {
       (left, right) => compareUtf813(left.handoffId, right.handoffId)
     ),
     claimPolicy: "reissue-active",
-    createdAt: parseTimestamp16(value.createdAt, "createdAt")
+    createdAt: parseTimestamp17(value.createdAt, "createdAt")
   };
   if (manifest.workspaceId !== config.workspaceId || !manifest.actorProfiles.some(
     (profile) => profile.actorId === manifest.actorId
@@ -37920,7 +38275,7 @@ function parseStagedTransportAuthority(value) {
       "transportEpoch"
     ),
     coordinationDomainId: parseCoordinationDomainId(value.coordinationDomainId),
-    stagedAt: parseTimestamp16(value.stagedAt, "stagedAt")
+    stagedAt: parseTimestamp17(value.stagedAt, "stagedAt")
   };
 }
 function parseEstablishedTransportAuthority(value) {
@@ -37963,7 +38318,7 @@ function parseEstablishedTransportAuthority(value) {
       parseClaim
     ).sort((left, right) => compareUtf813(left.claimId, right.claimId)),
     receipt: parseNonEmptyString(value.receipt, "receipt"),
-    establishedAt: parseTimestamp16(value.establishedAt, "establishedAt")
+    establishedAt: parseTimestamp17(value.establishedAt, "establishedAt")
   };
   assertUniqueCoordinationEntities(established.activeClaims, []);
   return established;
@@ -38099,7 +38454,7 @@ function parseDigest7(value, label) {
   }
   return value;
 }
-function parseTimestamp16(value, label) {
+function parseTimestamp17(value, label) {
   if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
     throw new Error(`${label} must be an ISO timestamp`);
   }
@@ -38119,7 +38474,7 @@ function compareUtf813(left, right) {
 var STAGE_DIRECTORY = "transport-migrations";
 var COLLECTIONS = ["claims", "handoffs", "task-heads"];
 async function createTransportMigrationFileAdapters(input) {
-  const projectRoot = path65.resolve(input.projectRoot);
+  const projectRoot = path66.resolve(input.projectRoot);
   assertUlid(input.actorId, "transport migration adapter actorId");
   if (input.operationId !== void 0) {
     assertUlid(input.operationId, "transport migration adapter operationId");
@@ -38171,7 +38526,7 @@ async function createTransportMigrationFileAdapters(input) {
 var FileSystemTransportMigrationConfigAdapter = class {
   constructor(projectRoot, coordinationStore) {
     this.coordinationStore = coordinationStore;
-    this.projectRoot = path65.resolve(projectRoot);
+    this.projectRoot = path66.resolve(projectRoot);
   }
   projectRoot;
   async read() {
@@ -39024,33 +39379,33 @@ async function publishMigrationActorProfiles(projectRoot, profiles) {
   }
 }
 async function archiveLocalCoordinationCollections(store, operationId) {
-  const archiveRoot = path65.join(
+  const archiveRoot = path66.join(
     store.root,
     STAGE_DIRECTORY,
     "archive",
     operationId
   );
-  await mkdir39(archiveRoot, { recursive: true });
+  await mkdir40(archiveRoot, { recursive: true });
   const directories = {
     claims: claimDirectory(store),
     handoffs: handoffDirectory(store),
     "task-heads": taskHeadDirectory(store)
   };
   for (const name of COLLECTIONS) {
-    const archived = path65.join(archiveRoot, name);
-    const absent = path65.join(archiveRoot, `${name}.absent`);
+    const archived = path66.join(archiveRoot, name);
+    const absent = path66.join(archiveRoot, `${name}.absent`);
     if (await pathKind(archived) === "directory" || await pathKind(absent) === "file") {
       continue;
     }
     const sourceKind = await pathKind(directories[name]);
     if (sourceKind === null) {
-      await writeFile46(absent, "\n", { encoding: "utf8", flag: "wx" });
+      await writeFile47(absent, "\n", { encoding: "utf8", flag: "wx" });
       continue;
     }
     if (sourceKind !== "directory") {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_LOCAL_AUTHORITY_UNSAFE");
     }
-    await rename12(directories[name], archived);
+    await rename13(directories[name], archived);
   }
 }
 async function listActorProfiles(projectRoot) {
@@ -39059,7 +39414,7 @@ async function listActorProfiles(projectRoot) {
   try {
     entries = await readdir21(directory);
   } catch (error) {
-    if (isNotFound32(error)) return [];
+    if (isNotFound33(error)) return [];
     throw error;
   }
   const profiles = [];
@@ -39076,18 +39431,18 @@ async function listActorProfiles(projectRoot) {
   return profiles;
 }
 async function listSharedTaskRefs(projectRoot) {
-  const directory = path65.join(projectRoot, ".mancode", "shared", "workflows");
+  const directory = path66.join(projectRoot, ".mancode", "shared", "workflows");
   let entries;
   try {
     entries = await readdir21(directory);
   } catch (error) {
-    if (isNotFound32(error)) return [];
+    if (isNotFound33(error)) return [];
     throw error;
   }
   const refs = [];
   for (const taskId of entries.sort(compareUtf814)) {
     assertUlid(taskId, "shared workflow directory");
-    const stat5 = await lstat25(path65.join(directory, taskId));
+    const stat5 = await lstat25(path66.join(directory, taskId));
     if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
     }
@@ -39099,7 +39454,7 @@ async function readTaskSnapshotOrNull(projectRoot, taskRef) {
   try {
     return await new V3ContextStore(projectRoot).readTaskSnapshot(taskRef);
   } catch (error) {
-    if (error instanceof Error && (error.message === "MANCODE_TASK_NOT_FOUND" || isNotFound32(error))) {
+    if (error instanceof Error && (error.message === "MANCODE_TASK_NOT_FOUND" || isNotFound33(error))) {
       return null;
     }
     throw error;
@@ -39161,7 +39516,7 @@ async function readStagedRecord(store, operationId) {
   );
 }
 function stagedPath(store, operationId) {
-  return path65.join(
+  return path66.join(
     store.root,
     STAGE_DIRECTORY,
     "staged",
@@ -39169,7 +39524,7 @@ function stagedPath(store, operationId) {
   );
 }
 function establishedPath(store, operationId) {
-  return path65.join(
+  return path66.join(
     store.root,
     STAGE_DIRECTORY,
     "established",
@@ -39177,12 +39532,12 @@ function establishedPath(store, operationId) {
   );
 }
 function projectConfigPath2(projectRoot) {
-  return path65.join(projectRoot, ".mancode", "shared", "config.json");
+  return path66.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function readProjectConfigFile(projectRoot) {
   try {
     return parseProjectConfig(
-      JSON.parse(await readFile44(projectConfigPath2(projectRoot), "utf8"))
+      JSON.parse(await readFile45(projectConfigPath2(projectRoot), "utf8"))
     );
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -39192,14 +39547,14 @@ async function readProjectConfigFile(projectRoot) {
   }
 }
 async function writeJsonAtomic5(target, value) {
-  await mkdir39(path65.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path65.dirname(target));
-  const temporary = path65.join(
-    path65.dirname(target),
-    `.${path65.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  await mkdir40(path66.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path66.dirname(target));
+  const temporary = path66.join(
+    path66.dirname(target),
+    `.${path66.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile46(temporary, serialize14(value), {
+    await writeFile47(temporary, serialize14(value), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -39210,10 +39565,10 @@ async function writeJsonAtomic5(target, value) {
   }
 }
 async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
-  await mkdir39(path65.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path65.dirname(target));
+  await mkdir40(path66.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path66.dirname(target));
   try {
-    await writeFile46(target, serialize14(value), { encoding: "utf8", flag: "wx" });
+    await writeFile47(target, serialize14(value), { encoding: "utf8", flag: "wx" });
   } catch (error) {
     if (!isAlreadyExists25(error)) throw error;
     const existing = await readJsonOrNull5(target, parser, conflictCode);
@@ -39229,14 +39584,14 @@ async function readJsonOrNull5(target, parser, corruptCode) {
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
-    const parsed = parser(JSON.parse(await readFile44(target, "utf8")));
+    const parsed = parser(JSON.parse(await readFile45(target, "utf8")));
     const after = await lstat25(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
     return parsed;
   } catch (error) {
-    if (isNotFound32(error)) return null;
+    if (isNotFound33(error)) return null;
     if (error instanceof SyntaxError) throw new Error(corruptCode);
     throw error;
   }
@@ -39294,7 +39649,7 @@ async function pathKind(target) {
     if (stat5.isDirectory()) return "directory";
     return "other";
   } catch (error) {
-    if (isNotFound32(error)) return null;
+    if (isNotFound33(error)) return null;
     throw error;
   }
 }
@@ -39308,7 +39663,7 @@ async function unlinkIfExists2(target) {
   try {
     await unlink4(target);
   } catch (error) {
-    if (!isNotFound32(error)) throw error;
+    if (!isNotFound33(error)) throw error;
   }
 }
 function serialize14(value) {
@@ -39321,7 +39676,7 @@ function compareUtf814(left, right) {
 function isAlreadyExists25(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound32(error) {
+function isNotFound33(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -40761,16 +41116,16 @@ function parsePositiveInteger6(value) {
 }
 
 // src/commands/uninstall.ts
-import { access as access5, readFile as readFile45, rm as rm20, writeFile as writeFile47 } from "fs/promises";
-import path66 from "path";
+import { access as access5, readFile as readFile46, rm as rm21, writeFile as writeFile48 } from "fs/promises";
+import path67 from "path";
 import process12 from "process";
 var EXIT_OK10 = 0;
 var EXIT_NOT_INITIALIZED7 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
 var EXIT_V3_AUTHORITY_PROTECTED = 3;
 async function uninstall(rootDir = process12.cwd(), platform, options = {}) {
-  const stateFile = path66.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path66.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path67.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path67.join(rootDir, ".mancode", "schema.json");
   if (await pathExists15(v3SchemaFile)) {
     return uninstallV3(rootDir, platform, options);
   }
@@ -40865,7 +41220,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm20(path66.join(rootDir, ".mancode"), {
+  await rm21(path67.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -40875,10 +41230,10 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path66.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path67.join(rootDir, ".claude", "settings.json");
   let content;
   try {
-    content = await readFile45(settingsPath, "utf-8");
+    content = await readFile46(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -40904,7 +41259,7 @@ async function cleanClaudeSettings(rootDir) {
     );
     settings.skills = Object.keys(retainedSkills).length > 0 ? retainedSkills : void 0;
   }
-  await writeFile47(
+  await writeFile48(
     settingsPath,
     `${JSON.stringify(settings, null, 2)}
 `,
@@ -40953,100 +41308,100 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path66.join(rootDir, "AGENTS.md");
+  const agentsPath = path67.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile45(agentsPath, "utf-8");
+    const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile47(agentsPath, `${cleaned}
+      await writeFile48(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm20(agentsPath, { force: true });
+      await rm21(agentsPath, { force: true });
     }
   } catch {
   }
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path66.join(
+  const instructionsPath = path67.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
   );
   try {
-    const content = await readFile45(instructionsPath, "utf-8");
+    const content = await readFile46(instructionsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile47(instructionsPath, `${cleaned}
+      await writeFile48(instructionsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm20(instructionsPath, { force: true });
+      await rm21(instructionsPath, { force: true });
     }
   } catch {
   }
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path66.join(rootDir, "AGENTS.md");
+  const agentsPath = path67.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile45(agentsPath, "utf-8");
+    const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
       content,
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile47(agentsPath, `${cleaned}
+      await writeFile48(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm20(agentsPath, { force: true });
+      await rm21(agentsPath, { force: true });
     }
   } catch {
   }
   await removeZcodeSkills(rootDir);
 }
 async function uninstallKimiCode(rootDir) {
-  const agentsPath = path66.join(rootDir, "AGENTS.md");
+  const agentsPath = path67.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile45(agentsPath, "utf-8");
+    const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
       content,
       KIMI_MANCODE_START_MARKER,
       KIMI_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile47(agentsPath, `${cleaned}
+      await writeFile48(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm20(agentsPath, { force: true });
+      await rm21(agentsPath, { force: true });
     }
   } catch {
   }
   await removeKimiSkills(rootDir);
 }
 async function uninstallQoder(rootDir) {
-  const agentsPath = path66.join(rootDir, "AGENTS.md");
+  const agentsPath = path67.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile45(agentsPath, "utf-8");
+    const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
       content,
       QODER_MANCODE_START_MARKER,
       QODER_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile47(agentsPath, `${cleaned}
+      await writeFile48(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm20(agentsPath, { force: true });
+      await rm21(agentsPath, { force: true });
     }
   } catch {
   }
   await removeQoderCommands(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path66.join(rootDir, ".mancode", "config.json");
+  const configPath = path67.join(rootDir, ".mancode", "config.json");
   try {
-    const raw = await readFile45(configPath, "utf-8");
+    const raw = await readFile46(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
@@ -41058,7 +41413,7 @@ async function removeFromConfig(rootDir, platform) {
         );
         config.platformOptions = Object.keys(platformOptions).length > 0 ? platformOptions : void 0;
       }
-      await writeFile47(
+      await writeFile48(
         configPath,
         `${JSON.stringify(config, null, 2)}
 `,
@@ -41091,8 +41446,8 @@ function version() {
 }
 
 // src/commands/workflow.ts
-import { access as access6, readFile as readFile47, rm as rm22, writeFile as writeFile49 } from "fs/promises";
-import path68 from "path";
+import { access as access6, readFile as readFile48, rm as rm23, writeFile as writeFile50 } from "fs/promises";
+import path69 from "path";
 
 // src/context/child-result-merge.ts
 async function mergeV3ChildResult(input) {
@@ -44152,13 +44507,13 @@ function updateMetadata4(previous, verification, operationId, updatedAt) {
 // src/context/workflow-create.ts
 import {
   lstat as lstat26,
-  mkdir as mkdir40,
-  readFile as readFile46,
-  rename as rename13,
-  rm as rm21,
-  writeFile as writeFile48
+  mkdir as mkdir41,
+  readFile as readFile47,
+  rename as rename14,
+  rm as rm22,
+  writeFile as writeFile49
 } from "fs/promises";
-import path67 from "path";
+import path68 from "path";
 
 // src/context/creation-resolution.ts
 function resolveWorkflowCreation(request) {
@@ -44268,7 +44623,7 @@ function rejectConflict(provided, expected, label) {
 
 // src/context/workflow-create.ts
 async function createV3Workflow(input) {
-  const projectRoot = path67.resolve(requireProjectRoot2(input.projectRoot));
+  const projectRoot = path68.resolve(requireProjectRoot2(input.projectRoot));
   const task = requireText2(input.task, "workflow task");
   const client = requireText2(input.client, "workflow client");
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -44453,8 +44808,8 @@ async function createV3Workflow(input) {
       throw new Error("MANCODE_REVISION_CONFLICT");
     }
     const taskParent = await ensureSafeTaskParent3(projectRoot, taskRef);
-    const targetDirectory = path67.join(taskParent, taskRef.taskId);
-    stagingDirectory = path67.join(
+    const targetDirectory = path68.join(taskParent, taskRef.taskId);
+    stagingDirectory = path68.join(
       taskParent,
       `.${taskRef.taskId}.${operationId}.staging`
     );
@@ -44903,10 +45258,10 @@ async function ensureSafeTaskParent3(projectRoot, taskRef) {
   const segments = [".mancode", taskRef.namespace, "workflows"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = path67.join(current, segment);
+    current = path68.join(current, segment);
     const existing = await lstatOrNull5(current);
     if (existing === null) {
-      await mkdir40(current);
+      await mkdir41(current);
       continue;
     }
     if (!existing.isDirectory() || existing.isSymbolicLink()) {
@@ -44919,7 +45274,7 @@ async function assertDirectoryAbsent(target, code) {
   if (await lstatOrNull5(target) !== null) throw new Error(code);
 }
 async function writeStagedEntities(stagingDirectory, entities) {
-  await mkdir40(stagingDirectory);
+  await mkdir41(stagingDirectory);
   await assertDirectory(stagingDirectory);
   await Promise.all([
     writeStagedJson(stagingDirectory, "metadata.json", entities.metadata),
@@ -44939,8 +45294,8 @@ async function writeStagedEntities(stagingDirectory, entities) {
 }
 async function writeStagedJson(stagingDirectory, fileName, value) {
   await assertDirectory(stagingDirectory);
-  const target = path67.join(stagingDirectory, fileName);
-  await writeFile48(target, `${JSON.stringify(value, null, 2)}
+  const target = path68.join(stagingDirectory, fileName);
+  await writeFile49(target, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -44977,12 +45332,12 @@ async function validateStagedEntities(stagingDirectory) {
   });
 }
 async function readStagedJson(stagingDirectory, fileName, parser) {
-  const target = path67.join(stagingDirectory, fileName);
+  const target = path68.join(stagingDirectory, fileName);
   const before = await lstat26(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const parsed = parser(JSON.parse(await readFile46(target, "utf8")));
+  const parsed = parser(JSON.parse(await readFile47(target, "utf8")));
   const after = await lstat26(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -44996,7 +45351,7 @@ async function publishStagedTask(stagingDirectory, targetDirectory) {
     targetDirectory,
     "MANCODE_WORKFLOW_ALREADY_EXISTS"
   );
-  await rename13(stagingDirectory, targetDirectory);
+  await rename14(stagingDirectory, targetDirectory);
   await assertDirectory(targetDirectory);
 }
 async function advanceJournal(store, previous, stepId, now, canAbort) {
@@ -45074,7 +45429,7 @@ async function abortPreparedCreate(store, journal, stagingDirectory, now) {
       { canAbort: true }
     );
   } finally {
-    await rm21(stagingDirectory, { recursive: true, force: true });
+    await rm22(stagingDirectory, { recursive: true, force: true });
   }
 }
 async function assertDirectory(target) {
@@ -45087,7 +45442,7 @@ async function lstatOrNull5(target) {
   try {
     return await lstat26(target);
   } catch (error) {
-    if (isNotFound33(error)) return null;
+    if (isNotFound34(error)) return null;
     throw error;
   }
 }
@@ -45107,7 +45462,7 @@ function requireText2(value, label) {
   }
   return value.trim();
 }
-function isNotFound33(error) {
+function isNotFound34(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -46085,7 +46440,7 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
   if (v3Activation === "v3_active") {
     return workflowV3(rootDir, subcommand, args, options);
   }
-  if (!await pathExists16(path68.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists16(path69.join(rootDir, ".mancode", "state.json"))) {
     if (v3Activation !== null) {
       return printV3Error(
         options.json,
@@ -46980,7 +47335,6 @@ async function workflowReviewV3(rootDir, args, options) {
       taskRef: result2.metadata.taskRef,
       metadata: result2.metadata,
       review: result2.review,
-      verification: result2.verification,
       aggregate: result2.aggregate,
       taskHeadFence: result2.taskHeadFence,
       operation: result2.operation
@@ -47058,8 +47412,6 @@ async function workflowPlanV3(rootDir, args, options) {
       taskRef: result2.metadata.taskRef,
       metadata: result2.metadata,
       planDigest: result2.planDigest,
-      review: result2.review,
-      verification: result2.verification,
       aggregate: result2.aggregate,
       taskHeadFence: result2.taskHeadFence,
       operation: result2.operation
@@ -47124,8 +47476,6 @@ async function workflowRequirementsV3(rootDir, args, options) {
       taskRef: result2.metadata.taskRef,
       metadata: result2.metadata,
       requirements: result2.requirements,
-      review: result2.review,
-      verification: result2.verification,
       aggregate: result2.aggregate,
       taskHeadFence: result2.taskHeadFence,
       operation: result2.operation
@@ -47177,8 +47527,8 @@ function parseV3ParticipantActorIds(values) {
   return values;
 }
 async function readWorkflowInputFile(projectRoot, value) {
-  const inputPath = path68.isAbsolute(value) ? value : path68.resolve(projectRoot, value);
-  return readFile47(inputPath, "utf8");
+  const inputPath = path69.isAbsolute(value) ? value : path69.resolve(projectRoot, value);
+  return readFile48(inputPath, "utf8");
 }
 async function readWorkflowJsonInputFile(projectRoot, value) {
   return JSON.parse(await readWorkflowInputFile(projectRoot, value));
@@ -47251,7 +47601,7 @@ async function readV3ActivationState2(rootDir) {
   try {
     const manifest = parseSchemaManifest(
       JSON.parse(
-        await readFile47(path68.join(rootDir, ".mancode", "schema.json"), "utf8")
+        await readFile48(path69.join(rootDir, ".mancode", "schema.json"), "utf8")
       )
     );
     return manifest.activationState === "v3_active" ? "v3_active" : "other";
@@ -47296,21 +47646,21 @@ async function workflowRequirements(rootDir, args, options) {
       "requirements can only be finalized for an in-progress man or manteam workflow at step 1 or 2"
     );
   }
-  const workflowPath = path68.join(rootDir, ".mancode", "workflows", taskId);
-  const jsonPath = path68.join(workflowPath, "requirements.json");
-  const markdownPath = path68.join(workflowPath, "requirements.md");
-  const metadataPath3 = path68.join(workflowPath, "metadata.json");
+  const workflowPath = path69.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path69.join(workflowPath, "requirements.json");
+  const markdownPath = path69.join(workflowPath, "requirements.md");
+  const metadataPath3 = path69.join(workflowPath, "metadata.json");
   let originalJson;
   let originalMarkdown;
   let originalMetadata;
   try {
-    const inputPath = path68.isAbsolute(options.file) ? options.file : path68.resolve(rootDir, options.file);
-    const input = await readFile47(inputPath, "utf-8");
+    const inputPath = path69.isAbsolute(options.file) ? options.file : path69.resolve(rootDir, options.file);
+    const input = await readFile48(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
     [originalJson, originalMarkdown, originalMetadata] = await Promise.all([
       readOptionalText2(jsonPath),
       readOptionalText2(markdownPath),
-      readFile47(metadataPath3, "utf-8")
+      readFile48(metadataPath3, "utf-8")
     ]);
     await writeRequirementsArtifacts(rootDir, taskId, requirements);
     await updateWorkflow(rootDir, taskId, {
@@ -47340,7 +47690,7 @@ async function workflowRequirements(rootDir, args, options) {
       const rollback = await Promise.allSettled([
         restoreOptionalText(jsonPath, originalJson),
         restoreOptionalText(markdownPath, originalMarkdown),
-        writeFile49(metadataPath3, originalMetadata, "utf-8")
+        writeFile50(metadataPath3, originalMetadata, "utf-8")
       ]);
       rollbackIncomplete = rollback.some(
         (result2) => result2.status === "rejected"
@@ -47428,7 +47778,7 @@ async function workflowVerify(rootDir, args, options) {
             );
           }
           if (options.evidenceFile) {
-            const evidencePath = path68.isAbsolute(options.evidenceFile) ? options.evidenceFile : path68.resolve(rootDir, options.evidenceFile);
+            const evidencePath = path69.isAbsolute(options.evidenceFile) ? options.evidenceFile : path69.resolve(rootDir, options.evidenceFile);
             if (!await pathExists16(evidencePath)) {
               return invalidArg(
                 options,
@@ -47488,17 +47838,17 @@ async function workflowVerify(rootDir, args, options) {
 }
 async function commitVerificationTransition(rootDir, meta, ledger) {
   const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path68.join(
+  const metadataPath3 = path69.join(
     rootDir,
     ".mancode",
     "workflows",
     meta.taskId,
     "metadata.json"
   );
-  const specPath = path68.join(rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path69.join(rootDir, ".mancode", "memory", "spec.md");
   const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile47(metadataPath3, "utf-8"),
+    readFile48(metadataPath3, "utf-8"),
     readOptionalText2(specPath)
   ]);
   const wasVerificationBlocked = meta.status === "blocked" && meta.blockingReason?.startsWith("[verification]");
@@ -47527,7 +47877,7 @@ async function commitVerificationTransition(rootDir, meta, ledger) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile49(metadataPath3, originalMetadata, "utf-8"),
+      writeFile50(metadataPath3, originalMetadata, "utf-8"),
       restoreOptionalText(specPath, originalSpec)
     ]);
     const message = error instanceof Error ? error.message : "verification transition failed";
@@ -47659,7 +48009,7 @@ async function workflowReview(rootDir, args, options) {
 }
 async function commitReviewSkip(rootDir, meta, reason) {
   const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path68.join(
+  const metadataPath3 = path69.join(
     rootDir,
     ".mancode",
     "workflows",
@@ -47668,7 +48018,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   );
   const [originalLedger, originalMetadata] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile47(metadataPath3, "utf-8")
+    readFile48(metadataPath3, "utf-8")
   ]);
   try {
     await initializeSkippedReview(rootDir, meta.taskId, reason);
@@ -47679,7 +48029,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile49(metadataPath3, originalMetadata, "utf-8")
+      writeFile50(metadataPath3, originalMetadata, "utf-8")
     ]);
     const message = error instanceof Error ? error.message : "review skip failed";
     return rollback.some((result2) => result2.status === "rejected") ? `${message}; rollback was incomplete` : message;
@@ -47899,18 +48249,18 @@ async function workflowHandoff(rootDir, taskId, options) {
       "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
     );
   }
-  const workflowPath = path68.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path68.join(workflowPath, "requirements.md")) || !await pathExists16(path68.join(workflowPath, "plan.md"))) {
+  const workflowPath = path69.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path69.join(workflowPath, "requirements.md")) || !await pathExists16(path69.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "solo handoff requires requirements.md and plan.md"
     );
   }
-  const statePath = path68.join(rootDir, ".mancode", "state.json");
+  const statePath = path69.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile47(statePath, "utf-8");
+    originalState = await readFile48(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -47981,11 +48331,11 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
       `workflow is not an active solo handoff: ${taskId}`
     );
   }
-  const statePath = path68.join(rootDir, ".mancode", "state.json");
+  const statePath = path69.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile47(statePath, "utf-8");
+    originalState = await readFile48(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -48048,18 +48398,18 @@ async function workflowDecide(rootDir, taskId, options) {
       `workflow is not ready for a plan-only decision: ${taskId}`
     );
   }
-  const workflowPath = path68.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path68.join(workflowPath, "requirements.md")) || !await pathExists16(path68.join(workflowPath, "plan.md"))) {
+  const workflowPath = path69.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path69.join(workflowPath, "requirements.md")) || !await pathExists16(path69.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "plan-only requires requirements.md and plan.md"
     );
   }
-  const statePath = path68.join(rootDir, ".mancode", "state.json");
+  const statePath = path69.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile47(statePath, "utf-8");
+    originalState = await readFile48(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -48111,25 +48461,25 @@ async function workflowDecide(rootDir, taskId, options) {
   return EXIT_OK11;
 }
 async function commitPlanningTransition(args) {
-  const metadataPath3 = path68.join(
+  const metadataPath3 = path69.join(
     args.rootDir,
     ".mancode",
     "workflows",
     args.taskId,
     "metadata.json"
   );
-  const specPath = path68.join(args.rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path69.join(args.rootDir, ".mancode", "memory", "spec.md");
   let originalMetadata;
   let originalSpec;
   try {
-    originalMetadata = await readFile47(metadataPath3, "utf-8");
+    originalMetadata = await readFile48(metadataPath3, "utf-8");
     originalSpec = await readOptionalText2(specPath);
   } catch (error) {
     return error instanceof Error ? `unable to prepare planning transition: ${error.message}` : "unable to prepare planning transition";
   }
   try {
     await updateWorkflow(args.rootDir, args.taskId, args.workflowPatch);
-    await writeFile49(
+    await writeFile50(
       args.statePath,
       `${JSON.stringify(args.nextState, null, 2)}
 `,
@@ -48143,9 +48493,9 @@ async function commitPlanningTransition(args) {
     return null;
   } catch (error) {
     const rollback = await Promise.allSettled([
-      writeFile49(metadataPath3, originalMetadata, "utf-8"),
-      writeFile49(args.statePath, args.originalState, "utf-8"),
-      originalSpec === null ? rm22(specPath, { force: true }) : writeFile49(specPath, originalSpec, "utf-8")
+      writeFile50(metadataPath3, originalMetadata, "utf-8"),
+      writeFile50(args.statePath, args.originalState, "utf-8"),
+      originalSpec === null ? rm23(specPath, { force: true }) : writeFile50(specPath, originalSpec, "utf-8")
     ]);
     const message = error instanceof Error ? error.message : "planning transition failed";
     return rollback.some((result2) => result2.status === "rejected") ? `${message}; rollback was incomplete` : message;
@@ -48153,7 +48503,7 @@ async function commitPlanningTransition(args) {
 }
 async function readOptionalText2(filePath) {
   try {
-    return await readFile47(filePath, "utf-8");
+    return await readFile48(filePath, "utf-8");
   } catch (error) {
     if (isNodeError10(error) && error.code === "ENOENT") return null;
     throw error;
@@ -48161,10 +48511,10 @@ async function readOptionalText2(filePath) {
 }
 async function restoreOptionalText(filePath, content) {
   if (content === null) {
-    await rm22(filePath, { force: true });
+    await rm23(filePath, { force: true });
     return;
   }
-  await writeFile49(filePath, content, "utf-8");
+  await writeFile50(filePath, content, "utf-8");
 }
 function readActiveSoloPlan(value) {
   if (!value || typeof value !== "object") return null;
@@ -48584,6 +48934,17 @@ contextProgram.command("reconcile-task-head <shared:id>").description(
     options
   );
 });
+contextProgram.command("glossary <action>").description("Manage the user-confirmed shared project glossary").option("--term <term>", "Glossary term (add, update, remove)").option("--definition <text>", "Term definition (add, update)").option(
+  "--alias <alias>",
+  "Term alias; repeat for multiple aliases (add, update)",
+  (value, previous) => [...previous, value],
+  []
+).option("--task <namespace:id>", "Source shared TaskRef (add, update)").option(
+  "--expected-revision <n>",
+  "Current glossary revision (0 for an empty glossary)"
+).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
+  process.exitCode = await contextGlossary(process.cwd(), action, options);
+});
 var contextWorktreeProgram = contextProgram.command("worktree").description("Register and inspect the current mancode checkout binding");
 contextWorktreeProgram.command("register").description(
   "Register this linked worktree before using mancode coordination"