odai-dsh-agent 0.0.3 → 0.0.4

package/README.md

@@ -35,7 +35,7 @@ Open a new DSH session and select `Odai` from the Agent preset picker. Existing
 
 In `dsh@0.1.0-rc.6`, the one-shot `--profile headless` driver creates a global agent directly and neither mounts nor accepts a session Agent preset. Automated Agent runs must create a Web session with `agentPreset: odai`; use the profile-wide Plugin for one-shot headless tasks.
 
-The installer copies through a mode-tightened staging directory and atomically publishes the preset. Updates verify every previously managed file first, refuse to overwrite local edits, and always change the composition generation key so new sessions in a running DSH process do not reuse stale runtime code.
+The installer copies through a mode-tightened staging directory and atomically publishes the preset. Updates verify every previously managed file first, refuse to overwrite local edits, and always change the composition generation key so new sessions in a running DSH process do not reuse stale runtime code. If install or update finds recognized historical Odai audit records, it refuses to change the preset until every DSH process is stopped and the command is rerun with `--yes`. The confirmed migration adds DSH's official `ignorable: true` envelope marker, covers both plaintext and concatenated-frame Zstandard session artifacts, verifies each replacement, and retains a content-addressed backup without deleting messages or evidence. Confirmation alone is insufficient: migration also refuses when local process inspection fails or finds any active DSH process. Keep DSH stopped until the installer exits because historical runtimes do not participate in a migration lock. An unknown unmarked `odai/*` type blocks the operation instead of being assumed safe to ignore.
 
 DSH classifies this as a `trust: user` preset. User presets have the same privileges as shell access, so install only reviewed package versions; the installer repeats this trust notice in both plain and JSON output.
 
@@ -49,7 +49,7 @@ The Agent ships no planner, executor, or reviewer model mapping. It stays quiet
 验收改用 provider-z/model-review，推理档 max。
 ```
 
-The controller calls `odai_routing_config` to persist that explicit choice. The user does not edit Agent files, YAML, or JSON and does not add trigger terms to later tasks. Mappings live in `$DSH_HOME/odai/routing.json`, outside the managed preset, so installer updates do not report them as drift. Changes apply from the next user turn. If reasoning effort is omitted, the target provider/model uses its own default rather than inheriting the source controller's setting. Plugin and Agent read the same store when both are deliberately present.
+The controller calls `odai_routing_config` to persist that explicit choice. The user does not edit Agent files, YAML, or JSON and does not add trigger terms to later tasks. Mappings live in `$DSH_HOME/odai/routing.json`, outside the managed preset, so installer updates do not report them as drift. Audit evidence likewise lives under `$DSH_HOME/odai/session-evidence/` instead of using private DSH session-event types, so changing or removing the preset cannot make a session unreadable. Changes apply from the next user turn. If reasoning effort is omitted, the target provider/model uses its own default rather than inheriting the source controller's setting. Plugin and Agent read the same stores when both are deliberately present.
 
 Planner, executor, and reviewer are independent optional responsibilities. If any needed one has no mapping, high-impact work fails closed and remains read-only; lower-impact work continues only where it does not depend on the missing independent responsibility. Odai never chooses a model on the user's behalf.
 
@@ -61,7 +61,7 @@ npx odai-dsh-agent status --json
 npx odai-dsh-agent uninstall
 ```
 
-`status` reports `absent`, `installed`, or `drifted`. Update and uninstall fail closed when managed files were changed or unmanaged files were added. Uninstall also refuses while `agent-presets.default` still names `odai`; select another default first so the next session cannot fail on a missing preset.
+`status` reports `absent`, `installed`, or `drifted`. Update and uninstall fail closed when managed files were changed or unmanaged files were added. Uninstall first checks for legacy Odai session events and, when any exist, requires the same stopped-DSH `--yes` confirmation before making them ignorable; a failed inspection or migration refuses removal. It also refuses while `agent-presets.default` still names `odai`; select another default first so the next session cannot fail on a missing preset. Stop DSH before install, update, or uninstall so session artifacts are not being written concurrently.
 
 ## Plugin versus Agent
 
@@ -71,7 +71,7 @@ Use only the surface that matches the desired scope:
 - `odai-dsh-agent`: selectable Odai governance for only sessions using this preset.
 - both: supported only for a deliberate combination of profile-wide and Agent-scoped behavior; normally redundant, so it is not the default recommendation.
 
-When both are deliberate, durable tool and route evidence is deduplicated and denials remain monotonic. Neither package installs or changes the provider-neutral `odai-cli`.
+When both are deliberate, the shared compatibility-safe evidence store deduplicates tool and route records and denials remain monotonic. Neither package installs or changes the provider-neutral `odai-cli`.
 
 ## Development
 

package/bin/odai-dsh-agent.mjs

@@ -18,6 +18,7 @@ Commands:
 Options:
   --dsh-home <path>  Override DSH_HOME
   --json             Print JSON
