@brainervirus/workit-cursor 1.0.8 → 1.0.10

package/dist/workit-hook.js

@@ -3,8 +3,8 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // packages/workit-cursor/hooks/workit-hook.ts
-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";
@@ -7573,6 +7573,7 @@ var decisionSchema = object({
     scope: scopeSchema,
     presented: text,
     approvedContent: text,
+    displayed: text.optional(),
     contentRefs: array(refSchema)
   }).strict(),
   digest,
@@ -7611,7 +7612,7 @@ var workerReportSchema = object({
 }).strict();
 var workerSchema = object({
   assignment: assignmentSchema,
-  state: _enum(["assigned", "running", "cancelling", "stopped", "unknown"]),
+  state: _enum(["assigned", "dispatching", "running", "cancelling", "stopped", "unknown"]),
   session: refSchema.nullable(),
   report: workerReportSchema.nullable()
 }).strict();
@@ -7651,6 +7652,10 @@ var actionProgressListSchema = array(actionProgressSchema).check((ctx) => {
       path: ["decisionId"]
     });
 });
+var runtimeSchema = object({
+  createdWith: text.nullable(),
+  updatedWith: text
+}).strict();
 var taskRecordSchema = object({
   schemaVersion: literal(1),
   id,
@@ -7664,6 +7669,8 @@ var taskRecordSchema = object({
   status: _enum(["active", "paused", "closed"]),
   closure: closureSchema.nullable(),
   progress: progressSchema,
+  pauseReason: text.nullable().optional(),
+  runtime: runtimeSchema.optional(),
   assessments: array(entrySchema(assessmentSchema)),
   policy: policySchema.nullable(),
   policyChanges: array(policyChangeSchema),
@@ -7679,6 +7686,7 @@ var workspaceRecordSchema = object({
   id,
   revision,
   root: nonEmpty,
+  runtime: runtimeSchema.optional(),
   writer: object({ state: _enum(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc }).strict().nullable()
 }).strict();
 var capabilitySchema = object({
@@ -7706,6 +7714,9 @@ var taskSummarySchema = object({
   id,
   revision,
   workspaceRevision: revision,
+  createdAt: utc,
+  updatedAt: utc,
+  runtime: runtimeSchema.nullable(),
   objective: text,
   status: _enum(["active", "paused", "closed"]),
   closure: closureSchema.nullable(),
@@ -7776,7 +7787,7 @@ var taskOperations = {
     expectedWorkspaceRevision: revision.optional(),
     outcome: outcomeSchema,
     summary: text,
-    decisionIds: array(id)
+    decisionIds: array(id).optional()
   })
 };
 var policyOperations = {
@@ -7868,14 +7879,15 @@ var writerOperations = {
     ...taskId,
     expectedRevision: revision.optional(),
     expectedWorkspaceRevision: revision.optional(),
-    workerId: nullableId.optional()
+    workerId: nullableId.optional(),
+    reason: text.optional()
   }),
   release: operation({
     action: literal("release"),
     ...taskId,
     expectedRevision: revision.optional(),
     expectedWorkspaceRevision: revision.optional(),
-    reason: text
+    reason: text.optional()
   })
 };
 var stateOperations = {
@@ -8026,7 +8038,21 @@ function requirementId(input) {
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import * as fs4 from "node:fs";
 import { hostname } 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;
+  }
+};
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -8077,7 +8103,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";
@@ -8167,13 +8193,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) {
@@ -8320,7 +8346,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) {
@@ -8411,26 +8437,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);
@@ -8643,6 +8669,33 @@ var metadataLockSchema = object({
   nonce: string2().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");
@@ -8669,12 +8722,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)
@@ -8708,7 +8761,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)
@@ -8742,7 +8795,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
         });
@@ -8754,11 +8807,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();
@@ -8780,6 +8839,7 @@ class TaskStore {
         status: "active",
         closure: null,
         progress: { summary: "", nextAction: null, blockers: [] },
+        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
         assessments: [],
         policy: null,
         policyChanges: [],
@@ -8810,7 +8870,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
         });
@@ -8818,11 +8878,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 = {
@@ -8830,7 +8896,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)
@@ -8879,7 +8949,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)
@@ -8913,7 +8984,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)
@@ -8956,7 +9028,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");
@@ -8981,7 +9054,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);
@@ -9008,7 +9082,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]
           });
       }
@@ -9201,7 +9275,8 @@ class TaskStore {
     const value = {
       ...workspace,
       writer: { ...workspace.writer, state: "uncertain" },
-      revision: newRevision()
+      revision: newRevision(),
+      runtime: stampNew(workspace)
     };
     this.replaceSnapshot(this.workspacePath, value, workspace);
   }
