@brainervirus/workit-cursor 1.0.9 → 1.0.11

package/dist/mcp-server.js

@@ -12479,8 +12479,8 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync3, realpathSync as realpathSync5 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync4, realpathSync as realpathSync5 } from "node:fs";
+import path7 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -20272,10 +20272,12 @@ var decisionSchema = object4({
     scope: scopeSchema,
     presented: text,
     approvedContent: text,
-    contentRefs: array3(refSchema)
+    displayed: text.optional(),
+    contentRefs: array3(refSchema),
+    statedChoice: object4({ ref: text, text }).strict().optional()
   }).strict(),
   digest,
-  response: _enum2(["approved", "rejected"]),
+  response: _enum2(["approved", "rejected", "stated"]),
   requirementIds: array3(digest),
   revoked: object4({ at: utc, reason: text }).strict().nullable(),
   consumption: object4({
@@ -20350,6 +20352,10 @@ var actionProgressListSchema = array3(actionProgressSchema).check((ctx) => {
       path: ["decisionId"]
     });
 });
+var runtimeSchema = object4({
+  createdWith: text.nullable(),
+  updatedWith: text
+}).strict();
 var taskRecordSchema = object4({
   schemaVersion: literal3(1),
   id,
@@ -20363,6 +20369,8 @@ var taskRecordSchema = object4({
   status: _enum2(["active", "paused", "closed"]),
   closure: closureSchema.nullable(),
   progress: progressSchema,
+  pauseReason: text.nullable().optional(),
+  runtime: runtimeSchema.optional(),
   assessments: array3(entrySchema(assessmentSchema)),
   policy: policySchema.nullable(),
   policyChanges: array3(policyChangeSchema),
@@ -20378,6 +20386,7 @@ var workspaceRecordSchema = object4({
   id,
   revision,
   root: nonEmpty,
+  runtime: runtimeSchema.optional(),
   writer: object4({ state: _enum2(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc }).strict().nullable()
 }).strict();
 var capabilitySchema = object4({
@@ -20405,6 +20414,9 @@ var taskSummarySchema = object4({
   id,
   revision,
   workspaceRevision: revision,
+  createdAt: utc,
+  updatedAt: utc,
+  runtime: runtimeSchema.nullable(),
   objective: text,
   status: _enum2(["active", "paused", "closed"]),
   closure: closureSchema.nullable(),
@@ -20475,7 +20487,7 @@ var taskOperations = {
     expectedWorkspaceRevision: revision.optional(),
     outcome: outcomeSchema,
     summary: text,
-    decisionIds: array3(id)
+    decisionIds: array3(id).optional()
   })
 };
 var policyOperations = {
@@ -20567,14 +20579,15 @@ var writerOperations = {
     ...taskId,
     expectedRevision: revision.optional(),
     expectedWorkspaceRevision: revision.optional(),
-    workerId: nullableId.optional()
+    workerId: nullableId.optional(),
+    reason: text.optional()
   }),
   release: operation({
     action: literal3("release"),
     ...taskId,
     expectedRevision: revision.optional(),
     expectedWorkspaceRevision: revision.optional(),
-    reason: text
+    reason: text.optional()
   })
 };
 var stateOperations = {
@@ -20781,7 +20794,26 @@ function requirementId(input) {
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import * as fs4 from "node:fs";
 import { hostname as hostname2 } from "node:os";
-import path3 from "node:path";
+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;
+};
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -20832,7 +20864,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 path from "node:path";
+import path2 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/bounded-read.js
 import fs from "node:fs";
@@ -20922,13 +20954,13 @@ ${ownershipToken}
   return { raw, ownershipToken };
 }
 function relativeSidecarLockPath(lockRoot, lockPath) {
-  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)) {
+  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)) {
     throw new FsSafeError("outside-workspace", "sidecar lock path is outside lockRoot");
   }
-  return relative.split(path.sep).join(path.posix.sep);
+  return relative.split(path2.sep).join(path2.posix.sep);
 }
 function parseSidecarLockPayload(raw, parser) {
   if (parser) {
@@ -21075,7 +21107,7 @@ function getFsSafeLockConfig() {
 
 // node_modules/@openclaw/fs-safe/dist/file-lock-sync.js
 import fs3 from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/timing.js
 function sleepSync(ms) {
@@ -21166,26 +21198,26 @@ function canonicalLockParentSync(parent) {
   return process.platform === "win32" ? fs3.realpathSync.native(parent) : fs3.realpathSync(parent);
 }
 function normalizeTargetPath(targetPath) {
-  const resolved = path2.resolve(targetPath);
-  fs3.mkdirSync(path2.dirname(resolved), { recursive: true });
+  const resolved = path3.resolve(targetPath);
+  fs3.mkdirSync(path3.dirname(resolved), { recursive: true });
   try {
-    return path2.join(canonicalLockParentSync(path2.dirname(resolved)), path2.basename(resolved));
+    return path3.join(canonicalLockParentSync(path3.dirname(resolved)), path3.basename(resolved));
   } catch {
     return resolved;
   }
 }
 function boundedLockPath(lockPath, lockRoot) {
-  const resolved = path2.resolve(lockPath);
+  const resolved = path3.resolve(lockPath);
   if (!lockRoot)
     return resolved;
   relativeSidecarLockPath(lockRoot, resolved);
-  const parent = path2.dirname(resolved);
+  const parent = path3.dirname(resolved);
   const parentReal = canonicalLockParentSync(parent);
-  const parentRelative = path2.relative(lockRoot.rootReal, parentReal);
-  if (parentRelative === ".." || parentRelative.startsWith(`..${path2.sep}`) || path2.isAbsolute(parentRelative)) {
+  const parentRelative = path3.relative(lockRoot.rootReal, parentReal);
+  if (parentRelative === ".." || parentRelative.startsWith(`..${path3.sep}`) || path3.isAbsolute(parentRelative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock parent is outside lockRoot");
   }
-  return path2.join(parentReal, path2.basename(resolved));
+  return path3.join(parentReal, path3.basename(resolved));
 }
 function defaultShouldReclaim(snapshot, staleMs, nowMs) {
   const createdAtMs = sidecarLockPayloadCreatedAtMs(snapshot.payload);
@@ -21398,6 +21430,33 @@ var metadataLockSchema = object4({
   nonce: string5().min(1)
 }).strict();
 var now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+var cachedRuntimeVersion = null;
+var runtimeVersion = () => {
+  if (cachedRuntimeVersion === null) {
+    try {
+      const pkg = JSON.parse(fs4.readFileSync(path4.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 [next, now] = [parts(candidate), parts(current)];
+  for (let index = 0;index < 3; index += 1) {
+    const left = next[index] ?? 0;
+    const right = now[index] ?? 0;
+    if (left !== right)
+      return left > right;
+  }
+  return false;
+};
 var jsonBytes = (value) => `${canonicalJson(value)}
 `;
 var digestBytes = (value) => createHash2("sha256").update(value).digest("hex");
@@ -21424,12 +21483,12 @@ var sameMetadataLock = (left, right) => {
 class TaskStore {
   root;
   constructor(root) {
-    this.root = fs4.existsSync(root) ? fs4.realpathSync(root) : path3.resolve(root);
+    this.root = fs4.existsSync(root) ? fs4.realpathSync(root) : path4.resolve(root);
   }
   readTask(taskId) {
     if (!validId(taskId))
       return failure("invalid_input", "task ID is invalid", { taskId });
-    const result = this.readRecord(path3.join(this.tasksDir, `${taskId}.json`), taskRecordSchema);
+    const result = this.readRecord(path4.join(this.tasksDir, `${taskId}.json`), taskRecordSchema);
     if (!result.exists)
       return failure("not_found", "task not found", { taskId });
     if (result.result.ok && result.result.data.id !== taskId)
@@ -21463,7 +21522,7 @@ class TaskStore {
       });
     const tasks = [];
     for (const name of names.sort()) {
-      const item = this.readRecord(path3.join(this.tasksDir, name), taskRecordSchema);
+      const item = this.readRecord(path4.join(this.tasksDir, name), taskRecordSchema);
       if (!item.exists)
         continue;
       if (!item.result.ok)
@@ -21497,7 +21556,7 @@ class TaskStore {
       if (!current.ok)
         return current;
       if (current.data ? value.expectedWorkspaceRevision !== current.data.revision : value.expectedWorkspaceRevision !== null) {
-        return failure("revision_conflict", "workspace revision does not match", {
+        return failure("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", {
           expectedWorkspaceRevision: value.expectedWorkspaceRevision,
           actualWorkspaceRevision: current.data?.revision ?? null
         });
@@ -21509,11 +21568,17 @@ class TaskStore {
       const previousWorkspaceBytes = current.data ? this.snapshotBytes(this.workspacePath) : null;
       if (current.data && !previousWorkspaceBytes)
         return failure("storage_error", "workspace snapshot disappeared during creation");
-      const workspace = current.data ? { ...current.data, revision: newRevision(), root: this.root } : {
+      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();
@@ -21535,6 +21600,7 @@ class TaskStore {
         status: "active",
         closure: null,
         progress: { summary: "", nextAction: null, blockers: [] },
+        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
         assessments: [],
         policy: null,
         policyChanges: [],
@@ -21565,7 +21631,7 @@ class TaskStore {
       if (!current.ok)
         return current;
       if (current.data ? input.expectedWorkspaceRevision !== current.data.revision : input.expectedWorkspaceRevision !== null)
-        return failure("revision_conflict", "workspace revision does not match", {
+        return failure("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", {
           expectedWorkspaceRevision: input.expectedWorkspaceRevision,
           actualWorkspaceRevision: current.data?.revision ?? null
         });
@@ -21573,11 +21639,17 @@ class TaskStore {
       if (current.data && !previousWorkspaceBytes)
         return failure("storage_error", "workspace snapshot disappeared during import");
       const timestamp = input.now ?? now();
-      const workspace = current.data ? { ...current.data, revision: newRevision(), root: this.root } : {
+      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 task = {
@@ -21585,7 +21657,11 @@ class TaskStore {
         workspaceId: workspace.id,
         revision: newRevision(),
         createdAt: timestamp,
-        updatedAt: timestamp
+        updatedAt: timestamp,
+        runtime: {
+          createdWith: input.task.runtime?.createdWith ?? null,
+          updatedWith: runtimeVersion()
+        }
       };
       const validTask = taskRecordSchema.safeParse(task);
       if (!validTask.success)
@@ -21634,7 +21710,8 @@ class TaskStore {
         workspaceId: current.data.workspaceId,
         createdAt: current.data.createdAt,
         revision: context.revision,
-        updatedAt: context.now
+        updatedAt: context.now,
+        runtime: stampNew(current.data)
       };
       const valid = taskRecordSchema.safeParse(record);
       if (!valid.success)
@@ -21668,7 +21745,8 @@ class TaskStore {
         ...changed.data,
         id: current.data.id,
         root: this.root,
-        revision: context.revision
+        revision: context.revision,
+        runtime: stampNew(current.data)
       };
       const valid = workspaceRecordSchema.safeParse(record);
       if (!valid.success)
@@ -21711,7 +21789,8 @@ class TaskStore {
         ...changedWorkspace.data,
         id: workspace.data.id,
         root: this.root,
-        revision: workspaceContext.revision
+        revision: workspaceContext.revision,
+        runtime: stampNew(workspace.data)
       });
       if (!nextWorkspace.success)
         return failure("invalid_input", "workspace mutation produced an invalid record");
@@ -21736,7 +21815,8 @@ class TaskStore {
         workspaceId: task.data.workspaceId,
         createdAt: task.data.createdAt,
         revision: taskContext.revision,
-        updatedAt: taskContext.now
+        updatedAt: taskContext.now,
+        runtime: stampNew(task.data)
       });
       if (!nextTask.success) {
         this.markUncertain(nextWorkspace.data);
@@ -21763,7 +21843,7 @@ class TaskStore {
         if (match)
           candidates.push({
             target: match[1],
-            path: path3.join(this.recoveryDir, name),
+            path: path4.join(this.recoveryDir, name),
             digest: match[3]
           });
       }
@@ -21956,7 +22036,8 @@ class TaskStore {
     const value = {
       ...workspace,
       writer: { ...workspace.writer, state: "uncertain" },
-      revision: newRevision()
+      revision: newRevision(),
+      runtime: stampNew(workspace)
     };
     this.replaceSnapshot(this.workspacePath, value, workspace);
   }
@@ -22034,7 +22115,7 @@ class TaskStore {
       }
       fs4.renameSync(temporary, file);
       temporary = undefined;
-      this.fsyncDirectory(path3.dirname(file));
+      this.fsyncDirectory(path4.dirname(file));
       return success(null, null, value);
     } catch (error) {
       return failure("storage_error", `snapshot replacement failed: ${String(error)}`, {
@@ -22048,9 +22129,9 @@ class TaskStore {
     }
   }
   saveRecovery(file, bytes) {
-    const target = path3.basename(file) === "workspace.json" ? "workspace" : "task";
-    const id = target === "task" ? path3.basename(file, ".json") : "workspace";
-    const destination = path3.join(this.recoveryDir, `${target}.${id}.${digestBytes(bytes)}.json`);
+    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 (fs4.existsSync(destination)) {
       if (digestBytes(fs4.readFileSync(destination)) === digestBytes(bytes))
         return;
@@ -22128,7 +22209,7 @@ class TaskStore {
       for (const name of fs4.readdirSync(this.tasksDir)) {
         if (!name.endsWith(".json") || !validId(name.slice(0, -5)))
           return null;
-        const parsed = this.parseBytes(fs4.readFileSync(path3.join(this.tasksDir, name)), taskRecordSchema);
+        const parsed = this.parseBytes(fs4.readFileSync(path4.join(this.tasksDir, name)), taskRecordSchema);
         if (!parsed.ok || parsed.data.id !== name.slice(0, -5))
           return null;
         ids.add(parsed.data.workspaceId);
@@ -22170,7 +22251,12 @@ class TaskStore {
     if (isObject3(value) && "schemaVersion" in value && value.schemaVersion !== SCHEMA_VERSION)
       return failure("unsupported_version", "unsupported snapshot schema version");
     const parsed = schema.safeParse(value);
-    return parsed.success ? success(null, null, parsed.data) : failure("recovery_required", "snapshot does not satisfy its schema");
+    if (parsed.success)
+      return success(null, null, parsed.data);
+    const writerVersion = isObject3(value) && isObject3(value.runtime) ? value.runtime.updatedWith : null;
+    if (typeof writerVersion === "string" && isNewerVersion(writerVersion, runtimeVersion()))
+      return failure("recovery_required", `snapshot was written by workit ${writerVersion}; upgrade Workit before mutating this checkout`);
+    return failure("recovery_required", "snapshot does not satisfy its schema");
   }
   processStart(pid) {
     try {
@@ -22180,43 +22266,98 @@ class TaskStore {
     }
   }
   conflict(expected, actual) {
-    return failure("revision_conflict", "snapshot revision does not match", {
+    return failure("revision_conflict", "snapshot revision does not match; omit expectedRevision to use the current record", {
       expectedRevision: expected,
       actualRevision: actual
     });
   }
   taskPath(taskId) {
-    return path3.join(this.tasksDir, `${taskId}.json`);
+    return path4.join(this.tasksDir, `${taskId}.json`);
   }
   get workitDir() {
-    return path3.join(this.root, ".workit");
+    return path4.join(this.root, ".workit");
   }
   get tasksDir() {
-    return path3.join(this.workitDir, "tasks");
+    return path4.join(this.workitDir, "tasks");
   }
   get recoveryDir() {
-    return path3.join(this.workitDir, "recovery");
+    return path4.join(this.workitDir, "recovery");
   }
   get workspacePath() {
-    return path3.join(this.workitDir, "workspace.json");
+    return path4.join(this.workitDir, "workspace.json");
   }
   get lockPath() {
-    return path3.join(this.workitDir, "metadata.lock");
+    return path4.join(this.workitDir, "metadata.lock");
   }
   get gitignorePath() {
-    return path3.join(this.workitDir, ".gitignore");
+    return path4.join(this.workitDir, ".gitignore");
   }
 }
+// packages/workit-core/src/core/workers.ts
+var same = (left, right) => {
+  try {
+    return canonicalJson(left) === canonicalJson(right);
+  } catch {
+    return false;
+  }
+};
+var UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
+var isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state);
+var callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor };
+var validPath = (value) => typeof value === "string" && value.length > 0 && ![...value].some((char) => {
+  const code = char.charCodeAt(0);
+  return code < 32 || code === 127;
+}) && !value.split(/[\\/]/).includes("..");
+var callerValue = (value) => ({ host: value.host, actor: value.actor });
+var workerIdOf = (value) => value.workerId ?? null;
+function assertProductWriteAllowed(input) {
+  if (!Array.isArray(input.paths) || input.paths.some((path) => !validPath(path)))
+    return failure("invalid_input", "invalid product write path");
+  if (!input.store)
+    return failure("permission_denied", "write authorization requires core state");
+  const task = input.store.readTask(input.task.id);
+  if (!task.ok)
+    return task;
+  const workspace = input.store.readWorkspace();
+  if (!workspace.ok)
+    return workspace;
+  if (!workspace.data)
+    return failure("not_found", "workspace not found");
+  const workspaceRecord = workspace.data;
+  if (task.data.status !== "active")
+    return failure("invalid_transition", "paused or closed tasks cannot own product writes");
+  if (workspaceRecord.id !== task.data.workspaceId || workspaceRecord.root.length === 0)
+    return failure("recovery_required", "task and workspace bindings are invalid");
+  const writer = workspaceRecord.writer;
+  if (!writer)
+    return failure("permission_denied", "checkout has no writer owner");
+  if (writer.state === "uncertain")
+    return failure("recovery_required", "checkout writer requires recovery", {
+      owner: writer.owner
+    });
+  const caller = callerValue(input.caller);
+  const workerId = workerIdOf(input.caller);
+  const owner = writer.owner;
+  if (owner.taskId !== task.data.id || owner.workerId !== workerId || owner.session.host !== caller.host || owner.session.handle !== caller.actor)
+    return failure("writer_conflict", "checkout is owned by another validated actor", { owner });
+  const worker = workerId === null ? null : task.data.workers.find((entry) => entry.id === workerId);
+  if (workerId !== null && (!worker || worker.data.assignment.role !== "implementer"))
+    return failure("permission_denied", "only implementers can own product writes");
+  if (workerId !== null && (!worker?.data.session || worker.data.state === "cancelling" || worker.data.state === "unknown" || worker.data.state === "stopped" || !same(worker.data.session, callerSession(input.caller))))
+    return failure("recovery_required", "worker session is not an active writer");
+  return success(null, workspaceRecord.revision, owner);
+}
+
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash4 } from "node:crypto";
 import * as fs6 from "node:fs";
 import { spawnSync } from "node:child_process";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // packages/workit-core/src/core/authority.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as fs5 from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 var verifiedAuthorities = new WeakMap;
 var trustedAuthority = (kind, provenance, expected, binding, caller) => {
   const token = {};
@@ -22343,20 +22484,31 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure("invalid_input", "document references require a byte digest");
-    const target = path4.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path4.sep}`))
-      return failure("invalid_input", "document reference escapes checkout");
+    const target = path5.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path5.sep}`))
+      return failure("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 = path4.relative(root, target);
+      const relative = path5.relative(root, target);
       let current = root;
-      for (const segment of relative.split(path4.sep)) {
+      for (const segment of relative.split(path5.sep)) {
         if (!segment)
           continue;
-        current = path4.join(current, segment);
+        current = path5.join(current, segment);
         const stat = fs5.lstatSync(current);
         const real = fs5.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path4.sep}`))
-          return failure("invalid_input", "document reference escapes checkout");
+        if (real !== root && !real.startsWith(`${root}${path5.sep}`))
+          return failure("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
+            fields: [
+              {
+                path: "contentRefs.path",
+                reason: `${reference.path} resolves outside the checkout`
+              }
+            ]
+          });
         if (stat.isSymbolicLink())
           return failure("invalid_input", "document reference uses a symlink");
         if (current === target && !stat.isFile())
@@ -22703,14 +22855,14 @@ var verifyDecisionContent = verifyContentRefs;
 
 // packages/workit-core/src/core/task-evaluation.ts
 var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path5.sep}`);
-var relative = (root, candidate) => path5.relative(root, candidate).split(path5.sep).join("/") || ".";
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path6.sep}`);
+var relative = (root, candidate) => path6.relative(root, candidate).split(path6.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path5.posix.normalize(value);
+  const normalized = path6.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -22758,14 +22910,14 @@ var gitPaths = (root) => {
       git: /not a git repository/i.test(stderr) ? false : true
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path5.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path6.sep).join("/")) : [];
   const stagedDeleted = spawnSync("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(path5.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path6.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
@@ -22780,7 +22932,7 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path5.join(directory, name);
+    const target = path6.join(directory, name);
     let stat;
     try {
       stat = fs6.lstatSync(target);
@@ -22798,17 +22950,17 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path5.resolve(root, item);
+    const target = path6.resolve(root, item);
     if (!inside(root, target))
-      return failure("invalid_input", "candidate scope escapes checkout");
+      return failure("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 (!fs6.existsSync(ancestor) && ancestor !== root)
-      ancestor = path5.dirname(ancestor);
+      ancestor = path6.dirname(ancestor);
     try {
       if (!inside(root, fs6.realpathSync(ancestor)))
-        return failure("invalid_input", "candidate scope escapes checkout");
+        return failure("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 failure("invalid_input", "candidate scope cannot be inspected");
+      return failure("invalid_input", `candidate scope cannot be inspected: ${item}`);
     }
     roots.push(target);
   }
@@ -22823,7 +22975,7 @@ function captureCandidate(root, scope, environment = []) {
   }
   const normalizedScope = canonicalScope(scope);
   if (!normalizedScope)
-    return failure("invalid_input", "candidate scope is invalid");
+    return failure("invalid_input", "candidate scope is invalid: paths must be checkout-relative — to work in another repository, keep this task here and coordinate a separate linked task in that checkout", { fields: [{ path: "scope.paths", reason: "must be checkout-relative" }] });
   const roots = scopeRoots(checkout, normalizedScope);
   if (!roots.ok)
     return roots;
@@ -22855,7 +23007,7 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].sort()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path5.join(checkout, item);
+    const target = path6.join(checkout, item);
     try {
       const stat = fs6.lstatSync(target);
       if (stat.isSymbolicLink()) {
@@ -22977,7 +23129,7 @@ function evaluateEvidence(task, candidate) {
 }
 var scopeCovers2 = scopeCovers;
 var applicableDecision2 = (task, workspace, requirement, checkoutRoot) => task.decisions.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data).filter((decision) => decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.binding.taskId === task.id && decision.binding.workspaceId === workspace.id && decision.requirementIds.includes(requirement.id) && decision.binding.scope && scopeCovers2(decision.binding.scope, requirement.scope) && decision.digest === decisionDigest(decision) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, decision.binding).ok : decision.binding.contentRefs.every((reference) => reference.kind !== "file")));
-var applicableRequirementDecision = (task, workspace, requirement, checkoutRoot) => task.decisions.filter(({ data, provenance }) => provenance.kind !== "imported" && data.purpose !== "limitation" && data.response === "approved" && data.revoked === null && data.binding.taskId === task.id && data.binding.workspaceId === workspace.id && data.requirementIds.includes(requirement.id) && scopeCovers2(data.binding.scope, requirement.scope) && data.digest === decisionDigest(data) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, data.binding).ok : data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map(({ id }) => ({ id }));
+var applicableRequirementDecision = (task, workspace, requirement, checkoutRoot) => task.decisions.filter(({ data, provenance }) => provenance.kind !== "imported" && data.purpose !== "limitation" && (data.response === "approved" || data.response === "stated") && data.revoked === null && data.binding.taskId === task.id && data.binding.workspaceId === workspace.id && data.requirementIds.includes(requirement.id) && scopeCovers2(data.binding.scope, requirement.scope) && data.digest === decisionDigest(data) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, data.binding).ok : data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map(({ id }) => ({ id }));
 var evidenceMatchesRequirement = (kind, evidenceKind, dimension) => {
   if (kind !== "passed")
     return false;
@@ -23012,7 +23164,7 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
         return true;
       const reviewSession = sessionFromRef(entry.data.reviewContext);
       const sameImplementation = sameSession(reviewSession, task.intent.provenance.session);
-      const sameEvidenceSession = task.evidence.some((other) => other.id !== entry.id && sameSession(reviewSession, other.provenance.session));
+      const sameEvidenceSession = task.evidence.some((other) => other.id !== entry.id && other.data.kind === "review" && sameSession(reviewSession, other.provenance.session));
       return entry.data.kind === "review" && reviewSession !== null && sameSession(reviewSession, entry.provenance.session) && (requirement.ruleId === "self-review" || !sameImplementation && !sameEvidenceSession);
     });
     if (passed.length) {
@@ -23053,7 +23205,7 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
         status: "satisfied",
         evidenceIds: [],
         decisionIds: decisions.map((decision) => decision.id),
-        reason: "an applicable approved decision satisfies the requirement"
+        reason: "an applicable approved or stated decision satisfies the requirement"
       };
     const limitations = requirement.acceptanceAllowed ? applicableDecision2(task, workspace, requirement, checkoutRoot) : [];
     if (limitations.length)
@@ -23108,7 +23260,17 @@ function evaluateClosure(requestedOutcome, view) {
   const blocking = evaluations.filter((item) => item.status === "unsatisfied" || item.status === "unavailable");
   if (requestedOutcome !== "stopped" && blocking.length)
     return failure("requirements_unsatisfied", "applicable requirements are unsatisfied", {
-      requirementIds: blocking.map((item) => item.requirementId)
+      requirementIds: blocking.map((item) => item.requirementId),
+      requirements: blocking.map((item) => {
+        const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
+        return {
+          requirementId: item.requirementId,
+          ruleId: requirement?.ruleId ?? "unknown",
+          reason: item.reason,
+          satisfaction: requirement?.satisfaction ?? "",
+          dependentAction: requirement?.dependentAction ?? null
+        };
+      })
     });
   const accepted = evaluations.filter((item) => item.status === "accepted_limitation");
   if (requestedOutcome === "verified" && accepted.length)
@@ -23144,7 +23306,7 @@ function reconcileResume(view, observations = []) {
     return candidate;
   const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
   const blockers = [...view.task.progress.blockers];
-  if (view.task.workers.some((entry) => ["dispatching", "running", "cancelling", "unknown"].includes(entry.data.state)))
+  if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
     blockers.push({
       reason: "worker state requires reconciliation",
       dependentAction: "resume",
@@ -23177,7 +23339,11 @@ var externalActionSchema = discriminatedUnion2("operation", [
   }).strict(),
   object4({
     operation: literal3("git.commit"),
-    payload: object4({ message: string5().min(1) }).strict()
+    payload: object4({
+      message: string5().min(1).optional(),
+      plan_steps: array3(string5().min(1)).optional(),
+      plan_branch: string5().min(1).optional()
+    }).strict()
   }).strict(),
   object4({
     operation: literal3("git.push"),
@@ -23412,7 +23578,7 @@ function resolveRequirements(input) {
       ].join(", ")}`,
       satisfaction: "An observed or inferred fact resolves the uncertainty and records its supporting references.",
       before: "dependent_action",
-      dependentAction: "dependent-action",
+      dependentAction: null,
       acceptanceAllowed: false
     }));
   if (signals.productChoiceOpen.value === true)
@@ -23423,7 +23589,7 @@ function resolveRequirements(input) {
       reason: `A consequential product choice remains open: ${signalReason(input, "productChoiceOpen")}`,
       satisfaction: "Present the material alternatives and record the user's decision before the dependent action.",
       before: "dependent_action",
-      dependentAction: "dependent-action",
+      dependentAction: null,
       acceptanceAllowed: false
     }));
   if (signals.behaviorChange.value === true)
@@ -23581,59 +23747,6 @@ function diffPolicy(previous, next, reason, now) {
   return parsed.data;
 }
 
-// packages/workit-core/src/core/workers.ts
-var same = (left, right) => {
-  try {
-    return canonicalJson(left) === canonicalJson(right);
-  } catch {
-    return false;
-  }
-};
-var callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor };
-var validPath = (value) => typeof value === "string" && value.length > 0 && ![...value].some((char) => {
-  const code = char.charCodeAt(0);
-  return code < 32 || code === 127;
-}) && !value.split(/[\\/]/).includes("..");
-var callerValue = (value) => ({ host: value.host, actor: value.actor });
-var workerIdOf = (value) => value.workerId ?? null;
-function assertProductWriteAllowed(input) {
-  if (!Array.isArray(input.paths) || input.paths.some((path) => !validPath(path)))
-    return failure("invalid_input", "invalid product write path");
-  if (!input.store)
-    return failure("permission_denied", "write authorization requires core state");
-  const task = input.store.readTask(input.task.id);
-  if (!task.ok)
-    return task;
-  const workspace = input.store.readWorkspace();
-  if (!workspace.ok)
-    return workspace;
-  if (!workspace.data)
-    return failure("not_found", "workspace not found");
-  const workspaceRecord = workspace.data;
-  if (task.data.status !== "active")
-    return failure("invalid_transition", "paused or closed tasks cannot own product writes");
-  if (workspaceRecord.id !== task.data.workspaceId || workspaceRecord.root.length === 0)
-    return failure("recovery_required", "task and workspace bindings are invalid");
-  const writer = workspaceRecord.writer;
-  if (!writer)
-    return failure("permission_denied", "checkout has no writer owner");
-  if (writer.state === "uncertain")
-    return failure("recovery_required", "checkout writer requires recovery", {
-      owner: writer.owner
-    });
-  const caller = callerValue(input.caller);
-  const workerId = workerIdOf(input.caller);
-  const owner = writer.owner;
-  if (owner.taskId !== task.data.id || owner.workerId !== workerId || owner.session.host !== caller.host || owner.session.handle !== caller.actor)
-    return failure("writer_conflict", "checkout is owned by another validated actor", { owner });
-  const worker = workerId === null ? null : task.data.workers.find((entry) => entry.id === workerId);
-  if (workerId !== null && (!worker || worker.data.assignment.role !== "implementer"))
-    return failure("permission_denied", "only implementers can own product writes");
-  if (workerId !== null && (!worker?.data.session || worker.data.state === "cancelling" || worker.data.state === "unknown" || worker.data.state === "stopped" || !same(worker.data.session, callerSession(input.caller))))
-    return failure("recovery_required", "worker session is not an active writer");
-  return success(null, workspaceRecord.revision, owner);
-}
-
 // packages/workit-core/src/core/task-engine.ts
 var provenance = (context, kind = context.provenanceKind ?? "host_observed") => ({
   kind,
@@ -23764,15 +23877,20 @@ var applyWorkerLifecycle = (input) => {
     return failure("invalid_transition", "worker has not started");
   if (input.state === "running" && entry.data.state === "stopped")
     return failure("invalid_transition", "stopped worker cannot run again");
+  const terminalCancel = entry.data.state === "cancelling" && input.state === "running";
   const nextEntry = {
     ...entry,
     recordedAt: input.now ?? entry.recordedAt,
     provenance: authority.provenance,
-    data: { ...entry.data, state: input.state, session: input.session }
+    data: {
+      ...entry.data,
+      state: terminalCancel ? "cancelling" : input.state,
+      session: input.session
+    }
   };
   const shouldClear = input.state === "stopped" && workspace.data.writer !== null && workspace.data.writer.owner.taskId === task.data.id && workspace.data.writer.owner.workerId === input.workerId;
   const shouldUncertain = input.state === "unknown" && workspace.data.writer !== null && workspace.data.writer.owner.taskId === task.data.id && workspace.data.writer.owner.workerId === input.workerId;
-  if (entry.data.state === input.state && sameValue(entry.data.session, input.session) && !shouldClear && !shouldUncertain)
+  if (entry.data.state === nextEntry.data.state && sameValue(entry.data.session, input.session) && !shouldClear && !shouldUncertain)
     return success(task.data.revision, workspace.data.revision, entry);
   const changed = input.store.mutateTaskAndWorkspace({
     taskId: task.data.id,
@@ -24142,7 +24260,7 @@ class WorkitCore {
   activeWorkerBlocker(task, workspace) {
     if (workspace.writer)
       return failure("recovery_required", "writer ownership must be released first");
-    if (task.workers.some((entry) => ["dispatching", "running", "cancelling", "unknown"].includes(entry.data.state)))
+    if (task.workers.some((entry) => isUncertainWorker(entry.data.state)))
       return failure("recovery_required", "worker state requires reconciliation");
     return null;
   }
@@ -24379,11 +24497,6 @@ class WorkitCore {
     if (helper && !helper.ok)
       return helper;
     const evidence = input.evidence;
-    if (helper?.ok) {
-      const assignment = helper.data.data.assignment;
-      if (evidence.requirementIds.some((id) => !assignment.requirementIds.includes(id)) || assignment.candidateId !== null && evidence.candidateId !== assignment.candidateId && evidence.beforeCandidateId !== assignment.candidateId || !refsWithinScope(evidence.refs, assignment.scope) || !refsWithinScope(evidence.refs, task.data.intent.data.scope))
-        return failure("permission_denied", "evidence is outside the worker assignment");
-    }
     if ((evidence.result === "missing" || evidence.result === "skipped") && !evidence.summary.trim())
       return failure("invalid_input", "missing or skipped evidence requires a reason");
     if (evidence.kind === "review") {
@@ -24400,6 +24513,11 @@ class WorkitCore {
       evidence.beforeCandidateId ??= null;
       evidence.candidateId ??= null;
     }
+    if (helper?.ok) {
+      const assignment = helper.data.data.assignment;
+      if (evidence.requirementIds.some((id) => !assignment.requirementIds.includes(id)) || assignment.candidateId !== null && evidence.candidateId !== assignment.candidateId && evidence.beforeCandidateId !== assignment.candidateId || !refsWithinScope(evidence.refs, assignment.scope) || !refsWithinScope(evidence.refs, task.data.intent.data.scope))
+        return failure("permission_denied", "evidence is outside the worker assignment");
+    }
     const knownCandidates = new Set(task.data.candidates.map((candidate) => candidate.id));
     for (const candidateId of [evidence.beforeCandidateId, evidence.candidateId]) {
       if (candidateId && candidateId !== currentCandidate.data.id && !knownCandidates.has(candidateId))
@@ -24453,7 +24571,12 @@ class WorkitCore {
     const input = parsed.data;
     if (nativeRequired && input.action !== "record")
       return failure("permission_denied", "native observation is only valid for recording decisions");
-    if (nativeRequired && nativeObservation === undefined)
+    const stated = input.action === "record" && input.response === "stated";
+    if (stated && input.purpose === "action")
+      return failure("permission_denied", "stated choices cannot authorize mutating actions");
+    if (stated && !input.binding?.statedChoice)
+      return failure("invalid_input", "stated choices require binding.statedChoice");
+    if (nativeRequired && nativeObservation === undefined && !stated)
       return failure("permission_denied", "native decision observation is required");
     const task = this.store.readTask(input.taskId);
     if (!task.ok)
@@ -24486,7 +24609,7 @@ class WorkitCore {
         consumption: null
       };
       const data = { ...base, digest: decisionDigest(base) };
-      const native = nativeRequired ? verifyNativeDecision(this.context.nativeAuthority, {
+      const native = nativeRequired && !stated ? verifyNativeDecision(this.context.nativeAuthority, {
         observation: nativeObservation,
         expected: {
           taskId: task.data.id,
@@ -25295,6 +25418,9 @@ class WorkitCore {
       id: task.id,
       revision: task.revision,
       workspaceRevision: workspace.data.revision,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      runtime: task.runtime ?? null,
       objective: task.intent.data.objective,
       status: task.status,
       closure: task.closure,
@@ -25380,7 +25506,7 @@ class WorkitCore {
     const base = reconcileResume(effectiveView);
     if (!base.ok)
       return base;
-    const needsReconciliation = view.task.workers.some((entry) => ["dispatching", "running", "cancelling", "unknown"].includes(observedStates.get(entry.id) ?? entry.data.state));
+    const needsReconciliation = view.task.workers.some((entry) => isUncertainWorker(observedStates.get(entry.id) ?? entry.data.state));
     const blockers = [...base.data.blockers];
     if (needsReconciliation && !blockers.some((entry) => entry.reason === "worker state requires reconciliation"))
       blockers.push({
@@ -25447,7 +25573,8 @@ class WorkitCore {
         ...current,
         status,
         candidates: resumeCandidate && !current.candidates.some((candidate) => candidate.id === resumeCandidate.id) ? [...current.candidates, resumeCandidate] : current.candidates,
-        progress: status === "paused" ? { ...current.progress, summary: input.reason } : current.progress
+        progress: current.progress,
+        pauseReason: status === "paused" ? input.reason ?? null : null
       })
     });
     if (!changed.ok)
@@ -25483,7 +25610,7 @@ class WorkitCore {
       return workspace;
     if (!workspace.data)
       return failure("not_found", "workspace not found");
-    if (workspace.data.writer || task.data.workers.some((entry) => entry.data.state !== "stopped"))
+    if (workspace.data.writer || task.data.workers.some((entry) => isUncertainWorker(entry.data.state)))
       return failure("recovery_required", "scope revision requires worker ownership reconciliation");
     this.fillRevisions(input, task.data, workspace.data);
     const changed = this.store.mutateTaskAndWorkspace({
@@ -25594,15 +25721,15 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path6.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path6.sep)) {
+  const target = path7.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path7.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
-  while (!existsSync3(ancestor))
-    ancestor = path6.dirname(ancestor);
+  while (!existsSync4(ancestor))
+    ancestor = path7.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path6.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path7.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -25787,14 +25914,14 @@ var gitContext = (workspaceRoot, paths = []) => {
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync4,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import os2 from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 var diagnosticLogger;
 var PRESETS = {
   gitflow: {
@@ -25815,7 +25942,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 ?? path7.join(process.env.XDG_CONFIG_HOME || path7.join(os2.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path8.join(process.env.XDG_CONFIG_HOME || path8.join(os2.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -25825,12 +25952,12 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path7.join(process.env.XDG_CONFIG_HOME || path7.join(os2.homedir(), ".config"), "workflow-toolkit");
-  if (!existsSync4(legacy)) {
+  const legacy = path8.join(process.env.XDG_CONFIG_HOME || path8.join(os2.homedir(), ".config"), "workflow-toolkit");
+  if (!existsSync5(legacy)) {
     migratedDir = dir;
     return dir;
   }
-  if (!migrationFailed && existsSync4(dir)) {
+  if (!migrationFailed && existsSync5(dir)) {
     migratedDir = dir;
     return dir;
   }
@@ -25838,9 +25965,9 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync3(legacy, { withFileTypes: true })) {
-    const src = path7.join(legacy, entry.name);
-    const dest = path7.join(dir, entry.name);
-    if (existsSync4(dest))
+    const src = path8.join(legacy, entry.name);
+    const dest = path8.join(dir, entry.name);
+    if (existsSync5(dest))
       continue;
     try {
       if (entry.isDirectory())
@@ -25913,7 +26040,7 @@ var parseConfigResult = (raw, file) => {
   };
 };
 var readConfigTyped = (dir) => {
-  const file = path7.join(dir ?? configDir(), "config.json");
+  const file = path8.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -25949,9 +26076,9 @@ var COMMIT_PRESETS = [
 
 // packages/workit-core/src/core/workspaces.ts
 import { readFileSync as readFileSync5, realpathSync as realpathSync6 } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path8.join(dir, "workspaces.json");
+  const file = path9.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync5(file, "utf8");
@@ -26049,10 +26176,10 @@ var resolveWorkspace = (cwd) => resolveWorkspaceFrom(cwd, configDir());
 
 // packages/workit-core/src/core/vcs-config.ts
 import fs7 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
 var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path9.join(configDir(), "vcs.json");
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.join(configDir(), "vcs.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
   const r = spawnSync3("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
@@ -26135,8 +26262,8 @@ function vcsConfig(mode, cwd) {
   }
   const prov = cfg[provider] ?? {};
   const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
-  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path9.join(configDir(), `${provider}.token`));
-  const tokenPath = path9.resolve(tokenFile);
+  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path10.join(configDir(), `${provider}.token`));
+  const tokenPath = path10.resolve(tokenFile);
   let tokenOk = false;
   if (fs7.existsSync(tokenPath)) {
     const token = fs7.readFileSync(tokenPath, "utf8").trim();
@@ -26145,7 +26272,7 @@ function vcsConfig(mode, cwd) {
   }
   const out = {
     ok: true,
-    configPath: path9.resolve(cfgPath),
+    configPath: path10.resolve(cfgPath),
     provider,
     defaultTargetBranch: defaultTarget,
     pr: cfg.pr ?? {},
@@ -26238,18 +26365,18 @@ var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig()
 
 // packages/workit-core/src/core/pr-create.ts
 import fs8 from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
   return m ? m[1] : String(value).trim().replace(/^#/, "");
 }
 function whichOnPath(tool) {
   const names = process.platform === "win32" ? [tool, `${tool}.exe`, `${tool}.cmd`] : [tool];
-  for (const dir of (process.env.PATH ?? "").split(path10.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path11.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path10.join(dir, name);
+      const candidate = path11.join(dir, name);
       try {
         fs8.accessSync(candidate, fs8.constants.X_OK);
         return candidate;
@@ -26262,8 +26389,8 @@ var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "gla
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "node:fs";
-import path11 from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "node:fs";
+import path12 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -26397,7 +26524,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path11.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path12.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -26428,8 +26555,8 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path11.join(cwd, "package.json");
-  if (!existsSync5(pkgPath))
+  const pkgPath = path12.join(cwd, "package.json");
+  if (!existsSync6(pkgPath))
     return [];
   try {
     const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
@@ -26454,9 +26581,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path11.join(dir, entry.name), depth + 1);
+        walk(path12.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path11.relative(cwd, path11.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path12.relative(cwd, path12.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -26464,7 +26591,7 @@ var documentationFiles = (cwd) => {
   return matches.sort().slice(0, 200);
 };
 var readTrimmed = (file, maxLines) => {
-  if (!existsSync5(file))
+  if (!existsSync6(file))
     return "";
   const lines = readFileSync6(file, "utf8").split(`
 `);
@@ -26472,7 +26599,7 @@ var readTrimmed = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path11.resolve(repoRoot(root));
+  const cwd = path12.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -26530,7 +26657,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed(path11.join(cwd, template), 220);
+    stdout += readTrimmed(path12.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -26540,7 +26667,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync5(path11.join(cwd, "package.json"))) {
+  if (existsSync6(path12.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -26549,7 +26676,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync5(path11.join(cwd, "Cargo.toml")) || existsSync5(path11.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync6(path12.join(cwd, "Cargo.toml")) || existsSync6(path12.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -26582,7 +26709,7 @@ var CHANGELOG_RULES = `- Use an [Unreleased] section.
 - Apply with the native workit_changelog_apply tool only (not hand-edits under Unreleased).
 - If Unreleased already has duplicate category headings, normalize_only first.`;
 function changelogContext(root, range) {
-  const cwd = path11.resolve(repoRoot(root));
+  const cwd = path12.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -26600,8 +26727,8 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path11.join(cwd, "CHANGELOG.md");
-  if (existsSync5(changelogPath)) {
+  const changelogPath = path12.join(cwd, "CHANGELOG.md");
+  if (existsSync6(changelogPath)) {
     stdout += readTrimmed(changelogPath, 260) + `
 `;
   } else {
@@ -26620,7 +26747,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path11.resolve(repoRoot(root));
+  const cwd = path12.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -26642,8 +26769,8 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path11.join(cwd, "README.md");
-  if (existsSync5(readme)) {
+  const readme = path12.join(cwd, "README.md");
+  if (existsSync6(readme)) {
     stdout += readTrimmed(readme, 220) + `
 `;
   } else {
@@ -26651,8 +26778,8 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path11.join(cwd, "package.json");
-  if (existsSync5(pkgPath)) {
+  const pkgPath = path12.join(cwd, "package.json");
+  if (existsSync6(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
@@ -26665,7 +26792,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path11.resolve(repoRoot(root));
+  const cwd = path12.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -26703,7 +26830,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync5(path11.join(cwd, rel)))
+    if (existsSync6(path12.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -26894,25 +27021,6 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 import fs10 from "node:fs";
 import path13 from "node:path";
 
-// packages/workit-core/src/core/package-root.ts
-import { existsSync as existsSync6 } from "node:fs";
-import path12 from "node:path";
-import { fileURLToPath } from "node:url";
-var packageRoot = () => {
-  let dir = path12.dirname(fileURLToPath(import.meta.url));
-  while (true) {
-    const parent = path12.dirname(dir);
-    if (existsSync6(path12.join(dir, "package.json")) || parent === dir)
-      return dir;
-    dir = parent;
-  }
-};
-var assetRoot = () => {
-  const root = packageRoot();
-  const assets = path12.join(root, "assets");
-  return existsSync6(assets) ? assets : root;
-};
-
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
 
@@ -27416,6 +27524,32 @@ var toolInputSchema = (family) => {
   const schema = boundedOperationJsonSchema(family);
   return { type: "object", ...schema };
 };
+var schemaBranches = (schema) => Array.isArray(schema.oneOf) ? schema.oneOf : Array.isArray(schema.anyOf) ? schema.anyOf : [schema];
+var readOnlyBranches = (family) => schemaBranches(boundedOperationJsonSchema(family)).filter((branch) => {
+  const action = branch.properties?.action?.const;
+  return typeof action === "string" && READ_ONLY_ACTIONS.has(action);
+});
+var advertisedToolSchemas = (attested) => {
+  if (attested)
+    return OPERATION_FAMILIES.map((family) => ({
+      name: `workit_${family}`,
+      description: operationDescription(family),
+      inputSchema: toolInputSchema(family)
+    }));
+  return OPERATION_FAMILIES.flatMap((family) => {
+    const branches = readOnlyBranches(family);
+    if (!branches.length)
+      return [];
+    const schema = boundedOperationJsonSchema(family);
+    return [
+      {
+        name: `workit_${family}`,
+        description: `${operationDescription(family)} Unattested MCP callers can only run read-only actions; mutating operations require an attested host session.`,
+        inputSchema: { type: "object", ...schema, oneOf: branches }
+      }
+    ];
+  });
+};
 var sanitizeFailure = (result, workspaceRoot) => {
   if (result.ok)
     return result;
@@ -27470,13 +27604,16 @@ function createMcpServer(host, contextProvider) {
   ].filter((file) => existsSync7(file)));
   let staleWarned = false;
   const server = new Server({ name: "workit", version: VERSION }, { capabilities: { tools: {}, resources: {} } });
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: OPERATION_FAMILIES.map((family) => ({
-      name: `workit_${family}`,
-      description: operationDescription(family),
-      inputSchema: toolInputSchema(family)
-    }))
-  }));
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    let attested = false;
+    try {
+      const context = await contextProvider.current();
+      attested = context.callerAttested === true;
+    } catch {
+      attested = false;
+    }
+    return { tools: advertisedToolSchemas(attested) };
+  });
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: CONTEXT_KINDS.map((kind) => ({
       uri: `workit://context/${kind}`,
@@ -27591,7 +27728,7 @@ function createMcpServer(host, contextProvider) {
       const parsed = parseOperation(family, request.params.arguments);
       if (!parsed.ok)
         return resultForClient(parsed, workspaceRoot);
-      if (context.callerAttested === false && requiresCallerIdentity(parsed.data))
+      if (context.callerAttested !== true && requiresCallerIdentity(parsed.data))
         return resultForClient({
           ok: false,
           schemaVersion: 1,
@@ -27680,6 +27817,13 @@ var cursorCapabilities = (availability = {}) => {
       reason: has("subagentStart") ? "Cursor subagentStart enforces explicit reviewer/investigator markers; implementer delegation is unavailable" : "Cursor subagentStart is absent",
       refs: [hostRef("subagentStart")]
     },
+    {
+      name: "fresh-context-review",
+      surface: "subagentStart",
+      assurance: has("subagentStart") ? "agent_guided" : "unavailable",
+      reason: has("subagentStart") ? "independent review runs as a bounded reviewer subagent; stops lack stable identity, so reviewer exclusivity is evaluated from recorded evidence" : "Cursor subagentStart is unavailable for independent review",
+      refs: [hostRef("subagentStart")]
+    },
     {
       name: "arbitrary_shell_write",
       surface: "unobservable_shell",