mancode 0.5.5 → 0.5.6

package/dist/cli.js

@@ -114,7 +114,7 @@ import {
   workflowMetadataDigest,
   writeOperationReservation,
   writeProjectFacts
-} from "./chunk-YWHFHZ4A.js";
+} from "./chunk-M5CWWECP.js";
 import {
   DEFAULT_MANCODE_END_MARKER,
   DEFAULT_MANCODE_START_MARKER,
@@ -142,7 +142,9 @@ import {
 } from "./chunk-AWOIP2LC.js";
 
 // src/cli.ts
-import { Option, program } from "commander";
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { Command, Option } from "commander";
 
 // src/installers/adapter-upgrade.ts
 import {
@@ -6551,6 +6553,20 @@ async function validateParentTask(projectRoot, mode, parentTaskId, requireStepSi
   }
 }
 async function validateWorkflowMeta(projectRoot, updated, existing, options) {
+  validateImmutableWorkflowFields(updated, existing);
+  validateWorkflowShapeAndSkipPolicy(updated);
+  validateWorkflowLifecycle(updated, existing);
+  validateWorkflowOutcome(updated);
+  validateWorkflowPolicyVersions(updated);
+  validateWorkflowPolicyState(updated);
+  validatePlanDecisionTransition(updated, existing);
+  await validatePlanningArtifactGate(projectRoot, updated);
+  await validateVerificationGate(projectRoot, updated, existing, options);
+  validatePlanVersionTransition(updated, existing);
+  await validateWorkflowFamilyState(projectRoot, updated);
+  await validateWorkflowCompletionGates(projectRoot, updated);
+}
+function validateImmutableWorkflowFields(updated, existing) {
   if (updated.mode !== existing.mode) {
     throw new Error("workflow mode cannot be changed");
   }
@@ -6574,6 +6590,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.verificationPolicyVersion !== existing.verificationPolicyVersion) {
     throw new Error("workflow verification policy version cannot be changed");
   }
+}
+function validateWorkflowShapeAndSkipPolicy(updated) {
   if (!Number.isInteger(updated.currentStep) || updated.currentStep < 1 || updated.currentStep > maxWorkflowStep(updated.mode)) {
     throw new Error(`invalid workflow step: ${updated.currentStep}`);
   }
@@ -6590,6 +6608,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       "workflow policy v2 only allows skipping clarification or review"
     );
   }
+}
+function validateWorkflowLifecycle(updated, existing) {
   if (!canTransition(existing.status, updated.status)) {
     throw new Error(
       `invalid workflow status transition: ${existing.status} -> ${updated.status}`
@@ -6616,6 +6636,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   } else if (updated.blockingReason !== void 0) {
     throw new Error("only blocked workflows can have a blocking reason");
   }
+}
+function validateWorkflowOutcome(updated) {
   if (updated.mode !== "mamba" && updated.outcome !== void 0) {
     throw new Error("only manba workflows can have an outcome");
   }
@@ -6628,6 +6650,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.mode === "mamba" && updated.status === "completed" && !updated.outcome) {
     throw new Error("completed manba workflows require an outcome");
   }
+}
+function validateWorkflowPolicyVersions(updated) {
   if (updated.mode === "mamba" && updated.planVersion !== void 0) {
     throw new Error("manba workflows cannot have a plan version");
   }
@@ -6651,6 +6675,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       "manba workflows cannot have a verification policy version"
     );
   }
+}
+function validateWorkflowPolicyState(updated) {
   if (updated.verificationStatus !== void 0 && !isVerificationStatus(updated.verificationStatus)) {
     throw new Error("invalid workflow verification status");
   }
@@ -6675,12 +6701,16 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.mode === "mamba" && updated.planDecision !== void 0) {
     throw new Error("manba workflows cannot have a plan decision");
   }
