@brainervirus/workit-cli 1.0.8 → 1.0.9

package/dist/index.js

@@ -50965,7 +50965,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();
@@ -58945,6 +58945,52 @@ 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 }];
+  });
+}
+
 // packages/workit-core/src/core/task-context.ts
 function reconcileResume(view, observations = []) {
   if (observations.length > 0)
@@ -58954,7 +59000,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",
@@ -59004,6 +59050,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),
@@ -59013,15 +59064,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) {
@@ -59796,10 +59850,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))
@@ -60186,7 +60240,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;
   }
@@ -60950,7 +61004,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)
         });
       }
     });
@@ -61419,7 +61478,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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cli",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "private": false,
   "description": "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
   "keywords": [
@@ -37,9 +37,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^1.0.8",
-    "@brainervirus/workit-cursor": "^1.0.8",
-    "@brainervirus/workit-opencode": "^1.0.8",
+    "@brainervirus/workit-core": "^1.0.9",
+    "@brainervirus/workit-cursor": "^1.0.9",
+    "@brainervirus/workit-opencode": "^1.0.9",
     "@inkjs/ui": "2.0.0",
     "ink": "7.1.1",
     "react": "19.2.8"