@brainervirus/workit-cursor 1.0.9 → 1.0.11

package/dist/cursor-session-start.js

@@ -7492,7 +7492,7 @@ var SCHEMA_VERSION = 1, POLICY_VERSION = "1.0.0", OPERATION_FAMILIES, uuidPatter
   const covers = (path) => normOuter.paths.some((base) => base === "." || path === base || path.startsWith(`${base}/`)) && !excluded(path, normOuter);
   const innerExcludes = (path) => innerExclusions.some((excludedPath) => excludedPath === path || path.startsWith(`${excludedPath}/`));
   return innerPaths.every(covers) && !normOuter.exclusions.some((excludedPath) => innerPaths.some((base) => (base === "." || excludedPath === base || excludedPath.startsWith(`${base}/`)) && !innerExcludes(excludedPath)));
-}, refSchema, provenanceSchema, entrySchema = (data) => object({ id, recordedAt: utc, provenance: provenanceSchema, data }).strict(), factSchema, signalSchema, signalSet, consequenceSchema, verificationSchema, assessmentSchema, constraintSchema, intentSchema, progressSchema, dimensionSchema, policySchema, requirementSchema, policyChangeSchema, candidateSchema, evidenceSchema, evidenceEvaluationSchema, decisionSchema, findingSchema, assignmentSchema, workerReportSchema, workerSchema, ownerSchema, closureSchema, actionProgressSchema, actionProgressListSchema, taskRecordSchema, workspaceRecordSchema, capabilitySchema, requirementEvaluationSchema, taskViewSchema, taskSummarySchema, exportBundleSchema, callerSchema, base, revisions, taskId, operation = (shape) => object({ ...base, ...shape }).strict(), taskOperations, policyOperations, evidenceOperations, findingOperations, decisionOperations, workerOperations, writerOperations, stateOperations, operationSchemas, compiledOperationSchemas, success = (revisionValue, workspaceRevisionValue, data) => ({
+}, refSchema, provenanceSchema, entrySchema = (data) => object({ id, recordedAt: utc, provenance: provenanceSchema, data }).strict(), factSchema, signalSchema, signalSet, consequenceSchema, verificationSchema, assessmentSchema, constraintSchema, intentSchema, progressSchema, dimensionSchema, policySchema, requirementSchema, policyChangeSchema, candidateSchema, evidenceSchema, evidenceEvaluationSchema, decisionSchema, findingSchema, assignmentSchema, workerReportSchema, workerSchema, ownerSchema, closureSchema, actionProgressSchema, actionProgressListSchema, runtimeSchema, taskRecordSchema, workspaceRecordSchema, capabilitySchema, requirementEvaluationSchema, taskViewSchema, taskSummarySchema, exportBundleSchema, callerSchema, base, revisions, taskId, operation = (shape) => object({ ...base, ...shape }).strict(), taskOperations, policyOperations, evidenceOperations, findingOperations, decisionOperations, workerOperations, writerOperations, stateOperations, operationSchemas, compiledOperationSchemas, success = (revisionValue, workspaceRevisionValue, data) => ({
   ok: true,
   schemaVersion: 1,
   revision: revisionValue,
@@ -7794,10 +7794,12 @@ var init_task_contract = __esm(() => {
       scope: scopeSchema,
       presented: text,
       approvedContent: text,
-      contentRefs: array(refSchema)
+      displayed: text.optional(),
+      contentRefs: array(refSchema),
+      statedChoice: object({ ref: text, text }).strict().optional()
     }).strict(),
     digest,
-    response: _enum(["approved", "rejected"]),
+    response: _enum(["approved", "rejected", "stated"]),
     requirementIds: array(digest),
     revoked: object({ at: utc, reason: text }).strict().nullable(),
     consumption: object({
@@ -7872,6 +7874,10 @@ var init_task_contract = __esm(() => {
         path: ["decisionId"]
       });
   });
+  runtimeSchema = object({
+    createdWith: text.nullable(),
+    updatedWith: text
+  }).strict();
   taskRecordSchema = object({
     schemaVersion: literal(1),
     id,
@@ -7885,6 +7891,8 @@ var init_task_contract = __esm(() => {
     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),
@@ -7900,6 +7908,7 @@ var init_task_contract = __esm(() => {
     id,
     revision,
     root: nonEmpty,
+    runtime: runtimeSchema.optional(),
     writer: object({ state: _enum(["held", "uncertain"]), owner: ownerSchema, acquiredAt: utc }).strict().nullable()
   }).strict();
   capabilitySchema = object({
@@ -7927,6 +7936,9 @@ var init_task_contract = __esm(() => {
     id,
     revision,
     workspaceRevision: revision,
+    createdAt: utc,
+    updatedAt: utc,
+    runtime: runtimeSchema.nullable(),
     objective: text,
     status: _enum(["active", "paused", "closed"]),
     closure: closureSchema.nullable(),
@@ -7996,7 +8008,7 @@ var init_task_contract = __esm(() => {
       expectedWorkspaceRevision: revision.optional(),
       outcome: outcomeSchema,
       summary: text,
-      decisionIds: array(id)
+      decisionIds: array(id).optional()
     })
   };
   policyOperations = {
@@ -8088,14 +8100,15 @@ var init_task_contract = __esm(() => {
       ...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()
     })
   };
   stateOperations = {
@@ -8130,6 +8143,21 @@ var init_task_contract = __esm(() => {
   compiledOperationSchemas = Object.fromEntries(OPERATION_FAMILIES.map((family) => [family, compile(operationSchemas[family])]));
 });
 
+// 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 init_package_root = () => {};
+
 // node_modules/@openclaw/fs-safe/dist/errors.js
 function categorizeFsSafeError(code) {
   return OPERATIONAL_CODES.has(code) ? "operational" : "policy";
@@ -8240,7 +8268,7 @@ var init_read_open_flags = () => {};
 // 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";
 function parseSidecarLockSnapshot(snapshot, parser) {
   return snapshot && { ...snapshot, payload: parseSidecarLockPayload(snapshot.raw, parser) };
 }
@@ -8268,13 +8296,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) {
@@ -8444,7 +8472,7 @@ function sleepSync(ms) {
 
 // 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";
 function getSyncHeldLocks() {
   const globalWithState = globalThis;
   if (!globalWithState[SYNC_HELD_LOCKS_KEY]) {
@@ -8522,26 +8550,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);
@@ -8760,17 +8788,17 @@ var init_file_lock = __esm(() => {
 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";
 
 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)
@@ -8804,7 +8832,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)
@@ -8838,7 +8866,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
         });
@@ -8850,11 +8878,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();
@@ -8876,6 +8910,7 @@ class TaskStore {
         status: "active",
         closure: null,
         progress: { summary: "", nextAction: null, blockers: [] },
+        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
         assessments: [],
         policy: null,
         policyChanges: [],
@@ -8906,7 +8941,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
         });
@@ -8914,11 +8949,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 = {
@@ -8926,7 +8967,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)
@@ -8975,7 +9020,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)
@@ -9009,7 +9055,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)
@@ -9052,7 +9099,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");
@@ -9077,7 +9125,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);
@@ -9104,7 +9153,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]
           });
       }
@@ -9297,7 +9346,8 @@ class TaskStore {
     const value = {
       ...workspace,
       writer: { ...workspace.writer, state: "uncertain" },
-      revision: newRevision()
+      revision: newRevision(),
+      runtime: stampNew(workspace)
     };
     this.replaceSnapshot(this.workspacePath, value, workspace);
   }
@@ -9375,7 +9425,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)}`, {
@@ -9389,9 +9439,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;
@@ -9469,7 +9519,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);
@@ -9511,7 +9561,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 {
@@ -9521,34 +9576,57 @@ 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");
   }
 }
-var processEvidenceSchema, metadataLockSchema, now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"), jsonBytes = (value) => `${canonicalJson(value)}
+var processEvidenceSchema, metadataLockSchema, now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"), cachedRuntimeVersion = null, 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;
+}, stampNew = (record) => ({
+  createdWith: record.runtime?.createdWith ?? null,
+  updatedWith: runtimeVersion()
+}), 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;
+}, jsonBytes = (value) => `${canonicalJson(value)}
 `, digestBytes = (value) => createHash2("sha256").update(value).digest("hex"), isObject2 = (value) => typeof value === "object" && value !== null, validId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value), validDigest = (value) => /^[0-9a-f]{64}$/.test(value), parseMetadataLock = (raw) => {
   let value;
   try {
@@ -9566,6 +9644,7 @@ var processEvidenceSchema, metadataLockSchema, now = () => new Date().toISOStrin
 };
 var init_task_store = __esm(() => {
   init_zod();
+  init_package_root();
   init_file_lock();
   init_task_contract();
   processEvidenceSchema = object({
@@ -9582,10 +9661,63 @@ var init_task_store = __esm(() => {
   }).strict();
 });
 
+// packages/workit-core/src/core/workers.ts
+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);
+}
+var same = (left, right) => {
+  try {
+    return canonicalJson(left) === canonicalJson(right);
+  } catch {
+    return false;
+  }
+}, UNCERTAIN_WORKER_STATES, isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state), callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor }, validPath = (value) => typeof value === "string" && value.length > 0 && ![...value].some((char) => {
+  const code = char.charCodeAt(0);
+  return code < 32 || code === 127;
+}) && !value.split(/[\\/]/).includes(".."), callerValue = (value) => ({ host: value.host, actor: value.actor }), workerIdOf = (value) => value.workerId ?? null;
+var init_workers = __esm(() => {
+  init_task_contract();
+  UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
+});
+
 // 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";
 function applicableDecision(task, purpose, binding, checkoutRoot) {
   if (binding.taskId !== task.id || binding.workspaceId !== task.workspaceId)
     return [];
@@ -9969,20 +10101,31 @@ var verifiedAuthorities, trustedAuthority = (kind, provenance, expected, 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())
@@ -10059,7 +10202,7 @@ var init_authority = __esm(() => {
 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";
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
@@ -10069,7 +10212,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;
@@ -10101,7 +10244,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()) {
@@ -10220,7 +10363,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) {
@@ -10261,7 +10404,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)
@@ -10316,7 +10459,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)
@@ -10342,12 +10495,12 @@ function evaluateClosure(requestedOutcome, view) {
     requirementIds: evaluations.map((item) => item.requirementId)
   });
 }