+}
+function validatePlanDecisionTransition(updated, existing) {
   if (updated.planDecision !== existing.planDecision && existing.planDecision !== void 0) {
     throw new Error("workflow plan decision cannot be changed");
   }
   if (updated.planDecision !== existing.planDecision && existing.currentStep !== 4) {
     throw new Error("workflow plan decision can only be set at step 4");
   }
+}
+async function validatePlanningArtifactGate(projectRoot, updated) {
   if (updated.planningPolicyVersion === 1 || updated.planningPolicyVersion === 2) {
     if (updated.currentStep >= 3) {
       if (updated.requirementsStatus !== "ready") {
@@ -6717,6 +6747,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       throw new Error("governed execution must be confirmed before step 5");
     }
   }
+}
+async function validateVerificationGate(projectRoot, updated, existing, options) {
   if (updated.verificationPolicyVersion === 1 && updated.currentStep >= 7 && updated.planDecision !== "solo_handoff" && !options.allowIncompleteVerification && !await verificationCanAdvance(
     projectRoot,
     updated.taskId,
@@ -6731,6 +6763,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       "verification-blocked workflows must resume through verify"
     );
   }
+}
+function validatePlanVersionTransition(updated, existing) {
   if (updated.planVersion !== void 0 && (!Number.isInteger(updated.planVersion) || updated.planVersion < 1)) {
     throw new Error("workflow plan version must be a positive integer");
   }
@@ -6740,10 +6774,14 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.planVersion !== existing.planVersion && updated.currentStep !== 4) {
     throw new Error("workflow plan version can only change at step 4");
   }
+}
+async function validateWorkflowFamilyState(projectRoot, updated) {
   await validateParentTask(projectRoot, updated.mode, updated.parentTaskId);
   if ((isTerminalWorkflowStatus(updated.status) || updated.status === "planned") && (await listActiveMambaChildren(projectRoot, updated.taskId)).length > 0) {
     throw new Error("cannot finish workflow with an active manba child");
   }
+}
+async function validateWorkflowCompletionGates(projectRoot, updated) {
   if (updated.status === "completed" && updated.reviewPolicyVersion === 1 && updated.planDecision !== "solo_handoff" && !reviewWasExplicitlySkipped(updated) && !await reviewCanComplete(projectRoot, updated.taskId)) {
     throw new Error("workflow review is incomplete or still has open blockers");
   }
@@ -9638,7 +9676,7 @@ async function activateLegacyMigration(input) {
     if (session === null || session.status !== "active") {
       throw new Error("MANCODE_SESSION_NOT_FOUND");
     }
-    const store = new (await import("./store-DREAZNIX.js")).V3ContextStore(root);
+    const store = new (await import("./store-Z53OE53A.js")).V3ContextStore(root);
     const project = await store.readProjectSnapshot();
     const stage = await readMigrationStage(root, input.stageId);
     if (stage.state !== "staged" || stage.revision !== input.expectedStageRevision) {
@@ -23100,7 +23138,7 @@ async function planContextCompaction(input) {
     ...gitRefWorkflowRepairPlan.protectedTaskRefs
   ]);
   const taskRefs = input.taskRef === void 0 ? await listTaskRefs(root) : [parseTaskRefValue(input.taskRef)];
-  const [checkpointPlan, sessions, overlays, cache] = await Promise.all([
+  const [checkpointPlan, sessions, cache] = await Promise.all([
     planCheckpointCompaction(
       store,
       coordinationStore,
@@ -23113,13 +23151,6 @@ async function planContextCompaction(input) {
       now,
       protectedSessionIds
     ),
-    planLocalOverlayRetention(
-      root,
-      store,
-      taskRefs,
-      project.policy.retention.localRawArtifactDays,
-      now
-    ),
     planLocalCacheRetention(root, project.policy.retention.localCacheDays, now)
   ]);
   return {
@@ -23130,7 +23161,6 @@ async function planContextCompaction(input) {
       ...operationPlan.candidates,
       ...gitRefWorkflowRepairPlan.candidates,
       ...checkpointPlan.candidates,
-      ...overlays,
       ...cache
     ].sort(
       (left, right) => Buffer.from(left.target, "utf8").compare(
@@ -23140,37 +23170,6 @@ async function planContextCompaction(input) {
     skippedReferencedCheckpoints: checkpointPlan.skippedReferencedCheckpoints
   };
 }
-async function planLocalOverlayRetention(root, store, taskRefs, localRawArtifactDays, now) {
-  const threshold = now.getTime() - localRawArtifactDays * 864e5;
-  const candidates = [];
-  for (const taskRef of taskRefs) {
-    if (taskRef.namespace !== "shared") continue;
-    const task = await store.readTaskSnapshot(taskRef);
-    if (!isTerminalTaskStatus(task.metadata.status)) continue;
-    const directory = path41.join(
-      root,
-      ".mancode",
-      "local",
-      "overlays",
-      taskRef.taskId,
-      "artifacts"
-    );
-    for (const entry of await readDirectoryOrEmpty(directory)) {
-      const target = path41.join(directory, entry);
-      const metadata = await regularFileMetadataOrNull(target);
-      if (metadata === null || metadata.mtimeMs >= threshold) continue;
-      candidates.push({
-        kind: "local_overlay_artifact",
-        target,
-        reason: `terminal task raw artifact exceeds ${localRawArtifactDays} day retention`,
-        // The artifact is local-only even though it is grouped by shared task.
-        taskRef: null,
-        relatedTargets: []
-      });
-    }
-  }
-  return candidates;
-}
 async function planLocalCacheRetention(root, localCacheDays, now) {
   const threshold = now.getTime() - localCacheDays * 864e5;
   const directory = path41.join(root, ".mancode", "local", "cache");
@@ -23355,9 +23354,6 @@ function taskRefKeyFromEntityKey(entityKey) {
   );
   return match === null ? null : `${match[1]}:${match[2]}`;
 }
-function isTerminalTaskStatus(status2) {
-  return status2 === "completed" || status2 === "abandoned" || status2 === "superseded";
-}
 async function listTaskRefs(root) {
   const refs = [];
   for (const namespace of ["local", "shared"]) {
@@ -28061,7 +28057,6 @@ async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, proj
       recursive: true
     }),
     mkdir35(path53.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "local", "overlays"), { recursive: true }),
     mkdir35(path53.join(stagingRoot, "local", "quarantine"), { recursive: true }),
     mkdir35(path53.join(stagingRoot, "local", "publish"), { recursive: true }),
     mkdir35(path53.join(stagingRoot, "local", "cache"), { recursive: true }),
@@ -41540,6 +41535,30 @@ function version() {
   console.log(platform);
 }
 
+// src/commands/workflow-subcommands.ts
+var WORKFLOW_SUBCOMMANDS = [
+  "create",
+  "list",
+  "show",
+  "update",
+  "requirements",
+  "plan",
+  "review",
+  "verify",
+  "complete",
+  "scope",
+  "reframe",
+  "archive",
+  "checkpoint",
+  "child",
+  "promote",
+  "handoff"
+];
+var WORKFLOW_SUBCOMMAND_SET = new Set(
+  WORKFLOW_SUBCOMMANDS
+);
+var CONTINUITY_COMPATIBILITY_SUBCOMMANDS = /* @__PURE__ */ new Set(["clean"]);
+
 // src/commands/workflow.ts
 import { access as access6, readFile as readFile48, rm as rm23, writeFile as writeFile50 } from "fs/promises";
 import path69 from "path";
@@ -46757,60 +46776,43 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
       return EXIT_INVALID_ARG3;
   }
 }
+var WORKFLOW_V3_HANDLERS = {
+  create: workflowCreateV3,
+  list: workflowListV3,
+  show: workflowShowV3,
+  update: workflowUpdateV3,
+  requirements: workflowRequirementsV3,
+  plan: workflowPlanV3,
+  review: workflowReviewV3,
+  verify: workflowVerifyV3,
+  complete: workflowCompleteV3,
+  scope: workflowScopeChangeV3,
+  reframe: workflowReframeV3,
+  archive: (rootDir, args, options) => workflowArtifactShowV3(rootDir, "archive", args, options),
+  checkpoint: (rootDir, args, options) => workflowArtifactShowV3(rootDir, "checkpoint", args, options),
+  child: workflowChildResultMergeV3,
+  promote: workflowPromoteV3,
+  handoff: workflowSoloHandoffV3
+};
+var CONTINUITY_COMPATIBILITY_HANDLERS = {
+  clean: (_rootDir, _args, options) => workflowCleanV3(options)
+};
 async function workflowV3(rootDir, subcommand, args, options) {
-  if (subcommand === "list") {
-    return workflowListV3(rootDir, args, options);
-  }
-  if (subcommand === "show") {
-    return workflowShowV3(rootDir, args, options);
-  }
-  if (subcommand === "clean") {
-    return workflowCleanV3(options);
-  }
-  if (subcommand === "create") {
-    return workflowCreateV3(rootDir, args, options);
-  }
-  if (subcommand === "update") {
-    return workflowUpdateV3(rootDir, args, options);
-  }
-  if (subcommand === "requirements") {
-    return workflowRequirementsV3(rootDir, args, options);
-  }
-  if (subcommand === "plan") {
-    return workflowPlanV3(rootDir, args, options);
-  }
-  if (subcommand === "review") {
-    return workflowReviewV3(rootDir, args, options);
-  }
-  if (subcommand === "verify") {
-    return workflowVerifyV3(rootDir, args, options);
-  }
-  if (subcommand === "complete") {
-    return workflowCompleteV3(rootDir, args, options);
-  }
-  if (subcommand === "scope") {
-    return workflowScopeChangeV3(rootDir, args, options);
-  }
-  if (subcommand === "reframe") {
-    return workflowReframeV3(rootDir, args, options);
-  }
-  if (subcommand === "archive" || subcommand === "checkpoint") {
-    return workflowArtifactShowV3(rootDir, subcommand, args, options);
-  }
-  if (subcommand === "child") {
-    return workflowChildResultMergeV3(rootDir, args, options);
-  }
-  if (subcommand === "promote") {
-    return workflowPromoteV3(rootDir, args, options);
+  if (!WORKFLOW_SUBCOMMAND_SET.has(subcommand) && !CONTINUITY_COMPATIBILITY_SUBCOMMANDS.has(subcommand)) {
+    return printV3Error(
+      options.json,
+      "MANCODE_V3_OPERATION_NOT_IMPLEMENTED",
+      `Unknown workflow subcommand: ${subcommand}. Use one of: ${WORKFLOW_SUBCOMMANDS.join(", ")}.`
+    );
   }
-  if (subcommand === "handoff") {
-    return workflowSoloHandoffV3(rootDir, args, options);
+  if (WORKFLOW_SUBCOMMAND_SET.has(subcommand)) {
+    return WORKFLOW_V3_HANDLERS[subcommand](
+      rootDir,
+      args,
+      options
+    );
   }
-  return printV3Error(
-    options.json,
-    "MANCODE_V3_OPERATION_NOT_IMPLEMENTED",
-    `workflow ${subcommand} is not yet implemented for mancode authority.`
-  );
+  return CONTINUITY_COMPATIBILITY_HANDLERS[subcommand](rootDir, args, options);
 }
 async function workflowListV3(rootDir, args, options) {
   if (args.length !== 0) {
@@ -49041,445 +49043,528 @@ async function pathExists16(p) {
 }
 
 // src/cli.ts
-program.name("mancode").description(
-  "AI coding agent harness. Modes: solo, man, manba, manteam, manps."
-).version(VERSION);
-program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode (MVP-2)").option("--no-team", "Force disable team mode (MVP-2)").option("--style <name>", "Specify aesthetic style (MVP-2)").option("--platform <platforms>", "Adapters: comma-separated names or all").option("--empty", "Initialize a safe empty directory as a generic project").addOption(new Option("--v3").hideHelp()).option("--legacy", "Use the legacy state.json initializer").option("--lang <locale>", "Initialization language: zh-CN or en").action(async (options) => {
-  const code = await init(process.cwd(), {
-    ...options,
-    fromCli: true,
-    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
-  });
-  process.exitCode = code;
-});
-program.command("install [platform]").description(
-  "Install platform adapter (claude-code, cursor, codex, copilot, zcode, kimi-code, qoder)"
-).option("--force", "Reinstall even if already installed").option("--minimal", "Minimal install (MVP-2)").option(
-  "--shadow",
-  "Stage a mancode bootstrap candidate without changing live files"
-).option("--confirm", "Confirm a journaled adapter install or repair").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option("--session <id>", "mancode session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").action(async (platform, options) => {
-  const code = await install(
-    process.cwd(),
-    platform ?? "claude-code",
-    options
-  );
-  process.exitCode = code;
-});
-var adapterProgram = program.command("adapter").description("Inspect and explicitly upgrade managed platform adapters");
-adapterProgram.command("status").description("Inspect managed adapter content on disk").option("--platform <platform>", "Inspect one platform adapter").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await adapterStatus(process.cwd(), options);
-});
-adapterProgram.command("upgrade").description("Preview or repair managed adapter content").option("--all", "Upgrade all platform adapters").option("--platform <platform>", "Upgrade one platform adapter").option("--dry-run", "Stage and report changes without writing live targets").option("--confirm", "Confirm the journaled adapter upgrade").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option("--session <id>", "mancode session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await adapterUpgrade(process.cwd(), options);
-});
-program.command("status").description("Show current mancode project status").option("--json", "Output as JSON (for scripts)").option("--brief", "Output compact mancode Continuity runtime status").action(async (options) => {
-  const code = await status(process.cwd(), options);
-  process.exitCode = code;
-});
-var projectProgram = program.command("project").description("Manage project-level mancode policy and compatibility");
-projectProgram.command("upgrade").description("Upgrade project governance policy explicitly").requiredOption("--policy <version>", "Target planning policy version (2)").option("--dry-run", "Preview the upgrade without writing").option("--operation-id <id>", "Operation ID returned by project dry-run").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await projectUpgrade(process.cwd(), options);
-});
-program.command("list-platforms").description("List available and installed mancode platform adapters").action(async () => {
-  const code = await listPlatforms(process.cwd());
-  process.exitCode = code;
-});
-program.command("uninstall [platform]").description("Remove platform adapter or all mancode artifacts").option("--force", "Skip confirmation message").option("--all", "Remove everything including .mancode/ directory").action(async (platform, options) => {
-  const code = await uninstall(process.cwd(), platform, options);
-  process.exitCode = code;
-});
-program.command("workflow <subcommand> [args...]").description("Manage mancode workflows").option("--dry-run", "Preview clean without deleting").option("--older-than <duration>", "Clean workflows older than (e.g. 30d)").option("--step <n>", "Update workflow current step").option("--status <status>", "Update workflow status").option(
-  "--parent-task <taskId>",
-  "Parent /man or /manteam workflow for manba"
-).option("--parent <namespace:id>", "Parent TaskRef for a manba child").option(
-  "--participant <actorId>",
-  "Invite a joined team participant",
-  collectOption,
-  []
-).option("--visibility <visibility>", "Task visibility: local or shared").option("--coordination <coordination>", "Task coordination: single or team").option("--session <id>", "mancode session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--expected-revision <n>", "Expected task revision for mutations").option("--checkpoint-id <id>", "Checkpoint ID for a requirements reframe").option("--child-revision <n>", "Expected child task revision for merge").option("--summary <text>", "Privacy-screened child result summary").option("--next-action <text>", "Next parent action after a child merge").option("--sync", "Publish shared mutations through git-ref transport").option(
-  "--confirm-shared",
-  "Confirm that task metadata may enter shared mancode authority"
-).option("--blocking-reason <reason>", "Explain why a workflow is blocked").option("--outcome <outcome>", "Set manba outcome when completing a task").option("--plan-version <n>", "Set the next man/manteam plan revision").option(
-  "--requirements-status <status>",
-  "Planning readiness: ready or needs_clarification"
-).option(
-  "--plan-decision <decision>",
-  "Plan gate choice: plan_only or governed_execution"
-).option("--to <mode>", "Workflow handoff target (solo)").option("--complete", "Complete an active solo handoff").option(
-  "--skipped <steps>",
-  "Policy v2: clarification only; use workflow review skip for review"
-).option("--review-depth <depth>", "Review depth: targeted or full").option("--review-domain <domain>", "Review domain: quality or security").option(
-  "--report <path>",
-  "Relative Markdown report path for a review domain"
-).option("--blockers <ids>", "Comma-separated blocker ids found by a review").option(
-  "--resolved <ids>",
-  "Comma-separated blocker ids resolved in remediation"
-).option(
-  "--file <path>",
-  "Semantic requirements JSON, plan Markdown, or ledger input file"
-).option(
-  "--scope-file <path>",
-  "Plan implementation scope JSON {include,exclude,modules}"
-).option("--acceptance <id>", "Acceptance criterion id (for example AC-1)").option("--method <method>", "Verification method: automated or manual").option("--result <result>", "Verification result").option("--evidence <text>", "Verification evidence or user confirmation").option("--command <command>", "Command used for automated verification").option("--exit-code <code>", "Exit code from automated verification").option("--evidence-file <path>", "Existing verification report or artifact").option("--reason <reason>", "Reason for an explicit review skip").option("--json", "Output as JSON (for scripts)").action(async (subcommand, args, options) => {
-  const code = await workflow(process.cwd(), subcommand, args ?? [], {
-    ...options,
-    participants: options.participant.length === 0 ? void 0 : options.participant
-  });
-  process.exitCode = code;
-});
-var contextProgram = program.command("context").description("Resolve mancode task context and manage explicit sessions");
-contextProgram.command("show").description("Resolve one mancode Context Pack").option("--task <namespace:id>", "Explicit TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--level <level>", "bootstrap, task, or full").option(
-  "--purpose <purpose>",
-  "orient, plan, implement, review, verify, or handoff"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextShow(process.cwd(), options);
-});
-var contextSessionProgram = contextProgram.command("session").description("Manage mancode session identities");
-contextSessionProgram.command("new").description("Create an explicit bootstrap session").requiredOption("--client <name>", "Client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextSessionNew(process.cwd(), options);
-});
-contextSessionProgram.command("show").description("Show one explicit session without changing it").requiredOption("--session <id>", "Session ID").option("--client <name>", "Expected client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextSessionShow(process.cwd(), options);
-});
-contextSessionProgram.command("spike").description("Record real-host session evidence without persisting host keys").requiredOption(
-  "--platform <platform>",
-  "claude-code, codex, cursor, copilot, zcode, kimi-code, or qoder"
-).requiredOption("--session-mode <mode>", "Evidence path: host or explicit").requiredOption(
-  "--host-session-source <source>",
-  "hook_stdin, environment, api, or none for explicit sessions"
-).requiredOption(
-  "--command-propagation <status>",
-  "Real host child-command result: proven, not_proven, not_tested, or not_applicable"
-).requiredOption(
-  "--subagent-inheritance <status>",
-  "Real host child-agent result: proven, not_proven, not_tested, or not_applicable"
-).option(
-  "--subagent-inheritance-reason <reason>",
-  "Required when child-agent inheritance is not applicable"
-).option(
-  "--hook-approval <status>",
-  "approved, unapproved, unknown, or not_applicable"
-).requiredOption(
-  "--host-version <version>",
-  "Installed host version used for the spike"
-).requiredOption(
-  "--release-candidate <id>",
-  "Immutable mancode release candidate or source commit identifier"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextSessionSpike(process.cwd(), options);
-});
-contextProgram.command("resume <namespace:id>").description("Validate and bind the current session to a mancode TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish shared mutations through git-ref transport").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await contextResume(process.cwd(), task, options);
-});
-contextProgram.command("close").description("Close one explicit session without affecting other sessions").requiredOption("--session <id>", "Session ID").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextClose(process.cwd(), options);
-});
-contextProgram.command("doctor").description("Inspect unfinished mancode operations or repair one explicitly").option(
-  "--repair <operationId>",
-  "Repair this operation with its original session"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextDoctor(process.cwd(), options);
-});
-contextProgram.command("diagnostics [action]").description("Show or configure local aggregate diagnostics").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
-  process.exitCode = await contextDiagnostics(process.cwd(), action, options);
-});
-contextProgram.command("compact").description("List and remove eligible mancode runtime retention candidates").option("--task <namespace:id>", "Compact checkpoints for one completed task").option("--dry-run", "Show the deletion list without changing files").option("--apply-shared", "Permit deletion for shared completed tasks").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextCompact(process.cwd(), options);
-});
-contextProgram.command("beta", { hidden: true }).description("Evaluate internal release-evidence gates").requiredOption(
-  "--release-candidate <id>",
-  "Release candidate that must match every platform evidence record"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextBeta(process.cwd(), options);
-});
-contextProgram.command("publish <local:id>").description("Create a privacy-screened shared man successor").requiredOption("--expected-revision <n>", "Current local task revision").requiredOption(
-  "--confirm-shared",
-  "Confirm that the screened task authority may enter shared storage"
-).option("--dry-run", "Validate the publish preflight without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await contextPublish(process.cwd(), task, options);
-});
-contextProgram.command("reconcile-task-head <shared:id>").description(
-  "Adopt a Git-sourced shared aggregate through an explicit fence CAS"
-).requiredOption(
-  "--expected-fence-revision <n>",
-  "Current shared task-head fence revision"
-).requiredOption(
-  "--from-git",
-  "Confirm the checked-out aggregate came from Git"
-).option("--dry-run", "Validate adoption without changing the task-head fence").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await contextReconcileTaskHead(
-    process.cwd(),
-    task,
-    options
-  );
-});
-contextProgram.command("glossary <action>").description("Manage the user-confirmed shared project glossary").option("--term <term>", "Glossary term (add, update, remove)").option("--definition <text>", "Term definition (add, update)").option(
-  "--alias <alias>",
-  "Term alias; repeat for multiple aliases (add, update)",
-  (value, previous) => [...previous, value],
-  []
-).option("--task <namespace:id>", "Source shared TaskRef (add, update)").option(
-  "--expected-revision <n>",
-  "Current glossary revision (0 for an empty glossary)"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
-  process.exitCode = await contextGlossary(process.cwd(), action, options);
-});
-var contextWorktreeProgram = contextProgram.command("worktree").description("Register and inspect the current mancode checkout binding");
-contextWorktreeProgram.command("register").description(
-  "Register this linked worktree before using mancode coordination"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextWorktreeRegister(process.cwd(), options);
-});
-var operationProgram = program.command("operation").description("Inspect and recover durable mancode operations");
-operationProgram.command("show <operationId>").description("Show one operation journal and its recovery disposition").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await operationShow(process.cwd(), operationId, options);
-});
-operationProgram.command("repair <operationId>").description("Repair an operation using its original actor and session").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await operationRepair(
-    process.cwd(),
-    operationId,
-    options
-  );
-});
-operationProgram.command("abort <operationId>").description(
-  "Abort only an operation proven to have no visible business write"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await operationAbort(
-    process.cwd(),
-    operationId,
-    options
-  );
-});
-var teamProgram = program.command("team").description("Manage mancode local identity and local-team membership");
-teamProgram.command("status").description("Show mancode team policy, transport, and local identity state").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamStatus(process.cwd(), options);
-});
-teamProgram.command("policy <mode>").description("Set the mancode team recommendation policy with a revision CAS").requiredOption("--expected-revision <n>", "Current team policy revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (policy, options) => {
-  process.exitCode = await teamPolicy(process.cwd(), {
-    ...options,
-    policy
+function createCliProgram() {
+  const program = new Command();
+  program.name("mancode").description(
+    "AI coding agent harness. Modes: solo, man, manba, manteam, manps."
+  ).version(VERSION);
+  program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode").option("--no-team", "Force disable team mode").option(
+    "--style <name>",
+    "Legacy aesthetic style (only supported with mancode init --legacy)"
+  ).option("--platform <platforms>", "Adapters: comma-separated names or all").option("--empty", "Initialize a safe empty directory as a generic project").addOption(new Option("--v3").hideHelp()).option("--legacy", "Use the legacy state.json initializer").option("--lang <locale>", "Initialization language: zh-CN or en").action(async (options) => {
+    const code = await init(process.cwd(), {
+      ...options,
+      fromCli: true,
+      interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+    });
+    process.exitCode = code;
+  });
+  program.command("install [platform]").description(
+    "Install platform adapter (claude-code, cursor, codex, copilot, zcode, kimi-code, qoder)"
+  ).option("--force", "Reinstall even if already installed").option(
+    "--minimal",
+    "Retained for legacy compatibility; Continuity bootstrap is already minimal"
+  ).option(
+    "--shadow",
+    "Stage a mancode bootstrap candidate without changing live files"
+  ).option("--confirm", "Confirm a journaled adapter install or repair").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option(
+    "--session <id>",
+    "mancode session ID (otherwise MANCODE_SESSION_ID)"
+  ).option("--client <name>", "Client identity (default: mancode-cli)").action(async (platform, options) => {
+    const code = await install(
+      process.cwd(),
+      platform ?? "claude-code",
+      options
+    );
+    process.exitCode = code;
+  });
+  const adapterProgram = program.command("adapter").description("Inspect and explicitly upgrade managed platform adapters");
+  adapterProgram.command("status").description("Inspect managed adapter content on disk").option("--platform <platform>", "Inspect one platform adapter").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await adapterStatus(process.cwd(), options);
+  });
+  adapterProgram.command("upgrade").description("Preview or repair managed adapter content").option("--all", "Upgrade all platform adapters").option("--platform <platform>", "Upgrade one platform adapter").option(
+    "--dry-run",
+    "Stage and report changes without writing live targets"
+  ).option("--confirm", "Confirm the journaled adapter upgrade").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option(
+    "--session <id>",
+    "mancode session ID (otherwise MANCODE_SESSION_ID)"
+  ).option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await adapterUpgrade(process.cwd(), options);
+  });
+  program.command("status").description("Show current mancode project status").option("--json", "Output as JSON (for scripts)").option("--brief", "Output compact mancode Continuity runtime status").action(async (options) => {
+    const code = await status(process.cwd(), options);
+    process.exitCode = code;
+  });
+  const projectProgram = program.command("project").description("Manage project-level mancode policy and compatibility");
+  projectProgram.command("upgrade").description("Upgrade project governance policy explicitly").requiredOption("--policy <version>", "Target planning policy version (2)").option("--dry-run", "Preview the upgrade without writing").option("--operation-id <id>", "Operation ID returned by project dry-run").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await projectUpgrade(process.cwd(), options);
+  });
+  program.command("list-platforms").description("List available and installed mancode platform adapters").action(async () => {
+    const code = await listPlatforms(process.cwd());
+    process.exitCode = code;
+  });
+  program.command("uninstall [platform]").description("Remove platform adapter or all mancode artifacts").option("--force", "Skip confirmation message").option("--all", "Remove everything including .mancode/ directory").action(async (platform, options) => {
+    const code = await uninstall(process.cwd(), platform, options);
+    process.exitCode = code;
+  });
+  program.command("workflow <subcommand> [args...]").description("Manage mancode workflows").addHelpText(
+    "after",
+    `
+Public Continuity subcommands:
+  ${WORKFLOW_SUBCOMMANDS.join(", ")}
+`
+  ).option("--dry-run", "Preview clean without deleting").option("--older-than <duration>", "Clean workflows older than (e.g. 30d)").option("--step <n>", "Update workflow current step").option("--status <status>", "Update workflow status").option(
+    "--parent-task <taskId>",
+    "Parent /man or /manteam workflow for manba"
+  ).option("--parent <namespace:id>", "Parent TaskRef for a manba child").option(
+    "--participant <actorId>",
+    "Invite a joined team participant",
+    collectOption,
+    []
+  ).option("--visibility <visibility>", "Task visibility: local or shared").option(
+    "--coordination <coordination>",
+    "Task coordination: single or team"
+  ).option(
+    "--session <id>",
+    "mancode session ID (otherwise MANCODE_SESSION_ID)"
+  ).option("--client <name>", "Client identity (default: mancode-cli)").option("--expected-revision <n>", "Expected task revision for mutations").option("--checkpoint-id <id>", "Checkpoint ID for a requirements reframe").option("--child-revision <n>", "Expected child task revision for merge").option("--summary <text>", "Privacy-screened child result summary").option("--next-action <text>", "Next parent action after a child merge").option("--sync", "Publish shared mutations through git-ref transport").option(
+    "--confirm-shared",
+    "Confirm that task metadata may enter shared mancode authority"
+  ).option("--blocking-reason <reason>", "Explain why a workflow is blocked").option("--outcome <outcome>", "Set manba outcome when completing a task").option("--plan-version <n>", "Set the next man/manteam plan revision").option(
+    "--requirements-status <status>",
+    "Planning readiness: ready or needs_clarification"
+  ).option(
+    "--plan-decision <decision>",
+    "Plan gate choice: plan_only or governed_execution"
+  ).option("--to <mode>", "Workflow handoff target (solo)").option("--complete", "Complete an active solo handoff").option(
+    "--skipped <steps>",
+    "Policy v2: clarification only; use workflow review skip for review"
+  ).option("--review-depth <depth>", "Review depth: targeted or full").option("--review-domain <domain>", "Review domain: quality or security").option(
+    "--report <path>",
+    "Relative Markdown report path for a review domain"
+  ).option("--blockers <ids>", "Comma-separated blocker ids found by a review").option(
+    "--resolved <ids>",
+    "Comma-separated blocker ids resolved in remediation"
+  ).option(
+    "--file <path>",
+    "Semantic requirements JSON, plan Markdown, or ledger input file"
+  ).option(
+    "--scope-file <path>",
+    "Plan implementation scope JSON {include,exclude,modules}"
+  ).option("--acceptance <id>", "Acceptance criterion id (for example AC-1)").option("--method <method>", "Verification method: automated or manual").option("--result <result>", "Verification result").option("--evidence <text>", "Verification evidence or user confirmation").option("--command <command>", "Command used for automated verification").option("--exit-code <code>", "Exit code from automated verification").option(
+    "--evidence-file <path>",
+    "Existing verification report or artifact"
+  ).option("--reason <reason>", "Reason for an explicit review skip").option("--json", "Output as JSON (for scripts)").action(async (subcommand, args, options) => {
+    const code = await workflow(process.cwd(), subcommand, args ?? [], {
+      ...options,
+      participants: options.participant.length === 0 ? void 0 : options.participant
+    });
+    process.exitCode = code;
+  });
+  const contextProgram = program.command("context").description("Resolve mancode task context and manage explicit sessions");
+  contextProgram.command("show").description("Resolve one mancode Context Pack").option("--task <namespace:id>", "Explicit TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--level <level>", "bootstrap, task, or full").option(
+    "--purpose <purpose>",
+    "orient, plan, implement, review, verify, or handoff"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextShow(process.cwd(), options);
+  });
+  const contextSessionProgram = contextProgram.command("session").description("Manage mancode session identities");
+  contextSessionProgram.command("new").description("Create an explicit bootstrap session").requiredOption("--client <name>", "Client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextSessionNew(process.cwd(), options);
+  });
+  contextSessionProgram.command("show").description("Show one explicit session without changing it").requiredOption("--session <id>", "Session ID").option("--client <name>", "Expected client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextSessionShow(process.cwd(), options);
+  });
+  contextSessionProgram.command("spike").description(
+    "Record real-host session evidence without persisting host keys"
+  ).requiredOption(
+    "--platform <platform>",
+    "claude-code, codex, cursor, copilot, zcode, kimi-code, or qoder"
+  ).requiredOption("--session-mode <mode>", "Evidence path: host or explicit").requiredOption(
+    "--host-session-source <source>",
+    "hook_stdin, environment, api, or none for explicit sessions"
+  ).requiredOption(
+    "--command-propagation <status>",
+    "Real host child-command result: proven, not_proven, not_tested, or not_applicable"
+  ).requiredOption(
+    "--subagent-inheritance <status>",
+    "Real host child-agent result: proven, not_proven, not_tested, or not_applicable"
+  ).option(
+    "--subagent-inheritance-reason <reason>",
+    "Required when child-agent inheritance is not applicable"
+  ).option(
+    "--hook-approval <status>",
+    "approved, unapproved, unknown, or not_applicable"
+  ).requiredOption(
+    "--host-version <version>",
+    "Installed host version used for the spike"
+  ).requiredOption(
+    "--release-candidate <id>",
+    "Immutable mancode release candidate or source commit identifier"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextSessionSpike(process.cwd(), options);
+  });
+  contextProgram.command("resume <namespace:id>").description("Validate and bind the current session to a mancode TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish shared mutations through git-ref transport").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await contextResume(process.cwd(), task, options);
+  });
+  contextProgram.command("close").description("Close one explicit session without affecting other sessions").requiredOption("--session <id>", "Session ID").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextClose(process.cwd(), options);
+  });
+  contextProgram.command("doctor").description(
+    "Inspect unfinished mancode operations or repair one explicitly"
+  ).option(
+    "--repair <operationId>",
+    "Repair this operation with its original session"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextDoctor(process.cwd(), options);
+  });
+  contextProgram.command("diagnostics [action]").description("Show or configure local aggregate diagnostics").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
+    process.exitCode = await contextDiagnostics(
+      process.cwd(),
+      action,
+      options
+    );
+  });
+  contextProgram.command("compact").description(
+    "List and remove eligible mancode runtime retention candidates"
+  ).option(
+    "--task <namespace:id>",
+    "Compact checkpoints for one completed task"
+  ).option("--dry-run", "Show the deletion list without changing files").option("--apply-shared", "Permit deletion for shared completed tasks").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextCompact(process.cwd(), options);
+  });
+  contextProgram.command("beta", { hidden: true }).description("Evaluate internal release-evidence gates").requiredOption(
+    "--release-candidate <id>",
+    "Release candidate that must match every platform evidence record"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextBeta(process.cwd(), options);
+  });
+  contextProgram.command("publish <local:id>").description("Create a privacy-screened shared man successor").requiredOption("--expected-revision <n>", "Current local task revision").requiredOption(
+    "--confirm-shared",
+    "Confirm that the screened task authority may enter shared storage"
+  ).option("--dry-run", "Validate the publish preflight without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await contextPublish(process.cwd(), task, options);
+  });
+  contextProgram.command("reconcile-task-head <shared:id>").description(
+    "Adopt a Git-sourced shared aggregate through an explicit fence CAS"
+  ).requiredOption(
+    "--expected-fence-revision <n>",
+    "Current shared task-head fence revision"
+  ).requiredOption(
+    "--from-git",
+    "Confirm the checked-out aggregate came from Git"
+  ).option(
+    "--dry-run",
+    "Validate adoption without changing the task-head fence"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await contextReconcileTaskHead(
+      process.cwd(),
+      task,
+      options
+    );
+  });
+  contextProgram.command("glossary <action>").description("Manage the user-confirmed shared project glossary").option("--term <term>", "Glossary term (add, update, remove)").option("--definition <text>", "Term definition (add, update)").option(
+    "--alias <alias>",
+    "Term alias; repeat for multiple aliases (add, update)",
+    (value, previous) => [...previous, value],
+    []
+  ).option("--task <namespace:id>", "Source shared TaskRef (add, update)").option(
+    "--expected-revision <n>",
+    "Current glossary revision (0 for an empty glossary)"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
+    process.exitCode = await contextGlossary(process.cwd(), action, options);
+  });
+  const contextWorktreeProgram = contextProgram.command("worktree").description("Register and inspect the current mancode checkout binding");
+  contextWorktreeProgram.command("register").description(
+    "Register this linked worktree before using mancode coordination"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextWorktreeRegister(process.cwd(), options);
+  });
+  const operationProgram = program.command("operation").description("Inspect and recover durable mancode operations");
+  operationProgram.command("show <operationId>").description("Show one operation journal and its recovery disposition").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await operationShow(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-teamProgram.command("conflicts").description(
-  "Inspect local claim conflicts and handoffs without mutating coordination"
-).option("--task <namespace:id>", "Narrow the report to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamConflicts(process.cwd(), options);
-});
-var teamTransportProgram = teamProgram.command("transport").description("Inspect and migrate the coordination authority");
-teamTransportProgram.command("status").description("Show active coordination transport and freshness").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamTransportStatus(process.cwd(), options);
-});
-teamTransportProgram.command("set <mode>").description(
-  "Switch an empty coordination authority; otherwise use transport migrate"
-).requiredOption(
-  "--expected-config-revision <n>",
-  "Current project config revision"
-).option(
-  "--remote <name>",
-  "Git remote for a git-ref target (default: origin)"
-).option("--dry-run", "Validate the empty-authority switch without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (mode, options) => {
-  process.exitCode = await teamTransportSet(process.cwd(), {
-    ...options,
-    mode
+  operationProgram.command("repair <operationId>").description("Repair an operation using its original actor and session").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await operationRepair(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-teamTransportProgram.command("migrate").description("Journal a single-authority local/git-ref transport switch").requiredOption("--to <mode>", "Target authority: local or git-ref").requiredOption(
-  "--expected-config-revision <n>",
-  "Current project config revision"
-).option(
-  "--remote <name>",
-  "Git remote for a git-ref target (default: origin)"
-).option("--dry-run", "Validate and preview without writing authority state").option("--confirm", "Explicitly confirm the authority migration").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamTransportMigrate(process.cwd(), options);
-});
-teamTransportProgram.command("recover <operationId>").description("Repair forward or safely abort a transport migration").requiredOption("--to <mode>", "Original target authority: local or git-ref").option("--remote <name>", "Original Git remote for a git-ref target").option("--abort", "Abort only before the target authority is established").option("--session <id>", "Original migration session ID").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await teamTransportRecover(
-    process.cwd(),
-    operationId,
-    options
-  );
-});
-var teamSyncProgram = teamProgram.command("sync").description("Explicitly synchronize the git-ref coordination authority");
-teamSyncProgram.command("pull").description("Fetch, validate, and cache refs/mancode/team").option("--task <namespace:id>", "Narrow output to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamSyncPull(process.cwd(), options);
-});
-teamSyncProgram.command("push <namespace:id>").description("Publish one task bundle through a fresh ownership fence CAS").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamSyncPush(process.cwd(), {
-    ...options,
-    task
+  operationProgram.command("abort <operationId>").description(
+    "Abort only an operation proven to have no visible business write"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await operationAbort(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-var teamIdentityProgram = teamProgram.command("identity").description("Manage the machine-local actor identity");
-teamIdentityProgram.command("create").description("Create one local actor identity").requiredOption("--name <displayName>", "Display name").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamIdentityCreate(process.cwd(), options);
-});
-teamIdentityProgram.command("show").description("Show local identity and whether it is joined").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamIdentityShow(process.cwd(), options);
-});
-var teamDecisionProgram = teamProgram.command("decision").description("Publish explicitly confirmed, privacy-safe shared decisions");
-teamDecisionProgram.command("publish").description("Publish one immutable confirmed decision").requiredOption("--title <text>", "Short decision title").requiredOption("--statement <text>", "Confirmed decision statement").option("--task <namespace:id>", "Optional shared TaskRef that produced it").requiredOption("--confirm", "Confirm this decision may enter shared memory").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamDecisionPublish(process.cwd(), options);
-});
-teamProgram.command("join").description(
-  "Publish the approved shared actor profile after explicit confirmation"
-).requiredOption("--name <displayName>", "Must match the local actor identity").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Request explicit remote sync when transport supports it").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamJoin(process.cwd(), options);
-});
-teamProgram.command("checkpoint <namespace:id>").description("Create a journaled immutable checkpoint for a shared task").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).requiredOption("--kind <kind>", "Checkpoint kind").requiredOption("--summary <text>", "Privacy-safe checkpoint summary").option("--next-action <text>", "Next action for the receiving workflow").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamCheckpoint(process.cwd(), {
-    ...options,
-    task
+  const teamProgram = program.command("team").description("Manage mancode local identity and local-team membership");
+  teamProgram.command("status").description(
+    "Show mancode team policy, transport, and local identity state"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamStatus(process.cwd(), options);
   });
-});
-teamProgram.command("claim <namespace:id>").description("Acquire a scoped claim for a shared task").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).option("--path <glob>", "Repository-relative path glob", collectOption, []).option("--module <name>", "Implementation module", collectOption, []).option("--api <name>", "Public API boundary", collectOption, []).option("--schema <name>", "Shared schema boundary", collectOption, []).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamClaim(process.cwd(), {
-    ...options,
-    task,
-    paths: options.path,
-    modules: options.module,
-    apis: options.api,
-    schemas: options.schema
+  teamProgram.command("policy <mode>").description(
+    "Set the mancode team recommendation policy with a revision CAS"
+  ).requiredOption("--expected-revision <n>", "Current team policy revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (policy, options) => {
+    process.exitCode = await teamPolicy(process.cwd(), {
+      ...options,
+      policy
+    });
+  });
+  teamProgram.command("conflicts").description(
+    "Inspect local claim conflicts and handoffs without mutating coordination"
+  ).option("--task <namespace:id>", "Narrow the report to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamConflicts(process.cwd(), options);
+  });
+  const teamTransportProgram = teamProgram.command("transport").description("Inspect and migrate the coordination authority");
+  teamTransportProgram.command("status").description("Show active coordination transport and freshness").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamTransportStatus(process.cwd(), options);
+  });
+  teamTransportProgram.command("set <mode>").description(
+    "Switch an empty coordination authority; otherwise use transport migrate"
+  ).requiredOption(
+    "--expected-config-revision <n>",
+    "Current project config revision"
+  ).option(
+    "--remote <name>",
+    "Git remote for a git-ref target (default: origin)"
+  ).option("--dry-run", "Validate the empty-authority switch without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (mode, options) => {
+    process.exitCode = await teamTransportSet(process.cwd(), {
+      ...options,
+      mode
+    });
   });
