unitbob 0.6.2 → 0.7.0

package/dist/verbs/runLocal.js

@@ -1,5 +1,5 @@
 import { branchRunner, readHostSuiteOutputsPerBranch, readSuiteBuildRequest, } from "../files/suiteBuild.js";
-import { digestOf, failureSet, readRunState, rememberFailures } from "../runner/failureDigest.js";
+import { digestOf, failureSet, readRunState, rememberFailures, reportedFailures, } from "../runner/failureDigest.js";
 import { placeProblem } from "../runner/place.js";
 import { placeAdvice } from "../runner/placeAdvice.js";
 import { runnerEnvironmentPlaceProblem } from "../runner/placeEnvironment.js";
@@ -143,8 +143,72 @@ async function runOneBranch(config, d, suiteKind, output) {
         return null;
     }
     d.stdout.write(report(result));
+    d.stdout.write(failureLines(runner, result));
     return { runner, result };
 }
+// How many lines of one failure's message are worth printing here. Enough for an
+// assertion diff and the frame under it; not the whole backtrace, which is in
+// the report file the line above names.
+const DETAIL_LINES = 6;
+const DETAIL_CHARS = 600;
+// Spec 37-2, criterion 5. The report is read by the side that knows its format.
+//
+// Both behavioral report shapes and all three structural ones are already parsed
+// in this connector, for the stall comparison — and the coordinator still opened
+// `pytest_bdd_report.json` with an inline `node -e` and `pytest_result.xml` with
+// an inline `python3`, because nothing printed what it found. That happened on
+// the most expensive turns of the run: the repair stretch of the microblog bench
+// cost 79 coordinator turns and 47% of its input, each turn re-reading a 300,000
+// token conversation.
+//
+// Every failure, up to a budget on the whole block — this list is what the
+// repair packets of step 12 are cut from, so a top-N would send the coordinator
+// back to the file for the rest, which is the cost this removes. But the run
+// this most exists for is the first red one, where the harness is not wired yet
+// and every case fails: unbounded, that is half a megabyte into the very context
+// this spec is trying to make cheaper. What does not fit says so, by count, and
+// the report file is named on the line above.
+const FAILURE_BLOCK_CHARS = 40_000;
+function failureLines(runner, result) {
+    const failures = reportedFailures(runner, result.report);
+    if (!failures || failures.length === 0)
+        return '';
+    const head = `\n${failures.length} ${failures.length === 1 ? 'case' : 'cases'} failed, read out of ` +
+        `${result.resultPath}. Do not open that file to find this again:\n`;
+    const printed = [];
+    let spent = 0;
+    for (const [index, failure] of failures.entries()) {
+        const line = one(failure, index);
+        if (spent + line.length > FAILURE_BLOCK_CHARS && printed.length > 0)
+            break;
+        printed.push(line);
+        spent += line.length;
+    }
+    const left = failures.length - printed.length;
+    const tail = left === 0
+        ? ''
+        : `\n  …and ${left} more failed ${left === 1 ? 'case' : 'cases'}, not printed to keep this readable. ` +
+            `They are in ${result.resultPath}; a branch failing this widely is usually one harness problem, ` +
+            'not that many repairs.\n';
+    return head + printed.join('') + tail;
+}
+function one(failure, index) {
+    const where = failure.file ? ` — ${failure.file}` : '';
+    const lines = [`\n  ${index + 1}. ${failure.name || failure.marker || '(the runner named no case)'}${where}`];
+    if (failure.marker && failure.name.includes(failure.marker) === false)
+        lines.push(`     ${failure.marker}`);
+    if (failure.step)
+        lines.push(`     step: ${failure.step}`);
+    for (const line of trimmed(failure.detail))
+        lines.push(`     ${line}`);
+    return `${lines.join('\n')}\n`;
+}
+function trimmed(detail) {
+    const lines = detail.split('\n').slice(0, DETAIL_LINES);
+    const kept = lines.join('\n').slice(0, DETAIL_CHARS).split('\n');
+    const complete = kept.join('\n') === detail;
+    return complete ? kept : [...kept, '…'];
+}
 // The command first, and always — including on a green run. It is the answer to
 // "how do I run just this one file again", which is the question the whole
 // iteration loop is made of, and printing it only on failure would hide it at
@@ -178,7 +242,7 @@ function outputTail(result) {
 }
 // The suite blob's own project-relative paths, exactly as the runners expect
 // them: the main file first, then every other file of the branch. The main file
-// stopped being the whole suite in spec 43, §6 — a branch is one file per
+// stopped being the whole suite in spec one-place-per-rule, §6 — a branch is one file per
 // assignment now — and running it alone would exercise a fraction of what the
 // answer claims to guard.
 //

package/dist/verbs/suitePrepare.js

