unitbob 0.4.1 → 0.4.3

package/README.md

@@ -30,7 +30,7 @@ claude plugin install unitbob@unitbob
 ```
 codex plugin marketplace add sergeygershun/unitbob-connector
 codex plugin add unitbob@unitbob
-npx -y unitbob@0.4.1 codex-install
+npx -y unitbob@0.4.3 codex-install
 ```
 
 Start a new Claude Code or Codex thread so the installed skill and named agents

package/dist/verbs/runLocal.js

@@ -33,24 +33,11 @@ export async function runLocal(config, args = [], deps) {
         // examined the suite.
         if (!ran)
             continue;
-        const spent = spend(config.projectRoot, `run-local:${suiteKind}`);
-        if (request.budget && spent > request.budget.repair_rounds) {
-            d.stdout.write(polishedEnoughNotice(suiteKind, spent, request.budget.repair_rounds));
-        }
+        // Kept as compatibility diagnostics only. The bounded repair role owns the
+        // mechanical ceiling; this counter never stops execution or classifies reds.
+        spend(config.projectRoot, `run-local:${suiteKind}`);
     }
 }
-// Not a refusal, and deliberately not about the budget either. After eight
-// rounds of repair the interesting fact is not that a number ran out — it is
-// what the remaining reds most likely are. Both real logs show 3-5 runs of a
-// branch as ordinary work, so a branch on its ninth has already been repaired
-// past the point where the harness is the usual explanation.
-function polishedEnoughNotice(suiteKind, spent, allowed) {
-    return (`\nThat was run ${spent} of the ${suiteKind} branch; this build budgeted ${allowed}. ` +
-        'Reds that survive this many rounds of repair are far more likely to be defects of your product ' +
-        'than of the harness around it.\n' +
-        'Publish the suite as it stands rather than keep polishing. A first suite that comes out red is ' +
-        'a finding, not a failure — finding those reds is what it was written to do.\n');
-}
 // Which branches to run. No argument runs every branch the request asked for —
 // the same "one suite, one run" shape both recipes insist on, so the default
 // never teaches the habit the recipes forbid. A named branch is for the repair

package/dist/verbs/validateWorkerCheckpoints.js

@@ -74,14 +74,25 @@ function validateCompactFacts(value, label, errors) {
         return;
     }
     for (const [index, entry] of value.entries()) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            errors.push(`${label}: $.facts[${index}] must be an object with fact and source_refs; got ${jsonType(entry)}`);
+            continue;
+        }
         const fact = entry;
-        if (!fact || typeof fact.fact !== 'string' || !fact.fact.trim())
+        if (typeof fact.fact !== 'string' || !fact.fact.trim())
             errors.push(`${label}: facts[${index}].fact must be non-empty`);
-        if (!Array.isArray(fact?.source_refs) || fact.source_refs.some((ref) => typeof ref !== 'string' || !ref.trim())) {
+        if (!Array.isArray(fact.source_refs) || fact.source_refs.some((ref) => typeof ref !== 'string' || !ref.trim())) {
             errors.push(`${label}: facts[${index}].source_refs must be compact source references`);
         }
-        if ('source' in (fact ?? {}) || 'transcript' in (fact ?? {}) || 'suite' in (fact ?? {})) {
+        if ('source' in fact || 'transcript' in fact || 'suite' in fact) {
             errors.push(`${label}: facts[${index}] may not embed source, transcript, or suite copies`);
         }
     }
 }