-});
-teamProgram.command("renew <claimId>").description("Renew one fresh claim lease").requiredOption("--expected-revision <n>", "Current claim revision").option("--ttl <duration>", "Lease duration: ms, s, m, h, or d").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimRenew(process.cwd(), {
-    ...options,
-    claimId
+  teamTransportProgram.command("migrate").description("Journal a single-authority local/git-ref transport switch").requiredOption("--to <mode>", "Target authority: local or git-ref").requiredOption(
+    "--expected-config-revision <n>",
+    "Current project config revision"
+  ).option(
+    "--remote <name>",
+    "Git remote for a git-ref target (default: origin)"
+  ).option("--dry-run", "Validate and preview without writing authority state").option("--confirm", "Explicitly confirm the authority migration").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamTransportMigrate(process.cwd(), options);
+  });
+  teamTransportProgram.command("recover <operationId>").description("Repair forward or safely abort a transport migration").requiredOption(
+    "--to <mode>",
+    "Original target authority: local or git-ref"
+  ).option("--remote <name>", "Original Git remote for a git-ref target").option("--abort", "Abort only before the target authority is established").option("--session <id>", "Original migration session ID").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await teamTransportRecover(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-teamProgram.command("release <claimId>").description("Release one claim").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimRelease(process.cwd(), {
-    ...options,
-    claimId
+  const teamSyncProgram = teamProgram.command("sync").description("Explicitly synchronize the git-ref coordination authority");
+  teamSyncProgram.command("pull").description("Fetch, validate, and cache refs/mancode/team").option("--task <namespace:id>", "Narrow output to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamSyncPull(process.cwd(), options);
   });
-});
-teamProgram.command("transfer <claimId>").description("Transfer a claim through a new successor identity").requiredOption("--to <actorId>", "Receiving joined participant actor ID").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimTransfer(process.cwd(), {
-    ...options,
-    claimId
+  teamSyncProgram.command("push <namespace:id>").description("Publish one task bundle through a fresh ownership fence CAS").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamSyncPush(process.cwd(), {
+      ...options,
+      task
+    });
+  });
+  const teamIdentityProgram = teamProgram.command("identity").description("Manage the machine-local actor identity");
+  teamIdentityProgram.command("create").description("Create one local actor identity").requiredOption("--name <displayName>", "Display name").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamIdentityCreate(process.cwd(), options);
+  });
+  teamIdentityProgram.command("show").description("Show local identity and whether it is joined").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamIdentityShow(process.cwd(), options);
+  });
+  const teamDecisionProgram = teamProgram.command("decision").description("Publish explicitly confirmed, privacy-safe shared decisions");
+  teamDecisionProgram.command("publish").description("Publish one immutable confirmed decision").requiredOption("--title <text>", "Short decision title").requiredOption("--statement <text>", "Confirmed decision statement").option("--task <namespace:id>", "Optional shared TaskRef that produced it").requiredOption(
+    "--confirm",
+    "Confirm this decision may enter shared memory"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamDecisionPublish(process.cwd(), options);
+  });
+  teamProgram.command("join").description(
+    "Publish the approved shared actor profile after explicit confirmation"
+  ).requiredOption(
+    "--name <displayName>",
+    "Must match the local actor identity"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Request explicit remote sync when transport supports it").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamJoin(process.cwd(), options);
+  });
+  teamProgram.command("checkpoint <namespace:id>").description("Create a journaled immutable checkpoint for a shared task").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).requiredOption("--kind <kind>", "Checkpoint kind").requiredOption("--summary <text>", "Privacy-safe checkpoint summary").option("--next-action <text>", "Next action for the receiving workflow").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamCheckpoint(process.cwd(), {
+      ...options,
+      task
+    });
   });