@@ -9279,7 +9354,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)}`, {
@@ -9293,9 +9368,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;
@@ -9373,7 +9448,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);
@@ -9415,7 +9490,12 @@ class TaskStore {
     if (isObject2(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 = isObject2(value) && isObject2(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 {
@@ -9425,43 +9505,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 = {};
@@ -9588,20 +9723,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())
@@ -9948,14 +10094,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(/\/$/, "");
@@ -10003,14 +10149,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 };
 };
@@ -10025,7 +10171,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);
@@ -10043,17 +10189,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);
   }
@@ -10068,7 +10214,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;
@@ -10100,7 +10246,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()) {
@@ -10257,7 +10403,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) {
@@ -10353,7 +10499,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)
@@ -10380,6 +10536,106 @@ function evaluateClosure(requestedOutcome, view) {
   });
 }
 
+// packages/workit-core/src/core/methods.ts
+var METHODS = {
+  "workit-challenge": { dimensions: ["challenge", "decisions"] },
+  "workit-behavioral-tdd": { dimensions: ["testing"] },
+  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review"] },
+  "workit-plan": { dimensions: ["artifacts", "continuity"] },
+  "workit-implement": { dimensions: ["delegation"] },
+  "workit-debug": { ruleIds: ["root-cause-investigation"] },
+  "workit-handoff": { ruleIds: ["durable-handoff"] },
+  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
+};
+var methodMatches = (id, definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true && !(id === "workit-review" && requirement.ruleId === "self-review") || definition.ruleIds?.includes(requirement.ruleId) === true;
+var assuranceFor = (id, definition, capabilities) => {
+  const keys = new Set([
+    id,
+    ...definition.dimensions ?? [],
+    ...definition.ruleIds ?? []
+  ]);
+  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
+  if (id === "workit-review" && matches.length === 0)
+    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
+  if (matches.some((capability) => capability.assurance === "unavailable"))
+    return {
+      assurance: "unavailable",
+      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
+    };
+  if (matches.some((capability) => capability.assurance === "enforced"))
+    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
+  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
+};
+function selectMethods(policy, capabilities) {
+  return Object.entries(METHODS).flatMap(([id, definition]) => {
+    const requirements = policy.requirements.filter((requirement) => methodMatches(id, definition, requirement));
+    if (requirements.length === 0)
+      return [];
+    const capability = assuranceFor(id, definition, capabilities);
+    const reasons = [
+      ...new Set(requirements.map((requirement) => requirement.reason)),
+      ...capability.reasons
+    ];
+    if (capability.assurance === "unavailable")
+      reasons.unshift("required capability is unavailable");
+    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
+  });
+}
+var invariantBootstrap = () => `
+Workit keeps one accountable lead and one shared task state. Inspect current task
+state before acting. An empty task.list means no session yet, not permission to
+skip Workit; for user-requested product, debug, or behavior work with no active
+or paused task, run task.start then policy.assess before other product mutations.
+Omitted expectedRevision, expectedWorkspaceRevision, and writer workerId default
+to the current records; explicit values are still concurrency-checked, so never
+copy revisions between calls. Happy path: task.list, task.start {intent} with no
+revisions, policy.assess {assessment: {facts, signals, consequences,
+verification}} where facts are inferred or observed with file refs,
+writer.acquire {taskId} before product writes, evidence.record {evidence} where
+check and review kinds auto-bind the current tree and need no digests. Record
+self-review requirements with kind review and reviewContext matching your own
+host session; the lead may also record checks. Fresh-context review requires a
+session distinct from the task creator and every other evidence recorder. Record
+verification evidence last: later evidence or commits can reopen fixed findings
+for re-verification, so verify, resolve, then close with nothing in between.
+decision.record {binding with taskId/workspaceId from inspect plus presented and
+approvedContent} only through a native approval question asked receipt-shaped:
+header Workit decision: <purpose>, the same label repeated in the question
+text (some host UIs do not render headers), exactly two options approved and
+rejected; ask once, never re-ask to mint a receipt. Before asking, present the
+item in the conversation (durable artifacts: complete digest plus exact path;
+inline plans: the content) and keep the question to one short scoped sentence;
+never ask to approve something unseen. An answer with custom text is steering,
+not approval: adjust, re-present, then ask a new scoped question. After the user
+approves a spec or plan, execute the remaining tasks continuously with one
+atomic commit per task and do not ask whether to continue; stop only for a new
+product decision, a failed safety or verification gate, a conflicting edit, or
+missing authority. Record the plan's commit list once through the plan-scoped
+action approval (git.commit with plan_steps and plan_branch) so each listed
+commit executes without a new question; an unlisted message needs a fresh
+approval. task.close {outcome,
+summary, decisionIds}. A completed native subagent run stops its bound worker
+by itself; if a worker strands in cancelling with its run verifiably over,
+repeat worker.cancel {reason} to confirm the stop. Check and review evidence
+without a bound candidate goes stale; findings close only as fixed with passing
+verification, dismissed with supporting evidence, or deferred under an approved
+limitation. Use only the
+shared operations for task, policy, evidence, finding, decision, worker, writer,
+and state changes. Authority is bounded by the requested scope, current
+revision, caller/session provenance, and observed capabilities. Never claim host
+enforcement or evidence that the host cannot provide. Shell-executed writes are
+unattested agent-guided work even when a writer is held. Preserve unresolved
+requirements, gaps, and uncertain workers. Skill routing: slash aliases /wk-*
+always load on demand. Model-invoked: new instructions, interruptions, or
+forgotten items mid-task → load workit-steer before responding; about to open
+a PR or fresh from implementing → load workit-deslop; CI red → load
+workit-green-run; small-looking change before close or merge → load
+workit-blast-radius; ambiguous, consequential, or disputed proposal before
+recommending → load workit-challenge; spec or plan needs a flow diagram →
+load workit-diagram, a UI sketch → load workit-mockup. Load the skill; never
+act from memory of it.
+`.trim();
+
 // packages/workit-core/src/core/task-context.ts
 function reconcileResume(view, observations = []) {
   if (observations.length > 0)
@@ -10389,7 +10645,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) => ["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",
@@ -10439,6 +10695,11 @@ function compactTaskContext(view) {
     digest: entry.data.digest,
     references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
   }));
+  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
+    id: method.id,
+    assurance: method.assurance,
+    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
+  })) : [];
   const gaps = Array.from(new Set([
     ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
     ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
@@ -10448,15 +10709,18 @@ function compactTaskContext(view) {
     objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
     status: view.task.status,
     decisions,
+    methods,
     gaps,
     nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
   };
   let encoded = JSON.stringify(context);
-  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.gaps.length)) {
+  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
     if (context.gaps.length)
       context.gaps.pop();
-    else
+    else if (context.decisions.length)
       context.decisions.pop();
+    else
+      context.methods.pop();
     encoded = JSON.stringify(context);
   }
   if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
@@ -10472,50 +10736,6 @@ var exportDigest = (bundle) => sha256({
   sourceWorkspaceId: bundle.sourceWorkspaceId,
   task: bundle.task
 });
-// packages/workit-core/src/core/methods.ts
-var invariantBootstrap = () => `
-Workit keeps one accountable lead and one shared task state. Inspect current task
-state before acting. An empty task.list means no session yet, not permission to
-skip Workit; for user-requested product, debug, or behavior work with no active
-or paused task, run task.start then policy.assess before other product mutations.
-Omitted expectedRevision, expectedWorkspaceRevision, and writer workerId default
-to the current records; explicit values are still concurrency-checked, so never
-copy revisions between calls. Happy path: task.list, task.start {intent} with no
-revisions, policy.assess {assessment: {facts, signals, consequences,
-verification}} where facts are inferred or observed with file refs,
-writer.acquire {taskId} before product writes, evidence.record {evidence} where
-check and review kinds auto-bind the current tree and need no digests. Record
-self-review requirements with kind review and reviewContext matching your own
-host session; the lead may also record checks. Fresh-context review requires a
-session distinct from the task creator and every other evidence recorder. Record
-verification evidence last: later evidence or commits can reopen fixed findings
-for re-verification, so verify, resolve, then close with nothing in between.
-decision.record {binding with taskId/workspaceId from inspect plus presented and
-approvedContent} only through a native approval question asked receipt-shaped:
-header Workit decision: <purpose>, the same label repeated in the question
-text (some host UIs do not render headers), exactly two options approved and
-rejected; ask once, never re-ask to mint a receipt. task.close {outcome,
-summary, decisionIds}. A completed native subagent run stops its bound worker
-by itself; if a worker strands in cancelling with its run verifiably over,
-repeat worker.cancel {reason} to confirm the stop. Check and review evidence
-without a bound candidate goes stale; findings close only as fixed with passing
-verification, dismissed with supporting evidence, or deferred under an approved
-limitation. Use only the
-shared operations for task, policy, evidence, finding, decision, worker, writer,
-and state changes. Authority is bounded by the requested scope, current
-revision, caller/session provenance, and observed capabilities. Never claim host
-enforcement or evidence that the host cannot provide. Shell-executed writes are
-unattested agent-guided work even when a writer is held. Preserve unresolved
-requirements, gaps, and uncertain workers. Skill routing: slash aliases /wk-*
-always load on demand. Model-invoked: new instructions, interruptions, or
-forgotten items mid-task → load workit-steer before responding; about to open
-a PR or fresh from implementing → load workit-deslop; CI red → load
-workit-green-run; small-looking change before close or merge → load
-workit-blast-radius; ambiguous, consequential, or disputed proposal before
-recommending → load workit-challenge; spec or plan needs a flow diagram →
-load workit-diagram, a UI sketch → load workit-mockup. Load the skill; never
-act from memory of it.
-`.trim();
 // packages/workit-core/src/core/external-action.ts
 var externalActionSchema = discriminatedUnion("operation", [
   object({
@@ -10529,7 +10749,11 @@ var externalActionSchema = discriminatedUnion("operation", [
   }).strict(),
   object({
     operation: literal("git.commit"),
-    payload: object({ message: string2().min(1) }).strict()
+    payload: object({
+      message: string2().min(1).optional(),
+      plan_steps: array(string2().min(1)).optional(),
+      plan_branch: string2().min(1).optional()
+    }).strict()
   }).strict(),
   object({
     operation: literal("git.push"),
@@ -10764,7 +10988,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)
@@ -10775,7 +10999,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)
@@ -10933,59 +11157,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,
@@ -11104,10 +11275,10 @@ var applyWorkerLifecycle = (input) => {
   const notStarted = input.dispatch === true;
   if (notStarted && (input.state !== "stopped" || input.session !== null))
     return failure("invalid_input", "a never-dispatched worker stops with no session");
-  if (notStarted && (entry.data.state === "stopped" || entry.data.state === "unknown"))
-    return failure("invalid_transition", "worker is no longer awaiting dispatch");
-  if (notStarted && (entry.data.session !== null || entry.data.state === "running"))
+  if (notStarted && entry.data.session !== null)
     return failure("invalid_transition", "worker already has an observed session");
+  if (notStarted && !["dispatching", "cancelling"].includes(entry.data.state))
+    return failure("invalid_transition", "worker launch was not claimed");
   if ((input.state === "running" || input.state === "cancelling" || input.state === "stopped" && !notStarted) && !input.session)
     return failure("invalid_input", "running worker observations require a session");
   if (entry.data.session && !sameValue(entry.data.session, input.session))
@@ -11116,15 +11287,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,
@@ -11494,7 +11670,7 @@ class WorkitCore {
   activeWorkerBlocker(task, workspace) {
     if (workspace.writer)
       return failure("recovery_required", "writer ownership must be released first");
-    if (task.workers.some((entry) => ["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;
   }
@@ -11731,11 +11907,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") {
@@ -11752,6 +11923,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))
@@ -12258,7 +12434,12 @@ class WorkitCore {
           return failure("invalid_transition", "worker is not awaiting dispatch");
         return success(mutation.revision, null, {
           ...current,
-          workers: current.workers.map((item) => item.id === input.workerId ? { ...item, recordedAt: mutation.now, provenance: attested.data } : item)
+          workers: current.workers.map((item) => item.id === input.workerId ? {
+            ...item,
+            recordedAt: mutation.now,
+            provenance: attested.data,
+            data: { ...item.data, state: "dispatching" }
+          } : item)
         });
       }
     });
@@ -12642,6 +12823,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,
@@ -12727,7 +12911,7 @@ class WorkitCore {
     const base = reconcileResume(effectiveView);
     if (!base.ok)
       return base;
-    const needsReconciliation = view.task.workers.some((entry) => ["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({
@@ -12794,7 +12978,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)
@@ -12830,7 +13015,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({
@@ -12959,6 +13144,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",
@@ -12992,7 +13184,7 @@ var parseCursorHookInput = (value) => {
   if (!Array.isArray(roots) || roots.length !== 1 || !roots.every(nonEmpty2))
     return { ok: false, error: "exactly one workspace root is required" };
   const root = roots[0];
-  if (!path6.isAbsolute(root) || !existsSync3(root))
+  if (!path7.isAbsolute(root) || !existsSync4(root))
     return { ok: false, error: "workspace root must be an existing absolute path" };
   const event = value.hook_event_name;
   const conversationId = nonEmpty2(value.conversation_id) ? value.conversation_id : undefined;