+function jsonType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitbob",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Unitbob connector — thin local hands for the Unitbob Rails brain. Owns no domain logic: it runs tools, relays bytes over the wire, and prints what the server returns.",
   "type": "module",
   "bin": {

package/plugin/codex/agents/suite-repair-worker.toml

@@ -1,26 +1,51 @@
 name = "suite-repair-worker"
-description = "Completes one bounded Unitbob failure packet using the prior checkpoint and owned files, without widening scope or running the suite."
+description = "Completes and executes one bounded Unitbob owned-slice repair packet without widening scope."
 model = "gpt-5.6-terra"
 model_reasoning_effort = "medium"
 developer_instructions = '''
-You receive one failure packet: one validated plan item, its checkpoint, owned
-paths, and only related failures or stack traces. This is your complete scope.
+You receive one failure packet: one validated plan item, its checkpoint, branch,
+owned paths and case markers, and only related failures or stack traces. This is
+your complete write scope.
 
 Complete `unresolved_promises` first while preserving every completed file and
-decision. Then repair only harness problems whose stack points into this slice's
-owned files. Do not expand capabilities, promises, planned cases, or paths. Do
-not edit host-owned shared files, the connector-owned harness, application
-production code, or another slice.
+decision. You may read the plan item's source paths and, only as needed for the
+owned diagnosis, stack-referenced project source, the runner setup and harness
+actually in use, helpers, and factories. Repair only this slice's owned generated
+files and its checkpoint. Do not expand capabilities, promises, planned cases,
+markers, or paths. Do not edit production code, host-owned shared files, the
+connector-owned harness, or another slice.
+
+After every owned edit, run
+`npx -y --loglevel=error unitbob@0.4.3 run-local <branch>` and inspect the machine
+report. Look only at examples or scenarios matching your owned paths or case
+markers. Do not require a green exit code from the whole branch: foreign failures
+and an already-confirmed product red do not widen your scope. Repeat the bounded
+`edit → run-local → inspect` loop until every owned case passes or is diagnosed
+as a product defect. Do not run the project's suite directly, boot a dev server,
+or invoke an arbitrary runner command.
+
+A product-defect diagnosis must briefly name the violated business contract, the
+reason, and production source references. Never delete a planned case, marker,
+capability binding, or assertion; never add `skip`, `pending`, `todo`, or weaken a
+business promise for green. You may correct a generated expectation only when
+the business promise remains intact and source confirms the correction. If the
+harness is still wrong, continue the loop. If the outcome is ambiguous, the
+runner is unusable, or the turn ceiling stops unfinished work, leave an honest
+branch `build_error`, never a product red. No strict JSON handoff is required.
 
 Update the same checkpoint as promises complete. Keep facts compact and
-source-referenced. Never run the suite or boot the application; the coordinator
-owns the single final run. Do not delegate a second repair, continue another
-agent, or request another repair round. If work remains at the turn ceiling,
-record it in `unresolved_promises` so the coordinator can produce an honest
-branch `build_error`.
+source-referenced. The normative JSON shape of one facts entry is:
+```json
+{"fact":"The route creates an order.","source_refs":["app/orders.rb:12"]}
+```
+Every facts entry is an object in that shape, never a string. Before handoff,
+make one final read of the checkpoint and confirm every `facts` entry is an
+object in the normative shape above. Do not delegate repair or auto-resume after
+the ceiling. Preserve files and checkpoint for the coordinator's existing
+`Continue once / Stop` choice; record unfinished work in `unresolved_promises`.
 '''
 
 [features.rollout_budget]
 enabled = true
-limit_tokens = 15000
+limit_tokens = 40000
 reminder_at_remaining_tokens = [3000]

package/plugin/codex/agents/suite-worker.toml

@@ -16,7 +16,12 @@ native budget stop, preserve the supplied checkpoint and completed files and
 continue only its `unresolved_promises`; never initialize that checkpoint again.
 Update the checkpoint after every completed promise. Also keep `known_problems` as a compact
 array of precise unresolved harness problems (empty when none are known). Facts are short statements with
-source references; never embed source files, suite copies, or transcript.
+source references. The normative JSON shape of one facts entry is:
+```json
+{"fact":"The route creates an order.","source_refs":["app/orders.rb:12"]}
+```
+Every facts entry is an object in that shape, never a string. Never embed source
+files, suite copies, or transcript.
 
 Read only the initial `source_paths` and dependencies needed for the finite
 planned cases. Ask closed questions with the files to look in. For a closed
@@ -31,7 +36,9 @@ copy it into an owned file.
 
 Never run the suite, boot the application, or perform branch-global duplicate,
 marker, metadata, or surface validation. You may make one final read of your
-owned files before handoff. Do not create temporary self-validation scripts or
+owned files before handoff. During that final read, confirm every `facts` entry
+is an object in the normative shape above and correct the checkpoint if it is
+not. Do not create temporary self-validation scripts or
 loop over repeated rereads. If the turn ceiling arrives, leave partial files and
 an accurate checkpoint; the coordinator will rotate unresolved work into one
 fresh repair task.