-var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path5.sep}`), relative = (root, candidate) => path5.relative(root, candidate).split(path5.sep).join("/") || ".", canonicalPath = (value) => {
+var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path6.sep}`), relative = (root, candidate) => path6.relative(root, candidate).split(path6.sep).join("/") || ".", 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(/\/$/, "");
@@ -10389,14 +10542,14 @@ var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex"),
       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 };
 }, walk = (root, directory, output) => {
@@ -10410,7 +10563,7 @@ var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex"),
   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);
@@ -10427,17 +10580,17 @@ var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex"),
 }, 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);
   }
@@ -10459,7 +10612,7 @@ var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex"),
 }, sameSession = (left, right) => {
   const other = sessionFromRef(right);
   return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
-}, evidenceScopes = (task, ids) => (task.policy?.requirements ?? []).filter((requirement) => ids.includes(requirement.id)).map((requirement) => requirement.scope), scopeCovers2, 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"))), 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 })), evidenceMatchesRequirement = (kind, evidenceKind, dimension) => {
+}, evidenceScopes = (task, ids) => (task.policy?.requirements ?? []).filter((requirement) => ids.includes(requirement.id)).map((requirement) => requirement.scope), scopeCovers2, 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"))), 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 })), evidenceMatchesRequirement = (kind, evidenceKind, dimension) => {
   if (kind !== "passed")
     return false;
   if (dimension === "testing" || dimension === "verification")
