@abelxiaoxing/cadence 1.8.4 → 2.0.1

package/src/operator-cli.mjs

@@ -1,2006 +1,522 @@
-// Generated by scripts/build-workspace-io.mjs; edit operator-cli-entry.mjs and its source modules.
+// Generated by scripts/build-operator.mjs; edit operator-cli-entry.mjs and its source modules.
 // src/operator-cli-entry.mjs
-import path9 from "node:path";
-
-// src/operator-tools.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { lstatSync as lstatSync8, readdirSync as readdirSync4, readFileSync as readFileSync5, realpathSync as realpathSync4 } from "node:fs";
-import path8 from "node:path";
-import { DatabaseSync } from "node:sqlite";
-
-// src/execution-profile.ts
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-function executionProfile(env = process.env) {
-  const mode = env.ABEL_EXECUTION_MODE ?? "isolated";
-  if (mode !== "isolated" && mode !== "local-trusted" && mode !== "host-trusted")
-    throw new Error("execution-mode-invalid");
-  const timeoutMs = Number(env.ABEL_VERIFICATION_TIMEOUT_MS ?? 600000);
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 86400000)
-    throw new Error("verification-timeout-invalid");
-  const inheritEnvironment = (env.ABEL_VERIFICATION_ENV ?? "").split(",").map((name) => name.trim()).filter(Boolean);
-  if (inheritEnvironment.some((name) => !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)))
-    throw new Error("verification-environment-names-invalid");
-  if (mode === "isolated" && inheritEnvironment.length)
-    throw new Error("verification-environment-requires-trusted-mode");
-  if (mode === "host-trusted" && env.ABEL_WINDOWS_JOB_HELPER !== undefined && (!env.ABEL_WINDOWS_JOB_HELPER || env.ABEL_WINDOWS_JOB_HELPER.includes("\x00") || !(path.isAbsolute(env.ABEL_WINDOWS_JOB_HELPER) || path.win32.isAbsolute(env.ABEL_WINDOWS_JOB_HELPER))))
-    throw new Error("windows-job-helper-path-invalid");
-  return {
-    mode,
-    timeoutMs,
-    bwrapPath: env.ABEL_BWRAP_PATH ?? "/usr/bin/bwrap",
-    inheritEnvironment,
-    ...mode === "host-trusted" ? {
-      windowsHelperPath: env.ABEL_WINDOWS_JOB_HELPER ?? fileURLToPath(new URL("./windows-job.exe", import.meta.url))
-    } : {}
-  };
-}
 
