@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/findings.js

@@ -4,7 +4,7 @@ import { claimCoversPath } from './claims.js';
 import { SmithError } from './errors.js';
 import { appendEvent, readLineageEvents } from './events.js';
 import { describeType } from './plan.js';
-import { compileSchemas, validateRecord } from './schemas.js';
+import { compileSchemas, validateEachShape, validateRecord, } from './schemas.js';
 import { readAddedTasks } from './taskEvents.js';
 import { bareTaskId, epicOfTaskId, taskIdsMatch } from './taskId.js';
 import { loadTaxonomy, validateTag } from './taxonomy.js';
@@ -326,6 +326,27 @@ const ORCHESTRATOR_OWNED_FINDING_FIELDS = [
 function mintFindingId(taskId, fingerprint) {
     return `f-${taskId}-${fingerprint.slice(0, 8)}`;
 }
+/**
+ * A shallow clone with the orchestrator-owned fields removed, so the
+ * schema-shape check below runs against exactly the judge's half of the
+ * contract. `finding-evidence.schema.json` declares `additionalProperties:
+ * false` and never lists these six fields — they are the orchestrator's to
+ * mint, never the judge's to write (interview N-2) — so validating a raw
+ * evidence item against it, un-stripped, would reject every legitimate item
+ * that happens to be re-minted from a stored finding and would make the
+ * dedicated `findings.evidence-carries-identity` error below unreachable.
+ */
+function stripOwnedFields(item) {
+    const clone = { ...item };
+    for (const field of ORCHESTRATOR_OWNED_FINDING_FIELDS)
+        delete clone[field];
+    return clone;
+}
+function describeShapeFailures(failures) {
+    return failures
+        .map((f) => `index ${f.index} (${f.errors.map((e) => e.message).join('; ')})`)
+        .join(', ');
+}
 /**
  * Guess which taxonomy value a judge meant when it wrote something close but
  * not equal to one. Derived from the vocabulary itself rather than a synonym
@@ -367,7 +388,20 @@ function suggestCanonical(values, written) {
  * `test-gap` for `test-coverage` cost a whole gate round that way.
  */
 export function mintFindings(evidence, ctx, opts = {}) {
-    const { taxonomy } = resolveTaxonomyAndSchemas(opts);
+    const { taxonomy, schemas } = resolveTaxonomyAndSchemas(opts);
+    // Issue #233: a wrong field name (`category`/`title`/`evidence` for
+    // `finding_category`/`summary`/none-of-those) or a wrong-shaped field
+    // (`failure_scenario` given as a string instead of {inputs, expected,
+    // actual}) used to reach `suggestCanonical`/`computeFingerprint` below and
+    // crash with a raw TypeError instead of a FindingError. Checked here,
+    // against the schema `finding-evidence.schema.json` already documents as
+    // the judge's half of the contract, every item's shape is settled before
+    // any item's fingerprint is computed or any finding is minted — so a batch
+    // with one bad item mints nothing, not "the good ones, then a crash."
+    const shapeFailures = validateEachShape(schemas, 'finding-evidence', evidence.map(stripOwnedFields));
+    if (shapeFailures.length > 0) {
+        throw new FindingError('findings.invalid-evidence', `Finding evidence does not match finding-evidence.schema.json at ${describeShapeFailures(shapeFailures)}. Expected {file_path, finding_category, severity, summary, failure_scenario: {inputs, expected, actual}} (criterion_ref optional).`, { failures: shapeFailures });
+    }
     const severities = taxonomy.dimensions.severity ?? [];
     const categories = taxonomy.dimensions.finding_category ?? [];
     return evidence.map((item, index) => {
@@ -531,7 +565,7 @@ export async function raiseFinding(input, ctx, opts = {}) {
         }, opts);
         return { suppressed: true, fingerprint, taskId: finding.task_id };
     }
-    await appendEvent({
+    const stored = await appendEvent({
         session_id: ctx.sessionId,
         actor: ctx.actor ?? finding.found_by,
         event_type: 'finding-raised',
@@ -540,7 +574,7 @@ export async function raiseFinding(input, ctx, opts = {}) {
         causal_parent: ctx.causalParent,
         payload: finding,
     }, opts);
-    return { suppressed: false, finding };
+    return { suppressed: false, finding, event_id: stored.event_id };
 }
 /**
  * Current state of every finding in this session's LINEAGE: a fold, never a
@@ -870,7 +904,7 @@ export async function transition(findingId, newStatus, ctx, opts = {}, extra = {
     // answer to a caller who named none, rather than a status complaint.
     if (current.finding_status === 'waived') {
         if (extra.waiverRevokedBy === undefined) {
-            throw new FindingError('findings.waiver-revocation-unproven', `Finding "${findingId}" is waived, and a waiver is undone by revoking it, not by typing a status at it. Record the operator's reversal first — "smith waiver apply" with a "denied" decision on this fingerprint reopens the finding as part of writing the denial.`, { findingId, to: newStatus });
+            throw new FindingError('findings.waiver-revocation-unproven', `Finding "${findingId}" is waived, and a waiver is undone by revoking it, not by typing a status at it. Record the operator's reversal first — "bs waiver apply" with a "denied" decision on this fingerprint reopens the finding as part of writing the denial.`, { findingId, to: newStatus });
         }
         if (newStatus !== preWaiverStatus) {
             throw new FindingError('findings.waiver-revocation-wrong-status', `Finding "${findingId}" was waived out of "${preWaiverStatus ?? 'an unrecorded status'}", so revoking that waiver returns it there, not to "${newStatus}". A revocation restores what the waiver closed over; it does not re-grade the finding.`, { findingId, to: newStatus, preWaiverStatus: preWaiverStatus ?? null });
@@ -883,14 +917,14 @@ export async function transition(findingId, newStatus, ctx, opts = {}, extra = {
         throw new FindingError('findings.not-amendable', `Finding "${findingId}" is scoped "${findingScope(current)}", so it cannot take the amendment path at "${newStatus}": only a spec finding closes by amending the plan. A defect in the diff is closed by fixing the diff.`, { findingId, scope: findingScope(current), to: newStatus });
     }
     if (newStatus === AMEND_PENDING_STATUS && (extra.amendsTaskIds?.length ?? 0) === 0) {
-        throw new FindingError('findings.amendment-without-obligation', `Finding "${findingId}" cannot enter "${AMEND_PENDING_STATUS}" naming no task ids. An amendment that obligates nothing discharges the finding the moment it is written, which is D-127 — say which added or superseded task this finding is now waiting on. "smith plan amend" derives that list from the plan diff and is the only verb that does (D-136).`, { findingId });
+        throw new FindingError('findings.amendment-without-obligation', `Finding "${findingId}" cannot enter "${AMEND_PENDING_STATUS}" naming no task ids. An amendment that obligates nothing discharges the finding the moment it is written, which is D-127 — say which added or superseded task this finding is now waiting on. "bs plan amend" derives that list from the plan diff and is the only verb that does (D-136).`, { findingId });
     }
     if (newStatus === AMENDED_STATUS) {
         const outstanding = outstandingObligations(current, extra.amendsSatisfiedBy ?? []);
         if (outstanding === null || outstanding.length > 0) {
             throw new FindingError('findings.amendment-not-discharged', outstanding === null
                 ? `Finding "${findingId}" is at "${AMEND_PENDING_STATUS}" but names no task ids at a plan version, so no evidence can discharge it. Expire it at the epic boundary instead.`
-                : `Finding "${findingId}" cannot close at "${AMENDED_STATUS}": ${outstanding.join(', ')} has not been shown to have landed at plan version ${current.amends_plan_version} or later. An amendment is discharged by its tasks landing, not by being told they did — this is D-127. "smith epic close" computes and supplies that evidence.`, {
+                : `Finding "${findingId}" cannot close at "${AMENDED_STATUS}": ${outstanding.join(', ')} has not been shown to have landed at plan version ${current.amends_plan_version} or later. An amendment is discharged by its tasks landing, not by being told they did — this is D-127. "bs epic close" computes and supplies that evidence.`, {
                 findingId,
                 outstanding: outstanding ?? [],
                 amendsPlanVersion: current.amends_plan_version,
@@ -918,7 +952,7 @@ export async function transition(findingId, newStatus, ctx, opts = {}, extra = {
     // landed tasks and their versions rather than having to re-derive them.
     if (extra.amendsSatisfiedBy !== undefined)
         payload.amends_satisfied_by = extra.amendsSatisfiedBy.map((row) => ({ ...row }));
-    await appendEvent({
+    const stored = await appendEvent({
         session_id: ctx.sessionId,
         actor: ctx.actor ?? 'system',
         event_type: 'finding-transitioned',
@@ -935,6 +969,12 @@ export async function transition(findingId, newStatus, ctx, opts = {}, extra = {
         ...(extra.amendsPlanVersion !== undefined
             ? { amends_plan_version: extra.amendsPlanVersion }
             : {}),
+        // #286: the id of the `finding-transitioned` event this call just
+        // appended, the same shape #238 gave `judge report` -- so a caller
+        // chaining transitions as `--causal-parent` has it without falling back
+        // to "log line count - 1", which names a sibling's event under parallel
+        // writers.
+        event_id: stored.event_id,
     };
     // A reopened finding carrying the id of the waiver that no longer holds it
     // is the same split state D-180 is about, one field smaller.
@@ -1068,7 +1108,7 @@ export async function repairObligation(input, ctx, opts = {}) {
     if (malformedEntries.length === 0) {
         throw new FindingError('findings.repair-not-corrupt', `Finding "${input.findingId}"'s obligation names ${original.length} task id(s), all ` +
             'well-formed — there is nothing to repair. This verb repairs malformed amends_task_ids ' +
-            'data; it never renegotiates a well-formed obligation. Use "smith plan amend" to change ' +
+            'data; it never renegotiates a well-formed obligation. Use "bs plan amend" to change ' +
             'what a finding is waiting on.', { findingId: input.findingId });
     }
     // Guard 4: reason required, non-empty. An unaudited repair is not a repair.
@@ -1116,7 +1156,7 @@ export async function repairObligation(input, ctx, opts = {}) {
     if (current.amends_plan_version !== undefined) {
         payload.amends_plan_version = current.amends_plan_version;
     }
-    await appendEvent({
+    const stored = await appendEvent({
         session_id: ctx.sessionId,
         actor: ctx.actor ?? 'user',
         event_type: FINDING_OBLIGATION_REPAIRED_EVENT_TYPE,
@@ -1125,7 +1165,12 @@ export async function repairObligation(input, ctx, opts = {}) {
         causal_parent: ctx.causalParent,
         payload,
     }, opts);
-    return { ...current, amends_task_ids: toObligation, obligation_repair_reason: reason };
+    return {
+        ...current,
+        amends_task_ids: toObligation,
+        obligation_repair_reason: reason,
+        event_id: stored.event_id,
+    };
 }
 /**
  * Which open findings are answering about code that no longer exists.
@@ -1204,9 +1249,34 @@ export async function staleFindings(sessionId, opts = {}) {
         const filePath = finding.file_path;
         if (filePath === undefined)
             continue;
+        // #217: the finding's OWN task merging its file is not a rewrite — it is
+        // exactly the diff the reviewer read when raising the finding, so
+        // treating it as staleness meant a waiver batch refused to grant over
+        // evidence a merge had not touched at all. But a re-cut does not always
+        // get a new task_id: a same-id supersede (spec.ts's "a same-id supersede
+        // needs no pairing") keeps the original id, so the same task_id CAN
+        // appear in `merges` twice — once for the diff already read, once for a
+        // genuine later rewrite. Only that one reviewed-diff merge is excluded;
+        // a second one is real evidence of a rewrite and must still be able to
+        // mark the finding stale.
+        //
+        // The reviewed-diff merge is anchored to `raisedIndex`, not `freshUntil`:
+        // it is the first merge of the finding's own task after the RAISE, and a
+        // later reverify must not shift which merge that is. Anchoring to
+        // `freshUntil` instead let raise → v1 merge → reverify → v2 merge skip
+        // TWO merges — `freshUntil` (moved past v1 by the reverify) filtered v1
+        // out of the loop before the self-merge check ever saw it, and the
+        // loop's "first self-merge encountered" rule then wrongly treated v2,
+        // the genuine post-reverify rewrite, as if it were the reviewed diff.
+        // Computed once by identity (its event index) rather than re-derived
+        // inside the loop, so the freshUntil filter below cannot shift which
+        // merge counts as "already read".
+        const reviewedMergeIndex = merges.find((merge) => merge.index > raisedIndex && taskIdsMatch(merge.taskId, finding.task_id))?.index;
         for (const merge of merges) {
             if (merge.index <= freshUntil)
                 continue;
+            if (merge.index === reviewedMergeIndex)
+                continue;
             if (merge.filesChanged) {
                 const hit = merge.filesChanged.find((changed) => normalizeFilePath(changed) === filePath);
                 if (hit === undefined)
@@ -1260,7 +1330,7 @@ export async function reverifyFinding(findingId, note, ctx, opts = {}) {
             findingId,
         });
     }
-    await appendEvent({
+    const stored = await appendEvent({
         session_id: ctx.sessionId,
         actor: ctx.actor ?? 'system',
         event_type: 'finding-reverified',
@@ -1274,4 +1344,5 @@ export async function reverifyFinding(findingId, note, ctx, opts = {}) {
             note,
         },
     }, opts);
+    return { event_id: stored.event_id };
 }

package/factory/orchestrator/dist/gate.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { TASK_RESULT_EVENT_TYPE } from './agents-registry.js';
 import { checkArtifacts } from './artifacts.js';
 import { recordReattribution, routeFindings } from './attribution.js';
+import { readTokenUsage } from './budgetAlarm.js';
 import { checkTaskBudget } from './budgets.js';
 import { certifyCommit } from './commit.js';
 import { collectCoverageEvidence } from './coverage.js';
@@ -11,6 +12,7 @@ import { loadCrosscheckPolicy } from './crosscheck.js';
 import { DiffstatError, measureDiff } from './diffstat.js';
 import { appendEvent, readLineageEvents } from './events.js';
 import { findingScope, raiseFinding, SPEC_FINDING_SCOPE, transition, } from './findings.js';
+import { runGit } from './git.js';
 import { outstandingJudges, readJudgeTurns } from './judges.js';
 import { enabledExternalProviders, findingJudgeRequest, nativeProviderName, runQuorumCase, } from './quorum.js';
 import { compileSchemas, validateRecord, } from './schemas.js';
@@ -19,6 +21,7 @@ import { readAddedTasks } from './taskEvents.js';
 import { taskIdsMatch } from './taskId.js';
 import { loadTaxonomy } from './taxonomy.js';
 import { run as runTestgate } from './testgate.js';
+import { checkUiux } from './uiuxGate.js';
 let cachedTaxonomy;
 let cachedSchemas;
 function resolveTaxonomyAndSchemas(opts) {
@@ -31,7 +34,7 @@ function resolveTaxonomyAndSchemas(opts) {
     return { taxonomy, schemas };
 }
 async function emit(eventType, payload, taskId, ctx, opts) {
-    await appendEvent({
+    return appendEvent({
         session_id: ctx.sessionId,
         actor: ctx.actor ?? 'system',
         event_type: eventType,
@@ -97,7 +100,7 @@ function resultHash(result) {
 async function recordResult(result, taskId, ctx, opts) {
     const hash = resultHash(result);
     const events = await readLineageEvents(ctx.sessionId, opts);
-    for (const { record } of events) {
+    for (const { event_id, record } of events) {
         if (record.event_type !== TASK_RESULT_EVENT_TYPE)
             continue;
         // Matched, not compared: the same task reaches the log under both
@@ -111,9 +114,78 @@ async function recordResult(result, taskId, ctx, opts) {
         // Result verbatim (db/projector.ts reads it as one), and a hash field
         // wedged in beside it would be a Result that no longer validates.
         if (resultHash(record.payload) === hash)
-            return;
+            return { eventId: event_id, deduped: true };
     }
-    await emit(TASK_RESULT_EVENT_TYPE, result, taskId, ctx, opts);
+    const stored = await emit(TASK_RESULT_EVENT_TYPE, result, taskId, ctx, opts);
+    return { eventId: stored.event_id, deduped: false };
+}
+/** `name-desktop-light.png` and the three siblings a visual pass has to cover. */
+const SCREENSHOT_RE = /-(desktop|mobile)-(light|dark)\.png$/;
+function screenshotsFromArtifacts(artifacts) {
+    const shots = [];
+    for (const a of artifacts) {
+        const match = SCREENSHOT_RE.exec(a.path);
+        const viewport = match?.[1];
+        const theme = match?.[2];
+        if (viewport !== undefined && theme !== undefined)
+            shots.push({ path: a.path, viewport, theme });
+    }
+    return shots;
+}
+export async function recordTaskResult(input, ctx, opts = {}) {
+    const { taxonomy, schemas } = resolveTaxonomyAndSchemas(opts);
+    const schemaResult = validateRecord(schemas, taxonomy, 'result', input.result);
+    await emit('schema-check-result', { valid: schemaResult.valid, errors: schemaResult.valid ? [] : schemaResult.errors }, input.taskId, ctx, opts);
+    if (!schemaResult.valid) {
+        return {
+            outcome: 'blocked',
+            taskId: input.taskId,
+            reason: 'schema-invalid',
+            schemaErrors: schemaResult.errors,
+            artifactIssues: [],
+        };
+    }
+    // The worker's Result is a fact about a run that already happened, so it is
+    // recorded before the artifact check can block on it (P9-12) — a tester
+    // whose screenshot path was wrong still ran, and the projector should see
+    // the Result even when the artifact check below refuses it.
+    const recorded = await recordResult(input.result, input.taskId, ctx, opts);
+    const artifacts = input.result.artifacts ?? [];
+    const artifactCheck = checkArtifacts(artifacts, {
+        taskId: input.taskId,
+        artifactsDir: input.artifactsDir,
+    });
+    const freshness = input.worktreeDir !== undefined
+        ? {
+            head: runGit(input.worktreeDir, ['rev-parse', 'HEAD']),
+            screenshots: screenshotsFromArtifacts(artifacts),
+        }
+        : {};
+    await emit('artifact-check-result', {
+        ok: artifactCheck.ok,
+        checked: artifactCheck.checked,
+        home: artifactCheck.home,
+        issues: artifactCheck.issues,
+        ...freshness,
+    }, input.taskId, ctx, opts);
+    if (!artifactCheck.ok) {
+        return {
+            outcome: 'blocked',
+            taskId: input.taskId,
+            reason: 'artifacts-missing',
+            schemaErrors: [],
+            artifactIssues: artifactCheck.issues,
+        };
+    }
+    return {
+        outcome: 'recorded',
+        taskId: input.taskId,
+        eventId: recorded.eventId,
+        // Additive alongside the existing `eventId` (camelCase, pre-existing):
+        // same value, snake_case, matching every other write verb's printed id.
+        event_id: recorded.eventId,
+        deduped: recorded.deduped,
+    };
 }
 /** A judge call is a network round-trip, not a test: generous enough that a reasoning model finishes, bounded so one hung provider can't hold the gate open. */
 const DEFAULT_JUDGE_BUDGET = { timeout_ms: 120_000, max_output_bytes: 262_144 };
@@ -231,7 +303,7 @@ function isRecord(value) {
  * load-bearing only if something loads it.
  *
  * The verdict lives at `.structured_output` of the result envelope the grader
- * writes (.claude/agents/grader.md, "Output contract"); the envelope itself is
+ * writes (.claude/agents/bs-grader.md, "Output contract"); the envelope itself is
  * a Result and is not re-checked here. Three ways to not pass: the file is not
  * shaped like a grader result (`grader-invalid`), the run came back `dead`
  * because the task spec had no checkable acceptance criteria (`grader-fail`,
@@ -707,6 +779,38 @@ export async function runGate(input, ctx, opts = {}) {
             outstandingJudges: outstanding,
         }, ctx, opts);
     }
+    // U2 S3: a ui-affecting task owes a reviewed, fresh screenshot set before
+    // the diff goes any further, measured against this run's own commit (D2).
+    // `uiAffecting` absent means no `--plan` was given at all, so the flag
+    // cannot be resolved either way — the stage records that honestly rather
+    // than guessing, and does not block (D6). `uiAffecting: false` (including a
+    // task with no flag at all, D3) means the stage has nothing to check.
+    let uiuxCheck = 'skipped';
+    if (input.uiAffecting === undefined) {
+        uiuxCheck = 'unverifiable';
+    }
+    else if (input.uiAffecting) {
+        uiuxCheck = 'checked';
+        const uiux = await checkUiux({
+            taskId: input.taskId,
+            ...(commitCheck.head === null ? {} : { head: commitCheck.head }),
+            artifactsDir: input.artifactsDir,
+        }, ctx, opts);
+        if (uiux.outcome === 'blocked') {
+            return finalize({
+                outcome: 'blocked',
+                taskId: input.taskId,
+                reason: uiux.reason,
+                testResult: null,
+                schemaErrors: [],
+                blockingFindings: [],
+                artifactIssues: [],
+                commitCheck,
+                uiuxCheck,
+            }, ctx, opts);
+        }
+    }
+    const uiuxStatus = { uiuxCheck };
     // Before the tests, not after: the grader has already run, and if its rubric
     // says the criteria were not met the diff bounces whatever the suite says —
     // so a full test run here is spent for nothing. It sits behind the commit
@@ -724,6 +828,7 @@ export async function runGate(input, ctx, opts = {}) {
                 blockingFindings: [],
                 artifactIssues: [],
                 commitCheck,
+                ...uiuxStatus,
             }, ctx, opts);
         }
     }
@@ -753,6 +858,7 @@ export async function runGate(input, ctx, opts = {}) {
             artifactIssues: [],
             commitCheck,
             ...budget,
+            ...uiuxStatus,
         }, ctx, opts);
     }
     // After the tests pass, before the findings are judged: a green coverage
