@brainervirus/workit-opencode 1.0.8 → 1.0.10

package/dist/plugin.js

@@ -14,14 +14,14 @@ var __export = (target, all) => {
 };
 
 // packages/workit-opencode/src/plugin.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import path25 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync3, realpathSync as realpathSync5 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync4, realpathSync as realpathSync5 } from "node:fs";
+import path7 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -7590,6 +7590,7 @@ var decisionSchema = object({
     scope: scopeSchema,
     presented: text,
     approvedContent: text,
+    displayed: text.optional(),
     contentRefs: array(refSchema)
   }).strict(),
   digest,
@@ -7602,6 +7603,27 @@ var decisionSchema = object({
     actionRef: refSchema
   }).strict().nullable()
 }).strict();
+var BINDING_QUESTION_BUDGET = 300;
+var bindingQuestionHeader = /^Workit decision: (design|action|limitation|preference)$/;
+var workitBindingQuestionIssue = (questions) => {
+  if (!Array.isArray(questions) || questions.length !== 1)
+    return null;
+  const question = questions[0];
+  if (!question || typeof question !== "object")
+    return null;
+  if (typeof question.header !== "string" || !bindingQuestionHeader.test(question.header.trim()))
+    return null;
+  const over = (label, value) => `invalid_input: ${label} is ${value.length} characters; Workit binding questions must stay within ${BINDING_QUESTION_BUDGET}. present the item in the conversation first, then ask a short scoped question.`;
+  if (typeof question.question === "string" && question.question.length > BINDING_QUESTION_BUDGET)
+    return over("the question text", question.question);
+  if (Array.isArray(question.options))
+    for (const option of question.options) {
+      const description = option.description;
+      if (typeof description === "string" && description.length > BINDING_QUESTION_BUDGET)
+        return over("an option description", description);
+    }
+  return null;
+};
 var findingSchema = object({
   claim: text,
   consequence: text,
@@ -7628,7 +7650,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();
@@ -7668,6 +7690,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,
@@ -7681,6 +7707,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),
@@ -7696,6 +7724,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({
@@ -7723,6 +7752,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(),
@@ -7793,7 +7825,7 @@ var taskOperations = {
     expectedWorkspaceRevision: revision.optional(),
     outcome: outcomeSchema,
     summary: text,
-    decisionIds: array(id)
+    decisionIds: array(id).optional()
   })
 };
 var policyOperations = {
@@ -7885,14 +7917,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 = {
@@ -8045,7 +8078,26 @@ 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;
+  }
+};
+var assetRoot = () => {
+  const root = packageRoot();
+  const assets = path.join(root, "assets");
+  return existsSync(assets) ? assets : root;
+};
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -8096,7 +8148,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";
@@ -8186,13 +8238,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) {
@@ -8339,7 +8391,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) {
@@ -8430,26 +8482,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);
@@ -8662,6 +8714,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");
@@ -8688,12 +8767,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)
@@ -8727,7 +8806,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)
@@ -8761,7 +8840,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
         });
@@ -8773,11 +8852,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();
@@ -8799,6 +8884,7 @@ class TaskStore {
         status: "active",
         closure: null,
         progress: { summary: "", nextAction: null, blockers: [] },
+        runtime: { createdWith: runtimeVersion(), updatedWith: runtimeVersion() },
         assessments: [],
         policy: null,
         policyChanges: [],
@@ -8829,7 +8915,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
         });
@@ -8837,11 +8923,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 = {
@@ -8849,7 +8941,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)
@@ -8898,7 +8994,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)
@@ -8932,7 +9029,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)
@@ -8975,7 +9073,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");
@@ -9000,7 +9099,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);
@@ -9027,7 +9127,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]
           });
       }
@@ -9220,7 +9320,8 @@ class TaskStore {
     const value = {
       ...workspace,
       writer: { ...workspace.writer, state: "uncertain" },
-      revision: newRevision()
+      revision: newRevision(),
+      runtime: stampNew(workspace)
     };
     this.replaceSnapshot(this.workspacePath, value, workspace);
   }
