@brainervirus/workit-opencode 1.0.8 → 1.0.9

package/assets/skills/workit-babysit/SKILL.md

@@ -7,7 +7,9 @@ description: Use after creating a PR (auto-starts, drive default), when a PR nee
 
 Babysit starts automatically on PR creation unless declined (`babysit:false`).
 One babysitter per PR; never mutate PR topology (no rebase strategy changes,
-no force-push).
+no force-push). When a PR URL is observed from a route Workit did not enforce
+(for example a raw `gh pr create` the host allowed), load this skill and drive
+that PR anyway; do not claim the Workit route was enforced.
 
 ## Before method work
 

package/dist/plugin.js

@@ -7628,7 +7628,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();
@@ -10399,6 +10399,95 @@ 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"] },
+  "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. 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 +10497,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) => ["dispatching", "running", "cancelling", "unknown"].includes(entry.data.state)))
     blockers.push({
       reason: "worker state requires reconciliation",
       dependentAction: "resume",
@@ -10458,6 +10547,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 +10561,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,50 +10588,47 @@ 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
 var externalActionSchema = discriminatedUnion("operation", [
   object({
@@ -11313,10 +11407,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))
@@ -11703,7 +11797,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) => ["dispatching", "running", "cancelling", "unknown"].includes(entry.data.state)))
       return failure("recovery_required", "worker state requires reconciliation");
     return null;
   }
@@ -12467,7 +12561,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)
         });
       }
     });
@@ -12936,7 +13035,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) => ["dispatching", "running", "cancelling", "unknown"].includes(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({
@@ -31040,11 +31139,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 +31153,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 +31194,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 +31210,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 +31230,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 +31243,7 @@ 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: "permission_denied: no matching native question receipt for this purpose; 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) {
@@ -31262,7 +31363,7 @@ 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)
+    if (!receipt || caller.host !== "opencode" || caller.actor !== actor || normalizeReceiptLabel(receipt.selectedLabel) !== normalizeReceiptLabel(expected.response) || expected.response === "approved" && receipt.selectedDescription !== expected.binding.approvedContent || receipt.decisionPurpose !== expected.purpose || receipt.contentDigest !== sha256(canonicalJson(decisionContent(expected.purpose, expected.binding.presented, expected.binding.approvedContent))) || 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",
@@ -31417,13 +31518,15 @@ var createWorkitTools = ({
       let result;
       if (family === "decision" && args.action === "record") {
         const decision = parsed.data;
-        const observed = receipts.consume(context.sessionID, "decision", {
+        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);
@@ -31685,7 +31788,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 +31815,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 +31851,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 +31859,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 +31995,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 +32058,15 @@ 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 === "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,7 +32076,11 @@ 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) => {
@@ -32011,8 +32129,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 +32153,6 @@ var plugin = async ({ client, directory }) => {
           text: `<workit-worker-context>${workerContext}</workit-worker-context>`
         });
       }
-      bootstrapped.add(sessionID);
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-opencode",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "private": false,
   "description": "Workit OpenCode plugin — native tools, adaptive policy, and fourteen method skills",
   "keywords": [
@@ -38,7 +38,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^1.0.8"
+    "@brainervirus/workit-core": "^1.0.9"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "1.18.30"