@@ -789,6 +895,7 @@ export async function runGate(input, ctx, opts = {}) {
                 commitCheck,
                 ...budget,
                 ...withCoverage,
+                ...uiuxStatus,
             }, ctx, opts);
         }
     }
@@ -822,6 +929,7 @@ export async function runGate(input, ctx, opts = {}) {
             ...diverted,
             ...budget,
             ...withCoverage,
+            ...uiuxStatus,
         }, ctx, opts);
     }
     if (pendingWaivers.length > 0) {
@@ -836,6 +944,7 @@ export async function runGate(input, ctx, opts = {}) {
             ...diverted,
             ...budget,
             ...withCoverage,
+            ...uiuxStatus,
         }, ctx, opts);
     }
     return finalize({
@@ -848,12 +957,13 @@ export async function runGate(input, ctx, opts = {}) {
         ...diverted,
         ...budget,
         ...withCoverage,
+        ...uiuxStatus,
     }, ctx, opts);
 }
-/** Real token spend off the already-schema-valid result, or undefined if absent. */
+/** Real token spend off the already-schema-valid result; undefined when absent or an unmeasured placeholder. */
 function tokensSpent(result) {
-    const usage = result?.token_usage;
-    return typeof usage?.total_tokens === 'number' ? usage.total_tokens : undefined;
+    const read = readTokenUsage(result?.token_usage);
+    return read.measured ? read.total : undefined;
 }
 /**
  * Declared budget vs. measured spend, for one task. The check never blocks: an
@@ -906,6 +1016,6 @@ function runBudgetCheck(input) {
     }
 }
 async function finalize(outcome, ctx, opts) {
-    await emit('gate-outcome', { outcome: outcome.outcome, reason: 'reason' in outcome ? outcome.reason : null }, outcome.taskId, ctx, opts);
-    return outcome;
+    const stored = await emit('gate-outcome', { outcome: outcome.outcome, reason: 'reason' in outcome ? outcome.reason : null }, outcome.taskId, ctx, opts);
+    return { ...outcome, event_id: stored.event_id };
 }

package/factory/orchestrator/dist/goalCheck.js

@@ -197,7 +197,7 @@ export function goalCheckBlockers(epicId, status, planVersion, livePlanTaskIds)
     }
     if (check === null) {
         return [
-            `Epic "${epicId}" has no spec-vs-goal check on record: nothing has asked whether its plan answers the goal milestone "${goal.milestoneId}" declares. Run \`smith epic goal-check --epic ${epicId}\`.`,
+            `Epic "${epicId}" has no spec-vs-goal check on record: nothing has asked whether its plan answers the goal milestone "${goal.milestoneId}" declares. Run \`bs epic goal-check --epic ${epicId}\`.`,
         ];
     }
     if (check.goalDigest !== goal.digest) {
@@ -246,7 +246,7 @@ export function goalCheckBlockers(epicId, status, planVersion, livePlanTaskIds)
     const uncovered = check.coverage.filter((entry) => entry.verdict === 'uncovered');
     if (uncovered.length > 0) {
         return [
-            `The spec-vs-goal check for "${epicId}" left ${uncovered.length} goal clause(s) uncovered by plan v${check.planVersion}: ${uncovered.map((entry) => JSON.stringify(entry.clause)).join('; ')}. Answer them with \`smith plan amend\` — no task diff can contain the fix.`,
+            `The spec-vs-goal check for "${epicId}" left ${uncovered.length} goal clause(s) uncovered by plan v${check.planVersion}: ${uncovered.map((entry) => JSON.stringify(entry.clause)).join('; ')}. Answer them with \`bs plan amend\` — no task diff can contain the fix.`,
         ];
     }
     return [];

package/factory/orchestrator/dist/harness.js

@@ -1,10 +1,13 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { parse as parseYaml } from 'yaml';
-import { loadBudgetPolicy } from './budgets.js';
+import { agentNameFor, templateFileFor } from './agentNames.js';
+import { loadBudgetPolicy, roleCapTokens } from './budgets.js';
+import { epicBudgetPolicies } from './epicBudget.js';
 import { SmithError } from './errors.js';
 import { AGENTS_DIR, HARNESS_POLICY_PATH, REPO_ROOT } from './paths.js';
 import { INSPECTED_FILE_TOOLS, loadGuardrailPolicy } from './policy.js';
+import { epicOfTaskId } from './taskId.js';
 import { loadTaxonomy } from './taxonomy.js';
 /**
  * The worker harness port: *how* a turn runs, named at last.
@@ -298,7 +301,7 @@ export function roleAccess(role, guardrails = loadGuardrailPolicy()) {
 }
 /** Where a role's prompt template lives, and whether it is there. */
 function templateFor(role, agentsDir) {
-    const file = path.join(agentsDir, `${role}.md`);
+    const file = path.join(agentsDir, templateFileFor(role));
     return { file, exists: existsSync(file) };
 }
 function serves(harness, role) {
@@ -347,17 +350,22 @@ function resolveSchema(name, harnessName) {
     }
     return { name, file };
 }