-});
-teamProgram.command("reclaim <claimId>").description("Explicitly mark an expired claim terminal").requiredOption("--expected-revision <n>", "Current claim revision").requiredOption("--reason <text>", "Privacy-safe expiry reclaim reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimReclaim(process.cwd(), {
-    ...options,
-    claimId
+  teamProgram.command("claim <namespace:id>").description("Acquire a scoped claim for a shared task").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).option("--path <glob>", "Repository-relative path glob", collectOption, []).option("--module <name>", "Implementation module", collectOption, []).option("--api <name>", "Public API boundary", collectOption, []).option("--schema <name>", "Shared schema boundary", collectOption, []).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamClaim(process.cwd(), {
+      ...options,
+      task,
+      paths: options.path,
+      modules: options.module,
+      apis: options.api,
+      schemas: options.schema
+    });
   });
-});
-teamProgram.command("revalidate <claimId>").description("Refresh one claim after task or code snapshot drift").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimRevalidate(process.cwd(), {
-    ...options,
-    claimId
+  teamProgram.command("renew <claimId>").description("Renew one fresh claim lease").requiredOption("--expected-revision <n>", "Current claim revision").option("--ttl <duration>", "Lease duration: ms, s, m, h, or d").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimRenew(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-var teamHandoffProgram = teamProgram.command("handoff").description("Create and transition journaled ownership handoffs");
-teamHandoffProgram.command("draft <namespace:id>").description("Create a checkpoint-backed named handoff draft").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).requiredOption("--to <actorId>", "Receiving joined participant actor ID").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamHandoffDraft(process.cwd(), {
-    ...options,
-    task
+  teamProgram.command("release <claimId>").description("Release one claim").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimRelease(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("offer <handoffId>").description("Offer a handoff draft to its receiving actor").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffOffer(process.cwd(), {
-    ...options,
-    handoffId
+  teamProgram.command("transfer <claimId>").description("Transfer a claim through a new successor identity").requiredOption("--to <actorId>", "Receiving joined participant actor ID").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimTransfer(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("accept <handoffId>").description("Accept an offered handoff and transfer ownership atomically").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffAccept(process.cwd(), {
-    ...options,
-    handoffId
+  teamProgram.command("reclaim <claimId>").description("Explicitly mark an expired claim terminal").requiredOption("--expected-revision <n>", "Current claim revision").requiredOption("--reason <text>", "Privacy-safe expiry reclaim reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimReclaim(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("reject <handoffId>").description("Reject an offered handoff with a durable reason").requiredOption("--expected-revision <n>", "Current handoff revision").requiredOption("--reason <text>", "Reason for rejecting the handoff").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffReject(process.cwd(), {
-    ...options,
-    handoffId
+  teamProgram.command("revalidate <claimId>").description("Refresh one claim after task or code snapshot drift").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimRevalidate(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("cancel <handoffId>").description("Cancel a draft or offered handoff").requiredOption("--expected-revision <n>", "Current handoff revision").option("--reason <text>", "Optional cancellation reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffCancel(process.cwd(), {
-    ...options,
-    handoffId
+  const teamHandoffProgram = teamProgram.command("handoff").description("Create and transition journaled ownership handoffs");
+  teamHandoffProgram.command("draft <namespace:id>").description("Create a checkpoint-backed named handoff draft").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).requiredOption("--to <actorId>", "Receiving joined participant actor ID").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamHandoffDraft(process.cwd(), {
+      ...options,
+      task
+    });
   });
-});
-var migrateProgram = program.command("migrate").description("Inspect and migrate legacy context into mancode staging");
-var migrateContextProgram = migrateProgram.command("context").description("Manage the isolated legacy-to-mancode context migration stage").option("--dry-run", "Inspect legacy authority without writing files").option("--stage", "Create or refresh an isolated local migration stage").option("--status", "Show local migration stages").option("--activate", "Attempt the journaled mancode activation").option(
-  "--rollback <operationId>",
-  "Roll back an untouched mancode activation"
-).option("--stage-id <id>", "Migration stage ID (required if more than one)").option(
-  "--expected-stage-revision <n>",
-  "Expected stage revision for activation"
-).option("--session <id>", "Active session required for activation").option("--confirm", "Explicitly confirm the mancode cutover").option("--confirm-shared", "Confirm promotion of staged shared authority").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  const code = await migrateContext(process.cwd(), options);
-  process.exitCode = code;
-});
-migrateContextProgram.command("resolve <legacyTaskId>").description("Resolve missing owner or implementation scope in one stage").requiredOption(
-  "--expected-stage-revision <n>",
-  "Expected local migration stage revision"
-).option("--stage-id <id>", "Migration stage ID (required if more than one)").option("--owner <actorId>", "Explicit owner actor ID").option(
-  "--scope-file <path>",
-  "JSON implementation scope {include,exclude,modules}"
-).option("--json", "Output as JSON (for scripts)").action(async (legacyTaskId, options) => {
-  const code = await migrateContextResolve(
-    process.cwd(),
-    legacyTaskId,
-    options
-  );
-  process.exitCode = code;
-});
-program.command("manps [area]").description("Run deterministic preseason health scan").option("--json", "Output as JSON (for scripts)").option("--remediate", "Review scan issues with y/n/skip prompts").action(async (area, options) => {
-  const code = await manps(process.cwd(), area ?? "all", options);
-  process.exitCode = code;
-});
-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>",
-  "forbid-as-interface-icon; legacy allow is normalized"
-).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(
-  "Refresh detected project facts after adding Git or project files"
-).action(async () => {
-  const code = await refreshProject(process.cwd());
-  process.exitCode = code;
-});
-program.command("version").description("Show version, node version, and platform").action(() => {
-  version();
-});
-program.parse();
+  teamHandoffProgram.command("offer <handoffId>").description("Offer a handoff draft to its receiving actor").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffOffer(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  teamHandoffProgram.command("accept <handoffId>").description("Accept an offered handoff and transfer ownership atomically").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffAccept(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  teamHandoffProgram.command("reject <handoffId>").description("Reject an offered handoff with a durable reason").requiredOption("--expected-revision <n>", "Current handoff revision").requiredOption("--reason <text>", "Reason for rejecting the handoff").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffReject(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  teamHandoffProgram.command("cancel <handoffId>").description("Cancel a draft or offered handoff").requiredOption("--expected-revision <n>", "Current handoff revision").option("--reason <text>", "Optional cancellation reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffCancel(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  const migrateProgram = program.command("migrate").description("Inspect and migrate legacy context into mancode staging");
+  const migrateContextProgram = migrateProgram.command("context").description(
+    "Manage the isolated legacy-to-mancode context migration stage"
+  ).option("--dry-run", "Inspect legacy authority without writing files").option("--stage", "Create or refresh an isolated local migration stage").option("--status", "Show local migration stages").option("--activate", "Attempt the journaled mancode activation").option(
+    "--rollback <operationId>",
+    "Roll back an untouched mancode activation"
+  ).option("--stage-id <id>", "Migration stage ID (required if more than one)").option(
+    "--expected-stage-revision <n>",
+    "Expected stage revision for activation"
+  ).option("--session <id>", "Active session required for activation").option("--confirm", "Explicitly confirm the mancode cutover").option("--confirm-shared", "Confirm promotion of staged shared authority").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    const code = await migrateContext(process.cwd(), options);
+    process.exitCode = code;
+  });
+  migrateContextProgram.command("resolve <legacyTaskId>").description("Resolve missing owner or implementation scope in one stage").requiredOption(
+    "--expected-stage-revision <n>",
+    "Expected local migration stage revision"
+  ).option("--stage-id <id>", "Migration stage ID (required if more than one)").option("--owner <actorId>", "Explicit owner actor ID").option(
+    "--scope-file <path>",
+    "JSON implementation scope {include,exclude,modules}"
+  ).option("--json", "Output as JSON (for scripts)").action(async (legacyTaskId, options) => {
+    const code = await migrateContextResolve(
+      process.cwd(),
+      legacyTaskId,
+      options
+    );
+    process.exitCode = code;
+  });
+  program.command("manps [area]").description("Run deterministic preseason health scan").option("--json", "Output as JSON (for scripts)").option("--remediate", "Review scan issues with y/n/skip prompts").action(async (area, options) => {
+    const code = await manps(process.cwd(), area ?? "all", options);
+    process.exitCode = code;
+  });
+  const 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>",
+    "forbid-as-interface-icon; legacy allow is normalized"
+  ).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(
+    "Refresh detected project facts after adding Git or project files"
+  ).action(async () => {
+    const code = await refreshProject(process.cwd());
+    process.exitCode = code;
+  });
+  program.command("version").description("Show version, node version, and platform").action(() => {
+    version();
+  });
+  return program;
+}
+if (isDirectExecution()) {
+  createCliProgram().parse();
+}
+function isDirectExecution() {
+  const entrypoint = process.argv[1];
+  if (entrypoint === void 0) return false;
+  try {
+    return realpathSync(entrypoint) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
 function collectOption(value, previous) {
   return [...previous, value];
 }
 export {
-  program as cliProgram
+  createCliProgram
 };
 //# sourceMappingURL=cli.js.map