+  --yes              Confirm DSH is stopped; active-process verification still applies
   -h, --help         Show this help
 `;
 
@@ -27,13 +28,19 @@ try {
     process.stdout.write(HELP);
   } else if (args.command === "install") {
     assertDshVersion();
-    print(await installAgentPreset({ dshHome: args.dshHome }), args.json);
+    print(await installAgentPreset({
+      dshHome: args.dshHome,
+      confirmDshStopped: args.yes,
+    }), args.json);
   } else if (args.command === "status") {
     const result = await inspectAgentInstallation({ dshHome: args.dshHome });
     print(result, args.json);
     if (result.status === "drifted") process.exitCode = 2;
   } else if (args.command === "uninstall") {
-    print(await uninstallAgentPreset({ dshHome: args.dshHome }), args.json);
+    print(await uninstallAgentPreset({
+      dshHome: args.dshHome,
+      confirmDshStopped: args.yes,
+    }), args.json);
   } else {
     throw new Error("a command is required\n\n" + HELP);
   }
@@ -56,11 +63,12 @@ function assertDshVersion() {
 }
 
 function parseArgs(argv) {
-  const parsed = { command: undefined, dshHome: undefined, json: false, help: false };
+  const parsed = { command: undefined, dshHome: undefined, json: false, yes: false, help: false };
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "-h" || arg === "--help") parsed.help = true;
     else if (arg === "--json") parsed.json = true;
+    else if (arg === "--yes") parsed.yes = true;
     else if (arg === "--dsh-home") parsed.dshHome = argv[++index];
     else if (!parsed.command && ["install", "status", "uninstall"].includes(arg)) parsed.command = arg;
     else throw new Error(`unknown argument: ${arg}`);
@@ -82,5 +90,17 @@ function print(result, json) {
     return;
   }
   process.stdout.write(`${result.operation}: ${result.target}\n`);
+  if (result.sessionCompatibility?.repairedEvents > 0) {
+    process.stdout.write(`session compatibility: made ${result.sessionCompatibility.repairedEvents} legacy Odai event(s) ignorable in ${result.sessionCompatibility.repairedArtifacts} session artifact(s)\n`);
+  }
+  if (result.sessionCompatibility?.backupPaths?.length > 0) {
+    process.stdout.write(`session compatibility: retained ${result.sessionCompatibility.backupPaths.length} verified backup artifact(s)\n`);
+  }
+  for (const path of result.sessionCompatibility?.tornArtifacts ?? []) {
+    process.stdout.write(`session compatibility warning: preserved DSH-recoverable torn tail: ${path}\n`);
+  }
+  for (const failure of result.sessionCompatibility?.failures ?? []) {
+    process.stdout.write(`session compatibility warning: ${failure.path}: ${failure.error}\n`);
+  }
   if (result.security) process.stdout.write(`security: ${result.security}\n`);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "odai-dsh-agent",
-  "version": "0.0.3",
-  "description": "完整继承 DSH Standard 全部能力的 Odai Agent preset。",
+  "version": "0.0.4",
+  "description": "完整继承 DSH 标准模式 全部能力的 Odai Agent preset。主要用于治理、规划、测试、验证 等，可当成默认总控使用。",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -56,7 +56,7 @@
     }
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22.15.0"
   },
   "keywords": [
     "agent",

package/preset/odai/preset.yml

@@ -1,3 +1,3 @@
-name: Odai
+name: odai 治理模式
 order: 40
-description: 完整继承 DSH Standard 全部能力，并叠加 Odai 治理、证据与自动路由。
+description: 完整继承 DSH 标准模式 全部能力，并叠加 odai 治理、证据与自动路由，以 odai 为总控。

package/preset/odai/runtime/governance.mjs

@@ -57,9 +57,9 @@ export function createChildToolGuard(options = {}) {
   };
 }
 
-export function activeRouteProtection(agent) {
+export function activeRouteProtection(agent, recordedEvents = agent?.session?.events) {
   if (isSubagent(agent)) return undefined;
-  const events = agent?.session?.events;
+  const events = recordedEvents;
   if (!Array.isArray(events)) return undefined;
 
   let currentTurn;

package/preset/odai/runtime/index.mjs

@@ -26,6 +26,7 @@ import {
   resolveRoleRoute,
   resolveRoutingConfigPath,
 } from "./routing-config.mjs";
+import { createSessionEvidence, resolveSessionEvidenceRoot } from "./session-evidence.mjs";
 
 export const name = "odai-dsh-runtime";
 export const inject = ["systemPrompt", "tools", "subagents"];
@@ -142,20 +143,6 @@ function loggerFor(ctx) {
   return ctx.logger(name);
 }
 
-function appendEvent(agent, type, data, logger) {
-  try {
-    agent?.session?.append(type, data);
-  } catch (error) {
-    logger.warn(`failed to append ${type}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-function hasSessionEvent(agent, type, predicate) {
-  const events = agent?.session?.events;
-  if (!Array.isArray(events)) return false;
-  return events.some((event) => event?.type === type && predicate(event.data));
-}
-
 function outputText(blocks) {
   if (!Array.isArray(blocks)) return "";
   return blocks
@@ -303,6 +290,18 @@ function routedRoleOf(agent) {
 export function apply(ctx, rawConfig) {
   const config = resolveConfig(rawConfig);
   const logger = loggerFor(ctx);
+  const evidence = createSessionEvidence({
+    root: resolveSessionEvidenceRoot(config.routing.configPath),
+    logger,
+  });
+  const appendEvent = (agent, type, data) => {
+    try {
+      evidence.append(agent, type, data);
+    } catch (error) {
+      logger.warn(`failed to record ${type}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+  const hasSessionEvent = (agent, type, predicate) => evidence.has(agent, type, predicate);
   const skillPath = resolveSkillPath(config.skillPath);
   const skillText = readFileSync(skillPath, "utf8").trim();
   if (!skillText) throw new Error(`odai canonical skill is empty: ${skillPath}`);
@@ -347,10 +346,14 @@ export function apply(ctx, rawConfig) {
     onDenied,
     protectionFor(agent) {
       if (config.routing.mode === "off") return undefined;
-      return routeProtections.get(agent) ?? activeRouteProtection(agent);
+      return routeProtections.get(agent) ?? activeRouteProtection(agent, evidence.events(agent));
     },
   });
-  ctx.tools.register(createRoutingConfigTool(config.routing.configPath));
+  ctx.tools.register(createRoutingConfigTool(config.routing.configPath, {
+    onConfigured(agent, data) {
+      appendEvent(agent, "odai/routing-configured", data);
+    },
+  }));
   ctx.tools.guard((execution) => childGuard(execution) ?? routeProtectionGuard(execution));
 
   ctx.on("tools/result", (execution, result) => {

package/preset/odai/runtime/routing-config.mjs

@@ -180,7 +180,8 @@ function resultFor(configPath, action, roles, responsibility, recoveredInvalidSt
   };
 }
 
-export function createRoutingConfigTool(configPath) {
+export function createRoutingConfigTool(configPath, options = {}) {
+  const onConfigured = typeof options.onConfigured === "function" ? options.onConfigured : () => {};
   return {
     name: "odai_routing_config",
     description: [
@@ -301,7 +302,7 @@ export function createRoutingConfigTool(configPath) {
         if (args.action === "remove") delete roles[args.responsibility];
         else roles[args.responsibility] = proposedRoute;
         writeRoutingStore(configPath, roles);
-        execution.agent.session?.append?.("odai/routing-configured", {
+        onConfigured(execution.agent, {
           action: args.action,
           responsibility: args.responsibility,
           route: roles[args.responsibility],

package/preset/odai/runtime/session-compat.mjs

@@ -0,0 +1,387 @@
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import {
+  closeSync,
+  constants as fsConstants,
+  copyFileSync,
+  existsSync,
+  fsyncSync,
+  openSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve, sep } from "node:path";
+import * as zlib from "node:zlib";
+
+const ZSTD_MAGIC = 4247762216;
+const ODAI_EVENT_PREFIX = "odai/";
+const LEGACY_ODAI_AUDIT_EVENT_TYPES = new Set([
+  "odai/governance-denied",
+  "odai/route-config-missing",
+  "odai/route-decided",
+  "odai/route-protection",
+  "odai/route-result",
+  "odai/route-upgrade",
+  "odai/routing-configured",
+  "odai/tool-observed",
+]);
+
+export function resolveDshHome(configured, env = process.env) {
+  const value = configured ?? env.DSH_HOME ?? resolve(homedir(), ".dsh");
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError("DSH home must be a non-empty path");
+  }
+  const trimmed = value.trim();
+  if (trimmed === "~") return homedir();
+  if (trimmed.startsWith(`~${sep}`)) return resolve(homedir(), trimmed.slice(2));
+  return resolve(trimmed);
+}
+
+function isDshCommand(commandLine) {
+  if (typeof commandLine !== "string") return false;
+  return /@deepseek-ai[\\/]dsh(?:[\\/]|$)/iu.test(commandLine)
+    || /(?:^|[\s"'])[^\s"']*[\\/]dsh(?:\.cmd|\.mjs|\.js)?(?=$|[\s"'])/iu.test(commandLine)
+    || /(?:^|[\s"'])dsh(?:\.cmd)?(?=$|[\s"'])/iu.test(commandLine);
+}
+
+function listWindowsProcesses() {
+  const command = "Get-CimInstance Win32_Process | Select-Object ProcessId,Name,CommandLine | ConvertTo-Json -Compress";
+  const output = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+    encoding: "utf8",
+    windowsHide: true,
+  }).trim();
+  if (output === "") return [];
+  const parsed = JSON.parse(output);
+  return (Array.isArray(parsed) ? parsed : [parsed]).map((entry) => ({
+    pid: Number(entry.ProcessId),
+    name: typeof entry.Name === "string" ? entry.Name : "unknown",
+    commandLine: entry.CommandLine,
+  }));
+}
+
+function listPosixProcesses() {
+  const output = execFileSync("ps", ["-axo", "pid=,comm=,args="], { encoding: "utf8" });
+  return output.split(/\r?\n/u).flatMap((line) => {
+    const matched = /^\s*(\d+)\s+(\S+)\s+(.*)$/u.exec(line);
+    return matched ? [{ pid: Number(matched[1]), name: matched[2], commandLine: matched[3] }] : [];
+  });
+}
+
+export function listActiveDshProcesses(platform = process.platform) {
+  const processes = platform === "win32" ? listWindowsProcesses() : listPosixProcesses();
+  return processes
+    .filter((entry) => Number.isSafeInteger(entry.pid) && entry.pid > 0 && entry.pid !== process.pid)
+    .filter((entry) => isDshCommand(entry.commandLine))
+    .map(({ pid, name }) => Object.freeze({ pid, name }));
+}
+
+function assertDshStopped(options) {
+  let active;
+  try {
+    const scanner = options.processScanner ?? listActiveDshProcesses;
+    active = scanner();
+  } catch {
+    throw new Error("cannot verify that DSH is stopped; run the repair from a normal terminal with permission to inspect local process command lines");
+  }
+  if (!Array.isArray(active)) throw new Error("DSH process scanner returned an invalid result");
+  if (active.length > 0) {
+    const owners = active.map((entry) => `${entry.name ?? "dsh"} (pid ${entry.pid ?? "unknown"})`).join(", ");
+    throw new Error(`refusing to rewrite session artifacts while DSH is running: ${owners}`);
+  }
+}
+
+function listSessionArtifacts(root) {
+  if (!existsSync(root)) return [];
+  const found = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const path = resolve(current, entry.name);
+      if (entry.isDirectory()) pending.push(path);
+      else if (entry.isFile() && (entry.name === "session.jsonl" || entry.name === "session.jsonl.zstd")) {
+        found.push(path);
+      }
+    }
+  }
+  return found.sort();
+}
+
+function transformLine(line) {
+  if (line === "") return { line, repaired: 0 };
+  const record = JSON.parse(line);
+  if (typeof record?.type !== "string" || !record.type.startsWith(ODAI_EVENT_PREFIX) || record.ignorable === true) {
+    return { line, repaired: 0 };
+  }
+  if (!LEGACY_ODAI_AUDIT_EVENT_TYPES.has(record.type)) {
+    throw new Error(`refusing unknown Odai session event type ${JSON.stringify(record.type)}; use a compatible Odai repair version`);
+  }
+  return { line: JSON.stringify({ ...record, ignorable: true }), repaired: 1 };
+}
+
+function transformCompleteJsonl(text) {
+  const output = [];
+  let repaired = 0;
+  let offset = 0;
+  for (;;) {
+    const newline = text.indexOf("\n", offset);
+    if (newline < 0) break;
+    const raw = text.slice(offset, newline);
+    const carriageReturn = raw.endsWith("\r");
+    const line = carriageReturn ? raw.slice(0, -1) : raw;
+    const transformed = transformLine(line);
+    output.push(transformed.line, carriageReturn ? "\r\n" : "\n");
+    repaired += transformed.repaired;
+    offset = newline + 1;
+  }
+  const tornTail = text.slice(offset);
+  output.push(tornTail);
+  return { text: output.join(""), repaired, torn: tornTail.length > 0 };
+}
+
+function scanZstdFrames(buffer) {
+  const frames = [];
+  let offset = 0;
+  while (offset < buffer.length) {
+    const start = offset;
+    if (buffer.length - offset < 4) return { frames, tornStart: start };
+    if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC) {
+      throw new Error(`invalid Zstandard frame magic at byte ${offset}`);
+    }
+    offset += 4;
+    if (offset === buffer.length) return { frames, tornStart: start };
+    const descriptor = buffer.readUInt8(offset);
+    offset += 1;
+    if ((descriptor & 24) !== 0) throw new Error(`reserved Zstandard frame-header bit at byte ${offset - 1}`);
+    const contentSizeFlag = descriptor >>> 6;
+    const singleSegment = (descriptor & 32) !== 0;
+    const checksum = (descriptor & 4) !== 0;
+    const dictionaryFlag = descriptor & 3;
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (buffer.length - offset < remainingHeaderBytes) return { frames, tornStart: start };
+    offset += remainingHeaderBytes;
+    for (;;) {
+      if (buffer.length - offset < 3) return { frames, tornStart: start };
+      const blockHeader = buffer.readUIntLE(offset, 3);
+      offset += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = (blockHeader >>> 1) & 3;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 3) throw new Error(`reserved Zstandard block type at byte ${offset - 3}`);
+      const payloadBytes = blockType === 1 ? 1 : blockSize;
+      if (buffer.length - offset < payloadBytes) return { frames, tornStart: start };
+      offset += payloadBytes;
+      if (lastBlock) break;
+    }
+    if (checksum) {
+      if (buffer.length - offset < 4) return { frames, tornStart: start };
+      offset += 4;
+    }
+    frames.push({ start, end: offset });
+  }
+  return { frames };
+}
+
+function assertZstdAvailable() {
+  if (typeof zlib.zstdCompressSync !== "function" || typeof zlib.zstdDecompressSync !== "function") {
+    throw new Error("this Node.js build cannot migrate Zstandard session logs");
+  }
+}
+
+function compressZstdFrame(plaintext) {
+  return zlib.zstdCompressSync(plaintext, {
+    params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 },
+  });
+}
+
+function transformZstd(source) {
+  assertZstdAvailable();
+  const { frames, tornStart } = scanZstdFrames(source);
+  if (frames.length === 0) throw new Error("Zstandard session log has no complete header frame");
+  const output = [];
+  let repaired = 0;
+  for (const [index, frame] of frames.entries()) {
+    const encoded = source.subarray(frame.start, frame.end);
+    if (index === 0) {
+      const header = zlib.zstdDecompressSync(encoded).toString("utf8");
+      if (!header.endsWith("\n") || JSON.parse(header.trimEnd())?.type !== "session") {
+        throw new Error("Zstandard session log has an invalid header frame");
+      }
+      output.push(encoded);
+      continue;
+    }
+    const plaintext = zlib.zstdDecompressSync(encoded);
+    const transformed = transformCompleteJsonl(plaintext.toString("utf8"));
+    if (transformed.torn) throw new Error("complete Zstandard event frame has an unterminated JSONL record");
+    repaired += transformed.repaired;
+    if (transformed.repaired === 0) {
+      output.push(encoded);
+      continue;
+    }
+    const replacementPlaintext = Buffer.from(transformed.text, "utf8");
+    const replacement = compressZstdFrame(replacementPlaintext);
+    if (!zlib.zstdDecompressSync(replacement).equals(replacementPlaintext)) {
+      throw new Error("Zstandard migration verification failed");
+    }
+    output.push(replacement);
+  }
+  if (tornStart !== undefined) output.push(source.subarray(tornStart));
+  return {
+    buffer: repaired > 0 ? Buffer.concat(output) : source,
+    repaired,
+    torn: tornStart !== undefined,
+  };
+}
+
+function transformArtifact(path) {
+  const source = readFileSync(path);
+  if (path.endsWith(".zstd")) return { source, ...transformZstd(source) };
+  const transformed = transformCompleteJsonl(source.toString("utf8"));
+  return {
+    source,
+    buffer: transformed.repaired > 0 ? Buffer.from(transformed.text, "utf8") : source,
+    repaired: transformed.repaired,
+    torn: transformed.torn,
+  };
+}
+
+function writeDurably(path, content, mode) {
+  const handle = openSync(path, "wx", mode);
+  try {
+    let offset = 0;
+    while (offset < content.length) {
+      const written = writeSync(handle, content, offset, content.length - offset);
+      if (written <= 0) throw new Error(`short write while preparing session artifact: ${path}`);
+      offset += written;
+    }
+    fsyncSync(handle);
+  } finally {
+    closeSync(handle);
+  }
+}
+
+function syncDirectory(path) {
+  let handle;
+  try {
+    handle = openSync(path, "r");
+    fsyncSync(handle);
+  } catch {
+    // Windows does not expose directory fsync; the file itself was already synced.
+  } finally {
+    if (handle !== undefined) closeSync(handle);
+  }
+}
+
+function backupPathFor(path, source) {
+  const digest = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  return `${path}.odai-compat-${digest}.bak`;
+}
+
+function createVerifiedBackup(path, source) {
+  const backupPath = backupPathFor(path, source);
+  if (!existsSync(backupPath)) {
+    copyFileSync(path, backupPath, fsConstants.COPYFILE_EXCL);
+    const handle = openSync(backupPath, "r+");
+    try {
+      fsyncSync(handle);
+    } finally {
+      closeSync(handle);
+    }
+    syncDirectory(dirname(path));
+  }
+  if (!readFileSync(backupPath).equals(source)) {
+    throw new Error(`session backup does not match the migration source: ${backupPath}`);
+  }
+  return backupPath;
+}
+
+function replaceAtomically(path, source, replacement, backupPath) {
+  if (!readFileSync(path).equals(source)) {
+    throw new Error("session artifact changed while compatibility migration was preparing it; stop every DSH process and retry");
+  }
+  const temporary = `${path}.odai-compat-${process.pid}-${randomUUID()}.tmp`;
+  const mode = statSync(path).mode & 0o777;
+  let published = false;
+  try {
+    writeDurably(temporary, replacement, mode);
+    renameSync(temporary, path);
+    published = true;
+    syncDirectory(dirname(path));
+    if (!readFileSync(path).equals(replacement)) throw new Error("published session artifact failed byte verification");
+    const verified = transformArtifact(path);
+    if (verified.repaired !== 0) throw new Error("published session artifact still contains required Odai events");
+  } catch (error) {
+    if (published) {
+      const restore = `${path}.odai-restore-${process.pid}-${randomUUID()}.tmp`;
+      try {
+        writeDurably(restore, readFileSync(backupPath), mode);
+        renameSync(restore, path);
+        syncDirectory(dirname(path));
+      } finally {
+        rmSync(restore, { force: true });
+      }
+    }
+    throw error;
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+
+function processLegacySessionLogs(options, writeChanges) {
+  const dshHome = resolveDshHome(options.dshHome);
+  const sessionRoot = resolve(options.sessionRoot ?? resolve(dshHome, "sessions"));
+  const artifacts = listSessionArtifacts(sessionRoot);
+  const result = {
+    dshHome,
+    sessionRoot,
+    scannedArtifacts: artifacts.length,
+    matchedArtifacts: 0,
+    matchedEvents: 0,
+    repairedArtifacts: 0,
+    repairedEvents: 0,
+    backupPaths: [],
+    tornArtifacts: [],
+    failures: [],
+  };
+
+  for (const path of artifacts) {
+    try {
+      const transformed = transformArtifact(path);
+      if (transformed.torn) result.tornArtifacts.push(path);
+      if (transformed.repaired === 0) continue;
+      result.matchedArtifacts += 1;
+      result.matchedEvents += transformed.repaired;
+      if (!writeChanges) continue;
+      const backupPath = createVerifiedBackup(path, transformed.source);
+      replaceAtomically(path, transformed.source, transformed.buffer, backupPath);
+      result.backupPaths.push(backupPath);
+      result.repairedArtifacts += 1;
+      result.repairedEvents += transformed.repaired;
+    } catch (error) {
+      result.failures.push({
+        path,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  return result;
+}
+
+export function inspectLegacySessionLogs(options = {}) {
+  return processLegacySessionLogs(options, false);
+}
+
+export function repairLegacySessionLogs(options = {}) {
+  if (options.confirmDshStopped !== true) {
+    throw new Error("refusing to rewrite session artifacts until confirmDshStopped is true; stop every DSH process first");
+  }
+  assertDshStopped(options);
+  return processLegacySessionLogs(options, true);
+}

package/preset/odai/runtime/session-evidence.mjs

@@ -0,0 +1,344 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  ftruncateSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeSync,
+} from "node:fs";
+import { dirname, resolve } from "node:path";
+
+const STORE_SCHEMA_VERSION = 1;
+const GLOBAL_STATE_KEY = Symbol.for("odai.dsh.session-evidence.v2");
+
+function sharedState() {
+  if (!globalThis[GLOBAL_STATE_KEY]) {
+    Object.defineProperty(globalThis, GLOBAL_STATE_KEY, {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: { bySession: new WeakMap() },
+    });
+  }
+  return globalThis[GLOBAL_STATE_KEY];
+}
+
+function isOdaiEvent(event) {
+  return typeof event?.type === "string" && event.type.startsWith("odai/");
+}
+
+function sessionIdOf(agent) {
+  const id = agent?.session?.header?.id;
+  return typeof id === "string" && id !== "" ? id : undefined;
+}
+
+function evidencePath(root, sessionId) {
+  const key = createHash("sha256").update(sessionId).digest("hex");
+  return resolve(root, `${key}.jsonl`);
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function evidenceId(type, data) {
+  let identity;
+  if (Number.isSafeInteger(data?.turn) && Number.isSafeInteger(data?.step)) {
+    identity = `${type}:${data.turn}:${data.step}`;
+  } else if (typeof data?.callId === "string" && data.callId !== "") {
+    identity = `${type}:${data.callId}`;
+  } else {
+    identity = `${type}:${stableJson(data)}`;
+  }
+  return createHash("sha256").update(identity).digest("hex");
+}
+
+function snapshotData(data, type) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(data);
+  } catch (error) {
+    throw new Error(`odai evidence ${type} is not JSON-serializable`, { cause: error });
+  }
+  if (encoded === undefined) throw new Error(`odai evidence ${type} is not JSON-serializable`);
+  return JSON.parse(encoded);
+}
+
+function readCompleteLines(path, strict) {
+  if (!existsSync(path)) return [];
+  const text = readFileSync(path, "utf8");
+  if (strict && text !== "" && !text.endsWith("\n")) {
+    throw new Error(`odai evidence log has an unterminated final record: ${path}`);
+  }
+  const completeLength = text.endsWith("\n") ? text.length : text.lastIndexOf("\n") + 1;
+  if (completeLength <= 0) return [];
+  return text.slice(0, completeLength).split("\n").filter(Boolean);
+}
+
+function readStoredState(root, sessionId, logger, strict = false) {
+  const path = evidencePath(root, sessionId);
+  const events = [];
+  const ids = new Set();
+  for (const [index, line] of readCompleteLines(path, strict).entries()) {
+    try {
+      const record = JSON.parse(line);
+      if (record?.schemaVersion !== STORE_SCHEMA_VERSION
+        || record.sessionId !== sessionId
+        || !isOdaiEvent(record)
+        || !Number.isSafeInteger(record.time)
+        || record.time < 0
+        || record.data === undefined) {
+        throw new Error("invalid evidence record");
+      }
+      const id = typeof record.id === "string" && record.id !== ""
+        ? record.id
+        : evidenceId(record.type, record.data);
+      if (ids.has(id)) continue;
+      ids.add(id);
+      events.push(Object.freeze({ id, type: record.type, time: record.time, data: record.data }));
+    } catch (error) {
+      if (strict) throw new Error(`invalid odai evidence at ${path}:${index + 1}`, { cause: error });
+      logger.warn(`ignored invalid odai evidence at ${path}:${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { events, ids };
+}
+
+function mergeUnique(target, events) {
+  for (const event of events) {
+    const id = event.id ?? evidenceId(event.type, event.data);
+    if (target.ids.has(id)) continue;
+    target.ids.add(id);
+    target.events.push(Object.freeze({ id, type: event.type, time: event.time, data: event.data }));
+  }
+}
+
+function stateFor(agent, root, logger) {
+  const session = agent?.session;
+  const owner = session && typeof session === "object"
+    ? session
+    : agent && typeof agent === "object"
+      ? agent
+      : undefined;
+  if (!owner) return { events: [], ids: new Set(), sessionId: undefined };
+
+  const shared = sharedState();
+  let roots = shared.bySession.get(owner);
+  if (!roots) {
+    roots = new Map();
+    shared.bySession.set(owner, roots);
+  }
+  const existing = roots.get(root);
+  if (existing) return existing;
+
+  const sessionId = sessionIdOf(agent);
+  const state = { events: [], ids: new Set(), sessionId };
+  const legacy = Array.isArray(session?.events) ? session.events.filter(isOdaiEvent) : [];
+  mergeUnique(state, legacy);
+  if (sessionId) mergeUnique(state, readStoredState(root, sessionId, logger).events);
+  roots.set(root, state);
+  return state;
+}
+
+function readLockOwner(lockPath) {
+  try {
+    const value = readFileSync(lockPath, "utf8").trim();
+    const separator = value.indexOf(":");
+    const pid = Number(separator < 0 ? "" : value.slice(0, separator));
+    return Number.isSafeInteger(pid) && pid > 0 && separator < value.length - 1
+      ? { value, pid }
+      : undefined;
+  } catch (error) {
+    if (error?.code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
+
+function createLock(lockPath, owner) {
+  const handle = openSync(lockPath, "wx", 0o600);
+  try {
+    const content = Buffer.from(`${owner}\n`, "utf8");
+    if (writeSync(handle, content, 0, content.length) !== content.length) {
+      throw new Error(`short write while acquiring odai evidence lock: ${lockPath}`);
+    }
+    fsyncSync(handle);
+    return handle;
+  } catch (error) {
+    closeSync(handle);
+    rmSync(lockPath, { force: true });
+    throw error;
+  }
+}
+
+function releaseLock(handle, lockPath, owner) {
+  closeSync(handle);
+  const current = readLockOwner(lockPath);
+  if (current === undefined) throw new Error(`odai evidence lock disappeared before release: ${lockPath}`);
+  if (current.value !== owner) throw new Error(`odai evidence lock ownership changed before release: ${lockPath}`);
+  rmSync(lockPath);
+}
+
+function acquireLock(path) {
+  const lockPath = `${path}.lock`;
+  const claimPath = `${lockPath}.claim`;
+  const owner = `${process.pid}:${randomUUID()}`;
+  const claimOwner = `${process.pid}:${randomUUID()}`;
+  let claimHandle;
+  try {
+    claimHandle = createLock(claimPath, claimOwner);
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      throw new Error(`odai evidence lock acquisition is already in progress: ${path}`);
+    }
+    throw error;
+  }
+
+  let handle;
+  try {
+    try {
+      handle = createLock(lockPath, owner);
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      const current = readLockOwner(lockPath);
+      if (current === undefined || processIsAlive(current.pid)) {
+        throw new Error(`odai evidence is being updated by another runtime: ${path}`);
+      }
+      rmSync(lockPath);
+      handle = createLock(lockPath, owner);
+    }
+  } finally {
+    try {
+      releaseLock(claimHandle, claimPath, claimOwner);
+    } catch (error) {
+      if (handle !== undefined) {
+        try {
+          releaseLock(handle, lockPath, owner);
+        } catch {
+          // Preserve the claim failure; lock cleanup already failed closed.
+        }
+        handle = undefined;
+      }
+      throw error;
+    }
+  }
+
+  if (handle === undefined) throw new Error(`could not lock odai evidence: ${path}`);
+  return () => releaseLock(handle, lockPath, owner);
+}
+
+function syncDirectory(path) {
+  let handle;
+  try {
+    handle = openSync(path, "r");
+    fsyncSync(handle);
+  } catch {
+    // Windows does not expose directory fsync; the evidence file itself was synced.
+  } finally {
+    if (handle !== undefined) closeSync(handle);
+  }
+}
+
+function persistRecord(root, sessionId, record, logger) {
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  const path = evidencePath(root, sessionId);
+  const release = acquireLock(path);
+  try {
+    const stored = readStoredState(root, sessionId, logger, true);
+    if (stored.ids.has(record.id)) return false;
+    const encoded = Buffer.from(`${JSON.stringify(record)}\n`, "utf8");
+    const originalSize = existsSync(path) ? statSync(path).size : 0;
+    const handle = openSync(path, "a", 0o600);
+    try {
+      let offset = 0;
+      while (offset < encoded.length) {
+        const written = writeSync(handle, encoded, offset, encoded.length - offset);
+        if (written <= 0) throw new Error(`short write while persisting odai evidence: ${path}`);
+        offset += written;
+      }
+      fsyncSync(handle);
+    } catch (error) {
+      ftruncateSync(handle, originalSize);
+      fsyncSync(handle);
+      throw error;
+    } finally {
+      closeSync(handle);
+    }
+    syncDirectory(root);
+    return true;
+  } finally {
+    release();
+  }
+}
+
+export function resolveSessionEvidenceRoot(routingConfigPath) {
+  return resolve(dirname(routingConfigPath), "session-evidence");
+}
+
+export function readStoredSessionEvidence(root, sessionId, logger = { warn() {} }) {
+  if (typeof sessionId !== "string" || sessionId === "") return [];
+  return readStoredState(resolve(root), sessionId, logger).events;
+}
+
+export function createSessionEvidence(options) {
+  const root = resolve(options.root);
+  const logger = options.logger ?? { warn() {} };
+
+  const events = (agent) => stateFor(agent, root, logger).events.slice();
+  const has = (agent, type, predicate = () => true) => stateFor(agent, root, logger)
+    .events
+    .some((event) => event.type === type && predicate(event.data));
+  const append = (agent, type, data) => {
+    if (typeof type !== "string" || !type.startsWith("odai/")) {
+      throw new TypeError("odai evidence type must start with odai/");
+    }
+    const state = stateFor(agent, root, logger);
+    const snapshot = snapshotData(data, type);
+    const id = evidenceId(type, snapshot);
+    const event = Object.freeze({ id, type, time: Date.now(), data: snapshot });
+    if (state.ids.has(id)) return state.events.find((candidate) => candidate.id === id);
+
+    if (!state.sessionId) {
+      state.ids.add(id);
+      state.events.push(event);
+      try {
+        agent?.session?.append?.(type, event.data);
+      } catch (error) {
+        logger.warn(`failed to append transient ${type}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return event;
+    }
+
+    const record = {
+      schemaVersion: STORE_SCHEMA_VERSION,
+      id,
+      sessionId: state.sessionId,
+      type,
+      time: event.time,
+      data: event.data,
+    };
+    persistRecord(root, state.sessionId, record, logger);
+    state.ids.add(id);
+    state.events.push(event);
+    return event;
+  };
+
+  return Object.freeze({ append, events, has, root });
+}

package/scripts/verify-agent-load.mjs

@@ -30,16 +30,29 @@ const yaml = (value) => JSON.stringify(value);
 
 function findDshPackageRoot(command) {
   const locator = process.platform === "win32" ? "where" : "which";
-  const located = execFileSync(locator, [command], { encoding: "utf8" }).trim().split(/\r?\n/u)[0];
-  let current = dirname(realpathSync(located));
-  while (dirname(current) !== current) {
-    try {
-      const metadata = JSON.parse(readFileSync(resolve(current, "package.json"), "utf8"));
-      if (metadata.name === "@deepseek-ai/dsh") return current;
-    } catch (error) {
-      if (error?.code !== "ENOENT") throw error;
+  const located = execFileSync(locator, [command], { encoding: "utf8" })
+    .trim()
+    .split(/\r?\n/u)
+    .filter(Boolean);
+  const candidates = new Set();
+  for (const path of located) {
+    const commandDir = dirname(realpathSync(path));
+    candidates.add(commandDir);
+    candidates.add(resolve(commandDir, "node_modules/@deepseek-ai/dsh"));
+  }
+  for (const candidate of candidates) {
+    let current = candidate;
+    for (;;) {
+      try {
+        const metadata = JSON.parse(readFileSync(resolve(current, "package.json"), "utf8"));
+        if (metadata.name === "@deepseek-ai/dsh") return current;
+      } catch (error) {
+        if (error?.code !== "ENOENT") throw error;
+      }
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
     }
-    current = dirname(current);
   }
   throw new Error(`cannot locate the @deepseek-ai/dsh package behind ${command}`);
 }
@@ -50,7 +63,8 @@ async function verifyPinnedComposition() {
     throw new Error(`agent preset expects DSH ${SUPPORTED_DSH_VERSION}, found ${dshMetadata.version}`);
   }
 
-  const standard = await readFile(resolve(dshRoot, "config/agent-presets/standard/agent.cordis.yml"), "utf8");
+  const standard = (await readFile(resolve(dshRoot, "config/agent-presets/standard/agent.cordis.yml"), "utf8"))
+    .replace(/\r\n/gu, "\n");
   const odaiSuffix = [
     "# Odai contributes scoped prompt, guard, routing, user-owned responsibility",
     "# mappings, and evidence listeners. Base controller selection stays host-owned.",
@@ -71,7 +85,9 @@ async function verifyPinnedComposition() {
       "You are Odai, a coding agent. Your working directory is {{cwd}}.",
     )
     .trimEnd()}\n\n${odaiSuffix}`;
-  const actual = (await readFile(resolve(agentRoot, "preset/odai/agent.cordis.yml"), "utf8")).trimEnd();
+  const actual = (await readFile(resolve(agentRoot, "preset/odai/agent.cordis.yml"), "utf8"))
+    .replace(/\r\n/gu, "\n")
+    .trimEnd();
   if (actual !== expected) {
     throw new Error("Odai Agent composition drifted from the pinned DSH standard preset");
   }
@@ -127,6 +143,23 @@ async function waitForMarker(child, output) {
   throw new Error(`timed out waiting for scope marker\n${output()}`);
 }
 
+async function terminateChild(child) {
+  if (process.platform === "win32" && child.pid) {
+    try {
+      execFileSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+    } catch {
+      if (child.exitCode === null) child.kill("SIGTERM");
+    }
+  } else if (child.exitCode === null) {
+    child.kill("SIGTERM");
+  }
+  await new Promise((accept) => {
+    if (child.exitCode !== null) return accept();
+    const timeout = setTimeout(() => { child.kill("SIGKILL"); accept(); }, 3_000);
+    child.once("exit", () => { clearTimeout(timeout); accept(); });
+  });
+}
+
 await mkdir(workspace, { recursive: true });
 await cp(resolve(agentRoot, "preset/odai"), sourceRoot, { recursive: true });
 const developmentRuntime = resolve(repoRoot, "dsh/runtime/src");
@@ -147,7 +180,7 @@ await writeFile(probePluginPath, probePlugin, "utf8");
 await writeFile(patchPath, [
   "- insert:",
   "    - id: odai-agent-scope-probe",
-  `      name: ${yaml(probePluginPath)}`,
+  `      name: ${yaml(pathToFileURL(probePluginPath).href)}`,
   "      config:",
   `        markerPath: ${yaml(markerPath)}`,
   `        standardWritePath: ${yaml(resolve(workspace, "standard-child-write.txt"))}`,
@@ -206,13 +239,8 @@ try {
   }
   process.stdout.write(`${JSON.stringify({ scratch, roster: ids, results }, null, 2)}\n`);
 } finally {
-  child.kill("SIGTERM");
-  await new Promise((accept) => {
-    if (child.exitCode !== null) return accept();
-    const timeout = setTimeout(() => { child.kill("SIGKILL"); accept(); }, 3_000);
-    child.once("exit", () => { clearTimeout(timeout); accept(); });
-  });
+  await terminateChild(child);
   if (process.env.KEEP_ODAI_SCOPE_PROBE !== "1") {
-    await rm(scratch, { recursive: true, force: true });
+    await rm(scratch, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
   }
 }

package/src/installer.mjs

@@ -12,7 +12,7 @@ import {
 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { parse as parseYaml } from "yaml";
 
@@ -27,6 +27,8 @@ const requiredFiles = Object.freeze([
   "agent.cordis.yml",
   "preset.yml",
   "runtime/index.mjs",
+  "runtime/session-compat.mjs",
+  "runtime/session-evidence.mjs",
   "skills/odai/SKILL.md",
 ]);
 
@@ -65,6 +67,12 @@ export async function installAgentPreset(options = {}) {
   }
 
   await assertSource(sourceRoot);
+  const sessionCompatibility = await repairSessionCompatibility(
+    dshHome,
+    [sourceRoot],
+    options.confirmDshStopped === true,
+    options.processScanner,
+  );
   await mkdir(targetRoot, { recursive: true, mode: 0o700 });
   const staging = resolve(targetRoot, `.${presetId}.tmp-${process.pid}-${randomUUID()}`);
   const backup = resolve(targetRoot, `.${presetId}.backup-${process.pid}-${randomUUID()}`);
@@ -111,6 +119,7 @@ export async function installAgentPreset(options = {}) {
       version: packageMetadata.version,
       trust: "user",
       security: "DSH user presets have the same privileges as shell access; install only reviewed preset code.",
+      sessionCompatibility,
     });
   } catch (error) {
     await rm(staging, { recursive: true, force: true });
@@ -133,8 +142,22 @@ export async function uninstallAgentPreset(options = {}) {
     throw new Error(`refusing to remove modified preset at ${inspected.target}: ${inspected.issues.join("; ")}`);
   }
   await assertPresetIsNotDefault(inspected.dshHome, inspected.presetId);
+  const sessionCompatibility = await repairSessionCompatibility(
+    inspected.dshHome,
+    [defaultSourceRoot, inspected.target],
+    options.confirmDshStopped === true,
+    options.processScanner,
+  );
+  if (sessionCompatibility.failures.length > 0) {
+    throw new Error(`refusing to uninstall before legacy Odai session evidence is made ignorable: ${sessionCompatibility.failures.map((failure) => `${failure.path}: ${failure.error}`).join("; ")}`);
+  }
   await rm(inspected.target, { recursive: true, force: true });
-  return Object.freeze({ operation: "uninstalled", target: inspected.target, presetId: inspected.presetId });
+  return Object.freeze({
+    operation: "uninstalled",
+    target: inspected.target,
+    presetId: inspected.presetId,
+    sessionCompatibility,
+  });
 }
 
 async function assertPresetIsNotDefault(dshHome, presetId) {
@@ -206,6 +229,36 @@ function validateManifest(manifest, presetId) {
   return issues;
 }
 
+async function repairSessionCompatibility(dshHome, sourceRoots, confirmDshStopped, processScanner) {
+  for (const sourceRoot of sourceRoots) {
+    const modulePath = resolve(sourceRoot, "runtime/session-compat.mjs");
+    if (await pathState(modulePath) !== "file") continue;
+    const compatibility = await import(pathToFileURL(modulePath).href);
+    if (typeof compatibility.inspectLegacySessionLogs !== "function"
+      || typeof compatibility.repairLegacySessionLogs !== "function") {
+      throw new Error(`agent package session compatibility module is invalid: ${modulePath}`);
+    }
+    const inspected = compatibility.inspectLegacySessionLogs({ dshHome });
+    if (inspected.failures.length > 0) {
+      throw new Error(`cannot inspect legacy Odai session evidence safely: ${inspected.failures.map((failure) => `${failure.path}: ${failure.error}`).join("; ")}`);
+    }
+    if (inspected.matchedEvents === 0) return inspected;
+    if (!confirmDshStopped) {
+      throw new Error(`found ${inspected.matchedEvents} legacy Odai session event(s); stop every DSH process and rerun with --yes before changing the Agent preset`);
+    }
+    const repaired = compatibility.repairLegacySessionLogs({
+      dshHome,
+      confirmDshStopped: true,
+      processScanner,
+    });
+    if (repaired.failures.length > 0) {
+      throw new Error(`cannot repair legacy Odai session evidence safely: ${repaired.failures.map((failure) => `${failure.path}: ${failure.error}`).join("; ")}`);
+    }
+    return repaired;
+  }
+  throw new Error("agent package is incomplete: missing runtime/session-compat.mjs");
+}
+
 async function assertSource(sourceRoot) {
   for (const path of requiredFiles) {
     const state = await pathState(resolve(sourceRoot, path));