odai-dsh-agent 0.2.5 → 0.2.6

package/scripts/verify-agent-load.mjs

@@ -1,260 +0,0 @@
-import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { createRequire } from "node:module";
-import { createServer } from "node:net";
-import { tmpdir } from "node:os";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { execFileSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-
-import { spawnDsh } from "../src/dsh-version.mjs";
-import {
-  installAgentPreset,
-  renderAgentCompositionForDsh,
-  SUPPORTED_DSH_VERSIONS,
-} from "../src/installer.mjs";
-
-const agentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const repoRoot = resolve(agentRoot, "../..");
-const dsh = process.env.DSH_BIN ?? "dsh";
-const dshRoot = process.env.DSH_PACKAGE_ROOT
-  ? resolve(process.env.DSH_PACKAGE_ROOT)
-  : findDshPackageRoot(dsh);
-const requireFromDsh = createRequire(resolve(dshRoot, "package.json"));
-const scopeModule = requireFromDsh.resolve("@deepseek-ai/dsh-scope");
-const targetDshVersion = await verifyPinnedComposition();
-const scratch = await mkdtemp(resolve(tmpdir(), "odai-agent-scope-"));
-const home = resolve(scratch, "home");
-const workspace = resolve(scratch, "workspace");
-const sourceRoot = resolve(scratch, "source-preset");
-const markerPath = resolve(scratch, "scope-results.json");
-const probePluginPath = resolve(scratch, "scope-probe-plugin.mjs");
-const patchPath = resolve(scratch, "scope-probe.patch.yml");
-
-const yaml = (value) => JSON.stringify(value);
-
-function findDshPackageRoot(command) {
-  const locator = process.platform === "win32" ? "where" : "which";
-  const located = existsSync(command)
-    ? [resolve(command)]
-    : 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"));
-    candidates.add(resolve(commandDir, "../@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;
-    }
-  }
-  throw new Error(`cannot locate the @deepseek-ai/dsh package behind ${command}`);
-}
-
-async function verifyPinnedComposition() {
-  const dshMetadata = JSON.parse(await readFile(resolve(dshRoot, "package.json"), "utf8"));
-  if (!SUPPORTED_DSH_VERSIONS.includes(dshMetadata.version)) {
-    throw new Error(`agent preset expects one of ${SUPPORTED_DSH_VERSIONS.join(", ")}, found ${dshMetadata.version}`);
-  }
-
-  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.",
-    "- id: odai-governance",
-    "  name: ./runtime/index.mjs",
-    "  config:",
-    "    routing:",
-    "      mode: auto",
-    "      provider: spawn",
-  ].join("\n");
-  const expected = `${standard
-    .replace(
-      "# The preset's own persona, shadowing the deployment default for this agent.\n# `{{model}}` and `{{cwd}}` resolve from the agent's own route and workspace.",
-      "# The preset's own model-neutral persona shadows the deployment default. Auto\n# routing can upgrade after prompt assembly; `{{cwd}}` remains workspace-local.",
-    )
-    .replace(
-      "You are a coding agent powered by the {{model}} model. Your working directory is {{cwd}}.",
-      "You are Odai, a coding agent. Your working directory is {{cwd}}.",
-    )
-    .trimEnd()}\n\n${odaiSuffix}`;
-  const actual = renderAgentCompositionForDsh(
-    await readFile(resolve(agentRoot, "preset/odai/agent.cordis.yml"), "utf8"),
-    dshMetadata.version,
-  ).trimEnd();
-  if (actual !== expected) {
-    throw new Error(`Odai Agent composition drifted from the DSH ${dshMetadata.version} standard preset`);
-  }
-  return dshMetadata.version;
-}
-
-async function freePort() {
-  return await new Promise((accept, reject) => {
-    const server = createServer();
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address();
-      const port = typeof address === "object" && address ? address.port : undefined;
-      server.close((error) => error ? reject(error) : accept(port));
-    });
-  });
-}
-
-async function rpc(baseUrl, method, payload) {
-  const rpcId = randomUUID();
-  const response = await fetch(`${baseUrl}/api/${method}`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ type: "client-request", rpcId, method, payload }),
-  });
-  const text = await response.text();
-  if (!response.ok) throw new Error(`${method} HTTP ${response.status}: ${text}`);
-  const body = JSON.parse(text);
-  if (body.result?.ok !== true) throw new Error(`${method} failed: ${text}`);
-  return body.result.value;
-}
-
-async function waitForServer(baseUrl, child, output) {
-  const deadline = Date.now() + 20_000;
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null) throw new Error(`dsh web exited early (${child.exitCode})\n${output()}`);
-    try {
-      await rpc(baseUrl, "agentPreset.list", {});
-      return;
-    } catch {
-      await new Promise((accept) => setTimeout(accept, 75));
-    }
-  }
-  throw new Error(`timed out waiting for dsh web\n${output()}`);
-}
-
-async function waitForMarker(child, output) {
-  const deadline = Date.now() + 15_000;
-  while (Date.now() < deadline) {
-    if (existsSync(markerPath)) return JSON.parse(await readFile(markerPath, "utf8"));
-    if (child.exitCode !== null) throw new Error(`dsh web exited before probe completed (${child.exitCode})\n${output()}`);
-    await new Promise((accept) => setTimeout(accept, 50));
-  }
-  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");
-const developmentSkill = resolve(repoRoot, "skills/odai");
-if (existsSync(developmentRuntime) && existsSync(developmentSkill)) {
-  await Promise.all([
-    cp(developmentRuntime, resolve(sourceRoot, "runtime"), { recursive: true }),
-    cp(developmentSkill, resolve(sourceRoot, "skills/odai"), { recursive: true }),
-  ]);
-} else if (!existsSync(resolve(sourceRoot, "runtime/index.mjs"))
-  || !existsSync(resolve(sourceRoot, "skills/odai/SKILL.md"))) {
-  throw new Error("Odai Agent verification requires either repository sources or packaged runtime and skill files");
-}
-await installAgentPreset({ dshHome: home, sourceRoot, dshVersion: targetDshVersion });
-
-const probePlugin = `import { existsSync, writeFileSync } from "node:fs";\nimport { bindScopeParent } from ${JSON.stringify(pathToFileURL(scopeModule).href)};\n\nexport const name = "odai-agent-scope-probe";\nexport const inject = ["systemPrompt", "tools"];\n\nexport function apply(ctx, config) {\n  const results = {};\n  let writing = Promise.resolve();\n\n  ctx.on("agent/created", ({ agent }) => {\n    writing = writing.then(async () => {\n      const preset = agent.session?.header?.agentPreset;\n      if (preset !== "standard" && preset !== "odai") return;\n\n      const assembly = await ctx.systemPrompt.assemble({ agent, scope: agent });\n      const canonicalSections = assembly.sections.filter((section) => section.name === "odai:canonical-governance");\n      if (preset === "odai") {\n        const coldNames = assembly.tools.map((tool) => tool.name).filter((toolName) => toolName.startsWith("odai_")).sort();\n        const expectedColdNames = ["odai_context_capability", "odai_responsibility_gap"];\n        if (JSON.stringify(coldNames) !== JSON.stringify(expectedColdNames)) {\n          throw new Error(\`cold Odai tool schema mismatch: \${JSON.stringify(coldNames)}\`);\n        }\n        const hiddenResult = await ctx.tools.execute({\n          callId: "scope-probe-odai-hidden-routing",\n          name: "odai_routing_config",\n          arguments: { action: "show" },\n          agent,\n          signal: new AbortController().signal,\n        });\n        if (!hiddenResult.isError || !/unknown tool/u.test(hiddenResult.error?.message ?? "")) {\n          throw new Error(\`hidden Odai routing tool remained executable: \${JSON.stringify(hiddenResult)}\`);\n        }\n        agent.session.append("turn/start", { turn: 1 });\n        agent.session.append("step/start", { turn: 1, step: 1 });\n        const gatewayResult = await ctx.tools.execute({\n          callId: "scope-probe-odai-routing-gateway",\n          name: "odai_context_capability",\n          arguments: { capability: "routing-config" },\n          agent,\n          signal: new AbortController().signal,\n        });\n        if (gatewayResult.isError) throw new Error(\`Odai capability gateway failed: \${JSON.stringify(gatewayResult)}\`);\n        const activatedAssembly = await ctx.systemPrompt.assemble({ agent, scope: agent });\n        const activatedNames = activatedAssembly.tools.map((tool) => tool.name).filter((toolName) => toolName.startsWith("odai_")).sort();\n        const expectedActivatedNames = ["odai_context_capability", "odai_responsibility_gap", "odai_routing_config"].sort();\n        if (JSON.stringify(activatedNames) !== JSON.stringify(expectedActivatedNames)) {\n          throw new Error(\`activated Odai tool schema mismatch: \${JSON.stringify(activatedNames)}\`);\n        }\n      }\n      const writePath = preset === "odai" ? config.odaiWritePath : config.standardWritePath;\n      const childSession = new Proxy(agent.session, {\n        get(target, property) {\n          if (property === "header") {\n            return { ...target.header, origin: "subagent", delegationDepth: 1 };\n          }\n          return Reflect.get(target, property, target);\n        },\n      });\n      const child = { id: agent.id, session: childSession };\n      bindScopeParent(child, agent);\n      const toolResult = await ctx.tools.execute({\n        callId: \`scope-probe-\${preset}\`,\n        name: "write",\n        arguments: { file_path: writePath, content: \`\${preset} child write reached body\\n\` },\n        agent: child,\n        signal: new AbortController().signal,\n      });\n\n      let routingProtected;\n      if (preset === "odai") {\n        const routingResult = await ctx.tools.execute({\n          callId: "scope-probe-odai-routing-config",\n          name: "odai_routing_config",\n          arguments: { action: "set", responsibility: "executor", provider: "probe-provider", model: "probe-executor", reasoningEffort: "high" },\n          agent,\n          signal: new AbortController().signal,\n        });\n        routingProtected = routingResult.isError === true\n          && /NO_ADAPTER/u.test(routingResult.error?.message ?? "")\n          && !existsSync(config.routingConfigPath);\n      }\n\n      results[preset] = {\n        canonicalSectionCount: canonicalSections.length,\n        toolIsError: toolResult.isError === true,\n        toolError: toolResult.isError === true ? toolResult.error?.message : undefined,\n        writeReachedBody: existsSync(writePath),\n        ...(routingProtected === undefined ? {} : { routingProtected }),\n        ...(preset === "odai" ? { toolExposureSynchronized: true } : {}),\n      };\n      if (results.standard && results.odai) {\n        writeFileSync(config.markerPath, JSON.stringify(results, null, 2) + "\\n", "utf8");\n      }\n    }).catch((error) => {\n      writeFileSync(config.markerPath, JSON.stringify({ probeError: error?.stack ?? String(error) }, null, 2) + "\\n", "utf8");\n    });\n  }, { global: true });\n}\n`;
-await writeFile(probePluginPath, probePlugin, "utf8");
-await writeFile(patchPath, [
-  "- insert:",
-  "    - id: odai-agent-scope-probe",
-  `      name: ${yaml(pathToFileURL(probePluginPath).href)}`,
-  "      config:",
-  `        markerPath: ${yaml(markerPath)}`,
-  `        standardWritePath: ${yaml(resolve(workspace, "standard-child-write.txt"))}`,
-  `        odaiWritePath: ${yaml(resolve(workspace, "odai-child-write.txt"))}`,
-  `        routingConfigPath: ${yaml(resolve(home, "odai/routing.json"))}`,
-  "",
-].join("\n"), "utf8");
-
-const port = await freePort();
-const baseUrl = `http://127.0.0.1:${port}`;
-const child = spawnDsh(dsh, [
-  "--profile", "web",
-  "--patch", patchPath,
-  "--host", "127.0.0.1",
-  "--port", String(port),
-], {
-  cwd: workspace,
-  env: {
-    ...process.env,
-    DSH_HOME: home,
-    DSH_TELEMETRY_MODE: "DISABLED",
-  },
-  stdio: ["ignore", "pipe", "pipe"],
-});
-let output = "";
-child.stdout.on("data", (chunk) => { output += chunk.toString(); });
-child.stderr.on("data", (chunk) => { output += chunk.toString(); });
-const capturedOutput = () => output;
-
-try {
-  await waitForServer(baseUrl, child, capturedOutput);
-  const roster = await rpc(baseUrl, "agentPreset.list", {});
-  const ids = roster.presets.map((preset) => preset.id);
-  if (!ids.includes("standard") || !ids.includes("odai")) {
-    throw new Error(`expected standard and odai presets, got ${JSON.stringify(ids)}`);
-  }
-  await rpc(baseUrl, "session.create", { cwd: workspace, agentPreset: "standard" });
-  await rpc(baseUrl, "session.create", { cwd: workspace, agentPreset: "odai" });
-  const results = await waitForMarker(child, capturedOutput);
-  if (results.probeError) throw new Error(results.probeError);
-  if (results.standard?.canonicalSectionCount !== 0) {
-    throw new Error(`standard saw odai canonical prompt: ${JSON.stringify(results)}`);
-  }
-  if (results.standard?.toolError?.startsWith("ODAI_SUBAGENT_BOUNDARY:")) {
-    throw new Error(`standard child call reached the odai guard: ${JSON.stringify(results)}`);
-  }
-  if (results.odai?.canonicalSectionCount !== 1) {
-    throw new Error(`odai canonical prompt count was not exactly one: ${JSON.stringify(results)}`);
-  }
-  if (results.odai?.writeReachedBody !== false || results.odai?.toolIsError !== true
-    || !results.odai?.toolError?.startsWith("ODAI_SUBAGENT_BOUNDARY:")) {
-    throw new Error(`odai child write was not denied by odai guard: ${JSON.stringify(results)}`);
-  }
-  if (results.odai?.toolExposureSynchronized !== true) {
-    throw new Error(`odai tool schemas and execution visibility were not synchronized: ${JSON.stringify(results)}`);
-  }
-  if (results.odai?.routingProtected !== true) {
-    throw new Error(`odai routing tool did not reject an unavailable route without mutation: ${JSON.stringify(results)}`);
-  }
-  process.stdout.write(`${JSON.stringify({ scratch, roster: ids, results }, null, 2)}\n`);
-} finally {
-  await terminateChild(child);
-  if (process.env.KEEP_ODAI_SCOPE_PROBE !== "1") {
-    await rm(scratch, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-  }
-}

package/src/dsh-version.mjs

@@ -1,24 +0,0 @@
-import { execFileSync, spawn } from "node:child_process";
-
-export function readDshVersion({
-  dsh = process.env.DSH_BIN ?? "dsh",
-  platform = process.platform,
-  execute = execFileSync,
-} = {}) {
-  return execute(normalizeDshCommand(dsh, platform), ["-V"], dshProcessOptions({ encoding: "utf8" }, platform)).trim();
-}
-
-export function spawnDsh(command, args, options = {}, {
-  platform = process.platform,
-  execute = spawn,
-} = {}) {
-  return execute(normalizeDshCommand(command, platform), args, dshProcessOptions(options, platform));
-}
-
-function normalizeDshCommand(command, platform) {
-  return platform === "win32" && command === "dsh" ? "dsh.cmd" : command;
-}
-
-function dshProcessOptions(options, platform) {
-  return platform === "win32" ? { ...options, shell: true } : options;
-}

package/src/installer.mjs

@@ -1,385 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import {
-  chmod,
-  cp,
-  lstat,
-  mkdir,
-  readFile,
-  readdir,
-  rename,
-  rm,
-  writeFile,
-} from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, relative, resolve, sep } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-import { parse as parseYaml } from "yaml";
-
-export const DEFAULT_PRESET_ID = "odai";
-export const MANIFEST_FILE = ".odai-agent.json";
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const defaultSourceRoot = resolve(packageRoot, "preset/odai");
-const packageMetadata = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
-const DSH_VERSION_PATTERN = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
-export const SUPPORTED_DSH_VERSIONS = Object.freeze(
-  packageMetadata.peerDependencies["@deepseek-ai/dsh"]
-    .split(/\s*\|\|\s*/u)
-    .filter(Boolean),
-);
-if (SUPPORTED_DSH_VERSIONS.length === 0 || SUPPORTED_DSH_VERSIONS.some((version) => !DSH_VERSION_PATTERN.test(version))) {
-  throw new Error("odai-dsh-agent peer dependency must list exact supported DSH versions");
-}
-const SOURCE_DSH_VERSION = "0.1.0-rc.8";
-const OPTIONAL_PROVIDER_COMMENTS = Object.freeze({
-  "0.1.0-rc.7": "    # Production dsh does not install these optional providers. An opting-in\n    # Profile mounts each provider once on the host plane; copy this preset,\n    # then remove `disabled` from the matching tool row.",
-  "0.1.0-rc.8": "    # Production dsh does not install these optional providers. Install the\n    # matching Bundle in this Profile and restart the Host, then copy this\n    # preset and remove `disabled` from the matching tool row. Host availability\n    # alone grants no tool.",
-});
-const compositionVersions = Object.keys(OPTIONAL_PROVIDER_COMMENTS);
-if (JSON.stringify(SUPPORTED_DSH_VERSIONS) !== JSON.stringify(compositionVersions)) {
-  throw new Error(`Odai Agent peer versions ${SUPPORTED_DSH_VERSIONS.join(", ")} must exactly match composition contracts ${compositionVersions.join(", ")}`);
-}
-if (compositionVersions.at(-1) !== SOURCE_DSH_VERSION) {
-  throw new Error(`Odai Agent source composition targets ${SOURCE_DSH_VERSION}, not contract baseline ${compositionVersions.at(-1)}`);
-}
-export const SUPPORTED_DSH_VERSION = SOURCE_DSH_VERSION;
-const requiredFiles = Object.freeze([
-  "agent.cordis.yml",
-  "preset.yml",
-  "runtime/index.mjs",
-  "runtime/session-compat.mjs",
-  "runtime/session-evidence.mjs",
-  "runtime/skill-bundle.mjs",
-  "runtime/skill-evolution.mjs",
-  "runtime/skill-selection-state.mjs",
-  "runtime/skill-selector.mjs",
-  "runtime/skill-source-config.mjs",
-  "skills/odai/SKILL.md",
-  "skills/odai/manifest.json",
-]);
-
-function replaceCompositionContract(composition, before, after, label) {
-  const first = composition.indexOf(before);
-  if (first < 0 || composition.indexOf(before, first + before.length) >= 0) {
-    throw new Error(`Odai Agent source composition does not contain exactly one ${label} contract`);
-  }
-  return `${composition.slice(0, first)}${after}${composition.slice(first + before.length)}`;
-}
-
-export function renderAgentCompositionForDsh(composition, dshVersion = SUPPORTED_DSH_VERSION) {
-  if (typeof composition !== "string" || composition.trim() === "") {
-    throw new TypeError("agent composition must be a non-empty string");
-  }
-  if (!SUPPORTED_DSH_VERSIONS.includes(dshVersion)) {
-    throw new Error(`unsupported DSH version ${dshVersion || "<empty>"}; expected one of ${SUPPORTED_DSH_VERSIONS.join(", ")}`);
-  }
-  let rendered = composition.replace(/\r\n/gu, "\n");
-  if (dshVersion === SOURCE_DSH_VERSION) return rendered;
-  const targetComment = OPTIONAL_PROVIDER_COMMENTS[dshVersion];
-  if (!targetComment) throw new Error(`missing Agent composition contract for DSH ${dshVersion}`);
-  rendered = replaceCompositionContract(
-    rendered,
-    OPTIONAL_PROVIDER_COMMENTS[SOURCE_DSH_VERSION],
-    targetComment,
-    "optional-provider comment",
-  );
-  return rendered;
-}
-
-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);
-}
-
-export async function inspectAgentInstallation(options = {}) {
-  const presetId = assertPresetId(options.presetId ?? DEFAULT_PRESET_ID);
-  const dshHome = resolveDshHome(options.dshHome);
-  const target = resolve(dshHome, ".agent-presets", presetId);
-  const state = await inspectTarget(target, presetId);
-  return Object.freeze({ dshHome, presetId, target, ...state });
-}
-
-export async function installAgentPreset(options = {}) {
-  const presetId = assertPresetId(options.presetId ?? DEFAULT_PRESET_ID);
-  const dshHome = resolveDshHome(options.dshHome);
-  const sourceRoot = resolve(options.sourceRoot ?? defaultSourceRoot);
-  const dshVersion = options.dshVersion ?? SUPPORTED_DSH_VERSION;
-  if (!SUPPORTED_DSH_VERSIONS.includes(dshVersion)) {
-    throw new Error(`unsupported DSH version ${dshVersion || "<empty>"}; expected one of ${SUPPORTED_DSH_VERSIONS.join(", ")}`);
-  }
-  const targetRoot = resolve(dshHome, ".agent-presets");
-  const target = resolve(targetRoot, presetId);
-  const current = await inspectTarget(target, presetId);
-  const previousCompositionSize = current.status === "installed"
-    ? Buffer.byteLength(await readFile(resolve(target, "agent.cordis.yml")))
-    : undefined;
-
-  if (current.status === "drifted") {
-    throw new Error(`refusing to replace modified preset at ${target}: ${current.issues.join("; ")}`);
-  }
-
-  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()}`);
-  let backupCreated = false;
-
-  try {
-    await cp(sourceRoot, staging, { recursive: true, errorOnExist: true });
-    await tightenTree(staging);
-    const compositionPath = resolve(staging, "agent.cordis.yml");
-    const composition = renderAgentCompositionForDsh(await readFile(compositionPath, "utf8"), dshVersion);
-    let stampedComposition = `${composition.trimEnd()}\n# odai-dsh-agent generation ${packageMetadata.version}:${randomUUID()}\n`;
-    // Supported DSH releases key standing generations by mtime and size, so size must change even on same-tick updates.
-    if (previousCompositionSize === Buffer.byteLength(stampedComposition)) {
-      stampedComposition += "# odai-dsh-agent generation size bump\n";
-    }
-    await writeFile(compositionPath, stampedComposition, "utf8");
-    const files = await hashTree(staging);
-    const manifest = {
-      schemaVersion: 1,
-      package: packageMetadata.name,
-      version: packageMetadata.version,
-      dshVersion,
-      presetId,
-      files,
-    };
-    const manifestPath = resolve(staging, MANIFEST_FILE);
-    await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
-    await chmod(manifestPath, 0o600);
-
-    if (current.status === "installed") {
-      await rename(target, backup);
-      backupCreated = true;
-    }
-    await rename(staging, target);
-    if (backupCreated) {
-      await rm(backup, { recursive: true, force: true });
-      backupCreated = false;
-    }
-
-    return Object.freeze({
-      operation: current.status === "installed" ? "updated" : "installed",
-      dshHome,
-      presetId,
-      target,
-      version: packageMetadata.version,
-      dshVersion,
-      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 });
-    if (backupCreated) {
-      const targetState = await pathState(target);
-      if (targetState === "missing") await rename(backup, target);
-    }
-    throw error;
-  } finally {
-    await rm(backup, { recursive: true, force: true });
-  }
-}
-
-export async function uninstallAgentPreset(options = {}) {
-  const inspected = await inspectAgentInstallation(options);
-  if (inspected.status === "absent") {
-    return Object.freeze({ operation: "absent", target: inspected.target, presetId: inspected.presetId });
-  }
-  if (inspected.status === "drifted") {
-    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,
-    sessionCompatibility,
-  });
-}
-
-async function assertPresetIsNotDefault(dshHome, presetId) {
-  const settingsPath = resolve(dshHome, "settings.yaml");
-  let text;
-  try {
-    text = await readFile(settingsPath, "utf8");
-  } catch (error) {
-    if (error?.code === "ENOENT") return;
-    throw error;
-  }
-  let settings;
-  try {
-    settings = parseYaml(text) ?? {};
-  } catch (error) {
-    throw new Error(`cannot verify the default agent preset in ${settingsPath}: ${error.message}`);
-  }
-  if (settings?.["agent-presets"]?.default === presetId) {
-    throw new Error(`refusing to uninstall the default preset ${presetId}; select another agent-presets.default first`);
-  }
-}
-
-async function inspectTarget(target, presetId) {
-  const state = await pathState(target);
-  if (state === "missing") return { status: "absent", issues: [] };
-  if (state !== "directory") return { status: "drifted", issues: ["target is not a regular directory"] };
-
-  let manifest;
-  try {
-    manifest = JSON.parse(await readFile(resolve(target, MANIFEST_FILE), "utf8"));
-  } catch (error) {
-    return { status: "drifted", issues: [`managed manifest is unavailable: ${error.message}`] };
-  }
-
-  const issues = validateManifest(manifest, presetId);
-  let actualFiles = {};
-  try {
-    actualFiles = await hashTree(target, { exclude: new Set([MANIFEST_FILE]) });
-  } catch (error) {
-    issues.push(error.message);
-  }
-
-  if (issues.length === 0) {
-    const expectedFiles = manifest.files;
-    for (const [path, hash] of Object.entries(expectedFiles)) {
-      if (!(path in actualFiles)) issues.push(`missing managed file ${path}`);
-      else if (actualFiles[path] !== hash) issues.push(`modified managed file ${path}`);
-    }
-    for (const path of Object.keys(actualFiles)) {
-      if (!(path in expectedFiles)) issues.push(`unmanaged file ${path}`);
-    }
-  }
-
-  return {
-    status: issues.length === 0 ? "installed" : "drifted",
-    issues,
-    version: typeof manifest?.version === "string" ? manifest.version : undefined,
-    dshVersion: typeof manifest?.dshVersion === "string" ? manifest.dshVersion : undefined,
-  };
-}
-
-function validateManifest(manifest, presetId) {
-  const issues = [];
-  if (manifest?.schemaVersion !== 1) issues.push("unsupported managed manifest schema");
-  if (manifest?.package !== packageMetadata.name) issues.push("managed manifest package mismatch");
-  if (manifest?.presetId !== presetId) issues.push("managed manifest preset id mismatch");
-  if (!manifest?.files || typeof manifest.files !== "object" || Array.isArray(manifest.files)) {
-    issues.push("managed manifest file map is invalid");
-  }
-  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));
-    if (state !== "file") throw new Error(`agent package is incomplete: missing ${path}`);
-  }
-}
-
-async function tightenTree(root) {
-  await chmod(root, 0o700);
-  const entries = await readdir(root, { withFileTypes: true });
-  for (const entry of entries) {
-    const path = resolve(root, entry.name);
-    if (entry.isSymbolicLink()) throw new Error(`symbolic link is not allowed in managed preset: ${entry.name}`);
-    if (entry.isDirectory()) await tightenTree(path);
-    else if (entry.isFile()) await chmod(path, 0o600);
-    else throw new Error(`unsupported filesystem entry in managed preset: ${entry.name}`);
-  }
-}
-
-async function hashTree(root, options = {}) {
-  const found = {};
-  await walk(root, "");
-  return Object.fromEntries(Object.entries(found).sort(([left], [right]) => left.localeCompare(right)));
-
-  async function walk(base, prefix) {
-    const entries = await readdir(base, { withFileTypes: true });
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-    for (const entry of entries) {
-      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (options.exclude?.has(relativePath)) continue;
-      const absolutePath = resolve(base, entry.name);
-      if (entry.isSymbolicLink()) throw new Error(`symbolic link is not allowed in managed preset: ${relativePath}`);
-      if (entry.isDirectory()) await walk(absolutePath, relativePath);
-      else if (entry.isFile()) found[relativePath] = await hashFile(absolutePath);
-      else throw new Error(`unsupported filesystem entry in managed preset: ${relativePath}`);
-    }
-  }
-}
-
-async function hashFile(path) {
-  return createHash("sha256").update(await readFile(path)).digest("hex");
-}
-
-async function pathState(path) {
-  try {
-    const stats = await lstat(path);
-    if (stats.isSymbolicLink()) return "symlink";
-    if (stats.isDirectory()) return "directory";
-    if (stats.isFile()) return "file";
-    return "other";
-  } catch (error) {
-    if (error?.code === "ENOENT") return "missing";
-    throw error;
-  }
-}
-
-function assertPresetId(value) {
-  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(value)) {
-    throw new TypeError("preset id must contain only letters, digits, dots, underscores, or hyphens");
-  }
-  return value;
-}