@@ -9298,7 +9399,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)}`, {
@@ -9312,9 +9413,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;
@@ -9392,7 +9493,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);
@@ -9434,7 +9535,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 {
@@ -9444,43 +9550,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 = {};
@@ -9607,20 +9768,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())
@@ -9967,14 +10139,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(/\/$/, "");
@@ -10022,14 +10194,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 };
 };
@@ -10044,7 +10216,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);
@@ -10062,17 +10234,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);
   }
@@ -10087,7 +10259,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;
@@ -10119,7 +10291,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()) {
@@ -10276,7 +10448,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) {
@@ -10372,7 +10544,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)
@@ -10399,6 +10581,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)
@@ -10408,7 +10690,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",
@@ -10458,6 +10740,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),
@@ -10467,15 +10754,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) {
@@ -10491,51 +10781,49 @@ 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/route-intent.ts
+var GUIDANCE = {
+  "git.branch_setup": "use the Workit git.branch_setup action (workit_external_action in hosts, or `workit action git.branch_setup --payload '{}' --confirm --json` in the CLI)",
+  "hosting.pull_request": "use the Workit hosting.pull_request action (workit_external_action in hosts, or `workit action hosting.pull_request --payload '{...}' --confirm --json` in the CLI), then drive the created PR through workit-babysit"
+};
+var unbalancedQuotes = (segment) => {
+  const text = segment.replace(/\\./gu, "");
+  return (text.match(/"/gu)?.length ?? 0) % 2 !== 0 || (text.match(/'/gu)?.length ?? 0) % 2 !== 0;
+};
+var segmentTokens = (segment) => {
+  if (segment.includes("`") || segment.includes("$("))
+    return null;
+  if (unbalancedQuotes(segment))
+    return null;
+  const parts = segment.trim().split(/\s+/u);
+  while (parts.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(parts[0]))
+    parts.shift();
+  return parts.length > 0 ? parts : null;
+};
+var unquote = (token) => token.replace(/^['"]|['"]$/gu, "");
+function shellRouteIntent(command) {
+  if (typeof command !== "string" || command.trim() === "")
+    return null;
+  for (const raw of command.split(/&&|\|\||;|\n/u)) {
+    const parts = segmentTokens(raw);
+    if (!parts)
+      continue;
+    const head = unquote(parts[0]);
+    const second = unquote(parts[1] ?? "");
+    const third = unquote(parts[2] ?? "");
+    if (head === "git" && second === "switch" && (third === "-c" || third === "--create"))
+      return { route: "git.branch_setup", guidance: GUIDANCE["git.branch_setup"] };
+    if (head === "git" && second === "checkout" && (third === "-b" || third === "-B"))
+      return { route: "git.branch_setup", guidance: GUIDANCE["git.branch_setup"] };
+    if (head === "gh" && second === "pr" && third === "create")
+      return { route: "hosting.pull_request", guidance: GUIDANCE["hosting.pull_request"] };
+    if (head === "glab" && second === "mr" && third === "create")
+      return { route: "hosting.pull_request", guidance: GUIDANCE["hosting.pull_request"] };
+  }
+  return null;
+}
 // packages/workit-core/src/core/external-action.ts
+import { execFileSync } from "node:child_process";
 var externalActionSchema = discriminatedUnion("operation", [
   object({
     operation: literal("git.branch_setup"),
@@ -10548,7 +10836,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"),
@@ -10637,7 +10929,7 @@ var externalActionDescriptor = (operation, payload) => canonicalJson({
   payload,
   ...payload && typeof payload === "object" && !Array.isArray(payload) && "resolved" in payload && payload.resolved && typeof payload.resolved === "object" && Array.isArray(payload.resolved.steps) ? { steps: payload.resolved.steps } : {}
 });
-var externalActionHelp = "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch?,stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
+var externalActionHelp = "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
 var externalActionRef = (host, actor, descriptor) => ({
   kind: "host",
   host,
@@ -10688,6 +10980,92 @@ var priorExternalAction = (store, host, actor, operation, payload) => {
     return failure("permission_denied", candidates.length === 0 ? "no prior external action matches this request" : "multiple prior external actions match this request");
   return success(workspace.data.revision, null, { ...candidates[0], workspace: workspace.data });
 };
+var planCommitDescriptor = (content) => {
+  try {
+    const value = JSON.parse(content);
+    if (value.operation !== "git.commit" || !value.payload)
+      return null;
+    const steps = value.payload.plan_steps;
+    const branch = value.payload.plan_branch;
+    if (!Array.isArray(steps) || steps.some((step) => typeof step !== "string" || !step) || typeof branch !== "string" || !branch)
+      return null;
+    return { steps, branch };
+  } catch {
+    return null;
+  }
+};
+var approvedPlanCommit = (store, host, actor, message) => {
+  if (typeof message !== "string" || !message)
+    return failure("invalid_input", "commit message is required");
+  const listed = store.listTasks();
+  const workspace = store.readWorkspace();
+  if (!listed.ok || !workspace.ok)
+    return failure("storage_error", "external action state is unavailable");
+  if (!workspace.data)
+    return failure("not_found", "workspace not found");
+  const matches = listed.data.flatMap((task) => {
+    if (task.status !== "active" || task.workspaceId !== workspace.data.id)
+      return [];
+    if (task.intent.provenance.session?.kind !== "host" || task.intent.provenance.session.host !== host || task.intent.provenance.session.handle !== actor)
+      return [];
+    return task.decisions.flatMap((entry) => {
+      const decision = entry.data;
+      if (decision.purpose !== "action" || decision.response !== "approved" || decision.revoked !== null)
+        return [];
+      if (entry.provenance.kind !== "host_observed" || entry.provenance.receipts.length === 0)
+        return [];
+      const plan = planCommitDescriptor(decision.binding.approvedContent);
+      if (!plan)
+        return [];
+      const completed = task.actionProgress?.find((progress) => progress.decisionId === entry.id)?.completedSteps ?? [];
+      if (plan.steps[completed.length] !== message)
+        return [];
+      return [{ task, entry, steps: plan.steps, branch: plan.branch, completed: [...completed] }];
+    });
+  });
+  if (matches.length !== 1)
+    return failure("permission_denied", matches.length === 0 ? "no plan commit authorization matches this message" : "multiple plan authorizations match this message");
+  return success(workspace.data.revision, null, matches[0]);
+};
+var commitMessageFromDescriptor = (operation) => {
+  try {
+    const descriptor = JSON.parse(operation);
+    return descriptor.operation === "git.commit" && typeof descriptor.payload?.message === "string" ? descriptor.payload.message : undefined;
+  } catch {
+    return;
+  }
+};
+var planCommitBinding = (store, host, actor, operation) => {
+  const message = commitMessageFromDescriptor(operation);
+  if (!message)
+    return null;
+  const plan = approvedPlanCommit(store, host, actor, message);
+  if (!plan.ok)
+    return null;
+  let branch;
+  try {
+    branch = execFileSync("git", ["branch", "--show-current"], {
+      cwd: store.root,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+  if (!branch || branch !== plan.data.branch)
+    return null;
+  const workspace = store.readWorkspace();
+  if (!workspace.ok || !workspace.data)
+    return null;
+  return {
+    taskId: plan.data.task.id,
+    decisionId: plan.data.entry.id,
+    binding: plan.data.entry.data.binding,
+    expectedRevision: plan.data.task.revision,
+    expectedWorkspaceRevision: workspace.data.revision,
+    step: message
+  };
+};
 var approvedExternalAction = (store, host, actor, operation) => {
   const selected = externalActionState(store, host, actor, operation);
   if (!selected.ok)
@@ -10696,6 +11074,23 @@ var approvedExternalAction = (store, host, actor, operation) => {
     return failure(selected.data.entry.data.consumption.state === "uncertain" ? "external_outcome_unknown" : "permission_denied", selected.data.entry.data.consumption.state === "uncertain" ? "previous external action outcome is unknown" : "external action was already settled");
   return selected;
 };
+var priorResolvedDrift = (store, host, actor, operation, payload, currentResolved) => {
+  const prior = priorExternalAction(store, host, actor, operation, payload);
+  if (!prior.ok)
+    return success(null, null, null);
+  let baseline;
+  try {
+    const parsed = JSON.parse(prior.data.entry.data.binding.approvedContent);
+    baseline = parsed.payload?.resolved;
+  } catch {
+    return success(null, null, null);
+  }
+  if (baseline === undefined || baseline === null)
+    return success(null, null, null);
+  if (canonicalJson(baseline) === canonicalJson(currentResolved))
+    return success(null, null, null);
+  return failure("invalid_input", "repository state changed since approval; show the current state and approve the action again", { outcome: "not_started", operation });
+};
 var createAuthorizedExternalActionRunner = (core, bind) => async (operation, effect) => {
   let steps = [];
   try {
@@ -10973,7 +11368,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)
@@ -10984,7 +11379,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)
@@ -11142,59 +11537,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,
@@ -11313,10 +11655,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))
@@ -11325,15 +11667,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,
@@ -11703,7 +12050,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;
   }
@@ -11940,11 +12287,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") {
@@ -11961,6 +12303,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))
@@ -12467,7 +12814,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)
         });
       }
     });
@@ -12851,6 +13203,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,
@@ -12936,7 +13291,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({
@@ -13003,7 +13358,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)
@@ -13039,7 +13395,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({
@@ -13157,15 +13513,15 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path6.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path6.sep)) {
+  const target = path7.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path7.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
-  while (!existsSync3(ancestor))
-    ancestor = path6.dirname(ancestor);
+  while (!existsSync4(ancestor))
+    ancestor = path7.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path6.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path7.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -13207,7 +13563,7 @@ if (false) {}
 // packages/workit-core/src/core/logger.ts
 import { appendFileSync, mkdirSync as mkdirSync2, readdirSync as readdirSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import os from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 var REDACTED = "[REDACTED]";
 var DEFAULT_MAX_RATE = 20;
 var DEFAULT_RATE_WINDOW_MS = 1000;
@@ -13263,14 +13619,14 @@ var resolveStateDir = () => {
     return override;
   const home = os.homedir();
   if (process.env.XDG_STATE_HOME)
-    return path7.join(process.env.XDG_STATE_HOME, "workit");
+    return path8.join(process.env.XDG_STATE_HOME, "workit");
   switch (os.platform()) {
     case "darwin":
-      return path7.join(home, "Library", "Application Support", "workit");
+      return path8.join(home, "Library", "Application Support", "workit");
     case "win32":
-      return path7.join(process.env.LOCALAPPDATA ?? path7.join(home, "AppData", "Local"), "workit");
+      return path8.join(process.env.LOCALAPPDATA ?? path8.join(home, "AppData", "Local"), "workit");
     default:
-      return path7.join(process.env.HOME ?? home, ".local", "state", "workit");
+      return path8.join(process.env.HOME ?? home, ".local", "state", "workit");
   }
 };
 var homePattern = new RegExp(`${escapeRegExp(os.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
@@ -13343,14 +13699,14 @@ var pruneOldFiles = (dir) => {
     const files = readdirSync3(dir).filter((name) => DAY_FILE.test(name)).sort().reverse();
     for (const file of files.slice(RETAINED_DAYS)) {
       try {
-        unlinkSync2(path7.join(dir, file));
+        unlinkSync2(path8.join(dir, file));
       } catch {}
     }
   } catch {}
 };
 var createLogger = (options = {}) => {
   const stateDir = options.stateDir ?? resolveStateDir();
-  const logDir = path7.join(stateDir, "logs");
+  const logDir = path8.join(stateDir, "logs");
   const now = options.now ?? (() => new Date);
   const maxRate = options.maxRate ?? DEFAULT_MAX_RATE;
   const rateWindowMs = options.rateWindowMs ?? DEFAULT_RATE_WINDOW_MS;
@@ -13384,7 +13740,7 @@ var createLogger = (options = {}) => {
       const line = `${JSON.stringify(event)}
 `;
       mkdirSync2(logDir, { recursive: true, mode: 448 });
-      appendFileSync(path7.join(logDir, dailyFileName(date)), line, { mode: 384 });
+      appendFileSync(path8.join(logDir, dailyFileName(date)), line, { mode: 384 });
       pruneOldFiles(logDir);
     } catch {
       try {
@@ -13395,7 +13751,7 @@ var createLogger = (options = {}) => {
           context: { redaction_failed: true }
         };
         mkdirSync2(logDir, { recursive: true, mode: 448 });
-        appendFileSync(path7.join(logDir, dailyFileName(date)), `${JSON.stringify(event)}
+        appendFileSync(path8.join(logDir, dailyFileName(date)), `${JSON.stringify(event)}
 `, {
           mode: 384
         });
@@ -13478,6 +13834,24 @@ OpenCode Workit decisions use the native question header "Workit decision: <purp
   return cached2;
 };
 
+// packages/workit-opencode/src/stale-sources.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var pluginSourceFiles = [
+  fileURLToPath2(import.meta.url),
+  fileURLToPath2(new URL("./plugin.ts", import.meta.url)),
+  fileURLToPath2(new URL("./tools/workit.ts", import.meta.url)),
+  ...[
+    "task-contract.ts",
+    "task-engine.ts",
+    "task-evaluation.ts",
+    "task-store.ts",
+    "workers.ts",
+    "authority.ts",
+    "methods.ts"
+  ].map((file) => fileURLToPath2(new URL(`../../workit-core/src/core/${file}`, import.meta.url)))
+].filter((file) => existsSync5(file));
+
 // packages/workit-opencode/src/tools/repo.ts
 import path22 from "node:path";
 import { realpathSync as realpathSync8 } from "node:fs";
@@ -25807,25 +26181,6 @@ import fs7 from "node:fs";
 import path9 from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 
-// packages/workit-core/src/core/package-root.ts
-import { existsSync as existsSync4 } from "node:fs";
-import path8 from "node:path";
-import { fileURLToPath } from "node:url";
-var packageRoot = () => {
-  let dir = path8.dirname(fileURLToPath(import.meta.url));
-  while (true) {
-    const parent = path8.dirname(dir);
-    if (existsSync4(path8.join(dir, "package.json")) || parent === dir)
-      return dir;
-    dir = parent;
-  }
-};
-var assetRoot = () => {
-  const root = packageRoot();
-  const assets = path8.join(root, "assets");
-  return existsSync4(assets) ? assets : root;
-};
-
 // packages/workit-core/src/core/scripts.ts
 var PLUGIN_ROOT = packageRoot();
 var ASSET_ROOT = assetRoot();
@@ -26158,10 +26513,10 @@ function changelogApply({
 }
 
 // packages/workit-core/src/core/git.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 var run2 = (cwd, args) => {
   try {
-    const stdout = execFileSync("git", args, {
+    const stdout = execFileSync2("git", args, {
       cwd,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -26279,15 +26634,15 @@ function parseVerifyOutput(stdout) {
 }
 
 // packages/workit-core/src/core/branch.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import path13 from "node:path";
 
 // packages/workit-core/src/core/config.ts
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync4,
   readdirSync as readdirSync4,
@@ -26327,11 +26682,11 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     return dir;
   }
   const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os2.homedir(), ".config"), "workflow-toolkit");
-  if (!existsSync5(legacy)) {
+  if (!existsSync6(legacy)) {
     migratedDir = dir;
     return dir;
   }
-  if (!migrationFailed && existsSync5(dir)) {
+  if (!migrationFailed && existsSync6(dir)) {
     migratedDir = dir;
     return dir;
   }
@@ -26341,7 +26696,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   for (const entry of readdirSync4(legacy, { withFileTypes: true })) {
     const src = path10.join(legacy, entry.name);
     const dest = path10.join(dir, entry.name);
-    if (existsSync5(dest))
+    if (existsSync6(dest))
       continue;
     try {
       if (entry.isDirectory())
@@ -26919,7 +27274,7 @@ var baseBranch = (cwd) => {
   return { base: String(resolved.defaultTargetBranch ?? "develop") };
 };
 var originBaseReady = (cwd, base) => {
-  const run = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  const run = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   try {
     try {
       run(["fetch", "origin", base, "--prune"]);
@@ -26927,7 +27282,7 @@ var originBaseReady = (cwd, base) => {
       run(["fetch", "origin", "--prune"]);
     }
     try {
-      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
+      execFileSync3("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
         cwd,
         stdio: "pipe"
       });
@@ -26946,11 +27301,11 @@ var originBaseReady = (cwd, base) => {
   }
 };
 var fastForwardBase = (cwd, base) => {
-  const run = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  const run = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   try {
     let hasLocalBase = true;
     try {
-      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
+      execFileSync3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
         cwd,
         stdio: "pipe"
       });
@@ -26991,18 +27346,17 @@ var branchSetup = ({
   log
 }) => {
   const cwd = path13.resolve(workspace_root);
-  const exec = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  const exec = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
   const current = gitContext(cwd).branch;
   if (!current || current === "unknown")
-    return { error: "not in a git repository" };
+    return { error: "not in a git repository", phase: "preflight" };
   const sdd = sdd_dir ?? "docs";
   const manifestPath = path13.isAbsolute(sdd) ? path13.join(sdd, "manifest.json") : path13.join(cwd, sdd, "manifest.json");
   const ensureManifestDir = () => {
     const dir = path13.dirname(manifestPath);
-    if (!existsSync6(dir))
+    if (!existsSync7(dir))
       mkdirSync4(dir, { recursive: true, mode: 493 });
   };
-  ensureManifestDir();
   const readManifest = () => {
     try {
       return JSON.parse(readFileSync6(manifestPath, "utf8"));
@@ -27020,13 +27374,16 @@ var branchSetup = ({
     const manifest = readManifest();
     const ref = manifest.stash_ref;
     if (!ref)
-      return { error: "no stash_ref in manifest" };
+      return { error: "no stash_ref in manifest", phase: "preflight" };
     journal(`pre-pop: ${String(ref)}`);
     try {
       exec(["stash", "pop", String(ref)]);
     } catch (error) {
       journal("pop: failed");
-      return { error: error instanceof Error ? error.message : "stash pop failed" };
+      return {
+        error: error instanceof Error ? error.message : "stash pop failed",
+        phase: "post_mutation"
+      };
     }
     journal("pop: ok");
     delete manifest.stash_ref;
@@ -27036,11 +27393,17 @@ var branchSetup = ({
   }
   const target = target_branch ?? "";
   if (!target)
-    return { error: "target branch required" };
+    return {
+      error: "target_branch (the working branch to create or switch to) is required for setup",
+      phase: "preflight"
+    };
   if (isProtected(cwd, target))
-    return { error: `protected branch ${target}` };
+    return { error: `protected branch ${target}`, phase: "preflight" };
   if (!allowedBranch(cwd, target))
-    return { error: `target branch ${target} is not allowed by the branch policy` };
+    return {
+      error: `target branch ${target} is not allowed by the branch policy`,
+      phase: "preflight"
+    };
   let base;
   let targetExists = true;
   try {
@@ -27051,12 +27414,12 @@ var branchSetup = ({
   if (!targetExists) {
     const baseResolved = baseBranch(cwd);
     if ("error" in baseResolved)
-      return { error: baseResolved.error };
+      return { error: baseResolved.error, phase: "preflight" };
     base = baseResolved.base;
   }
   journal(`entry: current=${current} target=${target} base=${base ?? "-"}`);
   let stash_ref;
-  const failAfterStash = (message) => {
+  const failAfterStash = (message, phase = "post_mutation") => {
     let suffix = "";
     if (stash_ref) {
       journal(`pre-pop: ${stash_ref}`);
@@ -27069,27 +27432,31 @@ var branchSetup = ({
         suffix = " (changes preserved in stash)";
       }
     }
-    return { error: `${message}${suffix}` };
+    return { error: `${message}${suffix}`, phase: stash_ref ? "post_mutation" : phase };
   };
   if (current !== target) {
     const dirty = Boolean(gitContext(cwd).status_short.trim());
     if (dirty && stash !== "yes") {
       return {
-        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes"
+        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes",
+        phase: "preflight"
       };
     }
     let validatedBase;
     if (!targetExists && base !== undefined) {
       const ready = originBaseReady(cwd, base);
       if (!ready.ok)
-        return { error: ready.error ?? "ensure-base-branch failed" };
+        return { error: ready.error ?? "ensure-base-branch failed", phase: "preflight" };
       validatedBase = base;
     }
     if (dirty) {
       try {
         exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`]);
       } catch (error) {
-        return { error: error instanceof Error ? error.message : "stash push failed" };
+        return {
+          error: error instanceof Error ? error.message : "stash push failed",
+          phase: "post_mutation"
+        };
       }
       stash_ref = "stash@{0}";
       journal(`stash push: ${stash_ref}`);
@@ -27100,14 +27467,14 @@ var branchSetup = ({
     } catch (error) {
       const message = error instanceof Error ? error.message : "checkout failed";
       if (/worktree/i.test(message)) {
-        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`);
+        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`, "preflight");
       }
       try {
         let effectiveBase = base;
         if (effectiveBase === undefined) {
           const lateResolved = baseBranch(cwd);
           if ("error" in lateResolved)
-            return failAfterStash(lateResolved.error);
+            return failAfterStash(lateResolved.error, "preflight");
           effectiveBase = lateResolved.base;
         }
         const baseResult = validatedBase !== undefined ? fastForwardBase(cwd, effectiveBase) : ensureBaseBranch(cwd, effectiveBase);
@@ -27153,7 +27520,7 @@ var branchSetup = ({
 };
 
 // packages/workit-core/src/core/gitignore.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import path14 from "node:path";
 var GITIGNORE_ENTRIES = [
   "# workit: SDD working state (never commit)",
@@ -27175,7 +27542,7 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
   const file = path14.join(workspaceRoot, ".gitignore");
-  const existing = existsSync7(file) ? readFileSync7(file, "utf8") : "";
+  const existing = existsSync8(file) ? readFileSync7(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
   const added = [];
@@ -27194,19 +27561,19 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
 ` : "") + append.join(`
 `) + `
 `, "utf8");
-  } else if (!existsSync7(file)) {
+  } else if (!existsSync8(file)) {
     writeFileSync4(file, "", "utf8");
   }
   return { ok: true, path: file, added };
 };
 
 // packages/workit-core/src/core/hygiene.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
 import path15 from "node:path";
 var repoRoot = assetRoot();
 var templatesDir = () => path15.join(repoRoot, "templates", "hygiene");
 var packageJson = (root) => {
-  if (!existsSync8(path15.join(root, "package.json")))
+  if (!existsSync9(path15.join(root, "package.json")))
     return null;
   try {
     return JSON.parse(readFileSync8(path15.join(root, "package.json"), "utf8"));
@@ -27215,7 +27582,7 @@ var packageJson = (root) => {
   }
 };
 var isOpenSource = (root) => {
-  if (existsSync8(path15.join(root, "LICENSE")))
+  if (existsSync9(path15.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
@@ -27243,10 +27610,10 @@ var planHygieneFiles = (root, opts = {}) => {
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync8(path15.join(root, file)))
+    if (existsSync9(path15.join(root, file)))
       continue;
     const tpl = path15.join(templatesDir(), file);
-    if (!existsSync8(tpl))
+    if (!existsSync9(tpl))
       continue;
     const content = readFileSync8(tpl, "utf8").replace(/<PROJECT>/g, path15.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
     planned.push({ path: path15.join(root, file), content });
@@ -27266,7 +27633,7 @@ var ensureHygieneFiles = (root, opts) => {
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync5 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync9, readdirSync as readdirSync5 } from "node:fs";
 import path16 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
@@ -27433,7 +27800,7 @@ var diffStatForRange = (cwd, range) => {
 };
 var packageScripts = (cwd, keys) => {
   const pkgPath = path16.join(cwd, "package.json");
-  if (!existsSync9(pkgPath))
+  if (!existsSync10(pkgPath))
     return [];
   try {
     const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
@@ -27468,7 +27835,7 @@ var documentationFiles = (cwd) => {
   return matches.sort().slice(0, 200);
 };
 var readTrimmed = (file, maxLines) => {
-  if (!existsSync9(file))
+  if (!existsSync10(file))
     return "";
   const lines = readFileSync9(file, "utf8").split(`
 `);
@@ -27544,7 +27911,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync9(path16.join(cwd, "package.json"))) {
+  if (existsSync10(path16.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -27553,7 +27920,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync9(path16.join(cwd, "Cargo.toml")) || existsSync9(path16.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync10(path16.join(cwd, "Cargo.toml")) || existsSync10(path16.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -27605,7 +27972,7 @@ function changelogContext(root, range) {
 `;
   stdout += printSection("Existing CHANGELOG.md");
   const changelogPath = path16.join(cwd, "CHANGELOG.md");
-  if (existsSync9(changelogPath)) {
+  if (existsSync10(changelogPath)) {
     stdout += readTrimmed(changelogPath, 260) + `
 `;
   } else {
@@ -27647,7 +28014,7 @@ function docsRefreshContext(root, range) {
 `;
   stdout += printSection("README Preview");
   const readme = path16.join(cwd, "README.md");
-  if (existsSync9(readme)) {
+  if (existsSync10(readme)) {
     stdout += readTrimmed(readme, 220) + `
 `;
   } else {
@@ -27656,7 +28023,7 @@ function docsRefreshContext(root, range) {
   }
   stdout += printSection("Package Scripts");
   const pkgPath = path16.join(cwd, "package.json");
-  if (existsSync9(pkgPath)) {
+  if (existsSync10(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
@@ -27707,7 +28074,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync9(path16.join(cwd, rel)))
+    if (existsSync10(path16.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -27736,7 +28103,7 @@ function releaseNotesContext(root, rangeOrTag) {
 
 // packages/workit-core/src/core/verify-project.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
 import path17 from "node:path";
 var commandOnPath = (name) => {
   const dirs = (process.env.PATH ?? "").split(path17.delimiter);
@@ -27761,7 +28128,7 @@ var commandOnPath = (name) => {
 };
 var hasScript = (cwd, name) => {
   const pkgPath = path17.join(cwd, "package.json");
-  if (!existsSync10(pkgPath))
+  if (!existsSync11(pkgPath))
     return false;
   try {
     const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
@@ -27771,10 +28138,10 @@ var hasScript = (cwd, name) => {
   }
 };
 var packageRunner = (cwd) => {
-  if (existsSync10(path17.join(cwd, "pnpm-lock.yaml")))
+  if (existsSync11(path17.join(cwd, "pnpm-lock.yaml")))
     return "pnpm";
   const pkgPath = path17.join(cwd, "package.json");
-  if (existsSync10(pkgPath)) {
+  if (existsSync11(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
       if (typeof pkg.packageManager === "string" && pkg.packageManager.startsWith("pnpm")) {
@@ -27782,7 +28149,7 @@ var packageRunner = (cwd) => {
       }
     } catch {}
   }
-  if (existsSync10(path17.join(cwd, "yarn.lock")))
+  if (existsSync11(path17.join(cwd, "yarn.lock")))
     return "yarn";
   return "npm";
 };
@@ -27843,7 +28210,7 @@ root: ${cwd}
   lines.push(`dry_run: ${String(dryRun)}
 `);
   const pkgPath = path17.join(cwd, "package.json");
-  if (existsSync10(pkgPath)) {
+  if (existsSync11(pkgPath)) {
     const runner = packageRunner(cwd);
     for (const script of ["lint", "format:check", "test", "build"]) {
       if (hasScript(cwd, script)) {
@@ -27858,7 +28225,7 @@ root: ${cwd}
   } else {
     skipCheck("javascript", "package.json not found");
   }
-  const cargoManifest = existsSync10(path17.join(cwd, "Cargo.toml")) ? "Cargo.toml" : existsSync10(path17.join(cwd, "src-tauri/Cargo.toml")) ? "src-tauri/Cargo.toml" : "";
+  const cargoManifest = existsSync11(path17.join(cwd, "Cargo.toml")) ? "Cargo.toml" : existsSync11(path17.join(cwd, "src-tauri/Cargo.toml")) ? "src-tauri/Cargo.toml" : "";
   if (cargoManifest) {
     runCheck("cargo fmt", "cargo", ["fmt", "--manifest-path", cargoManifest, "--", "--check"]);
     runCheck("cargo clippy", "cargo", [
@@ -27874,7 +28241,7 @@ root: ${cwd}
   } else {
     skipCheck("rust", "Cargo.toml not found");
   }
-  if (existsSync10(path17.join(cwd, "pyproject.toml")) || existsSync10(path17.join(cwd, "pytest.ini")) || existsSync10(path17.join(cwd, "tests"))) {
+  if (existsSync11(path17.join(cwd, "pyproject.toml")) || existsSync11(path17.join(cwd, "pytest.ini")) || existsSync11(path17.join(cwd, "tests"))) {
     if (commandOnPath("pytest"))
       runCheck("pytest", "pytest", []);
     else
@@ -27896,7 +28263,7 @@ root: ${cwd}
     lines.push(`status: skipped (dry run)
 `);
     skipped += 1;
-  } else if (existsSync10(changelogPath)) {
+  } else if (existsSync11(changelogPath)) {
     if (/## \[Unreleased\]/i.test(readFileSync10(changelogPath, "utf8"))) {
       lines.push(`status: pass
 `);
@@ -28231,7 +28598,7 @@ function writeFileExclusive(file, content, mode) {
 import {
   copyFileSync as copyFileSync2,
   cpSync as cpSync2,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync5,
   mkdtempSync,
@@ -29772,7 +30139,7 @@ function createRepoTools(runtime = defaultRuntime) {
         return output(legacyScriptResult({
           stdout: JSON.stringify(result),
           stderr: "",
-          exitCode: result.error ? 1 : 0,
+          exitCode: "error" in result ? 1 : 0,
           cwd: context.directory
         }));
       }
@@ -30420,6 +30787,94 @@ var safePath = (root, value) => {
     return null;
   }
 };
+var branchCreationBaseline = (root, target, base) => {
+  const exists = gitValue(root, ["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]) !== null;
+  if (exists)
+    return { base_branch: base, target_exists: true, remote_base: null };
+  const remote = run4(root, ["ls-remote", "origin", `refs/heads/${base}`]);
+  const sha = remote.exitCode === 0 ? remote.stdout.trim().split(/\s+/)[0] : "";
+  return {
+    base_branch: base,
+    target_exists: false,
+    remote_base: /^[0-9a-f]{40}$/.test(sha ?? "") ? sha : null
+  };
+};
+var shortSha = (value) => typeof value === "string" && value ? value.slice(0, 8) : "unknown";
+var isProtectedBranch2 = (root, branch) => resolveBranchPolicyFor(root).protected.has(branch.toLowerCase());
+var actionProposalQuestion = (request, descriptorPayload) => {
+  const payload = descriptorPayload ?? {};
+  const resolved = payload.resolved ?? {};
+  const payloadTarget = String(payload.target_branch ?? "");
+  if (request.operation === "git.commit" && Array.isArray(payload.plan_steps)) {
+    const steps = payload.plan_steps;
+    return {
+      presented: `Workit decision: action — Approve committing the plan's ${steps.length} listed tasks on \`${String(payload.plan_branch ?? "")}\`?`,
+      approvedText: `Approve the ${steps.length} listed plan commits.`
+    };
+  }
+  switch (request.operation) {
+    case "git.branch_setup": {
+      if (request.payload.action === "reapply_stash")
+        return {
+          presented: "Workit decision: action — Reapply the pre-checkout stash recorded in the branch manifest?",
+          approvedText: "Reapply the recorded stash."
+        };
+      const target = String(payload.target_branch ?? "");
+      if (resolved.target_exists === true)
+        return {
+          presented: `Workit decision: action — Switch to branch \`${target}\`?`,
+          approvedText: `Switch to \`${target}\`.`
+        };
+      const base = String(resolved.base_branch ?? "the base branch");
+      return {
+        presented: `Workit decision: action — Create branch \`${target}\` from \`${base}\` (currently ${shortSha(resolved.remote_base)})?`,
+        approvedText: `Create \`${target}\` from \`${base}\` at ${shortSha(resolved.remote_base)}.`
+      };
+    }
+    case "git.commit": {
+      const paths = Array.isArray(resolved.paths) ? resolved.paths : [];
+      return {
+        presented: `Workit decision: action — Commit ${paths.length} staged file(s) as "${String(request.payload.message)}"?`,
+        approvedText: `Commit as "${String(request.payload.message)}".`
+      };
+    }
+    case "git.push":
+      return {
+        presented: `Workit decision: action — Push branch \`${String(payload.branch ?? "")}\` to origin?`,
+        approvedText: `Push \`${String(payload.branch ?? "")}\` to origin.`
+      };
+    case "hosting.pull_request":
+      return {
+        presented: `Workit decision: action — Open a PR from \`${String(resolved.source_branch ?? "")}\` to \`${payloadTarget}\` titled "${String(request.payload.title)}"?`,
+        approvedText: `Open the PR: ${String(resolved.source_branch ?? "")} → ${payloadTarget}, "${String(request.payload.title)}".`
+      };
+    case "changelog.apply":
+      return {
+        presented: `Workit decision: action — Apply changelog changes at \`${String(payload.path ?? "CHANGELOG.md")}\`?`,
+        approvedText: `Apply changelog changes at ${String(payload.path ?? "CHANGELOG.md")}.`
+      };
+    case "youtrack.update":
+      return {
+        presented: `Workit decision: action — Update YouTrack issue ${String(request.payload.issueId)}${request.payload.minutes ? ` and log ${String(request.payload.minutes)}m` : ""}?`,
+        approvedText: `Update YouTrack issue ${String(request.payload.issueId)}.`
+      };
+    case "youtrack.time":
+      return {
+        presented: `Workit decision: action — Log ${String(request.payload.minutes)}m to YouTrack issue ${String(request.payload.issueId)}?`,
+        approvedText: `Log time to YouTrack issue ${String(request.payload.issueId)}.`
+      };
+    case "youtrack.meeting":
+      return {
+        presented: `Workit decision: action — Log meeting time to YouTrack issue ${String(request.payload.issueId)}?`,
+        approvedText: `Log meeting time to YouTrack issue ${String(request.payload.issueId)}.`
+      };
+    default:
+      return {
+        presented: `Workit decision: action — Approve ${request.operation}?`,
+        approvedText: `Approve ${request.operation}.`
+      };
+  }
+};
 var approvedResolvedExternalAction = (content) => {
   try {
     const value = JSON.parse(content);
@@ -30683,24 +31138,35 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
         const sdd_dir = safePath(root, request.payload.sdd_dir ?? "docs");
         if (!sdd_dir)
           return failure("invalid_input", "sdd_dir must stay inside the workspace");
+        const action = request.payload.action ?? "setup";
         const policy = resolveBranchPolicyFor(root);
-        const target_branch = request.payload.target_branch ?? policy.defaultTargetBranch;
+        const target_branch = request.payload.target_branch;
+        if (action !== "reapply_stash" && !target_branch)
+          return failure("invalid_input", "target_branch (the working branch to create or switch to) is required for setup", {
+            outcome: "not_started",
+            fields: [{ path: "target_branch", reason: "required for action=setup" }]
+          });
         const head = gitValue(root, ["rev-parse", "HEAD"]);
         if (!head)
           return failure("storage_error", "current Git commit could not be resolved");
+        const dirty = Boolean((gitRaw(root, ["status", "--short"]) ?? "").trim());
+        const creation = action === "reapply_stash" || !target_branch ? { base_branch: policy.defaultTargetBranch } : branchCreationBaseline(root, target_branch, policy.defaultTargetBranch);
         const normalized = {
           operation: request.operation,
           payload: {
             ...request.payload,
-            action: request.payload.action ?? "setup",
+            action,
             sdd_dir,
             stash: request.payload.stash ?? "no",
-            target_branch
+            ...target_branch ? { target_branch } : {}
           }
         };
         return success(null, null, {
           request: normalized,
-          descriptorPayload: { ...normalized.payload, resolved: { head, target_branch } }
+          descriptorPayload: {
+            ...normalized.payload,
+            resolved: { head, dirty, ...creation }
+          }
         });
       }
       case "git.push": {
@@ -30714,7 +31180,37 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
         }) : failure("invalid_input", "git push requires a resolvable current branch");
       }
       case "git.commit": {
+        const planSteps = request.payload.plan_steps;
+        const planBranch = request.payload.plan_branch;
         const head = gitValue(root, ["rev-parse", "HEAD"]);
+        if (!head)
+          return failure("storage_error", "Git state could not be resolved");
+        const branch = gitValue(root, ["branch", "--show-current"]);
+        if (planSteps !== undefined || planBranch !== undefined) {
+          if (!Array.isArray(planSteps) || planSteps.some((step) => typeof step !== "string" || !step.trim()) || new Set(planSteps).size !== planSteps.length || planSteps.length === 0 || planSteps.length > 32)
+            return failure("invalid_input", "plan_steps must be 1-32 unique non-empty commit messages", {
+              outcome: "not_started",
+              fields: [{ path: "plan_steps", reason: "unique strings" }]
+            });
+          if (typeof planBranch !== "string" || !planBranch.trim() || planBranch !== branch)
+            return failure("invalid_input", "plan_branch must name the current working branch", {
+              outcome: "not_started",
+              fields: [{ path: "plan_branch", reason: "current branch" }]
+            });
+          if (isProtectedBranch2(root, planBranch))
+            return failure("invalid_input", "plan_branch must not be a protected branch", {
+              outcome: "not_started",
+              fields: [{ path: "plan_branch", reason: "protected branch" }]
+            });
+          return success(null, null, {
+            request,
+            descriptorPayload: {
+              plan_steps: planSteps,
+              plan_branch: planBranch,
+              resolved: { head, branch, steps: planSteps }
+            }
+          });
+        }
         const staged = gitRaw(root, [
           "diff",
           "--cached",
@@ -30725,7 +31221,13 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
           "HEAD"
         ]);
         const paths = stagedPaths(root);
-        if (!head || staged === null || paths === null)
+        const message = request.payload.message;
+        if (typeof message !== "string" || !message)
+          return failure("invalid_input", "git.commit requires a commit message", {
+            outcome: "not_started",
+            fields: [{ path: "message", reason: "required unless plan_steps is provided" }]
+          });
+        if (staged === null || paths === null)
           return failure("storage_error", "Git state could not be resolved");
         let policy;
         try {
@@ -30740,13 +31242,13 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
 `).filter(Boolean));
           flavor = detected.flavor ?? "conventional";
         }
-        if (!matchCommitFlavor(request.payload.message, flavor, policy.pattern))
+        if (!matchCommitFlavor(message, flavor, policy.pattern))
           return failure("invalid_input", `Commit message does not match the ${flavor} flavor (commitPolicy.preset)`);
         return success(null, null, {
           request,
           descriptorPayload: {
             ...request.payload,
-            resolved: { head, staged: sha256(staged), paths }
+            resolved: { head, branch, staged: sha256(staged), paths }
           }
         });
       }
@@ -30916,10 +31418,24 @@ var executeConcreteExternalAction = async (request, root, marker, dateMs, step,
         sdd_dir: request.payload.sdd_dir ?? "docs",
         workspace_root: root
       });
-      return result.error ? unknown3(request.operation) : success(null, null, result);
+      if ("error" in result) {
+        if (result.phase === "preflight")
+          return failure("invalid_input", result.error, {
+            outcome: "not_started",
+            operation: request.operation
+          });
+        return unknown3(request.operation);
+      }
+      return success(null, null, result);
     }
     case "git.commit": {
-      const result = run4(root, ["commit", "-m", request.payload.message]);
+      const message = request.payload.message;
+      if (typeof message !== "string" || !message)
+        return failure("invalid_input", "git.commit requires a commit message", {
+          outcome: "not_started",
+          fields: [{ path: "message", reason: "required" }]
+        });
+      const result = run4(root, ["commit", "-m", message]);
       return result.exitCode === 0 ? success(null, null, { stdout: result.stdout.trim() }) : unknown3(request.operation);
     }
     case "git.push": {
@@ -31031,6 +31547,14 @@ var sessionParent = (session) => {
 };
 var freshMs = 5 * 60 * 1000;
 var rejectedDescription = "Reject this decision";
+var isSelfAuthorizingActionContent = (content) => {
+  try {
+    const value = JSON.parse(content);
+    return typeof value.operation === "string" && value.operation.length > 0;
+  } catch {
+    return /^[a-z][a-z_]*\.[a-z_]+$/.test(content);
+  }
+};
 var decisionContent = (purpose, question, approvedContent) => ({
   header: `Workit decision: ${purpose}`,
   question,
@@ -31040,11 +31564,12 @@ var decisionContent = (purpose, question, approvedContent) => ({
   ]
 });
 var decisionOptions = (options) => Array.isArray(options) && options.length === 2 && options.every((option) => typeof option === "object" && option !== null && typeof option.label === "string" && typeof option.description === "string" && Object.keys(option).length === 2 && Object.keys(option).every((key) => key === "label" || key === "description")) ? options : null;
+var normalizeReceiptLabel = (label) => label.trim().replace(/(?:\s*[([]\s*[^()[\]]*\s*[)\]]\s*)+$/u, "").trim().toLowerCase();
 var purposeForQuestion = (question) => {
   const header = typeof question.header === "string" ? question.header.trim() : "";
   const options = decisionOptions(question.options);
   const decisionPurpose = header.match(/^Workit decision: (design|action|limitation|preference)$/)?.[1];
-  if (decisionPurpose && options !== null && options[0].label === "approved" && options[1].label === "rejected" && options[1].description === rejectedDescription)
+  if (decisionPurpose && options !== null && normalizeReceiptLabel(options[0].label) === "approved" && normalizeReceiptLabel(options[1].label) === "rejected")
     return "decision";
   return;
 };
@@ -31053,6 +31578,10 @@ class NativeReceiptStore {
   #receipts = new Map;
   #observations = new WeakSet;
   #pending = new Map;
+  #now;
+  constructor(options = {}) {
+    this.#now = options.now ?? Date.now;
+  }
   recordRequest(requestID, sessionID, callID, questions) {
     if (typeof requestID !== "string" || !requestID)
       return;
@@ -31090,7 +31619,7 @@ class NativeReceiptStore {
     const options = decisionOptions(question.options);
     if (!options)
       return false;
-    const selected = options?.find((option) => option.label === answer);
+    const selected = options.find((option) => normalizeReceiptLabel(option.label) === normalizeReceiptLabel(answer));
     if (!selected)
       return false;
     const decisionPurpose = typeof question.header === "string" ? question.header.match(/^Workit decision: (design|action|limitation|preference)$/)?.[1] : undefined;
@@ -31106,7 +31635,7 @@ class NativeReceiptStore {
       question: content.question,
       purpose,
       contentDigest: sha256(canonicalJson(content)),
-      recordedAt: Date.now()
+      recordedAt: this.#now()
     };
     const queue = this.#receipts.get(sessionID) ?? [];
     queue.push(receipt);
@@ -31126,15 +31655,12 @@ class NativeReceiptStore {
       const receipt = queue[i];
       if (receipt.purpose !== purpose)
         continue;
-      if (expected.callID !== undefined && receipt.callID !== expected.callID || expected.selectedLabel !== undefined && receipt.selectedLabel !== expected.selectedLabel || expected.selectedDescription !== undefined && receipt.selectedDescription !== expected.selectedDescription || expected.decisionPurpose !== undefined && receipt.decisionPurpose !== expected.decisionPurpose || expected.contentDigest !== undefined && receipt.contentDigest !== expected.contentDigest || expected.question !== undefined && receipt.question !== expected.question)
-        return {
-          ok: false,
-          error: "permission_denied: native question receipt does not match the requested content " + "(binding questions must be asked receipt-shaped: header `Workit decision: <purpose>` " + "with the same label in the question text and exactly approved/rejected options)"
-        };
+      if (expected.callID !== undefined && receipt.callID !== expected.callID || expected.selectedLabel !== undefined && normalizeReceiptLabel(receipt.selectedLabel) !== normalizeReceiptLabel(expected.selectedLabel) || expected.selectedDescription !== undefined && receipt.selectedDescription !== expected.selectedDescription || expected.decisionPurpose !== undefined && receipt.decisionPurpose !== expected.decisionPurpose || expected.contentDigest !== undefined && receipt.contentDigest !== expected.contentDigest || expected.question !== undefined && receipt.question !== expected.question)
+        continue;
       queue.splice(i, 1);
       if (!queue.length)
         this.#receipts.delete(sessionID);
-      if (Date.now() - receipt.recordedAt > freshMs)
+      if (this.#now() - receipt.recordedAt > freshMs)
         return { ok: false, error: "permission_denied: native question receipt is stale" };
       const observation = { receipt };
       this.#observations.add(observation);
@@ -31142,7 +31668,27 @@ class NativeReceiptStore {
     }
     return {
       ok: false,
-      error: "permission_denied: no native question receipt for this purpose " + "(ordinary multi-option questions mint no receipt; ask binding questions receipt-shaped: " + "header `Workit decision: <purpose>`, the same label in the question text, with exactly " + "approved/rejected options)"
+      error: (() => {
+        const samePurpose = queue.filter((receipt) => receipt.purpose === purpose);
+        const base = "permission_denied: no matching native question receipt for this purpose";
+        if (samePurpose.length) {
+          const closest = samePurpose[samePurpose.length - 1];
+          const reasons = [];
+          if (expected.selectedLabel !== undefined && normalizeReceiptLabel(closest.selectedLabel) !== normalizeReceiptLabel(expected.selectedLabel))
+            reasons.push(`selected answer was "${closest.selectedLabel}"`);
+          if (expected.selectedDescription !== undefined && closest.selectedDescription !== expected.selectedDescription)
+            reasons.push("approved option description did not match");
+          if (expected.decisionPurpose !== undefined && closest.decisionPurpose !== expected.decisionPurpose)
+            reasons.push(`purpose was "${closest.decisionPurpose}"`);
+          if (expected.contentDigest !== undefined && closest.contentDigest !== expected.contentDigest)
+            reasons.push("question or approved content differed from the asked receipt");
+          if (this.#now() - closest.recordedAt > freshMs)
+            reasons.push("receipt is stale (older than 5 minutes)");
+          if (reasons.length)
+            return `${base} (closest ${purpose} receipt: ${reasons.join("; ")})`;
+        }
+        return `${base}; if the user already settled this choice in conversation, do not ask ` + `again — record the settled choice in task progress and reassess so the ` + `requirement can retire. Otherwise ask once, receipt-shaped: header ` + `\`Workit decision: <purpose>\`, the same label repeated in the question text, ` + `with exactly approved/rejected options`;
+      })()
     };
   }
   verify(observation, sessionID, purpose) {
@@ -31244,6 +31790,13 @@ var opencodeCapabilities = () => [
     reason: "nested native task launches are denied and observed child sessions are parent-bound",
     refs: [hostRef("task")]
   },
+  {
+    name: "fresh-context-review",
+    surface: "task",
+    assurance: "agent_guided",
+    reason: "independent review runs as a native direct-child session; evidence evaluation enforces creator and duplicate-reviewer exclusion",
+    refs: [hostRef("task")]
+  },
   {
     name: "known_product_writes",
     surface: "write/edit/bash",
@@ -31262,7 +31815,8 @@ var opencodeCapabilities = () => [
 var nativeAuthority = (receipts, actor, reconciliationTokens = new WeakSet) => ({
   verifyDecision: ({ observation, expected, caller }) => {
     const receipt = receipts.verify(observation, actor, "decision");
-    if (!receipt || caller.host !== "opencode" || caller.actor !== actor || receipt.selectedLabel !== expected.response || receipt.selectedDescription !== (expected.response === "approved" ? expected.binding.approvedContent : rejectedDescription) || receipt.decisionPurpose !== expected.purpose || receipt.contentDigest !== sha256(canonicalJson(decisionContent(expected.purpose, expected.binding.presented, expected.binding.approvedContent))) || receipt.question !== expected.binding.presented)
+    const expectedApproved = typeof expected.binding.displayed === "string" ? expected.binding.displayed : expected.binding.approvedContent;
+    if (!receipt || caller.host !== "opencode" || caller.actor !== actor || normalizeReceiptLabel(receipt.selectedLabel) !== normalizeReceiptLabel(expected.response) || expected.response === "approved" && receipt.selectedDescription !== expectedApproved || receipt.decisionPurpose !== expected.purpose || receipt.contentDigest !== sha256(canonicalJson(decisionContent(expected.purpose, expected.binding.presented, expectedApproved))) || receipt.question !== expected.binding.presented)
       return failure("permission_denied", "native decision receipt is not bound to this session");
     return success(null, null, {
       kind: "host_observed",
@@ -31337,8 +31891,34 @@ var nativeDispatchFor = (directChildren, actor, generation) => ({
 var nativeExternalActionRunner = (root, actor, core, step) => createAuthorizedExternalActionRunner(core, (operation) => {
   const store = new TaskStore(root);
   const selected = approvedExternalAction(store, "opencode", actor, operation);
-  if (!selected.ok)
+  if (!selected.ok) {
+    const plan = planCommitBinding(store, "opencode", actor, operation);
+    if (plan) {
+      const actionRef = externalActionRef("opencode", actor, operation);
+      return {
+        taskId: plan.taskId,
+        decisionId: plan.decisionId,
+        actionRef,
+        expectedRevision: plan.expectedRevision,
+        expectedWorkspaceRevision: plan.expectedWorkspaceRevision,
+        binding: plan.binding,
+        step: plan.step,
+        refresh: () => {
+          const task = store.readTask(plan.taskId);
+          const freshWorkspace = store.readWorkspace();
+          if (!task.ok || !freshWorkspace.ok || !freshWorkspace.data)
+            throw new Error("external action state changed");
+          return {
+            expectedRevision: task.data.revision,
+            expectedWorkspaceRevision: freshWorkspace.data.revision
+          };
+        },
+        reserveObservation: nativeExternalActionObservation(actor, actionRef, "reserve"),
+        settleObservation: (outcome, revisions) => nativeExternalActionObservation(actor, actionRef, outcome, actionRef.kind === "host" ? actionRef.handle : "external-action", revisions)
+      };
+    }
     return selected;
+  }
   const actionRef = externalActionRef("opencode", actor, operation);
   return {
     taskId: selected.data.task.id,
@@ -31382,8 +31962,10 @@ var workerIdFor = (store, actor, current, directChildren) => {
 var createWorkitTools = ({
   client,
   receipts = new NativeReceiptStore,
-  directChildren = new Map
+  directChildren = new Map,
+  now = Date.now
 } = {}) => {
+  const actionProposals = new Map;
   const make = (family) => tool({
     description: `Workit ${family} operations backed by the shared task contract.`,
     args: operationShapeFor(family),
@@ -31417,16 +31999,45 @@ var createWorkitTools = ({
       let result;
       if (family === "decision" && args.action === "record") {
         const decision = parsed.data;
-        const observed = receipts.consume(context.sessionID, "decision", {
+        const budgetIssue = workitBindingQuestionIssue([
+          decisionContent(decision.purpose, decision.binding.presented, decision.binding.approvedContent)
+        ]);
+        if (budgetIssue)
+          return output2(failure("invalid_input", budgetIssue));
+        const expectation = {
           selectedLabel: decision.response,
-          selectedDescription: decision.response === "approved" ? decision.binding.approvedContent : rejectedDescription,
           decisionPurpose: decision.purpose,
           contentDigest: sha256(canonicalJson(decisionContent(decision.purpose, decision.binding.presented, decision.binding.approvedContent))),
           question: decision.binding.presented
-        });
+        };
+        if (decision.response === "approved")
+          expectation.selectedDescription = decision.binding.approvedContent;
+        const observed = receipts.consume(context.sessionID, "decision", expectation);
         if (!observed.ok)
           return output2(failure("permission_denied", observed.error));
-        result = core.observeDecision(parsed.data, observed.observation);
+        let recordInput = parsed.data;
+        if (decision.purpose === "action" && decision.response === "approved") {
+          const queue = actionProposals.get(context.sessionID) ?? [];
+          const textMatches = queue.filter((pending) => pending.presented === decision.binding.presented && pending.approvedText === decision.binding.approvedContent);
+          const matches = textMatches.filter((pending) => now() - pending.createdAt <= 5 * 60 * 1000);
+          if (matches.length > 1)
+            return output2(failure("invalid_input", "multiple action proposals match this approval; resolve the action again"));
+          const pending = matches[0];
+          if (pending) {
+            actionProposals.set(context.sessionID, queue.filter((candidate) => candidate !== pending));
+            recordInput = {
+              ...recordInput,
+              binding: {
+                ...recordInput.binding,
+                approvedContent: pending.descriptor,
+                displayed: pending.approvedText
+              }
+            };
+          } else if (!isSelfAuthorizingActionContent(decision.binding.approvedContent)) {
+            return output2(failure("invalid_input", textMatches.length > 0 ? "action proposal expired; resolve the action again for a fresh proposal" : "no matching action proposal; resolve the action through the action tool first"));
+          }
+        }
+        result = core.observeDecision(recordInput, observed.observation);
       } else {
         const run = core[family];
         result = run.call(core, parsed.data);
@@ -31527,6 +32138,64 @@ var createWorkitTools = ({
           return output2(failure("external_outcome_unknown", "previous external action outcome is unknown"));
         }
         const descriptor = externalActionDescriptor(resolved.data.request.operation, resolved.data.descriptorPayload);
+        const drift = resolved.data.request.operation === "git.branch_setup" ? priorResolvedDrift(store, "opencode", context.sessionID, resolved.data.request.operation, resolved.data.request.payload, resolved.data.descriptorPayload.resolved) : success(null, null, null);
+        if (!drift.ok)
+          return output2(drift);
+        const localOperation = [
+          "git.branch_setup",
+          "git.commit",
+          "git.push",
+          "hosting.pull_request",
+          "changelog.apply"
+        ].includes(resolved.data.request.operation);
+        if (localOperation) {
+          const writer = assertLocalExternalActionWriter(context.directory, {
+            host: "opencode",
+            actor: context.sessionID
+          });
+          if (!writer.ok)
+            return output2(failure("needs_input", "writer ownership is required before this action", {
+              outcome: "not_started",
+              operation: resolved.data.request.operation,
+              guidance: "Acquire checkout writer ownership first (writer.acquire) and retry the action."
+            }));
+        }
+        const selected = approvedExternalAction(store, "opencode", context.sessionID, descriptor);
+        let planAuthorized = false;
+        if (!selected.ok) {
+          const commitMessage = resolved.data.request.operation === "git.commit" ? resolved.data.request.payload.message : undefined;
+          const currentBranch = resolved.data.descriptorPayload.resolved?.branch;
+          if (typeof commitMessage === "string" && commitMessage) {
+            const plan = approvedPlanCommit(store, "opencode", context.sessionID, commitMessage);
+            planAuthorized = plan.ok && plan.data.branch === currentBranch;
+          }
+        }
+        if (!selected.ok && !planAuthorized) {
+          if (selected.error.startsWith("no approved action")) {
+            const proposal = actionProposalQuestion(resolved.data.request, resolved.data.descriptorPayload);
+            const pending = actionProposals.get(context.sessionID) ?? [];
+            pending.push({
+              descriptor,
+              presented: proposal.presented,
+              approvedText: proposal.approvedText,
+              createdAt: now()
+            });
+            if (pending.length > 8)
+              pending.shift();
+            actionProposals.set(context.sessionID, pending);
+            return output2(failure("needs_input", proposal.presented, {
+              outcome: "not_started",
+              operation: resolved.data.request.operation,
+              proposal: {
+                presented: proposal.presented,
+                approvedContent: proposal.approvedText,
+                descriptorDigest: sha256(descriptor)
+              },
+              guidance: "Ask one native question with header `Workit decision: action`, the presented text as the question text, and exactly two options: approved (description = the proposal approvedContent) and rejected (description = `Reject this decision`). Then call decision.record with the same presented/approvedContent and the native receipt; the adapter binds the exact descriptor. Never show the raw descriptor."
+            }));
+          }
+          return output2(selected);
+        }
         const result = await nativeExternalActionRunner(context.directory, context.sessionID, core)(descriptor, (step) => executeResolvedExternalAction(resolved.data, context.directory, step, {
           host: "opencode",
           actor: context.sessionID
@@ -31626,26 +32295,14 @@ var loadProvenance = (logger, pkgUrl) => {
 };
 
 // packages/workit-opencode/src/plugin.ts
-var root = fileURLToPath2(new URL("../assets/", import.meta.url));
+var root = fileURLToPath3(new URL("../assets/", import.meta.url));
 var skillsPath = path25.join(root, "skills");
 var logger = createLogger({
   appLog: () => {
     return;
   }
 });
-var sourceMarker = markSourcesLoaded([
-  fileURLToPath2(import.meta.url),
-  fileURLToPath2(new URL("./tools/workit.ts", import.meta.url)),
-  ...[
-    "task-contract.ts",
-    "task-engine.ts",
-    "task-evaluation.ts",
-    "task-store.ts",
-    "workers.ts",
-    "authority.ts",
-    "methods.ts"
-  ].map((file) => fileURLToPath2(new URL(`../../../workit-core/src/core/${file}`, import.meta.url)))
-].filter((file) => existsSync12(file)));
+var sourceMarker = markSourcesLoaded(pluginSourceFiles);
 var staleSourcesWarned = false;
 var warnStaleSources = () => {
   if (staleSourcesWarned)
@@ -31685,7 +32342,6 @@ var plugin = async ({ client, directory }) => {
   const lifecycleBindings = new Map;
   const unresolvedTaskLaunches = new Set;
   const dispatches = new Map;
-  const bootstrapped = new Set;
   try {
     logger.info(EVENT.initialization, { host: "opencode", plugin_root: root });
     logger.info(EVENT.provenance, loadProvenance(logger, new URL("../package.json", import.meta.url)));
@@ -31713,16 +32369,20 @@ var plugin = async ({ client, directory }) => {
     return [...items].sort((a, b) => a.entry.recordedAt < b.entry.recordedAt ? -1 : a.entry.recordedAt > b.entry.recordedAt ? 1 : a.entry.id < b.entry.id ? -1 : 1)[0];
   };
   const prepareDispatch = (coordinator, callID) => {
-    dispatches.delete(coordinator);
+    if (dispatches.has(coordinator))
+      return "unsettled";
     const store = new TaskStore(directory);
     const workspace = store.readWorkspace();
     const listed = store.listTasks();
     if (!workspace.ok || !workspace.data || !listed.ok)
-      return;
-    const eligible = listed.data.flatMap((task) => task.status === "active" && task.workspaceId === workspace.data?.id ? task.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.host === "opencode" && entry.provenance.session.handle === coordinator).map((entry) => ({ task, entry })) : []);
+      return "unmanaged";
+    const owned = listed.data.filter((task) => task.status === "active" && task.workspaceId === workspace.data?.id && task.intent.provenance.session?.kind === "host" && task.intent.provenance.session.host === "opencode" && task.intent.provenance.session.handle === coordinator);
+    if (owned.length === 0)
+      return "unmanaged";
+    const eligible = owned.flatMap((task) => task.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.host === "opencode" && entry.provenance.session.handle === coordinator).map((entry) => ({ task, entry })));
     const next = oldestOfSingleTask(eligible);
     if (!next)
-      return;
+      return "unbound";
     const generation = {
       coordinator,
       callID,
@@ -31745,7 +32405,7 @@ var plugin = async ({ client, directory }) => {
       observation: { stage: "prepare", sessionID: coordinator, callID }
     });
     if (!prepared.ok)
-      return;
+      return "unbound";
     dispatches.set(coordinator, {
       generation,
       dispatch: prepared.data,
@@ -31753,6 +32413,7 @@ var plugin = async ({ client, directory }) => {
       taskId: next.task.id,
       workerId: next.entry.id
     });
+    return "prepared";
   };
   const commitDispatchStart = (coordinator, childID) => {
     const pending = dispatches.get(coordinator);
@@ -31888,7 +32549,7 @@ var plugin = async ({ client, directory }) => {
     const listed = store.listTasks();
     if (!workspace.ok || !workspace.data || !listed.ok)
       return;
-    const candidates = listed.data.flatMap((task) => task.status === "active" && task.workspaceId === workspace.data?.id ? task.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.host === "opencode" && entry.provenance.session.handle === info.parentID).map((entry) => ({ task, entry })) : []);
+    const candidates = listed.data.flatMap((task) => task.status === "active" && task.workspaceId === workspace.data?.id ? task.workers.filter((entry) => (entry.data.state === "assigned" || entry.data.state === "dispatching") && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.host === "opencode" && entry.provenance.session.handle === info.parentID).map((entry) => ({ task, entry })) : []);
     const next = oldestOfSingleTask(candidates);
     if (!next)
       return;
@@ -31951,8 +32612,21 @@ var plugin = async ({ client, directory }) => {
           unresolvedTaskLaunches.add(input.sessionID);
       }
     },
-    "tool.execute.before": async (input, _output) => {
+    "tool.execute.before": async (input, output) => {
       warnStaleSources();
+      if (input.tool === "bash") {
+        const command = output?.args?.command;
+        const route = typeof command === "string" ? shellRouteIntent(command) : null;
+        if (route)
+          throw new Error(`recovery_required: direct branch or PR creation bypasses the Workit route; ${route.guidance}`);
+        return;
+      }
+      if (input.tool === "question") {
+        const issue = workitBindingQuestionIssue(output?.args?.questions);
+        if (issue)
+          throw new Error(issue);
+        return;
+      }
       if (input.tool === "task") {
         const listed = new TaskStore(directory).listTasks();
         if (listed.ok && listed.data.some((task) => task.workers.some((worker) => (worker.data.state === "cancelling" || worker.data.state === "unknown") && worker.provenance.session?.kind === "host" && worker.provenance.session.handle === input.sessionID)))
@@ -31962,13 +32636,17 @@ var plugin = async ({ client, directory }) => {
         const session = await sessionData2(client, input.sessionID);
         if (!client || !trustedSession(directory, input.sessionID, session) || session.parentID)
           throw new Error("delegation_lineage_denied: native task workers must be direct children of the coordinator");
-        prepareDispatch(input.sessionID, input.callID);
+        const prepared = prepareDispatch(input.sessionID, input.callID);
+        if (prepared === "unsettled")
+          throw new Error("recovery_required: a previous native task launch is unsettled; wait for it to settle or reconcile its worker before launching again");
+        if (prepared === "unbound")
+          throw new Error("recovery_required: no assigned Workit worker is attributable to this coordinator; assign one with workit_worker before launching a native task");
       }
     },
     config: async (config) => {
       const mutable = config;
       const paths = [...mutable.skills?.paths ?? []];
-      if (existsSync12(skillsPath) && !paths.includes(skillsPath))
+      if (existsSync13(skillsPath) && !paths.includes(skillsPath))
         paths.push(skillsPath);
       mutable.skills ??= {};
       mutable.skills.paths = paths;
@@ -32011,8 +32689,6 @@ var plugin = async ({ client, directory }) => {
       if (!first || !first.parts.length)
         return;
       const sessionID = first.info.sessionID;
-      if (bootstrapped.has(sessionID))
-        return;
       const anchor = first.parts[0];
       const session = await sessionData2(client, sessionID);
       if (!trustedSession(directory, sessionID, session))
@@ -32037,7 +32713,6 @@ var plugin = async ({ client, directory }) => {
           text: `<workit-worker-context>${workerContext}</workit-worker-context>`
         });
       }
-      bootstrapped.add(sessionID);
     }
   };
 };