-function capTokensFor(role, access, budgets) {
-    // Only these three named roles carry a cap in budgets.yml today — every
-    // other role (security-reviewer, merger, tester, uiux, planner, scribe)
-    // has none, and null says so rather than inventing a number nobody set.
-    if (access === 'judge')
-        return budgets.task.judges.capTokens;
-    if (role === 'coder')
-        return budgets.task.coder.capTokens;
-    if (role === 'researcher')
-        return budgets.task.researcher.capTokens;
-    return null;
+function capTokensFor(role, budgets) {
+    // budgets.yml prices each role on its own line, sized for the policy's
+    // effort tier. A role it prices nowhere (merger, uiux, scribe, wave-runner)
+    // gets null, which says so rather than inventing a number nobody set.
+    return roleCapTokens(budgets, role);
+}
+/**
+ * budgets.yml sized for the effort tier of the epic `taskId` belongs to — the
+ * tier `cap_tokens` (and so the runner's `over_budget`) is judged at. A bare
+ * task id names no epic, and is priced at effort.yml's default tier.
+ */
+function budgetsForTask(taskId, planOpts) {
+    const epicId = epicOfTaskId(taskId);
+    return epicId === null
+        ? loadBudgetPolicy()
+        : epicBudgetPolicies(planOpts === undefined ? {} : { planOpts })(epicId);
 }
 function substitute(template, values, harness) {
     return template.replace(PLACEHOLDER_RE, (_match, token) => {
@@ -471,7 +479,7 @@ export function planWorkerTurn(request, options = {}) {
         throw new HarnessError('harness.unknown-tier', `"${request.tier}" is not a model tier. It is one of ${MODEL_TIERS.join(', ')}.`, { tier: request.tier });
     }
     if (request.promptFile === undefined || request.promptFile === '') {
-        throw new HarnessError('harness.missing-prompt', 'A worker turn needs a prompt file. This port renders invocations, not prompts — write the prompt first (`smith prompt record`), then plan the turn that carries it.', { role });
+        throw new HarnessError('harness.missing-prompt', 'A worker turn needs a prompt file. This port renders invocations, not prompts — write the prompt first (`bs prompt record`), then plan the turn that carries it.', { role });
     }
     const name = request.harness ?? policy.defaultHarness;
     const harness = policy.harnesses.find((h) => h.name === name);
@@ -509,7 +517,7 @@ export function planWorkerTurn(request, options = {}) {
         return {
             ...base,
             kind: 'in-process',
-            subagentType: role,
+            subagentType: agentNameFor(role),
             template: templateRelative,
         };
     }
@@ -536,11 +544,11 @@ export function planWorkerTurn(request, options = {}) {
     const roleArgs = access === 'judge' ? harness.judgeArgs : harness.workerArgs;
     const rawArgs = [...harness.args, ...roleArgs, ...(schema !== null ? harness.schemaArgs : [])];
     const args = rawArgs.map((arg) => substitute(arg, values, harness.name));
-    const budgets = options.budgets ?? loadBudgetPolicy();
+    const budgets = options.budgets ?? budgetsForTask(taskId, options.planOpts);
     const budget = {
         timeout_ms: harness.timeoutMs,
         max_output_bytes: harness.maxOutputBytes ?? HARNESS_DEFAULT_MAX_OUTPUT_BYTES,
-        cap_tokens: capTokensFor(role, access, budgets),
+        cap_tokens: capTokensFor(role, budgets),
     };
     return {
         ...base,