@brainervirus/workit-core 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/skills/workit-babysit/SKILL.md

@@ -1,13 +1,15 @@
 ---
 name: workit-babysit
-description: Use when a PR needs driving to merge-ready, CI is red, or the user says babysit
+description: Use after creating a PR (auto-starts, drive default), when a PR needs driving to merge-ready, CI is red, or the user says babysit
 ---
 
 # Babysit a PR to merge-ready
 
-Babysit starts automatically on PR creation unless declined (`--no-babysit`).
+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
 
@@ -17,8 +19,11 @@ selects requirements; do not wait for a rule that can only exist after assess.
 
 ## Method
 
-1. Declare mode: drive (fix + merge), watch (report only), or threads-only.
+1. Declare mode in the same turn as the PR URL: drive (fix + merge, the
+   default), watch (report only), or threads-only.
 2. Work the merge frontier in order: conflicts → review threads → CI.
+   Record a frontier brief (frontier state, next action) in task progress
+   per pass so the steps stay visible.
 3. Classify CI before retry: flake (rerun once) vs stale base (verify with
    `git merge-base --is-ancestor` before updating) vs real failure (fix).
 4. Triage bot findings skeptically: reproduce or quote code before acting;

package/src/core/external-action-effects.ts

@@ -937,6 +937,9 @@ export const resolveExternalActionRequest = (
   }
 };
 
+export const prBabysitNext = (output: string): string =>
+  `Babysit ${output} to merge-ready (drive mode default). Follow skill workit-babysit: declare mode in this turn, work conflicts, review threads, then CI, and record a frontier brief in task progress per pass. Opt out with babysit:false.`;
+
 export const executeConcreteExternalAction = async (
   request: ExternalActionRequest,
   root: string,
@@ -1015,6 +1018,9 @@ export const executeConcreteExternalAction = async (
             ...result,
             babysit: request.payload.babysit ?? true,
             babysitSkill: "workit-babysit",
+            ...((request.payload.babysit ?? true)
+              ? { next: prBabysitNext(String((result as { output?: unknown }).output ?? "")) }
+              : {}),
           });
     }
     case "changelog.apply": {

package/src/core/route-intent.ts

@@ -0,0 +1,51 @@
+export type ShellRouteIntent = {
+  route: "git.branch_setup" | "hosting.pull_request";
+  guidance: string;
+};
+
+const GUIDANCE: Record<ShellRouteIntent["route"], string> = {
+  "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",
+};
+
+const unbalancedQuotes = (segment: string): boolean => {
+  const text = segment.replace(/\\./gu, "");
+  return (text.match(/"/gu)?.length ?? 0) % 2 !== 0 || (text.match(/'/gu)?.length ?? 0) % 2 !== 0;
+};
+
+const segmentTokens = (segment: string): string[] | null => {
+  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;
+};
+
+const unquote = (token: string): string => token.replace(/^['"]|['"]$/gu, "");
+
+/**
+ * Narrow recognizer for direct branch and PR creation commands. It returns null
+ * for everything it cannot classify unambiguously, so hosts deny only the exact
+ * routes that must go through the shared action reservation.
+ */
+export function shellRouteIntent(command: string): ShellRouteIntent | null {
+  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;
+}

package/src/core/task-context.ts

@@ -13,6 +13,7 @@ import {
   type Utc,
 } from "./task-contract";
 import { captureCandidate, evaluateEvidence } from "./task-evaluation";
+import { selectMethods, type SelectedMethod } from "./methods";
 import type { NativeWorkerObservation } from "./workers";
 
 export type ResumeObservation = {
@@ -43,7 +44,7 @@ export function reconcileResume(
   const blockers = [...view.task.progress.blockers];
   if (
     view.task.workers.some((entry) =>
-      ["running", "cancelling", "unknown"].includes(entry.data.state),
+      ["dispatching", "running", "cancelling", "unknown"].includes(entry.data.state),
     )
   )
     blockers.push({
@@ -71,10 +72,12 @@ type CompactDecision = {
   digest: string;
   references: CompactReference[];
 };
+type CompactMethod = Pick<SelectedMethod, "id" | "assurance"> & { reason: string };
 export type CompactTaskContext = {
   objective: string;
   status: TaskView["task"]["status"];
   decisions: CompactDecision[];
+  methods: CompactMethod[];
   gaps: string[];
   nextAction: string | null;
 };
@@ -127,6 +130,13 @@ export function compactTaskContext(view: TaskView): string {
       digest: entry.data.digest,
       references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference),
     }));
+  const methods: CompactMethod[] = 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
@@ -145,16 +155,18 @@ export function compactTaskContext(view: TaskView): string {
     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)
+    (context.decisions.length || context.methods.length || context.gaps.length)
   ) {
     if (context.gaps.length) context.gaps.pop();
-    else context.decisions.pop();
+    else if (context.decisions.length) context.decisions.pop();
+    else context.methods.pop();
     encoded = JSON.stringify(context);
   }
   if (compactBytes(encoded) > COMPACT_MAX_BYTES) {

package/src/core/task-contract.ts

@@ -510,7 +510,7 @@ export type WorkerReport = z.infer<typeof workerReportSchema>;
 export const workerSchema = z
   .object({
     assignment: assignmentSchema,
-    state: z.enum(["assigned", "running", "cancelling", "stopped", "unknown"]),
+    state: z.enum(["assigned", "dispatching", "running", "cancelling", "stopped", "unknown"]),
     session: refSchema.nullable(),
     report: workerReportSchema.nullable(),
   })

package/src/core/task-engine.ts

@@ -343,10 +343,10 @@ const applyWorkerLifecycle = (input: ObserveWorkerLifecycleInput): Result<Entry<
   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" ||
@@ -824,7 +824,9 @@ export class WorkitCore {
     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))
+      task.workers.some((entry) =>
+        ["dispatching", "running", "cancelling", "unknown"].includes(entry.data.state),
+      )
     )
       return failure("recovery_required", "worker state requires reconciliation");
     return null;
@@ -1776,7 +1778,12 @@ export class WorkitCore {
           ...current,
           workers: current.workers.map((item) =>
             item.id === input.workerId
-              ? { ...item, recordedAt: mutation.now, provenance: attested.data }
+              ? {
+                  ...item,
+                  recordedAt: mutation.now,
+                  provenance: attested.data,
+                  data: { ...item.data, state: "dispatching" as const },
+                }
               : item,
           ),
         });
@@ -2337,7 +2344,7 @@ export class WorkitCore {
     const base = reconcileResumeContext(effectiveView);
     if (!base.ok) return base;
     const needsReconciliation = view.task.workers.some((entry) =>
-      ["running", "cancelling", "unknown"].includes(
+      ["dispatching", "running", "cancelling", "unknown"].includes(
         observedStates.get(entry.id) ?? entry.data.state,
       ),
     );

package/src/core.ts

@@ -66,6 +66,8 @@ export type {
 } from "./core/task-context";
 export { METHODS, invariantBootstrap, selectMethods } from "./core/methods";
 export type { MethodId, SelectedMethod } from "./core/methods";
+export { shellRouteIntent } from "./core/route-intent";
+export type { ShellRouteIntent } from "./core/route-intent";
 export { applicableDecision, reserveAction, settleAction, reconcileAction } from "./core/authority";
 export {
   createAuthorizedExternalActionRunner,