@brainervirus/workit-mcp 3.0.0 → 4.0.0

package/dist/index.js

@@ -6620,11 +6620,11 @@ var require_dist = __commonJS(function(exports, module) {
 
 // packages/workit-mcp/src/index.ts
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path18 from "node:path";
+import path20 from "node:path";
 
 // packages/workit-mcp/src/server.ts
 import { existsSync as existsSync7, readFileSync as readFileSync8, realpathSync as realpathSync8 } from "node:fs";
-import path17 from "node:path";
+import path19 from "node:path";
 
 // node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
@@ -16783,9 +16783,9 @@ class StdioServerTransport {
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync5, realpathSync as realpathSync7 } from "node:fs";
-import path13 from "node:path";
+import path15 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -17625,16 +17625,6 @@ var stateOperations = {
     expectedWorkspaceRevision: revision.nullable().optional(),
     bundle: exportBundleSchema,
     authorityRefs: array(refSchema)
-  }),
-  recover: operation({
-    action: literal("recover"),
-    taskId: id.optional(),
-    expectedWorkspaceRevision: revision.optional(),
-    target: _enum(["task", "workspace"]),
-    expectedBytes: digest,
-    snapshotDigest: digest,
-    reason: text,
-    authorityRefs: array(refSchema)
   })
 };
 var operationSchemas = {
@@ -17647,10 +17637,17 @@ var operationSchemas = {
   writer: discriminatedUnion("action", Object.values(writerOperations)),
   state: discriminatedUnion("action", Object.values(stateOperations))
 };
-var { recover: _unadvertisedRecover, ...advertisedStateOperations } = stateOperations;
+var withImplicitTask = (options) => Object.values(options).map((option) => ("taskId" in option.shape) ? option.extend({ taskId: id.optional() }) : option);
+var advertised = (options) => discriminatedUnion("action", withImplicitTask(options));
 var advertisedOperationSchemas = {
-  ...operationSchemas,
-  state: discriminatedUnion("action", Object.values(advertisedStateOperations))
+  task: advertised(taskOperations),
+  policy: advertised(policyOperations),
+  evidence: advertised(evidenceOperations),
+  finding: advertised(findingOperations),
+  decision: advertised(decisionOperations),
+  worker: advertised(workerOperations),
+  writer: advertised(writerOperations),
+  state: advertised(stateOperations)
 };
 var compiledOperationSchemas = Object.fromEntries(OPERATION_FAMILIES.map((family) => [family, compile(operationSchemas[family])]));
 var success = (revisionValue, workspaceRevisionValue, data) => ({
@@ -17865,29 +17862,10 @@ function requirementId(input) {
   });
 }
 // packages/workit-core/src/core/task-store.ts
-import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
-import * as fs5 from "node:fs";
-import path4 from "node:path";
-
-// packages/workit-core/src/core/package-root.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-var packageRoot = () => {
-  let dir = path.dirname(fileURLToPath(import.meta.url));
-  while (true) {
-    const parent = path.dirname(dir);
-    if (existsSync(path.join(dir, "package.json")) || parent === dir)
-      return dir;
-    dir = parent;
-  }
-};
-var assetRoot = () => {
-  const root = packageRoot();
-  const assets = path.join(root, "assets");
-  return existsSync(assets) ? assets : root;
-};
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import * as fs7 from "node:fs";
+import path6 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -17938,7 +17916,7 @@ function sameFileIdentity(left, right, platform = process.platform) {
 // node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.js
 import { randomBytes } from "node:crypto";
 import fsSync from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/bounded-read.js
 import fs from "node:fs";
@@ -18028,13 +18006,13 @@ ${ownershipToken}
   return { raw, ownershipToken };
 }
 function relativeSidecarLockPath(lockRoot, lockPath) {
-  const resolved = path2.resolve(lockPath);
-  const lexicalRelative = path2.relative(lockRoot.rootDir, resolved);
-  const relative = lexicalRelative !== ".." && !lexicalRelative.startsWith(`..${path2.sep}`) && !path2.isAbsolute(lexicalRelative) ? lexicalRelative : path2.relative(lockRoot.rootReal, resolved);
-  if (!relative || relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
+  const resolved = path.resolve(lockPath);
+  const lexicalRelative = path.relative(lockRoot.rootDir, resolved);
+  const relative = lexicalRelative !== ".." && !lexicalRelative.startsWith(`..${path.sep}`) && !path.isAbsolute(lexicalRelative) ? lexicalRelative : path.relative(lockRoot.rootReal, resolved);
+  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock path is outside lockRoot");
   }
-  return relative.split(path2.sep).join(path2.posix.sep);
+  return relative.split(path.sep).join(path.posix.sep);
 }
 function parseSidecarLockPayload(raw, parser) {
   if (parser) {
@@ -18181,7 +18159,7 @@ function getFsSafeLockConfig() {
 
 // node_modules/@openclaw/fs-safe/dist/file-lock-sync.js
 import fs3 from "node:fs";
-import path3 from "node:path";
+import path2 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/timing.js
 function sleepSync(ms) {
@@ -18272,26 +18250,26 @@ function canonicalLockParentSync(parent) {
   return process.platform === "win32" ? fs3.realpathSync.native(parent) : fs3.realpathSync(parent);
 }
 function normalizeTargetPath(targetPath) {
-  const resolved = path3.resolve(targetPath);
-  fs3.mkdirSync(path3.dirname(resolved), { recursive: true });
+  const resolved = path2.resolve(targetPath);
+  fs3.mkdirSync(path2.dirname(resolved), { recursive: true });
   try {
-    return path3.join(canonicalLockParentSync(path3.dirname(resolved)), path3.basename(resolved));
+    return path2.join(canonicalLockParentSync(path2.dirname(resolved)), path2.basename(resolved));
   } catch {
     return resolved;
   }
 }
 function boundedLockPath(lockPath, lockRoot) {
-  const resolved = path3.resolve(lockPath);
+  const resolved = path2.resolve(lockPath);
   if (!lockRoot)
     return resolved;
   relativeSidecarLockPath(lockRoot, resolved);
-  const parent = path3.dirname(resolved);
+  const parent = path2.dirname(resolved);
   const parentReal = canonicalLockParentSync(parent);
-  const parentRelative = path3.relative(lockRoot.rootReal, parentReal);
-  if (parentRelative === ".." || parentRelative.startsWith(`..${path3.sep}`) || path3.isAbsolute(parentRelative)) {
+  const parentRelative = path2.relative(lockRoot.rootReal, parentReal);
+  if (parentRelative === ".." || parentRelative.startsWith(`..${path2.sep}`) || path2.isAbsolute(parentRelative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock parent is outside lockRoot");
   }
-  return path3.join(parentReal, path3.basename(resolved));
+  return path2.join(parentReal, path2.basename(resolved));
 }
 function defaultShouldReclaim(snapshot, staleMs, nowMs) {
   const createdAtMs = sidecarLockPayloadCreatedAtMs(snapshot.payload);
@@ -18490,10 +18468,311 @@ function acquireFileLockSync(targetPath, options) {
     }
   }
 }
+// packages/workit-core/src/core/package-root.ts
+import { existsSync } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = () => {
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const parent = path3.dirname(dir);
+    if (existsSync(path3.join(dir, "package.json")) || parent === dir)
+      return dir;
+    dir = parent;
+  }
+};
+var assetRoot = () => {
+  const root = packageRoot();
+  const assets = path3.join(root, "assets");
+  return existsSync(assets) ? assets : root;
+};
+
 // packages/workit-core/src/core/store-lock.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import fs5 from "node:fs";
+import { hostname } from "node:os";
+
+// packages/workit-core/src/store/paths.ts
 import { spawnSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
 import fs4 from "node:fs";
-import { hostname } from "node:os";
+import path4 from "node:path";
+var NOT_A_REPO = /not a git repository \(or any (of the parent directories|parent up to)/u;
+var gitRun = (cwd, args) => {
+  const run = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0",
+      LC_ALL: "C",
+      LANGUAGE: "C"
+    }
+  });
+  const error = run.error;
+  return {
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: error ? String(error.message) : run.stderr ?? "",
+    missing: error?.code === "ENOENT"
+  };
+};
+var shortHash = (value) => createHash2("sha256").update(value).digest("hex").slice(0, 12);
+var real = (file) => {
+  try {
+    return fs4.realpathSync.native(file);
+  } catch {
+    return file;
+  }
+};
+var DISCOVERY_ENV = [
+  "GIT_DIR",
+  "GIT_COMMON_DIR",
+  "GIT_WORK_TREE",
+  "GIT_CEILING_DIRECTORIES",
+  "GIT_DISCOVERY_ACROSS_FILESYSTEM"
+];
+var isGitDir = (dir) => {
+  try {
+    return fs4.statSync(path4.join(dir, "HEAD")).isFile() && fs4.statSync(path4.join(dir, "objects")).isDirectory() && fs4.statSync(path4.join(dir, "refs")).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var reftableRefs = (common) => {
+  try {
+    return /^\s*refstorage\s*=\s*reftable\s*$/imu.test(fs4.readFileSync(path4.join(common, "config"), "utf8"));
+  } catch {
+    return false;
+  }
+};
+function fastGit(root) {
+  if (DISCOVERY_ENV.some((name) => process.env[name]))
+    return null;
+  let dir = real(root);
+  let device = null;
+  for (;; ) {
+    let stat;
+    try {
+      stat = fs4.statSync(dir);
+    } catch {
+      return null;
+    }
+    if (device !== null && stat.dev !== device)
+      return { kind: "none" };
+    device = stat.dev;
+    const dotGit = path4.join(dir, ".git");
+    let entry = null;
+    try {
+      entry = fs4.statSync(dotGit);
+    } catch {}
+    let gitDir = null;
+    let top = null;
+    if (entry) {
+      top = dir;
+      if (entry.isDirectory())
+        gitDir = dotGit;
+      else if (entry.isFile()) {
+        let text = "";
+        try {
+          text = fs4.readFileSync(dotGit, "utf8");
+        } catch {
+          return null;
+        }
+        const match = /^gitdir: (.+)$/mu.exec(text);
+        if (!match)
+          return null;
+        gitDir = path4.resolve(dir, match[1].trim());
+      } else
+        return null;
+      if (!fs4.existsSync(path4.join(gitDir, "HEAD")))
+        return null;
+    } else if (isGitDir(dir))
+      gitDir = dir;
+    if (gitDir) {
+      let common = gitDir;
+      try {
+        common = path4.resolve(gitDir, fs4.readFileSync(path4.join(gitDir, "commondir"), "utf8").trim());
+      } catch {}
+      if (!fs4.existsSync(path4.join(common, "objects")))
+        return null;
+      return {
+        kind: "repo",
+        common: real(common),
+        gitDir: real(gitDir),
+        top: top === null ? null : real(top),
+        reftable: reftableRefs(common)
+      };
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir)
+      return { kind: "none" };
+    dir = parent;
+  }
+}
+function resolveStore(root) {
+  root = path4.resolve(root);
+  let directory = false;
+  try {
+    directory = fs4.statSync(root).isDirectory();
+  } catch {}
+  if (!directory)
+    return { dir: path4.join(root, ".workit"), shared: false, top: null };
+  const fast = fastGit(root);
+  if (fast?.kind === "none")
+    return { dir: path4.join(root, ".workit"), shared: false, top: null };
+  if (fast?.kind === "repo")
+    return {
+      dir: path4.join(fast.common, "workit"),
+      shared: true,
+      top: fast.top,
+      git: { gitDir: fast.gitDir, top: fast.top, reftable: fast.reftable }
+    };
+  const run = gitRun(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  const common = run.stdout.trim();
+  if (run.ok && common) {
+    const top = gitRun(root, ["rev-parse", "--path-format=absolute", "--show-toplevel"]);
+    return {
+      dir: path4.join(real(path4.resolve(root, common)), "workit"),
+      shared: true,
+      top: top.ok && top.stdout.trim() ? real(top.stdout.trim()) : null
+    };
+  }
+  if (run.missing || !run.ok && NOT_A_REPO.test(run.stderr))
+    return { dir: path4.join(root, ".workit"), shared: false, top: null };
+  return new Error(`cannot locate the workit store: git rev-parse failed (${run.stderr.trim().split(`
+`)[0] || "no output"}); fix the repository (git status should work here)`);
+}
+var rebasingBranch = (gitDir) => {
+  for (const state of ["rebase-merge", "rebase-apply"]) {
+    try {
+      const ref = fs4.readFileSync(path4.join(gitDir, state, "head-name"), "utf8").trim();
+      const match = /^refs\/heads\/(.+)$/u.exec(ref);
+      if (match)
+        return match[1];
+    } catch {}
+  }
+  return null;
+};
+function resolveTaskKey(root, location) {
+  if (!location.shared)
+    return { key: `dir-${shortHash(root)}`, kind: "dir", branch: null };
+  const branchKey = (name) => ({ key: name, kind: "branch", branch: name });
+  if (location.git && !location.git.reftable) {
+    let head = "";
+    try {
+      head = fs4.readFileSync(path4.join(location.git.gitDir, "HEAD"), "utf8").trim();
+    } catch {}
+    const ref = /^ref: refs\/heads\/(.+)$/u.exec(head);
+    if (ref && ref[1] !== ".invalid")
+      return branchKey(ref[1]);
+    if (/^[0-9a-f]{40,64}$/u.test(head)) {
+      const rebasing = rebasingBranch(location.git.gitDir);
+      if (rebasing)
+        return branchKey(rebasing);
+      return {
+        key: `detached-${shortHash(location.git.top ?? location.git.gitDir)}`,
+        kind: "detached",
+        branch: null
+      };
+    }
+  }
+  const branch = gitRun(root, ["symbolic-ref", "-q", "--short", "HEAD"]);
+  const name = branch.ok ? branch.stdout.trim() : "";
+  if (name && name !== ".invalid")
+    return branchKey(name);
+  const gitDir = gitRun(root, ["rev-parse", "--path-format=absolute", "--git-dir"]);
+  if (gitDir.ok && gitDir.stdout.trim()) {
+    const rebasing = rebasingBranch(gitDir.stdout.trim());
+    if (rebasing)
+      return branchKey(rebasing);
+  }
+  const top = gitRun(root, ["rev-parse", "--path-format=absolute", "--show-toplevel"]);
+  const worktree = top.ok && top.stdout.trim() ? top.stdout.trim() : root;
+  return { key: `detached-${shortHash(real(worktree))}`, kind: "detached", branch: null };
+}
+function checkoutRootOf(root, location) {
+  const resolved = path4.resolve(root);
+  let canonical = resolved;
+  try {
+    canonical = fs4.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+  const found = location ?? resolveStore(canonical);
+  if (found instanceof Error || !found.shared || !found.top)
+    return canonical;
+  if (real(canonical) === found.top)
+    return canonical;
+  try {
+    return fs4.realpathSync(found.top);
+  } catch {
+    return canonical;
+  }
+}
+function branchRenames(location) {
+  if (!location.shared)
+    return [];
+  const files = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries)
+      if (entry.isDirectory())
+        walk(path4.join(dir, entry.name));
+      else
+        files.push(path4.join(dir, entry.name));
+  };
+  walk(path4.join(path4.dirname(location.dir), "logs", "refs", "heads"));
+  if (location.git)
+    files.push(path4.join(location.git.gitDir, "logs", "HEAD"));
+  const seen = new Set;
+  const renames = [];
+  for (const file of files) {
+    let text = "";
+    try {
+      text = fs4.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const match of text.matchAll(/ (\d+) [+-]\d{4}\tBranch: renamed refs\/heads\/(\S+) to refs\/heads\/(\S+)/gu)) {
+      const rename = { from: match[2], to: match[3], at: Number(match[1]) };
+      const id = `${rename.at}\x00${rename.from}\x00${rename.to}`;
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      renames.push(rename);
+    }
+  }
+  return renames.toSorted((left, right) => left.at - right.at);
+}
+function followRenames(key, boundAt, renames) {
+  let current = key;
+  let since = Math.floor(Date.parse(boundAt) / 1000);
+  for (const rename of renames)
+    if (rename.from === current && rename.at >= since) {
+      current = rename.to;
+      since = rename.at;
+    }
+  return current;
+}
+var checkoutSlug = (root) => {
+  let canonical = real(root);
+  if (process.platform === "win32")
+    canonical = canonical.toLowerCase();
+  const base = path4.basename(canonical).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 40) || "root";
+  return `${base}-${shortHash(canonical)}`;
+};
+
+// packages/workit-core/src/core/store-lock.ts
 var metadataLockSchema = object2({
   pid: number2().int().nonnegative().safe(),
   processStart: string2().nullable(),
@@ -18525,10 +18804,6 @@ var parseMetadataLockOrNull = (raw) => {
     return null;
   }
 };
-var sameMetadataLock = (left, right) => {
-  const parsed = metadataLockSchema.safeParse(left);
-  return parsed.success && canonicalJson(parsed.data) === canonicalJson(right);
-};
 var parseProcStatStart = (stat) => {
   const close = stat.lastIndexOf(")");
   if (close < 0)
@@ -18538,14 +18813,14 @@ var parseProcStatStart = (stat) => {
 var processStartOf = (pid) => {
   if (process.platform === "linux") {
     try {
-      return parseProcStatStart(fs4.readFileSync(`/proc/${pid}/stat`, "utf8"));
+      return parseProcStatStart(fs5.readFileSync(`/proc/${pid}/stat`, "utf8"));
     } catch {
       return null;
     }
   }
   if (process.platform === "darwin" || process.platform === "freebsd") {
     try {
-      const run = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      const run = spawnSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
         encoding: "utf8",
         timeout: 1000
       });
@@ -18559,7 +18834,7 @@ var processStartOf = (pid) => {
 };
 var readTrimmed = (file) => {
   try {
-    return fs4.readFileSync(file, "utf8").trim() || null;
+    return fs5.readFileSync(file, "utf8").trim() || null;
   } catch {
     return null;
   }
@@ -18570,7 +18845,7 @@ var localLockHost = () => {
     return cachedLockHost;
   let pidns = null;
   try {
-    pidns = /\[(\d+)\]/.exec(fs4.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
+    pidns = /\[(\d+)\]/.exec(fs5.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
   } catch {}
   const boot = readTrimmed("/proc/sys/kernel/random/boot_id");
   cachedLockHost = pidns || boot ? `${hostname()}#${pidns ?? "?"}:${boot ?? "?"}` : hostname();
@@ -18610,7 +18885,7 @@ var classifyLockOwner = (payload, ageMs, localHost = localLockHost()) => {
 };
 var ageOf = (file, nowMs) => {
   try {
-    return nowMs - fs4.lstatSync(file).mtimeMs;
+    return nowMs - fs5.lstatSync(file).mtimeMs;
   } catch {
     return null;
   }
@@ -18621,117 +18896,151 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
   if (age === null || age <= RECLAIM_GUARD_TTL_MS)
     return false;
   try {
-    fs4.rmdirSync(guard);
+    fs5.rmdirSync(guard);
     return true;
   } catch {
     return false;
   }
 };
 
-// packages/workit-core/src/core/task-store.ts
-var RECOVERY_COPIES_PER_RECORD = 3;
-var STALE_TEMPORARY_MS = 60 * 60000;
-var RECOVERY_NAME = /^(task|workspace)\.([^.]+)\.([0-9a-f]{64})\.json$/;
-var processEvidenceSchema = object2({
-  state: _enum(["stopped", "accounted_for"]),
-  pid: number2().int().nonnegative(),
-  processStart: string2().nullable(),
-  ownerDigest: string2().regex(/^[0-9a-f]{64}$/).nullable()
-}).strict();
-var INDEX_VERSION = 1;
-var hostSession = (value) => isObject2(value) && value.kind === "host" && typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
-var indexEntry = (task, file) => {
-  const sessions = [];
-  const intent = hostSession(task.intent.provenance.session);
-  if (intent)
-    sessions.push({ ...intent, workerId: null });
-  for (const worker of task.workers) {
-    const session = hostSession(worker.data.session);
-    if (session)
-      sessions.push({ ...session, workerId: worker.id });
+// packages/workit-core/src/store/event-log.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs6 from "node:fs";
+import path5 from "node:path";
+var EVENT_VERSION = 1;
+
+class LogDamage extends Error {
+  upgrade;
+  constructor(message, upgrade = false) {
+    super(message);
+    this.upgrade = upgrade;
   }
-  return {
-    id: task.id,
-    revision: task.revision,
-    status: task.status,
-    createdAt: task.createdAt,
-    updatedAt: task.updatedAt,
-    objective: task.intent.data.objective,
-    source: { host: task.intent.provenance.host, kind: task.intent.provenance.kind },
-    progress: { summary: task.progress.summary, nextAction: task.progress.nextAction },
-    sessions,
-    file
-  };
-};
-var fileSignature = (file) => {
+}
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseEvent = (line, file, offset) => {
+  let value;
   try {
-    const stat = fs5.statSync(file, { bigint: true });
-    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+    value = JSON.parse(line);
   } catch {
-    return null;
-  }
-};
-var RACY_WINDOW_NS = 2000000000n;
-var racySignature = (signature) => {
-  const [mtime = 0n, ctime = 0n] = signature.split(":").slice(3, 5).map(BigInt);
-  const changed = mtime > ctime ? mtime : ctime;
-  return BigInt(Date.now()) * 1000000n - changed < RACY_WINDOW_NS;
+    throw new LogDamage(`${file}: unreadable event at byte ${offset}`);
+  }
+  if (!isObject2(value) || typeof value.v !== "number")
+    throw new LogDamage(`${file}: malformed event at byte ${offset}`);
+  if (value.v > EVENT_VERSION)
+    throw new LogDamage(`${file}: event format v${value.v} was written by a newer Workit; upgrade Workit to read this task`, true);
+  if (typeof value.seq !== "number" || !Number.isInteger(value.seq) || typeof value.type !== "string" || typeof value.id !== "string" || typeof value.task !== "string" || !isObject2(value.data))
+    throw new LogDamage(`${file}: malformed event at byte ${offset}`);
+  return value;
 };
-var now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-var cachedRuntimeVersion = null;
-var runtimeVersion = () => {
-  if (cachedRuntimeVersion === null) {
+function readLog(file, from = 0, expectSeq = null) {
+  let fd;
+  try {
+    fd = fs6.openSync(file, "r");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  let bytes;
+  let size;
+  try {
+    size = fs6.fstatSync(fd).size;
+    if (from > size)
+      throw new LogDamage(`${file}: shorter than its snapshot`);
+    bytes = Buffer.alloc(size - from);
+    let read = 0;
+    while (read < bytes.length) {
+      const got = fs6.readSync(fd, bytes, read, bytes.length - read, from + read);
+      if (got === 0)
+        break;
+      read += got;
+    }
+    bytes = bytes.subarray(0, read);
+    size = from + read;
+  } finally {
+    fs6.closeSync(fd);
+  }
+  const events = [];
+  let start = 0;
+  let lastStart = from;
+  let seq = expectSeq;
+  for (;; ) {
+    const newline = bytes.indexOf(10, start);
+    if (newline < 0)
+      break;
+    const line = bytes.subarray(start, newline).toString("utf8");
+    if (line.trim() !== "") {
+      const event = parseEvent(line, file, from + start);
+      if (seq !== null && event.seq !== seq)
+        throw new LogDamage(`${file}: event seq ${event.seq} where ${seq} was expected`);
+      seq = event.seq + 1;
+      events.push(event);
+      lastStart = from + start;
+    }
+    start = newline + 1;
+  }
+  return { events, end: from + start, lastStart, size };
+}
+var fsyncDirectory = (dir) => {
+  try {
+    const fd = fs6.openSync(dir, "r");
     try {
-      const pkg = JSON.parse(fs5.readFileSync(path4.join(packageRoot(), "package.json"), "utf8"));
-      cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
-    } catch {
-      cachedRuntimeVersion = "0.0.0";
+      fs6.fsyncSync(fd);
+    } finally {
+      fs6.closeSync(fd);
     }
+  } catch (error) {
+    if (process.platform !== "win32")
+      throw error;
   }
-  return cachedRuntimeVersion;
 };
-var stampNew = (record) => ({
-  createdWith: record.runtime?.createdWith ?? null,
-  updatedWith: runtimeVersion()
-});
-var isNewerVersion = (candidate, current) => {
-  const parts = (value) => value.split("-")[0].split(".").map((item) => Number.parseInt(item, 10) || 0);
-  const [candidateParts, currentParts] = [parts(candidate), parts(current)];
-  for (let index = 0;index < 3; index += 1) {
-    const left = candidateParts[index] ?? 0;
-    const right = currentParts[index] ?? 0;
-    if (left !== right)
-      return left > right;
+function appendEvent(file, event, validEnd) {
+  const line = Buffer.from(`${JSON.stringify(event)}
+`, "utf8");
+  const created = !fs6.existsSync(file);
+  if (!created && fs6.statSync(file).size !== validEnd) {
+    const cut = fs6.openSync(file, "r+");
+    try {
+      fs6.ftruncateSync(cut, validEnd);
+      fs6.fsyncSync(cut);
+    } finally {
+      fs6.closeSync(cut);
+    }
   }
-  return false;
-};
-var jsonBytes = (value) => `${canonicalJson(value)}
-`;
-var digestBytes = (value) => createHash2("sha256").update(value).digest("hex");
-var isObject2 = (value) => typeof value === "object" && value !== null;
-var validId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
-var validDigest = (value) => /^[0-9a-f]{64}$/.test(value);
-var sameDirectoryIdentity = (left, right) => {
-  if (!path4.isAbsolute(left) || !path4.isAbsolute(right))
-    return false;
-  const normalizedLeft = path4.resolve(left);
-  const normalizedRight = path4.resolve(right);
+  const fd = fs6.openSync(file, "a", 384);
   try {
-    const a = fs5.statSync(normalizedLeft, { bigint: true });
-    const b = fs5.statSync(normalizedRight, { bigint: true });
-    if (!a.isDirectory() || !b.isDirectory())
-      return false;
-    if (process.platform === "win32" ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase() : normalizedLeft === normalizedRight)
-      return true;
-    const canonicalLeft = fs5.realpathSync(normalizedLeft);
-    const canonicalRight = fs5.realpathSync(normalizedRight);
-    if (process.platform === "win32" ? canonicalLeft.toLowerCase() === canonicalRight.toLowerCase() : canonicalLeft === canonicalRight)
-      return true;
-    return a.dev === b.dev && a.ino !== 0n && a.ino === b.ino;
-  } catch {
-    return false;
+    let written = 0;
+    while (written < line.length)
+      written += fs6.writeSync(fd, line, written, line.length - written);
+    fs6.fsyncSync(fd);
+  } finally {
+    fs6.closeSync(fd);
   }
-};
+  if (created)
+    fsyncDirectory(path5.dirname(file));
+  return validEnd;
+}
+function replaceFile(file, bytes, durable) {
+  const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+  try {
+    const fd = fs6.openSync(temporary, "wx", 384);
+    try {
+      fs6.writeSync(fd, bytes);
+      if (durable)
+        fs6.fsyncSync(fd);
+    } finally {
+      fs6.closeSync(fd);
+    }
+    renameWithRetry(temporary, file);
+    if (durable)
+      fsyncDirectory(path5.dirname(file));
+  } catch (error) {
+    try {
+      fs6.unlinkSync(temporary);
+    } catch {}
+    throw error;
+  }
+}
 var TRANSIENT_WINDOWS_CODES = new Set(["EPERM", "EACCES", "EBUSY"]);
 var isTransientWindowsError = (error) => {
   if (process.platform !== "win32")
@@ -18752,138 +19061,596 @@ var retryTransient = (run) => {
     }
   }
 };
+var renameWithRetry = (from, to) => retryTransient(() => fs6.renameSync(from, to));
+
+// packages/workit-core/src/store/patch.ts
+var isPlainObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var equal = (left, right) => {
+  if (left === right)
+    return true;
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null)
+    return false;
+  if (Array.isArray(left) !== Array.isArray(right))
+    return false;
+  if (Array.isArray(left)) {
+    const other = right;
+    return left.length === other.length && left.every((item, index) => equal(item, other[index]));
+  }
+  const leftKeys = Object.keys(left).filter((key) => left[key] !== undefined);
+  const rightKeys = Object.keys(right).filter((key) => right[key] !== undefined);
+  return leftKeys.length === rightKeys.length && leftKeys.every((key) => equal(left[key], right[key]));
+};
+function diff(before, after, path = []) {
+  if (equal(before, after))
+    return [];
+  if (isPlainObject3(before) && isPlainObject3(after)) {
+    const ops = [];
+    for (const key of Object.keys(before))
+      if (before[key] !== undefined && after[key] === undefined)
+        ops.push({ op: "del", path: [...path, key] });
+    for (const key of Object.keys(after)) {
+      if (after[key] === undefined)
+        continue;
+      if (before[key] === undefined)
+        ops.push({ op: "set", path: [...path, key], value: after[key] });
+      else
+        ops.push(...diff(before[key], after[key], [...path, key]));
+    }
+    return ops;
+  }
+  if (Array.isArray(before) && Array.isArray(after)) {
+    const ops = [];
+    if (after.length < before.length)
+      ops.push({ op: "cut", path, length: after.length });
+    const shared = Math.min(before.length, after.length);
+    let changed = 0;
+    for (let index = 0;index < shared; index += 1)
+      if (!equal(before[index], after[index]))
+        changed += 1;
+    if (shared > 0 && changed > shared / 2 && changed > 4)
+      return [{ op: "set", path, value: after }];
+    for (let index = 0;index < shared; index += 1)
+      ops.push(...diff(before[index], after[index], [...path, index]));
+    if (after.length > before.length)
+      ops.push({ op: "push", path, values: after.slice(before.length) });
+    return ops;
+  }
+  return [{ op: "set", path, value: after }];
+}
+var clone2 = (value) => structuredClone(value);
+function apply(target, ops) {
+  let root = target;
+  for (const op of ops) {
+    if (op.path.length === 0) {
+      if (op.op === "set")
+        root = clone2(op.value);
+      else if (op.op === "push" && Array.isArray(root))
+        root.push(...clone2(op.values));
+      else if (op.op === "cut" && Array.isArray(root))
+        root.length = op.length;
+      else
+        throw new Error(`patch: ${op.op} at the root is invalid`);
+      continue;
+    }
+    let parent = root;
+    for (const key of op.path.slice(0, -1)) {
+      if (typeof parent !== "object" || parent === null)
+        throw new Error(`patch: missing path ${op.path.join(".")}`);
+      parent = parent[key];
+    }
+    if (typeof parent !== "object" || parent === null)
+      throw new Error(`patch: missing path ${op.path.join(".")}`);
+    const key = op.path.at(-1);
+    const container = parent;
+    if (op.op === "set")
+      container[key] = clone2(op.value);
+    else if (op.op === "del")
+      delete container[key];
+    else {
+      const array = container[key];
+      if (!Array.isArray(array))
+        throw new Error(`patch: ${op.path.join(".")} is not an array`);
+      if (op.op === "push")
+        array.push(...clone2(op.values));
+      else
+        array.length = op.length;
+    }
+  }
+  return root;
+}
+var isPath = (value) => Array.isArray(value) && value.every((key) => typeof key === "string" || typeof key === "number" && Number.isInteger(key) && key >= 0);
+var isPatch = (value) => Array.isArray(value) && value.every((op) => {
+  if (!isPlainObject3(op) || !isPath(op.path))
+    return false;
+  if (op.op === "set")
+    return "value" in op;
+  if (op.op === "del")
+    return op.path.length > 0;
+  if (op.op === "push")
+    return Array.isArray(op.values);
+  if (op.op === "cut")
+    return typeof op.length === "number" && Number.isInteger(op.length) && op.length >= 0;
+  return false;
+});
+
+// packages/workit-core/src/store/reduce.ts
+import { createHash as createHash3 } from "node:crypto";
+var OPENING_TYPES = new Set([
+  "task.opened",
+  "task.imported",
+  "migrated.from_v2",
+  "task.checkpoint"
+]);
+var KNOWN_TYPES = new Set([
+  ...OPENING_TYPES,
+  "task.bound",
+  "task.noted",
+  "task.revised",
+  "task.judged",
+  "task.paused",
+  "task.resumed",
+  "task.closed",
+  "task.updated",
+  "check.ran",
+  "evidence.recorded",
+  "finding.recorded",
+  "finding.updated",
+  "decision.recorded",
+  "decision.updated",
+  "worker.updated"
+]);
+var isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isKey = (value) => isObject3(value) && typeof value.key === "string" && (value.kind === "branch" || value.kind === "detached" || value.kind === "dir") && (value.branch === null || typeof value.branch === "string");
+var BLOB_REF = "$blob";
+var blobRef = (value) => isObject3(value) && Object.keys(value).length === 1 && typeof value[BLOB_REF] === "string" && /^[0-9a-f]{64}$/.test(value[BLOB_REF]) ? value[BLOB_REF] : null;
+var blobDigest = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
+var toBlob = (value, blobs) => {
+  if (!isObject3(value))
+    return value;
+  const digest = blobDigest(value);
+  blobs.write(digest, value);
+  return { [BLOB_REF]: digest };
+};
+var encodeRecord = (record, blobs) => Array.isArray(record.candidates) ? { ...record, candidates: record.candidates.map((item) => toBlob(item, blobs)) } : record;
+var encodeOps = (ops, blobs) => ops.map((op) => {
+  if (op.path[0] !== "candidates")
+    return op;
+  if (op.op === "push" && op.path.length === 1)
+    return { ...op, values: op.values.map((item) => toBlob(item, blobs)) };
+  if (op.op === "set" && op.path.length === 1 && Array.isArray(op.value))
+    return { ...op, value: op.value.map((item) => toBlob(item, blobs)) };
+  if (op.op === "set" && op.path.length === 2)
+    return { ...op, value: toBlob(op.value, blobs) };
+  return op;
+});
+var decode3 = (value, blobs) => {
+  const digest = blobRef(value);
+  if (digest)
+    return blobs.read(digest);
+  if (Array.isArray(value))
+    return value.map((item) => decode3(item, blobs));
+  if (isObject3(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value))
+      out[key] = decode3(item, blobs);
+    return out;
+  }
+  return value;
+};
+function reduce(state, event, blobs) {
+  const data = event.data;
+  const known = KNOWN_TYPES.has(event.type);
+  const carries = "record" in data || "ops" in data || "key" in data;
+  if (!known && !carries) {
+    if (event.critical === true)
+      throw new LogDamage(`event ${event.type} was written by a newer Workit and must be understood; upgrade Workit to read this task`, true);
+    return state;
+  }
+  let next = state;
+  if ("record" in data) {
+    if (!isObject3(data.record))
+      throw new LogDamage(`event ${event.seq} carries a malformed record`);
+    next = {
+      record: decode3(data.record, blobs),
+      key: null,
+      legacy: null
+    };
+  } else if (next === null) {
+    throw new LogDamage(`the log does not start with an opening event (found ${event.type})`);
+  } else
+    next = { ...next };
+  if ("ops" in data) {
+    if (!isPatch(data.ops))
+      throw new LogDamage(`event ${event.seq} carries a malformed patch`);
+    try {
+      next.record = apply(next.record, decode3(data.ops, blobs));
+    } catch (error) {
+      throw new LogDamage(`event ${event.seq} does not apply: ${String(error)}`);
+    }
+  }
+  if ("key" in data)
+    next.key = isKey(data.key) ? data.key : null;
+  if ("legacy" in data && isObject3(data.legacy))
+    next.legacy = {
+      path: String(data.legacy.path ?? ""),
+      digest: String(data.legacy.digest ?? "")
+    };
+  return next;
+}
+function eventType(before, after) {
+  const count = (value) => Array.isArray(value) ? value.length : 0;
+  if (before.status !== after.status)
+    return after.status === "closed" ? "task.closed" : after.status === "paused" ? "task.paused" : "task.resumed";
+  if (count(after.evidence) > count(before.evidence)) {
+    const last = after.evidence.at(-1);
+    return last?.data?.observation ? "check.ran" : "evidence.recorded";
+  }
+  if (count(after.findings) > count(before.findings))
+    return "finding.recorded";
+  if (count(after.decisions) > count(before.decisions))
+    return "decision.recorded";
+  if (JSON.stringify(before.findings) !== JSON.stringify(after.findings))
+    return "finding.updated";
+  if (JSON.stringify(before.decisions) !== JSON.stringify(after.decisions))
+    return "decision.updated";
+  if (JSON.stringify(before.workers) !== JSON.stringify(after.workers))
+    return "worker.updated";
+  if (JSON.stringify(before.intent) !== JSON.stringify(after.intent))
+    return "task.revised";
+  if (JSON.stringify(before.assessments) !== JSON.stringify(after.assessments) || JSON.stringify(before.policy) !== JSON.stringify(after.policy))
+    return "task.judged";
+  if (JSON.stringify(before.progress) !== JSON.stringify(after.progress))
+    return "task.noted";
+  return "task.updated";
+}
+
+// packages/workit-core/src/store/notes.ts
+var SLOT = Symbol.for("workit.migrationReporter");
+var reportMigration = (report) => {
+  try {
+    const reporter = globalThis[SLOT];
+    if (typeof reporter === "function")
+      reporter(report);
+  } catch {}
+};
+var migrationReporterInstalled = () => typeof globalThis[SLOT] === "function";
+
+// packages/workit-core/src/core/task-store.ts
+var MIGRATION_PENDING = "workit migration pending";
+var STORE_FORMAT = 3;
+var STORE_MIN_RUNTIME = "3.0.0";
+var SNAPSHOT_EVERY = 32;
+var COMPACT_ABOVE = 200;
+var COMPACT_KEEP = 50;
+var AUTO_COMPACT_BYTES = 2 * 1024 * 1024;
+var TOMBSTONE = Symbol("tombstone");
+var STALE_TEMPORARY_MS = 60 * 60000;
+var INDEX_VERSION = 3;
+var isObject4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var hostSession = (value) => isObject4(value) && value.kind === "host" && typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
+var indexEntry = (task, key, legacy, file) => {
+  const sessions = [];
+  const intent = hostSession(task.intent.provenance.session);
+  if (intent)
+    sessions.push({ ...intent, workerId: null });
+  for (const worker of task.workers) {
+    const session = hostSession(worker.data.session);
+    if (session)
+      sessions.push({ ...session, workerId: worker.id });
+  }
+  return {
+    id: task.id,
+    revision: task.revision,
+    status: task.status,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    objective: task.intent.data.objective,
+    source: { host: task.intent.provenance.host, kind: task.intent.provenance.kind },
+    progress: { summary: task.progress.summary, nextAction: task.progress.nextAction },
+    sessions,
+    workspaceId: task.workspaceId,
+    key: key?.key ?? null,
+    branch: key?.branch ?? null,
+    boundAt: key?.boundAt ?? null,
+    legacy,
+    file
+  };
+};
+var fileSignature = (file) => {
+  try {
+    const stat = fs7.statSync(file, { bigint: true });
+    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  } catch {
+    return null;
+  }
+};
+var RACY_WINDOW_NS = 2000000000n;
+var racySignature = (signature) => {
+  const [mtime = 0n, ctime = 0n] = signature.split(":").slice(3, 5).map(BigInt);
+  const changed = mtime > ctime ? mtime : ctime;
+  return BigInt(Date.now()) * 1000000n - changed < RACY_WINDOW_NS;
+};
+var now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+var oldestFirst = (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
+var cachedRuntimeVersion = null;
+var runtimeVersion = () => {
+  if (cachedRuntimeVersion === null) {
+    try {
+      const pkg = JSON.parse(fs7.readFileSync(path6.join(packageRoot(), "package.json"), "utf8"));
+      cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
+    } catch {
+      cachedRuntimeVersion = "0.0.0";
+    }
+  }
+  return cachedRuntimeVersion;
+};
+var stampNew = (record) => ({
+  createdWith: record.runtime?.createdWith ?? null,
+  updatedWith: runtimeVersion()
+});
+var isNewerVersion = (candidate, current) => {
+  const parts = (value) => value.split("-")[0].split(".").map((item) => Number.parseInt(item, 10) || 0);
+  const [candidateParts, currentParts] = [parts(candidate), parts(current)];
+  for (let index = 0;index < 3; index += 1) {
+    const left = candidateParts[index] ?? 0;
+    const right = currentParts[index] ?? 0;
+    if (left !== right)
+      return left > right;
+  }
+  return false;
+};
+var validId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
+var sameDirectoryIdentity = (left, right) => {
+  if (!path6.isAbsolute(left) || !path6.isAbsolute(right))
+    return false;
+  const normalizedLeft = path6.resolve(left);
+  const normalizedRight = path6.resolve(right);
+  try {
+    const a = fs7.statSync(normalizedLeft, { bigint: true });
+    const b = fs7.statSync(normalizedRight, { bigint: true });
+    if (!a.isDirectory() || !b.isDirectory())
+      return false;
+    if (process.platform === "win32" ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase() : normalizedLeft === normalizedRight)
+      return true;
+    const canonicalLeft = fs7.realpathSync(normalizedLeft);
+    const canonicalRight = fs7.realpathSync(normalizedRight);
+    if (process.platform === "win32" ? canonicalLeft.toLowerCase() === canonicalRight.toLowerCase() : canonicalLeft === canonicalRight)
+      return true;
+    return a.dev === b.dev && a.ino !== 0n && a.ino === b.ino;
+  } catch {
+    return false;
+  }
+};
 var externalActionLockRoots = new AsyncLocalStorage;
 var heldInProcess = new Map;
-var holdRoot = (root) => heldInProcess.set(root, (heldInProcess.get(root) ?? 0) + 1);
-var dropRoot = (root) => {
-  const count = (heldInProcess.get(root) ?? 1) - 1;
+var hold = (lock) => heldInProcess.set(lock, (heldInProcess.get(lock) ?? 0) + 1);
+var drop = (lock) => {
+  const count = (heldInProcess.get(lock) ?? 1) - 1;
   if (count > 0)
-    heldInProcess.set(root, count);
+    heldInProcess.set(lock, count);
   else
-    heldInProcess.delete(root);
+    heldInProcess.delete(lock);
 };
-var dedupeCandidates = (candidates) => {
-  const last = new Map(candidates.map((candidate, index) => [candidate.id, index]));
-  return candidates.filter((candidate, index) => last.get(candidate.id) === index);
+var envActor = () => {
+  const value = (key) => process.env[key]?.trim() || null;
+  return {
+    host: value("WORKIT_HOST") ?? "runtime",
+    session: value("WORKIT_SESSION_ID"),
+    agentId: value("WORKIT_AGENT_ID")
+  };
 };
 
 class TaskStore {
   root;
+  origin;
   lockTimeoutMs;
+  actor;
+  migrateOnRead;
+  located;
+  migrationChecked = false;
+  compactDue = new Set;
   constructor(root, options = {}) {
-    this.root = fs5.existsSync(root) ? fs5.realpathSync(root) : path4.resolve(root);
+    const resolved = path6.resolve(root);
+    this.origin = fs7.existsSync(resolved) ? fs7.realpathSync(resolved) : resolved;
+    this.located = resolveStore(this.origin);
+    this.root = checkoutRootOf(this.origin, this.located);
     this.lockTimeoutMs = options.lockTimeoutMs ?? defaultLockTimeout();
+    this.actor = options.actor ?? envActor();
+    this.migrateOnRead = options.migrateOnRead;
+  }
+  location() {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs7.existsSync(path6.join(this.root, ".git"))) {
+      this.located = undefined;
+      this.migrationChecked = false;
+    }
+    if (this.located === undefined)
+      this.located = resolveStore(this.root);
+    return this.located instanceof Error ? failure2("storage_error", this.located.message, { path: this.root }) : success(null, null, this.located);
+  }
+  currentKey() {
+    const location = this.location();
+    if (!location.ok)
+      return location;
+    return success(null, null, resolveTaskKey(this.root, location.data));
   }
   readTask(taskId) {
     if (!validId(taskId))
       return failure2("invalid_input", "task ID is invalid", { taskId });
-    const result = this.readRecord(path4.join(this.tasksDir, `${taskId}.json`), taskRecordSchema);
-    if (!result.exists)
+    const ready = this.ready();
+    if (!ready.ok)
+      return ready;
+    const loaded = this.load(taskId);
+    if (!loaded.ok)
+      return loaded;
+    if (!loaded.data)
       return failure2("not_found", "task not found", { taskId });
-    if (result.result.ok && result.result.data.id !== taskId)
-      return failure2("recovery_required", "task filename and record ID differ", { taskId });
-    if (result.result.ok) {
-      const workspace = this.readWorkspace();
-      if (!workspace.ok)
-        return workspace;
-      if (!workspace.data || result.result.data.workspaceId !== workspace.data.id)
-        return failure2("recovery_required", "task workspace binding is invalid", { taskId });
-    }
-    return result.result;
-  }
-  listTasks() {
-    if (!fs5.existsSync(this.tasksDir))
-      return success(null, null, []);
-    let names;
-    try {
-      names = fs5.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
-    } catch (error) {
-      return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
-        path: this.tasksDir
-      });
-    }
     const workspace = this.readWorkspace();
     if (!workspace.ok)
       return workspace;
-    if (!workspace.data)
-      return failure2("recovery_required", "task workspace binding is invalid", {
-        path: this.workspacePath
-      });
+    const bound = this.bindingError(loaded.data.record, workspace.data);
+    return bound ?? success(null, null, loaded.data.record);
+  }
+  listTasks() {
+    const listed = this.listTaskIndex();
+    if (!listed.ok)
+      return listed;
     const tasks = [];
-    for (const name of names.toSorted()) {
-      const item = this.readRecord(path4.join(this.tasksDir, name), taskRecordSchema);
-      if (!item.exists)
-        continue;
-      if (!item.result.ok)
-        return item.result;
-      if (!validId(name.slice(0, -5)) || item.result.data.id !== name.slice(0, -5))
-        return failure2("recovery_required", "task filename and record ID differ", { path: name });
-      if (item.result.data.workspaceId !== workspace.data.id)
-        return failure2("recovery_required", "task workspace binding is invalid", { path: name });
-      tasks.push(item.result.data);
+    for (const entry of listed.data.toSorted((left, right) => left.id.localeCompare(right.id))) {
+      const loaded = this.load(entry.id);
+      if (!loaded.ok)
+        return loaded;
+      if (loaded.data)
+        tasks.push(loaded.data.record);
     }
     return success(null, null, tasks);
   }
   listTaskIndex() {
-    if (!fs5.existsSync(this.tasksDir))
+    const all = this.listStoreIndex();
+    if (!all.ok)
+      return all;
+    const workspace = this.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    if (!workspace.data)
       return success(null, null, []);
+    const id = workspace.data.id;
+    return success(null, null, all.data.filter((entry) => entry.workspaceId === id));
+  }
+  listStoreIndex() {
+    const ready = this.ready();
+    if (!ready.ok)
+      return ready;
+    const tasksDir = this.paths().tasks;
     let names;
     try {
-      names = fs5.readdirSync(this.tasksDir).filter((name) => name.endsWith(".json"));
+      names = fs7.existsSync(tasksDir) ? fs7.readdirSync(tasksDir).filter((name) => validId(name)) : [];
     } catch (error) {
       return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
-        path: this.tasksDir
+        path: tasksDir
       });
     }
-    const workspace = this.readWorkspace();
-    if (!workspace.ok)
-      return workspace;
-    if (!workspace.data)
-      return failure2("recovery_required", "task workspace binding is invalid", {
-        path: this.workspacePath
-      });
-    const stored = this.readIndex(workspace.data.id);
+    const stored = this.readIndex();
     const entries = [];
     let changed = Object.keys(stored).length !== names.length;
     for (const name of names.toSorted()) {
-      const file = path4.join(this.tasksDir, name);
-      const signature = fileSignature(file);
+      const signature = fileSignature(this.eventsPath(name));
       if (signature === null) {
         changed = true;
         continue;
       }
-      const cached = stored[name.slice(0, -5)];
+      const cached = stored[name];
       if (cached && cached.file === signature && !racySignature(signature)) {
         entries.push(cached);
         continue;
       }
-      const item = this.readRecord(file, taskRecordSchema);
-      if (!item.exists)
+      const loaded = this.load(name);
+      if (!loaded.ok)
+        return loaded;
+      if (!loaded.data)
         continue;
-      if (!item.result.ok)
-        return item.result;
-      if (!validId(name.slice(0, -5)) || item.result.data.id !== name.slice(0, -5))
-        return failure2("recovery_required", "task filename and record ID differ", { path: name });
-      if (item.result.data.workspaceId !== workspace.data.id)
-        return failure2("recovery_required", "task workspace binding is invalid", { path: name });
-      const entry = indexEntry(item.result.data, signature);
+      const entry = indexEntry(loaded.data.record, loaded.data.key, loaded.data.legacy !== null, signature);
       if (!cached || canonicalJson(cached) !== canonicalJson(entry))
         changed = true;
       entries.push(entry);
     }
     if (changed)
-      this.writeIndex(workspace.data.id, entries);
+      this.writeIndex(entries);
     return success(null, null, entries);
   }
   readWorkspace() {
-    const item = this.readRecord(this.workspacePath, workspaceRecordSchema);
-    if (!item.exists)
-      return success(null, null, null);
-    if (item.result.ok && item.result.data.root !== this.root && !sameDirectoryIdentity(item.result.data.root, this.root))
-      return failure2("recovery_required", "workspace root binding is invalid", {
-        path: this.workspacePath
+    const ready = this.ready();
+    if (!ready.ok)
+      return ready;
+    const file = this.paths().workspace;
+    let bytes;
+    try {
+      bytes = retryTransient(() => fs7.readFileSync(file, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return success(null, null, null);
+      return failure2("recovery_required", `workspace record cannot be read: ${String(error)}`, {
+        path: file
       });
-    return item.result;
+    }
+    const parsed = this.parseRecord(bytes, workspaceRecordSchema, "workspace");
+    if (!parsed.ok)
+      return parsed;
+    if (parsed.data.root !== this.root && !sameDirectoryIdentity(parsed.data.root, this.root))
+      return failure2("recovery_required", "workspace root binding is invalid", { path: file });
+    return parsed;
+  }
+  implicitTask(input) {
+    const ready = this.ready(input.create !== false);
+    if (!ready.ok)
+      return ready;
+    const key = this.currentKey();
+    if (!key.ok)
+      return key;
+    const found = this.openTaskForKey(key.data.key);
+    if (!found.ok)
+      return found;
+    const workspace = this.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    if (found.data && workspace.data && found.data.workspaceId === workspace.data.id && (found.data.key === key.data.key || input.create === false)) {
+      const task = this.readTask(found.data.id);
+      return task.ok ? success(task.revision, null, { task: task.data, created: false, key: key.data }) : task;
+    }
+    if (input.create === false) {
+      if (!found.data)
+        return success(null, null, null);
+      const loaded = this.load(found.data.id);
+      if (!loaded.ok)
+        return loaded;
+      return loaded.data ? success(null, null, { task: loaded.data.record, created: false, key: key.data }) : success(null, null, null);
+    }
+    return this.withLock(this.paths().checkoutLock, () => this.withKeyLock(key.data.key, () => this.implicitLocked(input, key.data)));
+  }
+  implicitLocked(input, key) {
+    {
+      const again = this.openTaskForKey(key.key);
+      if (!again.ok)
+        return again;
+      if (again.data) {
+        const moved = this.bindLocked(again.data.id, key, input.now);
+        return moved.ok ? success(moved.data.revision, null, { task: moved.data, created: false, key }) : moved;
+      }
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path6.basename(this.root) || this.root;
+      const intent = {
+        objective: input.objective?.trim() || `Work on ${label}`,
+        scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
+        authorityRefs: []
+      };
+      const created = this.createLocked({ intent, provenance: input.provenance, expectedWorkspaceRevision: null, now: input.now }, false, key, false);
+      return created.ok ? success(created.data.revision, null, { task: created.data, created: true, key }) : created;
+    }
+  }
+  adoptTask(taskId) {
+    if (!validId(taskId))
+      return failure2("invalid_input", "task ID is invalid", { taskId });
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    const key = this.currentKey();
+    if (!key.ok)
+      return key;
+    return this.withLock(this.paths().checkoutLock, () => this.withKeyLock(key.data.key, () => {
+      const holder = this.openTaskForKey(key.data.key);
+      if (!holder.ok)
+        return holder;
+      if (holder.data && holder.data.id !== taskId)
+        return failure2("invalid_transition", `${key.data.key} already has open task ${holder.data.id}; close it (\`workit task close\`) before adopting another`, { taskId: holder.data.id });
+      return this.bindLocked(taskId, key.data);
+    }));
+  }
+  keyReport() {
+    const key = this.currentKey();
+    if (!key.ok)
+      return key;
+    const bound = this.openTasksForKey(key.data.key);
+    if (!bound.ok)
+      return bound;
+    return success(null, null, { key: key.data, bound: bound.data });
   }
   create(input, provenance, expectedWorkspaceRevision) {
     const value = "intent" in input ? input : {
@@ -18891,82 +19658,16 @@ class TaskStore {
       provenance,
       expectedWorkspaceRevision: expectedWorkspaceRevision ?? null
     };
-    return this.withLock(() => {
-      const current = this.readWorkspace();
-      if (!current.ok)
-        return current;
-      if (current.data ? value.expectedWorkspaceRevision !== current.data.revision : value.expectedWorkspaceRevision !== null) {
-        return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", {
-          expectedWorkspaceRevision: value.expectedWorkspaceRevision,
-          actualWorkspaceRevision: current.data?.revision ?? null
-        });
-      }
-      if (!value.provenance)
-        return failure2("invalid_input", "provenance is required");
-      if (!intentSchema.safeParse(value.intent).success || !provenanceSchema.safeParse(value.provenance).success)
-        return failure2("invalid_input", "task intent or provenance is invalid");
-      const previousWorkspaceBytes = current.data ? this.snapshotBytes(this.workspacePath) : null;
-      if (current.data && !previousWorkspaceBytes)
-        return failure2("storage_error", "workspace snapshot disappeared during creation");
-      const workspace = current.data ? {
-        ...current.data,
-        revision: newRevision(),
-        root: this.root,
-        runtime: stampNew(current.data)
-      } : {
-        schemaVersion: SCHEMA_VERSION,
-        id: newId(),
-        revision: newRevision(),
-        root: this.root,
-        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
-        writer: null
-      };
-      const timestamp = value.now ?? now();
-      const task = {
-        schemaVersion: SCHEMA_VERSION,
-        id: newId(),
-        workspaceId: workspace.id,
-        revision: newRevision(),
-        createdAt: timestamp,
-        updatedAt: timestamp,
-        origin: null,
-        intent: {
-          id: newId(),
-          recordedAt: timestamp,
-          provenance: value.provenance,
-          data: value.intent
-        },
-        constraints: [],
-        status: "active",
-        closure: null,
-        progress: { summary: "", nextAction: null, blockers: [] },
-        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
-        assessments: [],
-        policy: null,
-        policyChanges: [],
-        candidates: [],
-        evidence: [],
-        decisions: [],
-        findings: [],
-        workers: []
-      };
-      const writtenWorkspace = this.replaceSnapshot(this.workspacePath, workspace, previousWorkspaceBytes);
-      if (!writtenWorkspace.ok)
-        return writtenWorkspace;
-      const writtenTask = this.replaceSnapshot(this.taskPath(task.id), task, null);
-      if (!writtenTask.ok) {
-        if (current.data && previousWorkspaceBytes) {
-          const restored = this.replaceSnapshot(this.workspacePath, current.data, this.snapshotBytes(this.workspacePath));
-          if (!restored.ok)
-            return failure2("external_outcome_unknown", "task creation failed and workspace restoration is uncertain", { operation: "create", outcome: "unknown" });
-        }
-        return failure2("external_outcome_unknown", "workspace created but task write is uncertain", { operation: "create", outcome: "unknown" });
-      }
-      return success(task.revision, workspace.revision, task);
-    });
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    return this.withLock(this.paths().checkoutLock, () => this.createLocked(value, true, null));
   }
   importTask(input) {
-    return this.withLock(() => {
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    return this.withLock(this.paths().checkoutLock, () => {
       const current = this.readWorkspace();
       if (!current.ok)
         return current;
@@ -18998,23 +19699,8 @@ class TaskStore {
           expectedWorkspaceRevision: input.expectedWorkspaceRevision,
           actualWorkspaceRevision: current.data?.revision ?? null
         });
-      const previousWorkspaceBytes = current.data ? this.snapshotBytes(this.workspacePath) : null;
-      if (current.data && !previousWorkspaceBytes)
-        return failure2("storage_error", "workspace snapshot disappeared during import");
       const timestamp = input.now ?? now();
-      const workspace = current.data ? {
-        ...current.data,
-        revision: newRevision(),
-        root: this.root,
-        runtime: stampNew(current.data)
-      } : {
-        schemaVersion: SCHEMA_VERSION,
-        id: input.workspaceId ?? newId(),
-        revision: newRevision(),
-        root: this.root,
-        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
-        writer: null
-      };
+      const workspace = this.nextWorkspace(current.data, input.workspaceId);
       const task = {
         ...input.task,
         workspaceId: workspace.id,
@@ -19029,62 +19715,46 @@ class TaskStore {
       const validTask = taskRecordSchema.safeParse(task);
       if (!validTask.success)
         return failure2("invalid_input", "imported task does not satisfy its schema");
-      const writtenWorkspace = this.replaceSnapshot(this.workspacePath, workspace, previousWorkspaceBytes);
-      if (!writtenWorkspace.ok)
-        return writtenWorkspace;
-      const writtenTask = this.replaceSnapshot(this.taskPath(task.id), validTask.data, null);
-      if (!writtenTask.ok) {
-        if (current.data && previousWorkspaceBytes) {
-          const restored = this.replaceSnapshot(this.workspacePath, current.data, this.snapshotBytes(this.workspacePath));
-          if (!restored.ok)
-            return failure2("external_outcome_unknown", "import failed and workspace restoration is uncertain", { operation: "import", outcome: "unknown" });
-        }
-        return failure2("external_outcome_unknown", `workspace created but task import is uncertain: ${writtenTask.error}`, {
-          operation: "import",
-          outcome: "unknown",
-          path: writtenTask.details.path
-        });
-      }
-      return success(validTask.data.revision, workspace.revision, validTask.data);
+      return this.writeNewTask(current.data, workspace, validTask.data, "task.imported", null, {
+        operation: "import"
+      });
     });
   }
   mutateTask(taskId, expected, update, timestamp) {
-    return this.withLock(() => {
-      const current = this.readTask(taskId);
-      if (!current.ok)
-        return current;
-      if (current.data.revision !== expected)
-        return this.conflict(expected, current.data.revision);
-      const previousBytes = this.snapshotBytes(this.taskPath(taskId));
-      if (!previousBytes)
-        return failure2("storage_error", "task snapshot disappeared during mutation");
+    if (!validId(taskId))
+      return failure2("invalid_input", "task ID is invalid", { taskId });
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    const result = this.withLock(this.taskLockPath(taskId), () => {
+      const loaded = this.loadBound(taskId);
+      if (!loaded.ok)
+        return loaded;
+      if (loaded.data.record.revision !== expected)
+        return this.conflict(expected, loaded.data.record.revision);
       const context = { now: timestamp ?? now(), revision: newRevision() };
       let changed;
       try {
-        changed = update(current.data, Object.freeze({ ...context }));
+        changed = update(structuredClone(loaded.data.record), Object.freeze({ ...context }));
       } catch (error) {
         return failure2("storage_error", `task mutation failed: ${String(error)}`);
       }
       if (!changed.ok)
         return changed;
-      const record = {
-        ...changed.data,
-        id: taskId,
-        workspaceId: current.data.workspaceId,
-        createdAt: current.data.createdAt,
-        revision: context.revision,
-        updatedAt: context.now,
-        runtime: stampNew(current.data)
-      };
-      const valid = taskRecordSchema.safeParse(record);
-      if (!valid.success)
+      const valid = this.nextTask(loaded.data.record, changed.data, context);
+      if (!valid)
         return failure2("invalid_input", "task mutation produced an invalid record");
-      const written = this.replaceSnapshot(this.taskPath(taskId), valid.data, previousBytes);
-      return written.ok ? success(valid.data.revision, null, valid.data) : written;
+      const written = this.appendPatch(loaded.data, valid);
+      return written.ok ? success(valid.revision, null, valid) : written;
     });
+    this.compactPending();
+    return result;
   }
   mutateWorkspace(expected, update) {
-    return this.withLock(() => {
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    return this.withLock(this.paths().checkoutLock, () => {
       const current = this.readWorkspace();
       if (!current.ok)
         return current;
@@ -19092,9 +19762,6 @@ class TaskStore {
         return failure2("not_found", "workspace not found");
       if (current.data.revision !== expected)
         return this.workspaceConflict(expected, current.data.revision);
-      const previousBytes = this.snapshotBytes(this.workspacePath);
-      if (!previousBytes)
-        return failure2("storage_error", "workspace snapshot disappeared during mutation");
       const context = { now: now(), revision: newRevision() };
       let changed;
       try {
@@ -19104,23 +19771,27 @@ class TaskStore {
       }
       if (!changed.ok)
         return changed;
-      const record = {
+      const valid = workspaceRecordSchema.safeParse({
         ...changed.data,
         id: current.data.id,
         root: this.root,
         revision: context.revision,
         runtime: stampNew(current.data)
-      };
-      const valid = workspaceRecordSchema.safeParse(record);
+      });
       if (!valid.success)
         return failure2("invalid_input", "workspace mutation produced an invalid record");
-      const written = this.replaceSnapshot(this.workspacePath, valid.data, previousBytes);
+      const written = this.writeWorkspace(valid.data);
       return written.ok ? success(valid.data.revision, valid.data.revision, valid.data) : written;
     });
   }
   mutateTaskAndWorkspace(input) {
-    return this.withLock(() => {
-      const task = this.readTask(input.taskId);
+    if (!validId(input.taskId))
+      return failure2("invalid_input", "task ID is invalid", { taskId: input.taskId });
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    const result = this.withLock(this.paths().checkoutLock, () => this.withLock(this.taskLockPath(input.taskId), () => {
+      const task = this.loadBound(input.taskId);
       if (!task.ok)
         return task;
       const workspace = this.readWorkspace();
@@ -19131,14 +19802,10 @@ class TaskStore {
       const expected = input.expectedRevision;
       if (!expected)
         return failure2("invalid_input", "task revision is required");
-      if (task.data.revision !== expected)
-        return this.conflict(expected, task.data.revision);
+      if (task.data.record.revision !== expected)
+        return this.conflict(expected, task.data.record.revision);
       if (workspace.data.revision !== input.expectedWorkspaceRevision)
         return this.workspaceConflict(input.expectedWorkspaceRevision, workspace.data.revision);
-      const previousWorkspaceBytes = this.snapshotBytes(this.workspacePath);
-      const previousTaskBytes = this.snapshotBytes(this.taskPath(input.taskId));
-      if (!previousWorkspaceBytes || !previousTaskBytes)
-        return failure2("storage_error", "snapshot disappeared during coupled mutation");
       const workspaceContext = { now: input.now ?? now(), revision: newRevision() };
       let changedWorkspace;
       try {
@@ -19157,286 +19824,69 @@ class TaskStore {
       });
       if (!nextWorkspace.success)
         return failure2("invalid_input", "workspace mutation produced an invalid record");
-      const reserved = this.replaceSnapshot(this.workspacePath, nextWorkspace.data, previousWorkspaceBytes);
+      const reserved = this.writeWorkspace(nextWorkspace.data);
       if (!reserved.ok)
         return reserved;
+      const uncertain = (message) => {
+        this.markUncertain(nextWorkspace.data);
+        return failure2("external_outcome_unknown", message, {
+          operation: "coupled_mutation",
+          outcome: "unknown"
+        });
+      };
       const taskContext = { now: input.now ?? now(), revision: newRevision() };
       let changedTask;
       try {
-        changedTask = input.task(task.data, Object.freeze({ ...taskContext }));
+        changedTask = input.task(structuredClone(task.data.record), Object.freeze({ ...taskContext }));
       } catch (error) {
-        this.markUncertain(nextWorkspace.data);
-        return failure2("external_outcome_unknown", `workspace reserved but task mutation threw: ${String(error)}`, { operation: "coupled_mutation", outcome: "unknown" });
-      }
-      if (!changedTask.ok) {
-        this.markUncertain(nextWorkspace.data);
-        return failure2("external_outcome_unknown", "workspace reserved but task update is uncertain", { operation: "coupled_mutation", outcome: "unknown" });
-      }
-      const nextTask = taskRecordSchema.safeParse({
-        ...changedTask.data,
-        id: input.taskId,
-        workspaceId: task.data.workspaceId,
-        createdAt: task.data.createdAt,
-        revision: taskContext.revision,
-        updatedAt: taskContext.now,
-        runtime: stampNew(task.data)
+        return uncertain(`workspace reserved but task mutation threw: ${String(error)}`);
+      }
+      if (!changedTask.ok)
+        return uncertain("workspace reserved but task update is uncertain");
+      const nextTask = this.nextTask(task.data.record, changedTask.data, taskContext);
+      if (!nextTask)
+        return uncertain("workspace reserved but task update is uncertain");
+      const written = this.appendPatch(task.data, nextTask);
+      if (!written.ok)
+        return uncertain("workspace reserved but task append is uncertain");
+      return success(nextTask.revision, nextWorkspace.data.revision, {
+        task: nextTask,
+        workspace: nextWorkspace.data
       });
-      if (!nextTask.success) {
-        this.markUncertain(nextWorkspace.data);
-        return failure2("external_outcome_unknown", "workspace reserved but task update is uncertain", { operation: "coupled_mutation", outcome: "unknown" });
-      }
-      const written = this.replaceSnapshot(this.taskPath(input.taskId), nextTask.data, previousTaskBytes);
-      if (!written.ok) {
-        this.markUncertain(nextWorkspace.data);
-        return failure2("external_outcome_unknown", "workspace reserved but task replacement is uncertain", { operation: "coupled_mutation", outcome: "unknown" });
-      }
-      return success(nextTask.data.revision, nextWorkspace.data.revision, {
-        task: nextTask.data,
-        workspace: nextWorkspace.data
-      });
-    });
-  }
-  recoveryCandidates() {
-    if (!fs5.existsSync(this.recoveryDir))
-      return success(null, null, []);
-    try {
-      const candidates = [];
-      for (const name of fs5.readdirSync(this.recoveryDir)) {
-        const match = RECOVERY_NAME.exec(name);
-        if (match)
-          candidates.push({
-            target: match[1],
-            path: path4.join(this.recoveryDir, name),
-            digest: match[3]
-          });
-      }
-      return success(null, null, candidates);
-    } catch (error) {
-      return failure2("storage_error", `unable to list recovery: ${String(error)}`, {
-        path: this.recoveryDir
-      });
-    }
-  }
-  recoverTask(taskId, input) {
-    return this.recover("task", taskId, input);
-  }
-  recoverWorkspace(input) {
-    return this.recover("workspace", null, input);
-  }
-  recover(target, taskId, input) {
-    if (taskId !== null && !validId(taskId))
-      return failure2("invalid_input", "task ID is invalid", { taskId });
-    if (!input.reason || !Array.isArray(input.authorityRefs) || typeof input.processEvidence !== "function" || !validDigest(input.expectedBytes) || !validDigest(input.snapshotDigest))
-      return failure2("invalid_input", "recovery authority is invalid");
-    if (input.authorityRefs.some((ref) => !refSchema.safeParse(ref).success))
-      return failure2("invalid_input", "recovery references are invalid");
-    try {
-      const workspace = this.readWorkspace();
-      if (!workspace.ok && target === "task")
-        return workspace;
-      const workspaceValue = workspace.ok ? workspace.data : null;
-      if (workspaceValue && workspaceValue.revision !== input.expectedWorkspaceRevision)
-        return this.conflict(input.expectedWorkspaceRevision, workspaceValue.revision);
-      const file = target === "workspace" ? this.workspacePath : this.taskPath(taskId);
-      const currentBytes = this.snapshotBytes(file);
-      if (!currentBytes)
-        return failure2("not_found", "snapshot not found");
-      if (digestBytes(currentBytes) !== input.expectedBytes)
-        return failure2("revision_conflict", "snapshot bytes do not match expected bytes");
-      let selectedBytes = currentBytes;
-      if (digestBytes(currentBytes) !== input.snapshotDigest) {
-        const candidate = this.findRecovery(target, taskId, input.snapshotDigest, workspaceValue);
-        if (!candidate)
-          return failure2("recovery_required", "validated recovery snapshot not found");
-        selectedBytes = candidate;
-      }
-      const selectedRecord = target === "workspace" ? this.parseBytes(selectedBytes, workspaceRecordSchema, "rewrite") : this.parseBytes(selectedBytes, taskRecordSchema, "rewrite");
-      if (!selectedRecord.ok)
-        return selectedRecord;
-      if (target === "workspace") {
-        const parsed = selectedRecord;
-        if (!parsed.ok || parsed.data.root !== this.root)
-          return failure2("recovery_required", "workspace recovery binding is invalid");
-      } else {
-        const parsed = selectedRecord;
-        if (!parsed.ok || parsed.data.id !== taskId || !workspaceValue || parsed.data.workspaceId !== workspaceValue.id)
-          return failure2("recovery_required", "task recovery binding is invalid");
-      }
-      const lock = this.readLockSnapshot();
-      if (!lock.ok)
-        return lock;
-      const writer = target === "workspace" ? selectedRecord.data.writer : workspaceValue?.writer ?? null;
-      const evidence = this.processEvidence(input, lock.data?.data ?? null, writer);
-      if (!evidence.ok)
-        return evidence;
-      if (lock.data && (evidence.data.pid !== lock.data.data.pid || evidence.data.processStart !== lock.data.data.processStart))
-        return failure2("recovery_required", "process evidence does not match metadata lock");
-      if (writer && (evidence.data.state !== "accounted_for" || evidence.data.ownerDigest !== sha256(canonicalJson(writer))))
-        return failure2("recovery_required", "workspace writer is not accounted for");
-      const recoveryGate = { reclaimed: false };
-      const result = this.withLock((handle) => {
-        if (lock.data && !recoveryGate.reclaimed)
-          return failure2("recovery_required", "metadata lock changed during recovery", {
-            path: this.lockPath
-          });
-        if (!handle.verifyStillHeld())
-          return failure2("recovery_required", "metadata lock was compromised", {
-            path: this.lockPath
-          });
-        const reacquiredBytes = this.snapshotBytes(file);
-        if (!reacquiredBytes)
-          return failure2("recovery_required", "snapshot disappeared during recovery");
-        if (digestBytes(reacquiredBytes) !== input.expectedBytes)
-          return failure2("revision_conflict", "snapshot changed during recovery");
-        if (target === "task") {
-          const currentWorkspace = this.readWorkspace();
-          if (!currentWorkspace.ok || !currentWorkspace.data)
-            return failure2("recovery_required", "workspace changed during recovery");
-          if (currentWorkspace.data.revision !== input.expectedWorkspaceRevision)
-            return this.conflict(input.expectedWorkspaceRevision, currentWorkspace.data.revision);
-        }
-        if (target === "workspace") {
-          const parsed = this.parseBytes(selectedBytes, workspaceRecordSchema, "rewrite");
-          if (!parsed.ok)
-            return parsed;
-          const value = { ...parsed.data, revision: newRevision(), writer: null };
-          const replaced = this.replaceSnapshot(file, value, reacquiredBytes);
-          return replaced.ok ? success(value.revision, value.revision, value) : replaced;
-        }
-        const parsed = this.parseBytes(selectedBytes, taskRecordSchema, "rewrite");
-        if (!parsed.ok)
-          return parsed;
-        const value = {
-          ...parsed.data,
-          revision: newRevision(),
-          updatedAt: now(),
-          status: parsed.data.status === "active" ? "paused" : parsed.data.status
-        };
-        const replaced = this.replaceSnapshot(file, value, reacquiredBytes);
-        return replaced.ok ? success(value.revision, null, value) : replaced;
-      }, this.recoveryLockOptions(lock.data, evidence.data, recoveryGate), "recovery_required");
-      return result;
-    } catch (error) {
-      return failure2("recovery_required", `recovery protocol failed: ${String(error)}`);
-    }
-  }
-  processEvidence(input, lock, writer) {
-    const lockCopy = lock ? this.deepFreeze(structuredClone(lock)) : null;
-    const writerCopy = writer ? this.deepFreeze(structuredClone(writer)) : null;
-    const lockDigest = lockCopy ? sha256(canonicalJson(lockCopy)) : null;
-    const writerDigest = writerCopy ? sha256(canonicalJson(writerCopy)) : null;
-    try {
-      const result = input.processEvidence(lockCopy, writerCopy);
-      if (lockCopy && sha256(canonicalJson(lockCopy)) !== lockDigest)
-        return failure2("recovery_required", "process evidence mutated lock identity");
-      if (writerCopy && sha256(canonicalJson(writerCopy)) !== writerDigest)
-        return failure2("recovery_required", "process evidence mutated writer identity");
-      if (!result.ok)
-        return result;
-      const parsed = processEvidenceSchema.safeParse(result.data);
-      return parsed.success ? success(null, null, parsed.data) : failure2("recovery_required", "process evidence is invalid");
-    } catch (error) {
-      return failure2("recovery_required", `process evidence failed: ${String(error)}`);
-    }
-  }
-  deepFreeze(value) {
-    if (value && typeof value === "object") {
-      for (const child of Object.values(value))
-        this.deepFreeze(child);
-      Object.freeze(value);
-    }
-    return value;
-  }
-  readLockSnapshot() {
-    try {
-      const stat = fs5.lstatSync(this.lockPath);
-      if (!stat.isFile() || stat.isSymbolicLink())
-        return failure2("recovery_required", "metadata lock is not a regular file", {
-          path: this.lockPath
-        });
-      const raw = fs5.readFileSync(this.lockPath, "utf8");
-      return success(null, null, { raw, data: parseMetadataLock(raw) });
-    } catch (error) {
-      if (error?.code === "ENOENT")
-        return success(null, null, null);
-      return failure2("recovery_required", `metadata lock is invalid: ${String(error)}`, {
-        path: this.lockPath
-      });
-    }
-  }
-  metadataLockOptions() {
-    const inProcess = heldInProcess.has(this.root);
-    return {
-      lockPath: this.lockPath,
-      staleMs: Number.MAX_SAFE_INTEGER,
-      timeoutMs: inProcess ? 0 : this.lockTimeoutMs,
-      retry: inProcess ? { retries: 0 } : { minTimeout: 5, maxTimeout: 100, factor: 1.5, randomize: true },
-      staleRecovery: "remove-if-unchanged",
-      shouldReclaim: ({ payload, nowMs }) => {
-        let ageMs = null;
-        try {
-          ageMs = nowMs - fs5.lstatSync(this.lockPath).mtimeMs;
-        } catch {}
-        return classifyLockOwner(payload, ageMs).state === "stale";
-      },
-      shouldRemoveStaleLock: () => true,
-      parsePayload: parseMetadataLockOrNull,
-      payload: () => ({
-        pid: process.pid,
-        processStart: processStartOf(process.pid),
-        host: localLockHost(),
-        nonce: randomUUID2()
-      })
-    };
-  }
-  acquireMetadataLock(options) {
-    clearAbandonedReclaimGuard(this.lockPath);
-    const deadline = Date.now() + (options.timeoutMs ?? 0);
-    while (true) {
-      try {
-        return acquireFileLockSync(this.workspacePath, {
-          ...options,
-          timeoutMs: Math.max(0, deadline - Date.now())
-        });
-      } catch (error) {
-        const code = error?.code;
-        if (code !== "file_lock_stale" && !isTransientWindowsError(error) || Date.now() >= deadline)
-          throw error;
-        if (code !== "file_lock_stale" && !this.lockHolderPresent() && !this.lockDirWritable())
-          throw error;
-        if (code !== "file_lock_stale")
-          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
-      }
-    }
-  }
-  externalActionLockOptions() {
-    const options = this.metadataLockOptions();
-    return { ...options, payload: () => ({ ...options.payload(), externalAction: true }) };
+    }));
+    this.compactPending();
+    return result;
   }
   async withExternalActionLock(operation, reentrant = false) {
     const activeRoots = externalActionLockRoots.getStore();
     if (activeRoots && [...activeRoots].some((root) => root === this.root || sameDirectoryIdentity(root, this.root)))
       return operation();
+    const ready = this.ready(true);
+    if (!ready.ok)
+      return ready;
+    const lockPath = this.paths().checkoutLock;
     try {
-      this.initializeMutationStorage();
+      this.initializeStorage();
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
-        path: this.workitDir
+        path: this.paths().dir
       });
     }
     let handle;
     try {
-      handle = this.acquireMetadataLock(this.externalActionLockOptions());
+      const options = this.lockOptions(lockPath);
+      handle = this.acquire(lockPath, {
+        ...options,
+        payload: () => ({ ...options.payload(), externalAction: true })
+      });
     } catch (error) {
-      return this.lockFailure(error);
+      return this.lockFailure(lockPath, error);
     }
-    holdRoot(this.root);
+    hold(lockPath);
     let result;
     try {
       if (!handle.verifyStillHeld())
-        result = failure2("recovery_required", "metadata lock was compromised", {
-          path: this.lockPath
-        });
+        result = failure2("recovery_required", "metadata lock was compromised", { path: lockPath });
       else {
         try {
           const run = () => operation();
@@ -19450,526 +19900,1144 @@ class TaskStore {
           if (!handle.verifyStillHeld())
             result = failure2("external_outcome_unknown", "metadata lock was compromised", {
               outcome: "unknown",
-              path: this.lockPath
+              path: lockPath
             });
         } catch {
           result = failure2("external_outcome_unknown", "metadata lock could not be verified", {
             outcome: "unknown",
-            path: this.lockPath
+            path: lockPath
           });
         }
       }
     } catch {
       result = failure2("external_outcome_unknown", "external action lock operation failed", {
         outcome: "unknown",
-        path: this.lockPath
+        path: lockPath
       });
     }
-    dropRoot(this.root);
+    drop(lockPath);
     try {
       retryTransient(() => handle.release());
     } catch (error) {
-      const released = this.lockFailure(error);
+      const released = this.lockFailure(lockPath, error);
       const releaseError = released.ok ? "metadata lock release failed" : released.error;
       return result.ok ? failure2("external_outcome_unknown", "external action metadata lock release is uncertain", {
         outcome: "unknown",
-        path: this.lockPath
+        path: lockPath
       }) : failure2("recovery_required", `${result.error}; ${releaseError}`, result.details);
     }
     return result;
   }
-  recoveryLockOptions(observed, evidence, gate) {
-    const options = this.metadataLockOptions();
-    options.timeoutMs = 0;
-    options.retry = { retries: 0 };
-    options.parsePayload = parseMetadataLock;
-    options.staleRecovery = "remove-if-unchanged";
-    options.shouldReclaim = ({ payload }) => Boolean(observed && sameMetadataLock(payload, observed.data) && (evidence.state === "stopped" || evidence.state === "accounted_for"));
-    options.shouldRemoveStaleLock = ({ raw, payload }) => {
-      if (!observed || raw !== observed.raw || !sameMetadataLock(payload, observed.data))
-        return false;
-      gate.reclaimed = true;
-      return true;
+  collectGarbage(options = {}) {
+    const dryRun = options.dryRun === true;
+    const compactAbove = options.compactAbove ?? COMPACT_ABOVE;
+    const report = {
+      dryRun,
+      compacted: { tasks: [], eventsFolded: 0, bytesBefore: 0, bytesAfter: 0 },
+      blobs: { removed: 0, removedBytes: 0, kept: 0 },
+      temporary: { removed: 0 },
+      legacyRecovery: null,
+      retried: [],
+      failed: []
     };
-    return options;
+    const ready = this.ready(!dryRun);
+    if (!ready.ok)
+      return ready;
+    const dirs = this.paths();
+    const recovery = path6.join(this.root, ".workit", "recovery");
+    if (fs7.existsSync(recovery)) {
+      let files = 0;
+      let bytes = 0;
+      try {
+        for (const name of fs7.readdirSync(recovery)) {
+          const stat = fs7.lstatSync(path6.join(recovery, name));
+          if (!stat.isFile())
+            continue;
+          files += 1;
+          bytes += stat.size;
+        }
+      } catch {}
+      const remove = options.pruneRecovery === true && !dryRun;
+      if (remove)
+        fs7.rmSync(recovery, { recursive: true, force: true });
+      report.legacyRecovery = { path: recovery, files, bytes, removed: remove };
+    }
+    if (!fs7.existsSync(dirs.tasks))
+      return success(null, null, report);
+    const names = fs7.readdirSync(dirs.tasks).filter((name) => validId(name));
+    for (const name of names) {
+      const file = this.eventsPath(name);
+      let size = 0;
+      try {
+        size = fs7.statSync(file).size;
+      } catch {
+        continue;
+      }
+      const lines = this.countEvents(file);
+      if (lines > compactAbove) {
+        if (dryRun) {
+          report.compacted.tasks.push(name);
+          report.compacted.eventsFolded += lines - COMPACT_KEEP;
+          report.compacted.bytesBefore += size;
+        } else {
+          const compacted = this.compact(name);
+          if (!compacted.ok)
+            (compacted.code === "busy" ? report.retried : report.failed).push(name);
+          else {
+            report.compacted.tasks.push(name);
+            report.compacted.eventsFolded += compacted.data.folded;
+            report.compacted.bytesBefore += size;
+            report.compacted.bytesAfter += compacted.data.bytes;
+          }
+        }
+      }
+    }
+    const nowMs = Date.now();
+    const sweep = () => {
+      const references = new Set;
+      for (const name of names)
+        try {
+          for (const match of fs7.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
+            references.add(match[1]);
+        } catch {}
+      if (fs7.existsSync(dirs.blobs))
+        for (const name of fs7.readdirSync(dirs.blobs)) {
+          const digest = name.replace(/\.json$/, "");
+          const file = path6.join(dirs.blobs, name);
+          let stat;
+          try {
+            stat = fs7.lstatSync(file);
+          } catch {
+            continue;
+          }
+          if (references.has(digest) || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS) {
+            report.blobs.kept += 1;
+            continue;
+          }
+          report.blobs.removed += 1;
+          report.blobs.removedBytes += stat.size;
+          if (!dryRun)
+            fs7.rmSync(file, { force: true });
+        }
+      return success(null, null, null);
+    };
+    const swept = dryRun ? sweep() : this.withLock(path6.join(dirs.dir, "gc.lock"), sweep);
+    if (!swept.ok)
+      return swept;
+    const temporaryDirs = [
+      dirs.dir,
+      dirs.tasks,
+      dirs.blobs,
+      dirs.checkout,
+      ...names.map((name) => path6.join(dirs.tasks, name))
+    ];
+    for (const directory of temporaryDirs) {
+      if (!fs7.existsSync(directory))
+        continue;
+      for (const name of fs7.readdirSync(directory)) {
+        if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
+          continue;
+        const file = path6.join(directory, name);
+        try {
+          const stat = fs7.lstatSync(file);
+          if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
+            continue;
+        } catch {
+          continue;
+        }
+        report.temporary.removed += 1;
+        if (!dryRun)
+          fs7.rmSync(file, { force: true });
+      }
+    }
+    return success(null, null, report);
   }
-  markUncertain(workspace) {
-    if (!workspace.writer || workspace.writer.state === "uncertain")
-      return;
-    const value = {
-      ...workspace,
-      writer: { ...workspace.writer, state: "uncertain" },
-      revision: newRevision(),
-      runtime: stampNew(workspace)
+  paths() {
+    const location = this.location();
+    const dir = location.ok ? location.data.dir : path6.join(this.root, ".workit");
+    const checkout = path6.join(dir, "checkouts", checkoutSlug(this.root));
+    return {
+      dir,
+      shared: location.ok ? location.data.shared : false,
+      marker: path6.join(dir, "store.json"),
+      checkout,
+      workspace: path6.join(checkout, "workspace.json"),
+      checkoutLock: path6.join(checkout, "metadata.lock"),
+      tasks: path6.join(dir, "tasks"),
+      index: path6.join(dir, "task-index.json"),
+      blobs: path6.join(dir, "blobs", "candidates"),
+      legacy: path6.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path6.join(this.root, ".workit")
     };
-    this.replaceSnapshot(this.workspacePath, value, workspace);
   }
-  withLock(operation, options = this.metadataLockOptions(), contention = "busy") {
+  eventsPath(taskId) {
+    return path6.join(this.paths().tasks, taskId, "events.jsonl");
+  }
+  snapshotPath(taskId) {
+    return path6.join(this.paths().tasks, taskId, "snapshot.json");
+  }
+  taskLockPath(taskId) {
+    return path6.join(this.paths().tasks, taskId, "lock");
+  }
+  ready(write = false) {
+    const location = this.location();
+    if (!location.ok)
+      return location;
+    if (this.migrationChecked)
+      return success(null, null, null);
+    const dirs = this.paths();
     try {
-      this.initializeMutationStorage();
-    } catch (error) {
-      return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
-        path: this.workitDir
-      });
+      const marker = JSON.parse(fs7.readFileSync(dirs.marker, "utf8"));
+      if (typeof marker.version === "number" && marker.version > STORE_FORMAT)
+        return failure2("recovery_required", `the workit store at ${dirs.dir} has format ${marker.version}; upgrade Workit to use it`, { path: dirs.marker });
+    } catch {}
+    this.migrationChecked = true;
+    const settled = this.settleMigrations(write);
+    if (!settled.ok)
+      this.migrationChecked = false;
+    return settled;
+  }
+  settleMigrations(write) {
+    const moved = this.adoptLocalStore();
+    if (!moved.ok)
+      return moved;
+    const pending = this.pendingMigrations();
+    if (pending.length > 0 && !write && !(this.migrateOnRead ?? migrationReporterInstalled()))
+      return failure2("needs_input", `${MIGRATION_PENDING}: the task store at ${pending[0]} has not been migrated yet; run \`workit task status\` to migrate it`, { path: pending[0], guidance: "workit task status" });
+    for (const v2 of this.v2Dirs()) {
+      const migrated = this.migrateV2(v2);
+      if (!migrated.ok)
+        return migrated;
     }
-    let handle;
-    let result = failure2("storage_error", "metadata lock operation did not produce a result");
+    return success(null, null, null);
+  }
+  blobStore() {
+    const dir = this.paths().blobs;
+    return {
+      read: (digest) => {
+        try {
+          return JSON.parse(fs7.readFileSync(path6.join(dir, `${digest}.json`), "utf8"));
+        } catch (error) {
+          throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
+        }
+      },
+      write: (digest, value) => {
+        const file = path6.join(dir, `${digest}.json`);
+        if (fs7.existsSync(file)) {
+          const stamp = new Date;
+          try {
+            fs7.utimesSync(file, stamp, stamp);
+            return;
+          } catch {}
+        }
+        fs7.mkdirSync(dir, { recursive: true });
+        replaceFile(file, JSON.stringify(value), true);
+      }
+    };
+  }
+  load(taskId) {
     try {
-      handle = this.acquireMetadataLock(options);
+      const loaded = this.loadOrThrow(taskId);
+      if (!loaded)
+        return success(null, null, null);
+      const parsed = this.parseTask(loaded.state.record, taskId);
+      if (!parsed.ok)
+        return parsed;
+      return success(null, null, {
+        record: parsed.data,
+        key: loaded.state.key,
+        legacy: loaded.state.legacy,
+        seq: loaded.seq,
+        lastId: loaded.lastId,
+        lastStart: loaded.lastStart,
+        end: loaded.end,
+        size: loaded.size,
+        snapshotSeq: loaded.snapshotSeq
+      });
     } catch (error) {
-      result = this.lockFailure(error, contention);
+      if (error instanceof LogDamage)
+        return failure2("recovery_required", error.upgrade ? error.message : `task ${taskId} log is damaged: ${error.message}`, { taskId, path: this.eventsPath(taskId) });
+      return failure2("recovery_required", `task ${taskId} cannot be read: ${String(error)}`, {
+        taskId
+      });
     }
-    if (handle)
-      holdRoot(this.root);
-    if (handle) {
+  }
+  loadOrThrow(taskId) {
+    const blobs = this.blobStore();
+    const file = this.eventsPath(taskId);
+    const snapshot = this.readSnapshot(taskId);
+    if (snapshot) {
       try {
-        if (!handle.verifyStillHeld())
-          result = failure2("recovery_required", "metadata lock was compromised", {
-            path: this.lockPath
-          });
-        else {
-          try {
-            result = operation(handle);
-          } catch (error) {
-            result = failure2("storage_error", `mutation failed: ${String(error)}`);
-          }
+        const tail = readLog(file, snapshot.lastStart, snapshot.seq);
+        const first = tail?.events[0];
+        if (tail && first && first.id === snapshot.lastId) {
+          let state = {
+            record: snapshot.record,
+            key: snapshot.key,
+            legacy: snapshot.legacy
+          };
+          for (const event of tail.events.slice(1))
+            state = reduce(state, event, blobs);
+          return this.loadedFrom(state, tail, snapshot.seq);
         }
       } catch (error) {
-        result = this.lockFailure(error);
+        if (error instanceof LogDamage && error.upgrade)
+          throw error;
       }
     }
-    if (handle) {
-      dropRoot(this.root);
-      try {
-        retryTransient(() => handle.release());
-      } catch (error) {
-        const releaseFailure = this.lockFailure(error);
-        const releaseError = releaseFailure.ok ? "metadata lock release failed" : releaseFailure.error;
-        result = result.ok ? releaseFailure : failure2("recovery_required", `${result.error}; ${releaseError}`, result.details);
-      }
+    const log = readLog(file, 0, null);
+    if (!log || log.events.length === 0) {
+      if (log && log.size > 0)
+        throw new LogDamage("the log holds no complete event");
+      return null;
     }
-    return result;
+    if (!OPENING_TYPES.has(log.events[0].type))
+      throw new LogDamage(`the log starts with ${log.events[0].type}, not an opening event`);
+    let state = null;
+    for (const event of log.events)
+      state = reduce(state, event, blobs);
+    return this.loadedFrom(state, log, 0);
   }
-  lockDirWritable() {
-    const probe = `${this.lockPath}.${process.pid}.${randomUUID2()}.probe`;
+  loadedFrom(state, log, snapshotSeq) {
+    const last = log.events.at(-1);
+    return {
+      state,
+      seq: last.seq,
+      lastId: last.id,
+      lastStart: log.lastStart,
+      end: log.end,
+      size: log.size,
+      snapshotSeq
+    };
+  }
+  readSnapshot(taskId) {
     try {
-      fs5.closeSync(fs5.openSync(probe, "wx", 384));
+      const value = JSON.parse(fs7.readFileSync(this.snapshotPath(taskId), "utf8"));
+      if (!isObject4(value) || value.v !== 1 || value.task !== taskId || typeof value.seq !== "number" || typeof value.lastId !== "string" || typeof value.lastStart !== "number" || typeof value.end !== "number" || !isObject4(value.record))
+        return null;
+      return value;
     } catch {
-      return false;
+      return null;
     }
+  }
+  writeSnapshot(taskId, loaded) {
+    const snapshot = {
+      v: 1,
+      task: taskId,
+      seq: loaded.seq,
+      lastId: loaded.lastId,
+      lastStart: loaded.lastStart,
+      end: loaded.end,
+      key: loaded.key,
+      legacy: loaded.legacy,
+      record: loaded.record
+    };
     try {
-      fs5.rmSync(probe, { force: true });
+      replaceFile(this.snapshotPath(taskId), JSON.stringify(snapshot), false);
     } catch {}
-    return true;
   }
-  lockHolderPresent() {
+  loadBound(taskId) {
+    const loaded = this.load(taskId);
+    if (!loaded.ok)
+      return loaded;
+    if (!loaded.data)
+      return failure2("not_found", "task not found", { taskId });
+    const workspace = this.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    const bound = this.bindingError(loaded.data.record, workspace.data);
+    return bound ?? success(null, null, loaded.data);
+  }
+  bindingError(task, workspace) {
+    if (workspace && task.workspaceId === workspace.id)
+      return null;
+    return failure2("not_found", `task ${task.id} belongs to another checkout of this repository; run there, or move it here with \`workit task adopt ${task.id}\``, { taskId: task.id });
+  }
+  nextTask(current, changed, context) {
+    const valid = taskRecordSchema.safeParse({
+      ...changed,
+      id: current.id,
+      workspaceId: current.workspaceId,
+      createdAt: current.createdAt,
+      revision: context.revision,
+      updatedAt: context.now,
+      runtime: stampNew(current)
+    });
+    return valid.success ? valid.data : null;
+  }
+  event(taskId, seq, type, data) {
+    return {
+      v: EVENT_VERSION,
+      seq,
+      at: new Date().toISOString(),
+      id: newId(),
+      task: taskId,
+      actor: this.actor,
+      type,
+      data
+    };
+  }
+  appendPatch(loaded, next, extra = {}) {
+    const taskId = next.id;
     try {
-      fs5.lstatSync(this.lockPath);
-      return true;
+      const blobs = this.blobStore();
+      const before = loaded.record;
+      const after = next;
+      const ops = encodeOps(diff(before, after), blobs);
+      const { type, ...data } = extra;
+      if (data.key)
+        data.key = { ...data.key, boundAt: data.key.boundAt ?? new Date().toISOString() };
+      const event = this.event(taskId, loaded.seq + 1, type ?? ("key" in extra ? "task.bound" : eventType(before, after)), { ops, ...data });
+      const start = appendEvent(this.eventsPath(taskId), event, loaded.end);
+      const end = start + Buffer.byteLength(`${JSON.stringify(event)}
+`);
+      const key = "key" in data ? data.key ?? null : loaded.key;
+      const state = {
+        record: next,
+        key,
+        legacy: extra.legacy ?? loaded.legacy,
+        seq: event.seq,
+        lastId: event.id,
+        lastStart: start,
+        end
+      };
+      if (event.seq - loaded.snapshotSeq >= SNAPSHOT_EVERY || next.status !== loaded.record.status || loaded.snapshotSeq === 0)
+        this.writeSnapshot(taskId, state);
+      if (end > AUTO_COMPACT_BYTES)
+        this.compactDue.add(taskId);
+      this.indexTask(next, key, (extra.legacy ?? loaded.legacy) !== null);
+      return success(null, null, null);
     } catch (error) {
-      return error?.code !== "ENOENT";
+      return failure2("storage_error", `task append failed: ${String(error)}`, {
+        path: this.eventsPath(taskId)
+      });
     }
   }
-  lockFailure(error, contention = "busy") {
-    const value = error;
-    const code = typeof value?.code === "string" ? value.code : "";
-    if (isTransientWindowsError(error) && !this.lockHolderPresent() && !this.lockDirWritable())
-      return failure2("storage_error", `cannot create the workspace metadata lock (${code}); no other Workit call holds it`, {
-        path: this.lockPath,
-        guidance: `Check permissions and the read-only attribute on ${path4.dirname(this.lockPath)}.`
+  openTask(record, type, key, legacy = null) {
+    const dir = path6.join(this.paths().tasks, record.id);
+    fs7.mkdirSync(dir, { recursive: true });
+    const blobs = this.blobStore();
+    const bound = key ? { ...key, boundAt: key.boundAt ?? new Date().toISOString() } : null;
+    const event = this.event(record.id, 1, type, {
+      record: encodeRecord(record, blobs),
+      key: bound,
+      ...legacy ? { legacy } : {}
+    });
+    const file = this.eventsPath(record.id);
+    const existing = readLog(file, 0, null);
+    if (existing && existing.events.length > 0)
+      throw new Error(`task ${record.id} already has a log`);
+    appendEvent(file, event, 0);
+    this.indexTask(record, bound, legacy !== null);
+  }
+  compactPending() {
+    for (const taskId of this.compactDue) {
+      this.compactDue.delete(taskId);
+      this.compact(taskId);
+    }
+  }
+  compact(taskId) {
+    try {
+      const file = this.eventsPath(taskId);
+      const log = readLog(file, 0, null);
+      if (!log || log.events.length <= COMPACT_KEEP + 1)
+        return success(null, null, { folded: 0, bytes: log?.size ?? 0 });
+      const blobs = this.blobStore();
+      const cut = log.events.length - COMPACT_KEEP;
+      let state = null;
+      for (const event of log.events.slice(0, cut))
+        state = reduce(state, event, blobs);
+      const folded = log.events[cut - 1];
+      const checkpoint = {
+        ...this.event(taskId, folded.seq, "task.checkpoint", {
+          record: encodeRecord(state.record, blobs),
+          key: state.key,
+          ...state.legacy ? { legacy: state.legacy } : {},
+          folded: { from: log.events[0].seq, to: folded.seq }
+        })
+      };
+      const prefix = `${[checkpoint, ...log.events.slice(cut)].map((event) => JSON.stringify(event)).join(`
+`)}
+`;
+      const last = log.events.at(-1);
+      return this.withLock(this.taskLockPath(taskId), () => {
+        let latest = null;
+        try {
+          latest = readLog(file, log.lastStart, last.seq);
+        } catch {}
+        if (!latest || latest.events[0]?.id !== last.id)
+          return failure2("busy", "the task log changed during compaction; retry", { taskId });
+        const appended = fs7.readFileSync(file).subarray(log.end, latest.end);
+        const bytes = Buffer.concat([Buffer.from(prefix, "utf8"), appended]);
+        replaceFile(file, bytes.toString("utf8"), true);
+        try {
+          fs7.rmSync(this.snapshotPath(taskId), { force: true });
+        } catch {}
+        const reloaded = this.load(taskId);
+        if (reloaded.ok && reloaded.data)
+          this.writeSnapshot(taskId, reloaded.data);
+        return success(null, null, { folded: cut, bytes: bytes.length });
       });
-    if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
-      let lock = null;
-      try {
-        lock = parseMetadataLockOrNull(fs5.readFileSync(this.lockPath, "utf8"));
-      } catch {}
-      if (lock?.externalAction)
-        return failure2("writer_conflict", "workspace is reserved by a managed external action", {
-          outcome: "not_started",
-          path: this.lockPath
-        });
-      if (contention === "busy")
-        return failure2("busy", `workspace metadata lock is held by another Workit call${lock ? ` (pid ${lock.pid} on ${lock.host})` : ""}; retry shortly`, {
-          outcome: "not_started",
-          path: this.lockPath,
-          guidance: "Retry the same call. If it stays busy, run `workit doctor --fix-lock` to clear a lock left by a dead process."
+    } catch (error) {
+      return failure2("storage_error", `compaction failed: ${String(error)}`, { taskId });
+    }
+  }
+  countEvents(file) {
+    try {
+      const bytes = fs7.readFileSync(file);
+      let count = 0;
+      for (let index = bytes.indexOf(10);index >= 0; index = bytes.indexOf(10, index + 1))
+        count += 1;
+      return count;
+    } catch {
+      return 0;
+    }
+  }
+  openTasksForKey(key) {
+    const all = this.listStoreIndex();
+    if (!all.ok)
+      return all;
+    const location = this.location();
+    const renames = location.ok ? branchRenames(location.data) : [];
+    return success(null, null, all.data.filter((entry) => entry.key !== null && entry.status !== "closed").filter((entry) => (renames.length ? followRenames(entry.key, entry.boundAt ?? entry.createdAt, renames) : entry.key) === key).toSorted(oldestFirst));
+  }
+  openTaskForKey(key) {
+    const bound = this.openTasksForKey(key);
+    return bound.ok ? success(null, null, bound.data[0] ?? null) : bound;
+  }
+  withKeyLock(key, operation) {
+    const digest = createHash4("sha256").update(key).digest("hex").slice(0, 32);
+    return this.withLock(path6.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+  }
+  bindLocked(taskId, key, timestamp) {
+    const current = this.readWorkspace();
+    if (!current.ok)
+      return current;
+    let workspace = current.data;
+    if (!workspace) {
+      workspace = this.nextWorkspace(null);
+      const written = this.writeWorkspace(workspace);
+      if (!written.ok)
+        return written;
+    }
+    const target = workspace;
+    return this.withLock(this.taskLockPath(taskId), () => {
+      const loaded = this.load(taskId);
+      if (!loaded.ok)
+        return loaded;
+      if (!loaded.data)
+        return failure2("not_found", "task not found", { taskId });
+      if (loaded.data.record.status === "closed")
+        return failure2("invalid_transition", "a closed task cannot be adopted", { taskId });
+      if (loaded.data.record.workspaceId === target.id && loaded.data.key?.key === key.key)
+        return success(loaded.data.record.revision, null, loaded.data.record);
+      const next = taskRecordSchema.safeParse({
+        ...loaded.data.record,
+        workspaceId: target.id,
+        revision: newRevision(),
+        updatedAt: timestamp ?? now(),
+        runtime: stampNew(loaded.data.record)
+      });
+      if (!next.success)
+        return failure2("invalid_input", "rebound task is invalid");
+      const written = this.appendPatch(loaded.data, next.data, { key });
+      return written.ok ? success(next.data.revision, null, next.data) : written;
+    });
+  }
+  unbindLocked(taskId) {
+    return this.withLock(this.taskLockPath(taskId), () => {
+      const loaded = this.load(taskId);
+      if (!loaded.ok)
+        return loaded;
+      if (!loaded.data || loaded.data.key === null)
+        return success(null, null, null);
+      return this.appendPatch(loaded.data, loaded.data.record, { key: null });
+    });
+  }
+  createLocked(value, bindCurrent, key, checkRevision = true) {
+    const current = this.readWorkspace();
+    if (!current.ok)
+      return current;
+    if (checkRevision && (current.data ? value.expectedWorkspaceRevision !== current.data.revision : value.expectedWorkspaceRevision !== null))
+      return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", {
+        expectedWorkspaceRevision: value.expectedWorkspaceRevision,
+        actualWorkspaceRevision: current.data?.revision ?? null
+      });
+    if (!value.provenance)
+      return failure2("invalid_input", "provenance is required");
+    if (!intentSchema.safeParse(value.intent).success || !provenanceSchema.safeParse(value.provenance).success)
+      return failure2("invalid_input", "task intent or provenance is invalid");
+    if (bindCurrent) {
+      const currentKey = this.currentKey();
+      if (currentKey.ok)
+        return this.withKeyLock(currentKey.data.key, () => {
+          const holder = this.openTaskForKey(currentKey.data.key);
+          if (!holder.ok)
+            return holder;
+          if (holder.data) {
+            const released = this.unbindLocked(holder.data.id);
+            if (!released.ok)
+              return released;
+          }
+          return this.newTask(value, current.data, currentKey.data);
         });
     }
-    const recovery = code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || code === "metadata_lock_invalid" || code === "not-file" || /metadata lock|file lock|reclaim/i.test(String(value?.message ?? error));
-    return failure2(recovery ? "recovery_required" : "storage_error", `metadata lock operation failed: ${String(error)}`, { path: this.lockPath });
+    return this.newTask(value, current.data, key);
+  }
+  newTask(value, previous, binding) {
+    const current = { data: previous };
+    const workspace = this.nextWorkspace(current.data);
+    const timestamp = value.now ?? now();
+    const task = {
+      schemaVersion: SCHEMA_VERSION,
+      id: newId(),
+      workspaceId: workspace.id,
+      revision: newRevision(),
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      origin: null,
+      intent: {
+        id: newId(),
+        recordedAt: timestamp,
+        provenance: value.provenance,
+        data: value.intent
+      },
+      constraints: [],
+      status: "active",
+      closure: null,
+      progress: { summary: "", nextAction: null, blockers: [] },
+      runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
+      assessments: [],
+      policy: null,
+      policyChanges: [],
+      candidates: [],
+      evidence: [],
+      decisions: [],
+      findings: [],
+      workers: []
+    };
+    return this.writeNewTask(current.data, workspace, task, "task.opened", binding, {
+      operation: "create"
+    });
+  }
+  nextWorkspace(current, id) {
+    return current ? { ...current, revision: newRevision(), root: this.root, runtime: stampNew(current) } : {
+      schemaVersion: SCHEMA_VERSION,
+      id: id ?? newId(),
+      revision: newRevision(),
+      root: this.root,
+      runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
+      writer: null
+    };
   }
-  initializeMutationStorage() {
-    retryTransient(() => fs5.mkdirSync(this.tasksDir, { recursive: true }));
-    retryTransient(() => fs5.mkdirSync(this.recoveryDir, { recursive: true }));
-    let current = null;
+  writeNewTask(previous, workspace, task, type, key, details) {
+    const written = this.writeWorkspace(workspace);
+    if (!written.ok)
+      return written;
     try {
-      current = retryTransient(() => fs5.readFileSync(this.gitignorePath, "utf8"));
-    } catch {}
-    if (current !== `*
-`)
-      retryTransient(() => fs5.writeFileSync(this.gitignorePath, `*
-`));
+      this.openTask(task, type, key);
+    } catch (error) {
+      if (previous) {
+        const restored = this.writeWorkspace(previous);
+        if (!restored.ok)
+          return failure2("external_outcome_unknown", `task ${details.operation} failed and workspace restoration is uncertain`, { ...details, outcome: "unknown" });
+      }
+      return failure2("external_outcome_unknown", `workspace written but the task log is uncertain: ${String(error)}`, { ...details, outcome: "unknown" });
+    }
+    return success(task.revision, workspace.revision, task);
   }
-  replaceSnapshot(file, value, previous) {
-    let temporary;
+  writeWorkspace(record) {
+    const file = this.paths().workspace;
     try {
-      if (Buffer.isBuffer(previous))
-        this.saveRecovery(file, previous);
-      else if (previous !== null && typeof previous === "object")
-        this.saveRecovery(file, jsonBytes(previous));
-      else if (typeof previous === "string")
-        this.saveRecovery(file, previous);
-      temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
-      const fd = fs5.openSync(temporary, "wx", 384);
-      try {
-        fs5.writeSync(fd, jsonBytes(value));
-        fs5.fsyncSync(fd);
-      } finally {
-        fs5.closeSync(fd);
-      }
-      retryTransient(() => fs5.renameSync(temporary, file));
-      temporary = undefined;
-      this.fsyncDirectory(path4.dirname(file));
-      if (path4.dirname(file) === this.tasksDir)
-        this.indexTaskWrite(file, value);
-      return success(null, null, value);
+      fs7.mkdirSync(path6.dirname(file), { recursive: true });
+      replaceFile(file, `${canonicalJson(record)}
+`, true);
+      return success(null, null, null);
     } catch (error) {
-      return failure2("storage_error", `snapshot replacement failed: ${String(error)}`, {
-        path: file
-      });
-    } finally {
-      if (temporary)
-        try {
-          fs5.unlinkSync(temporary);
-        } catch {}
+      return failure2("storage_error", `workspace write failed: ${String(error)}`, { path: file });
     }
   }
-  readIndex(workspaceId) {
+  markUncertain(workspace) {
+    if (!workspace.writer || workspace.writer.state === "uncertain")
+      return;
+    this.writeWorkspace({
+      ...workspace,
+      writer: { ...workspace.writer, state: "uncertain" },
+      revision: newRevision(),
+      runtime: stampNew(workspace)
+    });
+  }
+  readIndex() {
     try {
-      const value = JSON.parse(fs5.readFileSync(this.indexPath, "utf8"));
-      if (!isObject2(value) || value.version !== INDEX_VERSION || value.workspaceId !== workspaceId || !isObject2(value.tasks))
+      const value = JSON.parse(fs7.readFileSync(this.paths().index, "utf8"));
+      if (!isObject4(value) || value.version !== INDEX_VERSION || !isObject4(value.tasks))
         return {};
       const tasks = {};
       for (const [id, entry] of Object.entries(value.tasks))
-        if (isObject2(entry) && entry.id === id && typeof entry.file === "string" && typeof entry.status === "string" && typeof entry.updatedAt === "string" && Array.isArray(entry.sessions) && isObject2(entry.progress) && isObject2(entry.source))
+        if (isObject4(entry) && entry.id === id && typeof entry.file === "string" && typeof entry.status === "string" && typeof entry.updatedAt === "string" && typeof entry.workspaceId === "string" && Array.isArray(entry.sessions) && isObject4(entry.progress) && isObject4(entry.source))
           tasks[id] = entry;
       return tasks;
     } catch {
       return {};
     }
   }
-  writeIndex(workspaceId, entries) {
-    const temporary = `${this.indexPath}.${process.pid}.${randomUUID2()}.tmp`;
+  writeIndex(entries) {
     try {
-      fs5.writeFileSync(temporary, JSON.stringify({
+      fs7.mkdirSync(this.paths().tasks, { recursive: true });
+      replaceFile(this.paths().index, JSON.stringify({
         version: INDEX_VERSION,
-        workspaceId,
         tasks: Object.fromEntries(entries.map((entry) => [entry.id, entry]))
-      }), { mode: 384, flag: "wx" });
-      retryTransient(() => fs5.renameSync(temporary, this.indexPath));
+      }), false);
+    } catch {}
+  }
+  indexTask(task, key, legacy) {
+    try {
+      const signature = fileSignature(this.eventsPath(task.id));
+      if (signature === null)
+        return;
+      const tasks = this.readIndex();
+      tasks[task.id] = indexEntry(task, key, legacy, signature);
+      this.writeIndex(Object.values(tasks));
+    } catch {}
+  }
+  parseTask(record, taskId) {
+    const parsed = this.parseValue(record, taskRecordSchema, "task");
+    if (!parsed.ok)
+      return { ...parsed, details: { ...parsed.details, taskId } };
+    if (parsed.data.id !== taskId)
+      return failure2("recovery_required", "task log and record ID differ", { taskId });
+    return parsed;
+  }
+  parseRecord(bytes, schema, label) {
+    let value;
+    try {
+      value = JSON.parse(bytes);
+    } catch {
+      return failure2("recovery_required", `${label} record JSON is corrupt`);
+    }
+    return this.parseValue(value, schema, label);
+  }
+  parseValue(value, schema, label) {
+    if (isObject4(value) && "schemaVersion" in value && value.schemaVersion !== SCHEMA_VERSION)
+      return failure2("unsupported_version", `unsupported ${label} schema version`);
+    const parsed = parseStoredRecord(schema, value);
+    if (parsed.success)
+      return success(null, null, parsed.data);
+    const writerVersion = isObject4(value) && isObject4(value.runtime) ? value.runtime.updatedWith : null;
+    if (parsed.critical.length > 0)
+      return failure2("recovery_required", `${label} record requires fields this Workit cannot read (${parsed.critical.join(", ")}); upgrade Workit before mutating this checkout`);
+    if (typeof writerVersion === "string" && isNewerVersion(writerVersion, runtimeVersion()))
+      return failure2("recovery_required", `${label} record was written by workit ${writerVersion}; upgrade Workit before mutating this checkout`);
+    return failure2("recovery_required", `${label} record does not satisfy its schema`);
+  }
+  conflict(expected, actual) {
+    return failure2("revision_conflict", "snapshot revision does not match; omit expectedRevision to use the current record", { expectedRevision: expected, actualRevision: actual });
+  }
+  workspaceConflict(expected, actual) {
+    return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
+  }
+  v2Dirs() {
+    return [...new Set([this.root, this.origin])].map((dir) => path6.join(dir, ".workit"));
+  }
+  pendingMigrations() {
+    return this.v2Dirs().filter((dir) => {
+      const raw = this.readV2Workspace(path6.join(dir, "workspace.json"));
+      return raw !== null && raw !== TOMBSTONE;
+    });
+  }
+  migrateV2(v2) {
+    const dirs = this.paths();
+    const v2Workspace = path6.join(v2, "workspace.json");
+    const v2Tasks = path6.join(v2, "tasks");
+    const legacy = path6.join(dirs.dir, "legacy", checkoutSlug(path6.dirname(v2)), "v2");
+    const raw = this.readV2Workspace(v2Workspace);
+    if (raw === null || raw === TOMBSTONE)
+      return success(null, null, null);
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path6.join(v2, "metadata.lock"), () => {
+      const workspace = this.readV2Workspace(v2Workspace);
+      if (workspace === null || workspace === TOMBSTONE)
+        return success(null, null, null);
+      const parsedWorkspace = this.parseRecord(workspace.bytes, workspaceRecordSchema, "2.x workspace");
+      if (!parsedWorkspace.ok)
+        return failure2("recovery_required", `cannot migrate the 2.x store at ${v2}: ${parsedWorkspace.error}; move it aside to start fresh`, { path: v2Workspace });
+      let files = [];
+      try {
+        files = fs7.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path6.join(v2Tasks, name)));
+      } catch {}
+      const current = this.readWorkspace();
+      if (!current.ok)
+        return current;
+      let workspaceMoved = false;
+      let target = current.data;
+      if (!target) {
+        target = { ...parsedWorkspace.data, root: this.root };
+        const written = this.writeWorkspace(target);
+        if (!written.ok)
+          return written;
+        workspaceMoved = true;
+      }
+      let migrated = 0;
+      let skipped = 0;
+      const done = new Map;
+      try {
+        fs7.mkdirSync(path6.join(legacy, "tasks"), { recursive: true });
+        for (const name of ["workspace.json", "index.json"])
+          if (fs7.existsSync(path6.join(v2, name)))
+            fs7.copyFileSync(path6.join(v2, name), path6.join(legacy, name));
+        for (const name of files) {
+          const id = name.slice(0, -5);
+          const file = path6.join(v2Tasks, name);
+          const bytes = fs7.readFileSync(file, "utf8");
+          const digest = sha256(bytes);
+          fs7.writeFileSync(path6.join(legacy, "tasks", name), bytes);
+          const parsed = this.parseRecord(bytes, taskRecordSchema, "2.x task");
+          if (!parsed.ok || parsed.data.id !== id)
+            return failure2("recovery_required", `cannot migrate 2.x task ${id}: ${parsed.ok ? "file name and record ID differ" : parsed.error}; move ${file} aside to continue`, { path: file });
+          const record = { ...parsed.data, workspaceId: target.id };
+          const origin = { path: path6.join(legacy, "tasks", name), digest };
+          if (!fs7.existsSync(this.eventsPath(id))) {
+            this.openTask(record, "migrated.from_v2", null, origin);
+            migrated += 1;
+          } else {
+            const resynced = this.withLock(this.taskLockPath(id), () => {
+              const loaded = this.load(id);
+              if (!loaded.ok)
+                return loaded;
+              if (!loaded.data)
+                return failure2("not_found", "task not found", { taskId: id });
+              if (loaded.data.legacy?.digest === digest)
+                return success(null, null, false);
+              const appended = this.appendPatch(loaded.data, record, {
+                type: "migrated.from_v2",
+                legacy: origin
+              });
+              return appended.ok ? success(null, null, true) : appended;
+            });
+            if (!resynced.ok)
+              return resynced;
+            if (resynced.data)
+              migrated += 1;
+            else
+              skipped += 1;
+          }
+          done.set(name, digest);
+        }
+      } catch (error) {
+        return failure2("storage_error", `cannot migrate the 2.x store at ${v2}: ${String(error)}`, {
+          path: v2
+        });
+      }
+      try {
+        let complete = true;
+        for (const [name, digest] of done) {
+          const file = path6.join(v2Tasks, name);
+          if (sha256(fs7.readFileSync(file, "utf8")) !== digest) {
+            complete = false;
+            continue;
+          }
+          replaceFile(file, this.stubFor(name.slice(0, -5)), false);
+        }
+        if (!complete)
+          return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
+            path: v2
+          });
+        fs7.rmSync(path6.join(v2, "index.json"), { force: true });
+        this.writeTombstone(v2, target.id);
+      } catch (error) {
+        return failure2("storage_error", `cannot finish the 2.x migration: ${String(error)}`, {
+          path: v2
+        });
+      }
+      reportMigration({
+        from: v2,
+        to: dirs.dir,
+        backup: legacy,
+        tasks: migrated,
+        skipped,
+        workspace: workspaceMoved
+      });
+      return success(null, null, null);
+    }));
+  }
+  adoptLocalStore() {
+    const dirs = this.paths();
+    const marker = path6.join(dirs.v2, "store.json");
+    if (!dirs.shared || !fs7.existsSync(marker))
+      return success(null, null, null);
+    return this.withLock(dirs.checkoutLock, () => {
+      if (!fs7.existsSync(marker))
+        return success(null, null, null);
+      let tasks = 0;
+      try {
+        const merge = (from, to) => {
+          if (!fs7.existsSync(to)) {
+            fs7.mkdirSync(path6.dirname(to), { recursive: true });
+            try {
+              fs7.renameSync(from, to);
+            } catch {
+              fs7.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
+              fs7.rmSync(from, { recursive: true, force: true });
+            }
+            return;
+          }
+          if (fs7.lstatSync(from).isDirectory() && fs7.lstatSync(to).isDirectory())
+            for (const name of fs7.readdirSync(from))
+              merge(path6.join(from, name), path6.join(to, name));
+        };
+        for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
+          const from = path6.join(dirs.v2, sub);
+          if (!fs7.existsSync(from))
+            continue;
+          if (sub === "tasks") {
+            for (const name of fs7.readdirSync(from))
+              if (validId(name) && !fs7.existsSync(path6.join(dirs.dir, sub, name)))
+                tasks += 1;
+          }
+          merge(from, path6.join(dirs.dir, sub));
+        }
+        const ledger = path6.join(dirs.v2, "ledger");
+        if (fs7.existsSync(ledger) && !fs7.existsSync(path6.join(dirs.dir, "ledger")))
+          merge(ledger, path6.join(dirs.dir, "ledger"));
+        fs7.rmSync(path6.join(dirs.v2, "task-index.json"), { force: true });
+        fs7.renameSync(marker, path6.join(dirs.v2, "store.moved.json"));
+      } catch (error) {
+        return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
+          path: dirs.v2
+        });
+      }
+      reportMigration({
+        from: dirs.v2,
+        to: dirs.dir,
+        backup: dirs.v2,
+        tasks,
+        skipped: 0,
+        workspace: false
+      });
+      return success(null, null, null);
+    });
+  }
+  readV2Workspace(file) {
+    let bytes;
+    try {
+      bytes = fs7.readFileSync(file, "utf8");
     } catch {
-      try {
-        fs5.unlinkSync(temporary);
-      } catch {}
+      return null;
     }
-  }
-  indexTaskWrite(file, task) {
     try {
-      const signature = fileSignature(file);
-      if (signature === null)
-        return;
-      const tasks = this.readIndex(task.workspaceId);
-      tasks[task.id] = indexEntry(task, signature);
-      this.writeIndex(task.workspaceId, Object.values(tasks));
+      const value = JSON.parse(bytes);
+      if (isObject4(value) && isObject4(value.store) && value.store.format === "workit-store")
+        return TOMBSTONE;
     } catch {}
+    return { bytes };
+  }
+  writeTombstone(v2, workspaceId) {
+    const dirs = this.paths();
+    const version = isNewerVersion(runtimeVersion(), STORE_MIN_RUNTIME) ? runtimeVersion() : STORE_MIN_RUNTIME;
+    const marker = {
+      schemaVersion: SCHEMA_VERSION,
+      id: workspaceId ?? newId(),
+      revision: newRevision(),
+      root: path6.dirname(v2),
+      runtime: { createdWith: version, updatedWith: version },
+      writer: null,
+      store: {
+        format: "workit-store",
+        version: STORE_FORMAT,
+        path: dirs.dir,
+        note: `workit ${STORE_MIN_RUNTIME}+ keeps task state in ${dirs.dir}; upgrade Workit`
+      },
+      critical: ["store"]
+    };
+    fs7.mkdirSync(v2, { recursive: true });
+    const ignore = path6.join(v2, ".gitignore");
+    if (!fs7.existsSync(ignore))
+      fs7.writeFileSync(ignore, `*
+`);
+    replaceFile(path6.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+`, true);
+  }
+  stubFor(taskId) {
+    const version = isNewerVersion(runtimeVersion(), STORE_MIN_RUNTIME) ? runtimeVersion() : STORE_MIN_RUNTIME;
+    return `${JSON.stringify({
+      schemaVersion: SCHEMA_VERSION,
+      id: taskId,
+      runtime: { createdWith: version, updatedWith: version },
+      store: { format: "workit-store", version: STORE_FORMAT, path: this.paths().dir },
+      critical: ["store"]
+    })}
+`;
   }
-  saveRecovery(file, bytes) {
-    const target = path4.basename(file) === "workspace.json" ? "workspace" : "task";
-    const id = target === "task" ? path4.basename(file, ".json") : "workspace";
-    const destination = path4.join(this.recoveryDir, `${target}.${id}.${digestBytes(bytes)}.json`);
-    if (fs5.existsSync(destination)) {
-      if (digestBytes(retryTransient(() => fs5.readFileSync(destination))) !== digestBytes(bytes))
-        throw new Error("recovery copy already exists with different bytes");
-      const stamp = new Date;
-      retryTransient(() => fs5.utimesSync(destination, stamp, stamp));
-      this.pruneRecovery(`${target}.${id}.`, destination);
-      return;
-    }
-    let temporary;
+  isStub(file) {
     try {
-      temporary = `${destination}.${process.pid}.${randomUUID2()}.tmp`;
-      const fd = fs5.openSync(temporary, "wx", 384);
-      try {
-        fs5.writeSync(fd, bytes);
-        fs5.fsyncSync(fd);
-      } finally {
-        fs5.closeSync(fd);
-      }
-      retryTransient(() => fs5.renameSync(temporary, destination));
-      temporary = undefined;
-      this.fsyncDirectory(this.recoveryDir);
-      this.pruneRecovery(`${target}.${id}.`, destination);
-    } finally {
-      if (temporary)
-        try {
-          fs5.unlinkSync(temporary);
-        } catch {}
+      const value = JSON.parse(fs7.readFileSync(file, "utf8"));
+      return isObject4(value) && isObject4(value.store) && value.store.format === "workit-store";
+    } catch {
+      return false;
     }
   }
-  pruneRecovery(prefix, keep) {
+  writeTombstoneIfMissing() {
     try {
-      const copies = this.recoveryCopies(prefix);
-      const surplus = this.surplusCopies(copies, path4.basename(keep));
-      for (const copy of surplus)
-        fs5.rmSync(copy.path, { force: true });
+      const v2 = path6.join(this.root, ".workit");
+      if (fs7.existsSync(path6.join(v2, "workspace.json")))
+        return;
+      let id = null;
+      try {
+        id = JSON.parse(fs7.readFileSync(this.paths().workspace, "utf8")).id ?? null;
+      } catch {}
+      this.writeTombstone(v2, id);
     } catch {}
   }
-  recoveryCopies(prefix = "") {
-    if (!fs5.existsSync(this.recoveryDir))
-      return [];
-    const copies = [];
-    for (const name of fs5.readdirSync(this.recoveryDir)) {
-      if (!name.startsWith(prefix))
-        continue;
-      const match = RECOVERY_NAME.exec(name);
-      if (!match)
-        continue;
-      const file = path4.join(this.recoveryDir, name);
+  initializeStorage() {
+    const dirs = this.paths();
+    retryTransient(() => fs7.mkdirSync(dirs.checkout, { recursive: true }));
+    retryTransient(() => fs7.mkdirSync(dirs.tasks, { recursive: true }));
+    if (!fs7.existsSync(dirs.marker))
+      replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
+`, false);
+    if (!dirs.shared) {
+      const ignore = path6.join(dirs.dir, ".gitignore");
+      let current = null;
       try {
-        const stat = fs5.lstatSync(file, { bigint: true });
-        if (!stat.isFile())
-          continue;
-        copies.push({ name, path: file, group: `${match[1]}.${match[2]}`, mtimeNs: stat.mtimeNs });
+        current = fs7.readFileSync(ignore, "utf8");
       } catch {}
+      if (current !== `*
+`)
+        retryTransient(() => fs7.writeFileSync(ignore, `*
+`));
     }
-    return copies;
-  }
-  surplusCopies(copies, keep) {
-    const ordered = copies.toSorted((left, right) => left.name === keep ? -1 : right.name === keep ? 1 : left.mtimeNs === right.mtimeNs ? left.name.localeCompare(right.name) : left.mtimeNs > right.mtimeNs ? -1 : 1);
-    return ordered.slice(RECOVERY_COPIES_PER_RECORD);
+    this.writeTombstoneIfMissing();
   }
-  collectGarbage(options = {}) {
-    const dryRun = options.dryRun === true;
-    const report = {
-      dryRun,
-      recovery: { removed: 0, removedBytes: 0, kept: 0 },
-      temporary: { removed: 0 },
-      candidates: { removed: 0, tasks: [], skippedActive: [], skippedClosed: [], failed: [] }
+  lockOptions(lockPath) {
+    const inProcess = heldInProcess.has(lockPath);
+    return {
+      lockPath,
+      staleMs: Number.MAX_SAFE_INTEGER,
+      timeoutMs: inProcess ? 0 : this.lockTimeoutMs,
+      retry: inProcess ? { retries: 0 } : { minTimeout: 5, maxTimeout: 100, factor: 1.5, randomize: true },
+      staleRecovery: "remove-if-unchanged",
+      shouldReclaim: ({ payload, nowMs }) => {
+        let ageMs = null;
+        try {
+          ageMs = nowMs - fs7.lstatSync(lockPath).mtimeMs;
+        } catch {}
+        return classifyLockOwner(payload, ageMs).state === "stale";
+      },
+      shouldRemoveStaleLock: () => true,
+      parsePayload: parseMetadataLockOrNull,
+      payload: () => ({
+        pid: process.pid,
+        processStart: processStartOf(process.pid),
+        host: localLockHost(),
+        nonce: randomUUID3()
+      })
     };
-    if (!fs5.existsSync(this.workitDir))
-      return success(null, null, report);
-    const sweep = () => {
+  }
+  acquire(lockPath, options) {
+    clearAbandonedReclaimGuard(lockPath);
+    const deadline = Date.now() + (options.timeoutMs ?? 0);
+    while (true) {
       try {
-        const groups = new Map;
-        for (const copy of this.recoveryCopies())
-          groups.set(copy.group, [...groups.get(copy.group) ?? [], copy]);
-        for (const copies of groups.values()) {
-          const surplus = this.surplusCopies(copies);
-          report.recovery.kept += copies.length - surplus.length;
-          for (const copy of surplus) {
-            report.recovery.removed += 1;
-            try {
-              report.recovery.removedBytes += fs5.statSync(copy.path).size;
-            } catch {}
-            if (!dryRun)
-              fs5.rmSync(copy.path, { force: true });
-          }
-        }
-        const nowMs = Date.now();
-        for (const directory of [this.recoveryDir, this.tasksDir, this.workitDir]) {
-          if (!fs5.existsSync(directory))
-            continue;
-          for (const name of fs5.readdirSync(directory)) {
-            if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
-              continue;
-            const file = path4.join(directory, name);
-            const stat = fs5.lstatSync(file);
-            if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
-              continue;
-            report.temporary.removed += 1;
-            if (!dryRun)
-              fs5.rmSync(file, { force: true });
-          }
-        }
-        return success(null, null, null);
-      } catch (error) {
-        return failure2("storage_error", `garbage collection failed: ${String(error)}`, {
-          path: this.recoveryDir
+        return acquireFileLockSync(lockPath, {
+          ...options,
+          timeoutMs: Math.max(0, deadline - Date.now())
         });
+      } catch (error) {
+        const code = error?.code;
+        if (code !== "file_lock_stale" && !isTransientWindowsError(error) || Date.now() >= deadline)
+          throw error;
+        if (code !== "file_lock_stale" && !this.lockHolderPresent(lockPath) && !this.lockDirWritable(lockPath))
+          throw error;
+        if (code !== "file_lock_stale")
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
       }
-    };
-    const pruned = dryRun ? sweep() : this.withLock(sweep);
-    if (!pruned.ok)
-      return pruned;
-    const tasks = this.listTasks();
-    if (!tasks.ok)
-      return tasks;
-    for (const task of tasks.data) {
-      const deduped = dedupeCandidates(task.candidates);
-      const removed = task.candidates.length - deduped.length;
-      if (removed === 0)
-        continue;
-      if (task.status === "active") {
-        report.candidates.skippedActive.push(task.id);
-        continue;
-      }
-      if (task.status === "closed") {
-        report.candidates.skippedClosed.push(task.id);
-        continue;
-      }
-      if (!dryRun) {
-        const written = this.mutateTask(task.id, task.revision, (current) => success(current.revision, null, {
-          ...current,
-          candidates: dedupeCandidates(current.candidates)
-        }));
-        if (!written.ok) {
-          report.candidates.failed.push(task.id);
-          continue;
-        }
-      }
-      report.candidates.removed += removed;
-      report.candidates.tasks.push(task.id);
     }
-    return success(null, null, report);
   }
-  findRecovery(target, taskId, digest, workspace) {
-    if (!fs5.existsSync(this.recoveryDir))
-      return null;
-    const workspaceId = workspace?.id ?? this.trustedWorkspaceId();
-    if (target === "workspace" && !workspaceId)
-      return null;
-    const candidates = this.recoveryCandidates();
-    if (!candidates.ok)
-      return null;
-    for (const candidate of candidates.data) {
-      if (candidate.target !== target || candidate.digest !== digest)
-        continue;
-      try {
-        if (!fs5.lstatSync(candidate.path).isFile())
-          continue;
-        const bytes = fs5.readFileSync(candidate.path);
-        if (digestBytes(bytes) !== digest)
-          continue;
-        if (target === "workspace") {
-          const parsed = this.parseBytes(bytes, workspaceRecordSchema);
-          if (parsed.ok && parsed.data.id === workspaceId && parsed.data.root === this.root)
-            return bytes;
-        } else {
-          const parsed = this.parseBytes(bytes, taskRecordSchema);
-          if (parsed.ok && parsed.data.id === taskId && parsed.data.workspaceId === workspace?.id)
-            return bytes;
-        }
-      } catch {}
+  withLock(lockPath, operation) {
+    try {
+      this.initializeStorage();
+      fs7.mkdirSync(path6.dirname(lockPath), { recursive: true });
+    } catch (error) {
+      return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
+        path: this.paths().dir
+      });
     }
-    return null;
-  }
-  fsyncDirectory(directory) {
+    let handle;
     try {
-      const fd = fs5.openSync(directory, "r");
-      try {
-        fs5.fsyncSync(fd);
-      } finally {
-        fs5.closeSync(fd);
-      }
+      handle = this.acquire(lockPath, this.lockOptions(lockPath));
     } catch (error) {
-      if (process.platform !== "win32")
-        throw error;
+      return this.lockFailure(lockPath, error);
     }
-  }
-  trustedWorkspaceId() {
-    if (!fs5.existsSync(this.tasksDir))
-      return null;
-    const ids = new Set;
+    hold(lockPath);
+    let result;
     try {
-      for (const name of fs5.readdirSync(this.tasksDir)) {
-        if (!name.endsWith(".json") || !validId(name.slice(0, -5)))
-          return null;
-        const parsed = this.parseBytes(fs5.readFileSync(path4.join(this.tasksDir, name)), taskRecordSchema);
-        if (!parsed.ok || parsed.data.id !== name.slice(0, -5))
-          return null;
-        ids.add(parsed.data.workspaceId);
+      if (!handle.verifyStillHeld())
+        result = failure2("recovery_required", "metadata lock was compromised", { path: lockPath });
+      else {
+        try {
+          result = operation();
+        } catch (error) {
+          result = failure2("storage_error", `mutation failed: ${String(error)}`);
+        }
       }
-    } catch {
-      return null;
+    } catch (error) {
+      result = this.lockFailure(lockPath, error);
+    }
+    drop(lockPath);
+    try {
+      retryTransient(() => handle.release());
+    } catch (error) {
+      const released = this.lockFailure(lockPath, error);
+      const releaseError = released.ok ? "metadata lock release failed" : released.error;
+      result = result.ok ? released : failure2("recovery_required", `${result.error}; ${releaseError}`, result.details);
     }
-    return ids.size === 1 ? [...ids][0] : null;
+    return result;
   }
-  snapshotBytes(file) {
+  lockDirWritable(lockPath) {
+    const probe = `${lockPath}.${process.pid}.${randomUUID3()}.probe`;
     try {
-      return retryTransient(() => fs5.readFileSync(file));
+      fs7.closeSync(fs7.openSync(probe, "wx", 384));
     } catch {
-      return null;
+      return false;
     }
+    try {
+      fs7.rmSync(probe, { force: true });
+    } catch {}
+    return true;
   }
-  readRecord(file, schema) {
+  lockHolderPresent(lockPath) {
     try {
-      const bytes = retryTransient(() => fs5.readFileSync(file, "utf8"));
-      return { exists: true, result: this.parseBytes(bytes, schema) };
+      fs7.lstatSync(lockPath);
+      return true;
     } catch (error) {
-      if (error?.code === "ENOENT")
-        return { exists: false, result: success(null, null, null) };
-      return {
-        exists: true,
-        result: failure2("recovery_required", `snapshot cannot be read: ${String(error)}`, {
-          path: file
-        })
-      };
+      return error?.code !== "ENOENT";
     }
   }
-  parseBytes(bytes, schema, mode = "read") {
-    let value;
-    try {
-      value = JSON.parse(typeof bytes === "string" ? bytes : bytes.toString("utf8"));
-    } catch {
-      return failure2("recovery_required", "snapshot JSON is corrupt");
+  lockFailure(lockPath, error) {
+    const value = error;
+    const code = typeof value?.code === "string" ? value.code : "";
+    if (isTransientWindowsError(error) && !this.lockHolderPresent(lockPath) && !this.lockDirWritable(lockPath))
+      return failure2("storage_error", `cannot create the workit lock (${code}); no other Workit call holds it`, {
+        path: lockPath,
+        guidance: `Check permissions and the read-only attribute on ${path6.dirname(lockPath)}.`
+      });
+    if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
+      let lock = null;
+      try {
+        lock = parseMetadataLockOrNull(fs7.readFileSync(lockPath, "utf8"));
+      } catch {}
+      if (lock?.externalAction)
+        return failure2("writer_conflict", "workspace is reserved by a managed external action", {
+          outcome: "not_started",
+          path: lockPath
+        });
+      return failure2("busy", `workit lock is held by another Workit call${lock ? ` (pid ${lock.pid} on ${lock.host})` : ""}; retry shortly`, {
+        outcome: "not_started",
+        path: lockPath,
+        guidance: "Retry the same call. If it stays busy, run `workit doctor --fix-lock` to clear a lock left by a dead process."
+      });
     }
-    if (isObject2(value) && "schemaVersion" in value && value.schemaVersion !== SCHEMA_VERSION)
-      return failure2("unsupported_version", "unsupported snapshot schema version");
-    const parsed = parseStoredRecord(schema, value);
-    if (parsed.success && (mode === "read" || parsed.stripped.length === 0))
-      return success(null, null, parsed.data);
-    const writerVersion = isObject2(value) && isObject2(value.runtime) ? value.runtime.updatedWith : null;
-    const upgrade = `upgrade Workit before ${parsed.success ? "recovering" : "mutating"} this checkout`;
-    if (parsed.success)
-      return failure2("recovery_required", `snapshot carries fields this Workit cannot preserve (${parsed.stripped.join(", ")}); ${upgrade}`);
-    if (parsed.critical.length > 0)
-      return failure2("recovery_required", `snapshot requires fields this Workit cannot read (${parsed.critical.join(", ")}); ${upgrade}`);
-    if (typeof writerVersion === "string" && isNewerVersion(writerVersion, runtimeVersion()))
-      return failure2("recovery_required", `snapshot was written by workit ${writerVersion}; upgrade Workit before mutating this checkout`);
-    return failure2("recovery_required", "snapshot does not satisfy its schema");
-  }
-  conflict(expected, actual) {
-    return failure2("revision_conflict", "snapshot revision does not match; omit expectedRevision to use the current record", {
-      expectedRevision: expected,
-      actualRevision: actual
-    });
-  }
-  workspaceConflict(expected, actual) {
-    return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
-  }
-  taskPath(taskId) {
-    return path4.join(this.tasksDir, `${taskId}.json`);
-  }
-  get workitDir() {
-    return path4.join(this.root, ".workit");
-  }
-  get tasksDir() {
-    return path4.join(this.workitDir, "tasks");
-  }
-  get recoveryDir() {
-    return path4.join(this.workitDir, "recovery");
-  }
-  get workspacePath() {
-    return path4.join(this.workitDir, "workspace.json");
-  }
-  get indexPath() {
-    return path4.join(this.workitDir, "index.json");
-  }
-  get lockPath() {
-    return path4.join(this.workitDir, "metadata.lock");
-  }
-  get gitignorePath() {
-    return path4.join(this.workitDir, ".gitignore");
+    const recovery = code === "metadata_lock_invalid" || code === "not-file" || /metadata lock|file lock|reclaim/i.test(String(value?.message ?? error));
+    return failure2(recovery ? "recovery_required" : "storage_error", `lock operation failed: ${String(error)}`, { path: lockPath });
   }
 }
 // packages/workit-core/src/core/workers.ts
@@ -20033,30 +21101,30 @@ function assertProductWriteAllowed(input) {
 }
 
 // packages/workit-core/src/core/task-evaluation.ts
-import { createHash as createHash7 } from "node:crypto";
-import * as fs10 from "node:fs";
-import { spawnSync as spawnSync5 } from "node:child_process";
-import path12 from "node:path";
+import { createHash as createHash9 } from "node:crypto";
+import * as fs12 from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import path14 from "node:path";
 
 // packages/workit-core/src/core/authority.ts
-import { createHash as createHash5 } from "node:crypto";
-import * as fs7 from "node:fs";
-import path9 from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import * as fs9 from "node:fs";
+import path11 from "node:path";
 
 // packages/workit-core/src/core/auto-approval.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { readFileSync as readFileSync4, realpathSync as realpathSync3 } from "node:fs";
-import path8 from "node:path";
+import path10 from "node:path";
 
 // packages/workit-core/src/core/workspaces.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path6 from "node:path";
+import path8 from "node:path";
 
 // packages/workit-core/src/core/config.ts
 import {
-  copyFileSync,
-  cpSync,
+  copyFileSync as copyFileSync2,
+  cpSync as cpSync2,
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
@@ -20064,7 +21132,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import os from "node:os";
-import path5 from "node:path";
+import path7 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 import { statSync as statSync2 } from "node:fs";
@@ -20123,7 +21191,7 @@ var mergePreset = (preset, input = {}, current = {
     protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
   };
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path5.join(process.env.XDG_CONFIG_HOME || path5.join(os.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path7.join(process.env.XDG_CONFIG_HOME || path7.join(os.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -20133,7 +21201,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path5.join(process.env.XDG_CONFIG_HOME || path5.join(os.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path7.join(process.env.XDG_CONFIG_HOME || path7.join(os.homedir(), ".config"), "workflow-toolkit");
   if (!existsSync3(legacy)) {
     migratedDir = dir;
     return dir;
@@ -20146,15 +21214,15 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync2(legacy, { withFileTypes: true })) {
-    const src = path5.join(legacy, entry.name);
-    const dest = path5.join(dir, entry.name);
+    const src = path7.join(legacy, entry.name);
+    const dest = path7.join(dir, entry.name);
     if (existsSync3(dest))
       continue;
     try {
       if (entry.isDirectory())
-        cpSync(src, dest, { recursive: true });
+        cpSync2(src, dest, { recursive: true });
       else if (entry.isFile())
-        copyFileSync(src, dest);
+        copyFileSync2(src, dest);
     } catch (err) {
       migrationFailed = true;
       diagnosticLogger?.warn(EVENT.migration, { from: src, ok: false, ...errorDetail(err) });
@@ -20219,7 +21287,7 @@ var parseConfigResult = (raw, file) => {
   };
 };
 var readConfigTyped = (dir) => {
-  const file = path5.join(dir ?? configDir(), "config.json");
+  const file = path7.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -20316,7 +21384,7 @@ var releaseTrackSchema = object2({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource.kind === "package-json" && (path6.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource.kind === "package-json" && (path8.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -20370,7 +21438,7 @@ var workspacesFileSchema = object2({ workspaces: array(workspaceConfigSchema).op
     names.add(workspace.name);
   }
 });
-var workspacesRevision = (contents) => createHash3("sha256").update(contents ?? "<missing>").digest("hex");
+var workspacesRevision = (contents) => createHash5("sha256").update(contents ?? "<missing>").digest("hex");
 var validateWorkspacesDocument = (parsed, file) => {
   if (!isConfigObject(parsed)) {
     return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
@@ -20408,7 +21476,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path6.join(dir, "workspaces.json");
+  const file = path8.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -20579,7 +21647,7 @@ var runtimeWorkspaceIndexSchema = object2({
   workspaces: array(object2({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
 var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
-  const file = path6.join(configDir(), "workspaces.json");
+  const file = path8.join(configDir(), "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -20710,13 +21778,13 @@ var gitContext = (workspaceRoot, paths = []) => {
 };
 
 // packages/workit-core/src/core/vcs-config.ts
-import fs6 from "node:fs";
-import path7 from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path7.join(configDir(), "vcs.json");
+import fs8 from "node:fs";
+import path9 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path9.join(configDir(), "vcs.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync2("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync3("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -20753,7 +21821,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync2("ssh", ["-G", host], {
+  const resolved = spawnSync3("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -20803,7 +21871,7 @@ var readVcsConfig = () => {
   const file = vcsConfigPath();
   let raw;
   try {
-    raw = fs6.readFileSync(file, "utf8");
+    raw = fs8.readFileSync(file, "utf8");
   } catch {
     return { status: "missing", path: file, config: {} };
   }
@@ -20869,7 +21937,7 @@ function vcsConfig(mode, cwd) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path7.resolve(cfgPath),
+    configPath: path9.resolve(cfgPath),
     provider,
     defaultTargetBranch: defaultTarget,
     pr: cfg.pr ?? {},
@@ -20904,7 +21972,7 @@ function vcsCliIdentity(cwd) {
     PATH: process.env.PATH ?? "",
     ...provider === "github" ? { GH_HOST: host } : { GITLAB_HOST: host }
   };
-  const result = spawnSync2(bin, ["api", "user"], {
+  const result = spawnSync3(bin, ["api", "user"], {
     cwd: root,
     encoding: "utf8",
     env
@@ -20946,7 +22014,7 @@ function mergedPrStyle(limit = 6, cwd) {
 `).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
     descriptionPreview: desc.slice(0, 600)
   });
-  const remoteResult = spawnSync2("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const remoteResult = spawnSync3("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -20962,7 +22030,7 @@ function mergedPrStyle(limit = 6, cwd) {
   if (!hostingApiHostMatches(remote, host))
     return { ok: false, error: "PR style target does not match the provider host" };
   if (provider === "gitlab") {
-    const run = (args) => spawnSync2("glab", ["api", ...args], {
+    const run = (args) => spawnSync3("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -20982,7 +22050,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync2("gh", [
+    const r = spawnSync3("gh", [
       "pr",
       "list",
       "--repo",
@@ -21054,7 +22122,7 @@ var operationAutoClass = (operation) => typeof operation === "string" ? OPERATIO
 var digestOf = (configDirPath) => {
   try {
     const raw = readFileSync4(`${configDirPath}/workspaces.json`, "utf8");
-    return createHash4("sha256").update(raw).digest("hex");
+    return createHash6("sha256").update(raw).digest("hex");
   } catch {
     return null;
   }
@@ -21098,7 +22166,7 @@ var targetOf = (root, descriptor) => {
     const cwd = parsed?.payload?.cwd;
     if (cwd === undefined)
       return root;
-    if (typeof cwd !== "string" || !path8.isAbsolute(cwd))
+    if (typeof cwd !== "string" || !path10.isAbsolute(cwd))
       return null;
     return realpathSync3(cwd);
   } catch {
@@ -21323,11 +22391,11 @@ function applicableDecision(task, purpose, binding, checkoutRoot) {
     return [];
   return task.decisions.filter((entry) => entry.provenance.kind !== "imported" && decisionMatches(entry, purpose, binding) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, entry.data.binding).ok : entry.data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map((entry) => entry.data);
 }
-var digestBytes2 = (bytes) => createHash5("sha256").update(bytes).digest("hex");
+var digestBytes = (bytes) => createHash7("sha256").update(bytes).digest("hex");
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs7.realpathSync(checkoutRoot);
+    root = fs9.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -21336,23 +22404,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path9.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path9.sep}`))
+    const target = path11.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path11.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const relative = path9.relative(root, target);
+      const relative = path11.relative(root, target);
       let current = root;
-      for (const segment of relative.split(path9.sep)) {
+      for (const segment of relative.split(path11.sep)) {
         if (!segment)
           continue;
-        current = path9.join(current, segment);
-        const stat = fs7.lstatSync(current);
-        const real = fs7.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path9.sep}`))
+        current = path11.join(current, segment);
+        const stat = fs9.lstatSync(current);
+        const real = fs9.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path11.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -21368,7 +22436,7 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         if (current !== target && !stat.isDirectory())
           return failure2("invalid_input", "document reference ancestor is not a directory");
       }
-      if (digestBytes2(fs7.readFileSync(target)) !== reference.digest)
+      if (digestBytes(fs9.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "approved document bytes have changed");
     } catch {
       return failure2("invalid_input", "approved document is unavailable");
@@ -21732,9 +22800,9 @@ var bindingCovers = scopeCovers;
 var verifyDecisionContent = verifyContentRefs;
 
 // packages/workit-core/src/check-config.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
-import fs8 from "node:fs";
-import path10 from "node:path";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import fs10 from "node:fs";
+import path12 from "node:path";
 var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
 var CHECKS_FILE = "workit.checks.json";
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -21776,7 +22844,7 @@ function splitCommand(command) {
   return argv.length ? argv : new Error("empty command");
 }
 var git = (cwd, args) => {
-  const run = spawnSync3("git", args, {
+  const run = spawnSync4("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 20000,
@@ -21787,10 +22855,10 @@ var git = (cwd, args) => {
   return value || null;
 };
 function checkRoot(cwd) {
-  return path10.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+  return path12.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
 }
 var packageManager = (root) => {
-  const has = (file) => fs8.existsSync(path10.join(root, file));
+  const has = (file) => fs10.existsSync(path12.join(root, file));
   if (has("bun.lock") || has("bun.lockb"))
     return "bun";
   if (has("pnpm-lock.yaml"))
@@ -21810,7 +22878,7 @@ var CHECK_NAME = /^[a-z0-9][a-z0-9:._-]{0,63}$/u;
 function detectedChecks(root) {
   const read = (file) => {
     try {
-      return fs8.readFileSync(path10.join(root, file), "utf8");
+      return fs10.readFileSync(path12.join(root, file), "utf8");
     } catch {
       return null;
     }
@@ -21849,7 +22917,7 @@ function detectedChecks(root) {
 var GATES = ["testing", "verification"];
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = path10.join(root, CHECKS_FILE);
+  const file = path12.join(root, CHECKS_FILE);
   const none = (error = null) => ({
     source: error ? CHECKS_FILE : "none",
     root,
@@ -21859,7 +22927,7 @@ function loadCheckConfig(cwd) {
   });
   let text = null;
   try {
-    text = fs8.readFileSync(file, "utf8");
+    text = fs10.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT")
       return none(`cannot read ${CHECKS_FILE}: ${error.message}`);
@@ -21922,10 +22990,10 @@ function workitAvailable(env = process.env) {
     return workitOnPath;
   const windows = process.platform === "win32";
   const exts = windows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-  const dirs = (env.PATH ?? env.Path ?? "").split(path10.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path12.delimiter).filter(Boolean);
   workitOnPath = dirs.some((dir) => exts.some((ext) => {
     try {
-      return fs8.statSync(path10.join(dir, `workit${ext}`)).isFile();
+      return fs10.statSync(path12.join(dir, `workit${ext}`)).isFile();
     } catch {
       return false;
     }
@@ -21937,15 +23005,15 @@ function checkCommand(args, version, onPath = workitAvailable()) {
 }
 
 // packages/workit-core/src/git/rev.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
-import fs9 from "node:fs";
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { createHash as createHash8 } from "node:crypto";
+import fs11 from "node:fs";
 import os2 from "node:os";
-import path11 from "node:path";
+import path13 from "node:path";
 var MAX_BUFFER = 256 * 1024 * 1024;
 var GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
 var git2 = (cwd, args, options = {}) => {
-  const result = spawnSync4("git", args, {
+  const result = spawnSync5("git", args, {
     cwd,
     encoding: "utf8",
     env: options.env ?? process.env,
@@ -21975,10 +23043,10 @@ function headSha(cwd) {
 var emptyTree = (cwd) => line(git2(cwd, ["mktree"], { input: "" }));
 var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
 var seedIndex = (from, to) => {
-  fs9.copyFileSync(from, to);
-  const { atimeNs, mtimeNs } = fs9.statSync(from, { bigint: true });
+  fs11.copyFileSync(from, to);
+  const { atimeNs, mtimeNs } = fs11.statSync(from, { bigint: true });
   const seconds = (ns) => (Number(ns / 1000n) - 1) / 1e6;
-  fs9.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
+  fs11.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
 };
 function worktreeTree(cwd, options = {}) {
   const top = line(git2(cwd, ["rev-parse", "--show-toplevel"]));
@@ -21987,10 +23055,10 @@ function worktreeTree(cwd, options = {}) {
     return null;
   const cap = options.maxUntrackedBytes ?? MAX_UNTRACKED_BYTES;
   const timeoutMs = options.timeoutMs ?? GIT_TIMEOUTS.worktree;
-  const scratch = fs9.mkdtempSync(path11.join(os2.tmpdir(), "workit-tree-"));
+  const scratch = fs11.mkdtempSync(path13.join(os2.tmpdir(), "workit-tree-"));
   try {
-    const tempIndex = path11.join(scratch, "index");
-    if (fs9.existsSync(indexPath))
+    const tempIndex = path13.join(scratch, "index");
+    if (fs11.existsSync(indexPath))
       seedIndex(indexPath, tempIndex);
     const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
     const untracked = git2(top, ["ls-files", "--others", "--exclude-standard", "-z"], {
@@ -22002,7 +23070,7 @@ function worktreeTree(cwd, options = {}) {
     const skipped = [];
     for (const file of untracked.stdout.split("\x00").filter(Boolean)) {
       try {
-        const stat = fs9.statSync(path11.join(top, file));
+        const stat = fs11.statSync(path13.join(top, file));
         if (stat.isFile() && stat.size > cap)
           skipped.push({ path: file, size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) });
       } catch {}
@@ -22019,10 +23087,10 @@ function worktreeTree(cwd, options = {}) {
     if (!tree)
       return null;
     const base = line(git2(top, ["rev-parse", "--verify", "-q", "HEAD^{tree}"])) ?? emptyTree(top);
-    const key = skipped.length ? `sha256:${createHash6("sha256").update(JSON.stringify({ tree, skipped })).digest("hex")}` : tree;
+    const key = skipped.length ? `sha256:${createHash8("sha256").update(JSON.stringify({ tree, skipped })).digest("hex")}` : tree;
     return { tree, key, dirty: tree !== base || skipped.length > 0, skipped };
   } finally {
-    fs9.rmSync(scratch, { recursive: true, force: true });
+    fs11.rmSync(scratch, { recursive: true, force: true });
   }
 }
 function worktreeSignal(cwd, options = {}) {
@@ -22042,16 +23110,16 @@ function worktreeSignal(cwd, options = {}) {
   });
   if (!status.ok)
     return null;
-  const hash = createHash6("sha256");
+  const hash = createHash8("sha256");
   hash.update(`${headSha(top) ?? "unborn"}\x00`);
   for (const entry of status.stdout.split("\x00")) {
     if (entry.length < 4)
       continue;
     const file = entry.slice(3);
-    const absolute = path11.join(top, file);
+    const absolute = path13.join(top, file);
     let stat = "-";
     try {
-      const info = fs9.lstatSync(absolute, { bigint: true });
+      const info = fs11.lstatSync(absolute, { bigint: true });
       stat = `${info.mode.toString(8)}:${info.size}:${info.mtimeNs}`;
       if (info.isDirectory())
         stat += `:${headSha(absolute) ?? "-"}`;
@@ -22062,15 +23130,15 @@ function worktreeSignal(cwd, options = {}) {
 }
 
 // packages/workit-core/src/core/task-evaluation.ts
-var digestBytes3 = (value) => createHash7("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path12.sep}`);
-var relative = (root, candidate) => path12.relative(root, candidate).split(path12.sep).join("/") || ".";
+var digestBytes2 = (value) => createHash9("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path14.sep}`);
+var relative = (root, candidate) => path14.relative(root, candidate).split(path14.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path12.posix.normalize(value);
+  const normalized = path14.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -22106,7 +23174,7 @@ var compareCodeUnits2 = (left, right) => {
   return left.length - right.length;
 };
 var gitPaths = (root) => {
-  const result = spawnSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync6("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -22118,21 +23186,21 @@ var gitPaths = (root) => {
       git: !/not a git repository/i.test(stderr)
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path12.sep).join("/")) : [];
-  const stagedDeleted = spawnSync5("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path14.sep).join("/")) : [];
+  const stagedDeleted = spawnSync6("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
       return { paths, uncertain: true, git: true };
   } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path12.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path14.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs10.readdirSync(directory);
+    names = fs12.readdirSync(directory);
   } catch {
     return true;
   }
@@ -22140,10 +23208,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path12.join(directory, name);
+    const target = path14.join(directory, name);
     let stat;
     try {
-      stat = fs10.lstatSync(target);
+      stat = fs12.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -22158,14 +23226,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path12.resolve(root, item);
+    const target = path14.resolve(root, item);
     if (!inside(root, target))
       return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
     let ancestor = target;
-    while (!fs10.existsSync(ancestor) && ancestor !== root)
-      ancestor = path12.dirname(ancestor);
+    while (!fs12.existsSync(ancestor) && ancestor !== root)
+      ancestor = path14.dirname(ancestor);
     try {
-      if (!inside(root, fs10.realpathSync(ancestor)))
+      if (!inside(root, fs12.realpathSync(ancestor)))
         return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
     } catch {
       return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
@@ -22177,7 +23245,7 @@ var scopeRoots = (root, scope) => {
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs10.realpathSync(root);
+    checkout = fs12.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -22195,11 +23263,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs10.existsSync(target))
+    if (!fs12.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs10.lstatSync(target);
+      stat = fs12.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -22215,17 +23283,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path12.join(checkout, item);
+    const target = path14.join(checkout, item);
     try {
-      const stat = fs10.lstatSync(target);
+      const stat = fs12.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs10.readlinkSync(target);
-        files.push({ path: item, kind: "symlink", digest: digestBytes3(link), executable: null });
+        const link = fs12.readlinkSync(target);
+        files.push({ path: item, kind: "symlink", digest: digestBytes2(link), executable: null });
       } else if (stat.isFile()) {
         files.push({
           path: item,
           kind: "file",
-          digest: digestBytes3(fs10.readFileSync(target)),
+          digest: digestBytes2(fs12.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -22250,7 +23318,7 @@ function captureCandidate(root, scope, environment = []) {
   const values = supplied.toSorted((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
   if (values.some(({ value }) => value === null))
     completeness = "uncertain";
-  const headResult = spawnSync5("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync6("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
   if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
     completeness = "uncertain";
   const head = headResult.status === 0 ? headResult.stdout.trim() : null;
@@ -23421,6 +24489,38 @@ var applyWorkerLifecycle = (input) => {
   return updated ? success(changed.data.task.revision, changed.data.workspace.revision, updated) : failure2("recovery_required", "worker disappeared during lifecycle observation");
 };
 var refsWithinScope = (refs, scope) => refs.every((ref) => ref.kind !== "file" || bindingCovers(scope, { description: "", paths: [ref.path], exclusions: [] }));
+var TASK_SCOPED_ACTIONS = new Set([
+  "task.inspect",
+  "task.revise",
+  "task.progress",
+  "task.pause",
+  "task.resume",
+  "task.close",
+  "policy.assess",
+  "policy.preview",
+  "policy.explain",
+  "evidence.record",
+  "finding.record",
+  "finding.resolve",
+  "decision.record",
+  "decision.revoke",
+  "worker.assign",
+  "worker.report",
+  "worker.cancel",
+  "writer.acquire",
+  "writer.release",
+  "state.export"
+]);
+var CREATING_ACTIONS = new Set([
+  "task.revise",
+  "task.progress",
+  "policy.assess",
+  "evidence.record",
+  "finding.record",
+  "decision.record",
+  "worker.assign",
+  "writer.acquire"
+]);
 var REVISION_RETRY_ATTEMPTS = 8;
 var retryPause = new Int32Array(new SharedArrayBuffer(4));
 var filledRevisions = (request) => {
@@ -23672,7 +24772,9 @@ class WorkitCore {
   }
   contextRootError() {
     try {
-      if (realpathSync6(this.context.root) !== this.store.root)
+      realpathSync6(this.context.root);
+      const root = checkoutRootOf(this.context.root);
+      if (root !== this.store.root && !sameDirectoryIdentity(root, this.store.root))
         return failure2("invalid_input", "operation context root does not match the task store root");
     } catch {
       return failure2("invalid_input", "operation context root cannot be resolved");
@@ -23694,6 +24796,30 @@ class WorkitCore {
   retryOmittedRevisions(request, run) {
     return retryFilledRevisions(filledRevisions(request), run);
   }
+  implicitTask(family, request) {
+    if (typeof request !== "object" || request === null || Array.isArray(request))
+      return success(null, null, request);
+    const value = request;
+    if (value.taskId !== undefined || typeof value.action !== "string")
+      return success(null, null, request);
+    const action = `${family}.${value.action}`;
+    if (!TASK_SCOPED_ACTIONS.has(action))
+      return success(null, null, request);
+    const root = this.contextRootError();
+    if (!root.ok)
+      return root;
+    const create = CREATING_ACTIONS.has(action) && (this.context.workerId ?? null) === null;
+    const found = this.store.implicitTask({
+      provenance: provenance(this.context),
+      create,
+      now: trustedNow(this.context)
+    });
+    if (!found.ok)
+      return found;
+    if (!found.data)
+      return failure2("not_found", 'no task for this branch yet; pass taskId, or record something first (`workit task start "<objective>"`, a note, a check) to create it');
+    return success(null, null, { ...request, taskId: found.data.task.id });
+  }
   helperEntry(task, requireSession = false, requireActive = false) {
     const workerId = this.context.workerId ?? null;
     if (workerId === null)
@@ -23725,7 +24851,11 @@ class WorkitCore {
     return null;
   }
   state(request) {
-    return request?.action === "import" ? this.retryOmittedRevisions(request, () => this.stateOnce(request)) : this.stateOnce(request);
+    const resolved = this.implicitTask("state", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return value?.action === "import" ? this.retryOmittedRevisions(value, () => this.stateOnce(value)) : this.stateOnce(value);
   }
   stateOnce(request) {
     const root = this.contextRootError();
@@ -23792,44 +24922,14 @@ class WorkitCore {
         return imported;
       return this.summary(imported.data);
     }
-    if (!this.context.nativeRecovery)
-      return failure2("permission_denied", "native recovery authority is unavailable");
-    const processEvidence = (lock, writer) => this.context.nativeRecovery({
-      lock,
-      writer,
-      reason: input.reason,
-      authorityRefs: input.authorityRefs
-    });
-    if (input.target === "workspace")
-      return this.store.recoverWorkspace({
-        expectedBytes: input.expectedBytes,
-        snapshotDigest: input.snapshotDigest,
-        reason: input.reason,
-        authorityRefs: input.authorityRefs,
-        expectedWorkspaceRevision: input.expectedWorkspaceRevision,
-        processEvidence
-      });
-    const workspace = this.store.readWorkspace();
-    if (!workspace.ok)
-      return workspace;
-    if (!workspace.data)
-      return failure2("not_found", "workspace not found");
-    this.fillRevisions(input, undefined, workspace.data);
-    if (input.target === "workspace" && input.taskId !== undefined)
-      return failure2("invalid_input", "workspace recovery takes no task ID");
-    if (input.target === "task" && input.taskId === undefined)
-      return failure2("invalid_input", "task recovery requires a task ID");
-    return this.store.recoverTask(input.taskId, {
-      expectedBytes: input.expectedBytes,
-      snapshotDigest: input.snapshotDigest,
-      reason: input.reason,
-      authorityRefs: input.authorityRefs,
-      expectedWorkspaceRevision: input.expectedWorkspaceRevision,
-      processEvidence
-    });
+    return failure2("invalid_input", "unknown state action");
   }
   task(request) {
-    return this.retryOmittedRevisions(request, () => this.taskOnce(request));
+    const resolved = this.implicitTask("task", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.taskOnce(value));
   }
   taskOnce(request) {
     const root = this.contextRootError();
@@ -23931,7 +25031,11 @@ class WorkitCore {
     }
   }
   policy(request) {
-    return this.retryOmittedRevisions(request, () => this.policyOnce(request));
+    const resolved = this.implicitTask("policy", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.policyOnce(value));
   }
   policyOnce(request) {
     const root = this.contextRootError();
@@ -23980,7 +25084,11 @@ class WorkitCore {
     return success(changed.data.revision, null, changed.data.policy);
   }
   evidence(request) {
-    return this.retryOmittedRevisions(request, () => this.evidenceOnce(request));
+    const resolved = this.implicitTask("evidence", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.evidenceOnce(value));
   }
   evidenceOnce(request) {
     const root = this.contextRootError();
@@ -24121,13 +25229,16 @@ class WorkitCore {
     return success(changed.data.revision, null, changed.data.evidence.at(-1));
   }
   decision(request) {
-    return this.recordDecision(request);
+    const resolved = this.implicitTask("decision", request);
+    return resolved.ok ? this.recordDecision(resolved.data) : resolved;
   }
   observeDecision(request, observation) {
-    return this.recordDecision(request, observation, true);
+    const resolved = this.implicitTask("decision", request);
+    return resolved.ok ? this.recordDecision(resolved.data, observation, true) : resolved;
   }
   observeStandingDecision(request) {
-    return this.recordDecision(request, undefined, true, true);
+    const resolved = this.implicitTask("decision", request);
+    return resolved.ok ? this.recordDecision(resolved.data, undefined, true, true) : resolved;
   }
   commitTask(taskId, expected, filled, recheck, update) {
     let revision = expected;
@@ -24289,7 +25400,11 @@ class WorkitCore {
     return entry ? success(changed.data.revision, null, entry) : failure2("recovery_required", "decision disappeared");
   }
   finding(request) {
-    return this.retryOmittedRevisions(request, () => this.findingOnce(request));
+    const resolved = this.implicitTask("finding", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.findingOnce(value));
   }
   findingOnce(request) {
     const root = this.contextRootError();
@@ -24415,7 +25530,11 @@ class WorkitCore {
     return entry ? success(changed.data.revision, null, entry) : failure2("recovery_required", "finding disappeared");
   }
   worker(request) {
-    return this.retryOmittedRevisions(request, () => this.workerOnce(request));
+    const resolved = this.implicitTask("worker", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.workerOnce(value));
   }
   workerOnce(request) {
     const root = this.contextRootError();
@@ -24765,7 +25884,11 @@ class WorkitCore {
     return applied;
   }
   writer(request) {
-    return this.retryOmittedRevisions(request, () => this.writerOnce(request));
+    const resolved = this.implicitTask("writer", request);
+    if (!resolved.ok)
+      return resolved;
+    const value = resolved.data;
+    return this.retryOmittedRevisions(value, () => this.writerOnce(value));
   }
   writerOnce(request) {
     const root = this.contextRootError();
@@ -25401,22 +26524,22 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync7(root);
-  const target = path13.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path13.sep)) {
+  const target = path15.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path15.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync5(ancestor))
-    ancestor = path13.dirname(ancestor);
+    ancestor = path15.dirname(ancestor);
   const canonicalAncestor = realpathSync7(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path13.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path15.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync7(root);
-  const result = spawnSync6(executable, args, {
+  const result = spawnSync7(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -25487,9 +26610,9 @@ var applyPatterns = (value) => {
 var redactSecrets = (value) => applyPatterns(value);
 
 // packages/workit-core/src/core/pr-create.ts
-import fs11 from "node:fs";
-import path14 from "node:path";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import fs13 from "node:fs";
+import path16 from "node:path";
+import { spawnSync as spawnSync8 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
@@ -25499,13 +26622,13 @@ function parseGhIssue(value) {
 // packages/workit-core/src/core/pr-create.ts
 function whichOnPath(tool) {
   const names = process.platform === "win32" ? [tool, `${tool}.exe`, `${tool}.cmd`] : [tool];
-  for (const dir of (process.env.PATH ?? "").split(path14.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path16.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path14.join(dir, name);
+      const candidate = path16.join(dir, name);
       try {
-        fs11.accessSync(candidate, fs11.constants.X_OK);
+        fs13.accessSync(candidate, fs13.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -25514,7 +26637,7 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 var pushRemote = (cwd) => {
-  const result = spawnSync7("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync8("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -25525,9 +26648,9 @@ var pushRemote = (cwd) => {
 };
 
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -25554,7 +26677,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync8("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync9("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -25661,7 +26784,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path15.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path17.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -25692,7 +26815,7 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path15.join(cwd, "package.json");
+  const pkgPath = path17.join(cwd, "package.json");
   if (!existsSync6(pkgPath))
     return [];
   try {
@@ -25718,9 +26841,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path15.join(dir, entry.name), depth + 1);
+        walk(path17.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path15.relative(cwd, path15.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path17.relative(cwd, path17.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -25736,7 +26859,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path15.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -25794,7 +26917,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed2(path15.join(cwd, template), 220);
+    stdout += readTrimmed2(path17.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -25804,7 +26927,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync6(path15.join(cwd, "package.json"))) {
+  if (existsSync6(path17.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -25813,7 +26936,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync6(path15.join(cwd, "Cargo.toml")) || existsSync6(path15.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync6(path17.join(cwd, "Cargo.toml")) || existsSync6(path17.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -25846,7 +26969,7 @@ var CHANGELOG_RULES = `- Use an [Unreleased] section.
 - Apply with the host-native editor, preserving the repository changelog conventions.
 - If Unreleased already has duplicate category headings, normalize_only first.`;
 function changelogContext(root, range) {
-  const cwd = path15.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -25864,7 +26987,7 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path15.join(cwd, "CHANGELOG.md");
+  const changelogPath = path17.join(cwd, "CHANGELOG.md");
   if (existsSync6(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
@@ -25884,7 +27007,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path15.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -25906,7 +27029,7 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path15.join(cwd, "README.md");
+  const readme = path17.join(cwd, "README.md");
   if (existsSync6(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
@@ -25915,7 +27038,7 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path15.join(cwd, "package.json");
+  const pkgPath = path17.join(cwd, "package.json");
   if (existsSync6(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
@@ -25929,7 +27052,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path15.resolve(repoRoot(root));
+  const cwd = path17.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -25967,7 +27090,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync6(path15.join(cwd, rel)))
+    if (existsSync6(path17.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -25995,7 +27118,7 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 var repoPathFromRemote = (remote) => {
   let rest = (remote || "").trim().replace(/\/+$/, "");
   if (!rest)
@@ -26016,7 +27139,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync9(bin, args, {
+    const out = spawnSync10(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -26094,8 +27217,8 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 
 // packages/workit-core/src/core/youtrack.ts
-import fs12 from "node:fs";
-import path16 from "node:path";
+import fs14 from "node:fs";
+import path18 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -26108,22 +27231,22 @@ var resolveWorkspaceRoot = (explicit) => explicit || process.cwd();
 // packages/workit-core/src/core/youtrack.ts
 var ISSUE_RE = /^[A-Z]+-\d+$/;
 var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path16.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path16.join(resolveConfigDir(), "youtrack.json");
+var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path18.join(configDir(), "youtrack.json");
+var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path18.join(resolveConfigDir(), "youtrack.json");
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs12.statSync(p).mode & 511;
+  const mode = fs14.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs12.existsSync(cfgPath)) {
+  if (!fs14.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs12.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -26134,11 +27257,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs12.existsSync(cfgPath))
+  if (!fs14.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs12.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -26177,12 +27300,12 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path16.isAbsolute(tokenFile) ? path16.resolve(tokenFile) : path16.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs12.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path18.isAbsolute(tokenFile) ? path18.resolve(tokenFile) : path18.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs14.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs12.readFileSync(tokenPath, "utf8").trim();
+  const token = fs14.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -26247,9 +27370,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs12.existsSync(full))
+    if (!fs14.existsSync(full))
       continue;
-    const text = fs12.readFileSync(full, "utf8");
+    const text = fs14.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -26543,13 +27666,13 @@ var rootVariants = (workspaceRoot) => {
   if (!workspaceRoot)
     return [];
   const roots = new Set;
-  for (const candidate of [workspaceRoot, path17.resolve(workspaceRoot)]) {
-    if (path17.isAbsolute(candidate) && candidate !== path17.parse(candidate).root)
+  for (const candidate of [workspaceRoot, path19.resolve(workspaceRoot)]) {
+    if (path19.isAbsolute(candidate) && candidate !== path19.parse(candidate).root)
       roots.add(candidate);
   }
   try {
     const canonical = realpathSync8(workspaceRoot);
-    if (canonical !== path17.parse(canonical).root)
+    if (canonical !== path19.parse(canonical).root)
       roots.add(canonical);
   } catch {}
   return [...roots].toSorted((left, right) => right.length - left.length);
@@ -26650,11 +27773,11 @@ var thrownResult = (tool, error, workspaceRoot) => {
 };
 function createMcpServer(host, contextProvider) {
   assertMcpHost(host);
-  const here = path17.dirname(fileURLToPath2(import.meta.url));
+  const here = path19.dirname(fileURLToPath2(import.meta.url));
   const sourceMarker = markSourcesLoaded([
-    path17.join(here, "server.ts"),
-    path17.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
-    path17.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
+    path19.join(here, "server.ts"),
+    path19.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
+    path19.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
   ].filter((file) => existsSync7(file)));
   let staleWarned = false;
   const server = new Server({ name: "workit", version: VERSION }, { capabilities: { tools: {}, resources: {} } });
@@ -26834,8 +27957,8 @@ var main = async () => {
     process.exitCode = 2;
   }
 };
-var entryPath = process.argv[1] ? path18.resolve(process.argv[1]) : "";
-if (entryPath === path18.resolve(fileURLToPath3(import.meta.url)))
+var entryPath = process.argv[1] ? path20.resolve(process.argv[1]) : "";
+if (entryPath === path20.resolve(fileURLToPath3(import.meta.url)))
   await main();
 export {
   McpCapabilityUnavailableError,