@brainervirus/workit-pi 1.0.8 → 1.0.9

package/dist/worker.js

@@ -7591,7 +7591,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();

package/dist/workit.js

@@ -7834,7 +7834,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();
@@ -10659,6 +10659,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)
@@ -10668,7 +10757,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",
@@ -10718,6 +10807,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),
@@ -10727,15 +10821,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) {
@@ -10751,94 +10848,47 @@ var exportDigest = (bundle) => sha256({
   sourceWorkspaceId: bundle.sourceWorkspaceId,
   task: bundle.task
 });
-// 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"] }
+// 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 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) };
+var unbalancedQuotes = (segment) => {
+  const text = segment.replace(/\\./gu, "");
+  return (text.match(/"/gu)?.length ?? 0) % 2 !== 0 || (text.match(/'/gu)?.length ?? 0) % 2 !== 0;
 };
-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 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;
 }
-var invariantBootstrap = () => `
-Workit keeps one accountable lead and one shared task state. Inspect current task
-state before acting. An empty task.list means no session yet, not permission to
-skip Workit; for user-requested product, debug, or behavior work with no active
-or paused task, run task.start then policy.assess before other product mutations.
-Omitted expectedRevision, expectedWorkspaceRevision, and writer workerId default
-to the current records; explicit values are still concurrency-checked, so never
-copy revisions between calls. Happy path: task.list, task.start {intent} with no
-revisions, policy.assess {assessment: {facts, signals, consequences,
-verification}} where facts are inferred or observed with file refs,
-writer.acquire {taskId} before product writes, evidence.record {evidence} where
-check and review kinds auto-bind the current tree and need no digests. Record
-self-review requirements with kind review and reviewContext matching your own
-host session; the lead may also record checks. Fresh-context review requires a
-session distinct from the task creator and every other evidence recorder. Record
-verification evidence last: later evidence or commits can reopen fixed findings
-for re-verification, so verify, resolve, then close with nothing in between.
-decision.record {binding with taskId/workspaceId from inspect plus presented and
-approvedContent} only through a native approval question asked receipt-shaped:
-header Workit decision: <purpose>, the same label repeated in the question
-text (some host UIs do not render headers), exactly two options approved and
-rejected; ask once, never re-ask to mint a receipt. task.close {outcome,
-summary, decisionIds}. A completed native subagent run stops its bound worker
-by itself; if a worker strands in cancelling with its run verifiably over,
-repeat worker.cancel {reason} to confirm the stop. Check and review evidence
-without a bound candidate goes stale; findings close only as fixed with passing
-verification, dismissed with supporting evidence, or deferred under an approved
-limitation. Use only the
-shared operations for task, policy, evidence, finding, decision, worker, writer,
-and state changes. Authority is bounded by the requested scope, current
-revision, caller/session provenance, and observed capabilities. Never claim host
-enforcement or evidence that the host cannot provide. Shell-executed writes are
-unattested agent-guided work even when a writer is held. Preserve unresolved
-requirements, gaps, and uncertain workers. Skill routing: slash aliases /wk-*
-always load on demand. Model-invoked: new instructions, interruptions, or
-forgotten items mid-task → load workit-steer before responding; about to open
-a PR or fresh from implementing → load workit-deslop; CI red → load
-workit-green-run; small-looking change before close or merge → load
-workit-blast-radius; ambiguous, consequential, or disputed proposal before
-recommending → load workit-challenge; spec or plan needs a flow diagram →
-load workit-diagram, a UI sketch → load workit-mockup. Load the skill; never
-act from memory of it.
-`.trim();
 // packages/workit-core/src/core/external-action.ts
 var externalActionSchema = discriminatedUnion("operation", [
   object({
@@ -11617,10 +11667,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))
@@ -12007,7 +12057,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;
   }
@@ -12771,7 +12821,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)
         });
       }
     });
@@ -13240,7 +13295,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({
@@ -13534,14 +13589,12 @@ var workitContext = (ctx) => {
 
 Native Pi session: ${session}. Project-local Workit state is unavailable until Pi trusts this project.`;
   let taskContext = null;
-  let methods = [];
   try {
     const store = new TaskStore(ctx.cwd);
     const tasks = store.listTasks();
     if (tasks.ok) {
       const task = tasks.data.filter((entry) => entry.status !== "closed" && (entry.intent.provenance.session?.kind === "host" && entry.intent.provenance.session.host === "pi" && entry.intent.provenance.session.handle === session || entry.workers.some((worker) => worker.data.session?.kind === "host" && worker.data.session.host === "pi" && worker.data.session.handle === session))).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
       if (task) {
-        methods = task.policy ? selectMethods(task.policy, piCapabilities(ctx)) : [];
         const core = new WorkitCore(store, piContext(ctx));
         const view = core.task({
           schemaVersion: 1,
@@ -13554,13 +13607,11 @@ Native Pi session: ${session}. Project-local Workit state is unavailable until P
       }
     }
   } catch {}
-  const methodText = methods.length ? `
-Selected methods: ${methods.map((method) => `${method.id} (${method.assurance})`).join(", ")}.` : "";
   const taskText = taskContext ? `
 Current task context: ${taskContext}` : "";
   return `${invariantBootstrap()}
 
-Native Pi session: ${session}.${methodText}${taskText}`;
+Native Pi session: ${session}.${taskText}`;
 };
 
 // packages/workit-core/src/core/skill-manifests.ts
@@ -17415,6 +17466,16 @@ var registerWorkitTools = (pi, options = {}) => {
   });
 };
 var enforceNativeWriter = (event, ctx) => {
+  if (event.toolName === "bash") {
+    const command = event.input?.command;
+    const route = typeof command === "string" ? shellRouteIntent(command) : null;
+    if (route)
+      return {
+        block: true,
+        reason: `direct branch or PR creation bypasses the Workit route; ${route.guidance}`
+      };
+    return;
+  }
   if (event.toolName !== "write" && event.toolName !== "edit")
     return;
   if (!ctx.isProjectTrusted())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-pi",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Workit native extension for Pi — tools, method skills, and session continuity",
   "keywords": [
     "agentic-coding",

package/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