@@ -1,7 +1,8 @@
 import { clearRunState } from "../runner/failureDigest.js";
 import { materializeHelper } from "../files/guardrails.js";
 import { materializeBehavioralWorld } from "../files/behavioral.js";
-import { recipeNameFor, writeSuiteBuildRequest, } from "../files/suiteBuild.js";
+import { PACKETS_DIR, writeSuitePackets } from "../files/packets.js";
+import { movePreviousRunAside, recipeNameFor, writeSuiteBuildRequest, } from "../files/suiteBuild.js";
 import { bddStepLoading } from "../runner/bdd.js";
 import { bootCheck, SIGNAL_STRENGTH } from "../runner/bootcheck.js";
 import { anyStackPrecheck, behavioralHarnessNotice, detectBddRunner, detectStructuralRunner, runnerReadyPrecheck, } from "../runner/precheck.js";
@@ -230,16 +231,54 @@ export async function suitePrepare(config, args = [], deps) {
         throw new Error(`No suite branch can be built this run:\n${blockedNotices.join('\n')}\nNothing was written and nothing was uploaded.`);
     }
     const request = writeSuiteBuildRequest(config.projectRoot, branches, defectContext);
+    // Spec 37-1. The assignment names entrypoints; the packets are the files
+    // behind them, resolved from this machine's own graph and copied where a
+    // worker can open them. Built here because the entrypoints are known from the
+    // request and the workers are not yet — a packet belongs to an entrypoint,
+    // not to whoever ends up guarding it.
+    //
+    // Not written into `request.json`: the coordinator reads that file whole and
+    // pays for it on every turn of the longest-lived context in the run.
+    const sourcePackets = buildPackets(config.projectRoot, request);
     // A new request is a new build, and a new build has no previous run to be
     // stuck against (spec 34-6, criterion 3). Re-running this verb is a documented
     // step of the loop, so a failure set remembered from the build before it would
     // stop a branch that has not run once yet.
     clearRunState(config.projectRoot);
+    // Spec 37-2, criterion 3. Same reasoning, applied to the papers that were left
+    // behind rather than cleared: a plan and its checkpoints outlive the
+    // `request.json` they were digested against, and every one of them is refused
+    // by its own gate from here on. Moved rather than removed — see
+    // `movePreviousRunAside`.
+    //
+    // Wrapped for the same reason `buildPackets` is: by this line the request is
+    // written and the build is real. A read-only checkout or a permission the move
+    // does not have is a note, not a build that dies after its own work landed
+    // and before it could say so.
+    let displaced = [];
+    let displaceProblem = '';
+    try {
+        displaced = movePreviousRunAside(config.projectRoot);
+    }
+    catch (err) {
+        displaceProblem = err.message;
+    }
     const kinds = branches.map((branch) => branch.suite_kind).join(' and ');
     const nextCommand = branches.some((branch) => branch.suite_kind === 'behavioral')
         ? '`unitbob suite-review-prepare` before upload'
         : '`unitbob put-suite-build`';
     actual.stdout.write(`Suite build request written to ${request.project_root}/.unitbob/suite-build/request.json\n`);
+    if (displaced.length > 0) {
+        actual.stdout.write(`The previous run's ${displaced.join(', ')} moved to ` +
+            `${request.project_root}/.unitbob/suite-build/previous/ — none of it is left where this build will ` +
+            'look, and none of it was deleted.\n');
+    }
+    if (displaceProblem) {
+        actual.stdout.write(`\nThe previous run's files could not be moved out of the way (${displaceProblem}). This build is fine, ` +
+            'but a plan or checkpoint left over from it will be refused by its own gate — the digests belong to ' +
+            'the request that was just replaced.\n');
+    }
+    actual.stdout.write(packetNotice(request.project_root, sourcePackets));
     actual.stdout.write(`Next: build ${branches.length === 1 ? 'the' : 'both'} peer ${branches.length === 1 ? 'suite' : 'suites'} (${kinds}) following each branch's \`recipe\` and \`assignment\`, ` +
         `write your answer to ${request.output_path} as a branches array — one entry per branch named above, and a branch you cannot ` +
         `finish says so in its own entry rather than being left out of the array. Run each locally with \`unitbob run-local\` (the same ` +
@@ -288,8 +327,45 @@ export async function suitePrepare(config, args = [], deps) {
             '\n');
     }
 }
