mancode 0.4.2 → 0.5.0

package/dist/cli.js

@@ -134,7 +134,7 @@ import {
   stageV3AdapterUpgradeFiles,
   v3AdapterTargetPath,
   v3AdapterVersionsFromStatuses
-} from "./chunk-LYRYNJHW.js";
+} from "./chunk-73F46VQM.js";
 
 // src/cli.ts
 import { Option, program } from "commander";
@@ -401,7 +401,7 @@ async function inspectMancodeLayout(projectRoot) {
   ]);
   const v3AuthorityPathsPresent = (await Promise.all(
     V3_AUTHORITY_PATHS.map(
-      async (relativePath) => await lstatOrNull(path.join(mancodeRoot, relativePath)) === null ? null : relativePath
+      async (relativePath2) => await lstatOrNull(path.join(mancodeRoot, relativePath2)) === null ? null : relativePath2
     )
   )).filter(
     (value) => value !== null
@@ -436,9 +436,9 @@ async function scanLegacyEntry(root, legacyPath) {
   };
 }
 async function describeNode(target) {
-  const stat4 = await lstatOrNull(target);
-  if (stat4 === null) return null;
-  if (stat4.isFile()) {
+  const stat5 = await lstatOrNull(target);
+  if (stat5 === null) return null;
+  if (stat5.isFile()) {
     const contents = await readFile(target);
     return {
       kind: "file",
@@ -446,7 +446,7 @@ async function describeNode(target) {
       digest: sha256(contents)
     };
   }
-  if (stat4.isSymbolicLink()) {
+  if (stat5.isSymbolicLink()) {
     const link = await readlink(target);
     return {
       kind: "symlink",
@@ -454,7 +454,7 @@ async function describeNode(target) {
       digest: sha256(Buffer.from(link, "utf8"))
     };
   }
-  if (!stat4.isDirectory()) {
+  if (!stat5.isDirectory()) {
     return {
       kind: "other",
       hasBusinessContent: true,
@@ -4464,8 +4464,8 @@ async function unlinkIfExists(target) {
   }
 }
 async function assertSafeStateDirectory(target) {
-  const stat4 = await lstat2(target);
-  if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat2(target);
+  if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_TRANSPORT_AUTHORITY_STATE_UNSAFE");
   }
 }
@@ -9293,13 +9293,13 @@ function parseArtifacts(value) {
       ["relativePath", "classification", "includeInPromotion", "contentDigest"],
       "quarantine artifact"
     );
-    const relativePath = assertSafeSharedRelativePath(
+    const relativePath2 = assertSafeSharedRelativePath(
       item.relativePath
     );
-    if (paths.has(relativePath)) {
+    if (paths.has(relativePath2)) {
       throw new Error("quarantine artifacts must not repeat a relativePath");
     }
-    paths.add(relativePath);
+    paths.add(relativePath2);
     if (typeof item.classification !== "string" || !ARTIFACT_CLASSES.has(item.classification)) {
       throw new Error("quarantine artifact classification is invalid");
     }
@@ -9311,7 +9311,7 @@ function parseArtifacts(value) {
       throw new Error("MANCODE_RAW_ARTIFACT_CANNOT_BE_PROMOTED");
     }
     return {
-      relativePath,
+      relativePath: relativePath2,
       classification,
       includeInPromotion: item.includeInPromotion,
       contentDigest: parseDigestOrNull3(
@@ -9881,7 +9881,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-E6VEEDCF.js");
+        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-7XYKHGTB.js");
         await applyV3AdapterFilePlan2(root, action);
       }
       journal = await completeActivationStep(
@@ -10899,14 +10899,14 @@ function renderBlockedTask(loaded, aliases, allocator, now, blockers) {
 function buildQuarantineCandidate(loaded, candidate, quarantineId, now) {
   const entityFiles = candidateEntityFiles(candidate);
   const artifacts = [
-    ...entityFiles.map(({ relativePath, content }) => ({
-      relativePath,
+    ...entityFiles.map(({ relativePath: relativePath2, content }) => ({
+      relativePath: relativePath2,
       classification: "authority",
       includeInPromotion: true,
       contentDigest: digestText(content)
     })),
-    ...loaded.sourceFiles.filter((file) => file.relativePath.startsWith("artifacts/")).map(({ relativePath, content }) => ({
-      relativePath,
+    ...loaded.sourceFiles.filter((file) => file.relativePath.startsWith("artifacts/")).map(({ relativePath: relativePath2, content }) => ({
+      relativePath: relativePath2,
       classification: "human_view",
       includeInPromotion: true,
       contentDigest: digestText(content)
@@ -10934,8 +10934,8 @@ function buildSourceOnlyQuarantine(loaded, quarantineId, now) {
     purpose: "legacy_migration",
     sourceTaskRef: null,
     candidateTaskRef: { namespace: "local", taskId: quarantineId },
-    artifacts: loaded.sourceFiles.map(({ relativePath, content }) => ({
-      relativePath,
+    artifacts: loaded.sourceFiles.map(({ relativePath: relativePath2, content }) => ({
+      relativePath: relativePath2,
       classification: "authority",
       includeInPromotion: false,
       contentDigest: digestText(content)
@@ -11377,16 +11377,16 @@ function assertLegacyTaskId(value) {
     throw new Error("MANCODE_MIGRATION_LEGACY_TASK_ID_UNSAFE");
   }
 }
-async function readLegacyText(projectRoot, relativePath) {
-  const value = await readLegacyTextOrNull(projectRoot, relativePath);
+async function readLegacyText(projectRoot, relativePath2) {
+  const value = await readLegacyTextOrNull(projectRoot, relativePath2);
   if (value === null) {
     throw new Error("MANCODE_MIGRATION_LEGACY_ENTITY_MISSING");
   }
   return value;
 }
-async function readLegacyTextOrNull(projectRoot, relativePath) {
+async function readLegacyTextOrNull(projectRoot, relativePath2) {
   const root = path18.join(path18.resolve(projectRoot), ".mancode");
-  const segments = safeSegments(relativePath);
+  const segments = safeSegments(relativePath2);
   await assertSafeDirectory(root);
   let directory = root;
   for (const segment of segments.slice(0, -1)) {
@@ -11412,8 +11412,8 @@ async function readLegacyTextOrNull(projectRoot, relativePath) {
   }
   return content;
 }
-async function assertLegacyTextUnchanged(projectRoot, relativePath, expected) {
-  const actual = await readLegacyText(projectRoot, relativePath);
+async function assertLegacyTextUnchanged(projectRoot, relativePath2, expected) {
+  const actual = await readLegacyText(projectRoot, relativePath2);
   if (actual !== expected) {
     throw new Error("MANCODE_LEGACY_TREE_CHANGED_DURING_SCAN");
   }
@@ -11428,16 +11428,16 @@ async function readSafeDirectoryOrEmpty(target) {
   }
 }
 async function assertSafeDirectory(target) {
-  const stat4 = await lstat5(target);
-  if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat5(target);
+  if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_MIGRATION_LEGACY_PATH_UNSAFE");
   }
 }
-function safeSegments(relativePath) {
-  if (!relativePath || path18.isAbsolute(relativePath) || relativePath.includes("\0")) {
+function safeSegments(relativePath2) {
+  if (!relativePath2 || path18.isAbsolute(relativePath2) || relativePath2.includes("\0")) {
     throw new Error("MANCODE_MIGRATION_LEGACY_PATH_UNSAFE");
   }
-  const segments = relativePath.split(path18.sep);
+  const segments = relativePath2.split(path18.sep);
   if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
     throw new Error("MANCODE_MIGRATION_LEGACY_PATH_UNSAFE");
   }
@@ -11620,15 +11620,15 @@ function assertClaimMatchesStore(store, claim) {
   return claim;
 }
 async function assertSafeClaimFile(target) {
-  const stat4 = await lstat6(target);
-  if (!stat4.isFile() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat6(target);
+  if (!stat5.isFile() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_CLAIM_PATH_UNSAFE");
   }
 }
 async function assertSafeClaimDirectory(store) {
   const directory = claimDirectory(store);
-  const stat4 = await lstat6(directory);
-  if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat6(directory);
+  if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_CLAIM_PATH_UNSAFE");
   }
 }
@@ -11760,14 +11760,14 @@ async function atomicWriteHandoff(store, handoff) {
   await assertSafeHandoffFile(target);
 }
 async function assertSafeHandoffFile(target) {
-  const stat4 = await lstat7(target);
-  if (!stat4.isFile() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat7(target);
+  if (!stat5.isFile() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_HANDOFF_PATH_UNSAFE");
   }
 }
 async function assertSafeHandoffDirectory(store) {
-  const stat4 = await lstat7(handoffDirectory(store));
-  if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat7(handoffDirectory(store));
+  if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_HANDOFF_PATH_UNSAFE");
   }
 }
@@ -13737,7 +13737,7 @@ async function upgradeV3Adapters(input) {
   if (unfinished.length > 0) {
     throw new Error("MANCODE_ADAPTER_UPGRADE_OPERATION_PENDING");
   }
-  const actualVersions = await import("./v3-adapter-E6VEEDCF.js").then(
+  const actualVersions = await import("./v3-adapter-7XYKHGTB.js").then(
     ({ inspectV3AdapterVersions: inspectV3AdapterVersions2 }) => inspectV3AdapterVersions2(
       root,
       managedAdapterNames(project.manifest.managedAdapters)
@@ -14216,8 +14216,8 @@ async function removeAdapterUpgradePreview(root, operationId) {
 async function readAdapterUpgradePreview(root, operationId) {
   const target = adapterUpgradePreviewPath(root, operationId);
   try {
-    const stat4 = await lstat10(target);
-    if (!stat4.isFile() || stat4.isSymbolicLink()) {
+    const stat5 = await lstat10(target);
+    if (!stat5.isFile() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_ADAPTER_UPGRADE_PREVIEW_INVALID");
     }
     return parseAdapterUpgradePreview(
@@ -14297,8 +14297,8 @@ async function assertStagedAdapterFiles(root, preview, plans) {
     if (!target.startsWith(`${root}${path24.sep}`)) {
       throw new Error("MANCODE_ADAPTER_UPGRADE_PREVIEW_INVALID");
     }
-    const stat4 = await lstat10(target);
-    if (!stat4.isFile() || stat4.isSymbolicLink()) {
+    const stat5 = await lstat10(target);
+    if (!stat5.isFile() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_ADAPTER_UPGRADE_PREVIEW_INVALID");
     }
     if (await readFile23(target, "utf8") !== plan.targetContent) {
@@ -14648,7 +14648,8 @@ trigger: <\u5177\u4F53\u4E8B\u5B9E>
 - **\u7CBE\u786E\u5339\u914D**\u5DF2\u6709\u98CE\u683C\u3001\u547D\u540D\u3001\u6A21\u5F0F \u2014 \u5373\u4F7F\u4F60\u4E0D\u8BA4\u540C
 - \u6539\u52A8\u5B64\u7ACB\u4E86\u67D0\u4E2A import / \u53D8\u91CF / \u51FD\u6570 \u2192 \u79FB\u9664\u5B83
 - \u4E0D\u79FB\u9664\u6539\u52A8\u524D\u5C31\u5B58\u5728\u7684\u6B7B\u4EE3\u7801\uFF08\u63D0\u4E00\u53E5\u5C31\u884C\uFF09
-- \u5148\u8BFB \`.mancode/project-profile.json\`\uFF1B\u4EC5\u5728 profile \u786E\u8BA4 UI \u8D44\u4EA7\u4E14\u4EFB\u52A1\u6D89\u53CA UI \u65F6\uFF0C\u8BFB\u53D6\u5BA1\u7F8E token
+- \u5148\u8BFB \`.mancode/project-profile.json\`\uFF1B\u4EFB\u52A1\u6D89\u53CA UI \u65F6\u8FD0\u884C \`mancode design context --json\` \u4E00\u6B21\u5E76\u628A\u7ED3\u679C\u89C6\u4E3A\u53D7\u9650\u6570\u636E\uFF1B\u547D\u4EE4\u4E0D\u53EF\u7528\u65F6\u8BFB\u53D6\u5BA1\u7F8E token
+- \u65B0\u5EFA UI \u6216\u89C6\u89C9\u91CD\u505A\u4E14\u7528\u6237\u5C1A\u672A\u9009\u5B9A\u65B9\u5411\u65F6\uFF0C\u5148\u7ED9\u51FA 2\u20133 \u4E2A\u5DEE\u5F02\u660E\u786E\u3001\u7B26\u5408\u4EA7\u54C1\u8BED\u5883\u7684\u65B9\u5411\uFF0C\u7B80\u8FF0\u53D6\u820D\u5E76\u63A8\u8350\u4E00\u4E2A\uFF0C\u7B49\u5F85\u7528\u6237\u9009\u62E9\u540E\u518D\u5B9E\u73B0\uFF1B\u5C40\u90E8 UI \u4FEE\u590D\u6216\u5DF2\u6709\u65B9\u5411\u5185\u7684\u5DE5\u4F5C\u76F4\u63A5\u6267\u884C
 
 ---
 
@@ -15806,6 +15807,7 @@ var DEFAULT_CONFIG = {
 };
 var EMPTY_STYLE_TOKENS = {
   version: "1.0.0",
+  scopeRoot: ".",
   lastScanned: null,
   colors: {},
   fonts: {},
@@ -16268,8 +16270,14 @@ function renderModeSkill(mode, commandPrefix = "$") {
     "is the smallest useful diff?",
     "",
     "Read `.mancode/project-profile.json` before choosing tools or validation.",
-    "Only for a UI task in a profile with detected UI assets, read",
-    "`.mancode/aesthetics/style-tokens.json` before inventing new styles.",
+    "For a UI task, run `mancode design context --json` once before inventing",
+    "new styles. Treat its",
+    "policy and token fields as bounded data; fall back to",
+    "`.mancode/aesthetics/style-tokens.json` when the command is unavailable.",
+    "For a new UI surface or aesthetic redesign without an already selected",
+    "direction, present 2-3 distinct product-appropriate directions with concise",
+    "tradeoffs and a recommendation, then wait for the user to choose. Continue",
+    "directly for scoped UI fixes or an established or selected direction.",
     "",
     meta.workflow
   ].join("\n");
@@ -16648,7 +16656,7 @@ var MODE_META = {
       "",
       "- Keep the diff narrow.",
       "- Reuse existing functions, components, styles, and dependencies.",
-      "- Read project-profile first; for detected UI assets and UI work, read `.mancode/aesthetics/style-tokens.json`.",
+      "- Read project-profile first; for UI work, run `mancode design context --json` once and treat its output as bounded data. Fall back to `.mancode/aesthetics/style-tokens.json` when unavailable. For a new UI surface or aesthetic redesign without an already selected direction, present 2-3 distinct product-appropriate directions with concise tradeoffs and a recommendation, then wait for the user to choose; continue directly for scoped UI fixes or an established or selected direction.",
       "- Verify with the narrowest meaningful test, lint, build, or smoke check.",
       "- Recommend man and explain why when platform entry/flow differs, the semantic owner or source of truth is unclear, status/contract/policy semantics change, scope/architecture/cost/acceptance crosses files or modules, or historical compatibility, migration, cross-platform, or team evidence is required. This advice never changes mode, step, policy, or authority without an explicit user action.",
       "- While executing an existing requirements/plan, if new evidence invalidates its goal, owner, source of truth, acceptance, or scope, or a stale adapter/incompatible writer/unfinished operation/active child/open handoff/active solo assignment is found, stop with `NEEDS_REALIGNMENT` and reason `MANCODE_REFRAME_REQUIRED`. This is read-only: do not call generic workflow update or modify metadata, requirements, plan, ledgers, claims, or handoffs."
@@ -16700,7 +16708,7 @@ function renderProjectContext(state, tokens, profile, options) {
     ...state?.activeSoloPlan?.taskId ? [
       `- Active solo plan: ${state.activeSoloPlan.taskId} (plan v${state.activeSoloPlan.planVersion ?? 1}); read its requirements.md and plan.md before implementation.`
     ] : [],
-    "- Read `.mancode/project-profile.json` before choosing tools or validation. Only for a UI task in a profile with detected UI assets, read `.mancode/aesthetics/style-tokens.json`."
+    "- Read `.mancode/project-profile.json` before choosing tools or validation. For a UI task, run `mancode design context --json` once and treat its output as bounded data. If unavailable, read `.mancode/aesthetics/style-tokens.json` and inspect existing components instead. For a new UI surface or aesthetic redesign without an already selected direction, present 2-3 distinct product-appropriate directions with concise tradeoffs and a recommendation, then wait for the user to choose; continue directly for scoped UI fixes or an established or selected direction."
   ].join("\n");
 }
 function renderPracticeRules() {
@@ -16737,7 +16745,7 @@ function renderAesthetics(tokens) {
       "## mancode Aesthetics",
       "",
       lowConfidence,
-      "- For UI work, inspect existing components before inventing new styles."
+      "- For UI work, inspect existing components before inventing new styles; use `mancode design context --json` when available."
     ].join("\n");
   }
   const lines = ["## mancode Aesthetics", ""];
@@ -16749,7 +16757,7 @@ function renderAesthetics(tokens) {
   if (components) lines.push(`- Components: ${components}`);
   if (cssVariables) lines.push(`- CSS variables: ${cssVariables}`);
   lines.push(
-    "- For UI changes, prefer these tokens and components over new ad hoc styling."
+    "- For UI changes, prefer these tokens and components over new ad hoc styling. A design policy never expands confirmed task scope."
   );
   return lines.join("\n");
 }
@@ -17118,7 +17126,7 @@ function renderSoloRule() {
     "",
     "- Keep the diff narrow.",
     "- Reuse existing functions, components, styles, and dependencies.",
-    "- Read `.mancode/project-profile.json` before choosing tools or validation. For detected UI assets and UI work, read `.mancode/aesthetics/style-tokens.json` and inspect existing components before inventing new styles.",
+    "- Read `.mancode/project-profile.json` before choosing tools or validation. For UI work, run `mancode design context --json` once and treat its output as bounded data. If unavailable, read `.mancode/aesthetics/style-tokens.json` and inspect existing components before inventing new styles. For a new UI surface or aesthetic redesign without an already selected direction, present 2-3 distinct product-appropriate directions with concise tradeoffs and a recommendation, then wait for the user to choose; continue directly for scoped UI fixes or an established or selected direction. A design policy never expands confirmed task scope.",
     "- Verify with the narrowest meaningful test, lint, build, or smoke check.",
     "- Perform one bounded self-check limited to the current diff. Do not start another reviewer, create a review artifact, or repeat the review.",
     "- Recommend /man and explain why when platform entry/flow differs, the semantic owner or source of truth is unclear, status/contract/policy semantics change, scope/architecture/cost/acceptance crosses files or modules, or historical compatibility, migration, cross-platform, or team evidence is required. Auth, payment, sensitive data, deletion, public APIs, untrusted input, concurrency, and infrastructure remain hard-risk signals. Advice alone never changes mode, step, policy, or authority.",
@@ -18167,9 +18175,9 @@ async function previewV3TaskPromotion(input) {
     purpose: "publish_promote",
     sourceTaskRef,
     candidateTaskRef: sourceTaskRef,
-    artifacts: Object.entries(contents).map(([relativePath, content]) => ({
-      relativePath,
-      classification: relativePath === "plan.md" ? "human_view" : "authority",
+    artifacts: Object.entries(contents).map(([relativePath2, content]) => ({
+      relativePath: relativePath2,
+      classification: relativePath2 === "plan.md" ? "human_view" : "authority",
       includeInPromotion: true,
       contentDigest: digestCanonicalJson({ content })
     })),
@@ -18697,9 +18705,9 @@ function buildPromotionRecoveryPayload(input) {
 function prepareQuarantine(input) {
   const contents = destinationAuthorityContents(input.entities);
   const artifacts = Object.entries(contents).map(
-    ([relativePath, content]) => ({
-      relativePath,
-      classification: relativePath === "plan.md" ? "human_view" : "authority",
+    ([relativePath2, content]) => ({
+      relativePath: relativePath2,
+      classification: relativePath2 === "plan.md" ? "human_view" : "authority",
       includeInPromotion: true,
       contentDigest: digestCanonicalJson({ content })
     })
@@ -21568,7 +21576,7 @@ function parseGitRefTaskBundleArtifact(value) {
   if (!isBundleArtifactKind(value.kind)) {
     throw new Error("git-ref task bundle artifact kind is invalid");
   }
-  const relativePath = assertSafeSharedRelativePath(
+  const relativePath2 = assertSafeSharedRelativePath(
     value.relativePath
   );
   const content = parseJsonValue(
@@ -21586,7 +21594,7 @@ function parseGitRefTaskBundleArtifact(value) {
   if (contentDigest !== digestCanonicalJson(content)) {
     throw new Error("MANCODE_TRANSPORT_BUNDLE_ARTIFACT_DIGEST_MISMATCH");
   }
-  return { kind: value.kind, relativePath, content, contentDigest };
+  return { kind: value.kind, relativePath: relativePath2, content, contentDigest };
 }
 function parseJsonValue(value, label, depth = 0) {
   if (depth > MAX_JSON_DEPTH) {
@@ -23319,11 +23327,11 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
   }
   return matches[0] ?? null;
 }
-function artifact(kind, relativePath, value) {
+function artifact(kind, relativePath2, value) {
   const content = JSON.parse(JSON.stringify(value));
   return {
     kind,
-    relativePath,
+    relativePath: relativePath2,
     content,
     contentDigest: digestCanonicalJson(content)
   };
@@ -23670,13 +23678,13 @@ async function applyJournal(projectRoot, journal) {
     "workflows",
     journal.targetBundle.taskRef.taskId
   ]);
-  for (const [relativePath, content] of target) {
+  for (const [relativePath2, content] of target) {
     await replaceVerifiedFile(
       taskRoot2,
-      relativePath,
+      relativePath2,
       content,
-      predecessor.get(relativePath) ?? null,
-      relativePath === "metadata.json" ? pendingMetadataContent : null
+      predecessor.get(relativePath2) ?? null,
+      relativePath2 === "metadata.json" ? pendingMetadataContent : null
     );
   }
   for (const optional of ["plan.md", "summary.md"]) {
@@ -23814,18 +23822,18 @@ function serializeArtifact(artifact2) {
   return `${JSON.stringify(artifact2.content, null, 2)}
 `;
 }
-async function replaceVerifiedFile(taskRoot2, relativePath, targetContent, predecessorContent, alternatePredecessorContent) {
-  const target = safeTaskPath(taskRoot2, relativePath);
+async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, predecessorContent, alternatePredecessorContent) {
+  const target = safeTaskPath(taskRoot2, relativePath2);
   await ensureSafeDirectory(
     taskRoot2,
-    path42.dirname(relativePath).split(path42.sep)
+    path42.dirname(relativePath2).split(path42.sep)
   );
   const current = await readSafeFileOrNull(target);
-  if (contentMatches(relativePath, current, targetContent)) return;
-  if (current !== null && !contentMatches(relativePath, current, predecessorContent) && !contentMatches(relativePath, current, alternatePredecessorContent)) {
+  if (contentMatches(relativePath2, current, targetContent)) return;
+  if (current !== null && !contentMatches(relativePath2, current, predecessorContent) && !contentMatches(relativePath2, current, alternatePredecessorContent)) {
     throw new Error("MANCODE_SPLIT_BRAIN");
   }
-  if (current === null && (predecessorContent !== null || alternatePredecessorContent !== null) && relativePath !== "summary.md") {
+  if (current === null && (predecessorContent !== null || alternatePredecessorContent !== null) && relativePath2 !== "summary.md") {
     throw new Error("MANCODE_SPLIT_BRAIN");
   }
   const temporary = path42.join(
@@ -23835,9 +23843,9 @@ async function replaceVerifiedFile(taskRoot2, relativePath, targetContent, prede
   await writeFile36(temporary, targetContent, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
-function contentMatches(relativePath, current, expected) {
+function contentMatches(relativePath2, current, expected) {
   if (current === null || expected === null) return current === expected;
-  if (!relativePath.endsWith(".json")) return current === expected;
+  if (!relativePath2.endsWith(".json")) return current === expected;
   try {
     return digestCanonicalJson(JSON.parse(current)) === digestCanonicalJson(JSON.parse(expected));
   } catch {
@@ -23871,8 +23879,8 @@ function bundleMetadata(bundle) {
   }
   return parseWorkflowMetadata(artifact2.content);
 }
-async function removeVerifiedFile(taskRoot2, relativePath, predecessorContent) {
-  const target = safeTaskPath(taskRoot2, relativePath);
+async function removeVerifiedFile(taskRoot2, relativePath2, predecessorContent) {
+  const target = safeTaskPath(taskRoot2, relativePath2);
   const current = await readSafeFileOrNull(target);
   if (current === null) return;
   if (predecessorContent === null || current !== predecessorContent) {
@@ -23916,8 +23924,8 @@ async function ensureSafeDirectory(root, segments) {
     }
   }
 }
-function safeTaskPath(taskRoot2, relativePath) {
-  const target = path42.resolve(taskRoot2, relativePath);
+function safeTaskPath(taskRoot2, relativePath2) {
+  const target = path42.resolve(taskRoot2, relativePath2);
   const relative = path42.relative(taskRoot2, target);
   if (!relative || relative.startsWith("..") || path42.isAbsolute(relative)) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
@@ -25297,15 +25305,692 @@ function parseExpectedRevision2(value) {
   return Number.isSafeInteger(parsed) ? parsed : null;
 }
 
+// src/commands/design.ts
+import { readFile as readFile37, stat as stat4 } from "fs/promises";
+import path45 from "path";
+import process2 from "process";
+
+// src/context/design-policy.ts
+import {
+  lstat as lstat19,
+  mkdir as mkdir33,
+  readFile as readFile36,
+  realpath as realpath2,
+  rm as rm17,
+  writeFile as writeFile38
+} from "fs/promises";
+import path44 from "path";
+var DEFAULT_DESIGN_POLICY = {
+  schemaVersion: 1,
+  revision: 0,
+  enabled: false,
+  preset: "preserve",
+  iconPolicy: "existing-first",
+  emojiPolicy: "forbid-as-interface-icon",
+  motionPolicy: "purposeful",
+  browserValidation: "when-available",
+  lastOperationId: null,
+  updatedAt: "1970-01-01T00:00:00.000Z"
+};
+function designPolicyPath(projectRoot) {
+  return path44.join(
+    path44.resolve(projectRoot),
+    ".mancode",
+    "shared",
+    "context",
+    "design-policy.json"
+  );
+}
+function parseDesignPolicy(value) {
+  assertRecord(value, "design policy");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "revision",
+      "enabled",
+      "preset",
+      "iconPolicy",
+      "emojiPolicy",
+      "motionPolicy",
+      "browserValidation",
+      "lastOperationId",
+      "updatedAt"
+    ],
+    "design policy"
+  );
+  if (value.schemaVersion !== 1) {
+    throw new Error("design policy schemaVersion must be 1");
+  }
+  if (!isPositiveInteger(value.revision)) {
+    throw new Error("design policy revision must be a positive integer");
+  }
+  if (typeof value.enabled !== "boolean") {
+    throw new Error("design policy enabled must be boolean");
+  }
+  if (!isDesignPreset(value.preset)) {
+    throw new Error("design policy preset is invalid");
+  }
+  if (!isDesignIconPolicy(value.iconPolicy)) {
+    throw new Error("design policy iconPolicy is invalid");
+  }
+  if (!isDesignEmojiPolicy(value.emojiPolicy)) {
+    throw new Error("design policy emojiPolicy is invalid");
+  }
+  if (!isDesignMotionPolicy(value.motionPolicy)) {
+    throw new Error("design policy motionPolicy is invalid");
+  }
+  if (!isDesignBrowserValidation(value.browserValidation)) {
+    throw new Error("design policy browserValidation is invalid");
+  }
+  if (value.lastOperationId !== null) {
+    assertUlid(value.lastOperationId, "design policy lastOperationId");
+  }
+  if (typeof value.updatedAt !== "string" || Number.isNaN(Date.parse(value.updatedAt))) {
+    throw new Error("design policy updatedAt must be a timestamp");
+  }
+  return {
+    schemaVersion: 1,
+    revision: value.revision,
+    enabled: value.enabled,
+    preset: value.preset,
+    iconPolicy: value.iconPolicy,
+    emojiPolicy: value.emojiPolicy,
+    motionPolicy: value.motionPolicy,
+    browserValidation: value.browserValidation,
+    lastOperationId: value.lastOperationId,
+    updatedAt: value.updatedAt
+  };
+}
+async function readDesignPolicy(projectRoot) {
+  try {
+    return parseDesignPolicy(
+      JSON.parse(await readFile36(designPolicyPath(projectRoot), "utf8"))
+    );
+  } catch (error) {
+    if (isNotFound27(error)) return null;
+    if (error instanceof SyntaxError) {
+      throw new Error(
+        "MANCODE_CONTEXT_ENTITY_CORRUPT: shared/context/design-policy.json"
+      );
+    }
+    throw error;
+  }
+}
+async function configureDesignPolicy(input) {
+  assertNonNegativeRevision(input.expectedRevision);
+  const operationId = input.operationId ?? createUlid();
+  assertUlid(operationId, "design policy operationId");
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const root = path44.resolve(input.projectRoot);
+  const runtime = await readProjectRuntimeContext(root);
+  const store = resolveCoordinationEntityHomeStore(
+    runtime.entityHomeStoreContext
+  );
+  const locks = await acquireEntityLocks(store, operationId, [
+    `design-policy:${runtime.workspaceId}`
+  ]);
+  try {
+    await assertDesignPolicyPathSafe(root);
+    const current = await readDesignPolicy(root);
+    const currentRevision = current?.revision ?? 0;
+    if (currentRevision !== input.expectedRevision) {
+      throw new Error("MANCODE_EXPECTED_REVISION_CONFLICT");
+    }
+    const next = parseDesignPolicy({
+      ...current ?? DEFAULT_DESIGN_POLICY,
+      revision: currentRevision + 1,
+      enabled: input.enabled ?? current?.enabled ?? true,
+      preset: input.preset ?? current?.preset ?? DEFAULT_DESIGN_POLICY.preset,
+      iconPolicy: input.iconPolicy ?? current?.iconPolicy ?? DEFAULT_DESIGN_POLICY.iconPolicy,
+      emojiPolicy: input.emojiPolicy ?? current?.emojiPolicy ?? DEFAULT_DESIGN_POLICY.emojiPolicy,
+      motionPolicy: input.motionPolicy ?? current?.motionPolicy ?? DEFAULT_DESIGN_POLICY.motionPolicy,
+      browserValidation: input.browserValidation ?? current?.browserValidation ?? DEFAULT_DESIGN_POLICY.browserValidation,
+      lastOperationId: operationId,
+      updatedAt: now.toISOString()
+    });
+    if (next.enabled && next.preset === "experimental" && input.confirmExperimental !== true) {
+      throw new Error("MANCODE_DESIGN_EXPERIMENTAL_CONFIRMATION_REQUIRED");
+    }
+    await writeDesignPolicy(root, next);
+    return { policy: next, operationId, digest: digestCanonicalJson(next) };
+  } finally {
+    await Promise.allSettled(
+      [...locks].reverse().map((lock) => lock.release())
+    );
+  }
+}
+function isDesignPreset(value) {
+  return value === "preserve" || value === "refine" || value === "experimental";
+}
+function isDesignIconPolicy(value) {
+  return value === "existing-first" || value === "lucide";
+}
+function isDesignEmojiPolicy(value) {
+  return value === "allow" || value === "forbid-as-interface-icon";
+}
+function isDesignMotionPolicy(value) {
+  return value === "minimal" || value === "purposeful";
+}
+function isDesignBrowserValidation(value) {
+  return value === "off" || value === "when-available" || value === "required";
+}
+async function writeDesignPolicy(projectRoot, policy) {
+  const target = designPolicyPath(projectRoot);
+  await mkdir33(path44.dirname(target), { recursive: true });
+  const temporary = path44.join(
+    path44.dirname(target),
+    `.${path44.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  );
+  await writeFile38(temporary, `${JSON.stringify(policy, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: "wx"
+  });
+  try {
+    await replaceFileAtomically(temporary, target);
+  } finally {
+    await rm17(temporary, { force: true }).catch(() => void 0);
+  }
+}
+async function assertDesignPolicyPathSafe(projectRoot) {
+  const root = path44.resolve(projectRoot);
+  const policyPath = designPolicyPath(root);
+  const contextDir = path44.dirname(policyPath);
+  try {
+    for (const directory of [
+      path44.join(root, ".mancode"),
+      path44.join(root, ".mancode", "shared"),
+      contextDir
+    ]) {
+      const info = await lstat19(directory);
+      if (info.isSymbolicLink() || !info.isDirectory()) {
+        throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
+      }
+    }
+    const [resolvedRoot, resolvedContextDir] = await Promise.all([
+      realpath2(root),
+      realpath2(contextDir)
+    ]);
+    const relative = path44.relative(resolvedRoot, resolvedContextDir);
+    if (path44.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path44.sep}`)) {
+      throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
+    }
+    try {
+      const info = await lstat19(policyPath);
+      if (info.isSymbolicLink() || !info.isFile()) {
+        throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
+      }
+    } catch (error) {
+      if (!isNotFound27(error)) throw error;
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message === "MANCODE_DESIGN_POLICY_PATH_UNSAFE") {
+      throw error;
+    }
+    throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
+  }
+}
+function assertNonNegativeRevision(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("MANCODE_EXPECTED_REVISION_REQUIRED");
+  }
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNotFound27(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/commands/design.ts
+var EXIT_OK = 0;
+var EXIT_NOT_INITIALIZED = 1;
+var EXIT_DESIGN_FAILED = 2;
+var EXIT_DESIGN_ARGUMENT_INVALID = 3;
+async function designStatus(rootDir = process2.cwd(), options = {}) {
+  if (!await initializedKind(rootDir)) {
+    return printError(
+      options.json,
+      "MANCODE_NOT_INITIALIZED",
+      "Run `mancode init` first.",
+      EXIT_NOT_INITIALIZED
+    );
+  }
+  const policyResult = await readPolicyFailOpen(rootDir);
+  const payload = {
+    schemaVersion: 1,
+    policyStatus: policyResult.status,
+    policy: policyResult.policy,
+    effectivePreset: policyResult.policy?.enabled === true ? policyResult.policy.preset : "preserve",
+    policyPath: relativePath(rootDir, designPolicyPath(rootDir)),
+    warning: policyResult.warning
+  };
+  return printResult(options.json, payload, [
+    `Design policy: ${payload.policyStatus}`,
+    `Effective preset: ${payload.effectivePreset}`,
+    `Revision: ${payload.policy?.revision ?? 0}`,
+    ...payload.warning === null ? [] : [`Warning: ${payload.warning}`]
+  ]);
+}
+async function designContext(rootDir = process2.cwd(), options = {}) {
+  const kind = await initializedKind(rootDir);
+  if (!kind) {
+    return printError(
+      options.json,
+      "MANCODE_NOT_INITIALIZED",
+      "Run `mancode init` first.",
+      EXIT_NOT_INITIALIZED
+    );
+  }
+  try {
+    const [profile, policyResult, style] = await Promise.all([
+      readProfile(rootDir, kind),
+      readPolicyFailOpen(rootDir),
+      readStyleSummary(rootDir, kind)
+    ]);
+    const configured = policyResult.policy;
+    const active = configured?.enabled === true;
+    const policy = active ? configured : disabledPolicy();
+    const rootUiDetected = profile?.uiAssets === "detected";
+    const scopedUiDetected = style.scopeRoot !== "." && style.lastScanned !== null;
+    const applicable = rootUiDetected || scopedUiDetected;
+    const payload = {
+      schemaVersion: 1,
+      applicable,
+      reason: rootUiDetected ? "ui_assets_detected" : scopedUiDetected ? "scoped_ui_assets_detected" : "ui_assets_not_detected",
+      policyStatus: policyResult.status,
+      policySource: active ? "project" : "built-in-safe-default",
+      policy: {
+        enabled: policy.enabled,
+        revision: configured?.revision ?? 0,
+        preset: policy.preset,
+        iconPolicy: policy.iconPolicy,
+        emojiPolicy: policy.emojiPolicy,
+        motionPolicy: policy.motionPolicy,
+        browserValidation: policy.browserValidation
+      },
+      constraints: active ? {
+        doNotExpandTaskScope: true,
+        reuseExistingDesignSystem: true,
+        dependencyChangesRequireTaskApproval: true,
+        experimentalDoesNotAuthorizeProductChanges: true
+      } : {
+        doNotExpandTaskScope: true,
+        reuseExistingDesignSystem: true
+      },
+      project: {
+        kind: profile?.projectKind ?? "unknown",
+        uiAssets: profile?.uiAssets ?? "none",
+        browserAutomation: profile?.browserAutomation ?? "unknown"
+      },
+      guidance: designGuidance(policy),
+      qualityGates: designQualityGates(policy),
+      style,
+      warning: policyResult.warning
+    };
+    return printResult(options.json, payload, [
+      `Applicable: ${payload.applicable ? "yes" : "no"}`,
+      `Design preset: ${payload.policy.preset}`,
+      `Policy: ${payload.policyStatus}`,
+      `Style match: ${payload.style.matchLevel} (${payload.style.freshness})`
+    ]);
+  } catch (error) {
+    return printError(
+      options.json,
+      "MANCODE_DESIGN_CONTEXT_FAILED",
+      error instanceof Error ? error.message : "Unable to read design context.",
+      EXIT_DESIGN_FAILED
+    );
+  }
+}
+async function designConfigure(rootDir, options) {
+  const availability = await policyMutationAvailability(rootDir, options.json);
+  if (availability !== null) return availability;
+  const expectedRevision = parseNonNegativeInteger2(options.expectedRevision);
+  const values = parseConfigureValues(options);
+  if (expectedRevision === null || values === null) {
+    return printError(
+      options.json,
+      "MANCODE_DESIGN_ARGUMENT_INVALID",
+      "Use valid design policy values and --expected-revision <n>.",
+      EXIT_DESIGN_ARGUMENT_INVALID
+    );
+  }
+  if (values.preset === "experimental" && options.confirmExperimental !== true) {
+    return printError(
+      options.json,
+      "MANCODE_DESIGN_EXPERIMENTAL_CONFIRMATION_REQUIRED",
+      "Pass --confirm-experimental to enable the experimental preset.",
+      EXIT_DESIGN_ARGUMENT_INVALID
+    );
+  }
+  try {
+    const result2 = await configureDesignPolicy({
+      projectRoot: rootDir,
+      expectedRevision,
+      enabled: true,
+      confirmExperimental: options.confirmExperimental,
+      ...values
+    });
+    return printResult(options.json, { schemaVersion: 1, ...result2 }, [
+      `Design policy configured: ${result2.policy.preset}`,
+      `Revision: ${result2.policy.revision}`
+    ]);
+  } catch (error) {
+    const code = errorCode3(error, "MANCODE_DESIGN_CONFIGURE_FAILED");
+    return printError(
+      options.json,
+      code,
+      error instanceof Error ? error.message : "Unable to configure design policy.",
+      code === "MANCODE_DESIGN_EXPERIMENTAL_CONFIRMATION_REQUIRED" ? EXIT_DESIGN_ARGUMENT_INVALID : EXIT_DESIGN_FAILED
+    );
+  }
+}
+async function designDisable(rootDir, options) {
+  const availability = await policyMutationAvailability(rootDir, options.json);
+  if (availability !== null) return availability;
+  const expectedRevision = parseNonNegativeInteger2(options.expectedRevision);
+  if (expectedRevision === null) {
+    return printError(
+      options.json,
+      "MANCODE_DESIGN_ARGUMENT_INVALID",
+      "Use --expected-revision <n>.",
+      EXIT_DESIGN_ARGUMENT_INVALID
+    );
+  }
+  try {
+    const result2 = await configureDesignPolicy({
+      projectRoot: rootDir,
+      expectedRevision,
+      enabled: false
+    });
+    return printResult(options.json, { schemaVersion: 1, ...result2 }, [
+      "Design policy disabled.",
+      `Revision: ${result2.policy.revision}`
+    ]);
+  } catch (error) {
+    return printError(
+      options.json,
+      errorCode3(error, "MANCODE_DESIGN_DISABLE_FAILED"),
+      error instanceof Error ? error.message : "Unable to disable design policy.",
+      EXIT_DESIGN_FAILED
+    );
+  }
+}
+function parseConfigureValues(options) {
+  if (options.preset !== void 0 && !isDesignPreset(options.preset))
+    return null;
+  if (options.icons !== void 0 && !isDesignIconPolicy(options.icons))
+    return null;
+  if (options.emoji !== void 0 && !isDesignEmojiPolicy(options.emoji))
+    return null;
+  if (options.motion !== void 0 && !isDesignMotionPolicy(options.motion))
+    return null;
+  if (options.browserValidation !== void 0 && !isDesignBrowserValidation(options.browserValidation)) {
+    return null;
+  }
+  return {
+    preset: options.preset,
+    iconPolicy: options.icons,
+    emojiPolicy: options.emoji,
+    motionPolicy: options.motion,
+    browserValidation: options.browserValidation
+  };
+}
+async function readPolicyFailOpen(rootDir) {
+  try {
+    const policy = await readDesignPolicy(rootDir);
+    return policy === null ? { status: "missing", policy: null, warning: null } : { status: "configured", policy, warning: null };
+  } catch {
+    return {
+      status: "invalid",
+      policy: null,
+      warning: "Design policy is invalid; using the built-in preserve policy."
+    };
+  }
+}
+async function readProfile(rootDir, kind) {
+  if (kind === "continuity") {
+    return (await new V3ContextStore(rootDir).readProjectSnapshot()).projectFacts?.profile ?? null;
+  }
+  try {
+    return JSON.parse(
+      await readFile37(
+        path45.join(rootDir, ".mancode", "project-profile.json"),
+        "utf8"
+      )
+    );
+  } catch {
+    return null;
+  }
+}
+async function readStyleSummary(rootDir, kind) {
+  const cachePath = kind === "continuity" ? path45.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path45.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
+  try {
+    const raw = JSON.parse(await readFile37(cachePath, "utf8"));
+    return sanitizeStyleSummary(rootDir, raw);
+  } catch {
+    return emptyStyleSummary();
+  }
+}
+async function sanitizeStyleSummary(rootDir, value) {
+  if (!isRecord6(value)) return emptyStyleSummary();
+  const scopeRoot = safeScopeRoot(value.scopeRoot);
+  const lastScanned = safeTimestamp(value.lastScanned);
+  const sourceFiles = safeStringList(value.sourceFiles, 12, isSafeRelativeFile);
+  return {
+    scopeRoot,
+    lastScanned,
+    freshness: await styleFreshness(
+      rootDir,
+      scopeRoot,
+      lastScanned,
+      sourceFiles
+    ),
+    matchLevel: safeMatchLevel(value.matchLevel),
+    uiLibrary: safeShortText(value.uiLibrary),
+    darkMode: safeShortText(value.darkMode),
+    colors: safeStringRecord(value.colors, 8),
+    fonts: safeFontRecord(value.fonts, 4),
+    components: safeStringList(
+      value.components,
+      8,
+      (item) => /^[A-Z][A-Za-z0-9]{0,79}$/.test(item)
+    ),
+    cssVariables: safeStringRecord(value.cssVariables, 8),
+    sourceFiles
+  };
+}
+async function styleFreshness(rootDir, scopeRoot, lastScanned, sourceFiles) {
+  if (lastScanned === null || sourceFiles.length === 0) return "unavailable";
+  const scannedAt = Date.parse(lastScanned);
+  for (const file of sourceFiles) {
+    try {
+      const info = await stat4(path45.resolve(rootDir, scopeRoot, file));
+      if (info.mtimeMs > scannedAt) return "stale";
+    } catch {
+      return "stale";
+    }
+  }
+  return "fresh";
+}
+function disabledPolicy() {
+  return {
+    ...DEFAULT_DESIGN_POLICY,
+    emojiPolicy: "allow",
+    motionPolicy: "minimal",
+    browserValidation: "off"
+  };
+}
+function designGuidance(policy) {
+  return [
+    directionSelectionGuidance(),
+    presetGuidance(policy.preset),
+    iconGuidance(policy.iconPolicy),
+    emojiGuidance(policy.emojiPolicy),
+    motionGuidance(policy.motionPolicy)
+  ];
+}
+function directionSelectionGuidance() {
+  return "Before implementing a new UI surface or an aesthetic redesign when the user has not chosen a visual direction, present 2-3 distinct, product-appropriate directions with concise tradeoffs and a recommendation, then wait for the user to choose. Continue directly for scoped UI fixes or work within an established or already selected direction.";
+}
+function presetGuidance(preset) {
+  if (preset === "refine") {
+    return "Preserve the product structure while improving hierarchy, typography, spacing, interaction states, and responsive behavior within the task scope.";
+  }
+  if (preset === "experimental") {
+    return "After the user chooses a direction, execute one coherent, product-appropriate visual system. For brand, campaign, editorial, portfolio, or launch surfaces, make the first viewport the strongest brand signal and carry its visual motif through the full page; for task-oriented products, prioritize workflow clarity over spectacle. Advanced composition and purposeful motion are allowed only within the task scope and must not obscure core workflows.";
+  }
+  return "Retain the existing visual hierarchy, layout, component system, and interaction patterns; make only task-required UI changes.";
+}
+function iconGuidance(policy) {
+  return policy === "lucide" ? "Use Lucide for interface icons when it is already available; adding or replacing a dependency requires explicit task approval." : "Reuse the project's existing icon system; do not introduce another icon library without explicit task approval.";
+}
+function emojiGuidance(policy) {
+  return policy === "forbid-as-interface-icon" ? "Do not use emoji as interface icons." : "Follow the existing product conventions for emoji.";
+}
+function motionGuidance(policy) {
+  return policy === "purposeful" ? "Use motion only to clarify hierarchy, state changes, or spatial relationships, and preserve reduced-motion accessibility." : "Keep motion minimal and preserve reduced-motion accessibility.";
+}
+function designQualityGates(policy) {
+  const browserGate = policy.browserValidation === "required" ? "Validate changed UI in a browser at relevant desktop and mobile viewports before completion; report a blocker if browser validation is unavailable." : policy.browserValidation === "when-available" ? "When existing browser tooling is available, validate changed UI at relevant desktop and mobile viewports." : "Use the project checks already available; browser automation is not required by this policy.";
+  return [
+    "Preserve task-critical workflows, keyboard access, visible focus, readable contrast, and responsive behavior on changed surfaces.",
+    "Check changed surfaces for clipping, unintended overlap, horizontal overflow, and unstable layout.",
+    browserGate
+  ];
+}
+function emptyStyleSummary() {
+  return {
+    scopeRoot: ".",
+    lastScanned: null,
+    freshness: "unavailable",
+    matchLevel: "none",
+    uiLibrary: null,
+    darkMode: null,
+    colors: {},
+    fonts: {},
+    components: [],
+    cssVariables: {},
+    sourceFiles: []
+  };
+}
+async function initializedKind(rootDir) {
+  if (await exists(path45.join(rootDir, ".mancode", "schema.json"))) {
+    return "continuity";
+  }
+  if (await exists(path45.join(rootDir, ".mancode", "state.json")))
+    return "legacy";
+  return null;
+}
+async function policyMutationAvailability(rootDir, json) {
+  const kind = await initializedKind(rootDir);
+  if (kind === null) {
+    return printError(
+      json,
+      "MANCODE_NOT_INITIALIZED",
+      "Run `mancode init` first.",
+      EXIT_NOT_INITIALIZED
+    );
+  }
+  if (kind === "legacy") {
+    return printError(
+      json,
+      "MANCODE_DESIGN_POLICY_REQUIRES_CONTINUITY",
+      "Legacy projects can read the safe preserve context but cannot configure a shared design policy.",
+      EXIT_DESIGN_FAILED
+    );
+  }
+  return null;
+}
+function safeStringRecord(value, limit) {
+  if (!isRecord6(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      (entry) => /^[A-Za-z0-9_-]{1,80}$/.test(entry[0]) && typeof entry[1] === "string" && entry[1].length <= 120 && /^[#\w\s,.%()/+-]+$/.test(entry[1])
+    ).slice(0, limit)
+  );
+}
+function safeFontRecord(value, limit) {
+  if (!isRecord6(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      ([key, item]) => /^[A-Za-z0-9_-]{1,80}$/.test(key) && Array.isArray(item)
+    ).map(([key, item]) => [
+      key,
+      item.filter(
+        (font) => typeof font === "string" && font.length <= 80 && /^[\w\s,'"-]+$/.test(font)
+      ).slice(0, 6)
+    ]).filter(([, fonts]) => fonts.length > 0).slice(0, limit)
+  );
+}
+function safeStringList(value, limit, predicate) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (item) => typeof item === "string" && predicate(item)
+  ).slice(0, limit);
+}
+function safeScopeRoot(value) {
+  if (value === void 0 || value === ".") return ".";
+  return typeof value === "string" && isSafeRelativeFile(value) ? value : ".";
+}
+function safeTimestamp(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value)) ? value : null;
+}
+function safeMatchLevel(value) {
+  return value === "high" || value === "low" ? value : "none";
+}
+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 && !path45.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
+}
+function parseNonNegativeInteger2(value) {
+  if (value === void 0 || !/^\d+$/.test(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function relativePath(rootDir, target) {
+  return path45.relative(path45.resolve(rootDir), target).split(path45.sep).join("/");
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function exists(target) {
+  try {
+    await stat4(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function printResult(json, payload, lines) {
+  if (json) console.log(JSON.stringify(payload));
+  else for (const line of lines) console.log(line);
+  return EXIT_OK;
+}
+function printError(json, code, message, exitCode) {
+  if (json) console.log(JSON.stringify({ error: { code, message } }));
+  else console.error(`${code}: ${message}`);
+  return exitCode;
+}
+function errorCode3(error, fallback) {
+  if (!(error instanceof Error)) return fallback;
+  const match = error.message.match(/\bMANCODE_[A-Z0-9_]+\b/);
+  return match?.[0] ?? fallback;
+}
+
 // src/commands/init.ts
 import { promises as fs4 } from "fs";
 import os from "os";
-import path49 from "path";
-import process5 from "process";
+import path51 from "path";
+import process6 from "process";
 
 // src/installers/platform-status.ts
 import { promises as fs } from "fs";
-import path44 from "path";
+import path46 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
@@ -25322,13 +26007,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path44.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path46.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path44.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path44.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+        path46.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path46.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -25344,7 +26029,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path44.join(rootDir, ".cursor", "rules", file)
+        (file) => path46.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -25359,13 +26044,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path44.join(rootDir, ".cursor", "rules", file)
+          (file) => path46.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path44.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path46.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -25378,7 +26063,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path44.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path46.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -25395,9 +26080,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path44.join(rootDir, ".agents", "skills");
+    const skillsDir = path46.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path44.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path46.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -25409,7 +26094,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path44.join(rootDir, "AGENTS.md"),
+      path46.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -25429,9 +26114,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path44.join(rootDir, ".agents", "skills");
+    const skillsDir = path46.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path44.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path46.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -25442,7 +26127,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   const hasBlock = await fileHasManagedBlock(
-    path44.join(rootDir, ".github", "copilot-instructions.md")
+    path46.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -25453,9 +26138,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path44.join(rootDir, ".github", "prompts");
+    const promptsDir = path46.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path44.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path46.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -25488,13 +26173,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path44.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path46.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path44.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path46.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -25522,13 +26207,13 @@ async function fileHasAnyMarker(filePath, needles) {
 async function isPlatformMinimal(rootDir, platform) {
   try {
     const raw = await fs.readFile(
-      path44.join(rootDir, ".mancode", "config.json"),
+      path46.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
-    if (!isRecord6(config.platformOptions)) return false;
+    if (!isRecord7(config.platformOptions)) return false;
     const options = config.platformOptions[platform];
-    return isRecord6(options) && options.minimal === true;
+    return isRecord7(options) && options.minimal === true;
   } catch {
     return false;
   }
@@ -25544,7 +26229,7 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 async function claudeHooksRegistered(rootDir) {
   try {
     const raw = await fs.readFile(
-      path44.join(rootDir, ".claude", "settings.json"),
+      path46.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -25554,9 +26239,9 @@ async function claudeHooksRegistered(rootDir) {
   }
 }
 function hooksRegistered(settings) {
-  if (!isRecord6(settings)) return false;
+  if (!isRecord7(settings)) return false;
   const hooks = settings.hooks;
-  if (!isRecord6(hooks)) return false;
+  if (!isRecord7(hooks)) return false;
   return hasHookCommand(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand(
     hooks.UserPromptSubmit,
     ".mancode/hooks/user-prompt-submit.mjs"
@@ -25565,9 +26250,9 @@ function hooksRegistered(settings) {
 function hasHookCommand(value, needle) {
   if (!Array.isArray(value)) return false;
   return value.some((group) => {
-    if (!isRecord6(group) || !Array.isArray(group.hooks)) return false;
+    if (!isRecord7(group) || !Array.isArray(group.hooks)) return false;
     return group.hooks.some((hook) => {
-      if (!isRecord6(hook) || typeof hook.command !== "string") return false;
+      if (!isRecord7(hook) || typeof hook.command !== "string") return false;
       return hook.command.includes(needle);
     });
   });
@@ -25580,15 +26265,15 @@ async function pathExists4(p) {
     return false;
   }
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 
 // src/system/detect-team.ts
 import { execFile as execFile6 } from "child_process";
 import { access as access2 } from "fs/promises";
-import path45 from "path";
-import process2 from "process";
+import path47 from "path";
+import process3 from "process";
 import { promisify as promisify6 } from "util";
 var execFileAsync = promisify6(execFile6);
 var NO_TEAM = {
@@ -25598,7 +26283,7 @@ var NO_TEAM = {
   hasRemote: false
 };
 var GIT_ENV = {
-  ...process2.env,
+  ...process3.env,
   GIT_PAGER: "cat",
   PAGER: "cat",
   GIT_TERMINAL_PROMPT: "0"
@@ -25697,7 +26382,7 @@ async function anyPathExists(projectRoot, candidates) {
   const results = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access2(path45.join(projectRoot, candidate));
+        await access2(path47.join(projectRoot, candidate));
         return true;
       } catch {
         return false;
@@ -25720,10 +26405,10 @@ function emptySignals(isGitRepository) {
 
 // src/system/detect.ts
 import { execFile as execFile7 } from "child_process";
-import process3 from "process";
+import process4 from "process";
 import { promisify as promisify7 } from "util";
 var execFileAsync2 = promisify7(execFile7);
-async function detectSystemDeps(env = process3.env) {
+async function detectSystemDeps(env = process4.env) {
   try {
     await execFileAsync2("git", ["--version"], {
       env,
@@ -25738,18 +26423,18 @@ async function detectSystemDeps(env = process3.env) {
 // src/system/init-onboarding.ts
 import { execFileSync } from "child_process";
 import { promises as fs2 } from "fs";
-import path46 from "path";
-import process4 from "process";
+import path48 from "path";
+import process5 from "process";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
 var ALL_PLATFORMS = Object.keys(PLATFORM_INSTALLERS);
 var cachedNativeSystemLocale;
-function detectInitLocale(override, environment = process4.env, systemLocale = Intl.DateTimeFormat().resolvedOptions().locale, nativeLocale) {
+function detectInitLocale(override, environment = process5.env, systemLocale = Intl.DateTimeFormat().resolvedOptions().locale, nativeLocale) {
   if (override) return parseLocale(override);
   const resolvedNativeLocale = nativeLocale === void 0 ? getNativeSystemLocale() : nativeLocale;
   return parseLocale(resolvedNativeLocale) ?? detectEnvironmentLocale(environment) ?? parseLocale(systemLocale) ?? "en";
 }
-function detectNativeSystemLocale(platform = process4.platform, runCommand = runLocaleCommand) {
+function detectNativeSystemLocale(platform = process5.platform, runCommand = runLocaleCommand) {
   if (platform === "darwin") {
     const languages = runCommand("defaults", ["read", "-g", "AppleLanguages"]);
     const primaryLanguage = parsePrimaryAppleLanguage(languages);
@@ -25833,7 +26518,7 @@ function parsePlatformSelection(value) {
   }
   return [...new Set(choices)];
 }
-async function detectPlatformHints(rootDir, environment = process4.env) {
+async function detectPlatformHints(rootDir, environment = process5.env) {
   const hints = /* @__PURE__ */ new Set();
   if (environment.CLAUDECODE || environment.CLAUDE_CODE)
     hints.add("claude-code");
@@ -25841,17 +26526,17 @@ async function detectPlatformHints(rootDir, environment = process4.env) {
   if (environment.CURSOR_TRACE_ID) hints.add("cursor");
   if (environment.COPILOT_AGENT || environment.GITHUB_COPILOT)
     hints.add("copilot");
-  const exists = async (relative) => {
+  const exists2 = async (relative) => {
     try {
-      await fs2.access(path46.join(rootDir, relative));
+      await fs2.access(path48.join(rootDir, relative));
       return true;
     } catch {
       return false;
     }
   };
-  if (await exists(".claude")) hints.add("claude-code");
-  if (await exists(".cursor")) hints.add("cursor");
-  if (await exists(".github/copilot-instructions.md")) hints.add("copilot");
+  if (await exists2(".claude")) hints.add("claude-code");
+  if (await exists2(".cursor")) hints.add("cursor");
+  if (await exists2(".github/copilot-instructions.md")) hints.add("copilot");
   return ALL_PLATFORMS.filter((platform) => hints.has(platform));
 }
 function createTerminalPrompter() {
@@ -25919,10 +26604,10 @@ function createTerminalPrompter() {
 
 // src/system/scan-aesthetics.ts
 import { promises as fs3 } from "fs";
-import path47 from "path";
+import path49 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
-async function scanAesthetics(projectRoot, uiLibrary = null) {
+async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
   const sourceFiles = [];
   const configResult = await findTailwindConfig(projectRoot);
   let colors = {};
@@ -25955,12 +26640,13 @@ async function scanAesthetics(projectRoot, uiLibrary = null) {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists5(path47.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists5(path49.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
   return {
     version: "1.0.0",
+    scopeRoot,
     lastScanned: (/* @__PURE__ */ new Date()).toISOString(),
     colors,
     fonts,
@@ -25980,7 +26666,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path47.join(projectRoot, name);
+    const absPath = path49.join(projectRoot, name);
     if (await pathExists5(absPath)) {
       return { absPath, relPath: name };
     }
@@ -26207,7 +26893,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path47.join(projectRoot, relRoot);
+    const absRoot = path49.join(projectRoot, relRoot);
     if (!await pathExists5(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -26227,7 +26913,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path47.join(dir, entry);
+    const abs = path49.join(dir, entry);
     let info;
     try {
       info = await fs3.lstat(abs);
@@ -26248,7 +26934,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path47.basename(dir);
+      base = path49.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -26270,7 +26956,7 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path47.join(projectRoot, relPath);
+    const absPath = path49.join(projectRoot, relPath);
     if (!await pathExists5(absPath)) continue;
     const content = await fs3.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
@@ -26316,7 +27002,7 @@ function toPascalCase(value) {
 async function hasTailwindDep(projectRoot) {
   try {
     const raw = await fs3.readFile(
-      path47.join(projectRoot, "package.json"),
+      path49.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -26341,15 +27027,15 @@ async function pathExists5(p) {
 
 // src/context/greenfield-init.ts
 import {
-  lstat as lstat19,
-  mkdir as mkdir33,
-  readFile as readFile36,
+  lstat as lstat20,
+  mkdir as mkdir34,
+  readFile as readFile38,
   rename as rename10,
-  rm as rm17,
-  writeFile as writeFile38
+  rm as rm18,
+  writeFile as writeFile39
 } from "fs/promises";
-import path48 from "path";
-var JOURNAL_RELATIVE_DIRECTORY = path48.join(
+import path50 from "path";
+var JOURNAL_RELATIVE_DIRECTORY = path50.join(
   "local",
   "runtime",
   "initialization"
@@ -26372,7 +27058,7 @@ async function stageGreenfieldInitialization(input) {
     normalized.operationId
   );
   try {
-    await mkdir33(stagingRoot);
+    await mkdir34(stagingRoot);
   } catch (error) {
     if (isAlreadyExists22(error)) {
       throw new Error("MANCODE_GREENFIELD_STAGING_EXISTS");
@@ -26398,7 +27084,7 @@ async function stageGreenfieldInitialization(input) {
     operationId: normalized.operationId,
     workspaceId: normalized.workspaceId,
     state: "staged",
-    stagingDirectoryName: path48.basename(stagingRoot),
+    stagingDirectoryName: path50.basename(stagingRoot),
     targetDirectoryName: ".mancode",
     manifestDigest: digestCanonicalJson(manifest),
     configDigest: digestCanonicalJson(config),
@@ -26429,7 +27115,7 @@ async function stageGreenfieldInitialization(input) {
   return journal;
 }
 async function publishGreenfieldInitialization(input) {
-  const root = path48.resolve(input.projectRoot);
+  const root = path50.resolve(input.projectRoot);
   assertUlid(input.operationId, "greenfield operationId");
   const stagingRoot = greenfieldStagingPath(root, input.operationId);
   const targetRoot = greenfieldTargetPath(root);
@@ -26464,10 +27150,10 @@ async function initializeGreenfield(input, publication) {
 }
 function greenfieldStagingPath(projectRoot, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path48.join(path48.resolve(projectRoot), `.mancode.init-${operationId}`);
+  return path50.join(path50.resolve(projectRoot), `.mancode.init-${operationId}`);
 }
 function greenfieldTargetPath(projectRoot) {
-  return path48.join(path48.resolve(projectRoot), ".mancode");
+  return path50.join(path50.resolve(projectRoot), ".mancode");
 }
 function parseGreenfieldInitializationJournal(value) {
   assertRecord(value, "greenfield initialization journal");
@@ -26603,7 +27289,7 @@ async function finishPublishedInitialization(input, stagedJournal) {
     activatedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
   };
   assertSchemaManifestTransition(manifest, activeManifest);
-  await writeJson(path48.join(targetRoot, "schema.json"), activeManifest);
+  await writeJson(path50.join(targetRoot, "schema.json"), activeManifest);
   throwIfOperationCrashInjected(
     "greenfield_initialize",
     "activate-v3-manifest"
@@ -26619,46 +27305,46 @@ async function finishPublishedInitialization(input, stagedJournal) {
 }
 async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, projectFacts, journal) {
   await Promise.all([
-    mkdir33(path48.join(stagingRoot, "shared", "context"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, "shared", "memory", "decisions"), {
+    mkdir34(path50.join(stagingRoot, "shared", "context"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, "shared", "memory", "decisions"), {
       recursive: true
     }),
-    mkdir33(path48.join(stagingRoot, "shared", "team", "actors"), {
+    mkdir34(path50.join(stagingRoot, "shared", "team", "actors"), {
       recursive: true
     }),
-    mkdir33(path48.join(stagingRoot, "shared", "team", "handoffs"), {
+    mkdir34(path50.join(stagingRoot, "shared", "team", "handoffs"), {
       recursive: true
     }),
-    mkdir33(path48.join(stagingRoot, "shared", "team", "events"), {
+    mkdir34(path50.join(stagingRoot, "shared", "team", "events"), {
       recursive: true
     }),
-    mkdir33(path48.join(stagingRoot, "shared", "team", "transport"), {
+    mkdir34(path50.join(stagingRoot, "shared", "team", "transport"), {
       recursive: true
     }),
-    mkdir33(path48.join(stagingRoot, "local", "sessions"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
+    mkdir34(path50.join(stagingRoot, "local", "sessions"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
       recursive: true
     }),
-    mkdir33(path48.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, "local", "overlays"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, "local", "quarantine"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, "local", "publish"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, "local", "cache"), { recursive: true }),
-    mkdir33(path48.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
+    mkdir34(path50.join(stagingRoot, "local", "workflows"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, "local", "overlays"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, "local", "quarantine"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, "local", "publish"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, "local", "cache"), { recursive: true }),
+    mkdir34(path50.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
       recursive: true
     })
   ]);
   await Promise.all([
-    writeJson(path48.join(stagingRoot, "schema.json"), manifest),
-    writeJson(path48.join(stagingRoot, "shared", "config.json"), config),
-    writeJson(path48.join(stagingRoot, "shared", "team", "policy.json"), policy),
+    writeJson(path50.join(stagingRoot, "schema.json"), manifest),
+    writeJson(path50.join(stagingRoot, "shared", "config.json"), config),
+    writeJson(path50.join(stagingRoot, "shared", "team", "policy.json"), policy),
     writeJson(
-      path48.join(stagingRoot, "shared", "context", "project.json"),
+      path50.join(stagingRoot, "shared", "context", "project.json"),
       projectFacts
     ),
     writeJson(journalPath2(stagingRoot, journal.operationId), journal),
-    writeFile38(
-      path48.join(stagingRoot, ".gitignore"),
+    writeFile39(
+      path50.join(stagingRoot, ".gitignore"),
       `${V3_IGNORE.join("\n")}
 `,
       { encoding: "utf8", flag: "wx" }
@@ -26667,14 +27353,14 @@ async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, proj
 }
 async function readGreenfieldJournal(root, operationId) {
   try {
-    const raw = await readFile36(journalPath2(root, operationId), "utf8");
+    const raw = await readFile38(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 || isNotFound27(error)) {
+    if (error instanceof SyntaxError || isNotFound28(error)) {
       throw new Error("MANCODE_GREENFIELD_JOURNAL_CORRUPT");
     }
     throw error;
@@ -26683,10 +27369,10 @@ async function readGreenfieldJournal(root, operationId) {
 async function readManifest(root) {
   try {
     return parseSchemaManifest(
-      JSON.parse(await readFile36(path48.join(root, "schema.json"), "utf8"))
+      JSON.parse(await readFile38(path50.join(root, "schema.json"), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound27(error)) {
+    if (error instanceof SyntaxError || isNotFound28(error)) {
       throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
     }
     throw error;
@@ -26721,7 +27407,7 @@ async function readConfig(root) {
   try {
     config = parseProjectConfig(
       JSON.parse(
-        await readFile36(path48.join(root, "shared", "config.json"), "utf8")
+        await readFile38(path50.join(root, "shared", "config.json"), "utf8")
       )
     );
   } catch (error) {
@@ -26737,8 +27423,8 @@ async function readPolicy(root) {
   try {
     policy = parseTeamPolicy(
       JSON.parse(
-        await readFile36(
-          path48.join(root, "shared", "team", "policy.json"),
+        await readFile38(
+          path50.join(root, "shared", "team", "policy.json"),
           "utf8"
         )
       )
@@ -26755,14 +27441,14 @@ async function readProjectFactsAt(root) {
   try {
     return parseProjectFacts(
       JSON.parse(
-        await readFile36(
-          path48.join(root, "shared", "context", "project.json"),
+        await readFile38(
+          path50.join(root, "shared", "context", "project.json"),
           "utf8"
         )
       )
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound27(error)) {
+    if (error instanceof SyntaxError || isNotFound28(error)) {
       throw new Error("MANCODE_GREENFIELD_REPAIR_REQUIRED");
     }
     throw error;
@@ -26795,7 +27481,7 @@ function normalizeInput(input) {
   parseSchemaManifest(manifest);
   return {
     ...input,
-    projectRoot: path48.resolve(input.projectRoot),
+    projectRoot: path50.resolve(input.projectRoot),
     projectConfig: config,
     teamPolicy: policy,
     projectFacts: input.projectFacts === void 0 ? void 0 : parseProjectFacts(input.projectFacts)
@@ -26893,16 +27579,16 @@ function initializationProjectFacts(input, now) {
 }
 function journalPath2(root, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path48.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
+  return path50.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
 }
 async function writeJson(target, value) {
-  const directory = path48.dirname(target);
-  await mkdir33(directory, { recursive: true });
-  const temporary = path48.join(
+  const directory = path50.dirname(target);
+  await mkdir34(directory, { recursive: true });
+  const temporary = path50.join(
     directory,
-    `.${path48.basename(target)}.${process.pid}.${Date.now()}.tmp`
+    `.${path50.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile38(temporary, `${JSON.stringify(value, null, 2)}
+  await writeFile39(temporary, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -26926,13 +27612,13 @@ function isState(value) {
 }
 async function lstatOrNull4(target) {
   try {
-    return await lstat19(target);
+    return await lstat20(target);
   } catch (error) {
-    if (isNotFound27(error)) return null;
+    if (isNotFound28(error)) return null;
     throw error;
   }
 }
-function isNotFound27(error) {
+function isNotFound28(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExists22(error) {
@@ -27003,7 +27689,7 @@ async function initializeV3Project(input) {
 }
 
 // src/commands/init.ts
-var EXIT_OK = 0;
+var EXIT_OK2 = 0;
 var EXIT_ALREADY_INITIALIZED = 1;
 var EXIT_NOT_A_PROJECT_DIR = 2;
 var EXIT_USER_CANCEL = 3;
@@ -27014,15 +27700,15 @@ function resolveInitAuthority(options) {
   if (options.v3 || options.fromCli) return "v3";
   return "legacy";
 }
-async function init(rootDir = process5.cwd(), options = {}) {
+async function init(rootDir = process6.cwd(), options = {}) {
   if (options.v3 && options.legacy) {
     console.error("\u2717  --v3 and --legacy cannot be used together.");
     return EXIT_INIT_FAILED;
   }
   const authority = resolveInitAuthority(options);
-  const mancodeDir = path49.join(rootDir, ".mancode");
-  const stateFile = path49.join(mancodeDir, "state.json");
-  const v3SchemaFile = path49.join(mancodeDir, "schema.json");
+  const mancodeDir = path51.join(rootDir, ".mancode");
+  const stateFile = path51.join(mancodeDir, "state.json");
+  const v3SchemaFile = path51.join(mancodeDir, "schema.json");
   const wasInitialized = await pathExists6(stateFile);
   let mutationSnapshots = [];
   let directorySnapshots = [];
@@ -27090,7 +27776,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
     }
     return initializeV3(rootDir, options);
   }
-  const isGitRepo = await pathExists6(path49.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path51.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   let isGenericProject = false;
   if (!isGitRepo && !hasManifest) {
@@ -27208,8 +27894,8 @@ async function init(rootDir = process5.cwd(), options = {}) {
     const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
     mutationSnapshots = await snapshotFiles(managedFiles);
     directorySnapshots = await snapshotDirectories(managedFiles, [
-      path49.join(mancodeDir, "workflows"),
-      path49.join(mancodeDir, "preseason-reports")
+      path51.join(mancodeDir, "workflows"),
+      path51.join(mancodeDir, "preseason-reports")
     ]);
     const team = await detectTeamStatus(rootDir);
     const platformMinimal = Object.fromEntries(
@@ -27270,7 +27956,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
 `;
     await fs4.writeFile(stateFile, stateContent, "utf-8");
     await fs4.writeFile(
-      path49.join(mancodeDir, "project-profile.json"),
+      path51.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -27307,7 +27993,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
         )
       );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path49.join(
+      const tokensPath = path51.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
@@ -27442,7 +28128,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
         )
       );
     }
-    return EXIT_OK;
+    return EXIT_OK2;
   } catch (err) {
     await restoreFiles(mutationSnapshots);
     await removeNewEmptyDirectories(directorySnapshots);
@@ -27471,7 +28157,7 @@ async function initializeV3(rootDir, options) {
     );
     return EXIT_INIT_FAILED;
   }
-  const schemaPath = path49.join(rootDir, ".mancode", "schema.json");
+  const schemaPath = path51.join(rootDir, ".mancode", "schema.json");
   let existingV3 = false;
   let registeredAdapters = /* @__PURE__ */ new Set();
   if (await pathExists6(schemaPath)) {
@@ -27560,7 +28246,7 @@ async function initializeV3(rootDir, options) {
     } else {
       console.log(`   mancode bootstrap: ${selectedPlatforms.join(", ")}`);
     }
-    return EXIT_OK;
+    return EXIT_OK2;
   } catch (error) {
     printV3InitError(error);
     return EXIT_INIT_FAILED;
@@ -27574,7 +28260,7 @@ function printV3InitError(error) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path49.join(mancodeDir, "config.json");
+  const configPath = path51.join(mancodeDir, "config.json");
   let config = {};
   try {
     config = JSON.parse(await fs4.readFile(configPath, "utf-8"));
@@ -27583,7 +28269,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
   const existingPlatforms = Array.isArray(config.platforms) ? config.platforms.filter(
     (platform) => typeof platform === "string"
   ) : [];
-  const existingPlatformOptions = isRecord7(config.platformOptions) ? config.platformOptions : {};
+  const existingPlatformOptions = isRecord8(config.platformOptions) ? config.platformOptions : {};
   const definedPatch = Object.fromEntries(
     Object.entries(patch).filter(([, value]) => value !== void 0)
   );
@@ -27607,7 +28293,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir) {
   try {
     const config = JSON.parse(
-      await fs4.readFile(path49.join(mancodeDir, "config.json"), "utf-8")
+      await fs4.readFile(path51.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {
       platforms: Array.isArray(config.platforms) ? config.platforms.filter(
@@ -27621,10 +28307,10 @@ async function readExistingInitPreferences(mancodeDir) {
     if (config.teamMode === "auto" || config.teamMode === "on" || config.teamMode === "off") {
       preferences.teamMode = config.teamMode;
     }
-    if (isRecord7(config.platformOptions)) {
+    if (isRecord8(config.platformOptions)) {
       for (const platform of preferences.platforms) {
         const platformOptions = config.platformOptions[platform];
-        if (isRecord7(platformOptions) && platformOptions.minimal === true) {
+        if (isRecord8(platformOptions) && platformOptions.minimal === true) {
           preferences.minimalByPlatform[platform] = true;
         }
       }
@@ -27673,13 +28359,13 @@ async function selectInitPlatforms(input) {
 }
 async function hasProjectManifest(rootDir) {
   for (const name of PROJECT_MANIFESTS) {
-    if (await pathExists6(path49.join(rootDir, name))) return true;
+    if (await pathExists6(path51.join(rootDir, name))) return true;
   }
   return false;
 }
 async function canInitializeGenericProject(rootDir) {
-  const resolved = path49.resolve(rootDir);
-  if (resolved === path49.parse(resolved).root || resolved === path49.resolve(os.homedir())) {
+  const resolved = path51.resolve(rootDir);
+  if (resolved === path51.parse(resolved).root || resolved === path51.resolve(os.homedir())) {
     return { ok: false, reason: "unsafe" };
   }
   try {
@@ -27693,11 +28379,11 @@ async function canInitializeGenericProject(rootDir) {
   }
 }
 async function validateV3CliProjectBoundary(rootDir, options, locale, legacyInitialized) {
-  const isGitRepo = await pathExists6(path49.join(rootDir, ".git"));
+  const isGitRepo = await pathExists6(path51.join(rootDir, ".git"));
   const hasManifest = await hasProjectManifest(rootDir);
   if (isGitRepo || hasManifest) return null;
   const v3Initialized = await pathExists6(
-    path49.join(rootDir, ".mancode", "schema.json")
+    path51.join(rootDir, ".mancode", "schema.json")
   );
   const legacyAuthorityPresent = legacyInitialized || (await scanLegacyAuthority(rootDir)).authorityPresent;
   const genericSafety = await canInitializeGenericProject(rootDir);
@@ -27826,7 +28512,7 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.github/prompts/${mode}.prompt.md`);
     }
   }
-  return [...new Set(files.map((file) => path49.join(rootDir, file)))];
+  return [...new Set(files.map((file) => path51.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
@@ -27845,10 +28531,10 @@ async function snapshotFiles(filePaths) {
 async function snapshotDirectories(filePaths, additionalDirectories = []) {
   const directories = new Set(additionalDirectories);
   for (const filePath of filePaths) {
-    let current = path49.dirname(filePath);
-    while (current !== path49.dirname(current)) {
+    let current = path51.dirname(filePath);
+    while (current !== path51.dirname(current)) {
       directories.add(current);
-      current = path49.dirname(current);
+      current = path51.dirname(current);
     }
   }
   return Promise.all(
@@ -27864,7 +28550,7 @@ async function restoreFiles(snapshots) {
       await fs4.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs4.mkdir(path49.dirname(snapshot.filePath), { recursive: true });
+    await fs4.mkdir(path51.dirname(snapshot.filePath), { recursive: true });
     await fs4.writeFile(snapshot.filePath, snapshot.content, "utf-8");
   }
 }
@@ -27877,7 +28563,7 @@ async function removeNewEmptyDirectories(snapshots) {
     }
   }
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNodeError6(error) {
@@ -27931,15 +28617,15 @@ async function pathExists6(p) {
 
 // src/commands/install.ts
 import { promises as fs5 } from "fs";
-import path50 from "path";
-import process6 from "process";
-var EXIT_OK2 = 0;
-var EXIT_NOT_INITIALIZED = 1;
+import path52 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 = process6.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path50.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path50.join(rootDir, ".mancode", "schema.json");
+async function install(rootDir = process7.cwd(), platform = "claude-code", options = {}) {
+  const stateFile = path52.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path52.join(rootDir, ".mancode", "schema.json");
   if (await pathExists7(v3SchemaFile)) {
     return installV3(rootDir, platform, options);
   }
@@ -27953,7 +28639,7 @@ async function install(rootDir = process6.cwd(), platform = "claude-code", optio
   if (!await pathExists7(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
-    return EXIT_NOT_INITIALIZED;
+    return EXIT_NOT_INITIALIZED2;
   }
   const installer = getPlatformInstaller(platform);
   if (!installer) {
@@ -27986,7 +28672,7 @@ async function install(rootDir = process6.cwd(), platform = "claude-code", optio
           `\u2139\uFE0F  ${formatPlatformName(platform)} adapter already installed.`
         );
         console.log("   Run with --force to reinstall.");
-        return EXIT_OK2;
+        return EXIT_OK3;
       }
       console.log(
         `\u2139\uFE0F  ${formatPlatformName(platform)} adapter already installed; switching to minimal install.`
@@ -28028,7 +28714,7 @@ async function install(rootDir = process6.cwd(), platform = "claude-code", optio
     })
   });
   console.log(`\u2713  ${formatPlatformName(platform)} adapter installed.`);
-  return EXIT_OK2;
+  return EXIT_OK3;
 }
 async function installV3(rootDir, platform, options) {
   const installer = getPlatformInstaller(platform);
@@ -28050,7 +28736,7 @@ async function installV3(rootDir, platform, options) {
       for (const entry of staged.modeEntries) {
         console.log(`   ${entry.stagingTarget}`);
       }
-      return EXIT_OK2;
+      return EXIT_OK3;
     }
     if (project.manifest.activationState !== "v3_active") {
       throw new Error("MANCODE_V3_ADAPTER_INSTALL_REQUIRES_ACTIVE");
@@ -28083,7 +28769,7 @@ async function installV3(rootDir, platform, options) {
     );
     for (const target of installed.filePlans)
       console.log(`   ${target.target}`);
-    return EXIT_OK2;
+    return EXIT_OK3;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(
@@ -28100,7 +28786,7 @@ function printUnsupportedPlatform(platform) {
   }
 }
 async function readConfig2(rootDir) {
-  const configPath = path50.join(rootDir, ".mancode", "config.json");
+  const configPath = path52.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
@@ -28115,7 +28801,7 @@ function isNodeError7(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path50.join(rootDir, ".mancode", "config.json");
+  const configPath = path52.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
   await fs5.writeFile(configPath, content, "utf-8");
@@ -28130,28 +28816,28 @@ function withDefaultConfig(config, fallbackPlatform) {
   return {
     ...merged,
     platforms,
-    hooks: isRecord8(config.hooks) ? config.hooks : DEFAULT_CONFIG.hooks,
-    logging: isRecord8(config.logging) ? config.logging : DEFAULT_CONFIG.logging
+    hooks: isRecord9(config.hooks) ? config.hooks : DEFAULT_CONFIG.hooks,
+    logging: isRecord9(config.logging) ? config.logging : DEFAULT_CONFIG.logging
   };
 }
 function updatePlatformOptions(value, platform, options) {
-  const platformOptions = isRecord8(value) ? { ...value } : {};
+  const platformOptions = isRecord9(value) ? { ...value } : {};
   const existing = platformOptions[platform];
   platformOptions[platform] = {
-    ...isRecord8(existing) ? existing : {},
+    ...isRecord9(existing) ? existing : {},
     minimal: options.minimal === true
   };
   return platformOptions;
 }
 function readConfiguredMinimal(value, platform) {
-  if (!isRecord8(value)) return false;
+  if (!isRecord9(value)) return false;
   const platformOptions = value[platform];
-  return isRecord8(platformOptions) && platformOptions.minimal === true;
+  return isRecord9(platformOptions) && platformOptions.minimal === true;
 }
 async function readStatePlatform(rootDir) {
   try {
     const raw = await fs5.readFile(
-      path50.join(rootDir, ".mancode", "state.json"),
+      path52.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -28168,17 +28854,17 @@ async function pathExists7(p) {
     return false;
   }
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/commands/list-platforms.ts
 import { promises as fs6 } from "fs";
-import path51 from "path";
-import process7 from "process";
-var EXIT_OK3 = 0;
-async function listPlatforms(rootDir = process7.cwd()) {
-  if (await pathExists8(path51.join(rootDir, ".mancode", "schema.json"))) {
+import path53 from "path";
+import process8 from "process";
+var EXIT_OK4 = 0;
+async function listPlatforms(rootDir = process8.cwd()) {
+  if (await pathExists8(path53.join(rootDir, ".mancode", "schema.json"))) {
     return listV3Platforms(rootDir);
   }
   const installed = new Set(await readInstalledPlatforms(rootDir));
@@ -28189,7 +28875,7 @@ async function listPlatforms(rootDir = process7.cwd()) {
     console.log(formatPlatformLine(platform, installed.has(platform.name)));
   }
   console.log("");
-  return EXIT_OK3;
+  return EXIT_OK4;
 }
 async function listV3Platforms(rootDir) {
   const platforms = getPlatformInstallers();
@@ -28209,12 +28895,12 @@ async function listV3Platforms(rootDir) {
     );
   }
   console.log("");
-  return EXIT_OK3;
+  return EXIT_OK4;
 }
 async function readInstalledPlatforms(rootDir) {
   try {
     const raw = await fs6.readFile(
-      path51.join(rootDir, ".mancode", "config.json"),
+      path53.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -28246,8 +28932,8 @@ function describePlatform(platform) {
 }
 
 // src/commands/manps.ts
-import { access as access4, readFile as readFile38 } from "fs/promises";
-import path53 from "path";
+import { access as access4, readFile as readFile40 } from "fs/promises";
+import path55 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
@@ -28256,14 +28942,14 @@ import { createHash as createHash8 } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   access as access3,
-  lstat as lstat20,
-  mkdir as mkdir34,
-  readFile as readFile37,
+  lstat as lstat21,
+  mkdir as mkdir35,
+  readFile as readFile39,
   readdir as readdir18,
   rename as rename11,
-  writeFile as writeFile39
+  writeFile as writeFile40
 } from "fs/promises";
-import path52 from "path";
+import path54 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -28328,7 +29014,7 @@ var SCANNERS = [
   {
     name: "aesthetic-drift",
     areas: ["all"],
-    scan: ({ projectRoot, files }) => scanAestheticDrift(projectRoot, files)
+    scan: ({ projectRoot, files, pkg }) => scanAestheticDrift(projectRoot, files, pkg)
   },
   {
     name: "architecture",
@@ -28343,10 +29029,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 ?? path52.join(projectRoot, ".mancode");
-  const reportDir = path52.join(storageRoot, "preseason-reports");
-  await mkdir34(reportDir, { recursive: true });
-  const issueDbPath = path52.join(storageRoot, "preseason-issues.json");
+  const storageRoot = options.storageRoot ?? path54.join(projectRoot, ".mancode");
+  const reportDir = path54.join(storageRoot, "preseason-reports");
+  await mkdir35(reportDir, { recursive: true });
+  const issueDbPath = path54.join(storageRoot, "preseason-issues.json");
   const reportPath = await allocateReportPath(
     reportDir,
     `${generatedAt.replace(/[:.]/g, "-")}-${normalizedArea}`
@@ -28360,9 +29046,9 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
     issueDbPath
   };
   const database = await buildIssueDatabase(projectRoot, report);
-  await writeFile39(reportPath, renderPreseasonReport(report), "utf-8");
-  await writeFile39(
-    path52.join(storageRoot, "preseason-report.md"),
+  await writeFile40(reportPath, renderPreseasonReport(report), "utf-8");
+  await writeFile40(
+    path54.join(storageRoot, "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -28370,7 +29056,7 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = options.issueDbPath ?? path52.join(projectRoot, ".mancode", "preseason-issues.json");
+  const issueDbPath = options.issueDbPath ?? path54.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(
@@ -28448,7 +29134,7 @@ async function runPreseasonRemediation(projectRoot, issues, options = {}) {
     write2("   Decision: skipped.");
   }
   database.updatedAt = now;
-  await writeFile39(
+  await writeFile40(
     issueDbPath,
     `${JSON.stringify(database, null, 2)}
 `,
@@ -28480,7 +29166,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 = path52.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path54.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -28529,18 +29215,18 @@ async function walk(root, current, results, depth) {
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path52.join(current, entry);
-    const rel = path52.relative(root, abs);
+    const abs = path54.join(current, entry);
+    const rel = path54.relative(root, abs);
     let info;
     try {
-      info = await lstat20(abs);
+      info = await lstat21(abs);
     } catch {
       continue;
     }
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path52.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path54.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -28548,7 +29234,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile37(path52.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile39(path54.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -28641,7 +29327,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path52.join(projectRoot, file);
+    const abs = path54.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -28682,7 +29368,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 = path52.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path54.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -28691,13 +29377,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path52.basename(file)}.`,
+    detail: `No matching test file was found for ${path54.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(path52.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path54.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -28708,7 +29394,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path52.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path54.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -28721,13 +29407,13 @@ function scanConfig(projectRoot, files) {
   }
   return issues;
 }
-function scanAestheticDrift(projectRoot, files) {
+function scanAestheticDrift(projectRoot, files, pkg) {
   const issues = [];
   const frontendFiles = files.filter((file) => /\.(tsx|jsx|css)$/.test(file));
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path52.join(projectRoot, file));
+      content = readFileSyncSafe(path54.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -28744,10 +29430,41 @@ function scanAestheticDrift(projectRoot, files) {
       break;
     }
   }
+  const iconSystems = detectedIconSystems(pkg);
+  if (iconSystems.length > 1) {
+    issues.push({
+      id: "aesthetics-mixed-icon-systems",
+      severity: "P2",
+      type: "aesthetics",
+      title: "Multiple icon systems declared",
+      file: "package.json",
+      detail: `Multiple icon systems are declared: ${iconSystems.join(", ")}.`,
+      recommendation: "Use the configured design policy for new interface work; remove a redundant package only after confirming it has no active imports."
+    });
+  }
   return issues;
 }
+function detectedIconSystems(pkg) {
+  if (!pkg) return [];
+  const packages = Object.keys({
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  });
+  const systems = [
+    ["Lucide", /^lucide(?:-|$)/],
+    ["Heroicons", /^@heroicons\//],
+    [
+      "Material Icons",
+      /^(?:@mui\/icons-material|@material-design-icons\/|material-icons(?:-|$)|material-symbols(?:-|$))/
+    ],
+    ["Phosphor", /^(?:@phosphor-icons\/|phosphor-(?:react|icons)(?:-|$))/],
+    ["Font Awesome", /^@fortawesome\/(?:free|pro|sharp)-.+-svg-icons$/],
+    ["React Icons", /^react-icons$/]
+  ];
+  return systems.filter(([, pattern]) => packages.some((name) => pattern.test(name))).map(([name]) => name);
+}
 async function scanArchitecture(projectRoot) {
-  const localBinary = path52.join(
+  const localBinary = path54.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -28795,7 +29512,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists9(path52.join(projectRoot, file)))
+    files.map((file) => pathExists9(path54.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -28863,15 +29580,15 @@ function parseDepcruiseJson(output) {
   }
 }
 function extractDepcruiseViolations(value) {
-  if (!isRecord9(value)) return [];
-  const rawViolations = Array.isArray(value.violations) ? value.violations : isRecord9(value.summary) && Array.isArray(value.summary.violations) ? value.summary.violations : [];
+  if (!isRecord10(value)) return [];
+  const rawViolations = Array.isArray(value.violations) ? value.violations : isRecord10(value.summary) && Array.isArray(value.summary.violations) ? value.summary.violations : [];
   return rawViolations.map((violation) => normalizeDepcruiseViolation(violation)).filter(
     (violation) => violation !== null
   );
 }
 function normalizeDepcruiseViolation(value) {
-  if (!isRecord9(value)) return null;
-  const rule = isRecord9(value.rule) ? value.rule : {};
+  if (!isRecord10(value)) return null;
+  const rule = isRecord10(value.rule) ? value.rule : {};
   const from = typeof value.from === "string" ? value.from : "";
   const to = typeof value.to === "string" ? value.to : void 0;
   const ruleName = typeof rule.name === "string" ? rule.name : typeof value.name === "string" ? value.name : "unnamed-rule";
@@ -28901,9 +29618,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path52.relative(projectRoot, report.reportPath);
+  const reportRef = path54.relative(projectRoot, report.reportPath);
   const run = {
-    id: path52.basename(report.reportPath, ".md"),
+    id: path54.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -28945,7 +29662,7 @@ async function buildIssueDatabase(projectRoot, report) {
 async function readIssueDatabase(issueDbPath) {
   let raw;
   try {
-    raw = await readFile37(issueDbPath, "utf-8");
+    raw = await readFile39(issueDbPath, "utf-8");
   } catch (err) {
     if (isNodeError8(err) && err.code === "ENOENT") {
       return emptyIssueDatabase();
@@ -28966,7 +29683,7 @@ async function readIssueDatabase(issueDbPath) {
 }
 async function writeJsonAtomic3(file, value) {
   const tmp = `${file}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await writeFile39(tmp, `${JSON.stringify(value, null, 2)}
+  await writeFile40(tmp, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
   await rename11(tmp, file);
 }
@@ -29009,20 +29726,20 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path52.join(projectRoot, ".gitignore");
+    const gitignorePath = path54.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
-    await writeFile39(gitignorePath, `${DEFAULT_GITIGNORE}
+    await writeFile40(gitignorePath, `${DEFAULT_GITIGNORE}
 `, "utf-8");
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path52.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path54.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
-    await writeFile39(editorconfigPath, `${DEFAULT_EDITORCONFIG}
+    await writeFile40(editorconfigPath, `${DEFAULT_EDITORCONFIG}
 `, "utf-8");
     return { applied: true, action: "created .editorconfig" };
   }
@@ -29058,10 +29775,10 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path52.join(projectRoot, "package.json");
+  const packagePath = path54.join(projectRoot, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile37(packagePath, "utf-8"));
+    pkg = JSON.parse(await readFile39(packagePath, "utf-8"));
   } catch {
     return false;
   }
@@ -29071,7 +29788,7 @@ async function addPackageScript(projectRoot, scriptName, script) {
     ...scripts,
     [scriptName]: script
   };
-  await writeFile39(packagePath, `${JSON.stringify(pkg, null, 2)}
+  await writeFile40(packagePath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
   return true;
 }
@@ -29161,17 +29878,17 @@ async function pathExists9(file) {
 function isNodeError8(err) {
   return err instanceof Error && "code" in err;
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null;
 }
 
 // src/commands/manps.ts
-var EXIT_OK4 = 0;
-var EXIT_NOT_INITIALIZED2 = 1;
+var EXIT_OK5 = 0;
+var EXIT_NOT_INITIALIZED3 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  const v3SchemaPath = path53.join(rootDir, ".mancode", "schema.json");
+  const v3SchemaPath = path55.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}`;
@@ -29184,7 +29901,7 @@ async function manps(rootDir, area = "all", options = {}) {
     return EXIT_SCAN_FAILED;
   }
   const v3Initialized = v3Activation === "v3_active";
-  const initialized = v3Initialized || await pathExists10(path53.join(rootDir, ".mancode", "state.json"));
+  const initialized = v3Initialized || await pathExists10(path55.join(rootDir, ".mancode", "state.json"));
   if (!initialized) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
@@ -29192,12 +29909,12 @@ async function manps(rootDir, area = "all", options = {}) {
       console.error("\u2717  mancode not initialized.");
       console.error("   Run `mancode init` first.");
     }
-    return EXIT_NOT_INITIALIZED2;
+    return EXIT_NOT_INITIALIZED3;
   }
   let report;
   try {
     report = await runPreseasonScan(rootDir, area, {
-      storageRoot: v3Initialized ? path53.join(rootDir, ".mancode", "local") : void 0
+      storageRoot: v3Initialized ? path55.join(rootDir, ".mancode", "local") : void 0
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -29255,7 +29972,7 @@ async function manps(rootDir, area = "all", options = {}) {
   }
   if (options.json) {
     console.log(JSON.stringify({ ...report, remediation }, null, 2));
-    return EXIT_OK4;
+    return EXIT_OK5;
   }
   const p0 = report.issues.filter((issue) => issue.severity === "P0").length;
   const p1 = report.issues.filter((issue) => issue.severity === "P1").length;
@@ -29266,8 +29983,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path53.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path53.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path55.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path55.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -29283,10 +30000,10 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path53.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path55.relative(rootDir, remediation.issueDbPath)}`
     );
   }
-  return EXIT_OK4;
+  return EXIT_OK5;
 }
 async function runRemediation(rootDir, report, options, silent = false) {
   const write2 = silent ? () => {
@@ -29344,7 +30061,7 @@ async function readV3ActivationState(schemaPath) {
   if (!await pathExists10(schemaPath)) return null;
   try {
     const manifest = parseSchemaManifest(
-      JSON.parse(await readFile38(schemaPath, "utf8"))
+      JSON.parse(await readFile40(schemaPath, "utf8"))
     );
     return manifest.activationState;
   } catch {
@@ -29353,9 +30070,9 @@ async function readV3ActivationState(schemaPath) {
 }
 
 // src/commands/migrate.ts
-import { readFile as readFile39 } from "fs/promises";
-import path54 from "path";
-var EXIT_OK5 = 0;
+import { readFile as readFile41 } from "fs/promises";
+import path56 from "path";
+var EXIT_OK6 = 0;
 var EXIT_INVALID_ARG2 = 2;
 var EXIT_MIGRATION_BLOCKED = 3;
 async function migrateContext(rootDir, options) {
@@ -29367,7 +30084,7 @@ async function migrateContext(rootDir, options) {
     options.rollback !== void 0
   ].filter(Boolean).length;
   if (selected !== 1) {
-    return printError(
+    return printError2(
       options.json,
       "MANCODE_MIGRATION_ARGUMENT_INVALID",
       "Choose exactly one migration operation.",
@@ -29376,16 +30093,16 @@ async function migrateContext(rootDir, options) {
   }
   try {
     if (options.dryRun) {
-      return printResult(options.json, await dryRunLegacyMigration(rootDir));
+      return printResult2(options.json, await dryRunLegacyMigration(rootDir));
     }
     if (options.stage) {
-      return printResult(
+      return printResult2(
         options.json,
         await stageLegacyMigration({ projectRoot: rootDir })
       );
     }
     if (options.status) {
-      return printResult(options.json, {
+      return printResult2(options.json, {
         schemaVersion: 1,
         stages: await listMigrationStages(rootDir)
       });
@@ -29396,7 +30113,7 @@ async function migrateContext(rootDir, options) {
     assertUlid(options.session, "migration activation session");
     if (options.rollback !== void 0) {
       assertUlid(options.rollback, "migration rollback operation");
-      return printResult(
+      return printResult2(
         options.json,
         await rollbackLegacyMigration({
           projectRoot: rootDir,
@@ -29407,7 +30124,7 @@ async function migrateContext(rootDir, options) {
       );
     }
     const stageId = await selectStageId(rootDir, options.stageId);
-    return printResult(
+    return printResult2(
       options.json,
       await activateLegacyMigration({
         projectRoot: rootDir,
@@ -29419,9 +30136,9 @@ async function migrateContext(rootDir, options) {
       })
     );
   } catch (error) {
-    return printError(
+    return printError2(
       options.json,
-      errorCode3(error),
+      errorCode4(error),
       error instanceof Error ? error.message : "Migration failed.",
       EXIT_MIGRATION_BLOCKED
     );
@@ -29441,11 +30158,11 @@ async function migrateContextResolve(rootDir, legacyTaskId, options) {
       ownerActorId: owner,
       implementationScope
     });
-    return printResult(options.json, result2);
+    return printResult2(options.json, result2);
   } catch (error) {
-    return printError(
+    return printError2(
       options.json,
-      errorCode3(error),
+      errorCode4(error),
       error instanceof Error ? error.message : "Migration resolution failed.",
       EXIT_MIGRATION_BLOCKED
     );
@@ -29480,14 +30197,14 @@ async function readScopeFile(rootDir, file) {
   if (!file.trim() || file.includes("\0")) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
-  const resolved = path54.resolve(rootDir, file);
-  const relative = path54.relative(path54.resolve(rootDir), resolved);
-  if (relative === ".." || relative.startsWith(`..${path54.sep}`) || path54.isAbsolute(relative)) {
+  const resolved = path56.resolve(rootDir, file);
+  const relative = path56.relative(path56.resolve(rootDir), resolved);
+  if (relative === ".." || relative.startsWith(`..${path56.sep}`) || path56.isAbsolute(relative)) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
   try {
     return JSON.parse(
-      await readFile39(resolved, "utf8")
+      await readFile41(resolved, "utf8")
     );
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -29496,15 +30213,15 @@ async function readScopeFile(rootDir, file) {
     throw error;
   }
 }
-function printResult(json, result2) {
+function printResult2(json, result2) {
   if (json) {
     console.log(JSON.stringify(result2, null, 2));
   } else {
     console.log(JSON.stringify(result2, null, 2));
   }
-  return EXIT_OK5;
+  return EXIT_OK6;
 }
-function printError(json, code, message, exitCode) {
+function printError2(json, code, message, exitCode) {
   const result2 = { schemaVersion: 1, error: { code, message } };
   if (json) {
     console.log(JSON.stringify(result2, null, 2));
@@ -29514,7 +30231,7 @@ function printError(json, code, message, exitCode) {
   }
   return exitCode;
 }
-function errorCode3(error) {
+function errorCode4(error) {
   if (error instanceof Error && error.message.startsWith("MANCODE_")) {
     return error.message.split(":", 1)[0] ?? "MANCODE_MIGRATION_FAILED";
   }
@@ -29587,12 +30304,12 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
 }
 
 // src/context/project-policy-upgrade.ts
-import { lstat as lstat21, mkdir as mkdir35, readFile as readFile40, rm as rm18, writeFile as writeFile40 } from "fs/promises";
-import path55 from "path";
+import { lstat as lstat22, mkdir as mkdir36, readFile as readFile42, rm as rm19, writeFile as writeFile41 } from "fs/promises";
+import path57 from "path";
 var UPGRADE_OPERATION = "project_policy_upgrade";
 async function dryRunProjectPolicyUpgrade(input) {
   assertPolicyVersion(input.policyVersion);
-  const root = path55.resolve(input.projectRoot);
+  const root = path57.resolve(input.projectRoot);
   const project = await new V3ContextStore(root).readProjectSnapshot();
   const beforeDigest = digestManifest(project.manifest);
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -29636,7 +30353,7 @@ async function dryRunProjectPolicyUpgrade(input) {
 async function upgradeProjectPolicy(input) {
   assertPolicyVersion(input.policyVersion);
   assertUlid(input.sessionId, "project policy upgrade sessionId");
-  const root = path55.resolve(input.projectRoot);
+  const root = path57.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const operationId = input.operationId;
   if (operationId === void 0) {
@@ -29846,7 +30563,7 @@ async function collectUpgradeBlockers(root, project) {
   try {
     await assertUpgradePreflight(root, project);
   } catch (error) {
-    blockers.push(errorCode4(error));
+    blockers.push(errorCode5(error));
   }
   return [...new Set(blockers)];
 }
@@ -29890,24 +30607,24 @@ function buildV2Manifest(manifest, operationId) {
   return candidate;
 }
 async function readSchemaContent(root) {
-  return readFile40(path55.join(root, ".mancode", "schema.json"), "utf8");
+  return readFile42(path57.join(root, ".mancode", "schema.json"), "utf8");
 }
 async function writeSchemaContent(root, operationId, content) {
-  const directory = path55.join(root, ".mancode");
-  const target = path55.join(directory, "schema.json");
-  const stat4 = await lstat21(target);
-  if (!stat4.isFile() || stat4.isSymbolicLink()) {
+  const directory = path57.join(root, ".mancode");
+  const target = path57.join(directory, "schema.json");
+  const stat5 = await lstat22(target);
+  if (!stat5.isFile() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const temporary = path55.join(
+  const temporary = path57.join(
     directory,
     `.schema.json.${operationId}.${process.pid}.tmp`
   );
-  await writeFile40(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile41(temporary, content, { encoding: "utf8", flag: "wx" });
   try {
     await replaceFileAtomically(temporary, target);
   } catch (error) {
-    await rm18(temporary, { force: true });
+    await rm19(temporary, { force: true });
     throw error;
   }
 }
@@ -29968,22 +30685,22 @@ function assertPolicyVersion(value) {
     );
   }
 }
-function errorCode4(error) {
+function errorCode5(error) {
   return error instanceof Error && error.message.startsWith("MANCODE_") ? error.message.split(":", 1)[0] ?? "MANCODE_PROJECT_UPGRADE_BLOCKED" : "MANCODE_PROJECT_UPGRADE_BLOCKED";
 }
 async function releaseLocks3(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
 function projectUpgradePreviewRoot(root, operationId) {
-  return path55.join(root, ".mancode", "staging", "project-upgrade", operationId);
+  return path57.join(root, ".mancode", "staging", "project-upgrade", operationId);
 }
 async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
   const directory = projectUpgradePreviewRoot(root, receipt.operationId);
-  const receiptPath = path55.join(directory, "preview.json");
-  const manifestPath = path55.join(directory, "schema.json");
-  await mkdir35(path55.dirname(directory), { recursive: true });
+  const receiptPath = path57.join(directory, "preview.json");
+  const manifestPath = path57.join(directory, "schema.json");
+  await mkdir36(path57.dirname(directory), { recursive: true });
   try {
-    await mkdir35(directory);
+    await mkdir36(directory);
   } catch (error) {
     if (isAlreadyExists23(error)) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_EXISTS");
@@ -29991,25 +30708,25 @@ async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
     throw error;
   }
   try {
-    await writeFile40(receiptPath, `${JSON.stringify(receipt, null, 2)}
+    await writeFile41(receiptPath, `${JSON.stringify(receipt, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
-    await writeFile40(manifestPath, manifestContent, {
+    await writeFile41(manifestPath, manifestContent, {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
-    await rm18(directory, { recursive: true, force: true });
+    await rm19(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(path55.join(directory, "preview.json")),
-    readSafePreviewFile(path55.join(directory, "schema.json"))
+    readSafePreviewFile(path57.join(directory, "preview.json")),
+    readSafePreviewFile(path57.join(directory, "schema.json"))
   ]);
   let receipt;
   try {
@@ -30032,13 +30749,13 @@ async function assertProjectPolicyUpgradePreview(root, operationId, project) {
 }
 async function readSafePreviewFile(target) {
   try {
-    const stat4 = await lstat21(target);
-    if (!stat4.isFile() || stat4.isSymbolicLink()) {
+    const stat5 = await lstat22(target);
+    if (!stat5.isFile() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_INVALID");
     }
-    return readFile40(target, "utf8");
+    return readFile42(target, "utf8");
   } catch (error) {
-    if (isNotFound28(error)) {
+    if (isNotFound29(error)) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_REQUIRED");
     }
     throw error;
@@ -30071,7 +30788,7 @@ function parseProjectPolicyUpgradePreviewReceipt(value) {
     createdAt: record.createdAt
   };
 }
-function isNotFound28(error) {
+function isNotFound29(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExists23(error) {
@@ -30125,22 +30842,22 @@ async function projectUpgrade(rootDir, options) {
 // src/commands/refresh-project.ts
 import { randomUUID } from "crypto";
 import { promises as fs7 } from "fs";
-import path56 from "path";
-import process8 from "process";
-var EXIT_OK6 = 0;
-var EXIT_NOT_INITIALIZED3 = 1;
+import path58 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 = process8.cwd()) {
-  const mancodeDir = path56.join(rootDir, ".mancode");
-  const statePath = path56.join(mancodeDir, "state.json");
-  if (await pathExists11(path56.join(mancodeDir, "schema.json"))) {
+async function refreshProject(rootDir = process9.cwd()) {
+  const mancodeDir = path58.join(rootDir, ".mancode");
+  const statePath = path58.join(mancodeDir, "state.json");
+  if (await pathExists11(path58.join(mancodeDir, "schema.json"))) {
     return refreshV3Project(rootDir);
   }
   if (!await pathExists11(statePath)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
-    return EXIT_NOT_INITIALIZED3;
+    return EXIT_NOT_INITIALIZED4;
   }
   const state = await readRequiredState(statePath);
   if (!state) {
@@ -30153,12 +30870,12 @@ async function refreshProject(rootDir = process8.cwd()) {
     const [profile, team, hasGit, hasManifest] = await Promise.all([
       detectProjectProfile(rootDir),
       detectTeamStatus(rootDir),
-      pathExists11(path56.join(rootDir, ".git")),
+      pathExists11(path58.join(rootDir, ".git")),
       hasProjectManifest2(rootDir)
     ]);
     const uiLibrary = primaryUiLibrary(profile);
     const stack = [...profile.languages, ...profile.frameworks];
-    const config = await readJson2(path56.join(mancodeDir, "config.json"));
+    const config = await readJson2(path58.join(mancodeDir, "config.json"));
     const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
     const nextState = {
       ...state,
@@ -30170,7 +30887,7 @@ async function refreshProject(rootDir = process8.cwd()) {
     };
     await writeProjectFacts2(
       statePath,
-      path56.join(mancodeDir, "project-profile.json"),
+      path58.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(nextState, null, 2)}
 `,
       `${JSON.stringify(profile, null, 2)}
@@ -30198,7 +30915,7 @@ async function refreshProject(rootDir = process8.cwd()) {
     console.log(
       "   Run `mancode refresh-style` if UI files or dependencies changed."
     );
-    return EXIT_OK6;
+    return EXIT_OK7;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`\u2717  Project refresh failed: ${message}`);
@@ -30228,7 +30945,7 @@ async function refreshV3Project(rootDir) {
     console.log(
       "   mancode adapters remain unchanged because their bootstrap is static."
     );
-    return EXIT_OK6;
+    return EXIT_OK7;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`\u2717  mancode project facts refresh failed: ${message}`);
@@ -30237,7 +30954,7 @@ async function refreshV3Project(rootDir) {
 }
 async function hasProjectManifest2(rootDir) {
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists11(path56.join(rootDir, manifest))) return true;
+    if (await pathExists11(path58.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -30303,9 +31020,9 @@ async function readOptionalText(filePath) {
   }
 }
 function temporaryPath(filePath) {
-  return path56.join(
-    path56.dirname(filePath),
-    `.${path56.basename(filePath)}.${process8.pid}.${randomUUID()}.tmp`
+  return path58.join(
+    path58.dirname(filePath),
+    `.${path58.basename(filePath)}.${process9.pid}.${randomUUID()}.tmp`
   );
 }
 async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
@@ -30334,14 +31051,14 @@ function configuredPlatforms(config, fallbackPlatform) {
   );
 }
 function platformIsMinimal(config, platform) {
-  if (!isRecord10(config.platformOptions)) return false;
+  if (!isRecord11(config.platformOptions)) return false;
   const options = config.platformOptions[platform];
-  return isRecord10(options) && options.minimal === true;
+  return isRecord11(options) && options.minimal === true;
 }
 async function readJson2(filePath) {
   try {
     const value = JSON.parse(await fs7.readFile(filePath, "utf-8"));
-    return isRecord10(value) ? value : {};
+    return isRecord11(value) ? value : {};
   } catch {
     return {};
   }
@@ -30351,14 +31068,14 @@ async function readRequiredState(filePath) {
   try {
     const raw = await fs7.readFile(filePath, "utf-8");
     const parsed = JSON.parse(raw);
-    if (!isRecord10(parsed)) return null;
+    if (!isRecord11(parsed)) return null;
     state = parsed;
   } catch {
     return null;
   }
   return typeof state.version === "string" && typeof state.currentMode === "string" && typeof state.platform === "string" ? state : null;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNodeError9(error) {
@@ -30375,52 +31092,62 @@ async function pathExists11(filePath) {
 
 // src/commands/refresh-style.ts
 import { promises as fs8 } from "fs";
-import path57 from "path";
-import process9 from "process";
-var EXIT_OK7 = 0;
-var EXIT_NOT_INITIALIZED4 = 1;
+import path59 from "path";
+import process10 from "process";
+var EXIT_OK8 = 0;
+var EXIT_NOT_INITIALIZED5 = 1;
 var EXIT_V3_REFRESH_FAILED = 2;
-async function refreshStyle(rootDir = process9.cwd()) {
-  const stateFile = path57.join(rootDir, ".mancode", "state.json");
-  if (await pathExists12(path57.join(rootDir, ".mancode", "schema.json"))) {
-    return refreshV3Style(rootDir);
+async function refreshStyle(rootDir = process10.cwd(), options = {}) {
+  const scanTarget = await resolveScanTarget(rootDir, options.root);
+  if (scanTarget === null) {
+    console.error("\u2717  style scan root must stay inside the project root.");
+    return EXIT_V3_REFRESH_FAILED;
+  }
+  const stateFile = path59.join(rootDir, ".mancode", "state.json");
+  if (await pathExists12(path59.join(rootDir, ".mancode", "schema.json"))) {
+    return refreshV3Style(rootDir, scanTarget.root, scanTarget.scopeRoot);
   }
   if (!await pathExists12(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
-    return EXIT_NOT_INITIALIZED4;
+    return EXIT_NOT_INITIALIZED5;
   }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path57.join(rootDir, ".mancode", "project-profile.json");
+  const profilePath = path59.join(rootDir, ".mancode", "project-profile.json");
   await fs8.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
 `,
     "utf-8"
   );
-  const uiLibraryHint = primaryUiLibrary(profile);
+  const scanProfile = scanTarget.scopeRoot === "." ? profile : await detectProjectProfile(scanTarget.root);
+  const uiLibraryHint = primaryUiLibrary(scanProfile);
   await refreshLegacyStateContext(rootDir, profile, uiLibraryHint);
   console.log(
     `   \u7C7B\u578B: ${profile.projectKind} | UI: ${profile.uiAssets} | \u6D4F\u89C8\u5668: ${profile.browserAutomation}`
   );
-  if (profile.uiAssets !== "detected") {
+  if (scanProfile.uiAssets !== "detected") {
     console.log(
       "\u2139\uFE0F  No UI assets detected in project profile. Skipping style scan."
     );
     console.log("   Updated .mancode/project-profile.json.");
     await printStaticPlatformRefreshHint(rootDir);
-    return EXIT_OK7;
+    return EXIT_OK8;
   }
   console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
-  const tokens = await scanAesthetics(rootDir, uiLibraryHint);
-  const tokensPath = path57.join(
+  const tokens = await scanAesthetics(
+    scanTarget.root,
+    uiLibraryHint,
+    scanTarget.scopeRoot
+  );
+  const tokensPath = path59.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs8.mkdir(path57.dirname(tokensPath), { recursive: true });
+  await fs8.mkdir(path59.dirname(tokensPath), { recursive: true });
   await fs8.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
@@ -30433,7 +31160,7 @@ async function refreshStyle(rootDir = process9.cwd()) {
     "\u5DF2\u66F4\u65B0 .mancode/project-profile.json \u548C .mancode/aesthetics/style-tokens.json"
   );
   await printStaticPlatformRefreshHint(rootDir);
-  return EXIT_OK7;
+  return EXIT_OK8;
 }
 function printAestheticsSummary(tokens) {
   console.log("");
@@ -30474,7 +31201,7 @@ function printAestheticsSummary(tokens) {
     console.log(`  \u5339\u914D\u5EA6:   ${tokens.matchLevel}`);
   }
 }
-async function refreshV3Style(rootDir) {
+async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
   try {
     const project = await new V3ContextStore(rootDir).readProjectSnapshot();
     if (project.manifest.activationState !== "v3_active") {
@@ -30482,7 +31209,8 @@ async function refreshV3Style(rootDir) {
     }
     console.log("\u2713  \u5237\u65B0 mancode \u9879\u76EE profile...");
     const profile = await detectProjectProfile(rootDir);
-    const uiLibraryHint = primaryUiLibrary(profile);
+    const scanProfile = scopeRoot === "." ? profile : await detectProjectProfile(scanRoot);
+    const uiLibraryHint = primaryUiLibrary(scanProfile);
     await writeProjectFacts(
       rootDir,
       createProjectFacts(profile, {
@@ -30492,24 +31220,24 @@ async function refreshV3Style(rootDir) {
     console.log(
       `   \u7C7B\u578B: ${profile.projectKind} | UI: ${profile.uiAssets} | \u6D4F\u89C8\u5668: ${profile.browserAutomation}`
     );
-    const tokensPath = path57.join(
+    const tokensPath = path59.join(
       rootDir,
       ".mancode",
       "local",
       "cache",
       "style-tokens.json"
     );
-    if (profile.uiAssets !== "detected") {
+    if (scanProfile.uiAssets !== "detected") {
       await fs8.rm(tokensPath, { force: true });
       console.log(
         "\u2139\uFE0F  No UI assets detected in project profile. Skipping style scan."
       );
       console.log("   Updated mancode project facts.");
-      return EXIT_OK7;
+      return EXIT_OK8;
     }
     console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
-    const tokens = await scanAesthetics(rootDir, uiLibraryHint);
-    await fs8.mkdir(path57.dirname(tokensPath), { recursive: true });
+    const tokens = await scanAesthetics(scanRoot, uiLibraryHint, scopeRoot);
+    await fs8.mkdir(path59.dirname(tokensPath), { recursive: true });
     await fs8.writeFile(
       tokensPath,
       `${JSON.stringify(tokens, null, 2)}
@@ -30521,7 +31249,7 @@ async function refreshV3Style(rootDir) {
     console.log(
       "\u5DF2\u66F4\u65B0 .mancode/shared/context/project.json \u548C .mancode/local/cache/style-tokens.json"
     );
-    return EXIT_OK7;
+    return EXIT_OK8;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`\u2717  mancode style refresh failed: ${message}`);
@@ -30543,7 +31271,7 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path57.join(rootDir, ".mancode", "state.json");
+  const statePath = path59.join(rootDir, ".mancode", "state.json");
   try {
     const state = JSON.parse(await fs8.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
@@ -30567,7 +31295,7 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 async function readInstalledPlatforms2(rootDir) {
   try {
     const raw = await fs8.readFile(
-      path57.join(rootDir, ".mancode", "config.json"),
+      path59.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -30586,12 +31314,32 @@ async function pathExists12(p) {
     return false;
   }
 }
+async function resolveScanTarget(rootDir, requestedRoot) {
+  const projectRoot = await fs8.realpath(path59.resolve(rootDir)).catch(() => null);
+  if (projectRoot === null) return null;
+  if (requestedRoot === void 0 || requestedRoot === ".") {
+    return { root: projectRoot, scopeRoot: "." };
+  }
+  if (path59.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
+    return null;
+  }
+  const candidate = await fs8.realpath(path59.resolve(projectRoot, requestedRoot)).catch(() => null);
+  if (candidate === null) return null;
+  const relative = path59.relative(projectRoot, candidate);
+  if (relative.startsWith(`..${path59.sep}`) || relative === ".." || path59.isAbsolute(relative)) {
+    return null;
+  }
+  return {
+    root: candidate,
+    scopeRoot: relative.split(path59.sep).join("/") || "."
+  };
+}
 
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs9 } from "fs";
-import path58 from "path";
-import process10 from "process";
+import path60 from "path";
+import process11 from "process";
 
 // src/team/assessment.ts
 function assessTeam(input) {
@@ -30742,19 +31490,19 @@ function assertTimestamp3(value) {
 
 // src/commands/status.ts
 var HOOK_ESTIMATE_TIMEOUT_MS = 2e3;
-var EXIT_OK8 = 0;
-var EXIT_NOT_INITIALIZED5 = 1;
+var EXIT_OK9 = 0;
+var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_CORRUPT_STATE2 = 2;
-async function status(rootDir = process10.cwd(), options = {}) {
-  const stateFile = path58.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path58.join(rootDir, ".mancode", "schema.json");
+async function status(rootDir = process11.cwd(), options = {}) {
+  const stateFile = path60.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path60.join(rootDir, ".mancode", "schema.json");
   if (await pathExists13(v3SchemaFile)) {
     return statusV3(rootDir, options);
   }
   if (!await pathExists13(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` to get started.");
-    return EXIT_NOT_INITIALIZED5;
+    return EXIT_NOT_INITIALIZED6;
   }
   let state;
   try {
@@ -30811,7 +31559,7 @@ async function status(rootDir = process10.cwd(), options = {}) {
   } else {
     printText(result2);
   }
-  return EXIT_OK8;
+  return EXIT_OK9;
 }
 async function statusV3(rootDir, options) {
   try {
@@ -30952,7 +31700,7 @@ async function statusV3(rootDir, options) {
     } else {
       printV3Text(result2);
     }
-    return EXIT_OK8;
+    return EXIT_OK9;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error("\u2717  .mancode/schema.json is corrupt or incomplete.");
@@ -30981,7 +31729,7 @@ function toContinuityStatus(result2) {
   };
 }
 async function readV3StatusSession(rootDir) {
-  const sessionId = process10.env.MANCODE_SESSION_ID;
+  const sessionId = process11.env.MANCODE_SESSION_ID;
   if (sessionId === void 0 || !sessionId) return null;
   try {
     assertUlid(sessionId, "status sessionId");
@@ -30992,10 +31740,10 @@ async function readV3StatusSession(rootDir) {
 }
 async function shouldRefreshProject(rootDir, state) {
   if (state.projectMode !== "generic") return false;
-  const hasGit = await pathExists13(path58.join(rootDir, ".git"));
+  const hasGit = await pathExists13(path60.join(rootDir, ".git"));
   if (hasGit) return true;
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists13(path58.join(rootDir, manifest))) return true;
+    if (await pathExists13(path60.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -31039,19 +31787,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs9.readFile(path58.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path60.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path58.basename(rootDir);
+  return path60.basename(rootDir);
 }
 async function readConfig3(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path58.join(rootDir, ".mancode", "config.json"),
+      path60.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -31079,9 +31827,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists13(path58.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists13(path60.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
     pathExists13(
-      path58.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      path60.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -31090,7 +31838,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path58.join(rootDir, ".claude", "settings.json"),
+      path60.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -31100,9 +31848,9 @@ async function isRegistered(rootDir) {
   }
 }
 function hooksRegistered2(settings) {
-  if (!isRecord11(settings)) return false;
+  if (!isRecord12(settings)) return false;
   const hooks = settings.hooks;
-  if (!isRecord11(hooks)) return false;
+  if (!isRecord12(hooks)) return false;
   return hasHookCommand2(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand2(
     hooks.UserPromptSubmit,
     ".mancode/hooks/user-prompt-submit.mjs"
@@ -31111,15 +31859,15 @@ function hooksRegistered2(settings) {
 function hasHookCommand2(value, needle) {
   if (!Array.isArray(value)) return false;
   return value.some((group) => {
-    if (!isRecord11(group) || !Array.isArray(group.hooks)) return false;
+    if (!isRecord12(group) || !Array.isArray(group.hooks)) return false;
     return group.hooks.some((hook) => {
-      if (!isRecord11(hook) || typeof hook.command !== "string") return false;
+      if (!isRecord12(hook) || typeof hook.command !== "string") return false;
       return hook.command.includes(needle);
     });
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path58.join(
+  const hookPath = path60.join(
     rootDir,
     ".mancode",
     "hooks",
@@ -31140,7 +31888,7 @@ async function estimateHookInjection(rootDir) {
 }
 function runHookEstimate(rootDir, hookPath) {
   return new Promise((resolve, reject) => {
-    const child = spawn(process10.execPath, [hookPath], {
+    const child = spawn(process11.execPath, [hookPath], {
       cwd: rootDir,
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -31338,7 +32086,7 @@ function formatTeamStatus(team) {
 function workflowStepMax(mode) {
   return maxWorkflowStep(mode);
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 async function pathExists13(p) {
@@ -32616,8 +33364,8 @@ function assertPositiveRevision2(value, label) {
 }
 
 // src/team/git-ref-handoff-repair.ts
-import { lstat as lstat22, mkdir as mkdir36, readFile as readFile41, readdir as readdir19, writeFile as writeFile41 } from "fs/promises";
-import path59 from "path";
+import { lstat as lstat23, mkdir as mkdir37, readFile as readFile43, readdir as readdir19, writeFile as writeFile42 } from "fs/promises";
+import path61 from "path";
 
 // src/team/git-ref-operation.ts
 import { execFile as execFileCallback6 } from "child_process";
@@ -35195,7 +35943,7 @@ async function recoverGitRefHandoffRepairs(projectRoot) {
 }
 async function recoverGitRefHandoffRepair(projectRoot, operationId, transportReceipt) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  const root = path59.resolve(projectRoot);
+  const root = path61.resolve(projectRoot);
   let journal = await requireJournal2(root, operationId);
   if (journal.state === "committed" || journal.state === "aborted") {
     return recoveryResult2(journal);
@@ -35274,7 +36022,7 @@ async function recoverGitRefHandoffRepair(projectRoot, operationId, transportRec
   }
 }
 async function prepareHandoffRepairWhileTaskLocked(projectRoot, rawPrepared) {
-  const root = path59.resolve(projectRoot);
+  const root = path61.resolve(projectRoot);
   const prepared2 = parsePrepared2(rawPrepared);
   const runtime = await readProjectRuntimeContext(root);
   const previousMetadata = bundleMetadata2(prepared2.predecessorBundle);
@@ -35337,7 +36085,7 @@ async function restorePredecessorMetadata2(projectRoot, journal) {
   );
 }
 async function replaceMetadataVerified(projectRoot, expected, targetMetadata, alternateExpected) {
-  const target = path59.join(
+  const target = path61.join(
     taskRootPath(projectRoot, targetMetadata.taskRef),
     "metadata.json"
   );
@@ -35463,7 +36211,7 @@ async function createJournal3(projectRoot, journal) {
   await ensureJournalDirectory2(projectRoot);
   const target = journalPath3(projectRoot, journal.operationId);
   try {
-    await writeFile41(target, serialize13(journal), {
+    await writeFile42(target, serialize13(journal), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -35482,10 +36230,10 @@ async function replaceJournal3(projectRoot, journal) {
 async function requireJournal2(projectRoot, operationId) {
   try {
     return parseJournal3(
-      JSON.parse(await readFile41(journalPath3(projectRoot, operationId), "utf8"))
+      JSON.parse(await readFile43(journalPath3(projectRoot, operationId), "utf8"))
     );
   } catch (error) {
-    if (error instanceof SyntaxError || isNotFound29(error)) {
+    if (error instanceof SyntaxError || isNotFound30(error)) {
       throw new Error("MANCODE_HANDOFF_REPAIR_JOURNAL_NOT_FOUND");
     }
     throw error;
@@ -35496,7 +36244,7 @@ async function listJournals2(projectRoot) {
   try {
     entries = await readdir19(journalDirectory2(projectRoot));
   } catch (error) {
-    if (isNotFound29(error)) return [];
+    if (isNotFound30(error)) return [];
     throw error;
   }
   const journals = [];
@@ -35505,8 +36253,8 @@ async function listJournals2(projectRoot) {
     journals.push(
       parseJournal3(
         JSON.parse(
-          await readFile41(
-            path59.join(journalDirectory2(projectRoot), entry),
+          await readFile43(
+            path61.join(journalDirectory2(projectRoot), entry),
             "utf8"
           )
         )
@@ -35516,43 +36264,43 @@ async function listJournals2(projectRoot) {
   return journals;
 }
 async function readSafeFile2(target) {
-  const before = await lstat22(target);
+  const before = await lstat23(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const content = await readFile41(target, "utf8");
-  const after = await lstat22(target);
+  const content = await readFile43(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");
   }
   return content;
 }
 async function atomicWrite2(target, content) {
-  const temporary = path59.join(
-    path59.dirname(target),
-    `.${path59.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path61.join(
+    path61.dirname(target),
+    `.${path61.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile41(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile42(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory2(projectRoot) {
-  let current = path59.resolve(projectRoot);
+  let current = path61.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-handoff"]) {
-    current = path59.join(current, segment);
+    current = path61.join(current, segment);
     try {
-      await mkdir36(current);
+      await mkdir37(current);
     } catch (error) {
       if (!isAlreadyExists24(error)) throw error;
     }
-    const entry = await lstat22(current);
+    const entry = await lstat23(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
 function journalDirectory2(projectRoot) {
-  return path59.join(
-    path59.resolve(projectRoot),
+  return path61.join(
+    path61.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -35561,7 +36309,7 @@ function journalDirectory2(projectRoot) {
 }
 function journalPath3(projectRoot, operationId) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  return path59.join(journalDirectory2(projectRoot), `${operationId}.json`);
+  return path61.join(journalDirectory2(projectRoot), `${operationId}.json`);
 }
 function serialize13(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -35576,7 +36324,7 @@ function parseTimestamp15(value) {
 function isAlreadyExists24(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound29(error) {
+function isNotFound30(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -35660,8 +36408,8 @@ function parseReceipt(value) {
 }
 
 // src/team/policy-operation.ts
-import { lstat as lstat23, mkdir as mkdir37, readdir as readdir20, unlink as unlink3, writeFile as writeFile42 } from "fs/promises";
-import path60 from "path";
+import { lstat as lstat24, mkdir as mkdir38, readdir as readdir20, unlink as unlink3, writeFile as writeFile43 } from "fs/promises";
+import path62 from "path";
 async function updateTeamPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   const eventId = createUlid();
@@ -35672,7 +36420,7 @@ async function updateTeamPolicy(input) {
     throw new Error("MANCODE_TEAM_POLICY_INVALID");
   }
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path60.resolve(input.projectRoot);
+  const root = path62.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -35753,7 +36501,7 @@ async function applyTeamTransportSet(input, write2) {
   }
   const remote = transportRemote(input.mode, input.remote);
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path60.resolve(input.projectRoot);
+  const root = path62.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -35886,9 +36634,9 @@ async function assertTransportAuthorityEmpty(projectRoot, store) {
     listClaims(store),
     listHandoffs(store),
     directoryHasEntries(taskHeadDirectory(store)),
-    directoryHasEntries(path60.join(store.root, "transport-migrations")),
+    directoryHasEntries(path62.join(store.root, "transport-migrations")),
     directoryHasEntries(
-      path60.join(projectRoot, ".mancode", "shared", "team", "transport")
+      path62.join(projectRoot, ".mancode", "shared", "team", "transport")
     ),
     pathExists14(gitRefCachePath(projectRoot))
   ]);
@@ -35918,21 +36666,21 @@ function assertPositiveRevision5(value, label) {
   }
 }
 function teamPolicyPath(projectRoot) {
-  return path60.join(projectRoot, ".mancode", "shared", "team", "policy.json");
+  return path62.join(projectRoot, ".mancode", "shared", "team", "policy.json");
 }
 function projectConfigPath(projectRoot) {
-  return path60.join(projectRoot, ".mancode", "shared", "config.json");
+  return path62.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function writeJsonAtomic4(target, value) {
-  await mkdir37(path60.dirname(target), { recursive: true });
-  await assertPlainDirectory(path60.dirname(target));
+  await mkdir38(path62.dirname(target), { recursive: true });
+  await assertPlainDirectory(path62.dirname(target));
   await assertPlainFileOrMissing(target);
-  const temporary = path60.join(
-    path60.dirname(target),
-    `.${path60.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  const temporary = path62.join(
+    path62.dirname(target),
+    `.${path62.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile42(temporary, `${JSON.stringify(value, null, 2)}
+    await writeFile43(temporary, `${JSON.stringify(value, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -35944,61 +36692,61 @@ async function writeJsonAtomic4(target, value) {
   }
 }
 async function assertPlainDirectory(target) {
-  const entry = await lstat23(target);
+  const entry = await lstat24(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function assertPlainFileOrMissing(target) {
   try {
-    const entry = await lstat23(target);
+    const entry = await lstat24(target);
     if (!entry.isFile() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   } catch (error) {
-    if (isNotFound30(error)) return;
+    if (isNotFound31(error)) return;
     throw error;
   }
 }
 async function directoryHasEntries(target) {
   try {
-    const entry = await lstat23(target);
+    const entry = await lstat24(target);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     return (await readdir20(target)).length > 0;
   } catch (error) {
-    if (isNotFound30(error)) return false;
+    if (isNotFound31(error)) return false;
     throw error;
   }
 }
 async function pathExists14(target) {
   try {
-    await lstat23(target);
+    await lstat24(target);
     return true;
   } catch (error) {
-    if (isNotFound30(error)) return false;
+    if (isNotFound31(error)) return false;
     throw error;
   }
 }
 async function releaseLocks4(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
-function isNotFound30(error) {
+function isNotFound31(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/team/transport-migration-adapters.ts
 import {
-  lstat as lstat24,
-  mkdir as mkdir38,
-  readFile as readFile42,
+  lstat as lstat25,
+  mkdir as mkdir39,
+  readFile as readFile44,
   readdir as readdir21,
   rename as rename12,
   unlink as unlink4,
-  writeFile as writeFile43
+  writeFile as writeFile44
 } from "fs/promises";
-import path61 from "path";
+import path63 from "path";
 
 // src/team/transport-migration.ts
 var DIGEST_PATTERN7 = /^sha256:[a-f0-9]{64}$/;
@@ -36961,7 +37709,7 @@ function parseTaskSnapshot(value) {
     assertUlid(ownerActorId, "transport migration task ownerActorId");
   }
   const taskRevision = parsePositiveInteger5(value.taskRevision, "taskRevision");
-  const ownershipEpoch = parseNonNegativeInteger2(
+  const ownershipEpoch = parseNonNegativeInteger3(
     value.ownershipEpoch,
     "ownershipEpoch"
   );
@@ -37038,7 +37786,7 @@ function parsePositiveInteger5(value, label) {
   }
   return value;
 }
-function parseNonNegativeInteger2(value, label) {
+function parseNonNegativeInteger3(value, label) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
     throw new Error(`${label} must be a non-negative integer`);
   }
@@ -37070,7 +37818,7 @@ function compareUtf813(left, right) {
 var STAGE_DIRECTORY = "transport-migrations";
 var COLLECTIONS = ["claims", "handoffs", "task-heads"];
 async function createTransportMigrationFileAdapters(input) {
-  const projectRoot = path61.resolve(input.projectRoot);
+  const projectRoot = path63.resolve(input.projectRoot);
   assertUlid(input.actorId, "transport migration adapter actorId");
   if (input.operationId !== void 0) {
     assertUlid(input.operationId, "transport migration adapter operationId");
@@ -37122,7 +37870,7 @@ async function createTransportMigrationFileAdapters(input) {
 var FileSystemTransportMigrationConfigAdapter = class {
   constructor(projectRoot, coordinationStore) {
     this.coordinationStore = coordinationStore;
-    this.projectRoot = path61.resolve(projectRoot);
+    this.projectRoot = path63.resolve(projectRoot);
   }
   projectRoot;
   async read() {
@@ -37975,27 +38723,27 @@ async function publishMigrationActorProfiles(projectRoot, profiles) {
   }
 }
 async function archiveLocalCoordinationCollections(store, operationId) {
-  const archiveRoot = path61.join(
+  const archiveRoot = path63.join(
     store.root,
     STAGE_DIRECTORY,
     "archive",
     operationId
   );
-  await mkdir38(archiveRoot, { recursive: true });
+  await mkdir39(archiveRoot, { recursive: true });
   const directories = {
     claims: claimDirectory(store),
     handoffs: handoffDirectory(store),
     "task-heads": taskHeadDirectory(store)
   };
   for (const name of COLLECTIONS) {
-    const archived = path61.join(archiveRoot, name);
-    const absent = path61.join(archiveRoot, `${name}.absent`);
+    const archived = path63.join(archiveRoot, name);
+    const absent = path63.join(archiveRoot, `${name}.absent`);
     if (await pathKind(archived) === "directory" || await pathKind(absent) === "file") {
       continue;
     }
     const sourceKind = await pathKind(directories[name]);
     if (sourceKind === null) {
-      await writeFile43(absent, "\n", { encoding: "utf8", flag: "wx" });
+      await writeFile44(absent, "\n", { encoding: "utf8", flag: "wx" });
       continue;
     }
     if (sourceKind !== "directory") {
@@ -38010,7 +38758,7 @@ async function listActorProfiles(projectRoot) {
   try {
     entries = await readdir21(directory);
   } catch (error) {
-    if (isNotFound31(error)) return [];
+    if (isNotFound32(error)) return [];
     throw error;
   }
   const profiles = [];
@@ -38027,19 +38775,19 @@ async function listActorProfiles(projectRoot) {
   return profiles;
 }
 async function listSharedTaskRefs(projectRoot) {
-  const directory = path61.join(projectRoot, ".mancode", "shared", "workflows");
+  const directory = path63.join(projectRoot, ".mancode", "shared", "workflows");
   let entries;
   try {
     entries = await readdir21(directory);
   } catch (error) {
-    if (isNotFound31(error)) return [];
+    if (isNotFound32(error)) return [];
     throw error;
   }
   const refs = [];
   for (const taskId of entries.sort(compareUtf814)) {
     assertUlid(taskId, "shared workflow directory");
-    const stat4 = await lstat24(path61.join(directory, taskId));
-    if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
+    const stat5 = await lstat25(path63.join(directory, taskId));
+    if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
     }
     refs.push({ namespace: "shared", taskId });
@@ -38050,7 +38798,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" || isNotFound31(error))) {
+    if (error instanceof Error && (error.message === "MANCODE_TASK_NOT_FOUND" || isNotFound32(error))) {
       return null;
     }
     throw error;
@@ -38112,7 +38860,7 @@ async function readStagedRecord(store, operationId) {
   );
 }
 function stagedPath(store, operationId) {
-  return path61.join(
+  return path63.join(
     store.root,
     STAGE_DIRECTORY,
     "staged",
@@ -38120,7 +38868,7 @@ function stagedPath(store, operationId) {
   );
 }
 function establishedPath(store, operationId) {
-  return path61.join(
+  return path63.join(
     store.root,
     STAGE_DIRECTORY,
     "established",
@@ -38128,12 +38876,12 @@ function establishedPath(store, operationId) {
   );
 }
 function projectConfigPath2(projectRoot) {
-  return path61.join(projectRoot, ".mancode", "shared", "config.json");
+  return path63.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function readProjectConfigFile(projectRoot) {
   try {
     return parseProjectConfig(
-      JSON.parse(await readFile42(projectConfigPath2(projectRoot), "utf8"))
+      JSON.parse(await readFile44(projectConfigPath2(projectRoot), "utf8"))
     );
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -38143,14 +38891,14 @@ async function readProjectConfigFile(projectRoot) {
   }
 }
 async function writeJsonAtomic5(target, value) {
-  await mkdir38(path61.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path61.dirname(target));
-  const temporary = path61.join(
-    path61.dirname(target),
-    `.${path61.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  await mkdir39(path63.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path63.dirname(target));
+  const temporary = path63.join(
+    path63.dirname(target),
+    `.${path63.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile43(temporary, serialize14(value), {
+    await writeFile44(temporary, serialize14(value), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -38161,10 +38909,10 @@ async function writeJsonAtomic5(target, value) {
   }
 }
 async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
-  await mkdir38(path61.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path61.dirname(target));
+  await mkdir39(path63.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path63.dirname(target));
   try {
-    await writeFile43(target, serialize14(value), { encoding: "utf8", flag: "wx" });
+    await writeFile44(target, serialize14(value), { encoding: "utf8", flag: "wx" });
   } catch (error) {
     if (!isAlreadyExists25(error)) throw error;
     const existing = await readJsonOrNull5(target, parser, conflictCode);
@@ -38176,18 +38924,18 @@ async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
 }
 async function readJsonOrNull5(target, parser, corruptCode) {
   try {
-    const before = await lstat24(target);
+    const before = await lstat25(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
-    const parsed = parser(JSON.parse(await readFile42(target, "utf8")));
-    const after = await lstat24(target);
+    const parsed = parser(JSON.parse(await readFile44(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 (isNotFound31(error)) return null;
+    if (isNotFound32(error)) return null;
     if (error instanceof SyntaxError) throw new Error(corruptCode);
     throw error;
   }
@@ -38239,19 +38987,19 @@ function requireRemote(value) {
 }
 async function pathKind(target) {
   try {
-    const stat4 = await lstat24(target);
-    if (stat4.isSymbolicLink()) return "other";
-    if (stat4.isFile()) return "file";
-    if (stat4.isDirectory()) return "directory";
+    const stat5 = await lstat25(target);
+    if (stat5.isSymbolicLink()) return "other";
+    if (stat5.isFile()) return "file";
+    if (stat5.isDirectory()) return "directory";
     return "other";
   } catch (error) {
-    if (isNotFound31(error)) return null;
+    if (isNotFound32(error)) return null;
     throw error;
   }
 }
 async function assertPlainDirectory2(target) {
-  const stat4 = await lstat24(target);
-  if (!stat4.isDirectory() || stat4.isSymbolicLink()) {
+  const stat5 = await lstat25(target);
+  if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
   }
 }
@@ -38259,7 +39007,7 @@ async function unlinkIfExists2(target) {
   try {
     await unlink4(target);
   } catch (error) {
-    if (!isNotFound31(error)) throw error;
+    if (!isNotFound32(error)) throw error;
   }
 }
 function serialize14(value) {
@@ -38272,7 +39020,7 @@ function compareUtf814(left, right) {
 function isAlreadyExists25(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isNotFound31(error) {
+function isNotFound32(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -39681,12 +40429,12 @@ function parseActorId2(value) {
 function parseHandoffId(value) {
   return parseUlidArgument(value, "MANCODE_HANDOFF_ID_INVALID");
 }
-function parseUlidArgument(value, errorCode5) {
+function parseUlidArgument(value, errorCode6) {
   try {
     assertUlid(value, "value");
     return value;
   } catch {
-    throw new Error(errorCode5);
+    throw new Error(errorCode6);
   }
 }
 function parseTransportMode3(value) {
@@ -39712,23 +40460,23 @@ function parsePositiveInteger6(value) {
 }
 
 // src/commands/uninstall.ts
-import { access as access5, readFile as readFile43, rm as rm19, writeFile as writeFile44 } from "fs/promises";
-import path62 from "path";
-import process11 from "process";
-var EXIT_OK9 = 0;
-var EXIT_NOT_INITIALIZED6 = 1;
+import { access as access5, readFile as readFile45, rm as rm20, writeFile as writeFile45 } from "fs/promises";
+import path64 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 = process11.cwd(), platform, options = {}) {
-  const stateFile = path62.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path62.join(rootDir, ".mancode", "schema.json");
+async function uninstall(rootDir = process12.cwd(), platform, options = {}) {
+  const stateFile = path64.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path64.join(rootDir, ".mancode", "schema.json");
   if (await pathExists15(v3SchemaFile)) {
     return uninstallV3(rootDir, platform, options);
   }
   if (!await pathExists15(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
-    return EXIT_NOT_INITIALIZED6;
+    return EXIT_NOT_INITIALIZED7;
   }
   const removeAll = !platform || options.all;
   if (platform) {
@@ -39753,7 +40501,7 @@ async function uninstall(rootDir = process11.cwd(), platform, options = {}) {
     await uninstallPlatform(rootDir, platform ?? "claude-code");
   }
   console.log("\u2713  Uninstall complete.");
-  return EXIT_OK9;
+  return EXIT_OK10;
 }
 async function uninstallV3(rootDir, platform, options) {
   if (!platform || options.all) {
@@ -39784,7 +40532,7 @@ async function uninstallV3(rootDir, platform, options) {
     console.log(
       `\u2713  Removed ${formatPlatformName(platform)} mancode bootstrap.`
     );
-    return EXIT_OK9;
+    return EXIT_OK10;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`\u2717  mancode bootstrap removal failed: ${message}`);
@@ -39812,7 +40560,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm19(path62.join(rootDir, ".mancode"), {
+  await rm20(path64.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -39822,10 +40570,10 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path62.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path64.join(rootDir, ".claude", "settings.json");
   let content;
   try {
-    content = await readFile43(settingsPath, "utf-8");
+    content = await readFile45(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -39836,14 +40584,14 @@ async function cleanClaudeSettings(rootDir) {
     return;
   }
   const cleanedHooks = {};
-  if (isRecord12(settings.hooks)) {
+  if (isRecord13(settings.hooks)) {
     for (const [event, value] of Object.entries(settings.hooks)) {
       const cleaned = cleanClaudeHookValue(value);
       if (cleaned !== void 0) cleanedHooks[event] = cleaned;
     }
     settings.hooks = Object.keys(cleanedHooks).length > 0 ? cleanedHooks : void 0;
   }
-  if (isRecord12(settings.skills)) {
+  if (isRecord13(settings.skills)) {
     const retainedSkills = Object.fromEntries(
       Object.entries(settings.skills).filter(
         ([name, value]) => LEGACY_CLAUDE_SKILL_SETTINGS[name] !== value
@@ -39851,7 +40599,7 @@ async function cleanClaudeSettings(rootDir) {
     );
     settings.skills = Object.keys(retainedSkills).length > 0 ? retainedSkills : void 0;
   }
-  await writeFile44(
+  await writeFile45(
     settingsPath,
     `${JSON.stringify(settings, null, 2)}
 `,
@@ -39863,7 +40611,7 @@ function cleanClaudeHookValue(value) {
     const entries2 = value.flatMap(cleanClaudeHookEntry);
     return entries2.length > 0 ? entries2 : void 0;
   }
-  if (!isRecord12(value)) return value;
+  if (!isRecord13(value)) return value;
   if (Array.isArray(value.hooks) || typeof value.command === "string") {
     const entries2 = cleanClaudeHookEntry(value);
     return entries2.length > 0 ? entries2 : void 0;
@@ -39877,7 +40625,7 @@ function cleanClaudeHookValue(value) {
 }
 function cleanClaudeHookEntry(entry) {
   if (Array.isArray(entry)) return entry.flatMap(cleanClaudeHookEntry);
-  if (!isRecord12(entry)) return [entry];
+  if (!isRecord13(entry)) return [entry];
   if (Array.isArray(entry.hooks)) {
     const hooks = entry.hooks.filter((hook) => !isMancodeHookEntry(hook));
     return hooks.length > 0 ? [{ ...entry, hooks }] : [];
@@ -39885,11 +40633,11 @@ function cleanClaudeHookEntry(entry) {
   return isMancodeHookEntry(entry) ? [] : [entry];
 }
 function isMancodeHookEntry(value) {
-  return isRecord12(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
+  return isRecord13(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
 }
 function containsLegacyMancodeHookPath2(value) {
   if (Array.isArray(value)) return value.some(containsLegacyMancodeHookPath2);
-  if (!isRecord12(value)) return false;
+  if (!isRecord13(value)) return false;
   if (typeof value.command === "string" && value.command.includes(".mancode/hooks/")) {
     return true;
   }
@@ -39900,66 +40648,66 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path62.join(rootDir, "AGENTS.md");
+  const agentsPath = path64.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile43(agentsPath, "utf-8");
+    const content = await readFile45(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile44(agentsPath, `${cleaned}
+      await writeFile45(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm19(agentsPath, { force: true });
+      await rm20(agentsPath, { force: true });
     }
   } catch {
   }
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path62.join(
+  const instructionsPath = path64.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
   );
   try {
-    const content = await readFile43(instructionsPath, "utf-8");
+    const content = await readFile45(instructionsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile44(instructionsPath, `${cleaned}
+      await writeFile45(instructionsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm19(instructionsPath, { force: true });
+      await rm20(instructionsPath, { force: true });
     }
   } catch {
   }
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path62.join(rootDir, "AGENTS.md");
+  const agentsPath = path64.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile43(agentsPath, "utf-8");
+    const content = await readFile45(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
       content,
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile44(agentsPath, `${cleaned}
+      await writeFile45(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm19(agentsPath, { force: true });
+      await rm20(agentsPath, { force: true });
     }
   } catch {
   }
   await removeZcodeSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path62.join(rootDir, ".mancode", "config.json");
+  const configPath = path64.join(rootDir, ".mancode", "config.json");
   try {
-    const raw = await readFile43(configPath, "utf-8");
+    const raw = await readFile45(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
-      if (isRecord12(config.platformOptions)) {
+      if (isRecord13(config.platformOptions)) {
         const platformOptions = Object.fromEntries(
           Object.entries(config.platformOptions).filter(
             ([name]) => name !== platform
@@ -39967,7 +40715,7 @@ async function removeFromConfig(rootDir, platform) {
         );
         config.platformOptions = Object.keys(platformOptions).length > 0 ? platformOptions : void 0;
       }
-      await writeFile44(
+      await writeFile45(
         configPath,
         `${JSON.stringify(config, null, 2)}
 `,
@@ -39977,7 +40725,7 @@ async function removeFromConfig(rootDir, platform) {
   } catch {
   }
 }
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function pathExists15(p) {
@@ -39990,18 +40738,18 @@ async function pathExists15(p) {
 }
 
 // src/commands/version.ts
-import process12 from "process";
+import process13 from "process";
 function version() {
-  const nodeVersion = process12.version;
-  const platform = `${process12.platform}/${process12.arch}`;
+  const nodeVersion = process13.version;
+  const platform = `${process13.platform}/${process13.arch}`;
   console.log(`mancode/${VERSION}`);
   console.log(`node/${nodeVersion.replace("v", "")}`);
   console.log(platform);
 }
 
 // src/commands/workflow.ts
-import { access as access6, readFile as readFile45, rm as rm21, writeFile as writeFile46 } from "fs/promises";
-import path64 from "path";
+import { access as access6, readFile as readFile47, rm as rm22, writeFile as writeFile47 } from "fs/promises";
+import path66 from "path";
 
 // src/context/child-result-merge.ts
 async function mergeV3ChildResult(input) {
@@ -43060,14 +43808,14 @@ function updateMetadata4(previous, verification, operationId, updatedAt) {
 
 // src/context/workflow-create.ts
 import {
-  lstat as lstat25,
-  mkdir as mkdir39,
-  readFile as readFile44,
+  lstat as lstat26,
+  mkdir as mkdir40,
+  readFile as readFile46,
   rename as rename13,
-  rm as rm20,
-  writeFile as writeFile45
+  rm as rm21,
+  writeFile as writeFile46
 } from "fs/promises";
-import path63 from "path";
+import path65 from "path";
 
 // src/context/creation-resolution.ts
 function resolveWorkflowCreation(request) {
@@ -43177,7 +43925,7 @@ function rejectConflict(provided, expected, label) {
 
 // src/context/workflow-create.ts
 async function createV3Workflow(input) {
-  const projectRoot = path63.resolve(requireProjectRoot2(input.projectRoot));
+  const projectRoot = path65.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();
@@ -43362,8 +44110,8 @@ async function createV3Workflow(input) {
       throw new Error("MANCODE_REVISION_CONFLICT");
     }
     const taskParent = await ensureSafeTaskParent3(projectRoot, taskRef);
-    const targetDirectory = path63.join(taskParent, taskRef.taskId);
-    stagingDirectory = path63.join(
+    const targetDirectory = path65.join(taskParent, taskRef.taskId);
+    stagingDirectory = path65.join(
       taskParent,
       `.${taskRef.taskId}.${operationId}.staging`
     );
@@ -43812,10 +44560,10 @@ async function ensureSafeTaskParent3(projectRoot, taskRef) {
   const segments = [".mancode", taskRef.namespace, "workflows"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = path63.join(current, segment);
+    current = path65.join(current, segment);
     const existing = await lstatOrNull5(current);
     if (existing === null) {
-      await mkdir39(current);
+      await mkdir40(current);
       continue;
     }
     if (!existing.isDirectory() || existing.isSymbolicLink()) {
@@ -43828,7 +44576,7 @@ async function assertDirectoryAbsent(target, code) {
   if (await lstatOrNull5(target) !== null) throw new Error(code);
 }
 async function writeStagedEntities(stagingDirectory, entities) {
-  await mkdir39(stagingDirectory);
+  await mkdir40(stagingDirectory);
   await assertDirectory(stagingDirectory);
   await Promise.all([
     writeStagedJson(stagingDirectory, "metadata.json", entities.metadata),
@@ -43848,13 +44596,13 @@ async function writeStagedEntities(stagingDirectory, entities) {
 }
 async function writeStagedJson(stagingDirectory, fileName, value) {
   await assertDirectory(stagingDirectory);
-  const target = path63.join(stagingDirectory, fileName);
-  await writeFile45(target, `${JSON.stringify(value, null, 2)}
+  const target = path65.join(stagingDirectory, fileName);
+  await writeFile46(target, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
   });
-  const entry = await lstat25(target);
+  const entry = await lstat26(target);
   if (!entry.isFile() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -43886,13 +44634,13 @@ async function validateStagedEntities(stagingDirectory) {
   });
 }
 async function readStagedJson(stagingDirectory, fileName, parser) {
-  const target = path63.join(stagingDirectory, fileName);
-  const before = await lstat25(target);
+  const target = path65.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 readFile44(target, "utf8")));
-  const after = await lstat25(target);
+  const parsed = parser(JSON.parse(await readFile46(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");
   }
@@ -43983,20 +44731,20 @@ async function abortPreparedCreate(store, journal, stagingDirectory, now) {
       { canAbort: true }
     );
   } finally {
-    await rm20(stagingDirectory, { recursive: true, force: true });
+    await rm21(stagingDirectory, { recursive: true, force: true });
   }
 }
 async function assertDirectory(target) {
-  const entry = await lstat25(target);
+  const entry = await lstat26(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function lstatOrNull5(target) {
   try {
-    return await lstat25(target);
+    return await lstat26(target);
   } catch (error) {
-    if (isNotFound32(error)) return null;
+    if (isNotFound33(error)) return null;
     throw error;
   }
 }
@@ -44016,7 +44764,7 @@ function requireText2(value, label) {
   }
   return value.trim();
 }
-function isNotFound32(error) {
+function isNotFound33(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
@@ -44913,7 +45661,7 @@ function compareUtf817(left, right) {
 
 // src/commands/requirements-input.ts
 function normalizeRequirementsInput(value, requestedTaskRef, now = /* @__PURE__ */ new Date(), options = {}) {
-  if (isRecord13(value) && "schemaVersion" in value) {
+  if (isRecord14(value) && "schemaVersion" in value) {
     return parseRequirementsLedger(value);
   }
   const serialized = JSON.stringify(value);
@@ -44981,20 +45729,20 @@ function buildCanonicalRequirements(semantic, requestedTaskRef, now) {
     contentDigest: requirementsLedgerDigest(draft)
   });
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/commands/workflow.ts
-var EXIT_OK10 = 0;
-var EXIT_NOT_INITIALIZED7 = 1;
+var EXIT_OK11 = 0;
+var EXIT_NOT_INITIALIZED8 = 1;
 var EXIT_INVALID_ARG3 = 2;
 async function workflow(rootDir, subcommand, args = [], options = {}) {
   const v3Activation = await readV3ActivationState2(rootDir);
   if (v3Activation === "v3_active") {
     return workflowV3(rootDir, subcommand, args, options);
   }
-  if (!await pathExists16(path64.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists16(path66.join(rootDir, ".mancode", "state.json"))) {
     if (v3Activation !== null) {
       return printV3Error(
         options.json,
@@ -45008,7 +45756,7 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
       console.error("\u2717  mancode not initialized.");
       console.error("   Run `mancode init` to get started.");
     }
-    return EXIT_NOT_INITIALIZED7;
+    return EXIT_NOT_INITIALIZED8;
   }
   switch (subcommand) {
     case "create":
@@ -45124,7 +45872,7 @@ async function workflowListV3(rootDir, args, options) {
     }
     if (workflows.length === 0) {
       console.log("No mancode workflows.");
-      return EXIT_OK10;
+      return EXIT_OK11;
     }
     const active = workflows.filter(
       (item) => ["in_progress", "planned", "blocked"].includes(item.status)
@@ -45136,7 +45884,7 @@ async function workflowListV3(rootDir, args, options) {
     for (const metadata of workflows) {
       console.log(formatV3WorkflowRow(metadata));
     }
-    return EXIT_OK10;
+    return EXIT_OK11;
   } catch (error) {
     return printV3Error(
       options.json,
@@ -45194,7 +45942,7 @@ async function workflowShowV3(rootDir, args, options) {
     if (snapshot.aggregateError !== null) {
       console.log(`Aggregate:    ${snapshot.aggregateError}`);
     }
-    return EXIT_OK10;
+    return EXIT_OK11;
   } catch (error) {
     return printV3Error(
       options.json,
@@ -46086,8 +46834,8 @@ function parseV3ParticipantActorIds(values) {
   return values;
 }
 async function readWorkflowInputFile(projectRoot, value) {
-  const inputPath = path64.isAbsolute(value) ? value : path64.resolve(projectRoot, value);
-  return readFile45(inputPath, "utf8");
+  const inputPath = path66.isAbsolute(value) ? value : path66.resolve(projectRoot, value);
+  return readFile47(inputPath, "utf8");
 }
 async function readWorkflowJsonInputFile(projectRoot, value) {
   return JSON.parse(await readWorkflowInputFile(projectRoot, value));
@@ -46160,7 +46908,7 @@ async function readV3ActivationState2(rootDir) {
   try {
     const manifest = parseSchemaManifest(
       JSON.parse(
-        await readFile45(path64.join(rootDir, ".mancode", "schema.json"), "utf8")
+        await readFile47(path66.join(rootDir, ".mancode", "schema.json"), "utf8")
       )
     );
     return manifest.activationState === "v3_active" ? "v3_active" : "other";
@@ -46205,21 +46953,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 = path64.join(rootDir, ".mancode", "workflows", taskId);
-  const jsonPath = path64.join(workflowPath, "requirements.json");
-  const markdownPath = path64.join(workflowPath, "requirements.md");
-  const metadataPath3 = path64.join(workflowPath, "metadata.json");
+  const workflowPath = path66.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path66.join(workflowPath, "requirements.json");
+  const markdownPath = path66.join(workflowPath, "requirements.md");
+  const metadataPath3 = path66.join(workflowPath, "metadata.json");
   let originalJson;
   let originalMarkdown;
   let originalMetadata;
   try {
-    const inputPath = path64.isAbsolute(options.file) ? options.file : path64.resolve(rootDir, options.file);
-    const input = await readFile45(inputPath, "utf-8");
+    const inputPath = path66.isAbsolute(options.file) ? options.file : path66.resolve(rootDir, options.file);
+    const input = await readFile47(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
     [originalJson, originalMarkdown, originalMetadata] = await Promise.all([
       readOptionalText2(jsonPath),
       readOptionalText2(markdownPath),
-      readFile45(metadataPath3, "utf-8")
+      readFile47(metadataPath3, "utf-8")
     ]);
     await writeRequirementsArtifacts(rootDir, taskId, requirements);
     await updateWorkflow(rootDir, taskId, {
@@ -46242,14 +46990,14 @@ async function workflowRequirements(rootDir, args, options) {
         `Finalized requirements: ${taskId} (${requirementsAreReady2(requirements) ? "ready" : "needs_clarification"})`
       );
     }
-    return EXIT_OK10;
+    return EXIT_OK11;
   } catch (error) {
     let rollbackIncomplete = false;
     if (originalJson !== void 0 && originalMarkdown !== void 0 && originalMetadata !== void 0) {
       const rollback = await Promise.allSettled([
         restoreOptionalText(jsonPath, originalJson),
         restoreOptionalText(markdownPath, originalMarkdown),
-        writeFile46(metadataPath3, originalMetadata, "utf-8")
+        writeFile47(metadataPath3, originalMetadata, "utf-8")
       ]);
       rollbackIncomplete = rollback.some(
         (result2) => result2.status === "rejected"
@@ -46278,7 +47026,7 @@ async function workflowVerify(rootDir, args, options) {
       return invalidArg(options, `verification not initialized: ${taskId}`);
     }
     outputVerificationLedger(ledger, options);
-    return EXIT_OK10;
+    return EXIT_OK11;
   }
   if (meta.verificationPolicyVersion !== 1 || (action === "init" ? meta.currentStep !== 6 : meta.currentStep !== 6 && meta.currentStep !== 9) || meta.planDecision !== "governed_execution" || meta.status !== "in_progress" && meta.status !== "blocked") {
     return invalidArg(
@@ -46337,7 +47085,7 @@ async function workflowVerify(rootDir, args, options) {
             );
           }
           if (options.evidenceFile) {
-            const evidencePath = path64.isAbsolute(options.evidenceFile) ? options.evidenceFile : path64.resolve(rootDir, options.evidenceFile);
+            const evidencePath = path66.isAbsolute(options.evidenceFile) ? options.evidenceFile : path66.resolve(rootDir, options.evidenceFile);
             if (!await pathExists16(evidencePath)) {
               return invalidArg(
                 options,
@@ -46387,7 +47135,7 @@ async function workflowVerify(rootDir, args, options) {
     );
     if (transitionError) return invalidArg(options, transitionError);
     outputVerificationLedger(ledger, options);
-    return EXIT_OK10;
+    return EXIT_OK11;
   } catch (error) {
     return invalidArg(
       options,
@@ -46397,17 +47145,17 @@ async function workflowVerify(rootDir, args, options) {
 }
 async function commitVerificationTransition(rootDir, meta, ledger) {
   const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path64.join(
+  const metadataPath3 = path66.join(
     rootDir,
     ".mancode",
     "workflows",
     meta.taskId,
     "metadata.json"
   );
-  const specPath = path64.join(rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path66.join(rootDir, ".mancode", "memory", "spec.md");
   const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile45(metadataPath3, "utf-8"),
+    readFile47(metadataPath3, "utf-8"),
     readOptionalText2(specPath)
   ]);
   const wasVerificationBlocked = meta.status === "blocked" && meta.blockingReason?.startsWith("[verification]");
@@ -46436,7 +47184,7 @@ async function commitVerificationTransition(rootDir, meta, ledger) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile46(metadataPath3, originalMetadata, "utf-8"),
+      writeFile47(metadataPath3, originalMetadata, "utf-8"),
       restoreOptionalText(specPath, originalSpec)
     ]);
     const message = error instanceof Error ? error.message : "verification transition failed";
@@ -46471,7 +47219,7 @@ async function workflowReview(rootDir, args, options) {
     if (!ledger)
       return invalidArg(options, `review not initialized: ${taskId}`);
     outputReviewLedger(ledger, options);
-    return EXIT_OK10;
+    return EXIT_OK11;
   }
   if (meta.status !== "in_progress" || meta.currentStep < 6) {
     return invalidArg(
@@ -46501,7 +47249,7 @@ async function workflowReview(rootDir, args, options) {
       if (error) return invalidArg(options, error);
       const ledger = await readReviewLedger(rootDir, taskId);
       outputReviewLedger(ledger, options);
-      return EXIT_OK10;
+      return EXIT_OK11;
     } catch (error) {
       return invalidArg(
         options,
@@ -46558,7 +47306,7 @@ async function workflowReview(rootDir, args, options) {
       );
     }
     outputReviewLedger(ledger, options);
-    return EXIT_OK10;
+    return EXIT_OK11;
   } catch (error) {
     return invalidArg(
       options,
@@ -46568,7 +47316,7 @@ async function workflowReview(rootDir, args, options) {
 }
 async function commitReviewSkip(rootDir, meta, reason) {
   const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path64.join(
+  const metadataPath3 = path66.join(
     rootDir,
     ".mancode",
     "workflows",
@@ -46577,7 +47325,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   );
   const [originalLedger, originalMetadata] = await Promise.all([
     readOptionalText2(ledgerPath),
-    readFile45(metadataPath3, "utf-8")
+    readFile47(metadataPath3, "utf-8")
   ]);
   try {
     await initializeSkippedReview(rootDir, meta.taskId, reason);
@@ -46588,7 +47336,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile46(metadataPath3, originalMetadata, "utf-8")
+      writeFile47(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;
@@ -46648,7 +47396,7 @@ async function workflowCreate(rootDir, args, options) {
       error instanceof Error ? error.message : "unable to create workflow"
     );
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function workflowUpdate(rootDir, taskId, options) {
   if (!taskId) {
@@ -46783,7 +47531,7 @@ async function workflowUpdate(rootDir, taskId, options) {
   } else {
     console.log(`Updated workflow: ${taskId}`);
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function workflowHandoff(rootDir, taskId, options) {
   if (!taskId || !isValidWorkflowTaskId(taskId)) {
@@ -46808,18 +47556,18 @@ async function workflowHandoff(rootDir, taskId, options) {
       "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
     );
   }
-  const workflowPath = path64.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path64.join(workflowPath, "requirements.md")) || !await pathExists16(path64.join(workflowPath, "plan.md"))) {
+  const workflowPath = path66.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path66.join(workflowPath, "requirements.md")) || !await pathExists16(path66.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "solo handoff requires requirements.md and plan.md"
     );
   }
-  const statePath = path64.join(rootDir, ".mancode", "state.json");
+  const statePath = path66.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile45(statePath, "utf-8");
+    originalState = await readFile47(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -46880,7 +47628,7 @@ async function workflowHandoff(rootDir, taskId, options) {
   } else {
     console.log(`Handed off plan to solo: ${taskId}`);
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function workflowCompleteHandoff(rootDir, taskId, options) {
   const meta = await readWorkflow(rootDir, taskId);
@@ -46890,11 +47638,11 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
       `workflow is not an active solo handoff: ${taskId}`
     );
   }
-  const statePath = path64.join(rootDir, ".mancode", "state.json");
+  const statePath = path66.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile45(statePath, "utf-8");
+    originalState = await readFile47(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -46932,7 +47680,7 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
   } else {
     console.log(`Completed solo handoff: ${taskId}`);
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function workflowDecide(rootDir, taskId, options) {
   if (!taskId || !isValidWorkflowTaskId(taskId)) {
@@ -46957,18 +47705,18 @@ async function workflowDecide(rootDir, taskId, options) {
       `workflow is not ready for a plan-only decision: ${taskId}`
     );
   }
-  const workflowPath = path64.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path64.join(workflowPath, "requirements.md")) || !await pathExists16(path64.join(workflowPath, "plan.md"))) {
+  const workflowPath = path66.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path66.join(workflowPath, "requirements.md")) || !await pathExists16(path66.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "plan-only requires requirements.md and plan.md"
     );
   }
-  const statePath = path64.join(rootDir, ".mancode", "state.json");
+  const statePath = path66.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
-    originalState = await readFile45(statePath, "utf-8");
+    originalState = await readFile47(statePath, "utf-8");
     state = JSON.parse(originalState);
   } catch {
     return invalidArg(
@@ -47017,28 +47765,28 @@ async function workflowDecide(rootDir, taskId, options) {
   } else {
     console.log(`Saved plan without execution: ${taskId}`);
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function commitPlanningTransition(args) {
-  const metadataPath3 = path64.join(
+  const metadataPath3 = path66.join(
     args.rootDir,
     ".mancode",
     "workflows",
     args.taskId,
     "metadata.json"
   );
-  const specPath = path64.join(args.rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path66.join(args.rootDir, ".mancode", "memory", "spec.md");
   let originalMetadata;
   let originalSpec;
   try {
-    originalMetadata = await readFile45(metadataPath3, "utf-8");
+    originalMetadata = await readFile47(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 writeFile46(
+    await writeFile47(
       args.statePath,
       `${JSON.stringify(args.nextState, null, 2)}
 `,
@@ -47052,9 +47800,9 @@ async function commitPlanningTransition(args) {
     return null;
   } catch (error) {
     const rollback = await Promise.allSettled([
-      writeFile46(metadataPath3, originalMetadata, "utf-8"),
-      writeFile46(args.statePath, args.originalState, "utf-8"),
-      originalSpec === null ? rm21(specPath, { force: true }) : writeFile46(specPath, originalSpec, "utf-8")
+      writeFile47(metadataPath3, originalMetadata, "utf-8"),
+      writeFile47(args.statePath, args.originalState, "utf-8"),
+      originalSpec === null ? rm22(specPath, { force: true }) : writeFile47(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;
@@ -47062,7 +47810,7 @@ async function commitPlanningTransition(args) {
 }
 async function readOptionalText2(filePath) {
   try {
-    return await readFile45(filePath, "utf-8");
+    return await readFile47(filePath, "utf-8");
   } catch (error) {
     if (isNodeError10(error) && error.code === "ENOENT") return null;
     throw error;
@@ -47070,10 +47818,10 @@ async function readOptionalText2(filePath) {
 }
 async function restoreOptionalText(filePath, content) {
   if (content === null) {
-    await rm21(filePath, { force: true });
+    await rm22(filePath, { force: true });
     return;
   }
-  await writeFile46(filePath, content, "utf-8");
+  await writeFile47(filePath, content, "utf-8");
 }
 function readActiveSoloPlan(value) {
   if (!value || typeof value !== "object") return null;
@@ -47091,11 +47839,11 @@ async function workflowList(rootDir, options) {
   const views = attachActiveChildren(workflows);
   if (options.json) {
     console.log(JSON.stringify(views, null, 2));
-    return EXIT_OK10;
+    return EXIT_OK11;
   }
   if (workflows.length === 0) {
     console.log("No workflows.");
-    return EXIT_OK10;
+    return EXIT_OK11;
   }
   const inProgress = workflows.filter((w) => w.status === "in_progress").length;
   console.log(
@@ -47105,7 +47853,7 @@ async function workflowList(rootDir, options) {
   for (const meta of views) {
     console.log(formatWorkflowRow(meta));
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function workflowShow(rootDir, taskId, options) {
   if (!taskId) {
@@ -47142,7 +47890,7 @@ async function workflowShow(rootDir, taskId, options) {
         2
       )
     );
-    return EXIT_OK10;
+    return EXIT_OK11;
   }
   console.log(`Workflow:    ${meta.taskId}`);
   console.log(`Task:        ${meta.task}`);
@@ -47174,7 +47922,7 @@ async function workflowShow(rootDir, taskId, options) {
       }
     }
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 async function workflowClean(rootDir, options) {
   const workflows = await listWorkflows(rootDir);
@@ -47242,7 +47990,7 @@ async function workflowClean(rootDir, options) {
   } else {
     console.log(`Removed ${removed.length} workflow(s).`);
   }
-  return EXIT_OK10;
+  return EXIT_OK11;
 }
 function formatWorkflowRow(meta) {
   const stepMax = maxWorkflowStep(meta.mode);
@@ -47712,8 +48460,24 @@ program.command("manps [area]").description("Run deterministic preseason health
   const code = await manps(process.cwd(), area ?? "all", options);
   process.exitCode = code;
 });
-program.command("refresh-style").description("Refresh project profile and rescan applicable design tokens").action(async () => {
-  const code = await refreshStyle(process.cwd());
+var designProgram = program.command("design").description("Inspect and configure project UI design policy");
+designProgram.command("status").description("Show the configured and effective project design policy").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+  process.exitCode = await designStatus(process.cwd(), options);
+});
+designProgram.command("context").description("Emit bounded UI design context for coding agents").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+  process.exitCode = await designContext(process.cwd(), options);
+});
+designProgram.command("configure").description("CAS-update the optional project design policy").requiredOption(
+  "--expected-revision <n>",
+  "Current policy revision; use 0 when absent"
+).option("--preset <preset>", "preserve, refine, or experimental").option("--icons <policy>", "existing-first or lucide").option("--emoji <policy>", "allow or forbid-as-interface-icon").option("--motion <policy>", "minimal or purposeful").option("--browser-validation <mode>", "off, when-available, or required").option("--confirm-experimental", "Explicitly allow the experimental preset").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+  process.exitCode = await designConfigure(process.cwd(), options);
+});
+designProgram.command("disable").description("Disable the project design policy without deleting it").requiredOption("--expected-revision <n>", "Current policy revision").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+  process.exitCode = await designDisable(process.cwd(), options);
+});
+program.command("refresh-style").description("Refresh project profile and rescan applicable design tokens").option("--root <path>", "Repository-relative UI project root").action(async (options) => {
+  const code = await refreshStyle(process.cwd(), options);
   process.exitCode = code;
 });
 program.command("refresh-project").description(