-// src/openspec-cli.ts
-import { lstatSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import path2 from "node:path";
-var PACKAGE_NAME = "@fission-ai/openspec";
-var OPENSPEC_LIMITS = Object.freeze({
-  timeoutMs: 30000,
-  maxBuffer: 4 * 1024 * 1024
-});
-
-class OpenSpecCliError extends Error {
-  diagnostic;
-  constructor(command, phase, reason, detail = {}) {
-    super("design-openspec-unavailable");
-    this.name = "OpenSpecCliError";
-    this.diagnostic = Object.freeze({
-      code: "design-openspec-unavailable",
-      command,
-      phase,
-      reason,
-      ...["ENOENT", "EINVAL", "EACCES", "EPERM", "ENOEXEC", "E2BIG"].includes(detail.systemCode ?? "") ? { systemCode: detail.systemCode } : {},
-      ...Number.isSafeInteger(detail.exitCode) && (detail.exitCode ?? -1) >= 0 ? { exitCode: String(detail.exitCode) } : {}
-    });
-  }
-}
-function record(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function inside(root, target) {
-  const relative = path2.relative(root, target);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path2.sep}`) && !path2.isAbsolute(relative);
-}
-function envValue(environment, name) {
-  const key = Object.keys(environment).sort().find((candidate) => process.platform === "win32" ? candidate.toUpperCase() === name.toUpperCase() : candidate === name);
-  return key === undefined ? undefined : environment[key];
-}
-function packageEntry(root) {
-  const canonicalRoot = realpathSync(root);
-  const manifestPath = realpathSync(path2.join(canonicalRoot, "package.json"));
-  const manifestStat = lstatSync(manifestPath);
-  if (!inside(canonicalRoot, manifestPath) || !manifestStat.isFile() || manifestStat.size > 1024 * 1024)
-    throw new Error("manifest-limit");
-  const manifest = record(JSON.parse(readFileSync(manifestPath, "utf8")));
-  const bin = typeof manifest?.bin === "string" ? manifest.bin : record(manifest?.bin)?.openspec;
-  if (manifest?.name !== PACKAGE_NAME || typeof bin !== "string" || path2.isAbsolute(bin))
-    throw new Error("manifest-invalid");
-  const entry = realpathSync(path2.resolve(canonicalRoot, bin));
-  if (!inside(canonicalRoot, entry) || !/\.(?:cjs|mjs|js)$/iu.test(entry) || !lstatSync(entry).isFile())
-    throw new Error("entry-invalid");
-  return entry;
-}
-function canonicalConsumerRoot(consumerRoot) {
-  try {
-    const root = realpathSync(consumerRoot);
-    if (!lstatSync(root).isDirectory())
-      throw new Error("cwd-invalid");
-    return root;
-  } catch (error) {
-    throw new OpenSpecCliError("resolve", "resolution", "cwd-unavailable", {
-      systemCode: error.code
-    });
-  }
-}
-function commandIn(directory) {
-  const names = process.platform === "win32" ? ["openspec.exe", "openspec.cmd", "openspec"] : ["openspec"];
-  const entries = process.platform === "win32" ? readdirSync(directory) : names;
-  for (const name of names) {
-    const matches = entries.filter((entry) => entry.toLowerCase() === name);
-    if (matches.length > 1)
-      throw new Error("ambiguous-command");
-    if (matches.length === 1) {
-      const candidate = path2.join(directory, matches[0]);
-      if (lstatSync(candidate, { throwIfNoEntry: false }))
-        return candidate;
-    }
-  }
-  return;
-}
-function resolveOpenSpecInvocation(consumerRoot, environment = process.env) {
-  const configuredRoot = envValue(environment, "ABEL_OPENSPEC_PACKAGE_ROOT");
-  const configuredNode = envValue(environment, "ABEL_OPENSPEC_NODE");
-  const node = configuredNode ?? (process.release.name === "node" && !process.versions.bun ? process.execPath : undefined);
-  let executable;
-  try {
-    if (!node || !path2.isAbsolute(node) || /\.(?:cmd|bat|ps1)$/iu.test(node)) {
-      throw new Error("runtime-invalid");
-    }
-    executable = realpathSync(node);
-    if (!lstatSync(executable).isFile())
-      throw new Error("runtime-invalid");
-  } catch {
-    throw new OpenSpecCliError("resolve", "resolution", "runtime-unavailable");
-  }
-  if (configuredRoot !== undefined) {
-    try {
-      if (!path2.isAbsolute(configuredRoot))
-        throw new Error("root-invalid");
-      return { executable, entry: packageEntry(configuredRoot) };
-    } catch {
-      throw new OpenSpecCliError("resolve", "resolution", "installation-invalid");
-    }
-  }
-  const consumer = canonicalConsumerRoot(consumerRoot);
-  const directories = (envValue(environment, "PATH") ?? "").split(path2.delimiter);
-  for (const directory of directories) {
-    if (!path2.isAbsolute(directory))
-      continue;
-    let command;
-    let canonicalDirectory;
-    try {
-      canonicalDirectory = realpathSync(directory);
-      if (inside(consumer, canonicalDirectory))
-        continue;
-      command = commandIn(canonicalDirectory);
-    } catch {
-      continue;
-    }
-    if (!command)
-      continue;
-    try {
-      const target = realpathSync(command);
-      if (inside(consumer, target)) {
-        throw new OpenSpecCliError("resolve", "resolution", "unsafe-installation");
-      }
-      const layoutRoots = [
-        path2.join(canonicalDirectory, "node_modules", PACKAGE_NAME),
-        path2.resolve(canonicalDirectory, "../lib/node_modules", PACKAGE_NAME)
-      ];
-      const roots = [];
-      let ancestor = path2.dirname(target);
-      for (let depth = 0;depth < 8; depth++) {
-        roots.push(ancestor);
-        const parent = path2.dirname(ancestor);
-        if (parent === ancestor)
-          break;
-        ancestor = parent;
-      }
-      const linked = lstatSync(command).isSymbolicLink();
-      const candidates = linked ? roots : layoutRoots;
-      for (const root of candidates) {
-        let entry;
-        try {
-          entry = packageEntry(root);
-          if (linked && entry !== target)
-            continue;
-        } catch {
-          continue;
-        }
-        if (inside(consumer, entry)) {
-          throw new OpenSpecCliError("resolve", "resolution", "unsafe-installation");
-        }
-        return { executable, entry };
-      }
-    } catch (error) {
-      if (error instanceof OpenSpecCliError)
-        throw error;
-    }
-    throw new OpenSpecCliError("resolve", "resolution", "installation-invalid");
-  }
-  throw new OpenSpecCliError("resolve", "resolution", "installation-not-found");
-}
-
-// src/state-root.ts
-import { createHash } from "node:crypto";
-import { chmodSync, lstatSync as lstatSync2, mkdirSync, realpathSync as realpathSync2 } from "node:fs";
-import os from "node:os";
-import path3 from "node:path";
-class StateRootError extends Error {
-  code;
-  constructor(code) {
-    super(code);
-    this.name = "StateRootError";
-    this.code = code;
-  }
-}
-function isContainedBy(parent, candidate) {
-  const relative = path3.relative(parent, candidate);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
-}
-function inspectExistingComponents(absolutePath) {
-  const parsed = path3.parse(absolutePath);
-  const relativeParts = absolutePath.slice(parsed.root.length).split(path3.sep).filter(Boolean);
-  let current = parsed.root;
-  for (const part of relativeParts) {
-    current = path3.join(current, part);
-    let stat;
-    try {
-      stat = lstatSync2(current);
-    } catch (error) {
-      if (error.code === "ENOENT")
-        return;
-      throw error;
-    }
-    if (stat.isSymbolicLink()) {
-      throw new StateRootError("state-component-symlink");
-    }
-    if (!stat.isDirectory() && current !== absolutePath) {
-      throw new StateRootError("state-component-type");
-    }
-  }
-}
-function canonicalFuturePath(input) {
-  const absolute = path3.resolve(input);
-  inspectExistingComponents(absolute);
-  let cursor = absolute;
-  const missing = [];
-  for (;; ) {
-    try {
-      return path3.join(realpathSync2.native(cursor), ...missing.reverse());
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-      const parent = path3.dirname(cursor);
-      if (parent === cursor)
-        throw error;
-      missing.push(path3.basename(cursor));
-      cursor = parent;
-    }
-  }
-}
-function requireAbsoluteDirectoryBase(xdgStateHome, homeDir) {
-  if (xdgStateHome && path3.isAbsolute(xdgStateHome)) {
-    return canonicalFuturePath(xdgStateHome);
-  }
-  if (!path3.isAbsolute(homeDir)) {
-    throw new StateRootError("invalid-state-base");
-  }
-  return canonicalFuturePath(path3.join(homeDir, ".local", "state"));
-}
-function resolveStateRoot(options) {
-  let consumerRoot;
-  try {
-    consumerRoot = realpathSync2.native(path3.resolve(options.consumerRoot));
-    if (!lstatSync2(consumerRoot).isDirectory()) {
-      throw new StateRootError("consumer-root-unavailable");
-    }
-  } catch (error) {
-    if (error instanceof StateRootError)
-      throw error;
-    throw new StateRootError("consumer-root-unavailable");
-  }
-  const stateBase = requireAbsoluteDirectoryBase(options.xdgStateHome, options.homeDir ?? os.homedir());
-  const consumerRootHash = createHash("sha256").update(consumerRoot).digest("hex");
-  const productRoot = canonicalFuturePath(path3.join(stateBase, "abel-cadence"));
-  const rootsDir = canonicalFuturePath(path3.join(productRoot, "roots"));
-  const rootDir = canonicalFuturePath(path3.join(rootsDir, consumerRootHash));
-  if (isContainedBy(consumerRoot, rootDir)) {
-    throw new StateRootError("state-root-inside-consumer");
-  }
-  return {
-    consumerRoot,
-    consumerRootHash,
-    stateBase,
-    productRoot,
-    rootsDir,
-    rootDir,
-    databasePath: path3.join(rootDir, "control.sqlite3"),
-    artifactsDir: path3.join(rootDir, "artifacts"),
-    workspacesDir: path3.join(rootDir, "workspaces"),
-    transactionsDir: path3.join(rootDir, "transactions")
-  };
-}
-
-// src/transport-budget.ts
-var REQUEST_BOUNDS = Object.freeze({
-  firstProgressMs: 90000,
-  streamIdleMs: 180000,
-  cancellationDrainMs: 250
-});
-function requestBounds(env = process.env) {
-  const read = (name, fallback) => {
-    const value = Number(env[name] ?? fallback);
-    if (!Number.isSafeInteger(value) || value < 1 || value > 1200000)
-      throw new Error("request-budget-invalid");
-    return value;
-  };
-  return {
-    ...REQUEST_BOUNDS,
-    firstProgressMs: read("ABEL_FIRST_PROGRESS_MS", REQUEST_BOUNDS.firstProgressMs),
-    streamIdleMs: read("ABEL_STREAM_IDLE_MS", REQUEST_BOUNDS.streamIdleMs)
-  };
-}
-
-// src/verification-capability.ts
+// src/task-store.ts
+import { spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
 import {
-  lstatSync as lstatSync5,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync3,
-  realpathSync as realpathSync3
+  closeSync,
+  constants,
+  fstatSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readSync,
+  realpathSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
 } from "node:fs";
-import path5 from "node:path";
+import { homedir, hostname } from "node:os";
+import {
+  dirname,
+  isAbsolute,
+  join,
+  parse,
+  relative,
+  resolve,
+  sep
+} from "node:path";
 
-// src/control-contracts.ts
-var CONTROL_SCHEMA_PROPERTIES = {
-  command: {
-    type: "string",
-    enum: ["start", "status", "resume", "rebind", "cancel", "discard"]
-  },
-  stage: { type: "string", enum: ["abel-implement"] },
-  change: { type: "string" },
-  operationId: { type: "string" },
-  deliveryRevision: { type: "integer", minimum: 1 },
-  receiptHash: { type: "string" },
-  routeId: { type: "string" },
-  recovery: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      incidentKey: { type: "string", pattern: "^[a-f0-9]{64}$" },
-      failureSequence: { type: "integer", minimum: 1 },
-      reason: {
-        type: "string",
-        enum: ["parent-directed-retry", "route-changed", "context-extended"]
-      }
-    },
-    required: ["incidentKey", "failureSequence", "reason"]
-  }
-};
-var commandSchema = (command, fields) => ({
-  type: "object",
-  properties: {
-    command: { type: "string", enum: [command] },
-    ...Object.fromEntries(fields.map((field) => [field, CONTROL_SCHEMA_PROPERTIES[field]]))
-  },
-  required: ["command", ...fields],
-  additionalProperties: false
-});
-var CONTROL_COMMAND_PARAMETERS = {
-  type: "object",
-  properties: CONTROL_SCHEMA_PROPERTIES,
-  required: ["command", "stage", "change"],
-  anyOf: [
-    commandSchema("start", ["stage", "change", "operationId"]),
-    commandSchema("status", ["stage", "change"]),
-    commandSchema("resume", ["stage", "change", "operationId"]),
-    commandSchema("resume", ["stage", "change", "operationId", "recovery"]),
-    commandSchema("resume", [
-      "stage",
-      "change",
-      "operationId",
-      "deliveryRevision",
-      "receiptHash",
-      "recovery"
-    ]),
-    commandSchema("resume", [
-      "stage",
-      "change",
-      "operationId",
-      "deliveryRevision",
-      "receiptHash"
-    ]),
-    commandSchema("rebind", ["stage", "change", "operationId", "routeId"]),
-    commandSchema("cancel", ["stage", "change", "operationId"]),
-    commandSchema("discard", ["stage", "change", "operationId"])
-  ],
-  additionalProperties: false
-};
-var CONTROL_TOOL_FIELDS = new Set([
-  "command",
-  "stage",
-  "change",
-  "operationId",
-  "deliveryRevision",
-  "receiptHash",
-  "routeId",
-  "recovery"
-]);
-var COMMAND_FIELDS = Object.freeze({
-  start: new Set(["command", "stage", "change", "operationId"]),
-  status: new Set(["command", "stage", "change"]),
-  resume: new Set([
-    "command",
-    "stage",
-    "change",
-    "operationId",
-    "deliveryRevision",
-    "receiptHash",
-    "recovery"
-  ]),
-  rebind: new Set(["command", "stage", "change", "operationId", "routeId"]),
-  cancel: new Set(["command", "stage", "change", "operationId"]),
-  discard: new Set(["command", "stage", "change", "operationId"])
-});
-// src/contracts.ts
-var LIMITS = {
-  maxActiveChildSessions: 4,
-  maxEnvelopeBytes: 64 * 1024,
-  phaseTimeoutMs: 20 * 60 * 1000,
-  maxCompleteResultBytes: 64 * 1024
-};
-var VERIFICATION_LIMITS = Object.freeze({
-  minSteps: 1,
-  maxSteps: 8,
-  minTestFiles: 1,
-  maxTestFiles: 64
-});
-var NONCANONICAL = /(^|\/)\.\.(\/|$)|(^|\/)\/|^\//;
-var RELATIVE_PATH_PATTERN = String.raw`^(?:\.|(?!/)(?![a-zA-Z]:/)(?!\./)(?![\s\S]*\.\.)(?![\s\S]*[\\\u0000])(?![\s\S]*//)(?![\s\S]*/\.(?:/|$))(?![\s\S]*/$)[\s\S]+)$`;
-function isValidRelativePath(p) {
-  return typeof p === "string" && p.length > 0 && p.length <= 512 && !NONCANONICAL.test(p) && !p.startsWith("/") && !/^[a-z]:\//iu.test(p) && (p === "." || !p.startsWith("./") && !p.endsWith("/") && !p.split("/").includes(".")) && !p.includes("..") && !p.includes("\\") && !p.includes("\x00");
-}
-var UNSAFE_VERIFICATION_TOKEN = /[;&|`$<>\n\r\0]/u;
-var VERIFICATION_NAME = /^[a-z0-9][a-z0-9._:@/-]*$/iu;
-var EXECUTABLE_NAME = /^[a-z0-9][a-z0-9._-]*$/iu;
-var IDENTIFIER = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
-function validVerificationToken(value) {
-  const optionValue = typeof value === "string" && value.includes("=") ? value.slice(value.indexOf("=") + 1) : value;
-  return typeof value === "string" && value.length > 0 && value.length <= 512 && value.trim() === value && !UNSAFE_VERIFICATION_TOKEN.test(value) && !value.includes("\\") && !value.startsWith("/") && !/^[a-z]:\//iu.test(value) && !/(^|\/)\.\.(\/|$)/u.test(value) && typeof optionValue === "string" && !optionValue.startsWith("/") && !/^[a-z]:\//iu.test(optionValue) && !/(^|\/)\.\.(\/|$)/u.test(optionValue);
-}
-function validVerificationArgs(value) {
-  return Array.isArray(value) && value.length <= 128 && value.every(validVerificationToken);
-}
-function validScriptCommand(value) {
-  return typeof value === "string" && value.length > 0 && value.length <= 1024 && value.trim() === value && !value.includes("\x00");
-}
-function validVerificationIdentity(contract) {
-  if (!validIdentifier(contract.id) || !["expected-red", "expected-green", "expected-refactor"].includes(String(contract.classification))) {
-    return false;
-  }
-  return contract.classification === "expected-red" ? typeof contract.expectedFailure === "string" && contract.expectedFailure.length > 0 && contract.expectedFailure.length <= 512 : contract.expectedFailure === undefined;
-}
-function validatePackageScriptRunner(value) {
-  if (!hasExactKeys(value, ["kind", "packageManager", "script", "command"]) || value.kind !== "package-script" || !["bun", "npm", "pnpm", "yarn"].includes(String(value.packageManager)) || typeof value.script !== "string" || !VERIFICATION_NAME.test(value.script) || value.script.includes("/") || !validScriptCommand(value.command)) {
-    return false;
-  }
-  return true;
-}
-function validateExecutableRunner(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const runner = value;
-  if (runner.kind === "package-script") {
-    return validatePackageScriptRunner(runner);
-  }
-  if (runner.kind === "local-binary" && hasExactKeys(runner, ["kind", "executable"])) {
-    return typeof runner.executable === "string" && EXECUTABLE_NAME.test(runner.executable);
-  }
-  return runner.kind === "npx" && hasExactKeys(runner, ["kind", "executable", "noInstall"]) && typeof runner.executable === "string" && EXECUTABLE_NAME.test(runner.executable) && runner.noInstall === true;
-}
-function validateVitestRunner(value) {
-  if (value.kind === "package-script") {
-    if (UNSAFE_VERIFICATION_TOKEN.test(value.command))
-      return false;
-    const tokens = value.command.split(/\s+/u);
-    return tokens[0] === "vitest" || tokens[0] === "npx" && tokens[1] === "--no-install" && tokens[2] === "vitest";
-  }
-  return value.executable === "vitest";
-}
-function validateAtomicVerification(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const contract = value;
-  if (contract.executionBindings !== undefined && (!contract.executionBindings || typeof contract.executionBindings !== "object" || Array.isArray(contract.executionBindings) || Object.entries(contract.executionBindings).some(([key, hash]) => !VERIFICATION_CONFIGURATION_PATHS.includes(key) || hash !== null && (typeof hash !== "string" || !/^[a-f0-9]{64}$/u.test(hash)))))
-    return false;
-  const expectedFailure = [
-    ...contract.classification === "expected-red" ? ["expectedFailure"] : [],
-    ...contract.executionBindings === undefined ? [] : ["executionBindings"]
-  ];
-  if (contract.kind === "vitest") {
-    const executableRunner = contract.runner;
-    return hasExactKeys(contract, [
-      "kind",
-      "id",
-      "runner",
-      "testFiles",
-      "args",
-      "classification",
-      ...expectedFailure,
-      "minTests"
-    ]) && validVerificationIdentity(contract) && validateExecutableRunner(contract.runner) && validateVitestRunner(executableRunner) && Array.isArray(contract.testFiles) && contract.testFiles.length >= VERIFICATION_LIMITS.minTestFiles && contract.testFiles.length <= VERIFICATION_LIMITS.maxTestFiles && contract.testFiles.every(isValidRelativePath) && new Set(contract.testFiles).size === contract.testFiles.length && validVerificationArgs(contract.args) && Number.isSafeInteger(contract.minTests) && contract.minTests >= 1;
-  }
-  if (contract.kind === "package-script") {
-    const runner2 = {
-      kind: "package-script",
-      packageManager: contract.packageManager,
-      script: contract.script,
-      command: contract.command
-    };
-    return hasExactKeys(contract, [
-      "kind",
-      "id",
-      "packageManager",
-      "script",
-      "command",
-      "args",
-      "classification",
-      ...expectedFailure
-    ]) && validVerificationIdentity(contract) && validatePackageScriptRunner(runner2) && validVerificationArgs(contract.args);
-  }
-  if (contract.kind !== "static-check")
-    return false;
-  const runner = contract.runner;
-  const validRunner = validateExecutableRunner(runner) || hasExactKeys(runner, ["kind", "script"]) && runner.kind === "node" && isValidRelativePath(runner.script);
-  return hasExactKeys(contract, [
-    "kind",
-    "id",
-    "runner",
-    "args",
-    "classification",
-    ...expectedFailure
-  ]) && validVerificationIdentity(contract) && validRunner && validVerificationArgs(contract.args);
-}
-function validateStructuredVerification(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const contract = value;
-  if (contract.kind !== "steps") {
-    return validateAtomicVerification(contract);
-  }
-  if (!hasExactKeys(contract, ["kind", "id", "classification", "steps"]) || !validIdentifier(contract.id) || !["expected-red", "expected-green", "expected-refactor"].includes(String(contract.classification)) || !Array.isArray(contract.steps) || contract.steps.length < VERIFICATION_LIMITS.minSteps || contract.steps.length > VERIFICATION_LIMITS.maxSteps || !contract.steps.every((step) => validateAtomicVerification(step))) {
-    return false;
-  }
-  const steps = contract.steps;
-  return steps.slice(0, -1).every((step) => step.classification === "expected-green") && steps.at(-1)?.classification === contract.classification && new Set(steps.map((step) => step.id)).size === steps.length;
-}
-function validateVerificationContract(value) {
-  if (validateStructuredVerification(value)) {
-    return { ok: true, value: structuredClone(value) };
-  }
+// src/task-types.ts
+var TASK_SCHEMA = "cadence-workflow-assistant/1";
+var MAX_RECORD_BYTES = 128 * 1024;
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function boundedString(value, max) {
+  return typeof value === "string" && Buffer.byteLength(value) <= max && !value.includes("\x00");
+}
+function validId(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
+}
+function decodeCheck(value) {
+  if (!object(value) || !boundedString(value.name, 128) || !value.name.trim() || !boundedString(value.command, 4096) || !value.command.trim() || !Number.isInteger(value.timeoutMs) || Number(value.timeoutMs) < 100 || Number(value.timeoutMs) > 1200000)
+    throw new Error("Invalid check definition");
+  const controls = /[\x00-\x08\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/u;
+  if (controls.test(value.command) || controls.test(value.name) || /[\n\t]/u.test(value.name))
+    throw new Error("Check commands/names must be visibly representable in the terminal");
   return {
-    ok: false,
-    reason: "verification contract is unsupported by the Implement runtime"
+    name: value.name,
+    command: value.command,
+    timeoutMs: Number(value.timeoutMs)
   };
 }
-function verificationSteps(verification) {
-  const normalized = validateVerificationContract(verification);
-  if (!normalized.ok)
-    return [];
-  return normalized.value.kind === "steps" ? structuredClone(normalized.value.steps) : [structuredClone(normalized.value)];
-}
-var VERIFICATION_CONFIGURATION_PATHS = [
-  "package.json",
-  "package-lock.json",
-  "npm-shrinkwrap.json",
-  "bun.lock",
-  "bun.lockb",
-  "pnpm-lock.yaml",
-  "yarn.lock",
-  ".npmrc",
-  ".yarnrc",
-  ".yarnrc.yml",
-  "bunfig.toml",
-  "pnpm-workspace.yaml"
-];
-function verificationBoundInputPaths(verification) {
-  return [
-    ...new Set([
-      ...verificationInputPaths(verification),
-      ...verificationSteps(verification).flatMap((step) => step.kind === "vitest" || step.kind === "package-script" || ("runner" in step) && step.runner.kind === "package-script" ? VERIFICATION_CONFIGURATION_PATHS : [])
-    ])
-  ];
-}
-function verificationInputPaths(verification) {
-  return [
-    ...new Set(verificationSteps(verification).flatMap((step) => {
-      const paths = step.kind === "vitest" ? [...step.testFiles] : step.kind === "static-check" && step.runner.kind === "node" ? [step.runner.script] : [];
-      if (step.kind === "package-script" || "runner" in step && step.runner.kind === "package-script") {
-        paths.push("package.json");
-      }
-      return paths;
-    }))
-  ];
-}
-function hasExactKeys(value, required, optional = []) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const record2 = value;
-  const allowed = new Set([...required, ...optional]);
-  return required.every((key) => Object.hasOwn(record2, key)) && Object.keys(record2).every((key) => allowed.has(key));
-}
-function validIdentifier(value) {
-  return typeof value === "string" && IDENTIFIER.test(value);
+function decodeTask(value) {
+  if (!object(value) || value.schema !== TASK_SCHEMA || typeof value.id !== "string" || !validId(value.id) || !Number.isSafeInteger(value.revision) || Number(value.revision) < 1 || typeof value.kind !== "string" || !["code", "research", "diagnosis"].includes(value.kind) || typeof value.phase !== "string" || ![
+    "planning",
+    "running",
+    "review",
+    "interrupted",
+    "failed",
+    "done"
+  ].includes(value.phase) || !boundedString(value.goal, 8192) || !value.goal.trim() || !boundedString(value.plan, 32768) || !boundedString(value.cwd, 4096) || !boundedString(value.result, 16384) || !boundedString(value.baseline, 16384) || !Array.isArray(value.checks) || value.checks.length > 32 || !Array.isArray(value.activity) || value.activity.length > 64)
+    throw new Error("Unknown or corrupt task record");
+  for (const check of value.checks) {
+    decodeCheck(check);
+    if (!object(check) || !boundedString(check.cwd, 4096) || !(check.exitCode === null || Number.isInteger(check.exitCode)) || typeof check.durationMs !== "number" || !Number.isFinite(check.durationMs) || check.durationMs < 0 || typeof check.status !== "string" || !["passed", "failed", "canceled", "stale"].includes(check.status) || !boundedString(check.fingerprint, 128) || check.log !== undefined && (typeof check.log !== "string" || !/^[a-f0-9-]+\.log$/.test(check.log)))
+      throw new Error("Corrupt check record");
+  }
+  for (const entry of value.activity) {
+    if (!object(entry) || !boundedString(entry.at, 64) || !boundedString(entry.text, 512))
+      throw new Error("Corrupt activity");
+  }
+  if (value.review !== undefined && (!object(value.review) || !boundedString(value.review.fingerprint, 128) || typeof value.review.outcome !== "string" || !["reviewed", "reviewed-with-issues"].includes(value.review.outcome)))
+    throw new Error("Corrupt review");
+  const allowed = new Set([
+    "schema",
+    "id",
+    "revision",
+    "kind",
+    "goal",
+    "plan",
+    "cwd",
+    "phase",
+    "result",
+    "baseline",
+    "checks",
+    "review",
+    "activity"
+  ]);
+  if (Object.keys(value).some((key) => !allowed.has(key)))
+    throw new Error("Unknown task fields");
+  return structuredClone(value);
 }
 
-// src/file-snapshot.ts
-import { createHash as createHash2 } from "node:crypto";
-import { lstatSync as lstatSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, readlinkSync } from "node:fs";
-import { join, resolve } from "node:path";
+// src/verification-diagnostics.ts
+function diagnosticText(value, maximum = 4096, secrets = []) {
+  maximum = Math.max(0, Math.floor(maximum));
+  let clean = value;
+  for (const secret of [...new Set(secrets)].filter(Boolean).sort((a, b) => b.length - a.length))
+    clean = clean.split(secret).join("[redacted]");
+  clean = clean.replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, "").replace(/(Bearer\s+)\S+/gi, "$1[redacted]").replace(/((?:api[_-]?key|token|password|secret)\s*[:=]\s*)[^\s,;]+/gi, "$1[redacted]").replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, "$1[redacted]@");
+  if (Buffer.byteLength(clean) <= maximum)
+    return clean;
+  const marker = maximum >= 12 ? `
+[truncated]` : ".".repeat(maximum);
+  const bytes = Buffer.from(clean).subarray(0, Math.max(0, maximum - Buffer.byteLength(marker)));
+  return bytes.toString("utf8").replace(/\ufffd$/, "") + marker;
+}
 
-// src/safe-path.ts
-import { lstatSync as lstatSync3 } from "node:fs";
-import path4 from "node:path";
-function observeSafePath(root, relative) {
-  if (!isValidRelativePath(relative)) {
-    return { kind: "unsafe", reason: "invalid-path" };
-  }
+// src/task-store.ts
+function parseRecord(data) {
   try {
-    const resolvedRoot = path4.resolve(root);
-    const rootStat = lstatSync3(resolvedRoot, { throwIfNoEntry: false });
-    if (!rootStat?.isDirectory() || rootStat.isSymbolicLink()) {
-      return { kind: "unsafe", reason: "root-unavailable" };
-    }
-    if (relative === ".")
-      return { kind: "directory" };
-    let current = resolvedRoot;
-    const parts = relative.split("/");
-    for (const [index, part] of parts.entries()) {
-      current = path4.join(current, part);
-      if (!current.startsWith(`${resolvedRoot}${path4.sep}`)) {
-        return { kind: "unsafe", reason: "invalid-path" };
-      }
-      const stat = lstatSync3(current, { throwIfNoEntry: false });
-      if (!stat)
-        return { kind: "absent" };
-      if (stat.isSymbolicLink()) {
-        return { kind: "unsafe", reason: "symlink" };
-      }
-      if (index < parts.length - 1) {
-        if (!stat.isDirectory()) {
-          return { kind: "unsafe", reason: "parent-not-directory" };
-        }
-        continue;
-      }
-      if (stat.isFile())
-        return { kind: "file" };
-      if (stat.isDirectory())
-        return { kind: "directory" };
-      return { kind: "unsafe", reason: "special-file" };
-    }
+    return JSON.parse(data.toString("utf8"));
   } catch {
-    return { kind: "unsafe", reason: "path-unavailable" };
+    throw new Error("Corrupt JSON state; preserved without reset");
   }
-  return { kind: "unsafe", reason: "invalid-path" };
-}
-
-// src/file-snapshot.ts
-function sha256(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex");
 }
-function snapshotFile(root, relPath) {
-  if (observeSafePath(root, relPath).kind !== "file")
-    return null;
-  const abs = resolve(root, relPath);
-  const bytes = readFileSync2(abs);
-  return { sha256: sha256(bytes), bytes: bytes.length, kind: "file" };
+function absent(error) {
+  return object(error) && error.code === "ENOENT";
 }
-
-// src/verification-capability.ts
-var WINDOWS_EXECUTABLE_EXTENSIONS = new Set([".exe", ".cmd"]);
-var DEFAULT_WINDOWS_PATH_EXT = ".COM;.EXE;.BAT;.CMD";
-var SYSTEM_MOUNT_ROOTS = ["/usr", "/bin", "/lib", "/lib64", "/etc"];
-var BROAD_MOUNT_ROOTS = new Set([
-  "/",
-  "/home",
-  "/root",
-  "/tmp",
-  "/var",
-  "/var/tmp"
-]);
-function capabilitySuccess(verificationId, runnerBindings = []) {
-  const seen = new Set;
-  return {
-    ok: true,
-    verificationId,
-    runnerBindings: runnerBindings.filter((binding) => {
-      const key = `${binding.command}\x00${binding.executablePath}\x00${JSON.stringify(binding.fixedArgs ?? [])}\x00${binding.mountSource ?? ""}`;
-      if (seen.has(key))
+function safeDirectory(path, create = false, inspectExisting) {
+  const full = resolve(path);
+  const root = parse(full).root;
+  if (inspectExisting) {
+    const st = lstatSync(root);
+    if (!st.isDirectory() || st.isSymbolicLink())
+      throw new Error("Unsafe directory");
+    inspectExisting(root, st);
+  }
+  let at = root;
+  for (const part of full.slice(root.length).split(sep).filter(Boolean)) {
+    at = join(at, part);
+    let existing;
+    try {
+      const st = lstatSync(at);
+      if (!st.isDirectory())
+        throw new Error("Unsafe directory");
+      const checked = lstatSync(at);
+      if (checked.isSymbolicLink() || inspectExisting && !checked.isDirectory())
+        throw new Error("Unsafe directory");
+      existing = checked;
+    } catch (error) {
+      if (!absent(error))
+        throw error;
+      if (!create)
         return false;
-      seen.add(key);
-      return true;
-    }).map((binding) => ({
-      ...binding,
-      ...binding.fixedArgs ? { fixedArgs: [...binding.fixedArgs] } : {}
-    }))
-  };
-}
-function adapterFailure(verificationId, code, message, inputObservation) {
-  return {
-    ok: false,
-    diagnostic: {
-      kind: "verification-adapter",
-      code,
-      verificationId,
-      message,
-      ...inputObservation ? { inputObservation } : {}
-    }
-  };
-}
-function fileStatus(root, relative) {
-  const observation = observeSafePath(root, relative);
-  if (observation.kind === "file")
-    return "regular";
-  return observation.kind === "absent" ? "absent" : "unsafe";
-}
-function regularFile(root, relative) {
-  return fileStatus(root, relative) === "regular";
-}
-function localExecutable(root, executable, dependencyOwner = root, environment = {}) {
-  const dependencyRoot = path5.resolve(dependencyOwner, "node_modules");
-  try {
-    const canonicalDependencyRoot = realpathSync3(dependencyRoot);
-    for (const name of localExecutableNames(executable, environment)) {
-      const unresolved = resolveCandidateName(path5.resolve(dependencyRoot, ".bin"), name, environment.platform ?? process.platform);
-      if (!unresolved)
-        continue;
-      const canonical = realpathSync3(unresolved);
-      const stat = lstatSync5(canonical);
-      if (canonical !== canonicalDependencyRoot && pathWithin(canonicalDependencyRoot, canonical, environment.platform ?? process.platform) && regularExecutableFile(stat, environment.platform ?? process.platform)) {
-        return true;
+      try {
+        mkdirSync(at, { mode: 448 });
+      } catch (mkdirError) {
+        if (!object(mkdirError) || mkdirError.code !== "EEXIST")
+          throw mkdirError;
       }
+      if (!lstatSync(at).isDirectory() || lstatSync(at).isSymbolicLink())
+        throw new Error("Unsafe directory");
     }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function pathApi(platform, ...values) {
-  if (platform !== "win32")
-    return path5.posix;
-  if (process.platform === "win32" || values.some((value) => /^[a-z]:[\\/]/iu.test(value) || value.startsWith("\\\\"))) {
-    return path5.win32;
-  }
-  return path5.posix;
-}
-function pathWithin(root, candidate, platform) {
-  const platformPath = pathApi(platform, root, candidate);
-  const normalizedRoot = platformPath.resolve(root);
-  const relative = platformPath.relative(normalizedRoot, platformPath.resolve(candidate));
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${platformPath.sep}`) && !platformPath.isAbsolute(relative);
-}
-function regularExecutableFile(stat, platform) {
-  return stat.isFile() && (platform === "win32" || (stat.mode & 73) !== 0);
-}
-function windowsPathExtensions(pathExt) {
-  const seen = new Set;
-  const extensions = [];
-  for (const entry of (pathExt ?? DEFAULT_WINDOWS_PATH_EXT).split(";")) {
-    const extension = entry.trim().toLowerCase();
-    if (!WINDOWS_EXECUTABLE_EXTENSIONS.has(extension) || seen.has(extension)) {
-      continue;
-    }
-    seen.add(extension);
-    extensions.push(extension);
-  }
-  return extensions;
-}
-function runnerNames(command, environment) {
-  if (!/^[a-z0-9][a-z0-9._-]*$/iu.test(command))
-    return [];
-  if ((environment.platform ?? process.platform) !== "win32") {
-    return [command];
-  }
-  const extension = path5.extname(command).toLowerCase();
-  if (extension) {
-    return WINDOWS_EXECUTABLE_EXTENSIONS.has(extension) ? [command] : [];
+    if (existing)
+      inspectExisting?.(at, existing);
   }
-  return windowsPathExtensions(environment.pathExt).map((candidateExtension) => `${command}${candidateExtension}`);
-}
-function localExecutableNames(executable, environment) {
-  if (!/^[a-z0-9][a-z0-9._-]*$/iu.test(executable))
-    return [];
-  if ((environment.platform ?? process.platform) !== "win32") {
-    return [executable];
-  }
-  const extension = path5.extname(executable).toLowerCase();
-  if (extension) {
-    return WINDOWS_EXECUTABLE_EXTENSIONS.has(extension) ? [executable] : [];
-  }
-  return [
-    executable,
-    ...windowsPathExtensions(environment.pathExt).map((candidateExtension) => `${executable}${candidateExtension}`)
-  ];
-}
-function resolveCandidateName(directory, name, platform) {
-  const exact = path5.join(directory, name);
-  if (platform !== "win32")
-    return exact;
-  try {
-    const matches = readdirSync3(directory).filter((entry) => entry.toLowerCase() === name.toLowerCase());
-    return matches.length === 1 ? path5.join(directory, matches[0]) : null;
-  } catch {
-    return null;
-  }
-}
-function within(root, candidate) {
-  return candidate === root || candidate.startsWith(`${root}${path5.sep}`);
-}
-function commonDirectory(left, right, platform = process.platform) {
-  const platformPath = pathApi(platform, left, right);
-  const leftResolved = platformPath.resolve(left);
-  const rightResolved = platformPath.resolve(right);
-  const leftRoot = platformPath.parse(leftResolved).root;
-  const rightRoot = platformPath.parse(rightResolved).root;
-  const comparable = (value) => platform === "win32" ? value.toLowerCase() : value;
-  if (comparable(leftRoot) !== comparable(rightRoot))
-    return leftRoot;
-  const parts = (value, root) => platformPath.relative(root, value).split(platformPath.sep).filter(Boolean);
-  const leftParts = parts(leftResolved, leftRoot);
-  const rightParts = parts(rightResolved, rightRoot);
-  const common = [];
-  for (let index = 0;index < Math.min(leftParts.length, rightParts.length); index++) {
-    const leftPart = leftParts[index];
-    const rightPart = rightParts[index];
-    if (comparable(leftPart) !== comparable(rightPart))
-      break;
-    common.push(leftPart);
-  }
-  return platformPath.join(leftRoot, ...common);
-}
-function unsafeMountSource(source) {
-  if (BROAD_MOUNT_ROOTS.has(source))
-    return true;
-  if (path5.resolve(source) === path5.parse(path5.resolve(source)).root)
-    return true;
-  const parts = path5.relative(path5.parse(path5.resolve(source)).root, path5.resolve(source)).split(path5.sep).filter(Boolean).map((part) => part.toLowerCase());
-  return parts[0] === "home" && parts.length <= 2 || parts[0] === "users" && parts.length <= 2 || parts[0] === "root" && parts.length <= 1;
-}
-function safeRunnerSource(paths, platform) {
-  let source = path5.dirname(paths[0]);
-  for (const candidate of paths.slice(1)) {
-    source = commonDirectory(source, path5.dirname(candidate), platform);
-  }
-  if (unsafeMountSource(source))
-    return null;
-  try {
-    const stat = lstatSync5(source);
-    if (!stat.isDirectory() || stat.isSymbolicLink())
-      return null;
-  } catch {
-    return null;
-  }
-  return paths.every((candidate) => pathWithin(source, candidate, platform)) ? source : null;
-}
-function resolvedRunnerEnvironment(environment) {
-  return {
-    platform: environment.platform ?? process.platform,
-    path: environment.path ?? process.env.PATH ?? "",
-    pathExt: environment.pathExt ?? process.env.PATHEXT ?? DEFAULT_WINDOWS_PATH_EXT,
-    pathDelimiter: environment.pathDelimiter ?? path5.delimiter
-  };
+  return true;
 }
-function windowsShimBinding(command, launcherPath, environment) {
-  const name = path5.basename(command, path5.extname(command)).toLowerCase();
-  if (name !== "npm" && name !== "npx")
-    return null;
-  const node = resolveVerificationRunner("node", environment);
-  if (!node || node.fixedArgs || path5.extname(node.executablePath).toLowerCase() !== ".exe") {
-    return null;
-  }
-  const cli = path5.join(path5.dirname(launcherPath), "node_modules", "npm", "bin", `${name}-cli.js`);
+function readBounded(path, max) {
+  if (!safeDirectory(dirname(path)))
+    return;
+  let fd;
   try {
-    const canonicalLauncher = realpathSync3(launcherPath);
-    const canonicalCli = realpathSync3(cli);
-    const cliStat = lstatSync5(canonicalCli);
-    if (!cliStat.isFile())
-      return null;
-    const source = safeRunnerSource([node.executablePath, canonicalLauncher, canonicalCli], environment.platform);
-    if (!source)
-      return null;
-    return {
-      command,
-      executablePath: node.executablePath,
-      fixedArgs: [canonicalCli]
-    };
-  } catch {
-    return null;
+    const st = lstatSync(path);
+    if (!st.isFile() || st.isSymbolicLink() || st.nlink !== 1 || st.size > max)
+      throw new Error("Unsafe or oversized file");
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  } catch (error) {
+    if (absent(error))
+      return;
+    throw error;
   }
-}
-function localPackageDirectories(dependencyRoot) {
-  const packages = [];
   try {
-    for (const entry of readdirSync3(dependencyRoot, { withFileTypes: true })) {
-      if (!entry.isDirectory() || entry.name.startsWith("."))
-        continue;
-      const candidate = path5.join(dependencyRoot, entry.name);
-      if (!entry.name.startsWith("@")) {
-        packages.push(candidate);
-        continue;
-      }
-      for (const scoped of readdirSync3(candidate, { withFileTypes: true })) {
-        if (scoped.isDirectory() && !scoped.name.startsWith(".")) {
-          packages.push(path5.join(candidate, scoped.name));
-        }
-      }
+    const st = fstatSync(fd);
+    if (!st.isFile() || st.nlink !== 1 || st.size > max)
+      throw new Error("Unsafe or oversized file");
+    const buffer = Buffer.alloc(max + 1);
+    let size = 0;
+    while (size < buffer.length) {
+      const n = readSync(fd, buffer, size, buffer.length - size, null);
+      if (!n)
+        break;
+      size += n;
     }
-  } catch {
-    return [];
-  }
-  return packages;
-}
-function localPackageBinTargets(dependencyOwner, executable, platform) {
-  const dependencyRoot = path5.resolve(dependencyOwner, "node_modules");
-  let canonicalDependencyRoot;
-  try {
-    canonicalDependencyRoot = realpathSync3(dependencyRoot);
-  } catch {
-    return [];
-  }
-  const targets = [];
-  for (const packageDirectory of localPackageDirectories(dependencyRoot)) {
-    try {
-      const directoryStat = lstatSync5(packageDirectory);
-      if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) {
-        continue;
-      }
-      const canonicalPackage = realpathSync3(packageDirectory);
-      if (!pathWithin(canonicalDependencyRoot, canonicalPackage, platform) || canonicalPackage === canonicalDependencyRoot) {
-        continue;
-      }
-      const manifestPath = path5.join(canonicalPackage, "package.json");
-      const manifestStat = lstatSync5(manifestPath);
-      if (!manifestStat.isFile() || manifestStat.isSymbolicLink())
-        continue;
-      const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
-      if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
-        continue;
-      }
-      const record2 = manifest;
-      const packageName = typeof record2.name === "string" ? record2.name.split("/").pop() ?? "" : "";
-      const bin = record2.bin;
-      let relative;
-      if (typeof bin === "string" && (platform === "win32" ? packageName.toLowerCase() === executable.toLowerCase() : packageName === executable)) {
-        relative = bin;
-      } else if (bin && typeof bin === "object" && !Array.isArray(bin)) {
-        const entries = Object.entries(bin).filter(([name]) => platform === "win32" ? name.toLowerCase() === executable.toLowerCase() : name === executable);
-        if (entries.length === 1)
-          relative = entries[0]?.[1];
-      }
-      if (typeof relative !== "string" || relative.length === 0 || relative.includes("\x00")) {
-        continue;
-      }
-      const unresolved = path5.resolve(canonicalPackage, relative);
-      if (!pathWithin(canonicalPackage, unresolved, platform))
-        continue;
-      const canonical = realpathSync3(unresolved);
-      const stat = lstatSync5(canonical);
-      if (stat.isFile() && pathWithin(canonicalPackage, canonical, platform) && pathWithin(canonicalDependencyRoot, canonical, platform)) {
-        targets.push(canonical);
-      }
-    } catch {}
+    if (size > max)
+      throw new Error("Oversized file");
+    return buffer.subarray(0, size);
+  } finally {
+    closeSync(fd);
   }
-  return [...new Set(targets)];
 }
-function resolveLocalVerificationRunner(dependencyOwner, executable, runnerEnvironment) {
-  const environment = resolvedRunnerEnvironment(runnerEnvironment);
-  if (environment.platform !== "win32")
-    return null;
-  const targets = localPackageBinTargets(dependencyOwner, executable, environment.platform);
-  if (targets.length !== 1)
-    return null;
-  const target = targets[0];
-  const extension = path5.extname(target).toLowerCase();
-  if (extension === ".exe") {
-    return { command: executable, executablePath: target };
-  }
-  if (![".js", ".cjs", ".mjs"].includes(extension))
-    return null;
-  const node = resolveVerificationRunner("node", environment);
-  if (!node || node.fixedArgs)
-    return null;
+function gitEnvironment() {
   return {
-    command: executable,
-    executablePath: node.executablePath,
-    fixedArgs: [target]
+    ...Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_"))),
+    GIT_OPTIONAL_LOCKS: "0",
+    LC_ALL: "C"
   };
 }
-function resolveVerificationRunner(command, runnerEnvironment = {}) {
-  const environment = resolvedRunnerEnvironment(runnerEnvironment);
-  const directories = environment.path.split(environment.pathDelimiter).filter(Boolean);
-  const seenDirectories = new Set;
-  const candidates = [
-    ...command === "bun" && process.versions.bun && environment.platform === process.platform ? [process.execPath] : [],
-    ...directories.flatMap((directory) => {
-      const resolvedDirectory = path5.resolve(directory);
-      const key = environment.platform === "win32" ? resolvedDirectory.toLowerCase() : resolvedDirectory;
-      if (seenDirectories.has(key))
-        return [];
-      seenDirectories.add(key);
-      return runnerNames(command, environment).flatMap((name) => {
-        const candidate = resolveCandidateName(resolvedDirectory, name, environment.platform);
-        return candidate ? [candidate] : [];
-      });
-    })
-  ];
-  const seenCandidates = new Set;
-  for (const candidate of candidates) {
-    try {
-      const executablePath = path5.resolve(candidate);
-      const candidateKey = environment.platform === "win32" ? executablePath.toLowerCase() : executablePath;
-      if (seenCandidates.has(candidateKey))
-        continue;
-      seenCandidates.add(candidateKey);
-      const canonical = realpathSync3(executablePath);
-      const stat = lstatSync5(canonical);
-      if (!regularExecutableFile(stat, environment.platform))
-        continue;
-      if (environment.platform === "win32") {
-        const extension = path5.extname(executablePath).toLowerCase();
-        if (extension === ".cmd") {
-          const shim = windowsShimBinding(command, executablePath, environment);
-          if (shim)
-            return shim;
-          continue;
-        }
-        if (extension !== ".exe")
-          continue;
-        if (!safeRunnerSource([executablePath, canonical], environment.platform)) {
-          continue;
-        }
-        return { command, executablePath };
-      }
-      const systemVisible = SYSTEM_MOUNT_ROOTS.some((root) => within(root, executablePath) && within(root, canonical));
-      if (systemVisible)
-        return { command, executablePath };
-      const mountSource = commonDirectory(path5.dirname(executablePath), path5.dirname(canonical), environment.platform);
-      if (unsafeMountSource(mountSource))
-        continue;
-      const sourceStat = lstatSync5(mountSource);
-      if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink())
-        continue;
-      return { command, executablePath, mountSource };
-    } catch {}
-  }
-  return null;
-}
-function packageManifest(root) {
-  if (!regularFile(root, "package.json"))
-    return null;
-  try {
-    const value = JSON.parse(readFileSync3(path5.join(root, "package.json"), "utf8"));
-    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function validatePackageScript(root, verificationId, packageManager, script, approvedCommand, _dependencyOwner = root, runnerEnvironment = {}) {
-  const packageRunner = resolveVerificationRunner(packageManager, runnerEnvironment);
-  if (!packageRunner) {
-    return adapterFailure(verificationId, "runner-missing", `approved package manager ${packageManager} is unavailable or cannot be mounted safely`);
-  }
-  const manifest = packageManifest(root);
-  const scripts = manifest?.scripts;
-  const actual = scripts && typeof scripts === "object" && !Array.isArray(scripts) ? scripts[script] : undefined;
-  if (typeof actual !== "string") {
-    return adapterFailure(verificationId, "script-missing", `package.json script ${script} is missing`);
-  }
-  if (actual !== approvedCommand) {
-    return adapterFailure(verificationId, "script-command-mismatch", `package.json script ${script} differs from the Gate B contract`);
-  }
-  const runtimes = ["node", "bun", "npm", "npx", "pnpm", "yarn"].flatMap((command) => {
-    const binding = resolveVerificationRunner(command, runnerEnvironment);
-    return binding ? [binding] : [];
+function resolveWorkspace(cwd) {
+  const actual = realpathSync(cwd);
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: actual,
+    env: gitEnvironment(),
+    encoding: "utf8",
+    timeout: 3000,
+    maxBuffer: 8192,
+    windowsHide: true
   });
-  return capabilitySuccess(verificationId, [packageRunner, ...runtimes]);
-}
-function unsupportedExecutionConfiguration(source) {
-  const restricted = new Set([
-    "scriptshell",
-    "userconfig",
-    "globalconfig",
-    "yarnpath",
-    "plugins",
-    "auth",
-    "authtoken",
-    "password",
-    "token",
-    "npmauthtoken",
-    "npmauthident"
-  ]);
-  for (const line of source.split(/\r?\n/u)) {
-    let quote = "";
-    let escaped = false;
-    let active = "";
-    const parts = [];
-    let flowDepth = 0;
-    for (const character of line) {
-      if (escaped) {
-        active += character;
-        escaped = false;
-        continue;
-      }
-      if (character === "\\" && quote === '"') {
-        active += character;
-        escaped = true;
-        continue;
-      }
-      if (quote) {
-        active += character;
-        if (character === quote)
-          quote = "";
-      } else if (character === '"' || character === "'") {
-        quote = character;
-        active += character;
-      } else if (character === "#" || character === ";" && active.trim() === "") {
-        break;
-      } else if (character === "{" || character === "}" || character === "," && flowDepth > 0) {
-        if (character === "{")
-          flowDepth++;
-        if (character === "}")
-          flowDepth = Math.max(0, flowDepth - 1);
-        parts.push(active);
-        active = "";
-      } else
-        active += character;
-    }
-    parts.push(active);
-    for (const part of parts) {
-      if (part.includes("${"))
-        return true;
-      const directive = part.match(/^\s*(?:"((?:\\.|[^"\\])*)"|'([^']*)'|([^\s=]+))\s*(.*)$/u);
-      if (!directive)
-        continue;
-      const rawKey = directive[1] ?? directive[2] ?? directive[3];
-      if (!rawKey.endsWith(":") && !directive[4])
-        continue;
-      const key = rawKey.replace(/:$/u, "").split(":").at(-1)?.replace(/[-_]/gu, "").toLowerCase();
-      if (key && restricted.has(key))
-        return true;
-    }
-  }
-  return false;
-}
-function validateAtomicCapability(root, step, dependencyOwner, runnerEnvironment, executionWritePaths) {
-  if (step.kind === "vitest" && [
-    ...step.args,
-    ...step.runner.kind === "package-script" ? step.runner.command.split(/\s+/u) : []
-  ].some((arg) => /^--(?:reporters?|outputFile)(?:[.=]|$)/u.test(arg))) {
-    return adapterFailure(step.id, "report-arguments-conflict", "Vitest report arguments are owned by the adapter");
-  }
-  if (step.executionBindings) {
-    for (const [relative, expected] of Object.entries(step.executionBindings)) {
-      if (executionWritePaths.includes(relative))
-        continue;
-      const observation = observeSafePath(root, relative);
-      if (expected === null && observation.kind !== "absent" || expected !== null && snapshotFile(root, relative)?.sha256 !== expected) {
-        return adapterFailure(step.id, "verification-config-mismatch", "Bound execution inputs changed; recompile the verification contract");
-      }
-    }
-  }
-  for (const relative of verificationBoundInputPaths(step).filter((file) => VERIFICATION_CONFIGURATION_PATHS.includes(file))) {
-    const observation = observeSafePath(root, relative);
-    if (!["file", "absent"].includes(observation.kind))
-      return adapterFailure(step.id, "verification-config-unsafe", "Execution configuration must be a regular file");
-    if (observation.kind !== "file" || ![
-      ".npmrc",
-      ".yarnrc",
-      ".yarnrc.yml",
-      "bunfig.toml",
-      "pnpm-workspace.yaml"
-    ].includes(relative))
-      continue;
-    if (lstatSync5(path5.join(root, relative)).size > 64 * 1024 || executionProfile().mode === "isolated" && unsupportedExecutionConfiguration(readFileSync3(path5.join(root, relative), "utf8"))) {
-      return adapterFailure(step.id, "verification-config-unsafe", "Execution configuration requires unsupported credentials or host configuration");
-    }
-  }
-  if (step.kind === "package-script") {
-    return validatePackageScript(root, step.id, step.packageManager, step.script, step.command, dependencyOwner, runnerEnvironment);
-  }
-  const runner = step.runner;
-  if (runner.kind === "package-script") {
-    const script = validatePackageScript(root, step.id, runner.packageManager, runner.script, runner.command, dependencyOwner, runnerEnvironment);
-    if (!script.ok)
-      return script;
-    if (step.kind === "vitest" && !localExecutable(root, "vitest", dependencyOwner, runnerEnvironment)) {
-      return adapterFailure(step.id, "local-executable-missing", "Vitest is not installed in consumer node_modules");
-    }
-    return script;
-  }
-  if (runner.kind === "node") {
-    const node = resolveVerificationRunner("node", runnerEnvironment);
-    return node ? capabilitySuccess(step.id, [node]) : adapterFailure(step.id, "runner-missing", "Node is unavailable or cannot be mounted safely");
-  }
-  if (!localExecutable(root, runner.executable, dependencyOwner, runnerEnvironment)) {
-    return adapterFailure(step.id, "local-executable-missing", `local executable ${runner.executable} is unavailable`);
-  }
-  if (runner.kind === "npx") {
-    const npx = resolveVerificationRunner("npx", runnerEnvironment);
-    return npx ? capabilitySuccess(step.id, [npx]) : adapterFailure(step.id, "runner-missing", "npx is unavailable or cannot be mounted safely");
-  }
-  if ((runnerEnvironment.platform ?? process.platform) === "win32") {
-    const binding = resolveLocalVerificationRunner(dependencyOwner, runner.executable, runnerEnvironment);
-    return binding ? capabilitySuccess(step.id, [binding]) : adapterFailure(step.id, "local-executable-missing", `local executable ${runner.executable} has no safe direct Windows binding`);
-  }
-  return capabilitySuccess(step.id);
-}
-function validateVerificationAdapterCapability(root, value, options = {}) {
-  return validateCapability(root, value, options, false);
-}
-function validateCapability(root, value, options, requireInputAvailability) {
-  const validation = validateVerificationContract(value);
-  if (!validation.ok) {
-    const id = value && typeof value === "object" && !Array.isArray(value) && typeof value.id === "string" ? String(value.id) : undefined;
-    return {
-      ok: false,
-      diagnostic: {
-        kind: "design-readiness",
-        code: "verification-contract-unsupported",
-        ...id ? { verificationId: id } : {},
-        message: validation.reason
-      }
-    };
-  }
-  const dependencyOwner = options.dependencyOwner ?? root;
-  return validateAcceptedVerificationCapability(root, validation.value, dependencyOwner, options.runnerEnvironment ?? {}, requireInputAvailability, options.executionWritePaths ?? []);
-}
-function validateAcceptedVerificationCapability(root, verification, dependencyOwner, runnerEnvironment, requireInputAvailability, executionWritePaths) {
-  if (requireInputAvailability) {
-    for (const input of verificationInputPaths(verification)) {
-      const status = fileStatus(root, input);
-      if (status !== "regular") {
-        const inputObservation = { path: input, kind: status };
-        return adapterFailure(verification.id, status === "absent" ? "input-missing" : "input-unsafe", `verification input ${input} is ${status}`, inputObservation);
-      }
-    }
-  }
-  const runnerBindings = [];
-  for (const step of verificationSteps(verification)) {
-    const capability = validateAtomicCapability(root, step, dependencyOwner, runnerEnvironment, executionWritePaths);
-    if (!capability.ok)
-      return capability;
-    runnerBindings.push(...capability.runnerBindings);
-  }
-  return capabilitySuccess(verification.id, runnerBindings);
-}
-
-// src/windows-job-backend.ts
-import { spawn as spawn2, spawnSync } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { lstatSync as lstatSync7, readFileSync as readFileSync4 } from "node:fs";
-import path7 from "node:path";
-
-// src/isolation-backend.ts
-import { spawn } from "node:child_process";
-import { accessSync, constants, lstatSync as lstatSync6 } from "node:fs";
-import path6 from "node:path";
-var ISOLATION_RUN_LIMITS = Object.freeze({
-  timeoutMs: 10 * 60000,
-  maxOutputBytes: 256 * 1024,
-  terminateGraceMs: 1000
-});
-function defaultProbe(executable) {
+  const topLevel = result.stdout?.replace(process.platform === "win32" ? /\r?\n$/ : /\n$/, "");
+  if (result.status === 0 && topLevel)
+    return { root: realpathSync(topLevel), cwd: actual };
+  if (result.error && !object(result.error))
+    throw new Error("Cannot resolve workspace");
+  if (result.error && object(result.error) && result.error.code !== "ENOENT")
+    throw new Error("Workspace lookup failed");
+  if (!result.error && !result.stderr.includes("not a git repository"))
+    throw new Error("Git workspace lookup refused");
+  return { root: actual, cwd: actual };
+}
+function defaultStateHome() {
+  const candidate = process.platform === "win32" ? process.env.LOCALAPPDATA : process.env.XDG_STATE_HOME;
+  if (candidate && !isAbsolute(candidate))
+    throw new Error("State home must be absolute");
+  return candidate ?? join(homedir(), process.platform === "win32" ? "AppData/Local" : ".local/state");
+}
+function recordText(record) {
+  return `${JSON.stringify(record, null, 2)}
+`;
+}
+function contentIdentity(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function canonicalAmbientRoot(path) {
+  const full = resolve(path);
   try {
-    accessSync(executable, constants.X_OK);
-    return true;
-  } catch {
-    return false;
+    return realpathSync(full);
+  } catch (error) {
+    if (!absent(error))
+      throw error;
+    try {
+      lstatSync(full);
+      throw new Error("Dangling ambient root");
+    } catch (statError) {
+      if (!absent(statError))
+        throw statError;
+    }
+    const parent = dirname(full);
+    if (parent === full)
+      throw error;
+    return join(canonicalAmbientRoot(parent), full.slice(parent.length));
   }
 }
-function validEnvironmentName(name) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(name);
-}
 
-class BoundedLog {
-  bytes = 0;
-  #head = Buffer.alloc(0);
-  #tail = Buffer.alloc(0);
-  limit;
-  #witness;
-  #witnessTail = Buffer.alloc(0);
-  witnessMatched = false;
-  constructor(limit, witness) {
-    this.limit = limit;
-    if (witness)
-      this.#witness = Buffer.from(witness);
-  }
-  append(chunk) {
-    const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    this.bytes += input.byteLength;
-    if (this.#witness && !this.witnessMatched) {
-      const searchable = Buffer.concat([this.#witnessTail, input]);
-      this.witnessMatched = searchable.includes(this.#witness);
-      this.#witnessTail = this.witnessMatched ? Buffer.alloc(0) : Buffer.from(searchable.subarray(Math.max(0, searchable.length - this.#witness.length + 1)));
-    }
-    const headLimit = Math.ceil(this.limit / 2);
-    const take = Math.min(input.length, headLimit - this.#head.length);
-    if (take > 0)
-      this.#head = Buffer.concat([this.#head, input.subarray(0, take)]);
-    const rest = input.subarray(take);
-    const tailLimit = this.limit - headLimit;
-    if (rest.length && tailLimit) {
-      this.#tail = rest.length >= tailLimit ? Buffer.from(rest.subarray(-tailLimit)) : Buffer.concat([
-        this.#tail.subarray(Math.max(0, this.#tail.length + rest.length - tailLimit)),
-        rest
-      ]);
+class TaskStore {
+  root;
+  tasks;
+  privateRoot;
+  constructor(root, stateHome = defaultStateHome()) {
+    this.root = realpathSync(root);
+    this.tasks = join(this.root, ".cadence", "assistant", "tasks");
+    this.privateRoot = join(canonicalAmbientRoot(stateHome), "cadence-assistant-v1", createHash("sha256").update(this.root).digest("hex"));
+    const within = relative(this.root, resolve(this.privateRoot));
+    if (!within || !within.startsWith(`..${sep}`) && within !== ".." && !isAbsolute(within))
+      throw new Error("Private state home must be outside the working copy");
+  }
+  get lockPath() {
+    return join(this.privateRoot, "checkout.lock");
+  }
+  inspectPrivate() {
+    const namespace = dirname(this.privateRoot);
+    for (const path of [namespace, this.privateRoot]) {
+      if (!safeDirectory(path))
+        continue;
+      const st = lstatSync(path);
+      if (process.platform !== "win32" && ((st.mode & 63) !== 0 || process.getuid && st.uid !== process.getuid()))
+        throw new Error("Private state permissions refused");
     }
   }
-  text() {
-    return Buffer.concat([this.#head, this.#tail]).toString("utf8");
-  }
-  metadata() {
-    return { bytes: this.bytes, truncated: this.bytes > this.limit };
-  }
-}
-
-class BubblewrapIsolationBackend {
-  #localTrusted;
-  #bwrapPath;
-  #probe;
-  #spawn;
-  #timeoutMs;
-  #maxOutputBytes;
-  #terminateGraceMs;
-  constructor(options = {}) {
-    this.#localTrusted = options.localTrusted === true;
-    this.#bwrapPath = options.bwrapPath ?? "/usr/bin/bwrap";
-    this.#probe = options.probe ?? defaultProbe;
-    this.#spawn = options.spawnProcess ?? spawn;
-    this.#timeoutMs = options.timeoutMs ?? ISOLATION_RUN_LIMITS.timeoutMs;
-    this.#maxOutputBytes = options.maxOutputBytes ?? ISOLATION_RUN_LIMITS.maxOutputBytes;
-    this.#terminateGraceMs = options.terminateGraceMs ?? ISOLATION_RUN_LIMITS.terminateGraceMs;
-    if (!Number.isSafeInteger(this.#timeoutMs) || this.#timeoutMs < 1 || !Number.isSafeInteger(this.#maxOutputBytes) || this.#maxOutputBytes < 1 || !Number.isSafeInteger(this.#terminateGraceMs) || this.#terminateGraceMs < 1) {
-      throw new Error("isolation-run-limits-invalid");
+  inspectPrivateFile(path, max) {
+    this.inspectPrivate();
+    if (!safeDirectory(this.privateRoot))
+      return;
+    try {
+      const st = lstatSync(path);
+      if (!st.isFile() || st.isSymbolicLink() || st.nlink !== 1 || st.size > max || process.platform !== "win32" && ((st.mode & 63) !== 0 || process.getuid && st.uid !== process.getuid()))
+        throw new Error("Unsafe private state file");
+    } catch (error) {
+      if (!absent(error))
+        throw error;
     }
   }
-  async available() {
+  inspectLock() {
+    this.inspectPrivateFile(this.lockPath, 8192);
+    const data = readBounded(this.lockPath, 8192);
+    if (!data)
+      return;
+    const lock = parseRecord(data);
+    if (!object(lock) || lock.schema !== "cadence-assistant-lock/1" || lock.root !== this.root || typeof lock.token !== "string" || !validId(lock.token) || typeof lock.runId !== "string" || !validId(lock.runId) || typeof lock.host !== "string" || !Number.isInteger(lock.pid) || Number(lock.pid) < 1)
+      throw new Error("Unknown or corrupt coordination lock");
+    return lock;
+  }
+  acquire() {
+    this.inspectPrivate();
+    safeDirectory(this.privateRoot, true);
+    const lock = {
+      schema: "cadence-assistant-lock/1",
+      token: randomUUID(),
+      runId: randomUUID(),
+      pid: process.pid,
+      host: hostname(),
+      root: this.root
+    };
+    let fd;
     try {
-      if (this.#localTrusted && process.platform !== "linux")
-        return false;
-      return Boolean(await this.#probe(this.#bwrapPath));
+      fd = openSync(this.lockPath, "wx", 384);
     } catch {
-      return false;
+      throw new Error("Checkout busy or unresolved lock; inspect and explicitly recover only a dead owner");
     }
-  }
-  async run(input) {
-    if (input.outputWitness !== undefined && (typeof input.outputWitness !== "string" || input.outputWitness.length < 1 || input.outputWitness.length > 512))
-      throw new Error("isolation-output-witness-invalid");
-    if (!await this.available()) {
-      return {
-        ok: false,
-        state: "paused",
-        code: "isolation-backend-unavailable"
-      };
-    }
-    if (input.signal?.aborted) {
-      return { ok: false, state: "cancelled", code: "cancelled" };
-    }
-    const root = path6.resolve(input.root);
-    const rootStat = lstatSync6(root, { throwIfNoEntry: false });
-    if (!rootStat?.isDirectory() || rootStat.isSymbolicLink()) {
-      throw new Error("isolation-root-invalid");
-    }
-    const argv = this.#localTrusted ? [
-      "--die-with-parent",
-      "--new-session",
-      "--unshare-pid",
-      "--bind",
-      "/",
-      "/",
-      "--proc",
-      "/proc",
-      "--dev",
-      "/dev",
-      "--chdir",
-      root,
-      "--clearenv"
-    ] : [
-      "--die-with-parent",
-      "--new-session",
-      "--unshare-all",
-      "--proc",
-      "/proc",
-      "--dev",
-      "/dev",
-      "--tmpfs",
-      "/tmp",
-      "--bind",
-      root,
-      "/workspace",
-      "--chdir",
-      "/workspace",
-      "--clearenv",
-      "--setenv",
-      "PATH",
-      "/usr/local/bin:/usr/bin:/bin"
-    ];
-    if (!this.#localTrusted) {
-      for (const systemRoot of ["/usr", "/bin", "/lib", "/lib64"]) {
-        if (lstatSync6(systemRoot, { throwIfNoEntry: false }))
-          argv.push("--ro-bind", systemRoot, systemRoot);
-      }
-      for (const mount of input.mounts ?? []) {
-        if (!path6.isAbsolute(mount.source) || !path6.isAbsolute(mount.target))
-          throw new Error("isolation-mount-invalid");
-        argv.push(mount.writable ? "--bind" : "--ro-bind", mount.source, mount.target);
-      }
-    }
-    for (const [name, value] of Object.entries(input.environment ?? {}).sort()) {
-      if (!validEnvironmentName(name) || value.includes("\x00"))
-        throw new Error("isolation-environment-invalid");
-      argv.push("--setenv", name, value);
+    try {
+      writeFileSync(fd, JSON.stringify(lock));
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    return lock;
+  }
+  assertOwner(lock) {
+    if (JSON.stringify(this.inspectLock()) !== JSON.stringify(lock))
+      throw new Error("Coordination lock changed");
+  }
+  release(lock) {
+    if (lock.pid !== process.pid || lock.host !== hostname())
+      throw new Error("Only the owning process may release a lock");
+    this.assertOwner(lock);
+    unlinkSync(this.lockPath);
+  }
+  recover(expected, acknowledgeEscapedProcesses) {
+    if (!acknowledgeEscapedProcesses || expected.host !== hostname())
+      throw new Error("Recovery requires informed local-owner confirmation");
+    this.assertOwner(expected);
+    try {
+      process.kill(expected.pid, 0);
+    } catch (error) {
+      if (!object(error) || error.code !== "ESRCH")
+        throw new Error("Owner status unknown");
+      this.assertOwner(expected);
+      unlinkSync(this.lockPath);
+      return;
     }
-    argv.push("--", input.executable, ...input.args ?? []);
-    return new Promise((resolve2) => {
-      let settled = false;
-      const stdout = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
-      const stderr = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
-      let child;
-      let executionTimer;
-      let killTimer;
-      let terminationResult;
-      const settle = (result) => {
-        if (settled)
-          return;
-        settled = true;
-        if (executionTimer)
-          clearTimeout(executionTimer);
-        input.signal?.removeEventListener("abort", abort);
-        resolve2(result);
-      };
-      const kill = (signal) => {
-        child?.kill(signal);
-      };
-      const terminate = (result) => {
-        if (settled || terminationResult)
-          return;
-        terminationResult = result;
-        if (executionTimer)
-          clearTimeout(executionTimer);
-        killTimer = setTimeout(() => kill("SIGKILL"), this.#terminateGraceMs);
-        killTimer.unref?.();
-        kill("SIGTERM");
-      };
-      const abort = () => {
-        terminate({ ok: false, state: "cancelled", code: "cancelled" });
-      };
-      try {
-        child = this.#spawn(this.#bwrapPath, argv, {
-          cwd: root,
-          shell: false,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-      } catch {
-        settle({
-          ok: false,
-          state: "paused",
-          code: "isolation-backend-launch-failed"
-        });
-        return;
-      }
-      const capture = (destination, chunk) => {
-        if (!settled && !terminationResult)
-          destination.append(chunk);
-      };
-      child.stdout?.on("data", (chunk) => {
-        capture(stdout, chunk);
-      });
-      child.stderr?.on("data", (chunk) => {
-        capture(stderr, chunk);
-      });
-      child.once("error", () => {
-        if (terminationResult)
-          return;
-        settle({
-          ok: false,
-          state: "paused",
-          code: "isolation-backend-launch-failed"
-        });
-      });
-      child.once("close", (code) => {
-        if (killTimer)
-          clearTimeout(killTimer);
-        settle(terminationResult ?? {
-          ok: true,
-          state: "completed",
-          exitCode: code ?? 1,
-          stdout: stdout.text(),
-          stderr: stderr.text(),
-          logs: { stdout: stdout.metadata(), stderr: stderr.metadata() },
-          ...input.outputWitness ? {
-            outputWitnessMatched: stdout.witnessMatched || stderr.witnessMatched
-          } : {}
-        });
-      });
-      input.signal?.addEventListener("abort", abort, { once: true });
-      if (input.signal?.aborted) {
-        abort();
-        return;
-      }
-      executionTimer = setTimeout(() => terminate({
-        ok: false,
-        state: "paused",
-        code: "isolation-execution-timeout"
-      }), this.#timeoutMs);
-      executionTimer.unref?.();
-    });
-  }
-}
-
-// src/windows-job-backend.ts
-var SHUTDOWN_MS = 5000;
-var invalid = () => {
-  throw new Error("windows-job-request-invalid");
-};
-var text = (value) => typeof value === "string" && value.length <= 16384 && !value.includes("\x00") && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
-var absolute = (value) => text(value) && /^[A-Za-z]:\\/u.test(value) && path7.win32.isAbsolute(value);
-function encodeWindowsJobRequest(input, timeoutMs) {
-  if (!absolute(input.root) || !absolute(input.executable) || !input.executable.toLowerCase().endsWith(".exe") || input.mounts?.length || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 86400000)
-    invalid();
-  const args = input.args ?? [];
-  if (args.length > 128 || !args.every(text))
-    invalid();
-  const seen = new Set;
-  const env = Object.entries(input.environment ?? {});
-  for (const [name, value] of env) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || !text(value) || seen.has(name.toUpperCase()))
-      invalid();
-    seen.add(name.toUpperCase());
+    throw new Error("Owner is live; stop it first");
   }
-  const quote = (value) => `"${value.replace(/(\\*)"/gu, "$1$1\\\"").replace(/(\\+)$/gu, "$1$1")}"`;
-  const command = [input.executable, ...args].map(quote).join(" ");
-  if (command.length >= 32767)
-    invalid();
-  const environment = `${env.sort(([a], [b]) => a.toUpperCase() < b.toUpperCase() ? -1 : 1).map(([k, v]) => `${k}=${v}`).join("\x00")}\x00\x00`;
-  const parts = [
-    `${input.executable}\x00`,
-    `${command}\x00`,
-    `${input.root}\x00`,
-    environment
-  ].map((s) => Buffer.from(s, "utf16le"));
-  const header = Buffer.alloc(36);
-  [2, timeoutMs, SHUTDOWN_MS, 0, ...parts.map((p) => p.length), 0].forEach((n, i) => {
-    header.writeUInt32LE(n, i * 4);
-  });
-  const wire = Buffer.concat([header, ...parts]);
-  if (wire.length > 65536 || parts.some((p) => p.length > 60000))
-    invalid();
-  return wire;
-}
-function verifyWindowsJobHelper(helper) {
-  try {
-    if (!path7.isAbsolute(helper))
-      return false;
-    const files = [helper, `${helper}.json`];
-    if (files.some((file) => {
-      const s = lstatSync7(file);
-      return !s.isFile() || s.isSymbolicLink() || s.size > 8 * 1024 * 1024;
-    }))
-      return false;
-    const bytes = readFileSync4(helper);
-    const pe = bytes.length >= 64 ? bytes.readUInt32LE(60) : -1;
-    if (bytes.toString("ascii", 0, 2) !== "MZ" || pe < 64 || pe + 6 > bytes.length || bytes.readUInt32LE(pe) !== 17744 || bytes.readUInt16LE(pe + 4) !== 34404)
-      return false;
-    const hash = (data) => createHash3("sha256").update(data).digest("hex");
-    const manifest = JSON.parse(readFileSync4(`${helper}.json`, "utf8"));
-    return manifest.version === 2 && manifest.arch === "x64" && manifest.helperSha256 === hash(bytes) && manifest.sourceSha256 === hash(readFileSync4(new URL("./windows-job.c", import.meta.url)));
-  } catch {
-    return false;
+  load(id) {
+    return this.loadSnapshot(id)?.record;
   }
-}
-function observation(value) {
-  if (!value || typeof value !== "object")
-    return;
-  const v = value;
-  if (Object.keys(v).sort().join(",") !== "exitCode,managedSettled,outcome,reason,rootExited,version" || v.version !== 2 || !["complete", "failed", "uncertain"].includes(v.outcome) || ![
-    "exit",
-    "timeout",
-    "cancelled",
-    "launch-failed",
-    "termination-unconfirmed"
-  ].includes(v.reason) || typeof v.rootExited !== "boolean" || typeof v.managedSettled !== "boolean" || !(v.exitCode === null || Number.isInteger(v.exitCode) && v.exitCode >= 0 && v.exitCode <= 4294967295))
-    return;
-  if (v.outcome === "complete" && (v.reason !== "exit" || !v.rootExited || !v.managedSettled || v.exitCode === null))
-    return;
-  if (v.outcome === "failed" && (!v.managedSettled || !["timeout", "cancelled", "launch-failed"].includes(v.reason)))
-    return;
-  return v;
-}
-var uncertain = () => ({
-  ok: false,
-  state: "paused",
-  code: "isolation-termination-unconfirmed"
-});
-function classify(v, helperExit, output, cancelled) {
-  if (!v?.managedSettled || v.outcome === "uncertain" || helperExit !== 0)
-    return uncertain();
-  if (cancelled || v.reason === "cancelled")
-    return { ok: false, state: "cancelled", code: "cancelled" };
-  if (v.reason === "timeout")
-    return { ok: false, state: "paused", code: "isolation-execution-timeout" };
-  if (v.reason === "launch-failed")
-    return {
-      ok: false,
-      state: "paused",
-      code: "isolation-backend-launch-failed"
-    };
-  if (v.outcome !== "complete" || v.exitCode === null)
-    return uncertain();
-  return {
-    ok: true,
-    state: "completed",
-    exitCode: v.exitCode,
-    stdout: output.text(),
-    stderr: "",
-    outputWitnessMatched: output.witnessMatched,
-    logs: { stdout: output.metadata(), stderr: { bytes: 0, truncated: false } }
-  };
-}
-
-class WindowsJobBackend {
-  #options;
-  constructor(options) {
-    for (const [value, maximum] of [
-      [options.timeoutMs ?? ISOLATION_RUN_LIMITS.timeoutMs, 86400000],
-      [
-        options.maxOutputBytes ?? ISOLATION_RUN_LIMITS.maxOutputBytes,
-        1024 * 1024
-      ]
-    ])
-      if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
-        throw new Error("isolation-run-limits-invalid");
-    this.#options = options;
-  }
-  available() {
-    return (this.#options.platform ?? process.platform) === "win32" && (this.#options.arch ?? process.arch) === "x64" && (this.#options.probe ?? verifyWindowsJobHelper)(this.#options.helperPath);
+  loadSnapshot(id) {
+    if (!validId(id))
+      throw new Error("Invalid task id");
+    const directory = join(this.tasks, id);
+    if (safeDirectory(directory) && readdirSync(directory).some((name) => name !== "task.json"))
+      throw new Error("Unknown task directory content; preserved without reset");
+    const data = readBounded(join(this.tasks, id, "task.json"), MAX_RECORD_BYTES);
+    if (!data)
+      return;
+    const record = decodeTask(parseRecord(data));
+    if (record.id !== id)
+      throw new Error("Task identity mismatch");
+    return { record, identity: contentIdentity(data) };
+  }
+  list() {
+    if (!safeDirectory(this.tasks))
+      return [];
+    const entries = readdirSync(this.tasks);
+    if (entries.length > 1000)
+      throw new Error("Task listing limit exceeded");
+    return entries.map((id) => {
+      const task = this.load(id);
+      if (!task)
+        throw new Error("Unknown task directory");
+      return task;
+    });
   }
-  async run(input) {
-    if (!this.available())
-      return {
-        ok: false,
-        state: "paused",
-        code: "isolation-backend-unavailable"
-      };
-    if (input.signal?.aborted)
-      return { ok: false, state: "cancelled", code: "cancelled" };
-    if (input.outputWitness !== undefined && (!text(input.outputWitness) || input.outputWitness.length < 1 || input.outputWitness.length > 512))
-      return {
-        ok: false,
-        state: "paused",
-        code: "isolation-backend-launch-failed"
-      };
-    const timeoutMs = this.#options.timeoutMs ?? ISOLATION_RUN_LIMITS.timeoutMs;
-    let wire;
+  save(record, expectedRevision, held, expectedIdentity) {
+    const next = decodeTask(record);
+    if (next.revision !== expectedRevision + 1)
+      throw new Error("Revision conflict");
+    const text = recordText(next);
+    if (Buffer.byteLength(text) > MAX_RECORD_BYTES)
+      throw new Error("Task record limit");
+    const lock = held ?? this.acquire();
+    if (lock.pid !== process.pid || lock.host !== hostname())
+      throw new Error("Not the lock owner");
     try {
-      wire = encodeWindowsJobRequest(input, timeoutMs);
-    } catch {
-      return {
-        ok: false,
-        state: "paused",
-        code: "isolation-backend-launch-failed"
-      };
-    }
-    const output = new BoundedLog(this.#options.maxOutputBytes ?? ISOLATION_RUN_LIMITS.maxOutputBytes, input.outputWitness);
-    return new Promise((resolve2) => {
-      let child;
-      let line = "", final, bad = false, closed = false, launchFailed = false;
-      let timer;
-      let stopping = false;
-      const armDeadline = (duration) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => {
-          bad = true;
-          child.kill();
-          finish(uncertain());
-        }, duration);
-        timer.unref?.();
-      };
-      const cancel = () => {
-        if (stopping || closed)
-          return;
-        stopping = true;
-        child.stdin?.end();
-        armDeadline(SHUTDOWN_MS + 5000);
-      };
-      const finish = (result) => {
-        if (closed)
-          return;
-        closed = true;
-        clearTimeout(timer);
-        input.signal?.removeEventListener("abort", cancel);
-        resolve2(result);
-      };
+      this.assertOwner(lock);
+      const current = this.loadSnapshot(next.id);
+      if ((current?.record.revision ?? 0) !== expectedRevision)
+        throw new Error("Revision conflict");
+      if (current?.identity !== expectedIdentity)
+        throw new Error("Task content changed; reopen it");
+      const dir = join(this.tasks, next.id);
+      safeDirectory(dir, true);
+      if (!current && readdirSync(dir).length)
+        throw new Error("Unknown task directory");
+      const temporary = join(dir, `task.${randomUUID()}.tmp`);
+      const fd = openSync(temporary, "wx", 384);
       try {
-        child = (this.#options.spawnProcess ?? spawn2)(this.#options.helperPath, [], {
-          cwd: input.root,
-          shell: false,
-          windowsHide: true,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      } catch {
-        finish({
-          ok: false,
-          state: "paused",
-          code: "isolation-backend-launch-failed"
-        });
-        return;
+        writeFileSync(fd, text);
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
       }
-      const malformed = () => {
-        bad = true;
-        cancel();
-      };
-      child.stdout?.on("data", (chunk) => {
-        if (closed || bad)
-          return;
-        line += chunk.toString("utf8");
-        while (line.includes(`
-`)) {
-          const end = line.indexOf(`
-`);
-          const row = line.slice(0, end);
-          line = line.slice(end + 1);
-          if (row.length > 4096 || final) {
-            malformed();
-            return;
-          }
-          try {
-            const value = JSON.parse(row);
-            if (Object.keys(value).length === 1 && typeof value.outputHex === "string" && /^(?:[a-f0-9]{2}){1,1024}$/u.test(value.outputHex))
-              output.append(Buffer.from(value.outputHex, "hex"));
-            else {
-              final = observation(value);
-              if (!final) {
-                malformed();
-                return;
-              }
-            }
-          } catch {
-            malformed();
-            return;
-          }
-        }
-        if (line.length > 4096)
-          malformed();
-      });
-      child.stderr?.on("data", () => {});
-      child.stdin?.on("error", () => {
-        bad = true;
-      });
-      child.once("error", () => {
-        bad = true;
-        launchFailed = child.pid === undefined;
-      });
-      child.once("close", (code) => finish(launchFailed ? {
-        ok: false,
-        state: "paused",
-        code: "isolation-backend-launch-failed"
-      } : bad || line.length ? uncertain() : classify(final, code, output, input.signal?.aborted === true)));
-      armDeadline(timeoutMs + SHUTDOWN_MS + 1e4);
-      input.signal?.addEventListener("abort", cancel, { once: true });
-      child.stdin?.write(wire);
-      if (input.signal?.aborted)
-        cancel();
+      this.assertOwner(lock);
+      const latest = readBounded(join(dir, "task.json"), MAX_RECORD_BYTES);
+      if ((latest ? contentIdentity(latest) : undefined) !== expectedIdentity)
+        throw new Error("Task content changed; replacement preserved without overwrite");
+      renameSync(temporary, join(dir, "task.json"));
+      return next;
+    } finally {
+      if (!held)
+        this.release(lock);
+    }
+  }
+  checks() {
+    const data = readBounded(join(this.root, ".cadence", "assistant", "config.json"), 32768);
+    if (!data)
+      return [];
+    const value = parseRecord(data);
+    if (!object(value) || value.schema !== TASK_CONFIG_SCHEMA || !Array.isArray(value.checks) || value.checks.length > 32 || Object.keys(value).some((key) => !["schema", "checks"].includes(key)))
+      throw new Error("Unknown check configuration");
+    const checks = value.checks.map(decodeCheck);
+    if (new Set(checks.map((check) => check.name)).size !== checks.length || checks.some((check) => check.name === "Manual command"))
+      throw new Error("Duplicate or reserved check name");
+    return checks;
+  }
+  readLog(name) {
+    if (!/^[a-f0-9-]{36}\.log$/.test(name))
+      throw new Error("Invalid diagnostic name");
+    this.inspectPrivateFile(join(this.privateRoot, name), 65536);
+    const data = readBounded(join(this.privateRoot, name), 65536);
+    return data ? diagnosticText(data.toString("utf8"), 65536) : "Private diagnostic unavailable";
+  }
+  writeLog(lock, output) {
+    if (lock.pid !== process.pid || lock.host !== hostname())
+      throw new Error("Not the lock owner");
+    this.assertOwner(lock);
+    const name = `${randomUUID()}.log`;
+    writeFileSync(join(this.privateRoot, name), diagnosticText(output, 65536), {
+      flag: "wx",
+      mode: 384
     });
+    return name;
   }
 }
-function probeWindowsJob(helper) {
-  if (process.platform !== "win32" || process.arch !== "x64" || !verifyWindowsJobHelper(helper))
-    return false;
-  const wire = encodeWindowsJobRequest({
-    root: process.cwd(),
-    executable: process.execPath,
-    args: ["-e", "process.exit(0)"],
-    environment: { SystemRoot: process.env.SystemRoot ?? "C:\\Windows" }
-  }, 5000);
-  const result = spawnSync(helper, ["--probe"], {
-    input: wire,
-    shell: false,
-    encoding: "utf8",
-    timeout: 15000,
-    maxBuffer: 65536
-  });
-  try {
-    const v = observation(JSON.parse(result.stdout.trim()));
-    return !result.error && result.status === 0 && v?.outcome === "complete" && v.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
+var TASK_CONFIG_SCHEMA = "cadence-assistant-checks/1";
 
 // src/operator-tools.ts
-var PACKAGE_LOCKS = {
-  bun: ["bun.lock", "bun.lockb"],
-  npm: ["package-lock.json", "npm-shrinkwrap.json"],
-  pnpm: ["pnpm-lock.yaml"],
-  yarn: ["yarn.lock"]
-};
-function packageManagerSelection(root, declaration) {
-  const managers = Object.keys(PACKAGE_LOCKS);
-  const lockfiles = managers.flatMap((manager) => PACKAGE_LOCKS[manager].filter((file) => lstatSync8(path8.join(root, file), { throwIfNoEntry: false })?.isFile()));
-  const inferred = managers.filter((manager) => PACKAGE_LOCKS[manager].some((file) => lockfiles.includes(file)));
-  const declared = typeof declaration === "string" ? managers.find((manager) => new RegExp(`^${manager}@[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][a-z0-9._+-]+)?$`, "iu").test(declaration)) : undefined;
-  const selectedPackageManager = declaration !== undefined ? declared ?? null : inferred.length === 1 ? inferred[0] ?? null : inferred.length > 1 ? null : "npm";
-  const selectionSource = declaration !== undefined ? declared ? "package.json" : "invalid-declaration" : inferred.length === 1 ? "lockfile" : inferred.length > 1 ? "ambiguous" : "default";
+function inspectConsumer(cwd) {
+  const workspace = resolveWorkspace(cwd);
+  const store = new TaskStore(workspace.root);
+  const tasks = store.list();
+  const checks = store.checks();
+  const lock = store.inspectLock();
   return {
-    selectedPackageManager,
-    selectionSource,
-    lockfiles,
-    ambiguousLockfiles: inferred.length > 1
-  };
-}
-function inspectConsumer(root) {
-  root = realpathSync4(root);
-  const checks = [];
-  const check = (name, action, nextStep) => {
-    try {
-      checks.push({ name, ok: true, detail: action() });
-    } catch (error) {
-      checks.push({
-        name,
-        ok: false,
-        detail: error instanceof Error ? error.message : "unavailable",
-        nextStep
-      });
-    }
+    ok: true,
+    schema: "cadence-assistant-doctor/1",
+    root: workspace.root,
+    cwd: workspace.cwd,
+    taskCount: tasks.length,
+    checks: checks.map(({ name, timeoutMs }) => ({
+      name: diagnosticText(name),
+      timeoutMs
+    })),
+    checkStatus: "not-run",
+    coordination: lock ? "locked; inspect in the terminal workflow" : "unlocked",
+    note: "Observation only. Missing state stays absent. Old history is not imported. External and older writers are not contained."
   };
-  check("node", () => {
-    if (Number(process.versions.node.split(".")[0]) < 22 || Number(process.versions.node.split(".")[0]) === 22 && Number(process.versions.node.split(".")[1]) < 13)
-      throw new Error("Node 22.13+ required");
-    return process.versions.node;
-  }, "Install Node >=22.13.");
-  check("git", () => {
-    const result = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
-      cwd: root,
-      encoding: "utf8",
-      timeout: 5000,
-      maxBuffer: 65536
-    });
-    if (result.status !== 0)
-      throw new Error("git-repository-unavailable");
-    return result.stdout.trim();
-  }, "Install Git and initialize the consumer repository.");
-  check("openspec", () => {
-    resolveOpenSpecInvocation(root);
-    return "resolved (protocol not executed)";
-  }, "Install @fission-ai/openspec@1.5.0, or configure ABEL_OPENSPEC_PACKAGE_ROOT / ABEL_OPENSPEC_NODE before launching the host.");
-  check("execution", () => {
-    const profile = executionProfile();
-    if (profile.mode === "host-trusted") {
-      if (!probeWindowsJob(profile.windowsHelperPath ?? ""))
-        throw new Error("windows-job-backend-unavailable");
-      return "host-trusted: Windows x64 Job probe passed; host files/network accessible";
-    }
-    if (process.platform !== "linux")
-      throw new Error("linux-pid-isolation-required");
-    const result = spawnSync2(profile.bwrapPath, [
-      "--ro-bind",
-      "/",
-      "/",
-      profile.mode === "local-trusted" ? "--unshare-pid" : "--unshare-all",
-      "--",
-      "/bin/true"
-    ], { timeout: 5000, encoding: "utf8", maxBuffer: 65536 });
-    if (result.status !== 0)
-      throw new Error("bubblewrap-probe-failed");
-    return `${profile.mode}: Bubblewrap PID namespace probe passed`;
-  }, "On Linux install/enable Bubblewrap; set ABEL_BWRAP_PATH for a custom install. Trusted Linux projects may explicitly set ABEL_EXECUTION_MODE=local-trusted; Windows x64 trusted projects may explicitly select ABEL_EXECUTION_MODE=host-trusted and install the matching native Job helper (ABEL_WINDOWS_JOB_HELPER).");
-  check("request-budgets", () => JSON.stringify(requestBounds()), "Set ABEL_FIRST_PROGRESS_MS and ABEL_STREAM_IDLE_MS to positive milliseconds <=1200000.");
-  check("state-root", () => resolveStateRoot({
-    consumerRoot: root,
-    xdgStateHome: process.env.XDG_STATE_HOME
-  }).rootDir, "Use an absolute repository-external XDG_STATE_HOME.");
-  check("workspace-dependencies", () => {
-    const dependencies = path8.join(root, "node_modules");
-    if (!lstatSync8(dependencies, { throwIfNoEntry: false }))
-      return "no node_modules; prepare dependencies before verification";
-    const names = readdirSync4(dependencies).flatMap((name) => name.startsWith("@") && lstatSync8(path8.join(dependencies, name)).isDirectory() ? readdirSync4(path8.join(dependencies, name)).map((child) => `${name}/${child}`) : [name]);
-    if (names.length > 20000)
-      throw new Error("dependency-view-too-large");
-    let links = 0;
-    for (const name of names) {
-      const file = path8.join(dependencies, name);
-      if (!lstatSync8(file).isSymbolicLink())
-        continue;
-      const resolved = realpathSync4(file);
-      const relative = path8.relative(root, resolved);
-      if (relative === ".." || relative.startsWith(`..${path8.sep}`) || path8.isAbsolute(relative))
-        throw new Error("dependency-link-outside-consumer");
-      if (!resolved.startsWith(`${dependencies}${path8.sep}`))
-        links++;
-    }
-    return `${links} repository workspace link(s); their targets must be included in the candidate baseline`;
-  }, "Repair dangling/external workspace links and ensure local package sources are tracked or admitted in the candidate.");
-  const manifest = path8.join(root, "package.json");
-  let selection = packageManagerSelection(root, undefined);
-  if (lstatSync8(manifest, { throwIfNoEntry: false })?.isFile()) {
-    check("manifest", () => {
-      const parsed2 = JSON.parse(readFileSync5(manifest, "utf8"));
-      if (!parsed2 || typeof parsed2 !== "object")
-        throw new Error("manifest-invalid");
-      return Object.keys(parsed2.scripts ?? {}).join(", ") || "no package scripts";
-    }, "Repair package.json.");
-    const parsed = (() => {
-      try {
-        const value = JSON.parse(readFileSync5(manifest, "utf8"));
-        return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-      } catch {
-        return {};
-      }
-    })();
-    selection = packageManagerSelection(root, parsed.packageManager);
-    check("package-manager", () => {
-      if (!selection.selectedPackageManager)
-        throw new Error(`package-manager-${selection.selectionSource}`);
-      return `${selection.selectedPackageManager} (${selection.selectionSource})`;
-    }, "Declare the intended packageManager in package.json; doctor does not read private plans, install runners or remove lockfiles.");
-    for (const script of ["test", "check", "build"].filter((name) => typeof parsed.scripts?.[name] === "string")) {
-      check(`script:${script}`, () => {
-        const manager = selection.selectedPackageManager;
-        if (!manager)
-          throw new Error(`package-manager-${selection.selectionSource}`);
-        const result = validateVerificationAdapterCapability(root, {
-          kind: "package-script",
-          id: `doctor-${script}`,
-          packageManager: manager,
-          script,
-          command: parsed.scripts[script],
-          args: [],
-          classification: "expected-green"
-        });
-        if (!result.ok)
-          throw new Error(`${manager}:${result.diagnostic.code}`);
-        return "statically admitted; tests not executed";
-      }, "Check the runner, installed dependencies and execution configuration; this probe does not execute your tests.");
-    }
-  }
-  return { root, ...selection, ok: checks.every((entry) => entry.ok), checks };
 }
-function storageUsage(root, maximum = 1e5) {
-  let entries = 0;
-  let bytes = 0;
-  let truncated = false;
-  const visit = (file) => {
-    if (entries >= maximum) {
-      truncated = true;
-      return;
-    }
-    const stat = lstatSync8(file, { throwIfNoEntry: false });
-    if (!stat)
-      return;
-    entries++;
-    if (stat.isFile())
-      bytes += stat.size;
-    else if (stat.isDirectory())
-      for (const name of readdirSync4(file)) {
-        visit(path8.join(file, name));
-        if (truncated)
-          break;
-      }
+function inspectRuns(cwd) {
+  const workspace = resolveWorkspace(cwd);
+  const store = new TaskStore(workspace.root);
+  return {
+    ok: true,
+    schema: "cadence-assistant-history/1",
+    root: workspace.root,
+    tasks: store.list().map((task) => ({
+      id: task.id,
+      kind: task.kind,
+      phase: task.phase === "running" ? "interrupted" : task.phase,
+      goal: diagnosticText(task.goal, 512),
+      revision: task.revision,
+      checks: task.checks.map(({ name, status, exitCode, durationMs }) => ({
+        name: diagnosticText(name, 128),
+        status,
+        exitCode,
+        durationMs
+      })),
+      review: task.review?.outcome ?? "not-reviewed"
+    })),
+    note: "Context only; no work resumed. Stored check outcomes are historical, not a current freshness verification. Legacy stores remain untouched."
   };
-  visit(root);
-  return { entries, bytes, truncated };
-}
-function inspectRuns(root) {
-  const state = resolveStateRoot({
-    consumerRoot: root,
-    xdgStateHome: process.env.XDG_STATE_HOME
-  });
-  const usage = storageUsage(state.rootDir);
-  if (!lstatSync8(state.databasePath, { throwIfNoEntry: false }))
-    return { stateRoot: state.rootDir, usage, runs: [], truncated: false };
-  const db = new DatabaseSync(state.databasePath, { readOnly: true });
-  try {
-    const rows = db.prepare("SELECT run_id, stage, change_name, state, sequence FROM runs ORDER BY run_id LIMIT 1001").all();
-    return {
-      stateRoot: state.rootDir,
-      usage,
-      runs: rows.slice(0, 1000),
-      truncated: rows.length > 1000
-    };
-  } finally {
-    db.close();
-  }
 }
 
 // src/operator-cli-entry.mjs
-var [command = "doctor", root = process.cwd()] = process.argv.slice(2);
 try {
-  if (!["doctor", "runs"].includes(command))
-    throw new Error("Usage: node --experimental-strip-types <cadence>/src/operator-cli.mjs doctor|runs [consumer-root]");
-  const result = command === "doctor" ? inspectConsumer(path9.resolve(root)) : inspectRuns(path9.resolve(root));
+  const [command = "doctor", root = process.cwd(), ...extra] = process.argv.slice(2);
+  if (!["doctor", "runs"].includes(command) || extra.length)
+    throw new Error("usage");
+  const result = command === "doctor" ? inspectConsumer(path.resolve(root)) : inspectRuns(path.resolve(root));
   console.log(JSON.stringify(result, null, 2));
-  if (command === "doctor" && !result.ok)
-    process.exitCode = 1;
-} catch (error) {
+} catch {
   console.error(JSON.stringify({
     ok: false,
-    error: error instanceof Error ? error.message : "operator-command-failed"
+    error: "operator-refused",
+    usage: "node <cadence>/src/operator-cli.mjs doctor|runs [workspace]"
   }));
   process.exitCode = 1;
 }