@brainervirus/workit-codex 2.6.0 → 2.7.0

package/dist/launch-mcp.js

@@ -6622,12 +6622,12 @@ var require_dist = __commonJS(function(exports, module) {
 
 // packages/workit-codex/scripts/launch-mcp.ts
 import { existsSync as existsSync8, realpathSync as realpathSync9, statSync as statSync3 } from "node:fs";
-import path16 from "node:path";
+import path18 from "node:path";
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync5, realpathSync as realpathSync7 } from "node:fs";
-import path11 from "node:path";
+import path13 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -14803,7 +14803,37 @@ var candidateSchema = object({
       path: ["id"]
     });
 });
-var evidenceSchema = object({
+var checkObservationSchema = object({
+  observer: literal("workit_cli"),
+  name: nonEmpty.nullable(),
+  configured: boolean2(),
+  argv: array(text).min(1),
+  shell: boolean2(),
+  cwd: nonEmpty,
+  exitCode: safeInteger,
+  durationMs: safeInteger.min(0),
+  timedOut: boolean2(),
+  head: text.nullable(),
+  tree: text.nullable(),
+  dirty: boolean2().nullable(),
+  signal: text.nullable(),
+  treeAfter: text.nullable(),
+  modifiedWorktree: boolean2(),
+  base: text.nullable(),
+  patchId: text.nullable(),
+  environment: object({
+    platform: nonEmpty,
+    arch: nonEmpty,
+    vars: record(nonEmpty, text.nullable())
+  }).strict(),
+  logDigest: text.nullable(),
+  logRef: text.nullable(),
+  logTail: array(text).max(40),
+  ledgerRowId: text.nullable(),
+  attestation: object({ host: nonEmpty, session: text.nullable(), agentId: text.nullable() }).strict().nullable()
+}).strict();
+var CHECK_OBSERVATION_PATH = "evidence.*.data.observation";
+var evidenceFields = {
   kind: _enum(["check", "review", "investigation", "artifact"]),
   claim: text,
   requirementIds: array(digest),
@@ -14814,7 +14844,9 @@ var evidenceSchema = object({
   refs: array(refSchema),
   exitCode: safeInteger.nullable(),
   reviewContext: refSchema.nullable()
-}).strict();
+};
+var evidenceSchema = object({ ...evidenceFields, observation: checkObservationSchema.optional() }).strict();
+var reportedEvidenceSchema = object(evidenceFields).strict();
 var evidenceEvaluationSchema = object({
   evidenceId: id,
   status: _enum(["passed", "failed", "missing", "skipped", "stale"]),
@@ -15125,7 +15157,7 @@ var evidenceOperations = {
     action: literal("record"),
     ...taskId,
     expectedRevision: revision.optional(),
-    evidence: evidenceSchema
+    evidence: reportedEvidenceSchema
   })
 };
 var findingOperations = {
@@ -17625,10 +17657,10 @@ function assertProductWriteAllowed(input) {
 }
 
 // packages/workit-core/src/core/task-evaluation.ts
-import { createHash as createHash6 } from "node:crypto";
-import * as fs8 from "node:fs";
-import { spawnSync as spawnSync3 } from "node:child_process";
-import path10 from "node:path";
+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";
 
 // packages/workit-core/src/core/authority.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -19323,16 +19355,346 @@ function reconcileAction(input) {
 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";
+var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
+var CHECKS_FILE = "workit.checks.json";
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var SHELL_META = /[|&;<>()$`\\*?[\]{}~!#]/u;
+function splitCommand(command) {
+  const argv = [];
+  let current = "";
+  let quote = null;
+  let started = false;
+  for (const char of command) {
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      else
+        current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      started = true;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      if (started)
+        argv.push(current);
+      current = "";
+      started = false;
+      continue;
+    }
+    if (SHELL_META.test(char))
+      return new Error(`"${command}" uses shell syntax (${char}); configure an argv array instead`);
+    current += char;
+    started = true;
+  }
+  if (quote)
+    return new Error(`"${command}" has an unterminated quote`);
+  if (started)
+    argv.push(current);
+  return argv.length ? argv : new Error("empty command");
+}
+var git = (cwd, args) => {
+  const run = spawnSync3("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 20000,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  const value = run.status === 0 ? (run.stdout ?? "").trim() : "";
+  return value || null;
+};
+function checkRoot(cwd) {
+  return path10.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+}
+var packageManager = (root) => {
+  const has = (file) => fs8.existsSync(path10.join(root, file));
+  if (has("bun.lock") || has("bun.lockb"))
+    return "bun";
+  if (has("pnpm-lock.yaml"))
+    return "pnpm";
+  if (has("yarn.lock"))
+    return "yarn";
+  return "npm";
+};
+var scriptCheck = (pm, name) => {
+  const argv = [pm, "run", name];
+  const accepts = [argv];
+  if (pm === "pnpm" || pm === "yarn" || pm === "npm" && name === "test")
+    accepts.push([pm, name]);
+  return { name, argv, accepts };
+};
+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");
+    } catch {
+      return null;
+    }
+  };
+  const checks = [];
+  const add = (check) => {
+    if (!checks.some((item) => item.name === check.name))
+      checks.push(check);
+  };
+  const manifestText = read("package.json");
+  if (manifestText !== null) {
+    let manifest = null;
+    try {
+      manifest = JSON.parse(manifestText);
+    } catch {}
+    const scripts = isRecord2(manifest) && isRecord2(manifest.scripts) ? manifest.scripts : {};
+    const pm = packageManager(root);
+    for (const name of SCRIPT_CHECKS) {
+      const script = scripts[name];
+      if (typeof script === "string" && script.trim() !== "")
+        add(scriptCheck(pm, name));
+    }
+  }
+  const plain = (name, argv) => ({ name, argv, accepts: [argv] });
+  if (read("go.mod") !== null)
+    add(plain("test", ["go", "test", "./..."]));
+  if (read("Cargo.toml") !== null)
+    add(plain("test", ["cargo", "test"]));
+  if (read("pytest.ini") !== null || /\bpytest\b/u.test(read("pyproject.toml") ?? ""))
+    add(plain("test", ["pytest"]));
+  const makefile = read("Makefile") ?? read("makefile") ?? read("GNUmakefile");
+  if (makefile !== null && /^test\s*:(?!=)/mu.test(makefile))
+    add(plain("test", ["make", "test"]));
+  return checks;
+}
+var GATES = ["testing", "verification"];
+function loadCheckConfig(cwd) {
+  const root = checkRoot(cwd);
+  const file = path10.join(root, CHECKS_FILE);
+  const none = (error = null) => ({
+    source: error ? CHECKS_FILE : "none",
+    root,
+    checks: [],
+    gates: {},
+    error
+  });
+  let text = null;
+  try {
+    text = fs8.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      return none(`cannot read ${CHECKS_FILE}: ${error.message}`);
+  }
+  if (text === null) {
+    const checks = detectedChecks(root);
+    return checks.length ? { source: "defaults", root, checks, gates: {}, error: null } : none();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return none(`${CHECKS_FILE} is not valid JSON`);
+  }
+  if (!isRecord2(parsed) || !isRecord2(parsed.checks))
+    return none(`${CHECKS_FILE} must be {"checks":{"<name>":"<command>"|["argv",…]}}`);
+  const checks = [];
+  for (const [name, value] of Object.entries(parsed.checks)) {
+    if (!CHECK_NAME.test(name))
+      return none(`${CHECKS_FILE}: check name "${name}" must match ${CHECK_NAME.source}`);
+    const argv = typeof value === "string" ? splitCommand(value) : Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.length > 0) ? value : new Error("expected a command string or a non-empty argv array");
+    if (argv instanceof Error)
+      return none(`${CHECKS_FILE}: check "${name}": ${argv.message}`);
+    checks.push({ name, argv, accepts: [argv] });
+  }
+  const gates = {};
+  if (parsed.gates !== undefined) {
+    if (!isRecord2(parsed.gates))
+      return none(`${CHECKS_FILE}: gates must be {"testing":"<name>"|["<name>",…]}`);
+    for (const [gate, value] of Object.entries(parsed.gates)) {
+      if (!GATES.includes(gate))
+        return none(`${CHECKS_FILE}: unknown gate "${gate}" (use ${GATES.join(" or ")})`);
+      const names = typeof value === "string" ? [value] : value;
+      if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string" && checks.some((c) => c.name === name)))
+        return none(`${CHECKS_FILE}: gates.${gate} must name configured checks`);
+      gates[gate] = names;
+    }
+  }
+  return { source: CHECKS_FILE, root, checks, gates, error: null };
+}
+var sameArgv = (left, right) => left.length === right.length && left.every((item, index) => item === right[index]);
+function matchesNamedCheck(config, name, argv, cwd) {
+  if (config.error || name === null || cwd !== ".")
+    return false;
+  const check = config.checks.find((item) => item.name === name);
+  return Boolean(check?.accepts.some((accepted) => sameArgv(accepted, argv)));
+}
+function gateCheckNames(config, dimension) {
+  const explicit = config.gates[dimension];
+  if (explicit)
+    return explicit;
+  const names = config.checks.map((check) => check.name);
+  if (dimension === "testing")
+    return names.includes("test") ? ["test"] : [];
+  return names;
+}
+var workitOnPath;
+function workitAvailable(env = process.env) {
+  if (workitOnPath !== undefined)
+    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);
+  workitOnPath = dirs.some((dir) => exts.some((ext) => {
+    try {
+      return fs8.statSync(path10.join(dir, `workit${ext}`)).isFile();
+    } catch {
+      return false;
+    }
+  }));
+  return workitOnPath;
+}
+function checkCommand(args, version, onPath = workitAvailable()) {
+  return onPath ? `workit check ${args}` : `npx -y @brainervirus/workit-cli@${version} check ${args}`;
+}
+
+// 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 os2 from "node:os";
+import path11 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, {
+    cwd,
+    encoding: "utf8",
+    env: options.env ?? process.env,
+    input: options.input,
+    maxBuffer: MAX_BUFFER,
+    timeout: options.timeoutMs ?? GIT_TIMEOUTS.local,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  const error = result.error;
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut: error?.code === "ETIMEDOUT"
+  };
+};
+var line = (run) => {
+  if (!run.ok)
+    return null;
+  const value = run.stdout.trim();
+  return value ? value : null;
+};
+function headSha(cwd) {
+  return line(git2(cwd, ["rev-parse", "--verify", "-q", "HEAD^{commit}"]));
+}
+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 });
+  const seconds = (ns) => (Number(ns / 1000n) - 1) / 1e6;
+  fs9.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
+};
+function worktreeTree(cwd, options = {}) {
+  const top = line(git2(cwd, ["rev-parse", "--show-toplevel"]));
+  const indexPath = line(git2(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "index"]));
+  if (!top || !indexPath)
+    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-"));
+  try {
+    const tempIndex = path11.join(scratch, "index");
+    if (fs9.existsSync(indexPath))
+      seedIndex(indexPath, tempIndex);
+    const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
+    const untracked = git2(top, ["ls-files", "--others", "--exclude-standard", "-z"], {
+      env,
+      timeoutMs
+    });
+    if (!untracked.ok)
+      return null;
+    const skipped = [];
+    for (const file of untracked.stdout.split("\x00").filter(Boolean)) {
+      try {
+        const stat = fs9.statSync(path11.join(top, file));
+        if (stat.isFile() && stat.size > cap)
+          skipped.push({ path: file, size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) });
+      } catch {}
+    }
+    skipped.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    const added = skipped.length ? git2(top, ["add", "-A", "--pathspec-from-file=-", "--pathspec-file-nul"], {
+      env,
+      timeoutMs,
+      input: [".", ...skipped.map((file) => `:(exclude,literal)${file.path}`)].join("\x00")
+    }) : git2(top, ["add", "-A"], { env, timeoutMs });
+    if (!added.ok)
+      return null;
+    const tree = line(git2(top, ["write-tree"], { env, timeoutMs }));
+    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;
+    return { tree, key, dirty: tree !== base || skipped.length > 0, skipped };
+  } finally {
+    fs9.rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function worktreeSignal(cwd, options = {}) {
+  const top = line(git2(cwd, ["rev-parse", "--show-toplevel"]));
+  if (!top)
+    return null;
+  const status = git2(top, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--no-renames",
+    "--ignore-submodules=dirty"
+  ], {
+    env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+    timeoutMs: options.timeoutMs ?? GIT_TIMEOUTS.worktree
+  });
+  if (!status.ok)
+    return null;
+  const hash = createHash6("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);
+    let stat = "-";
+    try {
+      const info = fs9.lstatSync(absolute, { bigint: true });
+      stat = `${info.mode.toString(8)}:${info.size}:${info.mtimeNs}`;
+      if (info.isDirectory())
+        stat += `:${headSha(absolute) ?? "-"}`;
+    } catch {}
+    hash.update(`${entry.slice(0, 2)}\x00${file}\x00${stat}\x00`);
+  }
+  return `sig:${hash.digest("hex")}`;
+}
+
 // packages/workit-core/src/core/task-evaluation.ts
-var digestBytes3 = (value) => createHash6("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path10.sep}`);
-var relative = (root, candidate) => path10.relative(root, candidate).split(path10.sep).join("/") || ".";
+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 canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path10.posix.normalize(value);
+  const normalized = path12.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -19368,7 +19730,7 @@ var compareCodeUnits2 = (left, right) => {
   return left.length - right.length;
 };
 var gitPaths = (root) => {
-  const result = spawnSync3("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync5("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -19380,21 +19742,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(path10.sep).join("/")) : [];
-  const stagedDeleted = spawnSync3("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(path12.sep).join("/")) : [];
+  const stagedDeleted = spawnSync5("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(path10.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path12.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs8.readdirSync(directory);
+    names = fs10.readdirSync(directory);
   } catch {
     return true;
   }
@@ -19402,10 +19764,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path10.join(directory, name);
+    const target = path12.join(directory, name);
     let stat;
     try {
-      stat = fs8.lstatSync(target);
+      stat = fs10.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -19420,14 +19782,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path10.resolve(root, item);
+    const target = path12.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 (!fs8.existsSync(ancestor) && ancestor !== root)
-      ancestor = path10.dirname(ancestor);
+    while (!fs10.existsSync(ancestor) && ancestor !== root)
+      ancestor = path12.dirname(ancestor);
     try {
-      if (!inside(root, fs8.realpathSync(ancestor)))
+      if (!inside(root, fs10.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}`);
@@ -19439,7 +19801,7 @@ var scopeRoots = (root, scope) => {
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs8.realpathSync(root);
+    checkout = fs10.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -19457,11 +19819,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs8.existsSync(target))
+    if (!fs10.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs8.lstatSync(target);
+      stat = fs10.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -19477,17 +19839,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path10.join(checkout, item);
+    const target = path12.join(checkout, item);
     try {
-      const stat = fs8.lstatSync(target);
+      const stat = fs10.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs8.readlinkSync(target);
+        const link = fs10.readlinkSync(target);
         files.push({ path: item, kind: "symlink", digest: digestBytes3(link), executable: null });
       } else if (stat.isFile()) {
         files.push({
           path: item,
           kind: "file",
-          digest: digestBytes3(fs8.readFileSync(target)),
+          digest: digestBytes3(fs10.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -19512,7 +19874,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 = spawnSync3("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync5("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;
@@ -19550,7 +19912,24 @@ var sameSession = (left, right) => {
   return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
 };
 var evidenceScopes = (task, ids) => (task.policy?.requirements ?? []).filter((requirement) => ids.includes(requirement.id)).map((requirement) => requirement.scope);
-function evaluateEvidence(task, candidate) {
+var memo2 = (compute) => {
+  let value;
+  return () => {
+    if (value === undefined)
+      value = compute();
+    return value;
+  };
+};
+var treeFreshness = (root) => ({
+  mode: "tree",
+  current: memo2(() => worktreeTree(root)?.key ?? null)
+});
+var signalFreshness = (root) => ({
+  mode: "signal",
+  current: memo2(() => worktreeSignal(root))
+});
+var isObservedCheck = (entry) => entry.data.kind === "check" && entry.data.observation?.observer === "workit_cli" && entry.provenance?.kind === "host_observed" && entry.provenance.host === "workit_cli";
+function evaluateEvidence(task, candidate, freshness) {
   const current = candidate ?? task.candidates.at(-1) ?? null;
   return task.evidence.map((entry) => {
     const evidence = entry.data;
@@ -19560,6 +19939,25 @@ function evaluateEvidence(task, candidate) {
         status: "failed",
         reason: "failed evidence remains historical"
       };
+    const observation = isObservedCheck(entry) ? evidence.observation : undefined;
+    if (observation && observation.tree !== null) {
+      if (task.status === "closed")
+        return { evidenceId: entry.id, status: evidence.result, reason: "recorded before close" };
+      if (observation.modifiedWorktree)
+        return {
+          evidenceId: entry.id,
+          status: "stale",
+          reason: "the check changed the worktree while it ran; ignore or clean its outputs"
+        };
+      const recorded = freshness?.mode === "signal" ? observation.signal : observation.tree;
+      if (recorded !== null && freshness && recorded === freshness.current())
+        return { evidenceId: entry.id, status: evidence.result, reason: "worktree is unchanged" };
+      return {
+        evidenceId: entry.id,
+        status: "stale",
+        reason: freshness?.mode === "signal" ? "the worktree may have changed since the check ran (quick signal; inspect re-checks exactly)" : "the worktree changed since the check ran"
+      };
+    }
     if (evidence.kind === "check" || evidence.kind === "review") {
       if (!evidence.beforeCandidateId || !evidence.candidateId)
         return {
@@ -19643,8 +20041,45 @@ var expectedKinds = (dimension, ruleId) => {
     return "decision";
   return "worker report";
 };
-function evaluateRequirements(task, workspace, capabilities, candidate, checkoutRoot, _caller) {
-  const evidence = evaluateEvidence(task, candidate);
+var observedGate = (requirement) => (requirement.dimension === "testing" || requirement.dimension === "verification") && requirement.before === "close";
+function evaluateObservedGate(task, requirement, statuses, config) {
+  const names = gateCheckNames(config, requirement.dimension);
+  const observed = task.evidence.filter(isObservedCheck);
+  const fresh = observed.filter((entry) => statuses.get(entry.id) === "passed" && entry.data.observation?.exitCode === 0);
+  const named = (entry) => {
+    const observation = entry.data.observation;
+    return observation.configured && !observation.shell && names.includes(observation.name ?? "") && matchesNamedCheck(config, observation.name, observation.argv, observation.cwd);
+  };
+  const considered = observed.map((entry) => entry.id);
+  const run = checkCommand(names[0] ?? "<name>", runtimeVersion());
+  if (config.error)
+    return {
+      satisfied: [],
+      considered,
+      reason: `check config is invalid (${config.error}); fix it, then run ${run}`
+    };
+  if (!names.length)
+    return {
+      satisfied: [],
+      considered,
+      reason: requirement.dimension === "testing" && config.checks.length ? `no \`test\` check is configured; add one (or gates.testing) to ${CHECKS_FILE}, then run ${checkCommand("test", runtimeVersion())}` : `no checks are configured or detected; add ${CHECKS_FILE} (committed, so it shows in the diff), e.g. {"checks":{"test":"<your test command>"}}, then run ${checkCommand("test", runtimeVersion())}`
+    };
+  const satisfied = fresh.filter(named);
+  if (satisfied.length)
+    return {
+      satisfied: satisfied.map((entry) => entry.id),
+      considered,
+      reason: `a fresh passing configured check (${names.join("|")}) was observed by workit check`
+    };
+  const reported = task.evidence.some((entry) => entry.data.kind === "check" && !isObservedCheck(entry) && entry.data.requirementIds.includes(requirement.id));
+  const reason = fresh.length ? `ad-hoc checks do not satisfy a configured gate; run ${run}` : observed.some((entry) => statuses.get(entry.id) === "stale") ? `observed checks are stale (the worktree changed); run ${run}` : observed.some((entry) => statuses.get(entry.id) === "failed") ? `the observed check failed; fix it and run ${run}` : reported ? `agent-reported checks are notes, not evidence; run ${run}` : `no CLI-observed check (needs kind:check observed by workit check); run ${run}`;
+  return { satisfied: [], considered, reason };
+}
+function evaluateRequirements(task, workspace, capabilities, candidate, checkoutRoot, _caller, freshness = treeFreshness(checkoutRoot)) {
+  const evidence = evaluateEvidence(task, candidate, freshness);
+  const statuses = new Map(evidence.map((item) => [item.evidenceId, item.status]));
+  let checkConfig;
+  const configFor = () => checkConfig ??= loadCheckConfig(checkoutRoot);
   if (task.policy && task.policy.policyVersion !== POLICY_VERSION)
     return task.policy.requirements.map((requirement) => ({
       requirementId: requirement.id,
@@ -19654,8 +20089,19 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
       reason: "stored policy version is unsupported; reassessment is required"
     }));
   return (task.policy?.requirements ?? []).map((requirement) => {
+    const gate = observedGate(requirement) ? evaluateObservedGate(task, requirement, statuses, configFor()) : null;
+    if (gate?.satisfied.length)
+      return {
+        requirementId: requirement.id,
+        status: "satisfied",
+        evidenceIds: gate.satisfied,
+        decisionIds: [],
+        reason: gate.reason
+      };
     const related = task.evidence.map((entry, index) => ({ entry, evaluation: evidence[index] })).filter(({ entry }) => entry.data.requirementIds.includes(requirement.id));
     const passed = related.filter(({ entry, evaluation }) => {
+      if (gate)
+        return false;
       if (!evidenceMatchesRequirement(evaluation.status, entry.data.kind, requirement.dimension, requirement.ruleId))
         return false;
       if ((entry.data.kind === "check" || entry.data.kind === "review") && (!entry.data.beforeCandidateId || !entry.data.candidateId || entry.data.beforeCandidateId !== entry.data.candidateId))
@@ -19718,6 +20164,14 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
         reason: "an applicable approved limitation permits the missing evidence"
       };
     const unavailable = capabilities.some((capability) => capability.assurance === "unavailable" && (capability.name === requirement.dimension || capability.surface === requirement.dimension));
+    if (gate)
+      return {
+        requirementId: requirement.id,
+        status: unavailable ? "unavailable" : "unsatisfied",
+        evidenceIds: [...new Set([...gate.considered, ...related.map(({ entry }) => entry.id)])],
+        decisionIds: [],
+        reason: unavailable ? "required capability is unavailable" : gate.reason
+      };
     if (!unavailable && related.length > 0 && !passed.length)
       return {
         requirementId: requirement.id,
@@ -19870,7 +20324,7 @@ function reconcileResume(view, observations = []) {
   const candidate = captureCandidate(view.workspace.root, view.task.intent.data.scope, []);
   if (!candidate.ok)
     return candidate;
-  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
+  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data, treeFreshness(view.workspace.root)).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
   const blockers = [...view.task.progress.blockers];
   if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
     blockers.push({
@@ -21210,10 +21664,7 @@ class WorkitCore {
           if (finding.data.disposition !== "fixed")
             return finding;
           const withEntry = { ...current, candidates, evidence: [...current.evidence, entry] };
-          const statuses = new Map(evaluateEvidence(withEntry, currentCandidate.data).map((item) => [
-            item.evidenceId,
-            item.status
-          ]));
+          const statuses = new Map(evaluateEvidence(withEntry, currentCandidate.data, treeFreshness(this.store.root)).map((item) => [item.evidenceId, item.status]));
           const verified = withEntry.evidence.some((item) => findingVerificationPasses(finding.data.candidateId, {
             kind: item.data.kind,
             candidateId: item.data.candidateId,
@@ -21228,6 +21679,71 @@ class WorkitCore {
       return changed;
     return success(changed.data.revision, null, changed.data.evidence.at(-1));
   }
+  observeCheck(request) {
+    return this.retryOmittedRevisions(request, () => this.observeCheckOnce(request));
+  }
+  observeCheckOnce(request) {
+    const root = this.contextRootError();
+    if (!root.ok)
+      return root;
+    if (this.context.caller.host !== "workit_cli" || (this.context.workerId ?? null) !== null)
+      return failure2("permission_denied", "only the workit CLI records observed checks");
+    const observation = checkObservationSchema.safeParse(request?.observation);
+    if (!observation.success)
+      return failure2("invalid_input", "check observation is invalid", {
+        fields: observation.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          reason: issue.message
+        }))
+      });
+    const task = this.store.readTask(request.taskId);
+    if (!task.ok)
+      return task;
+    if (task.data.status === "closed")
+      return failure2("invalid_transition", "closed task cannot record evidence");
+    const observed = observation.data;
+    let candidate = null;
+    if (observed.tree === null) {
+      const captured = captureCandidate(this.store.root, task.data.intent.data.scope, environment());
+      if (!captured.ok)
+        return captured;
+      candidate = captured.data;
+    }
+    const label = observed.name ?? observed.argv.join(" ");
+    const data = {
+      kind: "check",
+      claim: `workit check ${label}`.slice(0, 500),
+      requirementIds: [],
+      ...candidate ? { beforeCandidateId: candidate.id, candidateId: candidate.id } : {},
+      result: observed.exitCode === 0 ? "passed" : "failed",
+      summary: `${observed.configured ? "configured" : "ad-hoc"} check exited ${observed.exitCode}${observed.timedOut ? " (timed out)" : ""} in ${observed.durationMs} ms`,
+      refs: [],
+      exitCode: observed.exitCode,
+      reviewContext: null,
+      observation: observed
+    };
+    const changed = this.store.mutateTask(task.data.id, request.expectedRevision ?? task.data.revision, (current, mutation) => {
+      const candidates = candidate === null || current.candidates.some((item) => item.id === candidate.id) ? current.candidates : [...current.candidates, candidate];
+      const critical = [...new Set([...current.critical ?? [], CHECK_OBSERVATION_PATH])];
+      return success(mutation.revision, null, {
+        ...current,
+        critical,
+        candidates,
+        evidence: [
+          ...current.evidence,
+          {
+            id: newId(),
+            recordedAt: mutation.now,
+            provenance: provenance(this.context, "host_observed"),
+            data
+          }
+        ]
+      });
+    }, trustedNow(this.context));
+    if (!changed.ok)
+      return changed;
+    return success(changed.data.revision, null, changed.data.evidence.at(-1));
+  }
   decision(request) {
     return this.recordDecision(request);
   }
@@ -21463,7 +21979,7 @@ class WorkitCore {
       const current = captureCandidate(this.store.root, task.data.intent.data.scope, environment());
       if (!current.ok)
         return current;
-      const evaluations = evaluateEvidence(task.data, current.data);
+      const evaluations = evaluateEvidence(task.data, current.data, treeFreshness(this.store.root));
       const verified = evidence.some((entry) => {
         const evaluation = evaluations.find((item) => item.evidenceId === entry.id);
         return entry.recordedAt >= finding.recordedAt && findingVerificationPasses(finding.data.candidateId, {
@@ -22167,7 +22683,8 @@ class WorkitCore {
     if (!current.ok)
       return current;
     const evaluationWorkspace = task.status === "closed" ? { ...workspace.data, writer: null } : workspace.data;
-    const requirements = evaluateRequirements(task, evaluationWorkspace, this.context.capabilities, current.data, this.store.root, this.context.caller);
+    const tree = treeFreshness(this.store.root);
+    const requirements = evaluateRequirements(task, evaluationWorkspace, this.context.capabilities, current.data, this.store.root, this.context.caller, tree);
     return success(task.revision, workspace.data.revision, {
       id: task.id,
       revision: task.revision,
@@ -22184,7 +22701,7 @@ class WorkitCore {
       writer: evaluationWorkspace.writer
     });
   }
-  compactContext(taskId) {
+  compactContext(taskId, freshness) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -22194,12 +22711,12 @@ class WorkitCore {
     const helper = this.helperTaskGuard(task.data, true);
     if (!helper.ok)
       return helper;
-    const view = this.view(task.data, false);
+    const view = this.view(task.data, false, freshness ?? signalFreshness(this.store.root));
     if (!view.ok)
       return view;
     return success(view.revision, view.workspaceRevision, compactTaskContext(view.data));
   }
-  view(task, capture = true) {
+  view(task, capture = true, freshness = treeFreshness(this.store.root)) {
     const workspace = this.store.readWorkspace();
     if (!workspace.ok)
       return workspace;
@@ -22210,13 +22727,14 @@ class WorkitCore {
     if (!current.ok)
       return current;
     const evaluationWorkspace = task.status === "closed" ? { ...workspace.data, writer: null } : workspace.data;
-    const requirements = evaluateRequirements(task, evaluationWorkspace, this.context.capabilities, current.data, this.store.root, this.context.caller);
+    const tree = freshness;
+    const requirements = evaluateRequirements(task, evaluationWorkspace, this.context.capabilities, current.data, this.store.root, this.context.caller, tree);
     return success(task.revision, workspace.data.revision, {
       task,
       workspace: evaluationWorkspace,
       capabilities: this.context.capabilities,
       requirements,
-      evidence: evaluateEvidence(task, current.data)
+      evidence: evaluateEvidence(task, current.data, tree)
     });
   }
   reconcileResume(view, observations = []) {
@@ -22443,13 +22961,14 @@ class WorkitCore {
       return current;
     const withCandidate = current.data;
     const taskForView = withCandidate.id === task.data.candidates.at(-1)?.id ? task.data : { ...task.data, candidates: [...task.data.candidates, withCandidate] };
-    const requirements = evaluateRequirements(taskForView, workspace.data, this.context.capabilities, withCandidate, this.store.root, this.context.caller);
+    const tree = treeFreshness(this.store.root);
+    const requirements = evaluateRequirements(taskForView, workspace.data, this.context.capabilities, withCandidate, this.store.root, this.context.caller, tree);
     const view = {
       task: taskForView,
       workspace: workspace.data,
       capabilities: this.context.capabilities,
       requirements,
-      evidence: evaluateEvidence(taskForView, withCandidate)
+      evidence: evaluateEvidence(taskForView, withCandidate, tree)
     };
     const closure = evaluateClosure(input.outcome, view);
     if (!closure.ok)
@@ -22506,22 +23025,22 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync7(root);
-  const target = path11.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path11.sep)) {
+  const target = path13.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path13.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync5(ancestor))
-    ancestor = path11.dirname(ancestor);
+    ancestor = path13.dirname(ancestor);
   const canonicalAncestor = realpathSync7(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path11.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path13.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync7(root);
-  const result = spawnSync4(executable, args, {
+  const result = spawnSync6(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -22546,7 +23065,7 @@ var SUPPORT_MATRIX = {
 
 // packages/workit-mcp/src/server.ts
 import { existsSync as existsSync7, readFileSync as readFileSync8, realpathSync as realpathSync8 } from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
   const schema = s;
@@ -24925,7 +25444,7 @@ class StdioServerTransport {
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/workit-core/src/core/logger.ts
-import os2 from "node:os";
+import os3 from "node:os";
 var REDACTED = "[REDACTED]";
 var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
 var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
@@ -24968,7 +25487,7 @@ var SENSITIVE_WORDS = new Set([
 ]);
 var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var homePattern = new RegExp(`${escapeRegExp(os2.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+var homePattern = new RegExp(`${escapeRegExp(os3.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
 var applyPatterns = (value) => {
   let out = value;
   out = out.replace(SECRET_VALUE, REDACTED);
@@ -24982,9 +25501,9 @@ var applyPatterns = (value) => {
 var redactSecrets = (value) => applyPatterns(value);
 
 // packages/workit-core/src/core/pr-create.ts
-import fs9 from "node:fs";
-import path12 from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import fs11 from "node:fs";
+import path14 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
@@ -24994,13 +25513,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(path12.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path14.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path12.join(dir, name);
+      const candidate = path14.join(dir, name);
       try {
-        fs9.accessSync(candidate, fs9.constants.X_OK);
+        fs11.accessSync(candidate, fs11.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -25009,7 +25528,7 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 var pushRemote = (cwd) => {
-  const result = spawnSync5("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync7("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -25020,9 +25539,9 @@ var pushRemote = (cwd) => {
 };
 
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
-import path13 from "node:path";
+import path15 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -25049,7 +25568,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync6("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync8("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -25156,7 +25675,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path13.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path15.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -25187,7 +25706,7 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path13.join(cwd, "package.json");
+  const pkgPath = path15.join(cwd, "package.json");
   if (!existsSync6(pkgPath))
     return [];
   try {
@@ -25213,9 +25732,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path13.join(dir, entry.name), depth + 1);
+        walk(path15.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path13.relative(cwd, path13.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path15.relative(cwd, path15.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -25231,7 +25750,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path15.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -25289,7 +25808,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed2(path13.join(cwd, template), 220);
+    stdout += readTrimmed2(path15.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -25299,7 +25818,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync6(path13.join(cwd, "package.json"))) {
+  if (existsSync6(path15.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -25308,7 +25827,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync6(path13.join(cwd, "Cargo.toml")) || existsSync6(path13.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync6(path15.join(cwd, "Cargo.toml")) || existsSync6(path15.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -25341,7 +25860,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 = path13.resolve(repoRoot(root));
+  const cwd = path15.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -25359,7 +25878,7 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path13.join(cwd, "CHANGELOG.md");
+  const changelogPath = path15.join(cwd, "CHANGELOG.md");
   if (existsSync6(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
@@ -25379,7 +25898,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path15.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -25401,7 +25920,7 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path13.join(cwd, "README.md");
+  const readme = path15.join(cwd, "README.md");
   if (existsSync6(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
@@ -25410,7 +25929,7 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path13.join(cwd, "package.json");
+  const pkgPath = path15.join(cwd, "package.json");
   if (existsSync6(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
@@ -25424,7 +25943,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path13.resolve(repoRoot(root));
+  const cwd = path15.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -25462,7 +25981,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync6(path13.join(cwd, rel)))
+    if (existsSync6(path15.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -25490,7 +26009,7 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 var repoPathFromRemote = (remote) => {
   let rest = (remote || "").trim().replace(/\/+$/, "");
   if (!rest)
@@ -25511,7 +26030,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync7(bin, args, {
+    const out = spawnSync9(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -25589,8 +26108,8 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 
 // packages/workit-core/src/core/youtrack.ts
-import fs10 from "node:fs";
-import path14 from "node:path";
+import fs12 from "node:fs";
+import path16 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -25603,22 +26122,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 ?? path14.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path14.join(resolveConfigDir(), "youtrack.json");
+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 youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs10.statSync(p).mode & 511;
+  const mode = fs12.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs10.existsSync(cfgPath)) {
+  if (!fs12.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs10.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs12.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -25629,11 +26148,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs10.existsSync(cfgPath))
+  if (!fs12.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs10.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs12.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -25672,12 +26191,12 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path14.isAbsolute(tokenFile) ? path14.resolve(tokenFile) : path14.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs10.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path16.isAbsolute(tokenFile) ? path16.resolve(tokenFile) : path16.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs12.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs10.readFileSync(tokenPath, "utf8").trim();
+  const token = fs12.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -25742,9 +26261,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs10.existsSync(full))
+    if (!fs12.existsSync(full))
       continue;
-    const text = fs10.readFileSync(full, "utf8");
+    const text = fs12.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -25897,10 +26416,6 @@ var ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9])(["']?${KEY}["']?\s*[:=]\
 var QUOTED_ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9])(["']?${KEY}["']?\s*[:=]\s*)(["'])([^"'\n]*[^\s"'][^"'\n]*)\2`, "giu");
 var ANSI = new RegExp(String.raw`\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007]*\u0007`, "gu");
 
-// packages/workit-core/src/git/rev.ts
-var MAX_BUFFER = 256 * 1024 * 1024;
-var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
-
 // packages/workit-core/src/ledger.ts
 var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
 var FAILING = new Set(["failed", "blocked"]);
@@ -26042,13 +26557,13 @@ var rootVariants = (workspaceRoot) => {
   if (!workspaceRoot)
     return [];
   const roots = new Set;
-  for (const candidate of [workspaceRoot, path15.resolve(workspaceRoot)]) {
-    if (path15.isAbsolute(candidate) && candidate !== path15.parse(candidate).root)
+  for (const candidate of [workspaceRoot, path17.resolve(workspaceRoot)]) {
+    if (path17.isAbsolute(candidate) && candidate !== path17.parse(candidate).root)
       roots.add(candidate);
   }
   try {
     const canonical = realpathSync8(workspaceRoot);
-    if (canonical !== path15.parse(canonical).root)
+    if (canonical !== path17.parse(canonical).root)
       roots.add(canonical);
   } catch {}
   return [...roots].toSorted((left, right) => right.length - left.length);
@@ -26149,11 +26664,11 @@ var thrownResult = (tool, error, workspaceRoot) => {
 };
 function createMcpServer(host, contextProvider) {
   assertMcpHost(host);
-  const here = path15.dirname(fileURLToPath2(import.meta.url));
+  const here = path17.dirname(fileURLToPath2(import.meta.url));
   const sourceMarker = markSourcesLoaded([
-    path15.join(here, "server.ts"),
-    path15.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
-    path15.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
+    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")
   ].filter((file) => existsSync7(file)));
   let staleWarned = false;
   const server = new Server({ name: "workit", version: VERSION }, { capabilities: { tools: {}, resources: {} } });
@@ -26343,6 +26858,7 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
   };
 });
 // packages/workit-core/src/hooks/context.ts
+var signals = new Map;
 var cache = new Map;
 // packages/workit-core/src/hooks/handle.ts
 var offered = new Set;
@@ -26490,8 +27006,8 @@ var codexQualification = (host) => host === "codex_cli" ? { surface: host, cli:
 var resolveCodexWorkspaceRoot = (pluginRoot, env) => {
   const explicit = env.WORKFLOW_WORKSPACE_ROOT;
   const inherited = env.PWD;
-  const candidate = explicit ?? (inherited && path16.resolve(inherited) !== path16.resolve(pluginRoot) ? inherited : undefined);
-  if (!candidate || !path16.isAbsolute(candidate) || !existsSync8(candidate))
+  const candidate = explicit ?? (inherited && path18.resolve(inherited) !== path18.resolve(pluginRoot) ? inherited : undefined);
+  if (!candidate || !path18.isAbsolute(candidate) || !existsSync8(candidate))
     return null;
   try {
     if (!statSync3(candidate).isDirectory())