+// A checkout we cannot write packets into is a run without packets, not a
+// failed build: the workers search the source themselves, exactly as they did
+// before this spec. The same rule the route inventory follows for the same
+// reason — a read-only checkout or a full disk must not take a build down.
+function buildPackets(projectRoot, request) {
+    try {
+        return writeSuitePackets(projectRoot, request);
+    }
+    catch (err) {
+        return err.message;
+    }
+}
+function packetNotice(projectRoot, packets) {
+    if (typeof packets === 'string') {
+        return (`\nNo packets were written this run (${packets}). Workers find their own source, as before.\n`);
+    }
+    if (packets.targets === 0)
+        return '';
+    const where = `${projectRoot}/${PACKETS_DIR}`;
+    const head = packets.files === 0
+        ? `\nNo packet was written this run, so ${where} holds only its index.\n`
+        : `\n${packets.files} ${packets.files === 1 ? 'packet' : 'packets'} (${packets.bytes.toLocaleString('en-US')} bytes) ` +
+            `written to ${where}: the source behind ${packets.resolved} of ${packets.targets} entrypoints, resolved from this ` +
+            `machine's own graph and route inventory without asking a model. Hand each worker the paths of its packets, ` +
+            'never their contents — `unitbob accept-worker-plan` prints them per worker.\n';
+    // Two different outcomes, never merged: a file that was found and not carried
+    // still saves the worker the search, and a name nothing answered to does not.
+    const carried = packets.located - packets.resolved;
+    const unknown = packets.targets - packets.located;
+    if (carried === 0 && unknown === 0)
+        return head;
+    return (head +
+        `${carried + unknown} of ${packets.targets} entrypoints have no packet` +
+        (carried > 0 ? `; ${carried} name a file that was found but not carried` : '') +
+        ` (${packets.notes.join('; ')}). ` +
+        `Each says why in ${where}/index.json.\n`);
+}
 // The runner's own rule for which step files it will load, in the words of the
-// side that loads them (spec 44, §3.2). The same object is in `request.json`, on
+// side that loads them (spec ask-before-you-spend, §3.2). The same object is in `request.json`, on
 // the behavioral branch; this is the copy the coordinator sees without opening a
 // file.
 //

package/dist/wire.js

@@ -87,7 +87,7 @@ export class Wire {
     // carries one result per suite_kind.
     //
     // `dryRun` is the same route, the same body and the same server-side
-    // validation, stopped before the first write (spec 43, §1). It answers
+    // validation, stopped before the first write (spec one-place-per-rule, §1). It answers
     // `would_publish` instead of `created`, and it is deliberately not a route of
     // its own: a second route would grow a second implementation, which is the
     // defect this whole spec removes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitbob",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "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

@@ -21,7 +21,7 @@ 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.6.2 run-local <branch>` and inspect the machine
+`npx -y --loglevel=error unitbob@0.7.0 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

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

@@ -7,10 +7,10 @@ You receive exactly one worker-plan item and the request paths it references.
 That item is your complete scope. Do not add capabilities, promises, examples,
 or scenarios after fan-out.
 
-Your checkpoint already exists: the coordinator wrote it before fan-out, at the
-path the workflow prescribes, with the exact request and plan digests, your
-branch and worker id, your promises in `unresolved_promises`, and the facts it
-had already verified. Never initialize it again — not on the first incarnation,
+Your checkpoint already exists: `accept-worker-plan` wrote it before fan-out, at
+the path the workflow prescribes, with the exact request and plan digests, your
+branch and worker id, and your promises in `unresolved_promises`; the
+coordinator added the facts it had already verified. Never initialize it again — not on the first incarnation,
 and not on an explicitly approved fresh incarnation after a native budget stop,
 where you preserve the supplied checkpoint and completed files and continue only
 its `unresolved_promises`. Update it after every completed promise.
@@ -62,7 +62,15 @@ workers got it as verified. One of them looked, disagreed, and kept its scenario
 honest, which is the only reason that access hole came back red instead of green.
 Nothing mechanical enforces any of this; it holds because you keep it.
 
-Read only the `source_paths` and dependencies your finite planned cases need.
+Your source packets are the starting point: do not go looking for what is
+already in one. A source packet is the whole file behind one of your entrypoints,
+found for you and put on disk, so opening it is a read and not a search. Your
+task names the paths — sometimes a path to open in place, when the file was too
+large to carry. If it names none, or the code you need is not in the ones it
+names, then search as you would have anyway.
+
+Read only the source packets, the `source_paths` and the dependencies your
+finite planned cases need.
 Ask closed questions with the files to look in. For a closed missing fact, use
 the named `fact-finder` agent, as often as the work genuinely needs. A lookup
 may confirm implementation facts but may not expand the plan.

package/dist/verbs/validateWorkerPlan.js

@@ -1,9 +0,0 @@
-import { validateWorkerPlanFiles, workerPlanDigest } from "../files/workerPlan.js";
-export async function validateWorkerPlan(config, _args = [], deps = { stdout: process.stdout }) {
-    const errors = validateWorkerPlanFiles(config.projectRoot);
-    if (errors.length > 0)
-        throw new Error(`Worker plan is invalid:\n- ${errors.join('\n- ')}`);
-    const planDigest = workerPlanDigest(config.projectRoot);
-    deps.stdout.write(`Worker plan valid (${planDigest}). Fan-out may start.\n`);
-    return { plan_digest: planDigest };
-}