@@ -10532,7 +10685,18 @@ 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,
+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
@@ -10558,7 +10722,7 @@ var init_methods = __esm(() => {
   METHODS = {
     "workit-challenge": { dimensions: ["challenge", "decisions"] },
     "workit-behavioral-tdd": { dimensions: ["testing"] },
-    "workit-review": { dimensions: ["review"] },
+    "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review"] },
     "workit-plan": { dimensions: ["artifacts", "continuity"] },
     "workit-implement": { dimensions: ["delegation"] },
     "workit-debug": { ruleIds: ["root-cause-investigation"] },
@@ -10576,7 +10740,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",
@@ -10659,6 +10823,7 @@ var COMPACT_MAX_BYTES = 4096, COMPACT_MAX_ITEMS = 8, COMPACT_TEXT_BYTES = 128, s
   task: bundle.task
 });
 var init_task_context = __esm(() => {
+  init_workers();
   init_task_contract();
   init_task_evaluation();
   init_methods();
@@ -10668,7 +10833,9 @@ var init_task_context = __esm(() => {
 });
 
 // packages/workit-core/src/core/route-intent.ts
-var init_route_intent = () => {};
+var init_route_intent = __esm(() => {
+  init_task_store();
+});
 
 // packages/workit-core/src/core/external-action.ts
 var externalActionSchema;
@@ -10687,7 +10854,11 @@ var init_external_action = __esm(() => {
     }).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"),
@@ -10819,7 +10990,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)
@@ -10830,7 +11001,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)
@@ -11082,58 +11253,6 @@ var init_policy_resolver = __esm(() => {
   }).strict();
 });
 
-// packages/workit-core/src/core/workers.ts
-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);
-}
-var same = (left, right) => {
-  try {
-    return canonicalJson(left) === canonicalJson(right);
-  } catch {
-    return false;
-  }
-}, callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor }, validPath = (value) => typeof value === "string" && value.length > 0 && ![...value].some((char) => {
-  const code = char.charCodeAt(0);
-  return code < 32 || code === 127;
-}) && !value.split(/[\\/]/).includes(".."), callerValue = (value) => ({ host: value.host, actor: value.actor }), workerIdOf = (value) => value.workerId ?? null;
-var init_workers = __esm(() => {
-  init_task_contract();
-});
-
 // packages/workit-core/src/core/task-engine.ts
 import { realpathSync as realpathSync4 } from "node:fs";
 
@@ -11195,7 +11314,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;
   }
@@ -11432,11 +11551,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") {
@@ -11453,6 +11567,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))
@@ -11506,7 +11625,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)
@@ -11539,7 +11663,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,
@@ -12348,6 +12472,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,
@@ -12433,7 +12560,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({
@@ -12500,7 +12627,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)
@@ -12536,7 +12664,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({
@@ -12736,15 +12864,20 @@ var provenance = (context, kind = context.provenanceKind ?? "host_observed") =>
     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,
@@ -13072,8 +13205,8 @@ var init_core3 = __esm(() => {
 });
 
 // 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";
 var hostRef = (handle) => ({ kind: "host", host: "cursor", handle }), cursorCapabilities = (availability = {}) => {
   const has = (name) => availability[name] === true;
   return [
@@ -13105,6 +13238,13 @@ var hostRef = (handle) => ({ kind: "host", host: "cursor", handle }), cursorCapa
       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",
@@ -13127,7 +13267,7 @@ var hostRef = (handle) => ({ kind: "host", host: "cursor", handle }), cursorCapa
   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;