mancode 0.5.6 → 0.6.1

package/dist/cli.js

@@ -3,7 +3,6 @@ import {
   VERSION
 } from "./chunk-57PJQDQ3.js";
 import {
-  PROJECT_MANIFESTS,
   V3ContextStore,
   assertActivationRollbackManifestTransition,
   assertClaimTransition,
@@ -51,6 +50,7 @@ import {
   formatTaskRef,
   gitRefWorkflowRepairJournalPath,
   handoffDirectory,
+  hasProjectEvidence,
   implementationScopeIsExecutable,
   isUlid,
   listGitRefWorkflowRepairJournalSummaries,
@@ -114,7 +114,7 @@ import {
   workflowMetadataDigest,
   writeOperationReservation,
   writeProjectFacts
-} from "./chunk-M5CWWECP.js";
+} from "./chunk-44UHUCE6.js";
 import {
   DEFAULT_MANCODE_END_MARKER,
   DEFAULT_MANCODE_START_MARKER,
@@ -139,7 +139,7 @@ import {
   stageV3AdapterUpgradeFiles,
   v3AdapterTargetPath,
   v3AdapterVersionsFromStatuses
-} from "./chunk-AWOIP2LC.js";
+} from "./chunk-PBXSV352.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";
@@ -9485,7 +9485,8 @@ var MANAGED_ADAPTERS = [
   "copilot",
   "zcode",
   "kimi-code",
-  "qoder"
+  "qoder",
+  "dsh"
 ];
 var DIGEST_PATTERN5 = /^sha256:[a-f0-9]{64}$/;
 var STAGE_STATES = /* @__PURE__ */ new Set([
@@ -9676,7 +9677,7 @@ async function activateLegacyMigration(input) {
     if (session === null || session.status !== "active") {
       throw new Error("MANCODE_SESSION_NOT_FOUND");
     }
-    const store = new (await import("./store-Z53OE53A.js")).V3ContextStore(root);
+    const store = new (await import("./store-TQFQCAAF.js")).V3ContextStore(root);
     const project = await store.readProjectSnapshot();
     const stage = await readMigrationStage(root, input.stageId);
     if (stage.state !== "staged" || stage.revision !== input.expectedStageRevision) {
@@ -9939,7 +9940,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-TCEFETAG.js");
+        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-TPXL336I.js");
         await applyV3AdapterFilePlan2(root, action);
       }
       journal = await completeActivationStep(
@@ -13795,7 +13796,7 @@ async function upgradeV3Adapters(input) {
   if (unfinished.length > 0) {
     throw new Error("MANCODE_ADAPTER_UPGRADE_OPERATION_PENDING");
   }
-  const actualVersions = await import("./v3-adapter-TCEFETAG.js").then(
+  const actualVersions = await import("./v3-adapter-TPXL336I.js").then(
     ({ inspectV3AdapterVersions: inspectV3AdapterVersions2 }) => inspectV3AdapterVersions2(
       root,
       managedAdapterNames(project.manifest.managedAdapters)
@@ -16344,6 +16345,8 @@ var LEGACY_MODE_NAMES = ["mamba", "man8"];
 var CODEX_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:codex-skill. Do not edit this file manually. -->";
 var ZCODE_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:zcode-skill. Do not edit this file manually. -->";
 var KIMI_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:kimi-skill. Do not edit this file manually. -->";
+var DSH_SKILL_MANAGED_MARKER = "<!-- Managed by mancode:dsh-skill. Do not edit this file manually. -->";
+var MANCODE_DSH_SKILL_MARKERS = [DSH_SKILL_MANAGED_MARKER];
 var MODE_FILE_MANAGED_MARKER = "<!-- Managed by mancode:mode-file. Do not edit this file manually. -->";
 var MANCODE_AGENT_SKILL_MARKERS = [
   CODEX_SKILL_MANAGED_MARKER,
@@ -16484,6 +16487,39 @@ async function installKimiSkills(projectRoot, minimal) {
   }
   await removeLegacyManagedSkills(skillsDir, MANCODE_AGENT_SKILL_MARKERS);
 }
+async function installDshSkills(projectRoot, minimal) {
+  if (minimal) {
+    await removeDshSkills(projectRoot);
+    return;
+  }
+  const skillsDir = path27.join(projectRoot, ".dsh", "skills");
+  for (const mode of MODE_NAMES) {
+    const modeDir = path27.join(skillsDir, mode);
+    await mkdir23(modeDir, { recursive: true });
+    const meta = MODE_META[mode];
+    const content = [
+      "---",
+      `name: ${mode}`,
+      `description: ${JSON.stringify(meta.description)}`,
+      "disable-model-invocation: true",
+      "user-invocable: true",
+      "---",
+      "",
+      DSH_SKILL_MANAGED_MARKER,
+      "",
+      renderModeSkill(mode, "/"),
+      ""
+    ].join("\n");
+    await writeManagedSkill(
+      path27.join(modeDir, "SKILL.md"),
+      content,
+      DSH_SKILL_MANAGED_MARKER,
+      "DeepSeek Harness",
+      MANCODE_DSH_SKILL_MARKERS
+    );
+  }
+  await removeLegacyManagedSkills(skillsDir, MANCODE_DSH_SKILL_MARKERS);
+}
 async function installCursorCommands(projectRoot, minimal) {
   if (minimal) {
     await removeCursorCommands(projectRoot);
@@ -16628,6 +16664,12 @@ async function removeKimiSkills(projectRoot) {
     );
   }
 }
+async function removeDshSkills(projectRoot) {
+  await cleanManagedSkills(
+    path27.join(projectRoot, ".dsh", "skills"),
+    MANCODE_DSH_SKILL_MARKERS
+  );
+}
 async function removeQoderCommands(projectRoot) {
   for (const mode of MODE_NAMES) {
     const filePath = path27.join(projectRoot, ".qoder", "commands", `${mode}.md`);
@@ -16976,6 +17018,8 @@ function renderModes(options) {
     commandLabel = "Invoke mode skills with `/skill:man`, `/skill:manba`, `/skill:manteam`, `/skill:manps`, `/skill:mansolo`.";
   } else if (options.platform === "qoder") {
     commandLabel = "Invoke mode commands with `/man`, `/manba`, `/manteam`, `/manps`, `/mansolo`.";
+  } else if (options.platform === "dsh") {
+    commandLabel = "Invoke user-only mode skills with `/man`, `/manba`, `/manteam`, `/manps`, `/mansolo`.";
   } else if (options.capabilities.skills === "agents-skills") {
     commandLabel = "Invoke mode skills with `$man`, `$manba`, `$manteam`, `$manps`, `$mansolo`.";
   } else if (options.capabilities.slashCommands === "native") {
@@ -17361,14 +17405,124 @@ function renderManpsRule() {
   return renderModeSkill("manps", "/");
 }
 
-// src/installers/kimi-code.ts
-import { writeFile as writeFile29 } from "fs/promises";
+// src/installers/dsh.ts
+import { lstat as lstat11, rename as rename9, rm as rm13, writeFile as writeFile29 } from "fs/promises";
 import path32 from "path";
+var DSH_MANCODE_START_MARKER = "<!-- mancode:dsh:start -->";
+var DSH_MANCODE_END_MARKER = "<!-- mancode:dsh:end -->";
+var DSH_MODE_PATH_NAMES = [
+  "manba",
+  "man",
+  "manteam",
+  "manps",
+  "mansolo",
+  "mamba",
+  "man8"
+];
+async function installDsh(projectRoot, options) {
+  const root = path32.resolve(projectRoot);
+  await assertDshAdapterPathsSafe(root);
+  await installMancodeCore(root);
+  const agentsPath = path32.join(root, "AGENTS.md");
+  const existing = await readTextIfExists(agentsPath);
+  const sharedContent = await generateSharedContent(root, {
+    platform: "dsh",
+    displayName: "DeepSeek Harness",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: true,
+      hooks: false,
+      skills: "dsh-skills"
+    },
+    minimal: options.minimal,
+    techStack: options.techStack,
+    uiLibrary: options.uiLibrary,
+    projectProfile: options.projectProfile
+  });
+  const block = [
+    DSH_MANCODE_START_MARKER,
+    "<!-- Managed by mancode. Do not edit this block manually. -->",
+    "",
+    "# mancode Configuration",
+    "",
+    sharedContent.trim(),
+    DSH_MANCODE_END_MARKER
+  ].join("\n");
+  await writeDshAgentsFile(
+    root,
+    replaceManagedBlock(
+      existing,
+      block,
+      DSH_MANCODE_START_MARKER,
+      DSH_MANCODE_END_MARKER
+    )
+  );
+  await assertDshAdapterPathsSafe(root);
+  await installDshSkills(root, options.minimal ?? false);
+}
+async function assertDshAdapterPathsSafe(projectRoot) {
+  const root = path32.resolve(projectRoot);
+  const targets = [
+    path32.join(root, "AGENTS.md"),
+    ...DSH_MODE_PATH_NAMES.map(
+      (mode) => path32.join(root, ".dsh", "skills", mode, "SKILL.md")
+    )
+  ];
+  for (const target of targets) {
+    await assertDshArtifactPathSafe(root, target);
+  }
+}
+async function writeDshAgentsFile(projectRoot, content) {
+  const root = path32.resolve(projectRoot);
+  const agentsPath = path32.join(root, "AGENTS.md");
+  await assertDshArtifactPathSafe(root, agentsPath);
+  const temporary = path32.join(
+    root,
+    `.AGENTS.md.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    await writeFile29(temporary, content, { encoding: "utf-8", flag: "wx" });
+    await rename9(temporary, agentsPath);
+  } finally {
+    await rm13(temporary, { force: true }).catch(() => void 0);
+  }
+}
+async function assertDshArtifactPathSafe(root, target) {
+  const relative = path32.relative(root, target);
+  if (!relative || relative.startsWith("..") || path32.isAbsolute(relative)) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const rootEntry = await lstat11(root);
+  if (!rootEntry.isDirectory() || rootEntry.isSymbolicLink()) {
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  }
+  const segments = relative.split(path32.sep);
+  let current = root;
+  for (let index = 0; index < segments.length; index += 1) {
+    current = path32.join(current, segments[index] ?? "");
+    try {
+      const entry = await lstat11(current);
+      if (entry.isSymbolicLink() || index < segments.length - 1 && !entry.isDirectory() || index === segments.length - 1 && !entry.isFile()) {
+        throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+      }
+    } catch (error) {
+      if (isNodeError6(error) && error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+}
+function isNodeError6(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/installers/kimi-code.ts
+import { writeFile as writeFile30 } from "fs/promises";
+import path33 from "path";
 var KIMI_MANCODE_START_MARKER = "<!-- mancode:kimi-code:start -->";
 var KIMI_MANCODE_END_MARKER = "<!-- mancode:kimi-code:end -->";
 async function installKimiCode(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path32.join(projectRoot, "AGENTS.md");
+  const agentsPath = path33.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "kimi-code",
@@ -17393,7 +17547,7 @@ async function installKimiCode(projectRoot, options) {
     sharedContent.trim(),
     KIMI_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile29(
+  await writeFile30(
     agentsPath,
     replaceManagedBlock(
       existing,
@@ -17407,13 +17561,13 @@ async function installKimiCode(projectRoot, options) {
 }
 
 // src/installers/qoder.ts
-import { writeFile as writeFile30 } from "fs/promises";
-import path33 from "path";
+import { writeFile as writeFile31 } from "fs/promises";
+import path34 from "path";
 var QODER_MANCODE_START_MARKER = "<!-- mancode:qoder:start -->";
 var QODER_MANCODE_END_MARKER = "<!-- mancode:qoder:end -->";
 async function installQoder(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path33.join(projectRoot, "AGENTS.md");
+  const agentsPath = path34.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "qoder",
@@ -17438,7 +17592,7 @@ async function installQoder(projectRoot, options) {
     sharedContent.trim(),
     QODER_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile30(
+  await writeFile31(
     agentsPath,
     replaceManagedBlock(
       existing,
@@ -17452,13 +17606,13 @@ async function installQoder(projectRoot, options) {
 }
 
 // src/installers/zcode.ts
-import { writeFile as writeFile31 } from "fs/promises";
-import path34 from "path";
+import { writeFile as writeFile32 } from "fs/promises";
+import path35 from "path";
 var ZCODE_MANCODE_START_MARKER = "<!-- mancode:zcode:start -->";
 var ZCODE_MANCODE_END_MARKER = "<!-- mancode:zcode:end -->";
 async function installZcode(projectRoot, options) {
   await installMancodeCore(projectRoot);
-  const agentsPath = path34.join(projectRoot, "AGENTS.md");
+  const agentsPath = path35.join(projectRoot, "AGENTS.md");
   const existing = await readTextIfExists(agentsPath);
   const sharedContent = await generateSharedContent(projectRoot, {
     platform: "zcode",
@@ -17483,7 +17637,7 @@ async function installZcode(projectRoot, options) {
     sharedContent.trim(),
     ZCODE_MANCODE_END_MARKER
   ].join("\n");
-  await writeFile31(
+  await writeFile32(
     agentsPath,
     replaceManagedBlock(
       existing,
@@ -17574,6 +17728,17 @@ var PLATFORM_INSTALLERS = {
       skills: "rules"
     },
     install: installQoder
+  },
+  dsh: {
+    name: "dsh",
+    displayName: "DeepSeek Harness",
+    capabilities: {
+      slashCommands: "partial",
+      subagents: true,
+      hooks: false,
+      skills: "dsh-skills"
+    },
+    install: installDsh
   }
 };
 function getPlatformInstaller(platform) {
@@ -17591,11 +17756,11 @@ function isPlatformName(platform) {
 }
 
 // src/commands/v3-support.ts
-import path36 from "path";
+import path37 from "path";
 
 // src/runtime/platform-spike-store.ts
-import { lstat as lstat11, mkdir as mkdir26, readFile as readFile29, rm as rm13, writeFile as writeFile32 } from "fs/promises";
-import path35 from "path";
+import { lstat as lstat12, mkdir as mkdir26, readFile as readFile29, rm as rm14, writeFile as writeFile33 } from "fs/promises";
+import path36 from "path";
 
 // src/runtime/platform-spike.ts
 var SESSION_SPIKE_PLATFORMS = [
@@ -17605,7 +17770,8 @@ var SESSION_SPIKE_PLATFORMS = [
   "copilot",
   "zcode",
   "kimi-code",
-  "qoder"
+  "qoder",
+  "dsh"
 ];
 function createPlatformSessionSpike(input) {
   assertSessionSpikePlatform(input.platform);
@@ -17977,7 +18143,7 @@ async function readPlatformSessionSpike(projectRoot, platform) {
   if (directory === null) return null;
   try {
     const raw = await readSafeRegularFile(
-      path35.join(directory, `${platform}.json`)
+      path36.join(directory, `${platform}.json`)
     );
     return parsePlatformSessionSpike(JSON.parse(raw));
   } catch (error) {
@@ -18007,13 +18173,13 @@ async function writePlatformSessionSpike(projectRoot, spike) {
   if (directory === null) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const target = path35.join(directory, `${parsed.platform}.json`);
+  const target = path36.join(directory, `${parsed.platform}.json`);
   await assertSafeReplacementTarget(target);
-  const temporary = path35.join(
+  const temporary = path36.join(
     directory,
     `.${parsed.platform}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile32(temporary, `${JSON.stringify(parsed, null, 2)}
+  await writeFile33(temporary, `${JSON.stringify(parsed, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -18022,15 +18188,15 @@ async function writePlatformSessionSpike(projectRoot, spike) {
     await replaceFileAtomically(temporary, target);
     await assertSafeReplacementTarget(target);
   } catch (error) {
-    await rm13(temporary, { force: true });
+    await rm14(temporary, { force: true });
     throw error;
   }
   return parsed;
 }
 async function safeEvidenceDirectory(projectRoot, create) {
-  let current = path35.resolve(projectRoot);
+  let current = path36.resolve(projectRoot);
   for (const segment of EVIDENCE_DIRECTORY_SEGMENTS) {
-    const target = path35.join(current, segment);
+    const target = path36.join(current, segment);
     try {
       await assertSafeDirectory2(target);
     } catch (error) {
@@ -18048,14 +18214,14 @@ async function safeEvidenceDirectory(projectRoot, create) {
   return current;
 }
 async function assertSafeDirectory2(target) {
-  const entry = await lstat11(target);
+  const entry = await lstat12(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function assertSafeReplacementTarget(target) {
   try {
-    const entry = await lstat11(target);
+    const entry = await lstat12(target);
     if (!entry.isFile() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -18065,12 +18231,12 @@ async function assertSafeReplacementTarget(target) {
   }
 }
 async function readSafeRegularFile(target) {
-  const before = await lstat11(target);
+  const before = await lstat12(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   const content = await readFile29(target, "utf8");
-  const after = await lstat11(target);
+  const after = await lstat12(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -18173,7 +18339,7 @@ var EXIT_V3_OK = 0;
 var EXIT_V3_INVALID_ARGUMENT = 2;
 var EXIT_V3_BLOCKED = 3;
 async function readV3CommandProject(projectRoot) {
-  const root = path36.resolve(projectRoot);
+  const root = path37.resolve(projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = new V3ContextStore(root);
   return {
@@ -18226,7 +18392,7 @@ async function resolveV3SessionCandidate(project, input, client) {
   });
 }
 function platformForClient(client) {
-  return client === "claude-code" || client === "codex" || client === "cursor" || client === "copilot" || client === "zcode" || client === "kimi-code" || client === "qoder" ? client : null;
+  return client === "claude-code" || client === "codex" || client === "cursor" || client === "copilot" || client === "zcode" || client === "kimi-code" || client === "qoder" || client === "dsh" ? client : null;
 }
 function commandClient(value) {
   const client = value ?? "mancode-cli";
@@ -18351,8 +18517,8 @@ function selectUpgradePlatforms(options) {
 }
 
 // src/context/glossary.ts
-import { mkdir as mkdir27, readFile as readFile30, rename as rename9, rm as rm14, writeFile as writeFile33 } from "fs/promises";
-import path37 from "path";
+import { mkdir as mkdir27, readFile as readFile30, rename as rename10, rm as rm15, writeFile as writeFile34 } from "fs/promises";
+import path38 from "path";
 var GLOSSARY_TERM_MAX_LENGTH = 64;
 var GLOSSARY_DEFINITION_MAX_LENGTH = 500;
 var GLOSSARY_MAX_ENTRIES = 200;
@@ -18428,8 +18594,8 @@ function parseGlossaryEntry(value) {
   };
 }
 function projectGlossaryPath(projectRoot) {
-  return path37.join(
-    path37.resolve(projectRoot),
+  return path38.join(
+    path38.resolve(projectRoot),
     ".mancode",
     "shared",
     "context",
@@ -18556,20 +18722,20 @@ async function mutateProjectGlossary(projectRoot, store, expectedRevision, mutat
 }
 async function writeGlossaryFile(projectRoot, glossary) {
   const target = projectGlossaryPath(projectRoot);
-  await mkdir27(path37.dirname(target), { recursive: true });
-  const temporary = path37.join(
-    path37.dirname(target),
-    `.${path37.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  await mkdir27(path38.dirname(target), { recursive: true });
+  const temporary = path38.join(
+    path38.dirname(target),
+    `.${path38.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   try {
-    await writeFile33(temporary, `${JSON.stringify(glossary, null, 2)}
+    await writeFile34(temporary, `${JSON.stringify(glossary, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
-    await rename9(temporary, target);
+    await rename10(temporary, target);
   } finally {
-    await rm14(temporary, { force: true }).catch(() => void 0);
+    await rm15(temporary, { force: true }).catch(() => void 0);
   }
 }
 function assertGlobalTermUniqueness(entries) {
@@ -18605,8 +18771,8 @@ function isNotFound20(error) {
 }
 
 // src/context/publish-promote.ts
-import { lstat as lstat12, mkdir as mkdir28, rename as rename10, rm as rm15, writeFile as writeFile34 } from "fs/promises";
-import path38 from "path";
+import { lstat as lstat13, mkdir as mkdir28, rename as rename11, rm as rm16, writeFile as writeFile35 } from "fs/promises";
+import path39 from "path";
 
 // src/context/task-mutation.ts
 function markTaskReviewStale(previous, operationId, updatedAt) {
@@ -19338,7 +19504,7 @@ async function stageDestinationAuthority(projectRoot, destinationTaskRef, operat
   const target = taskRootPath(projectRoot, destinationTaskRef);
   const parent = await ensureSafeTaskParent2(projectRoot, destinationTaskRef);
   await assertPathAbsent(target, "MANCODE_PROMOTION_DESTINATION_EXISTS");
-  const staging = path38.join(
+  const staging = path39.join(
     parent,
     `.${destinationTaskRef.taskId}.${operationId}.staging`
   );
@@ -19346,7 +19512,7 @@ async function stageDestinationAuthority(projectRoot, destinationTaskRef, operat
   await mkdir28(staging);
   try {
     for (const [fileName, content] of Object.entries(contents)) {
-      await writeFile34(path38.join(staging, fileName), content, {
+      await writeFile35(path39.join(staging, fileName), content, {
         encoding: "utf8",
         flag: "wx"
       });
@@ -19354,7 +19520,7 @@ async function stageDestinationAuthority(projectRoot, destinationTaskRef, operat
     await assertSafeDirectory3(staging);
     return staging;
   } catch (error) {
-    await rm15(staging, { recursive: true, force: true });
+    await rm16(staging, { recursive: true, force: true });
     throw error;
   }
 }
@@ -19362,7 +19528,7 @@ async function ensureSafeTaskParent2(projectRoot, taskRef) {
   await assertSafeDirectory3(projectRoot);
   let current = projectRoot;
   for (const segment of [".mancode", taskRef.namespace, "workflows"]) {
-    current = path38.join(current, segment);
+    current = path39.join(current, segment);
     const existing = await lstatOrNull2(current);
     if (existing === null) {
       try {
@@ -19372,7 +19538,7 @@ async function ensureSafeTaskParent2(projectRoot, taskRef) {
         if (!isAlreadyExists16(error)) throw error;
       }
     }
-    const checked = existing ?? await lstat12(current);
+    const checked = existing ?? await lstat13(current);
     if (!checked.isDirectory() || checked.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -19383,7 +19549,7 @@ async function publishStagedDestination(projectRoot, destinationTaskRef, staging
   const target = taskRootPath(projectRoot, destinationTaskRef);
   await assertSafeDirectory3(staging);
   await assertPathAbsent(target, "MANCODE_PROMOTION_DESTINATION_EXISTS");
-  await rename10(staging, target);
+  await rename11(staging, target);
   await assertSafeDirectory3(target);
 }
 async function assertDestinationAbsent(projectRoot, destinationHomeStore, destinationTaskRef) {
@@ -19538,7 +19704,7 @@ async function handlePromotionFailure(source, primaryStore, journal, stagingDire
   } catch {
   } finally {
     if (stagingDirectory !== null) {
-      await rm15(stagingDirectory, { recursive: true, force: true });
+      await rm16(stagingDirectory, { recursive: true, force: true });
     }
   }
 }
@@ -19547,41 +19713,41 @@ async function renewPromotionLocks(source) {
 }
 async function writePromotionQuarantine(projectRoot, operationId, candidate, contents) {
   const directory = publishStagingDirectory(projectRoot, operationId);
-  const parent = path38.dirname(directory);
+  const parent = path39.dirname(directory);
   await mkdir28(parent, { recursive: true });
   await assertSafeDirectory3(parent);
   await assertPathAbsent(directory, "MANCODE_PROMOTION_QUARANTINE_CONFLICT");
   await mkdir28(directory);
   try {
-    await writeFile34(
-      path38.join(directory, "candidate.json"),
+    await writeFile35(
+      path39.join(directory, "candidate.json"),
       serializeTaskAuthority(candidate),
       { encoding: "utf8", flag: "wx" }
     );
     for (const [fileName, content] of Object.entries(contents)) {
-      await writeFile34(path38.join(directory, fileName), content, {
+      await writeFile35(path39.join(directory, fileName), content, {
         encoding: "utf8",
         flag: "wx"
       });
     }
   } catch (error) {
-    await rm15(directory, { recursive: true, force: true });
+    await rm16(directory, { recursive: true, force: true });
     throw error;
   }
 }
 async function rewritePromotionQuarantine(projectRoot, operationId, candidate) {
   const directory = publishStagingDirectory(projectRoot, operationId);
   await assertSafeDirectory3(directory);
-  const target = path38.join(directory, "candidate.json");
-  const temporary = path38.join(
+  const target = path39.join(directory, "candidate.json");
+  const temporary = path39.join(
     directory,
     `.candidate.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile34(temporary, serializeTaskAuthority(candidate), {
+  await writeFile35(temporary, serializeTaskAuthority(candidate), {
     encoding: "utf8",
     flag: "wx"
   });
-  await rename10(temporary, target);
+  await rename11(temporary, target);
 }
 function completeOperationStep2(steps, stepId) {
   const index = steps.findIndex((step) => step.id === stepId);
@@ -19614,14 +19780,14 @@ async function assertPathAbsent(target, code) {
   throw new Error(code);
 }
 async function assertSafeDirectory3(target) {
-  const entry = await lstat12(target);
+  const entry = await lstat13(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function lstatOrNull2(target) {
   try {
-    return await lstat12(target);
+    return await lstat13(target);
   } catch (error) {
     if (isNotFound21(error)) return null;
     throw error;
@@ -20395,7 +20561,7 @@ function compareUtf89(left, right) {
 
 // src/context/task-head-reconcile.ts
 import { execFile as execFileCallback4 } from "child_process";
-import path40 from "path";
+import path41 from "path";
 import { promisify as promisify4 } from "util";
 
 // src/team/conflicts.ts
@@ -20595,9 +20761,9 @@ function unique(values) {
 
 // src/team/git-ref-transport.ts
 import { execFile as execFileCallback3 } from "child_process";
-import { mkdtemp, rm as rm16, writeFile as writeFile35 } from "fs/promises";
+import { mkdtemp, rm as rm17, writeFile as writeFile36 } from "fs/promises";
 import { tmpdir } from "os";
-import path39 from "path";
+import path40 from "path";
 import { promisify as promisify3 } from "util";
 var execFile3 = promisify3(execFileCallback3);
 var TEAM_REF = "refs/mancode/team";
@@ -20620,7 +20786,7 @@ async function resolveGitRefRemoteIdentityHash(projectRoot, remote) {
   }
   let configured = remote;
   try {
-    const output = await runGit2(path39.resolve(projectRoot), [
+    const output = await runGit2(path40.resolve(projectRoot), [
       "remote",
       "get-url",
       "--all",
@@ -20670,7 +20836,7 @@ var GitRefTeamManifestStore = class {
       "git-ref configRevision"
     );
     parseOptionalDigest(options.configDigest, "git-ref configDigest");
-    this.projectRoot = path39.resolve(options.projectRoot);
+    this.projectRoot = path40.resolve(options.projectRoot);
     this.remote = options.remote;
     this.workspaceId = options.workspaceId;
     this.expectedHeader = {
@@ -22376,17 +22542,17 @@ function upsertActorProfile(profiles, profile) {
 }
 async function writeManifestCommit(projectRoot, parent, manifest, now) {
   const temporaryDirectory = await mkdtemp(
-    path39.join(tmpdir(), "mancode-git-ref-")
+    path40.join(tmpdir(), "mancode-git-ref-")
   );
-  const manifestPath = path39.join(temporaryDirectory, "manifest.json");
-  const indexPath = path39.join(temporaryDirectory, "index");
+  const manifestPath = path40.join(temporaryDirectory, "manifest.json");
+  const indexPath = path40.join(temporaryDirectory, "index");
   try {
     const serialized = `${JSON.stringify(manifest, null, 2)}
 `;
     if (Buffer.byteLength(serialized, "utf8") > MAX_MANIFEST_BYTES) {
       throw new Error("MANCODE_TRANSPORT_MANIFEST_TOO_LARGE");
     }
-    await writeFile35(manifestPath, serialized);
+    await writeFile36(manifestPath, serialized);
     const blob = (await runGit2(projectRoot, ["hash-object", "-w", manifestPath])).trim();
     const environment = { ...process.env, GIT_INDEX_FILE: indexPath };
     await runGit2(projectRoot, ["read-tree", "--empty"], environment);
@@ -22418,7 +22584,7 @@ async function writeManifestCommit(projectRoot, parent, manifest, now) {
       commitEnvironment
     )).trim();
   } finally {
-    await rm16(temporaryDirectory, { recursive: true, force: true });
+    await rm17(temporaryDirectory, { recursive: true, force: true });
   }
 }
 async function pushWithLease(projectRoot, remote, expectedCommit, commit3) {
@@ -22500,7 +22666,7 @@ function normalizeRemoteIdentity(projectRoot, value) {
     url.pathname = url.pathname.replace(/\/+$/g, "");
     return url.toString();
   } catch {
-    return path39.resolve(projectRoot, value).replaceAll("\\", "/");
+    return path40.resolve(projectRoot, value).replaceAll("\\", "/");
   }
 }
 function parseBundleCodeRef(value) {
@@ -22874,8 +23040,8 @@ function injectAfterReconcileStep(stepId) {
   throwIfOperationCrashInjected("task_head_reconcile", stepId);
 }
 async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
-  const relativeTaskRoot = path40.relative(projectRoot, taskRoot2);
-  if (!relativeTaskRoot || path40.isAbsolute(relativeTaskRoot) || relativeTaskRoot.split(path40.sep).some((part) => part === "..")) {
+  const relativeTaskRoot = path41.relative(projectRoot, taskRoot2);
+  if (!relativeTaskRoot || path41.isAbsolute(relativeTaskRoot) || relativeTaskRoot.split(path41.sep).some((part) => part === "..")) {
     throw new Error("MANCODE_TASK_UNAVAILABLE");
   }
   const authorityFiles = [
@@ -22883,7 +23049,7 @@ async function assertGitSourcedTaskAggregate(projectRoot, taskRoot2) {
     "requirements.json",
     "review-ledger.json",
     "verification-ledger.json"
-  ].map((file) => path40.join(relativeTaskRoot, file));
+  ].map((file) => path41.join(relativeTaskRoot, file));
   try {
     await execFile4("git", ["rev-parse", "--verify", "HEAD^{commit}"], {
       cwd: projectRoot,
@@ -23103,16 +23269,17 @@ var BETA_PLATFORMS = [
   "copilot",
   "zcode",
   "kimi-code",
-  "qoder"
+  "qoder",
+  "dsh"
 ];
 
 // src/runtime/retention.ts
-import { lstat as lstat13, readFile as readFile31, readdir as readdir14, rm as rm17 } from "fs/promises";
-import path41 from "path";
+import { lstat as lstat14, readFile as readFile31, readdir as readdir14, rm as rm18 } from "fs/promises";
+import path42 from "path";
 var TERMINAL_JOURNAL_RETENTION_DAYS = 30;
 var RETAINED_NON_MILESTONE_CHECKPOINTS = 10;
 async function planContextCompaction(input) {
-  const root = path41.resolve(input.projectRoot);
+  const root = path42.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const store = new V3ContextStore(root);
   const [project, runtime] = await Promise.all([
@@ -23172,7 +23339,7 @@ async function planContextCompaction(input) {
 }
 async function planLocalCacheRetention(root, localCacheDays, now) {
   const threshold = now.getTime() - localCacheDays * 864e5;
-  const directory = path41.join(root, ".mancode", "local", "cache");
+  const directory = path42.join(root, ".mancode", "local", "cache");
   const candidates = [];
   for (const target of await listRegularFilesRecursively(directory)) {
     const metadata = await regularFileMetadataOrNull(target);
@@ -23235,7 +23402,7 @@ async function planCheckpointCompaction(store, coordinationStore, taskRefs, prot
       }
       candidates.push({
         kind: "checkpoint",
-        target: path41.join(
+        target: path42.join(
           task.location.taskRoot,
           "checkpoints",
           `${checkpoint.checkpointId}.json`
@@ -23249,13 +23416,13 @@ async function planCheckpointCompaction(store, coordinationStore, taskRefs, prot
   return { candidates, skippedReferencedCheckpoints };
 }
 async function planCompletedSessionRetention(root, completedSessionDays, now, protectedSessionIds) {
-  const directory = path41.join(root, ".mancode", "local", "sessions");
+  const directory = path42.join(root, ".mancode", "local", "sessions");
   const entries = await readDirectoryOrEmpty(directory);
   const threshold = now.getTime() - completedSessionDays * 864e5;
   const candidates = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const target = path41.join(directory, entry);
+    const target = path42.join(directory, entry);
     const session = parseSessionState(
       JSON.parse(await readRegularFile(target))
     );
@@ -23281,7 +23448,7 @@ async function planOperationRetention(stores, now) {
     const entries = await readDirectoryOrEmpty(directory);
     for (const entry of entries) {
       if (!entry.endsWith(".json")) continue;
-      const target = path41.join(directory, entry);
+      const target = path42.join(directory, entry);
       const journal = parseOperationJournal(
         JSON.parse(await readRegularFile(target))
       );
@@ -23357,7 +23524,7 @@ function taskRefKeyFromEntityKey(entityKey) {
 async function listTaskRefs(root) {
   const refs = [];
   for (const namespace of ["local", "shared"]) {
-    const directory = path41.join(root, ".mancode", namespace, "workflows");
+    const directory = path42.join(root, ".mancode", namespace, "workflows");
     for (const entry of await readDirectoryOrEmpty(directory)) {
       if (!/^[0-9A-HJKMNP-TV-Z]{26}$/.test(entry)) continue;
       refs.push({ namespace, taskId: entry });
@@ -23370,12 +23537,12 @@ async function listTaskRefs(root) {
   );
 }
 async function listTaskCheckpoints(taskRoot2, taskRef) {
-  const directory = path41.join(taskRoot2, "checkpoints");
+  const directory = path42.join(taskRoot2, "checkpoints");
   const checkpoints = [];
   for (const entry of await readDirectoryOrEmpty(directory)) {
     if (!entry.endsWith(".json")) continue;
     const checkpoint = parseCheckpoint(
-      JSON.parse(await readRegularFile(path41.join(directory, entry)))
+      JSON.parse(await readRegularFile(path42.join(directory, entry)))
     );
     if (!sameTaskRef(checkpoint.taskRef, taskRef) || entry !== `${checkpoint.checkpointId}.json`) {
       throw new Error("MANCODE_RETENTION_CHECKPOINT_CORRUPT");
@@ -23399,7 +23566,7 @@ function uniqueStores(stores) {
 }
 async function readDirectoryOrEmpty(directory) {
   try {
-    const entry = await lstat13(directory);
+    const entry = await lstat14(directory);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_RETENTION_PATH_UNSAFE");
     }
@@ -23414,7 +23581,7 @@ async function readDirectoryOrEmpty(directory) {
 async function listRegularFilesRecursively(directory) {
   const files = [];
   for (const entry of await readDirectoryOrEmpty(directory)) {
-    const target = path41.join(directory, entry);
+    const target = path42.join(directory, entry);
     const metadata = await lstatOrNull3(target);
     if (metadata === null) continue;
     if (metadata.isSymbolicLink()) {
@@ -23433,12 +23600,12 @@ async function listRegularFilesRecursively(directory) {
   return files;
 }
 async function readRegularFile(target) {
-  const before = await lstat13(target);
+  const before = await lstat14(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_RETENTION_PATH_UNSAFE");
   }
   const content = await readFile31(target, "utf8");
-  const after = await lstat13(target);
+  const after = await lstat14(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_RETENTION_PATH_UNSAFE");
   }
@@ -23446,7 +23613,7 @@ async function readRegularFile(target) {
 }
 async function removeRegularFile(target) {
   await readRegularFile(target);
-  await rm17(target);
+  await rm18(target);
 }
 async function regularFileExists(target) {
   try {
@@ -23467,7 +23634,7 @@ async function regularFileMetadataOrNull(target) {
 }
 async function lstatOrNull3(target) {
   try {
-    return await lstat13(target);
+    return await lstat14(target);
   } catch (error) {
     if (isNotFound22(error)) return null;
     throw error;
@@ -23478,8 +23645,8 @@ function isNotFound22(error) {
 }
 
 // src/team/git-ref-cache.ts
-import { lstat as lstat14, mkdir as mkdir29, readFile as readFile32, writeFile as writeFile36 } from "fs/promises";
-import path42 from "path";
+import { lstat as lstat15, mkdir as mkdir29, readFile as readFile32, writeFile as writeFile37 } from "fs/promises";
+import path43 from "path";
 var DEFAULT_GIT_REF_FRESHNESS_TTL_MS = 5 * 60 * 1e3;
 async function writeGitRefTeamCache(projectRoot, config, snapshot) {
   const remote = gitRefRemote(config);
@@ -23495,11 +23662,11 @@ async function writeGitRefTeamCache(projectRoot, config, snapshot) {
   });
   const directory = await ensureSafeCacheDirectory(projectRoot);
   const target = gitRefCachePath(projectRoot);
-  const temporary = path42.join(
+  const temporary = path43.join(
     directory,
     `.snapshot.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile36(temporary, `${JSON.stringify(cache, null, 2)}
+  await writeFile37(temporary, `${JSON.stringify(cache, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -23512,14 +23679,14 @@ async function readGitRefTeamCache(projectRoot, config) {
   const target = gitRefCachePath(projectRoot);
   try {
     await assertSafeCacheDirectory(projectRoot);
-    const before = await lstat14(target);
+    const before = await lstat15(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_TRANSPORT_CACHE_UNSAFE");
     }
     const cache = parseGitRefTeamCache(
       JSON.parse(await readFile32(target, "utf8"))
     );
-    const after = await lstat14(target);
+    const after = await lstat15(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_TRANSPORT_CACHE_CHANGED_DURING_READ");
     }
@@ -23611,11 +23778,11 @@ function parseGitRefTeamCache(value) {
   };
 }
 function gitRefCachePath(projectRoot) {
-  return path42.join(gitRefCacheDirectory(projectRoot), "snapshot.json");
+  return path43.join(gitRefCacheDirectory(projectRoot), "snapshot.json");
 }
 function gitRefCacheDirectory(projectRoot) {
-  return path42.join(
-    path42.resolve(projectRoot),
+  return path43.join(
+    path43.resolve(projectRoot),
     ".mancode",
     "local",
     "cache",
@@ -23661,10 +23828,10 @@ function parseReceiptOrNull(value) {
   return value;
 }
 async function ensureSafeCacheDirectory(projectRoot) {
-  const root = path42.resolve(projectRoot);
+  const root = path43.resolve(projectRoot);
   let current = root;
   for (const segment of [".mancode", "local", "cache", "git-ref"]) {
-    current = path42.join(current, segment);
+    current = path43.join(current, segment);
     try {
       await mkdir29(current);
     } catch (error) {
@@ -23675,14 +23842,14 @@ async function ensureSafeCacheDirectory(projectRoot) {
   return current;
 }
 async function assertSafeCacheDirectory(projectRoot) {
-  let current = path42.resolve(projectRoot);
+  let current = path43.resolve(projectRoot);
   for (const segment of [".mancode", "local", "cache", "git-ref"]) {
-    current = path42.join(current, segment);
+    current = path43.join(current, segment);
     await assertDirectoryNotLinked(current);
   }
 }
 async function assertDirectoryNotLinked(directory) {
-  const entry = await lstat14(directory);
+  const entry = await lstat15(directory);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_TRANSPORT_CACHE_UNSAFE");
   }
@@ -23695,24 +23862,24 @@ function isAlreadyExists17(error) {
 }
 
 // src/team/git-ref-workflow-repair.ts
-import { lstat as lstat18, mkdir as mkdir33, readFile as readFile36, readdir as readdir17, writeFile as writeFile40 } from "fs/promises";
-import path46 from "path";
+import { lstat as lstat19, mkdir as mkdir33, readFile as readFile36, readdir as readdir17, writeFile as writeFile41 } from "fs/promises";
+import path47 from "path";
 
 // src/team/git-ref-materialization.ts
 import {
-  lstat as lstat17,
+  lstat as lstat18,
   mkdir as mkdir32,
   readFile as readFile35,
   readdir as readdir16,
   unlink as unlink2,
-  writeFile as writeFile39
+  writeFile as writeFile40
 } from "fs/promises";
-import path45 from "path";
+import path46 from "path";
 
 // src/team/git-ref-bundle.ts
 import { execFile as execFileCallback5 } from "child_process";
-import { lstat as lstat15, mkdir as mkdir30, readFile as readFile33, readdir as readdir15, writeFile as writeFile37 } from "fs/promises";
-import path43 from "path";
+import { lstat as lstat16, mkdir as mkdir30, readFile as readFile33, readdir as readdir15, writeFile as writeFile38 } from "fs/promises";
+import path44 from "path";
 import { promisify as promisify5 } from "util";
 var execFile5 = promisify5(execFileCallback5);
 function createGitRefTaskBundle(input) {
@@ -23775,7 +23942,7 @@ async function assertGitRefBundleCodeReachable(projectRoot, bundle) {
       "git",
       ["cat-file", "-e", `${parsed.codeRef.head}^{commit}`],
       {
-        cwd: path43.resolve(projectRoot),
+        cwd: path44.resolve(projectRoot),
         windowsHide: true
       }
     );
@@ -23788,8 +23955,8 @@ async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
     throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
   }
   const parsed = parseGitRefTaskBundle(bundle);
-  const directory = path43.join(
-    path43.resolve(projectRoot),
+  const directory = path44.join(
+    path44.resolve(projectRoot),
     ".mancode",
     "local",
     "quarantine",
@@ -23805,9 +23972,9 @@ async function quarantineGitRefTaskBundle(projectRoot, remoteRevision, bundle) {
     parsed.taskRef.taskId,
     String(remoteRevision)
   ]);
-  const target = path43.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
+  const target = path44.join(directory, `${parsed.bundleDigest.slice(7)}.json`);
   try {
-    await writeFile37(target, `${JSON.stringify(parsed, null, 2)}
+    await writeFile38(target, `${JSON.stringify(parsed, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -23822,8 +23989,8 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
     throw new Error("MANCODE_TRANSPORT_REVISION_INVALID");
   }
   const parsedTaskRef = parseTaskRefValue(taskRef);
-  const directory = path43.join(
-    path43.resolve(projectRoot),
+  const directory = path44.join(
+    path44.resolve(projectRoot),
     ".mancode",
     "local",
     "quarantine",
@@ -23849,15 +24016,15 @@ async function readQuarantinedGitRefTaskBundle(projectRoot, remoteRevision, task
   const matches = [];
   for (const entry of entries.sort()) {
     if (!/^[a-f0-9]{64}\.json$/.test(entry)) continue;
-    const target = path43.join(directory, entry);
-    const before = await lstat15(target);
+    const target = path44.join(directory, entry);
+    const before = await lstat16(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     const bundle = parseGitRefTaskBundle(
       JSON.parse(await readFile33(target, "utf8"))
     );
-    const after = await lstat15(target);
+    const after = await lstat16(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -23886,25 +24053,25 @@ function parseCodeRef(value) {
   return { branch: value.branch, head: value.head };
 }
 async function ensureFixedDirectory(projectRoot, segments) {
-  let current = path43.resolve(projectRoot);
+  let current = path44.resolve(projectRoot);
   for (const segment of segments) {
-    current = path43.join(current, segment);
+    current = path44.join(current, segment);
     try {
       await mkdir30(current);
     } catch (error) {
       if (!isAlreadyExists18(error)) throw error;
     }
-    const entry = await lstat15(current);
+    const entry = await lstat16(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
 async function assertFixedDirectory(projectRoot, segments) {
-  let current = path43.resolve(projectRoot);
+  let current = path44.resolve(projectRoot);
   for (const segment of segments) {
-    current = path43.join(current, segment);
-    const entry = await lstat15(current);
+    current = path44.join(current, segment);
+    const entry = await lstat16(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -23918,22 +24085,22 @@ function isNotFound24(error) {
 }
 
 // src/team/git-ref-task-base.ts
-import { lstat as lstat16, mkdir as mkdir31, readFile as readFile34, writeFile as writeFile38 } from "fs/promises";
-import path44 from "path";
+import { lstat as lstat17, mkdir as mkdir31, readFile as readFile34, writeFile as writeFile39 } from "fs/promises";
+import path45 from "path";
 async function readGitRefTaskRemoteBase(projectRoot, taskRef) {
   const parsedTaskRef = parseTaskRefValue(taskRef);
   const runtime = await readProjectRuntimeContext(projectRoot);
   const target = remoteBasePath(projectRoot, parsedTaskRef);
   try {
     await assertRemoteBaseDirectory(projectRoot);
-    const before = await lstat16(target);
+    const before = await lstat17(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     const state = parseGitRefTaskRemoteBase(
       JSON.parse(await readFile34(target, "utf8"))
     );
-    const after = await lstat16(target);
+    const after = await lstat17(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -23962,11 +24129,11 @@ async function recordGitRefTaskRemoteBase(projectRoot, remoteRevision, bundle) {
   });
   const directory = await ensureRemoteBaseDirectory(projectRoot);
   const target = remoteBasePath(projectRoot, parsedBundle.taskRef);
-  const temporary = path44.join(
+  const temporary = path45.join(
     directory,
     `.${parsedBundle.taskRef.taskId}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile38(temporary, `${JSON.stringify(state, null, 2)}
+  await writeFile39(temporary, `${JSON.stringify(state, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -23999,7 +24166,7 @@ function parseGitRefTaskRemoteBase(value) {
   };
 }
 async function ensureRemoteBaseDirectory(projectRoot) {
-  let current = path44.resolve(projectRoot);
+  let current = path45.resolve(projectRoot);
   for (const segment of [
     ".mancode",
     "local",
@@ -24007,13 +24174,13 @@ async function ensureRemoteBaseDirectory(projectRoot) {
     "git-ref",
     "remote-bases"
   ]) {
-    current = path44.join(current, segment);
+    current = path45.join(current, segment);
     try {
       await mkdir31(current);
     } catch (error) {
       if (!isAlreadyExists19(error)) throw error;
     }
-    const entry = await lstat16(current);
+    const entry = await lstat17(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -24021,7 +24188,7 @@ async function ensureRemoteBaseDirectory(projectRoot) {
   return current;
 }
 async function assertRemoteBaseDirectory(projectRoot) {
-  let current = path44.resolve(projectRoot);
+  let current = path45.resolve(projectRoot);
   for (const segment of [
     ".mancode",
     "local",
@@ -24029,8 +24196,8 @@ async function assertRemoteBaseDirectory(projectRoot) {
     "git-ref",
     "remote-bases"
   ]) {
-    current = path44.join(current, segment);
-    const entry = await lstat16(current);
+    current = path45.join(current, segment);
+    const entry = await lstat17(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -24038,8 +24205,8 @@ async function assertRemoteBaseDirectory(projectRoot) {
 }
 function remoteBasePath(projectRoot, taskRef) {
   const parsed = parseTaskRefValue(taskRef);
-  return path44.join(
-    path44.resolve(projectRoot),
+  return path45.join(
+    path45.resolve(projectRoot),
     ".mancode",
     "local",
     "cache",
@@ -24063,7 +24230,7 @@ function isNotFound25(error) {
 
 // src/team/git-ref-materialization.ts
 async function materializeGitRefTaskBundle(input) {
-  const projectRoot = path45.resolve(input.projectRoot);
+  const projectRoot = path46.resolve(input.projectRoot);
   const remoteRevision = positiveInteger3(
     input.remoteRevision,
     "git-ref materialization remoteRevision"
@@ -24369,7 +24536,7 @@ async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, pred
   const target = safeTaskPath(taskRoot2, relativePath2);
   await ensureSafeDirectory(
     taskRoot2,
-    path45.dirname(relativePath2).split(path45.sep)
+    path46.dirname(relativePath2).split(path46.sep)
   );
   const current = await readSafeFileOrNull(target);
   if (contentMatches(relativePath2, current, targetContent)) return;
@@ -24379,11 +24546,11 @@ async function replaceVerifiedFile(taskRoot2, relativePath2, targetContent, pred
   if (current === null && (predecessorContent !== null || alternatePredecessorContent !== null) && relativePath2 !== "summary.md") {
     throw new Error("MANCODE_SPLIT_BRAIN");
   }
-  const temporary = path45.join(
-    path45.dirname(target),
-    `.${path45.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path46.join(
+    path46.dirname(target),
+    `.${path46.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile39(temporary, targetContent, { encoding: "utf8", flag: "wx" });
+  await writeFile40(temporary, targetContent, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 function contentMatches(relativePath2, current, expected) {
@@ -24433,12 +24600,12 @@ async function removeVerifiedFile(taskRoot2, relativePath2, predecessorContent)
 }
 async function readSafeFileOrNull(target) {
   try {
-    const before = await lstat17(target);
+    const before = await lstat18(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
     const content = await readFile35(target, "utf8");
-    const after = await lstat17(target);
+    const after = await lstat18(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -24449,28 +24616,28 @@ async function readSafeFileOrNull(target) {
   }
 }
 async function ensureSafeDirectory(root, segments) {
-  let current = path45.resolve(root);
+  let current = path46.resolve(root);
   for (const segment of segments) {
     if (!segment || segment === ".") continue;
     if (segment === ".." || segment.includes("/") || segment.includes("\\")) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
-    current = path45.join(current, segment);
+    current = path46.join(current, segment);
     try {
       await mkdir32(current);
     } catch (error) {
       if (!isAlreadyExists20(error)) throw error;
     }
-    const entry = await lstat17(current);
+    const entry = await lstat18(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
 function safeTaskPath(taskRoot2, relativePath2) {
-  const target = path45.resolve(taskRoot2, relativePath2);
-  const relative = path45.relative(taskRoot2, target);
-  if (!relative || relative.startsWith("..") || path45.isAbsolute(relative)) {
+  const target = path46.resolve(taskRoot2, relativePath2);
+  const relative = path46.relative(taskRoot2, target);
+  if (!relative || relative.startsWith("..") || path46.isAbsolute(relative)) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   return target;
@@ -24482,7 +24649,7 @@ async function createJournal(projectRoot, journal) {
     "journals",
     "git-ref-materialize"
   ]);
-  await writeFile39(
+  await writeFile40(
     journalPath(projectRoot, journal.operationId),
     serialize11(journal),
     {
@@ -24493,11 +24660,11 @@ async function createJournal(projectRoot, journal) {
 }
 async function replaceJournal(projectRoot, journal) {
   const target = journalPath(projectRoot, journal.operationId);
-  const temporary = path45.join(
-    path45.dirname(target),
+  const temporary = path46.join(
+    path46.dirname(target),
     `.${journal.operationId}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile39(temporary, serialize11(journal), {
+  await writeFile40(temporary, serialize11(journal), {
     encoding: "utf8",
     flag: "wx"
   });
@@ -24526,7 +24693,7 @@ async function listJournals(projectRoot) {
   const journals = [];
   for (const entry of entries.sort()) {
     if (!entry.endsWith(".json")) continue;
-    journals.push(await readJournal(path45.join(directory, entry)));
+    journals.push(await readJournal(path46.join(directory, entry)));
   }
   return journals;
 }
@@ -24592,8 +24759,8 @@ function result(status2, bundle, localJournalPath, taskHeadFence) {
   };
 }
 function journalDirectory(projectRoot) {
-  return path45.join(
-    path45.resolve(projectRoot),
+  return path46.join(
+    path46.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -24602,7 +24769,7 @@ function journalDirectory(projectRoot) {
 }
 function journalPath(projectRoot, operationId) {
   assertUlid(operationId, "git-ref materialization operationId");
-  return path45.join(journalDirectory(projectRoot), `${operationId}.json`);
+  return path46.join(journalDirectory(projectRoot), `${operationId}.json`);
 }
 function serialize11(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -24622,7 +24789,7 @@ function timestamp2(value) {
 }
 async function pathExists3(target) {
   try {
-    await lstat17(target);
+    await lstat18(target);
     return true;
   } catch (error) {
     if (isNotFound26(error)) return false;
@@ -24638,7 +24805,7 @@ function isNotFound26(error) {
 
 // src/team/git-ref-workflow-repair.ts
 async function prepareGitRefWorkflowRepair(input) {
-  const root = path46.resolve(input.projectRoot);
+  const root = path47.resolve(input.projectRoot);
   const prepared2 = parsePrepared(input.prepared);
   const pendingMetadata = parseWorkflowMetadata(input.pendingMetadata);
   assertPendingMetadata2(prepared2, pendingMetadata);
@@ -24673,7 +24840,7 @@ async function prepareGitRefWorkflowRepair(input) {
 }
 async function recoverGitRefWorkflowRepair(projectRoot, operationId, transportReceipt = null, options = {}) {
   assertUlid(operationId, "git-ref workflow repair operationId");
-  const root = path46.resolve(projectRoot);
+  const root = path47.resolve(projectRoot);
   let journal = await requireJournal(root, operationId);
   await assertRecoveryAuthorized(root, journal, options);
   if (journal.state === "committed" || journal.state === "aborted") {
@@ -25040,7 +25207,7 @@ async function createJournal2(projectRoot, journal) {
   await ensureJournalDirectory(projectRoot);
   const target = gitRefWorkflowRepairJournalPath(projectRoot, journal.operationId);
   try {
-    await writeFile40(target, serialize12(journal), {
+    await writeFile41(target, serialize12(journal), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -25080,38 +25247,38 @@ function metadataFromBundle(bundle) {
   return parseWorkflowMetadata(artifact2.content);
 }
 function metadataPath2(projectRoot, taskRef) {
-  return path46.join(taskRootPath(projectRoot, taskRef), "metadata.json");
+  return path47.join(taskRootPath(projectRoot, taskRef), "metadata.json");
 }
 async function readSafeFile(target) {
-  const before = await lstat18(target);
+  const before = await lstat19(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   const content = await readFile36(target, "utf8");
-  const after = await lstat18(target);
+  const after = await lstat19(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 atomicWrite(target, content) {
-  const temporary = path46.join(
-    path46.dirname(target),
-    `.${path46.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path47.join(
+    path47.dirname(target),
+    `.${path47.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile40(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile41(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory(projectRoot) {
-  let current = path46.resolve(projectRoot);
+  let current = path47.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-workflow"]) {
-    current = path46.join(current, segment);
+    current = path47.join(current, segment);
     try {
       await mkdir33(current);
     } catch (error) {
       if (!isAlreadyExists21(error)) throw error;
     }
-    const entry = await lstat18(current);
+    const entry = await lstat19(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -25950,19 +26117,19 @@ function parseExpectedRevision2(value) {
 
 // src/commands/design.ts
 import { readFile as readFile38, stat as stat4 } from "fs/promises";
-import path48 from "path";
+import path49 from "path";
 import process2 from "process";
 
 // src/context/design-policy.ts
 import {
-  lstat as lstat19,
+  lstat as lstat20,
   mkdir as mkdir34,
   readFile as readFile37,
   realpath as realpath2,
-  rm as rm18,
-  writeFile as writeFile41
+  rm as rm19,
+  writeFile as writeFile42
 } from "fs/promises";
-import path47 from "path";
+import path48 from "path";
 var DEFAULT_DESIGN_POLICY = {
   schemaVersion: 1,
   revision: 0,
@@ -25976,8 +26143,8 @@ var DEFAULT_DESIGN_POLICY = {
   updatedAt: "1970-01-01T00:00:00.000Z"
 };
 function designPolicyPath(projectRoot) {
-  return path47.join(
-    path47.resolve(projectRoot),
+  return path48.join(
+    path48.resolve(projectRoot),
     ".mancode",
     "shared",
     "context",
@@ -26065,7 +26232,7 @@ async function configureDesignPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   assertUlid(operationId, "design policy operationId");
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path47.resolve(input.projectRoot);
+  const root = path48.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -26121,12 +26288,12 @@ function isDesignBrowserValidation(value) {
 }
 async function writeDesignPolicy(projectRoot, policy) {
   const target = designPolicyPath(projectRoot);
-  await mkdir34(path47.dirname(target), { recursive: true });
-  const temporary = path47.join(
-    path47.dirname(target),
-    `.${path47.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  await mkdir34(path48.dirname(target), { recursive: true });
+  const temporary = path48.join(
+    path48.dirname(target),
+    `.${path48.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile41(temporary, `${JSON.stringify(policy, null, 2)}
+  await writeFile42(temporary, `${JSON.stringify(policy, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -26134,20 +26301,20 @@ async function writeDesignPolicy(projectRoot, policy) {
   try {
     await replaceFileAtomically(temporary, target);
   } finally {
-    await rm18(temporary, { force: true }).catch(() => void 0);
+    await rm19(temporary, { force: true }).catch(() => void 0);
   }
 }
 async function assertDesignPolicyPathSafe(projectRoot) {
-  const root = path47.resolve(projectRoot);
+  const root = path48.resolve(projectRoot);
   const policyPath = designPolicyPath(root);
-  const contextDir = path47.dirname(policyPath);
+  const contextDir = path48.dirname(policyPath);
   try {
     for (const directory of [
-      path47.join(root, ".mancode"),
-      path47.join(root, ".mancode", "shared"),
+      path48.join(root, ".mancode"),
+      path48.join(root, ".mancode", "shared"),
       contextDir
     ]) {
-      const info = await lstat19(directory);
+      const info = await lstat20(directory);
       if (info.isSymbolicLink() || !info.isDirectory()) {
         throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
       }
@@ -26156,12 +26323,12 @@ async function assertDesignPolicyPathSafe(projectRoot) {
       realpath2(root),
       realpath2(contextDir)
     ]);
-    const relative = path47.relative(resolvedRoot, resolvedContextDir);
-    if (path47.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path47.sep}`)) {
+    const relative = path48.relative(resolvedRoot, resolvedContextDir);
+    if (path48.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path48.sep}`)) {
       throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
     }
     try {
-      const info = await lstat19(policyPath);
+      const info = await lstat20(policyPath);
       if (info.isSymbolicLink() || !info.isFile()) {
         throw new Error("MANCODE_DESIGN_POLICY_PATH_UNSAFE");
       }
@@ -26412,7 +26579,7 @@ async function readProfile(rootDir, kind) {
   try {
     return JSON.parse(
       await readFile38(
-        path48.join(rootDir, ".mancode", "project-profile.json"),
+        path49.join(rootDir, ".mancode", "project-profile.json"),
         "utf8"
       )
     );
@@ -26421,7 +26588,7 @@ async function readProfile(rootDir, kind) {
   }
 }
 async function readStyleSummary(rootDir, kind) {
-  const cachePath = kind === "continuity" ? path48.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path48.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
+  const cachePath = kind === "continuity" ? path49.join(rootDir, ".mancode", "local", "cache", "style-tokens.json") : path49.join(rootDir, ".mancode", "aesthetics", "style-tokens.json");
   try {
     const raw = JSON.parse(await readFile38(cachePath, "utf8"));
     return sanitizeStyleSummary(rootDir, raw);
@@ -26462,7 +26629,7 @@ async function styleFreshness(rootDir, scopeRoot, lastScanned, sourceFiles) {
   const scannedAt = Date.parse(lastScanned);
   for (const file of sourceFiles) {
     try {
-      const info = await stat4(path48.resolve(rootDir, scopeRoot, file));
+      const info = await stat4(path49.resolve(rootDir, scopeRoot, file));
       if (info.mtimeMs > scannedAt) return "stale";
     } catch {
       return "stale";
@@ -26539,10 +26706,10 @@ function emptyStyleSummary() {
   };
 }
 async function initializedKind(rootDir) {
-  if (await exists(path48.join(rootDir, ".mancode", "schema.json"))) {
+  if (await exists(path49.join(rootDir, ".mancode", "schema.json"))) {
     return "continuity";
   }
-  if (await exists(path48.join(rootDir, ".mancode", "state.json")))
+  if (await exists(path49.join(rootDir, ".mancode", "state.json")))
     return "legacy";
   return null;
 }
@@ -26607,7 +26774,7 @@ function safeShortText(value) {
   return typeof value === "string" && value.length <= 100 && /^[A-Za-z0-9@/_. -]+$/.test(value) ? value : null;
 }
 function isSafeRelativeFile(value) {
-  return value.length <= 240 && !path48.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
+  return value.length <= 240 && !path49.isAbsolute(value) && !value.includes("\0") && value.split(/[\\/]/).every((part) => part !== "" && part !== "." && part !== "..");
 }
 function parseNonNegativeInteger2(value) {
   if (value === void 0 || !/^\d+$/.test(value)) return null;
@@ -26615,7 +26782,7 @@ function parseNonNegativeInteger2(value) {
   return Number.isSafeInteger(parsed) ? parsed : null;
 }
 function relativePath(rootDir, target) {
-  return path48.relative(path48.resolve(rootDir), target).split(path48.sep).join("/");
+  return path49.relative(path49.resolve(rootDir), target).split(path49.sep).join("/");
 }
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -26647,12 +26814,12 @@ function errorCode3(error, fallback) {
 // src/commands/init.ts
 import { promises as fs4 } from "fs";
 import os from "os";
-import path54 from "path";
+import path55 from "path";
 import process6 from "process";
 
 // src/installers/platform-status.ts
 import { promises as fs } from "fs";
-import path49 from "path";
+import path50 from "path";
 async function checkPlatformStatus(rootDir, platform, installed) {
   const readiness = await checkPlatformReadiness(rootDir, platform);
   return {
@@ -26669,13 +26836,13 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "claude-code") {
     const [hasSoloSkill, registered, hasHookFiles] = await Promise.all([
       fileMatches(
-        path49.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
+        path50.join(rootDir, ".claude", "skills", "solo", "SKILL.md"),
         (content) => isGeneratedClaudeSkill(content, "solo")
       ),
       claudeHooksRegistered(rootDir),
       pathsExist([
-        path49.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
-        path49.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+        path50.join(rootDir, ".mancode", "hooks", "session-start.mjs"),
+        path50.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
       ])
     ]);
     const present = hasSoloSkill && registered && hasHookFiles;
@@ -26691,7 +26858,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   if (platform === "cursor") {
     const hasCoreRules = await allManagedSkills(
       MANCODE_CURSOR_CORE_RULE_FILES.map(
-        (file) => path49.join(rootDir, ".cursor", "rules", file)
+        (file) => path50.join(rootDir, ".cursor", "rules", file)
       ),
       [CURSOR_RULE_MANAGED_MARKER]
     );
@@ -26706,13 +26873,13 @@ async function checkPlatformReadiness(rootDir, platform) {
     const [hasRules, hasCommands] = await Promise.all([
       allManagedSkills(
         MANCODE_CURSOR_RULE_FILES.map(
-          (file) => path49.join(rootDir, ".cursor", "rules", file)
+          (file) => path50.join(rootDir, ".cursor", "rules", file)
         ),
         [CURSOR_RULE_MANAGED_MARKER]
       ),
       allManagedSkills(
         MODE_NAMES.map(
-          (mode) => path49.join(rootDir, ".cursor", "commands", `${mode}.md`)
+          (mode) => path50.join(rootDir, ".cursor", "commands", `${mode}.md`)
         ),
         [MODE_FILE_MANAGED_MARKER]
       )
@@ -26725,7 +26892,7 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (platform === "codex") {
-    const hasBlock2 = await fileHasManagedBlock(path49.join(rootDir, "AGENTS.md"));
+    const hasBlock2 = await fileHasManagedBlock(path50.join(rootDir, "AGENTS.md"));
     if (!hasBlock2) {
       return {
         present: false,
@@ -26742,9 +26909,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path49.join(rootDir, ".agents", "skills");
+    const skillsDir = path50.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path50.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -26756,7 +26923,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "zcode") {
     const hasBlock2 = await fileHasManagedBlock(
-      path49.join(rootDir, "AGENTS.md"),
+      path50.join(rootDir, "AGENTS.md"),
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
@@ -26776,9 +26943,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path49.join(rootDir, ".agents", "skills");
+    const skillsDir = path50.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path50.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -26790,7 +26957,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "kimi-code") {
     const hasBlock2 = await fileHasManagedBlock(
-      path49.join(rootDir, "AGENTS.md"),
+      path50.join(rootDir, "AGENTS.md"),
       KIMI_MANCODE_START_MARKER,
       KIMI_MANCODE_END_MARKER
     );
@@ -26810,9 +26977,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const skillsDir = path49.join(rootDir, ".agents", "skills");
+    const skillsDir = path50.join(rootDir, ".agents", "skills");
     const hasSkills = await allManagedSkills(
-      MODE_NAMES.map((mode) => path49.join(skillsDir, mode, "SKILL.md")),
+      MODE_NAMES.map((mode) => path50.join(skillsDir, mode, "SKILL.md")),
       MANCODE_AGENT_SKILL_MARKERS
     );
     return {
@@ -26824,7 +26991,7 @@ async function checkPlatformReadiness(rootDir, platform) {
   }
   if (platform === "qoder") {
     const hasBlock2 = await fileHasManagedBlock(
-      path49.join(rootDir, "AGENTS.md"),
+      path50.join(rootDir, "AGENTS.md"),
       QODER_MANCODE_START_MARKER,
       QODER_MANCODE_END_MARKER
     );
@@ -26844,9 +27011,9 @@ async function checkPlatformReadiness(rootDir, platform) {
         readyDetail: "managed block present"
       };
     }
-    const commandsDir = path49.join(rootDir, ".qoder", "commands");
+    const commandsDir = path50.join(rootDir, ".qoder", "commands");
     const hasCommands = await allManagedSkills(
-      MODE_NAMES.map((mode) => path49.join(commandsDir, `${mode}.md`)),
+      MODE_NAMES.map((mode) => path50.join(commandsDir, `${mode}.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -26856,8 +27023,42 @@ async function checkPlatformReadiness(rootDir, platform) {
       readyDetail: hasCommands ? "managed block and commands present" : "mode commands are missing, incomplete, or user-authored"
     };
   }
+  if (platform === "dsh") {
+    const hasBlock2 = await fileHasManagedBlock(
+      path50.join(rootDir, "AGENTS.md"),
+      DSH_MANCODE_START_MARKER,
+      DSH_MANCODE_END_MARKER
+    );
+    if (!hasBlock2) {
+      return {
+        present: false,
+        ready: false,
+        target: "AGENTS.md",
+        readyDetail: "managed block missing"
+      };
+    }
+    if (await isPlatformMinimal(rootDir, "dsh")) {
+      return {
+        present: true,
+        ready: true,
+        target: "AGENTS.md",
+        readyDetail: "managed block present"
+      };
+    }
+    const skillsDir = path50.join(rootDir, ".dsh", "skills");
+    const hasSkills = await allManagedSkills(
+      MODE_NAMES.map((mode) => path50.join(skillsDir, mode, "SKILL.md")),
+      MANCODE_DSH_SKILL_MARKERS
+    );
+    return {
+      present: true,
+      ready: hasSkills,
+      target: "AGENTS.md + .dsh/skills/",
+      readyDetail: hasSkills ? "managed block and skills present" : "mode skills are missing, incomplete, or user-authored"
+    };
+  }
   const hasBlock = await fileHasManagedBlock(
-    path49.join(rootDir, ".github", "copilot-instructions.md")
+    path50.join(rootDir, ".github", "copilot-instructions.md")
   );
   if (!hasBlock) {
     return {
@@ -26868,9 +27069,9 @@ async function checkPlatformReadiness(rootDir, platform) {
     };
   }
   if (!await isPlatformMinimal(rootDir, "copilot")) {
-    const promptsDir = path49.join(rootDir, ".github", "prompts");
+    const promptsDir = path50.join(rootDir, ".github", "prompts");
     const hasPrompts = await allManagedSkills(
-      MODE_NAMES.map((mode) => path49.join(promptsDir, `${mode}.prompt.md`)),
+      MODE_NAMES.map((mode) => path50.join(promptsDir, `${mode}.prompt.md`)),
       [MODE_FILE_MANAGED_MARKER]
     );
     return {
@@ -26903,13 +27104,13 @@ async function allManagedSkills(paths, markers) {
 async function claudeFullContentReady(rootDir) {
   const skillChecks = MVP2_SKILLS.map(
     (skill) => fileMatches(
-      path49.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
+      path50.join(rootDir, ".claude", "skills", skill.name, "SKILL.md"),
       (content) => isGeneratedClaudeSkill(content, skill.name)
     )
   );
   const agentChecks = ALL_AGENTS.map(
     (agent) => fileMatches(
-      path49.join(rootDir, ".claude", "agents", `${agent.name}.md`),
+      path50.join(rootDir, ".claude", "agents", `${agent.name}.md`),
       (content) => isGeneratedClaudeAgent(content, agent.name)
     )
   );
@@ -26937,7 +27138,7 @@ async function fileHasAnyMarker(filePath, needles) {
 async function isPlatformMinimal(rootDir, platform) {
   try {
     const raw = await fs.readFile(
-      path49.join(rootDir, ".mancode", "config.json"),
+      path50.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -26959,7 +27160,7 @@ async function fileHasManagedBlock(filePath, startMarker = DEFAULT_MANCODE_START
 async function claudeHooksRegistered(rootDir) {
   try {
     const raw = await fs.readFile(
-      path49.join(rootDir, ".claude", "settings.json"),
+      path50.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -27002,7 +27203,7 @@ function isRecord7(value) {
 // src/system/detect-team.ts
 import { execFile as execFile6 } from "child_process";
 import { access as access2 } from "fs/promises";
-import path50 from "path";
+import path51 from "path";
 import process3 from "process";
 import { promisify as promisify6 } from "util";
 var execFileAsync = promisify6(execFile6);
@@ -27112,7 +27313,7 @@ async function anyPathExists(projectRoot, candidates) {
   const results = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access2(path50.join(projectRoot, candidate));
+        await access2(path51.join(projectRoot, candidate));
         return true;
       } catch {
         return false;
@@ -27153,7 +27354,7 @@ async function detectSystemDeps(env = process4.env) {
 // src/system/init-onboarding.ts
 import { execFileSync } from "child_process";
 import { promises as fs2 } from "fs";
-import path51 from "path";
+import path52 from "path";
 import process5 from "process";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
@@ -27256,9 +27457,10 @@ async function detectPlatformHints(rootDir, environment = process5.env) {
   if (environment.CURSOR_TRACE_ID) hints.add("cursor");
   if (environment.COPILOT_AGENT || environment.GITHUB_COPILOT)
     hints.add("copilot");
+  if (environment.DSH_SHELL === "1") hints.add("dsh");
   const exists2 = async (relative) => {
     try {
-      await fs2.access(path51.join(rootDir, relative));
+      await fs2.access(path52.join(rootDir, relative));
       return true;
     } catch {
       return false;
@@ -27268,6 +27470,7 @@ async function detectPlatformHints(rootDir, environment = process5.env) {
   if (await exists2(".cursor")) hints.add("cursor");
   if (await exists2(".github/copilot-instructions.md")) hints.add("copilot");
   if (await exists2(".qoder")) hints.add("qoder");
+  if (await exists2(".dsh")) hints.add("dsh");
   return ALL_PLATFORMS.filter((platform) => hints.has(platform));
 }
 function createTerminalPrompter() {
@@ -27335,7 +27538,7 @@ function createTerminalPrompter() {
 
 // src/system/scan-aesthetics.ts
 import { promises as fs3 } from "fs";
-import path52 from "path";
+import path53 from "path";
 var MAX_COMPONENT_SCAN_DEPTH = 12;
 var MAX_COMPONENT_FILES = 2e3;
 async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
@@ -27371,7 +27574,7 @@ async function scanAesthetics(projectRoot, uiLibrary = null, scopeRoot = ".") {
   } else if (await hasTailwindDep(projectRoot) || uiLibrary) {
     matchLevel = "low";
   }
-  if (uiLibrary && await pathExists5(path52.join(projectRoot, "package.json"))) {
+  if (uiLibrary && await pathExists5(path53.join(projectRoot, "package.json"))) {
     sourceFiles.push("package.json");
   }
   sourceFiles.push(...cssScan.sourceFiles);
@@ -27397,7 +27600,7 @@ async function findTailwindConfig(projectRoot) {
     "tailwind.config.mjs"
   ];
   for (const name of candidates) {
-    const absPath = path52.join(projectRoot, name);
+    const absPath = path53.join(projectRoot, name);
     if (await pathExists5(absPath)) {
       return { absPath, relPath: name };
     }
@@ -27624,7 +27827,7 @@ async function scanComponents(projectRoot) {
   const names = /* @__PURE__ */ new Set();
   let visitedFiles = 0;
   for (const relRoot of roots) {
-    const absRoot = path52.join(projectRoot, relRoot);
+    const absRoot = path53.join(projectRoot, relRoot);
     if (!await pathExists5(absRoot)) continue;
     visitedFiles = await collectComponentNames(absRoot, names, 0, visitedFiles);
     if (visitedFiles >= MAX_COMPONENT_FILES) break;
@@ -27644,7 +27847,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
   }
   for (const entry of entries) {
     if (fileCount >= MAX_COMPONENT_FILES) return fileCount;
-    const abs = path52.join(dir, entry);
+    const abs = path53.join(dir, entry);
     let info;
     try {
       info = await fs3.lstat(abs);
@@ -27665,7 +27868,7 @@ async function collectComponentNames(dir, names, depth, visitedFiles) {
       ""
     );
     if (base === "index") {
-      base = path52.basename(dir);
+      base = path53.basename(dir);
     }
     if (base.startsWith(".")) continue;
     const componentName = toPascalCase(base);
@@ -27687,7 +27890,7 @@ async function scanCssVariables(projectRoot) {
   const variables = {};
   const sourceFiles = [];
   for (const relPath of candidates) {
-    const absPath = path52.join(projectRoot, relPath);
+    const absPath = path53.join(projectRoot, relPath);
     if (!await pathExists5(absPath)) continue;
     const content = await fs3.readFile(absPath, "utf-8");
     const found = extractCssVariables(content);
@@ -27733,7 +27936,7 @@ function toPascalCase(value) {
 async function hasTailwindDep(projectRoot) {
   try {
     const raw = await fs3.readFile(
-      path52.join(projectRoot, "package.json"),
+      path53.join(projectRoot, "package.json"),
       "utf-8"
     );
     const pkg = JSON.parse(raw);
@@ -27758,15 +27961,15 @@ async function pathExists5(p) {
 
 // src/context/greenfield-init.ts
 import {
-  lstat as lstat20,
+  lstat as lstat21,
   mkdir as mkdir35,
   readFile as readFile39,
-  rename as rename11,
-  rm as rm19,
-  writeFile as writeFile42
+  rename as rename12,
+  rm as rm20,
+  writeFile as writeFile43
 } from "fs/promises";
-import path53 from "path";
-var JOURNAL_RELATIVE_DIRECTORY = path53.join(
+import path54 from "path";
+var JOURNAL_RELATIVE_DIRECTORY = path54.join(
   "local",
   "runtime",
   "initialization"
@@ -27815,7 +28018,7 @@ async function stageGreenfieldInitialization(input) {
     operationId: normalized.operationId,
     workspaceId: normalized.workspaceId,
     state: "staged",
-    stagingDirectoryName: path53.basename(stagingRoot),
+    stagingDirectoryName: path54.basename(stagingRoot),
     targetDirectoryName: ".mancode",
     manifestDigest: digestCanonicalJson(manifest),
     configDigest: digestCanonicalJson(config),
@@ -27846,7 +28049,7 @@ async function stageGreenfieldInitialization(input) {
   return journal;
 }
 async function publishGreenfieldInitialization(input) {
-  const root = path53.resolve(input.projectRoot);
+  const root = path54.resolve(input.projectRoot);
   assertUlid(input.operationId, "greenfield operationId");
   const stagingRoot = greenfieldStagingPath(root, input.operationId);
   const targetRoot = greenfieldTargetPath(root);
@@ -27864,7 +28067,7 @@ async function publishGreenfieldInitialization(input) {
   if (await lstatOrNull4(targetRoot) !== null) {
     throw new Error("MANCODE_V3_TARGET_EXISTS");
   }
-  await rename11(stagingRoot, targetRoot);
+  await rename12(stagingRoot, targetRoot);
   throwIfOperationCrashInjected("greenfield_initialize", "publish-v3-root");
   return finishPublishedInitialization(
     { ...input, projectRoot: root },
@@ -27881,10 +28084,10 @@ async function initializeGreenfield(input, publication) {
 }
 function greenfieldStagingPath(projectRoot, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path53.join(path53.resolve(projectRoot), `.mancode.init-${operationId}`);
+  return path54.join(path54.resolve(projectRoot), `.mancode.init-${operationId}`);
 }
 function greenfieldTargetPath(projectRoot) {
-  return path53.join(path53.resolve(projectRoot), ".mancode");
+  return path54.join(path54.resolve(projectRoot), ".mancode");
 }
 function parseGreenfieldInitializationJournal(value) {
   assertRecord(value, "greenfield initialization journal");
@@ -28020,7 +28223,7 @@ async function finishPublishedInitialization(input, stagedJournal) {
     activatedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
   };
   assertSchemaManifestTransition(manifest, activeManifest);
-  await writeJson(path53.join(targetRoot, "schema.json"), activeManifest);
+  await writeJson(path54.join(targetRoot, "schema.json"), activeManifest);
   throwIfOperationCrashInjected(
     "greenfield_initialize",
     "activate-v3-manifest"
@@ -28036,45 +28239,45 @@ async function finishPublishedInitialization(input, stagedJournal) {
 }
 async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, projectFacts, journal) {
   await Promise.all([
-    mkdir35(path53.join(stagingRoot, "shared", "context"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "shared", "memory", "decisions"), {
+    mkdir35(path54.join(stagingRoot, "shared", "context"), { recursive: true }),
+    mkdir35(path54.join(stagingRoot, "shared", "memory", "decisions"), {
       recursive: true
     }),
-    mkdir35(path53.join(stagingRoot, "shared", "team", "actors"), {
+    mkdir35(path54.join(stagingRoot, "shared", "team", "actors"), {
       recursive: true
     }),
-    mkdir35(path53.join(stagingRoot, "shared", "team", "handoffs"), {
+    mkdir35(path54.join(stagingRoot, "shared", "team", "handoffs"), {
       recursive: true
     }),
-    mkdir35(path53.join(stagingRoot, "shared", "team", "events"), {
+    mkdir35(path54.join(stagingRoot, "shared", "team", "events"), {
       recursive: true
     }),
-    mkdir35(path53.join(stagingRoot, "shared", "team", "transport"), {
+    mkdir35(path54.join(stagingRoot, "shared", "team", "transport"), {
       recursive: true
     }),
-    mkdir35(path53.join(stagingRoot, "local", "sessions"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
+    mkdir35(path54.join(stagingRoot, "local", "sessions"), { recursive: true }),
+    mkdir35(path54.join(stagingRoot, JOURNAL_RELATIVE_DIRECTORY), {
       recursive: true
     }),
-    mkdir35(path53.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "local", "quarantine"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "local", "publish"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "local", "cache"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
+    mkdir35(path54.join(stagingRoot, "local", "workflows"), { recursive: true }),
+    mkdir35(path54.join(stagingRoot, "local", "quarantine"), { recursive: true }),
+    mkdir35(path54.join(stagingRoot, "local", "publish"), { recursive: true }),
+    mkdir35(path54.join(stagingRoot, "local", "cache"), { recursive: true }),
+    mkdir35(path54.join(stagingRoot, "runtime", "non-git", journal.workspaceId), {
       recursive: true
     })
   ]);
   await Promise.all([
-    writeJson(path53.join(stagingRoot, "schema.json"), manifest),
-    writeJson(path53.join(stagingRoot, "shared", "config.json"), config),
-    writeJson(path53.join(stagingRoot, "shared", "team", "policy.json"), policy),
+    writeJson(path54.join(stagingRoot, "schema.json"), manifest),
+    writeJson(path54.join(stagingRoot, "shared", "config.json"), config),
+    writeJson(path54.join(stagingRoot, "shared", "team", "policy.json"), policy),
     writeJson(
-      path53.join(stagingRoot, "shared", "context", "project.json"),
+      path54.join(stagingRoot, "shared", "context", "project.json"),
       projectFacts
     ),
     writeJson(journalPath2(stagingRoot, journal.operationId), journal),
-    writeFile42(
-      path53.join(stagingRoot, ".gitignore"),
+    writeFile43(
+      path54.join(stagingRoot, ".gitignore"),
       `${V3_IGNORE.join("\n")}
 `,
       { encoding: "utf8", flag: "wx" }
@@ -28099,7 +28302,7 @@ async function readGreenfieldJournal(root, operationId) {
 async function readManifest(root) {
   try {
     return parseSchemaManifest(
-      JSON.parse(await readFile39(path53.join(root, "schema.json"), "utf8"))
+      JSON.parse(await readFile39(path54.join(root, "schema.json"), "utf8"))
     );
   } catch (error) {
     if (error instanceof SyntaxError || isNotFound29(error)) {
@@ -28137,7 +28340,7 @@ async function readConfig(root) {
   try {
     config = parseProjectConfig(
       JSON.parse(
-        await readFile39(path53.join(root, "shared", "config.json"), "utf8")
+        await readFile39(path54.join(root, "shared", "config.json"), "utf8")
       )
     );
   } catch (error) {
@@ -28154,7 +28357,7 @@ async function readPolicy(root) {
     policy = parseTeamPolicy(
       JSON.parse(
         await readFile39(
-          path53.join(root, "shared", "team", "policy.json"),
+          path54.join(root, "shared", "team", "policy.json"),
           "utf8"
         )
       )
@@ -28172,7 +28375,7 @@ async function readProjectFactsAt(root) {
     return parseProjectFacts(
       JSON.parse(
         await readFile39(
-          path53.join(root, "shared", "context", "project.json"),
+          path54.join(root, "shared", "context", "project.json"),
           "utf8"
         )
       )
@@ -28211,7 +28414,7 @@ function normalizeInput(input) {
   parseSchemaManifest(manifest);
   return {
     ...input,
-    projectRoot: path53.resolve(input.projectRoot),
+    projectRoot: path54.resolve(input.projectRoot),
     projectConfig: config,
     teamPolicy: policy,
     projectFacts: input.projectFacts === void 0 ? void 0 : parseProjectFacts(input.projectFacts)
@@ -28309,21 +28512,21 @@ function initializationProjectFacts(input, now) {
 }
 function journalPath2(root, operationId) {
   assertUlid(operationId, "greenfield operationId");
-  return path53.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
+  return path54.join(root, JOURNAL_RELATIVE_DIRECTORY, `${operationId}.json`);
 }
 async function writeJson(target, value) {
-  const directory = path53.dirname(target);
+  const directory = path54.dirname(target);
   await mkdir35(directory, { recursive: true });
-  const temporary = path53.join(
+  const temporary = path54.join(
     directory,
-    `.${path53.basename(target)}.${process.pid}.${Date.now()}.tmp`
+    `.${path54.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile42(temporary, `${JSON.stringify(value, null, 2)}
+  await writeFile43(temporary, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
   });
-  await rename11(temporary, target);
+  await rename12(temporary, target);
 }
 function parseDigest6(value, label) {
   if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value)) {
@@ -28342,7 +28545,7 @@ function isState(value) {
 }
 async function lstatOrNull4(target) {
   try {
-    return await lstat20(target);
+    return await lstat21(target);
   } catch (error) {
     if (isNotFound29(error)) return null;
     throw error;
@@ -28436,9 +28639,9 @@ async function init(rootDir = process6.cwd(), options = {}) {
     return EXIT_INIT_FAILED;
   }
   const authority = resolveInitAuthority(options);
-  const mancodeDir = path54.join(rootDir, ".mancode");
-  const stateFile = path54.join(mancodeDir, "state.json");
-  const v3SchemaFile = path54.join(mancodeDir, "schema.json");
+  const mancodeDir = path55.join(rootDir, ".mancode");
+  const stateFile = path55.join(mancodeDir, "state.json");
+  const v3SchemaFile = path55.join(mancodeDir, "schema.json");
   const wasInitialized = await pathExists6(stateFile);
   let mutationSnapshots = [];
   let directorySnapshots = [];
@@ -28506,11 +28709,15 @@ async function init(rootDir = process6.cwd(), options = {}) {
     }
     return initializeV3(rootDir, options);
   }
-  const isGitRepo = await pathExists6(path54.join(rootDir, ".git"));
-  const hasManifest = await hasProjectManifest(rootDir);
+  const genericSafety = await canInitializeGenericProject(rootDir);
+  if (!genericSafety.ok && genericSafety.reason === "unsafe") {
+    printNotProjectDirectory(rootDir, locale, "unsafe");
+    return EXIT_NOT_A_PROJECT_DIR;
+  }
+  const isGitRepo = await pathExists6(path55.join(rootDir, ".git"));
+  const hasEvidence = await hasProjectEvidence(rootDir);
   let isGenericProject = false;
-  if (!isGitRepo && !hasManifest) {
-    const genericSafety = await canInitializeGenericProject(rootDir);
+  if (!isGitRepo && !hasEvidence) {
     if (!genericSafety.ok && !(wasInitialized && genericSafety.reason === "nonempty")) {
       printNotProjectDirectory(rootDir, locale, genericSafety.reason);
       return EXIT_NOT_A_PROJECT_DIR;
@@ -28564,12 +28771,12 @@ async function init(rootDir = process6.cwd(), options = {}) {
       if (uiLibrary) {
         console.log(`   UI: ${uiLibraryStr}`);
       }
-    } else if (hasManifest) {
+    } else if (hasEvidence) {
       console.log(
         localize(
           locale,
-          "   \u5DF2\u53D1\u73B0\u9879\u76EE manifest\uFF0C\u672A\u8BC6\u522B\u5230\u6846\u67B6\u4F9D\u8D56",
-          "   Project manifest found; no known framework dependencies"
+          "   \u5DF2\u53D1\u73B0\u9879\u76EE\u6E90\u7801\uFF0C\u672A\u8BC6\u522B\u5230\u6846\u67B6\u4F9D\u8D56",
+          "   Project source found; no known framework dependencies"
         )
       );
     } else {
@@ -28624,8 +28831,8 @@ async function init(rootDir = process6.cwd(), options = {}) {
     const managedFiles = getInitManagedFilePaths(rootDir, selectedPlatforms);
     mutationSnapshots = await snapshotFiles(managedFiles);
     directorySnapshots = await snapshotDirectories(managedFiles, [
-      path54.join(mancodeDir, "workflows"),
-      path54.join(mancodeDir, "preseason-reports")
+      path55.join(mancodeDir, "workflows"),
+      path55.join(mancodeDir, "preseason-reports")
     ]);
     const team = await detectTeamStatus(rootDir);
     const platformMinimal = Object.fromEntries(
@@ -28686,7 +28893,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
 `;
     await fs4.writeFile(stateFile, stateContent, "utf-8");
     await fs4.writeFile(
-      path54.join(mancodeDir, "project-profile.json"),
+      path55.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(profile, null, 2)}
 `,
       "utf-8"
@@ -28723,7 +28930,7 @@ async function init(rootDir = process6.cwd(), options = {}) {
         )
       );
       const tokens = await scanAesthetics(rootDir, uiLibrary);
-      const tokensPath = path54.join(
+      const tokensPath = path55.join(
         mancodeDir,
         "aesthetics",
         "style-tokens.json"
@@ -28887,7 +29094,7 @@ async function initializeV3(rootDir, options) {
     );
     return EXIT_INIT_FAILED;
   }
-  const schemaPath = path54.join(rootDir, ".mancode", "schema.json");
+  const schemaPath = path55.join(rootDir, ".mancode", "schema.json");
   let existingV3 = false;
   let registeredAdapters = /* @__PURE__ */ new Set();
   if (await pathExists6(schemaPath)) {
@@ -28990,7 +29197,7 @@ function printV3InitError(error) {
   }
 }
 async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms) {
-  const configPath = path54.join(mancodeDir, "config.json");
+  const configPath = path55.join(mancodeDir, "config.json");
   let config = {};
   try {
     config = JSON.parse(await fs4.readFile(configPath, "utf-8"));
@@ -29023,7 +29230,7 @@ async function updateConfigOptions(mancodeDir, patch, preserveInstalledPlatforms
 async function readExistingInitPreferences(mancodeDir) {
   try {
     const config = JSON.parse(
-      await fs4.readFile(path54.join(mancodeDir, "config.json"), "utf-8")
+      await fs4.readFile(path55.join(mancodeDir, "config.json"), "utf-8")
     );
     const preferences = {
       platforms: Array.isArray(config.platforms) ? config.platforms.filter(
@@ -29087,15 +29294,9 @@ async function selectInitPlatforms(input) {
   }
   return [DEFAULT_INIT_PLATFORM];
 }
-async function hasProjectManifest(rootDir) {
-  for (const name of PROJECT_MANIFESTS) {
-    if (await pathExists6(path54.join(rootDir, name))) return true;
-  }
-  return false;
-}
 async function canInitializeGenericProject(rootDir) {
-  const resolved = path54.resolve(rootDir);
-  if (resolved === path54.parse(resolved).root || resolved === path54.resolve(os.homedir())) {
+  const resolved = path55.resolve(rootDir);
+  if (resolved === path55.parse(resolved).root || resolved === path55.resolve(os.homedir())) {
     return { ok: false, reason: "unsafe" };
   }
   try {
@@ -29109,14 +29310,18 @@ async function canInitializeGenericProject(rootDir) {
   }
 }
 async function validateV3CliProjectBoundary(rootDir, options, locale, legacyInitialized) {
-  const isGitRepo = await pathExists6(path54.join(rootDir, ".git"));
-  const hasManifest = await hasProjectManifest(rootDir);
-  if (isGitRepo || hasManifest) return null;
+  const genericSafety = await canInitializeGenericProject(rootDir);
+  if (!genericSafety.ok && genericSafety.reason === "unsafe") {
+    printNotProjectDirectory(rootDir, locale, "unsafe");
+    return EXIT_NOT_A_PROJECT_DIR;
+  }
+  const isGitRepo = await pathExists6(path55.join(rootDir, ".git"));
+  const hasEvidence = await hasProjectEvidence(rootDir);
+  if (isGitRepo || hasEvidence) return null;
   const v3Initialized = await pathExists6(
-    path54.join(rootDir, ".mancode", "schema.json")
+    path55.join(rootDir, ".mancode", "schema.json")
   );
   const legacyAuthorityPresent = legacyInitialized || (await scanLegacyAuthority(rootDir)).authorityPresent;
-  const genericSafety = await canInitializeGenericProject(rootDir);
   if (!genericSafety.ok && !((legacyAuthorityPresent || v3Initialized) && genericSafety.reason === "nonempty")) {
     printNotProjectDirectory(rootDir, locale, genericSafety.reason);
     return EXIT_NOT_A_PROJECT_DIR;
@@ -29137,7 +29342,7 @@ function printNotProjectDirectory(rootDir, locale, reason) {
       console.error("   \u4E3A\u907F\u514D\u8BEF\u5199\uFF0C\u4E0D\u80FD\u5728 Home \u76EE\u5F55\u6216\u78C1\u76D8\u6839\u76EE\u5F55\u521D\u59CB\u5316\u3002");
     } else if (reason === "nonempty") {
       console.error(
-        "   \u672A\u8BC6\u522B\u5230\u9879\u76EE\u6587\u4EF6\uFF0C\u4E14\u76EE\u5F55\u4E2D\u5DF2\u6709\u6587\u4EF6\u3002\u8BF7\u5148\u8FDB\u5165\u9879\u76EE\u76EE\u5F55\u3002"
+        "   \u672A\u8BC6\u522B\u5230\u9876\u5C42\u9879\u76EE\u6E05\u5355\u3001\u6E90\u7801\u6587\u4EF6\u6216\u6E90\u7801\u76EE\u5F55\u3002\u8BF7\u5148\u8FDB\u5165\u5B9E\u9645\u9879\u76EE\u6839\u76EE\u5F55\u3002"
       );
     } else {
       console.error(
@@ -29153,7 +29358,7 @@ function printNotProjectDirectory(rootDir, locale, reason) {
     );
   } else if (reason === "nonempty") {
     console.error(
-      "   No project files were detected and the directory is not empty."
+      "   No top-level manifest, source file, or source directory was detected."
     );
   } else {
     console.error(
@@ -29238,6 +29443,12 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.qoder/commands/${mode}.md`);
     }
   }
+  if (platforms.includes("dsh")) {
+    files.push("AGENTS.md");
+    for (const mode of MODE_NAMES) {
+      files.push(`.dsh/skills/${mode}/SKILL.md`);
+    }
+  }
   if (platforms.includes("copilot")) {
     files.push(
       ".github/copilot-instructions.md",
@@ -29248,7 +29459,7 @@ function getInitManagedFilePaths(rootDir, platforms) {
       files.push(`.github/prompts/${mode}.prompt.md`);
     }
   }
-  return [...new Set(files.map((file) => path54.join(rootDir, file)))];
+  return [...new Set(files.map((file) => path55.join(rootDir, file)))];
 }
 async function snapshotFiles(filePaths) {
   return Promise.all(
@@ -29256,7 +29467,7 @@ async function snapshotFiles(filePaths) {
       try {
         return { filePath, content: await fs4.readFile(filePath, "utf-8") };
       } catch (error) {
-        if (isNodeError6(error) && error.code === "ENOENT") {
+        if (isNodeError7(error) && error.code === "ENOENT") {
           return { filePath, content: null };
         }
         throw error;
@@ -29267,10 +29478,10 @@ async function snapshotFiles(filePaths) {
 async function snapshotDirectories(filePaths, additionalDirectories = []) {
   const directories = new Set(additionalDirectories);
   for (const filePath of filePaths) {
-    let current = path54.dirname(filePath);
-    while (current !== path54.dirname(current)) {
+    let current = path55.dirname(filePath);
+    while (current !== path55.dirname(current)) {
       directories.add(current);
-      current = path54.dirname(current);
+      current = path55.dirname(current);
     }
   }
   return Promise.all(
@@ -29286,7 +29497,7 @@ async function restoreFiles(snapshots) {
       await fs4.rm(snapshot.filePath, { force: true });
       continue;
     }
-    await fs4.mkdir(path54.dirname(snapshot.filePath), { recursive: true });
+    await fs4.mkdir(path55.dirname(snapshot.filePath), { recursive: true });
     await fs4.writeFile(snapshot.filePath, snapshot.content, "utf-8");
   }
 }
@@ -29302,7 +29513,7 @@ async function removeNewEmptyDirectories(snapshots) {
 function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNodeError6(error) {
+function isNodeError7(error) {
   return error instanceof Error && "code" in error;
 }
 function printPlatformCreatedFiles(platform, locale) {
@@ -29347,6 +29558,13 @@ function printPlatformCreatedFiles(platform, locale) {
     console.log("  .qoder/commands/            # Qoder mode commands");
     return;
   }
+  if (platform === "dsh") {
+    console.log(
+      "  AGENTS.md                   # DeepSeek Harness managed block"
+    );
+    console.log("  .dsh/skills/                # DeepSeek Harness mode skills");
+    return;
+  }
   console.log("  .github/copilot-instructions.md # Copilot instructions");
 }
 function localize(locale, chinese, english) {
@@ -29363,15 +29581,15 @@ async function pathExists6(p) {
 
 // src/commands/install.ts
 import { promises as fs5 } from "fs";
-import path55 from "path";
+import path56 from "path";
 import process7 from "process";
 var EXIT_OK3 = 0;
 var EXIT_NOT_INITIALIZED2 = 1;
 var EXIT_UNSUPPORTED_PLATFORM = 2;
 var EXIT_INSTALL_FAILED = 3;
 async function install(rootDir = process7.cwd(), platform = "claude-code", options = {}) {
-  const stateFile = path55.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path55.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path56.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path56.join(rootDir, ".mancode", "schema.json");
   if (await pathExists7(v3SchemaFile)) {
     return installV3(rootDir, platform, options);
   }
@@ -29532,22 +29750,22 @@ function printUnsupportedPlatform(platform) {
   }
 }
 async function readConfig2(rootDir) {
-  const configPath = path55.join(rootDir, ".mancode", "config.json");
+  const configPath = path56.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await fs5.readFile(configPath, "utf-8");
     return { config: JSON.parse(raw), valid: true };
   } catch (err) {
-    if (isNodeError7(err) && err.code === "ENOENT") {
+    if (isNodeError8(err) && err.code === "ENOENT") {
       return { config: {}, valid: false };
     }
     throw err;
   }
 }
-function isNodeError7(err) {
+function isNodeError8(err) {
   return err instanceof Error && "code" in err;
 }
 async function updateConfig(rootDir, config) {
-  const configPath = path55.join(rootDir, ".mancode", "config.json");
+  const configPath = path56.join(rootDir, ".mancode", "config.json");
   const content = `${JSON.stringify(config, null, 2)}
 `;
   await fs5.writeFile(configPath, content, "utf-8");
@@ -29583,7 +29801,7 @@ function readConfiguredMinimal(value, platform) {
 async function readStatePlatform(rootDir) {
   try {
     const raw = await fs5.readFile(
-      path55.join(rootDir, ".mancode", "state.json"),
+      path56.join(rootDir, ".mancode", "state.json"),
       "utf-8"
     );
     const state = JSON.parse(raw);
@@ -29606,11 +29824,11 @@ function isRecord9(value) {
 
 // src/commands/list-platforms.ts
 import { promises as fs6 } from "fs";
-import path56 from "path";
+import path57 from "path";
 import process8 from "process";
 var EXIT_OK4 = 0;
 async function listPlatforms(rootDir = process8.cwd()) {
-  if (await pathExists8(path56.join(rootDir, ".mancode", "schema.json"))) {
+  if (await pathExists8(path57.join(rootDir, ".mancode", "schema.json"))) {
     return listV3Platforms(rootDir);
   }
   const installed = new Set(await readInstalledPlatforms(rootDir));
@@ -29646,7 +29864,7 @@ async function listV3Platforms(rootDir) {
 async function readInstalledPlatforms(rootDir) {
   try {
     const raw = await fs6.readFile(
-      path56.join(rootDir, ".mancode", "config.json"),
+      path57.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -29679,7 +29897,7 @@ function describePlatform(platform) {
 
 // src/commands/manps.ts
 import { access as access4, readFile as readFile41 } from "fs/promises";
-import path58 from "path";
+import path59 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/system/preseason.ts
@@ -29688,14 +29906,14 @@ import { createHash as createHash8 } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
   access as access3,
-  lstat as lstat21,
+  lstat as lstat22,
   mkdir as mkdir36,
   readFile as readFile40,
   readdir as readdir18,
-  rename as rename12,
-  writeFile as writeFile43
+  rename as rename13,
+  writeFile as writeFile44
 } from "fs/promises";
-import path57 from "path";
+import path58 from "path";
 var PRESEASON_AREAS = [
   "all",
   "deps",
@@ -29775,10 +29993,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 ?? path57.join(projectRoot, ".mancode");
-  const reportDir = path57.join(storageRoot, "preseason-reports");
+  const storageRoot = options.storageRoot ?? path58.join(projectRoot, ".mancode");
+  const reportDir = path58.join(storageRoot, "preseason-reports");
   await mkdir36(reportDir, { recursive: true });
-  const issueDbPath = path57.join(storageRoot, "preseason-issues.json");
+  const issueDbPath = path58.join(storageRoot, "preseason-issues.json");
   const reportPath = await allocateReportPath(
     reportDir,
     `${generatedAt.replace(/[:.]/g, "-")}-${normalizedArea}`
@@ -29792,9 +30010,9 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
     issueDbPath
   };
   const database = await buildIssueDatabase(projectRoot, report);
-  await writeFile43(reportPath, renderPreseasonReport(report), "utf-8");
-  await writeFile43(
-    path57.join(storageRoot, "preseason-report.md"),
+  await writeFile44(reportPath, renderPreseasonReport(report), "utf-8");
+  await writeFile44(
+    path58.join(storageRoot, "preseason-report.md"),
     renderPreseasonReport(report),
     "utf-8"
   );
@@ -29802,7 +30020,7 @@ async function runPreseasonScan(projectRoot, area = "all", options = {}) {
   return report;
 }
 async function runPreseasonRemediation(projectRoot, issues, options = {}) {
-  const issueDbPath = options.issueDbPath ?? path57.join(projectRoot, ".mancode", "preseason-issues.json");
+  const issueDbPath = options.issueDbPath ?? path58.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(
@@ -29880,7 +30098,7 @@ async function runPreseasonRemediation(projectRoot, issues, options = {}) {
     write2("   Decision: skipped.");
   }
   database.updatedAt = now;
-  await writeFile43(
+  await writeFile44(
     issueDbPath,
     `${JSON.stringify(database, null, 2)}
 `,
@@ -29912,7 +30130,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 = path57.join(reportDir, `${baseName}${suffix}.md`);
+    const candidate = path58.join(reportDir, `${baseName}${suffix}.md`);
     if (!existsSync(candidate)) return candidate;
   }
   throw new Error(`unable to allocate preseason report path: ${baseName}`);
@@ -29961,18 +30179,18 @@ async function walk(root, current, results, depth) {
   }
   for (const entry of entries) {
     if (IGNORE_DIRS.has(entry)) continue;
-    const abs = path57.join(current, entry);
-    const rel = path57.relative(root, abs);
+    const abs = path58.join(current, entry);
+    const rel = path58.relative(root, abs);
     let info;
     try {
-      info = await lstat21(abs);
+      info = await lstat22(abs);
     } catch {
       continue;
     }
     if (info.isSymbolicLink()) continue;
     if (info.isDirectory()) {
       await walk(root, abs, results, depth + 1);
-    } else if (SOURCE_EXTENSIONS.has(path57.extname(entry)) || entry === "package.json") {
+    } else if (SOURCE_EXTENSIONS.has(path58.extname(entry)) || entry === "package.json") {
       results.push(rel);
       if (results.length >= MAX_PROJECT_FILES) return;
     }
@@ -29980,7 +30198,7 @@ async function walk(root, current, results, depth) {
 }
 async function readPackageJson(projectRoot) {
   try {
-    const raw = await readFile40(path57.join(projectRoot, "package.json"), "utf-8");
+    const raw = await readFile40(path58.join(projectRoot, "package.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -30073,7 +30291,7 @@ function scanTodos(projectRoot, files) {
   const matches = [];
   for (const file of files) {
     if (matches.length >= 7) break;
-    const abs = path57.join(projectRoot, file);
+    const abs = path58.join(projectRoot, file);
     matches.push(...readTodoIssues(abs, file, matches.length));
   }
   return matches.slice(0, 7);
@@ -30114,7 +30332,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 = path57.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
+    const base = path58.basename(file).replace(/\.(ts|tsx|js|jsx)$/, "");
     return !Array.from(tests).some((test) => test.includes(base));
   }).slice(0, 4);
   return missing.map((file, index) => ({
@@ -30123,13 +30341,13 @@ function scanTestGaps(files) {
     type: "tests",
     title: "Core source file has no obvious test",
     file,
-    detail: `No matching test file was found for ${path57.basename(file)}.`,
+    detail: `No matching test file was found for ${path58.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(path57.join(projectRoot, ".gitignore"))) {
+  if (!files.includes(".gitignore") && !pathExistsSync(path58.join(projectRoot, ".gitignore"))) {
     issues.push({
       id: "config-gitignore",
       severity: "P1",
@@ -30140,7 +30358,7 @@ function scanConfig(projectRoot, files) {
       recommendation: "Add a .gitignore that excludes dependencies, build output, coverage, and local env files."
     });
   }
-  if (!files.includes(".editorconfig") && !pathExistsSync(path57.join(projectRoot, ".editorconfig"))) {
+  if (!files.includes(".editorconfig") && !pathExistsSync(path58.join(projectRoot, ".editorconfig"))) {
     issues.push({
       id: "config-editorconfig",
       severity: "P2",
@@ -30159,7 +30377,7 @@ function scanAestheticDrift(projectRoot, files, pkg) {
   for (const file of frontendFiles) {
     let content;
     try {
-      content = readFileSyncSafe(path57.join(projectRoot, file));
+      content = readFileSyncSafe(path58.join(projectRoot, file));
     } catch {
       continue;
     }
@@ -30210,7 +30428,7 @@ function detectedIconSystems(pkg) {
   return systems.filter(([, pattern]) => packages.some((name) => pattern.test(name))).map(([name]) => name);
 }
 async function scanArchitecture(projectRoot) {
-  const localBinary = path57.join(
+  const localBinary = path58.join(
     projectRoot,
     "node_modules",
     ".bin",
@@ -30258,7 +30476,7 @@ async function hasDependencyCruiserConfig(projectRoot) {
     "dependency-cruiser.config.mjs"
   ];
   const results = await Promise.all(
-    files.map((file) => pathExists9(path57.join(projectRoot, file)))
+    files.map((file) => pathExists9(path58.join(projectRoot, file)))
   );
   return results.some(Boolean);
 }
@@ -30364,9 +30582,9 @@ function inferCommands(pkg) {
   return ["lint", "test", "build"].filter((name) => scripts[name]).map((name) => `npm run ${name}`);
 }
 async function buildIssueDatabase(projectRoot, report) {
-  const reportRef = path57.relative(projectRoot, report.reportPath);
+  const reportRef = path58.relative(projectRoot, report.reportPath);
   const run = {
-    id: path57.basename(report.reportPath, ".md"),
+    id: path58.basename(report.reportPath, ".md"),
     generatedAt: report.generatedAt,
     area: report.area,
     reportPath: reportRef,
@@ -30410,7 +30628,7 @@ async function readIssueDatabase(issueDbPath) {
   try {
     raw = await readFile40(issueDbPath, "utf-8");
   } catch (err) {
-    if (isNodeError8(err) && err.code === "ENOENT") {
+    if (isNodeError9(err) && err.code === "ENOENT") {
       return emptyIssueDatabase();
     }
     throw err;
@@ -30429,9 +30647,9 @@ async function readIssueDatabase(issueDbPath) {
 }
 async function writeJsonAtomic3(file, value) {
   const tmp = `${file}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  await writeFile43(tmp, `${JSON.stringify(value, null, 2)}
+  await writeFile44(tmp, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
-  await rename12(tmp, file);
+  await rename13(tmp, file);
 }
 function emptyIssueDatabase() {
   return {
@@ -30472,20 +30690,20 @@ function compareIssueRecords(a, b) {
 }
 async function applySafeRemediation(projectRoot, issue) {
   if (issue.id === "config-gitignore" && issue.file === ".gitignore") {
-    const gitignorePath = path57.join(projectRoot, ".gitignore");
+    const gitignorePath = path58.join(projectRoot, ".gitignore");
     if (pathExistsSync(gitignorePath)) {
       return { applied: false };
     }
-    await writeFile43(gitignorePath, `${DEFAULT_GITIGNORE}
+    await writeFile44(gitignorePath, `${DEFAULT_GITIGNORE}
 `, "utf-8");
     return { applied: true, action: "created .gitignore" };
   }
   if (issue.id === "config-editorconfig" && issue.file === ".editorconfig") {
-    const editorconfigPath = path57.join(projectRoot, ".editorconfig");
+    const editorconfigPath = path58.join(projectRoot, ".editorconfig");
     if (pathExistsSync(editorconfigPath)) {
       return { applied: false };
     }
-    await writeFile43(editorconfigPath, `${DEFAULT_EDITORCONFIG}
+    await writeFile44(editorconfigPath, `${DEFAULT_EDITORCONFIG}
 `, "utf-8");
     return { applied: true, action: "created .editorconfig" };
   }
@@ -30521,7 +30739,7 @@ async function inferSafePackageScript(projectRoot, scriptName) {
   }
 }
 async function addPackageScript(projectRoot, scriptName, script) {
-  const packagePath = path57.join(projectRoot, "package.json");
+  const packagePath = path58.join(projectRoot, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(await readFile40(packagePath, "utf-8"));
@@ -30534,7 +30752,7 @@ async function addPackageScript(projectRoot, scriptName, script) {
     ...scripts,
     [scriptName]: script
   };
-  await writeFile43(packagePath, `${JSON.stringify(pkg, null, 2)}
+  await writeFile44(packagePath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
   return true;
 }
@@ -30621,7 +30839,7 @@ async function pathExists9(file) {
     return false;
   }
 }
-function isNodeError8(err) {
+function isNodeError9(err) {
   return err instanceof Error && "code" in err;
 }
 function isRecord10(value) {
@@ -30634,7 +30852,7 @@ var EXIT_NOT_INITIALIZED3 = 1;
 var EXIT_SCAN_FAILED = 2;
 var EXIT_INVALID_ARG = 3;
 async function manps(rootDir, area = "all", options = {}) {
-  const v3SchemaPath = path58.join(rootDir, ".mancode", "schema.json");
+  const v3SchemaPath = path59.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}`;
@@ -30647,7 +30865,7 @@ async function manps(rootDir, area = "all", options = {}) {
     return EXIT_SCAN_FAILED;
   }
   const v3Initialized = v3Activation === "v3_active";
-  const initialized = v3Initialized || await pathExists10(path58.join(rootDir, ".mancode", "state.json"));
+  const initialized = v3Initialized || await pathExists10(path59.join(rootDir, ".mancode", "state.json"));
   if (!initialized) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
@@ -30660,7 +30878,7 @@ async function manps(rootDir, area = "all", options = {}) {
   let report;
   try {
     report = await runPreseasonScan(rootDir, area, {
-      storageRoot: v3Initialized ? path58.join(rootDir, ".mancode", "local") : void 0
+      storageRoot: v3Initialized ? path59.join(rootDir, ".mancode", "local") : void 0
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -30729,8 +30947,8 @@ async function manps(rootDir, area = "all", options = {}) {
   console.log(
     `Issues:   ${report.issues.length} total (P0 ${p0}, P1 ${p1}, P2 ${p2})`
   );
-  console.log(`Report:   ${path58.relative(rootDir, report.reportPath)}`);
-  console.log(`Issue DB: ${path58.relative(rootDir, report.issueDbPath)}`);
+  console.log(`Report:   ${path59.relative(rootDir, report.reportPath)}`);
+  console.log(`Issue DB: ${path59.relative(rootDir, report.issueDbPath)}`);
   if (report.issues.length > 0) {
     console.log("");
     for (const issue of report.issues.slice(0, 7)) {
@@ -30746,7 +30964,7 @@ async function manps(rootDir, area = "all", options = {}) {
     console.log(`  Skipped:  ${remediation.skipped}`);
     console.log(`  Fixed:    ${remediation.fixed}`);
     console.log(
-      `  Issue DB: ${path58.relative(rootDir, remediation.issueDbPath)}`
+      `  Issue DB: ${path59.relative(rootDir, remediation.issueDbPath)}`
     );
   }
   return EXIT_OK5;
@@ -30817,7 +31035,7 @@ async function readV3ActivationState(schemaPath) {
 
 // src/commands/migrate.ts
 import { readFile as readFile42 } from "fs/promises";
-import path59 from "path";
+import path60 from "path";
 var EXIT_OK6 = 0;
 var EXIT_INVALID_ARG2 = 2;
 var EXIT_MIGRATION_BLOCKED = 3;
@@ -30943,9 +31161,9 @@ async function readScopeFile(rootDir, file) {
   if (!file.trim() || file.includes("\0")) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
-  const resolved = path59.resolve(rootDir, file);
-  const relative = path59.relative(path59.resolve(rootDir), resolved);
-  if (relative === ".." || relative.startsWith(`..${path59.sep}`) || path59.isAbsolute(relative)) {
+  const resolved = path60.resolve(rootDir, file);
+  const relative = path60.relative(path60.resolve(rootDir), resolved);
+  if (relative === ".." || relative.startsWith(`..${path60.sep}`) || path60.isAbsolute(relative)) {
     throw new Error("MANCODE_MIGRATION_SCOPE_FILE_INVALID");
   }
   try {
@@ -31050,12 +31268,12 @@ async function runOperationMutation(rootDir, operationId, options, mode) {
 }
 
 // src/context/project-policy-upgrade.ts
-import { lstat as lstat22, mkdir as mkdir37, readFile as readFile43, rm as rm20, writeFile as writeFile44 } from "fs/promises";
-import path60 from "path";
+import { lstat as lstat23, mkdir as mkdir37, readFile as readFile43, rm as rm21, writeFile as writeFile45 } from "fs/promises";
+import path61 from "path";
 var UPGRADE_OPERATION = "project_policy_upgrade";
 async function dryRunProjectPolicyUpgrade(input) {
   assertPolicyVersion(input.policyVersion);
-  const root = path60.resolve(input.projectRoot);
+  const root = path61.resolve(input.projectRoot);
   const project = await new V3ContextStore(root).readProjectSnapshot();
   const beforeDigest = digestManifest(project.manifest);
   const now = input.now ?? /* @__PURE__ */ new Date();
@@ -31099,7 +31317,7 @@ async function dryRunProjectPolicyUpgrade(input) {
 async function upgradeProjectPolicy(input) {
   assertPolicyVersion(input.policyVersion);
   assertUlid(input.sessionId, "project policy upgrade sessionId");
-  const root = path60.resolve(input.projectRoot);
+  const root = path61.resolve(input.projectRoot);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const operationId = input.operationId;
   if (operationId === void 0) {
@@ -31353,24 +31571,24 @@ function buildV2Manifest(manifest, operationId) {
   return candidate;
 }
 async function readSchemaContent(root) {
-  return readFile43(path60.join(root, ".mancode", "schema.json"), "utf8");
+  return readFile43(path61.join(root, ".mancode", "schema.json"), "utf8");
 }
 async function writeSchemaContent(root, operationId, content) {
-  const directory = path60.join(root, ".mancode");
-  const target = path60.join(directory, "schema.json");
-  const stat5 = await lstat22(target);
+  const directory = path61.join(root, ".mancode");
+  const target = path61.join(directory, "schema.json");
+  const stat5 = await lstat23(target);
   if (!stat5.isFile() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
-  const temporary = path60.join(
+  const temporary = path61.join(
     directory,
     `.schema.json.${operationId}.${process.pid}.tmp`
   );
-  await writeFile44(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile45(temporary, content, { encoding: "utf8", flag: "wx" });
   try {
     await replaceFileAtomically(temporary, target);
   } catch (error) {
-    await rm20(temporary, { force: true });
+    await rm21(temporary, { force: true });
     throw error;
   }
 }
@@ -31438,13 +31656,13 @@ async function releaseLocks3(locks) {
   await Promise.allSettled([...locks].reverse().map((lock) => lock.release()));
 }
 function projectUpgradePreviewRoot(root, operationId) {
-  return path60.join(root, ".mancode", "staging", "project-upgrade", operationId);
+  return path61.join(root, ".mancode", "staging", "project-upgrade", operationId);
 }
 async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
   const directory = projectUpgradePreviewRoot(root, receipt.operationId);
-  const receiptPath = path60.join(directory, "preview.json");
-  const manifestPath = path60.join(directory, "schema.json");
-  await mkdir37(path60.dirname(directory), { recursive: true });
+  const receiptPath = path61.join(directory, "preview.json");
+  const manifestPath = path61.join(directory, "schema.json");
+  await mkdir37(path61.dirname(directory), { recursive: true });
   try {
     await mkdir37(directory);
   } catch (error) {
@@ -31454,25 +31672,25 @@ async function stageProjectPolicyUpgrade(root, receipt, manifestContent) {
     throw error;
   }
   try {
-    await writeFile44(receiptPath, `${JSON.stringify(receipt, null, 2)}
+    await writeFile45(receiptPath, `${JSON.stringify(receipt, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
-    await writeFile44(manifestPath, manifestContent, {
+    await writeFile45(manifestPath, manifestContent, {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
-    await rm20(directory, { recursive: true, force: true });
+    await rm21(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(path60.join(directory, "preview.json")),
-    readSafePreviewFile(path60.join(directory, "schema.json"))
+    readSafePreviewFile(path61.join(directory, "preview.json")),
+    readSafePreviewFile(path61.join(directory, "schema.json"))
   ]);
   let receipt;
   try {
@@ -31495,7 +31713,7 @@ async function assertProjectPolicyUpgradePreview(root, operationId, project) {
 }
 async function readSafePreviewFile(target) {
   try {
-    const stat5 = await lstat22(target);
+    const stat5 = await lstat23(target);
     if (!stat5.isFile() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_PROJECT_UPGRADE_PREVIEW_INVALID");
     }
@@ -31588,16 +31806,16 @@ async function projectUpgrade(rootDir, options) {
 // src/commands/refresh-project.ts
 import { randomUUID } from "crypto";
 import { promises as fs7 } from "fs";
-import path61 from "path";
+import path62 from "path";
 import process9 from "process";
 var EXIT_OK7 = 0;
 var EXIT_NOT_INITIALIZED4 = 1;
 var EXIT_CORRUPT_STATE = 2;
 var EXIT_REFRESH_FAILED = 3;
 async function refreshProject(rootDir = process9.cwd()) {
-  const mancodeDir = path61.join(rootDir, ".mancode");
-  const statePath = path61.join(mancodeDir, "state.json");
-  if (await pathExists11(path61.join(mancodeDir, "schema.json"))) {
+  const mancodeDir = path62.join(rootDir, ".mancode");
+  const statePath = path62.join(mancodeDir, "state.json");
+  if (await pathExists11(path62.join(mancodeDir, "schema.json"))) {
     return refreshV3Project(rootDir);
   }
   if (!await pathExists11(statePath)) {
@@ -31613,27 +31831,27 @@ async function refreshProject(rootDir = process9.cwd()) {
   }
   let factsWritten = false;
   try {
-    const [profile, team, hasGit, hasManifest] = await Promise.all([
+    const [profile, team, hasGit, hasEvidence] = await Promise.all([
       detectProjectProfile(rootDir),
       detectTeamStatus(rootDir),
-      pathExists11(path61.join(rootDir, ".git")),
-      hasProjectManifest2(rootDir)
+      pathExists11(path62.join(rootDir, ".git")),
+      hasProjectEvidence(rootDir)
     ]);
     const uiLibrary = primaryUiLibrary(profile);
     const stack = [...profile.languages, ...profile.frameworks];
-    const config = await readJson2(path61.join(mancodeDir, "config.json"));
+    const config = await readJson2(path62.join(mancodeDir, "config.json"));
     const configuredTeam = config.forceTeamMode === true ? true : config.teamMode === "on" ? true : config.teamMode === "off" ? false : team.isTeam;
     const nextState = {
       ...state,
       techStack: stack.join(" + ") || profile.projectKind,
       uiLibrary: uiLibrary ?? "None",
-      projectMode: hasGit || hasManifest ? "detected" : "generic",
+      projectMode: hasGit || hasEvidence ? "detected" : "generic",
       teamModeAutoDetected: configuredTeam,
       contributors: team.contributors
     };
     await writeProjectFacts2(
       statePath,
-      path61.join(mancodeDir, "project-profile.json"),
+      path62.join(mancodeDir, "project-profile.json"),
       `${JSON.stringify(nextState, null, 2)}
 `,
       `${JSON.stringify(profile, null, 2)}
@@ -31650,7 +31868,7 @@ async function refreshProject(rootDir = process9.cwd()) {
     );
     console.log("\u2713  Project facts refreshed.");
     console.log(
-      `   ${hasGit ? "Git detected" : "No Git repository"} | ${hasManifest ? "project manifest detected" : "generic project"}`
+      `   ${hasGit ? "Git detected" : "No Git repository"} | ${hasEvidence ? "project source detected" : "generic project"}`
     );
     console.log(
       `   Stack: ${nextState.techStack} | UI: ${nextState.uiLibrary}`
@@ -31698,12 +31916,6 @@ async function refreshV3Project(rootDir) {
     return EXIT_REFRESH_FAILED;
   }
 }
-async function hasProjectManifest2(rootDir) {
-  for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists11(path61.join(rootDir, manifest))) return true;
-  }
-  return false;
-}
 async function writeProjectFacts2(statePath, profilePath, stateContent, profileContent) {
   await Promise.all([
     ensureReplaceableFile(statePath),
@@ -31744,7 +31956,7 @@ async function ensureReplaceableFile(filePath) {
       throw new Error(`cannot replace non-file path: ${filePath}`);
     }
   } catch (error) {
-    if (isNodeError9(error) && error.code === "ENOENT") return;
+    if (isNodeError10(error) && error.code === "ENOENT") return;
     throw error;
   }
 }
@@ -31761,14 +31973,14 @@ async function readOptionalText(filePath) {
   try {
     return await fs7.readFile(filePath, "utf-8");
   } catch (error) {
-    if (isNodeError9(error) && error.code === "ENOENT") return null;
+    if (isNodeError10(error) && error.code === "ENOENT") return null;
     throw error;
   }
 }
 function temporaryPath(filePath) {
-  return path61.join(
-    path61.dirname(filePath),
-    `.${path61.basename(filePath)}.${process9.pid}.${randomUUID()}.tmp`
+  return path62.join(
+    path62.dirname(filePath),
+    `.${path62.basename(filePath)}.${process9.pid}.${randomUUID()}.tmp`
   );
 }
 async function refreshStaticPlatforms(rootDir, config, fallbackPlatform, stack, uiLibrary, profile) {
@@ -31824,7 +32036,7 @@ async function readRequiredState(filePath) {
 function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNodeError9(error) {
+function isNodeError10(error) {
   return error instanceof Error && "code" in error;
 }
 async function pathExists11(filePath) {
@@ -31838,7 +32050,7 @@ async function pathExists11(filePath) {
 
 // src/commands/refresh-style.ts
 import { promises as fs8 } from "fs";
-import path62 from "path";
+import path63 from "path";
 import process10 from "process";
 var EXIT_OK8 = 0;
 var EXIT_NOT_INITIALIZED5 = 1;
@@ -31849,8 +32061,8 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
     console.error("\u2717  style scan root must stay inside the project root.");
     return EXIT_V3_REFRESH_FAILED;
   }
-  const stateFile = path62.join(rootDir, ".mancode", "state.json");
-  if (await pathExists12(path62.join(rootDir, ".mancode", "schema.json"))) {
+  const stateFile = path63.join(rootDir, ".mancode", "state.json");
+  if (await pathExists12(path63.join(rootDir, ".mancode", "schema.json"))) {
     return refreshV3Style(rootDir, scanTarget.root, scanTarget.scopeRoot);
   }
   if (!await pathExists12(stateFile)) {
@@ -31860,7 +32072,7 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
   }
   console.log("\u2713  \u5237\u65B0\u9879\u76EE profile...");
   const profile = await detectProjectProfile(rootDir);
-  const profilePath = path62.join(rootDir, ".mancode", "project-profile.json");
+  const profilePath = path63.join(rootDir, ".mancode", "project-profile.json");
   await fs8.writeFile(
     profilePath,
     `${JSON.stringify(profile, null, 2)}
@@ -31887,13 +32099,13 @@ async function refreshStyle(rootDir = process10.cwd(), options = {}) {
     uiLibraryHint,
     scanTarget.scopeRoot
   );
-  const tokensPath = path62.join(
+  const tokensPath = path63.join(
     rootDir,
     ".mancode",
     "aesthetics",
     "style-tokens.json"
   );
-  await fs8.mkdir(path62.dirname(tokensPath), { recursive: true });
+  await fs8.mkdir(path63.dirname(tokensPath), { recursive: true });
   await fs8.writeFile(
     tokensPath,
     `${JSON.stringify(tokens, null, 2)}
@@ -31966,7 +32178,7 @@ async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
     console.log(
       `   \u7C7B\u578B: ${profile.projectKind} | UI: ${profile.uiAssets} | \u6D4F\u89C8\u5668: ${profile.browserAutomation}`
     );
-    const tokensPath = path62.join(
+    const tokensPath = path63.join(
       rootDir,
       ".mancode",
       "local",
@@ -31983,7 +32195,7 @@ async function refreshV3Style(rootDir, scanRoot, scopeRoot) {
     }
     console.log("\u2713  \u626B\u63CF\u9879\u76EE\u8BBE\u8BA1 token...");
     const tokens = await scanAesthetics(scanRoot, uiLibraryHint, scopeRoot);
-    await fs8.mkdir(path62.dirname(tokensPath), { recursive: true });
+    await fs8.mkdir(path63.dirname(tokensPath), { recursive: true });
     await fs8.writeFile(
       tokensPath,
       `${JSON.stringify(tokens, null, 2)}
@@ -32017,7 +32229,7 @@ async function printStaticPlatformRefreshHint(rootDir) {
   );
 }
 async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
-  const statePath = path62.join(rootDir, ".mancode", "state.json");
+  const statePath = path63.join(rootDir, ".mancode", "state.json");
   try {
     const state = JSON.parse(await fs8.readFile(statePath, "utf-8"));
     const stack = [...profile.languages, ...profile.frameworks];
@@ -32041,7 +32253,7 @@ async function refreshLegacyStateContext(rootDir, profile, uiLibrary) {
 async function readInstalledPlatforms2(rootDir) {
   try {
     const raw = await fs8.readFile(
-      path62.join(rootDir, ".mancode", "config.json"),
+      path63.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     const config = JSON.parse(raw);
@@ -32061,30 +32273,30 @@ async function pathExists12(p) {
   }
 }
 async function resolveScanTarget(rootDir, requestedRoot) {
-  const projectRoot = await fs8.realpath(path62.resolve(rootDir)).catch(() => null);
+  const projectRoot = await fs8.realpath(path63.resolve(rootDir)).catch(() => null);
   if (projectRoot === null) return null;
   if (requestedRoot === void 0 || requestedRoot === ".") {
     return { root: projectRoot, scopeRoot: "." };
   }
-  if (path62.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
+  if (path63.isAbsolute(requestedRoot) || requestedRoot.includes("\0") || requestedRoot.split(/[\\/]/).some((segment) => segment === "" || segment === "." || segment === "..")) {
     return null;
   }
-  const candidate = await fs8.realpath(path62.resolve(projectRoot, requestedRoot)).catch(() => null);
+  const candidate = await fs8.realpath(path63.resolve(projectRoot, requestedRoot)).catch(() => null);
   if (candidate === null) return null;
-  const relative = path62.relative(projectRoot, candidate);
-  if (relative.startsWith(`..${path62.sep}`) || relative === ".." || path62.isAbsolute(relative)) {
+  const relative = path63.relative(projectRoot, candidate);
+  if (relative.startsWith(`..${path63.sep}`) || relative === ".." || path63.isAbsolute(relative)) {
     return null;
   }
   return {
     root: candidate,
-    scopeRoot: relative.split(path62.sep).join("/") || "."
+    scopeRoot: relative.split(path63.sep).join("/") || "."
   };
 }
 
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs9 } from "fs";
-import path63 from "path";
+import path64 from "path";
 import process11 from "process";
 
 // src/team/assessment.ts
@@ -32240,8 +32452,8 @@ var EXIT_OK9 = 0;
 var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_CORRUPT_STATE2 = 2;
 async function status(rootDir = process11.cwd(), options = {}) {
-  const stateFile = path63.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path63.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path64.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path64.join(rootDir, ".mancode", "schema.json");
   if (await pathExists13(v3SchemaFile)) {
     return statusV3(rootDir, options);
   }
@@ -32486,12 +32698,9 @@ async function readV3StatusSession(rootDir) {
 }
 async function shouldRefreshProject(rootDir, state) {
   if (state.projectMode !== "generic") return false;
-  const hasGit = await pathExists13(path63.join(rootDir, ".git"));
+  const hasGit = await pathExists13(path64.join(rootDir, ".git"));
   if (hasGit) return true;
-  for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists13(path63.join(rootDir, manifest))) return true;
-  }
-  return false;
+  return hasProjectEvidence(rootDir);
 }
 async function checkPlatformStatus2(rootDir, installedPlatforms) {
   const installed = new Set(installedPlatforms);
@@ -32533,19 +32742,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs9.readFile(path63.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path64.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path63.basename(rootDir);
+  return path64.basename(rootDir);
 }
 async function readConfig3(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path63.join(rootDir, ".mancode", "config.json"),
+      path64.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -32573,9 +32782,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists13(path63.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists13(path64.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
     pathExists13(
-      path63.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      path64.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -32584,7 +32793,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path63.join(rootDir, ".claude", "settings.json"),
+      path64.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -32613,7 +32822,7 @@ function hasHookCommand2(value, needle) {
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path63.join(
+  const hookPath = path64.join(
     rootDir,
     ".mancode",
     "hooks",
@@ -34110,8 +34319,8 @@ function assertPositiveRevision2(value, label) {
 }
 
 // src/team/git-ref-handoff-repair.ts
-import { lstat as lstat23, mkdir as mkdir38, readFile as readFile44, readdir as readdir19, writeFile as writeFile45 } from "fs/promises";
-import path64 from "path";
+import { lstat as lstat24, mkdir as mkdir38, readFile as readFile44, readdir as readdir19, writeFile as writeFile46 } from "fs/promises";
+import path65 from "path";
 
 // src/team/git-ref-operation.ts
 import { execFile as execFileCallback6 } from "child_process";
@@ -36689,7 +36898,7 @@ async function recoverGitRefHandoffRepairs(projectRoot) {
 }
 async function recoverGitRefHandoffRepair(projectRoot, operationId, transportReceipt) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  const root = path64.resolve(projectRoot);
+  const root = path65.resolve(projectRoot);
   let journal = await requireJournal2(root, operationId);
   if (journal.state === "committed" || journal.state === "aborted") {
     return recoveryResult2(journal);
@@ -36768,7 +36977,7 @@ async function recoverGitRefHandoffRepair(projectRoot, operationId, transportRec
   }
 }
 async function prepareHandoffRepairWhileTaskLocked(projectRoot, rawPrepared) {
-  const root = path64.resolve(projectRoot);
+  const root = path65.resolve(projectRoot);
   const prepared2 = parsePrepared2(rawPrepared);
   const runtime = await readProjectRuntimeContext(root);
   const previousMetadata = bundleMetadata2(prepared2.predecessorBundle);
@@ -36831,7 +37040,7 @@ async function restorePredecessorMetadata2(projectRoot, journal) {
   );
 }
 async function replaceMetadataVerified(projectRoot, expected, targetMetadata, alternateExpected) {
-  const target = path64.join(
+  const target = path65.join(
     taskRootPath(projectRoot, targetMetadata.taskRef),
     "metadata.json"
   );
@@ -36957,7 +37166,7 @@ async function createJournal3(projectRoot, journal) {
   await ensureJournalDirectory2(projectRoot);
   const target = journalPath3(projectRoot, journal.operationId);
   try {
-    await writeFile45(target, serialize13(journal), {
+    await writeFile46(target, serialize13(journal), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -37000,7 +37209,7 @@ async function listJournals2(projectRoot) {
       parseJournal3(
         JSON.parse(
           await readFile44(
-            path64.join(journalDirectory2(projectRoot), entry),
+            path65.join(journalDirectory2(projectRoot), entry),
             "utf8"
           )
         )
@@ -37010,43 +37219,43 @@ async function listJournals2(projectRoot) {
   return journals;
 }
 async function readSafeFile2(target) {
-  const before = await lstat23(target);
+  const before = await lstat24(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   const content = await readFile44(target, "utf8");
-  const after = await lstat23(target);
+  const after = await lstat24(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 = path64.join(
-    path64.dirname(target),
-    `.${path64.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  const temporary = path65.join(
+    path65.dirname(target),
+    `.${path65.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
-  await writeFile45(temporary, content, { encoding: "utf8", flag: "wx" });
+  await writeFile46(temporary, content, { encoding: "utf8", flag: "wx" });
   await replaceFileAtomically(temporary, target);
 }
 async function ensureJournalDirectory2(projectRoot) {
-  let current = path64.resolve(projectRoot);
+  let current = path65.resolve(projectRoot);
   for (const segment of [".mancode", "local", "journals", "git-ref-handoff"]) {
-    current = path64.join(current, segment);
+    current = path65.join(current, segment);
     try {
       await mkdir38(current);
     } catch (error) {
       if (!isAlreadyExists24(error)) throw error;
     }
-    const entry = await lstat23(current);
+    const entry = await lstat24(current);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
   }
 }
 function journalDirectory2(projectRoot) {
-  return path64.join(
-    path64.resolve(projectRoot),
+  return path65.join(
+    path65.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -37055,7 +37264,7 @@ function journalDirectory2(projectRoot) {
 }
 function journalPath3(projectRoot, operationId) {
   assertUlid(operationId, "git-ref handoff repair operationId");
-  return path64.join(journalDirectory2(projectRoot), `${operationId}.json`);
+  return path65.join(journalDirectory2(projectRoot), `${operationId}.json`);
 }
 function serialize13(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -37154,8 +37363,8 @@ function parseReceipt(value) {
 }
 
 // src/team/policy-operation.ts
-import { lstat as lstat24, mkdir as mkdir39, readdir as readdir20, unlink as unlink3, writeFile as writeFile46 } from "fs/promises";
-import path65 from "path";
+import { lstat as lstat25, mkdir as mkdir39, readdir as readdir20, unlink as unlink3, writeFile as writeFile47 } from "fs/promises";
+import path66 from "path";
 async function updateTeamPolicy(input) {
   const operationId = input.operationId ?? createUlid();
   const eventId = createUlid();
@@ -37166,7 +37375,7 @@ async function updateTeamPolicy(input) {
     throw new Error("MANCODE_TEAM_POLICY_INVALID");
   }
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path65.resolve(input.projectRoot);
+  const root = path66.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -37247,7 +37456,7 @@ async function applyTeamTransportSet(input, write2) {
   }
   const remote = transportRemote(input.mode, input.remote);
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const root = path65.resolve(input.projectRoot);
+  const root = path66.resolve(input.projectRoot);
   const runtime = await readProjectRuntimeContext(root);
   const store = resolveCoordinationEntityHomeStore(
     runtime.entityHomeStoreContext
@@ -37380,9 +37589,9 @@ async function assertTransportAuthorityEmpty(projectRoot, store) {
     listClaims(store),
     listHandoffs(store),
     directoryHasEntries(taskHeadDirectory(store)),
-    directoryHasEntries(path65.join(store.root, "transport-migrations")),
+    directoryHasEntries(path66.join(store.root, "transport-migrations")),
     directoryHasEntries(
-      path65.join(projectRoot, ".mancode", "shared", "team", "transport")
+      path66.join(projectRoot, ".mancode", "shared", "team", "transport")
     ),
     pathExists14(gitRefCachePath(projectRoot))
   ]);
@@ -37412,21 +37621,21 @@ function assertPositiveRevision5(value, label) {
   }
 }
 function teamPolicyPath(projectRoot) {
-  return path65.join(projectRoot, ".mancode", "shared", "team", "policy.json");
+  return path66.join(projectRoot, ".mancode", "shared", "team", "policy.json");
 }
 function projectConfigPath(projectRoot) {
-  return path65.join(projectRoot, ".mancode", "shared", "config.json");
+  return path66.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function writeJsonAtomic4(target, value) {
-  await mkdir39(path65.dirname(target), { recursive: true });
-  await assertPlainDirectory(path65.dirname(target));
+  await mkdir39(path66.dirname(target), { recursive: true });
+  await assertPlainDirectory(path66.dirname(target));
   await assertPlainFileOrMissing(target);
-  const temporary = path65.join(
-    path65.dirname(target),
-    `.${path65.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  const temporary = path66.join(
+    path66.dirname(target),
+    `.${path66.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile46(temporary, `${JSON.stringify(value, null, 2)}
+    await writeFile47(temporary, `${JSON.stringify(value, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
@@ -37438,14 +37647,14 @@ async function writeJsonAtomic4(target, value) {
   }
 }
 async function assertPlainDirectory(target) {
-  const entry = await lstat24(target);
+  const entry = await lstat25(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function assertPlainFileOrMissing(target) {
   try {
-    const entry = await lstat24(target);
+    const entry = await lstat25(target);
     if (!entry.isFile() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -37456,7 +37665,7 @@ async function assertPlainFileOrMissing(target) {
 }
 async function directoryHasEntries(target) {
   try {
-    const entry = await lstat24(target);
+    const entry = await lstat25(target);
     if (!entry.isDirectory() || entry.isSymbolicLink()) {
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     }
@@ -37468,7 +37677,7 @@ async function directoryHasEntries(target) {
 }
 async function pathExists14(target) {
   try {
-    await lstat24(target);
+    await lstat25(target);
     return true;
   } catch (error) {
     if (isNotFound32(error)) return false;
@@ -37484,15 +37693,15 @@ function isNotFound32(error) {
 
 // src/team/transport-migration-adapters.ts
 import {
-  lstat as lstat25,
+  lstat as lstat26,
   mkdir as mkdir40,
   readFile as readFile45,
   readdir as readdir21,
-  rename as rename13,
+  rename as rename14,
   unlink as unlink4,
-  writeFile as writeFile47
+  writeFile as writeFile48
 } from "fs/promises";
-import path66 from "path";
+import path67 from "path";
 
 // src/team/transport-migration.ts
 var DIGEST_PATTERN7 = /^sha256:[a-f0-9]{64}$/;
@@ -38564,7 +38773,7 @@ function compareUtf813(left, right) {
 var STAGE_DIRECTORY = "transport-migrations";
 var COLLECTIONS = ["claims", "handoffs", "task-heads"];
 async function createTransportMigrationFileAdapters(input) {
-  const projectRoot = path66.resolve(input.projectRoot);
+  const projectRoot = path67.resolve(input.projectRoot);
   assertUlid(input.actorId, "transport migration adapter actorId");
   if (input.operationId !== void 0) {
     assertUlid(input.operationId, "transport migration adapter operationId");
@@ -38616,7 +38825,7 @@ async function createTransportMigrationFileAdapters(input) {
 var FileSystemTransportMigrationConfigAdapter = class {
   constructor(projectRoot, coordinationStore) {
     this.coordinationStore = coordinationStore;
-    this.projectRoot = path66.resolve(projectRoot);
+    this.projectRoot = path67.resolve(projectRoot);
   }
   projectRoot;
   async read() {
@@ -39469,7 +39678,7 @@ async function publishMigrationActorProfiles(projectRoot, profiles) {
   }
 }
 async function archiveLocalCoordinationCollections(store, operationId) {
-  const archiveRoot = path66.join(
+  const archiveRoot = path67.join(
     store.root,
     STAGE_DIRECTORY,
     "archive",
@@ -39482,20 +39691,20 @@ async function archiveLocalCoordinationCollections(store, operationId) {
     "task-heads": taskHeadDirectory(store)
   };
   for (const name of COLLECTIONS) {
-    const archived = path66.join(archiveRoot, name);
-    const absent = path66.join(archiveRoot, `${name}.absent`);
+    const archived = path67.join(archiveRoot, name);
+    const absent = path67.join(archiveRoot, `${name}.absent`);
     if (await pathKind(archived) === "directory" || await pathKind(absent) === "file") {
       continue;
     }
     const sourceKind = await pathKind(directories[name]);
     if (sourceKind === null) {
-      await writeFile47(absent, "\n", { encoding: "utf8", flag: "wx" });
+      await writeFile48(absent, "\n", { encoding: "utf8", flag: "wx" });
       continue;
     }
     if (sourceKind !== "directory") {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_LOCAL_AUTHORITY_UNSAFE");
     }
-    await rename13(directories[name], archived);
+    await rename14(directories[name], archived);
   }
 }
 async function listActorProfiles(projectRoot) {
@@ -39521,7 +39730,7 @@ async function listActorProfiles(projectRoot) {
   return profiles;
 }
 async function listSharedTaskRefs(projectRoot) {
-  const directory = path66.join(projectRoot, ".mancode", "shared", "workflows");
+  const directory = path67.join(projectRoot, ".mancode", "shared", "workflows");
   let entries;
   try {
     entries = await readdir21(directory);
@@ -39532,7 +39741,7 @@ async function listSharedTaskRefs(projectRoot) {
   const refs = [];
   for (const taskId of entries.sort(compareUtf814)) {
     assertUlid(taskId, "shared workflow directory");
-    const stat5 = await lstat25(path66.join(directory, taskId));
+    const stat5 = await lstat26(path67.join(directory, taskId));
     if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
       throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
     }
@@ -39606,7 +39815,7 @@ async function readStagedRecord(store, operationId) {
   );
 }
 function stagedPath(store, operationId) {
-  return path66.join(
+  return path67.join(
     store.root,
     STAGE_DIRECTORY,
     "staged",
@@ -39614,7 +39823,7 @@ function stagedPath(store, operationId) {
   );
 }
 function establishedPath(store, operationId) {
-  return path66.join(
+  return path67.join(
     store.root,
     STAGE_DIRECTORY,
     "established",
@@ -39622,7 +39831,7 @@ function establishedPath(store, operationId) {
   );
 }
 function projectConfigPath2(projectRoot) {
-  return path66.join(projectRoot, ".mancode", "shared", "config.json");
+  return path67.join(projectRoot, ".mancode", "shared", "config.json");
 }
 async function readProjectConfigFile(projectRoot) {
   try {
@@ -39637,14 +39846,14 @@ async function readProjectConfigFile(projectRoot) {
   }
 }
 async function writeJsonAtomic5(target, value) {
-  await mkdir40(path66.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path66.dirname(target));
-  const temporary = path66.join(
-    path66.dirname(target),
-    `.${path66.basename(target)}.${process.pid}.${createUlid()}.tmp`
+  await mkdir40(path67.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path67.dirname(target));
+  const temporary = path67.join(
+    path67.dirname(target),
+    `.${path67.basename(target)}.${process.pid}.${createUlid()}.tmp`
   );
   try {
-    await writeFile47(temporary, serialize14(value), {
+    await writeFile48(temporary, serialize14(value), {
       encoding: "utf8",
       flag: "wx"
     });
@@ -39655,10 +39864,10 @@ async function writeJsonAtomic5(target, value) {
   }
 }
 async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
-  await mkdir40(path66.dirname(target), { recursive: true });
-  await assertPlainDirectory2(path66.dirname(target));
+  await mkdir40(path67.dirname(target), { recursive: true });
+  await assertPlainDirectory2(path67.dirname(target));
   try {
-    await writeFile47(target, serialize14(value), { encoding: "utf8", flag: "wx" });
+    await writeFile48(target, serialize14(value), { encoding: "utf8", flag: "wx" });
   } catch (error) {
     if (!isAlreadyExists25(error)) throw error;
     const existing = await readJsonOrNull5(target, parser, conflictCode);
@@ -39670,12 +39879,12 @@ async function writeJsonExclusiveOrEqual(target, value, parser, conflictCode) {
 }
 async function readJsonOrNull5(target, parser, corruptCode) {
   try {
-    const before = await lstat25(target);
+    const before = await lstat26(target);
     if (!before.isFile() || before.isSymbolicLink()) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
     const parsed = parser(JSON.parse(await readFile45(target, "utf8")));
-    const after = await lstat25(target);
+    const after = await lstat26(target);
     if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
       throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
     }
@@ -39733,7 +39942,7 @@ function requireRemote(value) {
 }
 async function pathKind(target) {
   try {
-    const stat5 = await lstat25(target);
+    const stat5 = await lstat26(target);
     if (stat5.isSymbolicLink()) return "other";
     if (stat5.isFile()) return "file";
     if (stat5.isDirectory()) return "directory";
@@ -39744,7 +39953,7 @@ async function pathKind(target) {
   }
 }
 async function assertPlainDirectory2(target) {
-  const stat5 = await lstat25(target);
+  const stat5 = await lstat26(target);
   if (!stat5.isDirectory() || stat5.isSymbolicLink()) {
     throw new Error("MANCODE_TRANSPORT_MIGRATION_STAGE_UNSAFE");
   }
@@ -41206,16 +41415,16 @@ function parsePositiveInteger6(value) {
 }
 
 // src/commands/uninstall.ts
-import { access as access5, readFile as readFile46, rm as rm21, writeFile as writeFile48 } from "fs/promises";
-import path67 from "path";
+import { access as access5, readFile as readFile46, rm as rm22, writeFile as writeFile49 } from "fs/promises";
+import path68 from "path";
 import process12 from "process";
 var EXIT_OK10 = 0;
 var EXIT_NOT_INITIALIZED7 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
 var EXIT_V3_AUTHORITY_PROTECTED = 3;
 async function uninstall(rootDir = process12.cwd(), platform, options = {}) {
-  const stateFile = path67.join(rootDir, ".mancode", "state.json");
-  const v3SchemaFile = path67.join(rootDir, ".mancode", "schema.json");
+  const stateFile = path68.join(rootDir, ".mancode", "state.json");
+  const v3SchemaFile = path68.join(rootDir, ".mancode", "schema.json");
   if (await pathExists15(v3SchemaFile)) {
     return uninstallV3(rootDir, platform, options);
   }
@@ -41301,6 +41510,8 @@ async function uninstallPlatform(rootDir, platform) {
     await uninstallKimiCode(rootDir);
   } else if (platform === "qoder") {
     await uninstallQoder(rootDir);
+  } else if (platform === "dsh") {
+    await uninstallDsh(rootDir);
   }
   await removeFromConfig(rootDir, platform);
 }
@@ -41310,7 +41521,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm21(path67.join(rootDir, ".mancode"), {
+  await rm22(path68.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -41320,7 +41531,7 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path67.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path68.join(rootDir, ".claude", "settings.json");
   let content;
   try {
     content = await readFile46(settingsPath, "utf-8");
@@ -41349,7 +41560,7 @@ async function cleanClaudeSettings(rootDir) {
     );
     settings.skills = Object.keys(retainedSkills).length > 0 ? retainedSkills : void 0;
   }
-  await writeFile48(
+  await writeFile49(
     settingsPath,
     `${JSON.stringify(settings, null, 2)}
 `,
@@ -41398,22 +41609,22 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path67.join(rootDir, "AGENTS.md");
+  const agentsPath = path68.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile48(agentsPath, `${cleaned}
+      await writeFile49(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm21(agentsPath, { force: true });
+      await rm22(agentsPath, { force: true });
     }
   } catch {
   }
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path67.join(
+  const instructionsPath = path68.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
@@ -41422,17 +41633,17 @@ async function uninstallCopilot(rootDir) {
     const content = await readFile46(instructionsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile48(instructionsPath, `${cleaned}
+      await writeFile49(instructionsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm21(instructionsPath, { force: true });
+      await rm22(instructionsPath, { force: true });
     }
   } catch {
   }
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path67.join(rootDir, "AGENTS.md");
+  const agentsPath = path68.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -41441,17 +41652,17 @@ async function uninstallZcode(rootDir) {
       ZCODE_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile48(agentsPath, `${cleaned}
+      await writeFile49(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm21(agentsPath, { force: true });
+      await rm22(agentsPath, { force: true });
     }
   } catch {
   }
   await removeZcodeSkills(rootDir);
 }
 async function uninstallKimiCode(rootDir) {
-  const agentsPath = path67.join(rootDir, "AGENTS.md");
+  const agentsPath = path68.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -41460,17 +41671,17 @@ async function uninstallKimiCode(rootDir) {
       KIMI_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile48(agentsPath, `${cleaned}
+      await writeFile49(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm21(agentsPath, { force: true });
+      await rm22(agentsPath, { force: true });
     }
   } catch {
   }
   await removeKimiSkills(rootDir);
 }
 async function uninstallQoder(rootDir) {
-  const agentsPath = path67.join(rootDir, "AGENTS.md");
+  const agentsPath = path68.join(rootDir, "AGENTS.md");
   try {
     const content = await readFile46(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
@@ -41479,17 +41690,38 @@ async function uninstallQoder(rootDir) {
       QODER_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile48(agentsPath, `${cleaned}
+      await writeFile49(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
-      await rm21(agentsPath, { force: true });
+      await rm22(agentsPath, { force: true });
     }
   } catch {
   }
   await removeQoderCommands(rootDir);
 }
+async function uninstallDsh(rootDir) {
+  await assertDshAdapterPathsSafe(rootDir);
+  const agentsPath = path68.join(rootDir, "AGENTS.md");
+  try {
+    const content = await readFile46(agentsPath, "utf-8");
+    const cleaned = removeManagedBlock(
+      content,
+      DSH_MANCODE_START_MARKER,
+      DSH_MANCODE_END_MARKER
+    );
+    if (cleaned.trim()) {
+      await writeDshAgentsFile(rootDir, `${cleaned}
+`);
+    } else {
+      await rm22(agentsPath, { force: true });
+    }
+  } catch {
+  }
+  await assertDshAdapterPathsSafe(rootDir);
+  await removeDshSkills(rootDir);
+}
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path67.join(rootDir, ".mancode", "config.json");
+  const configPath = path68.join(rootDir, ".mancode", "config.json");
   try {
     const raw = await readFile46(configPath, "utf-8");
     const config = JSON.parse(raw);
@@ -41503,7 +41735,7 @@ async function removeFromConfig(rootDir, platform) {
         );
         config.platformOptions = Object.keys(platformOptions).length > 0 ? platformOptions : void 0;
       }
-      await writeFile48(
+      await writeFile49(
         configPath,
         `${JSON.stringify(config, null, 2)}
 `,
@@ -41560,8 +41792,8 @@ var WORKFLOW_SUBCOMMAND_SET = new Set(
 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";
+import { access as access6, readFile as readFile48, rm as rm24, writeFile as writeFile51 } from "fs/promises";
+import path70 from "path";
 
 // src/context/child-result-merge.ts
 async function mergeV3ChildResult(input) {
@@ -44753,14 +44985,14 @@ function updateMetadata4(previous, verification, operationId, updatedAt) {
 
 // src/context/workflow-create.ts
 import {
-  lstat as lstat26,
+  lstat as lstat27,
   mkdir as mkdir41,
   readFile as readFile47,
-  rename as rename14,
-  rm as rm22,
-  writeFile as writeFile49
+  rename as rename15,
+  rm as rm23,
+  writeFile as writeFile50
 } from "fs/promises";
-import path68 from "path";
+import path69 from "path";
 
 // src/context/creation-resolution.ts
 function resolveWorkflowCreation(request) {
@@ -44870,7 +45102,7 @@ function rejectConflict(provided, expected, label) {
 
 // src/context/workflow-create.ts
 async function createV3Workflow(input) {
-  const projectRoot = path68.resolve(requireProjectRoot2(input.projectRoot));
+  const projectRoot = path69.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();
@@ -45055,8 +45287,8 @@ async function createV3Workflow(input) {
       throw new Error("MANCODE_REVISION_CONFLICT");
     }
     const taskParent = await ensureSafeTaskParent3(projectRoot, taskRef);
-    const targetDirectory = path68.join(taskParent, taskRef.taskId);
-    stagingDirectory = path68.join(
+    const targetDirectory = path69.join(taskParent, taskRef.taskId);
+    stagingDirectory = path69.join(
       taskParent,
       `.${taskRef.taskId}.${operationId}.staging`
     );
@@ -45514,7 +45746,7 @@ async function ensureSafeTaskParent3(projectRoot, taskRef) {
   const segments = [".mancode", taskRef.namespace, "workflows"];
   let current = projectRoot;
   for (const segment of segments) {
-    current = path68.join(current, segment);
+    current = path69.join(current, segment);
     const existing = await lstatOrNull5(current);
     if (existing === null) {
       await mkdir41(current);
@@ -45550,13 +45782,13 @@ async function writeStagedEntities(stagingDirectory, entities) {
 }
 async function writeStagedJson(stagingDirectory, fileName, value) {
   await assertDirectory(stagingDirectory);
-  const target = path68.join(stagingDirectory, fileName);
-  await writeFile49(target, `${JSON.stringify(value, null, 2)}
+  const target = path69.join(stagingDirectory, fileName);
+  await writeFile50(target, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
   });
-  const entry = await lstat26(target);
+  const entry = await lstat27(target);
   if (!entry.isFile() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -45588,13 +45820,13 @@ async function validateStagedEntities(stagingDirectory) {
   });
 }
 async function readStagedJson(stagingDirectory, fileName, parser) {
-  const target = path68.join(stagingDirectory, fileName);
-  const before = await lstat26(target);
+  const target = path69.join(stagingDirectory, fileName);
+  const before = await lstat27(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   const parsed = parser(JSON.parse(await readFile47(target, "utf8")));
-  const after = await lstat26(target);
+  const after = await lstat27(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
@@ -45607,7 +45839,7 @@ async function publishStagedTask(stagingDirectory, targetDirectory) {
     targetDirectory,
     "MANCODE_WORKFLOW_ALREADY_EXISTS"
   );
-  await rename14(stagingDirectory, targetDirectory);
+  await rename15(stagingDirectory, targetDirectory);
   await assertDirectory(targetDirectory);
 }
 async function advanceJournal(store, previous, stepId, now, canAbort) {
@@ -45685,18 +45917,18 @@ async function abortPreparedCreate(store, journal, stagingDirectory, now) {
       { canAbort: true }
     );
   } finally {
-    await rm22(stagingDirectory, { recursive: true, force: true });
+    await rm23(stagingDirectory, { recursive: true, force: true });
   }
 }
 async function assertDirectory(target) {
-  const entry = await lstat26(target);
+  const entry = await lstat27(target);
   if (!entry.isDirectory() || entry.isSymbolicLink()) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
 }
 async function lstatOrNull5(target) {
   try {
-    return await lstat26(target);
+    return await lstat27(target);
   } catch (error) {
     if (isNotFound34(error)) return null;
     throw error;
@@ -46721,7 +46953,7 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
   if (v3Activation === "v3_active") {
     return workflowV3(rootDir, subcommand, args, options);
   }
-  if (!await pathExists16(path69.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists16(path70.join(rootDir, ".mancode", "state.json"))) {
     if (v3Activation !== null) {
       return printV3Error(
         options.json,
@@ -47804,7 +48036,7 @@ function parseV3ParticipantActorIds(values) {
   return values;
 }
 async function readWorkflowInputFile(projectRoot, value) {
-  const inputPath = path69.isAbsolute(value) ? value : path69.resolve(projectRoot, value);
+  const inputPath = path70.isAbsolute(value) ? value : path70.resolve(projectRoot, value);
   return readFile48(inputPath, "utf8");
 }
 async function readWorkflowJsonInputFile(projectRoot, value) {
@@ -47878,12 +48110,12 @@ async function readV3ActivationState2(rootDir) {
   try {
     const manifest = parseSchemaManifest(
       JSON.parse(
-        await readFile48(path69.join(rootDir, ".mancode", "schema.json"), "utf8")
+        await readFile48(path70.join(rootDir, ".mancode", "schema.json"), "utf8")
       )
     );
     return manifest.activationState === "v3_active" ? "v3_active" : "other";
   } catch (error) {
-    if (isNodeError10(error) && error.code === "ENOENT") return null;
+    if (isNodeError11(error) && error.code === "ENOENT") return null;
     throw error;
   }
 }
@@ -47923,15 +48155,15 @@ 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 = path69.join(rootDir, ".mancode", "workflows", taskId);
-  const jsonPath = path69.join(workflowPath, "requirements.json");
-  const markdownPath = path69.join(workflowPath, "requirements.md");
-  const metadataPath3 = path69.join(workflowPath, "metadata.json");
+  const workflowPath = path70.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path70.join(workflowPath, "requirements.json");
+  const markdownPath = path70.join(workflowPath, "requirements.md");
+  const metadataPath3 = path70.join(workflowPath, "metadata.json");
   let originalJson;
   let originalMarkdown;
   let originalMetadata;
   try {
-    const inputPath = path69.isAbsolute(options.file) ? options.file : path69.resolve(rootDir, options.file);
+    const inputPath = path70.isAbsolute(options.file) ? options.file : path70.resolve(rootDir, options.file);
     const input = await readFile48(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
     assertRequirementsScopeConsistent2(requirements);
@@ -47968,7 +48200,7 @@ async function workflowRequirements(rootDir, args, options) {
       const rollback = await Promise.allSettled([
         restoreOptionalText(jsonPath, originalJson),
         restoreOptionalText(markdownPath, originalMarkdown),
-        writeFile50(metadataPath3, originalMetadata, "utf-8")
+        writeFile51(metadataPath3, originalMetadata, "utf-8")
       ]);
       rollbackIncomplete = rollback.some(
         (result2) => result2.status === "rejected"
@@ -48056,7 +48288,7 @@ async function workflowVerify(rootDir, args, options) {
             );
           }
           if (options.evidenceFile) {
-            const evidencePath = path69.isAbsolute(options.evidenceFile) ? options.evidenceFile : path69.resolve(rootDir, options.evidenceFile);
+            const evidencePath = path70.isAbsolute(options.evidenceFile) ? options.evidenceFile : path70.resolve(rootDir, options.evidenceFile);
             if (!await pathExists16(evidencePath)) {
               return invalidArg(
                 options,
@@ -48116,14 +48348,14 @@ async function workflowVerify(rootDir, args, options) {
 }
 async function commitVerificationTransition(rootDir, meta, ledger) {
   const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path69.join(
+  const metadataPath3 = path70.join(
     rootDir,
     ".mancode",
     "workflows",
     meta.taskId,
     "metadata.json"
   );
-  const specPath = path69.join(rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path70.join(rootDir, ".mancode", "memory", "spec.md");
   const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
     readOptionalText2(ledgerPath),
     readFile48(metadataPath3, "utf-8"),
@@ -48155,7 +48387,7 @@ async function commitVerificationTransition(rootDir, meta, ledger) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile50(metadataPath3, originalMetadata, "utf-8"),
+      writeFile51(metadataPath3, originalMetadata, "utf-8"),
       restoreOptionalText(specPath, originalSpec)
     ]);
     const message = error instanceof Error ? error.message : "verification transition failed";
@@ -48287,7 +48519,7 @@ async function workflowReview(rootDir, args, options) {
 }
 async function commitReviewSkip(rootDir, meta, reason) {
   const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
-  const metadataPath3 = path69.join(
+  const metadataPath3 = path70.join(
     rootDir,
     ".mancode",
     "workflows",
@@ -48307,7 +48539,7 @@ async function commitReviewSkip(rootDir, meta, reason) {
   } catch (error) {
     const rollback = await Promise.allSettled([
       restoreOptionalText(ledgerPath, originalLedger),
-      writeFile50(metadataPath3, originalMetadata, "utf-8")
+      writeFile51(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;
@@ -48527,14 +48759,14 @@ async function workflowHandoff(rootDir, taskId, options) {
       "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
     );
   }
-  const workflowPath = path69.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path69.join(workflowPath, "requirements.md")) || !await pathExists16(path69.join(workflowPath, "plan.md"))) {
+  const workflowPath = path70.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path70.join(workflowPath, "requirements.md")) || !await pathExists16(path70.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "solo handoff requires requirements.md and plan.md"
     );
   }
-  const statePath = path69.join(rootDir, ".mancode", "state.json");
+  const statePath = path70.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
@@ -48609,7 +48841,7 @@ async function workflowCompleteHandoff(rootDir, taskId, options) {
       `workflow is not an active solo handoff: ${taskId}`
     );
   }
-  const statePath = path69.join(rootDir, ".mancode", "state.json");
+  const statePath = path70.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
@@ -48676,14 +48908,14 @@ async function workflowDecide(rootDir, taskId, options) {
       `workflow is not ready for a plan-only decision: ${taskId}`
     );
   }
-  const workflowPath = path69.join(rootDir, ".mancode", "workflows", taskId);
-  if (!await pathExists16(path69.join(workflowPath, "requirements.md")) || !await pathExists16(path69.join(workflowPath, "plan.md"))) {
+  const workflowPath = path70.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists16(path70.join(workflowPath, "requirements.md")) || !await pathExists16(path70.join(workflowPath, "plan.md"))) {
     return invalidArg(
       options,
       "plan-only requires requirements.md and plan.md"
     );
   }
-  const statePath = path69.join(rootDir, ".mancode", "state.json");
+  const statePath = path70.join(rootDir, ".mancode", "state.json");
   let originalState;
   let state;
   try {
@@ -48739,14 +48971,14 @@ async function workflowDecide(rootDir, taskId, options) {
   return EXIT_OK11;
 }
 async function commitPlanningTransition(args) {
-  const metadataPath3 = path69.join(
+  const metadataPath3 = path70.join(
     args.rootDir,
     ".mancode",
     "workflows",
     args.taskId,
     "metadata.json"
   );
-  const specPath = path69.join(args.rootDir, ".mancode", "memory", "spec.md");
+  const specPath = path70.join(args.rootDir, ".mancode", "memory", "spec.md");
   let originalMetadata;
   let originalSpec;
   try {
@@ -48757,7 +48989,7 @@ async function commitPlanningTransition(args) {
   }
   try {
     await updateWorkflow(args.rootDir, args.taskId, args.workflowPatch);
-    await writeFile50(
+    await writeFile51(
       args.statePath,
       `${JSON.stringify(args.nextState, null, 2)}
 `,
@@ -48771,9 +49003,9 @@ async function commitPlanningTransition(args) {
     return null;
   } catch (error) {
     const rollback = await Promise.allSettled([
-      writeFile50(metadataPath3, originalMetadata, "utf-8"),
-      writeFile50(args.statePath, args.originalState, "utf-8"),
-      originalSpec === null ? rm23(specPath, { force: true }) : writeFile50(specPath, originalSpec, "utf-8")
+      writeFile51(metadataPath3, originalMetadata, "utf-8"),
+      writeFile51(args.statePath, args.originalState, "utf-8"),
+      originalSpec === null ? rm24(specPath, { force: true }) : writeFile51(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;
@@ -48783,16 +49015,16 @@ async function readOptionalText2(filePath) {
   try {
     return await readFile48(filePath, "utf-8");
   } catch (error) {
-    if (isNodeError10(error) && error.code === "ENOENT") return null;
+    if (isNodeError11(error) && error.code === "ENOENT") return null;
     throw error;
   }
 }
 async function restoreOptionalText(filePath, content) {
   if (content === null) {
-    await rm23(filePath, { force: true });
+    await rm24(filePath, { force: true });
     return;
   }
-  await writeFile50(filePath, content, "utf-8");
+  await writeFile51(filePath, content, "utf-8");
 }
 function readActiveSoloPlan(value) {
   if (!value || typeof value !== "object") return null;
@@ -48802,7 +49034,7 @@ function readActiveSoloPlan(value) {
   }
   return { taskId: plan.taskId, planVersion: plan.planVersion };
 }
-function isNodeError10(error) {
+function isNodeError11(error) {
   return error instanceof Error && "code" in error;
 }
 async function workflowList(rootDir, options) {
@@ -49060,7 +49292,7 @@ function createCliProgram() {
     process.exitCode = code;
   });
   program.command("install [platform]").description(
-    "Install platform adapter (claude-code, cursor, codex, copilot, zcode, kimi-code, qoder)"
+    "Install platform adapter (claude-code, cursor, codex, copilot, zcode, kimi-code, qoder, dsh)"
   ).option("--force", "Reinstall even if already installed").option(
     "--minimal",
     "Retained for legacy compatibility; Continuity bootstrap is already minimal"
@@ -49179,7 +49411,7 @@ Public Continuity subcommands:
     "Record real-host session evidence without persisting host keys"
   ).requiredOption(
     "--platform <platform>",
-    "claude-code, codex, cursor, copilot, zcode, kimi-code, or qoder"
+    "claude-code, codex, cursor, copilot, zcode, kimi-code, qoder, or dsh"
   ).requiredOption("--session-mode <mode>", "Evidence path: host or explicit").requiredOption(
     "--host-session-source <source>",
     "hook_stdin, environment, api, or none for explicit sessions"