@juzser/blacksmith 0.3.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';
@@ -250,7 +250,9 @@ function escapeRegExp(text) {
  * forms) — never a bare `:digits` anywhere in the text. A blanket
  * `:\d+` strip is wrong: free-text like "debug endpoint exposed on :8080"
  * would collide with an unrelated ":9090" finding (reproduced regression,
- * reviewer finding #3).
+ * reviewer finding #3). The line number may itself be a range
+ * (`Widget.tsx:1549-1576`), which a re-review reports as often as a single
+ * line (issue #178).
  */
 function stripPathLineRef(summary, filePath) {
     const forwardSlashPath = filePath.replace(/\\/g, '/');
@@ -259,16 +261,37 @@ function stripPathLineRef(summary, filePath) {
     for (const candidate of candidates) {
         if (!candidate)
             continue;
-        const pattern = new RegExp(`${escapeRegExp(candidate)}:\\d+(?::\\d+)?`, 'g');
+        const pattern = new RegExp(`${escapeRegExp(candidate)}:\\d+(?:[-–—]\\d+)?(?::\\d+)?`, 'g');
         result = result.replace(pattern, candidate);
     }
     return result;
 }
+/**
+ * A `lines N-M` / `lines N–M` (en dash) / `line N to line M` range — the
+ * shape a judge describing a large component actually writes, and the one
+ * the original single `line N` strip below never covered (issue #178).
+ * Anchored on the word "line"/"lines" immediately before the numbers, so
+ * free-text numerics elsewhere in the sentence are never touched.
+ */
+const LINE_SPAN_RE = /\blines?\s+\d[\d,]*\s*(?:[-–—]|to(?:\s+lines?)?)\s*\d[\d,]*\b/g;
+/**
+ * `~5,050-line` / `6,720-line` — a size given as a hyphenated adjective
+ * before "line"/"component"/"file"/etc, approximate or exact. Only the
+ * `<number>-line` token is removed; the noun it modifies is untouched, and
+ * a hyphenated count before any OTHER noun (`3-day`, `5-retry`) is left
+ * alone — it is not a line reference.
+ */
+const LINE_COUNT_RE = /~?\d[\d,]*-line\b/g;
+/** `L1549-L6600` — a GitHub-style permalink line range, bare or after `#`. */
+const GITHUB_LINE_RANGE_RE = /\bl\d+-l\d+\b/g;
 /** lowercase, whitespace collapsed (spec wording; path-anchored line refs stripped by the caller). */
 function normalizeSummary(summary) {
     return summary
         .toLowerCase()
+        .replace(LINE_SPAN_RE, '')
         .replace(/\bline\s+\d+\b/g, '')
+        .replace(LINE_COUNT_RE, '')
+        .replace(GITHUB_LINE_RANGE_RE, '')
         .replace(/\s+/g, ' ')
         .trim();
 }
@@ -303,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
@@ -344,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) => {
@@ -508,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',
@@ -517,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
@@ -847,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 });
@@ -860,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,
@@ -895,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',
@@ -912,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.
@@ -1045,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.
@@ -1093,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,
@@ -1102,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.
@@ -1181,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)
@@ -1237,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',
@@ -1251,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/gh.js

@@ -141,9 +141,26 @@ function writeBodyFile(body) {
 export function buildCreateIssueArgv(repo, title, body) {
     return ['issue', 'create', '--repo', repo, '--title', title, '--body-file', writeBodyFile(body)];
 }
-/** Pure builder: the argv for `gh issue list` restricted to open issues matching `query`. */
+/**
+ * Pure builder: the argv for `gh issue list` restricted to open issues
+ * matching `query`. Without --json, gh prints a human-readable table that
+ * parseSearchResult can never parse as JSON, folding a real search into a
+ * generic failure indistinguishable from an actual nonzero exit. The fields
+ * requested here are exactly the ones parseSearchResult reads off each item.
+ */
 export function buildSearchIssuesArgv(repo, query) {
-    return ['issue', 'list', '--repo', repo, '--state', 'open', '--search', query];
+    return [
+        'issue',
+        'list',
+        '--repo',
+        repo,
+        '--state',
+        'open',
+        '--json',
+        'number,body,url',
+        '--search',
+        query,
+    ];
 }
 /** Pure builder: the argv for `gh issue comment`. Spawns nothing. */
 export function buildCommentArgv(repo, issueNumber, body) {

package/factory/orchestrator/dist/git.js

@@ -44,7 +44,11 @@ export function redactCredentials(text) {
         return colon === -1 ? `${scheme}***@` : `${scheme}${userinfo.slice(0, colon)}:***@`;
     });
 }
-function exec(cwd, args) {
+/**
+ * `onConflict`, when given, reads what git said from stdout on exit 1 — for
+ * the commands (merge-tree) that report a conflict there, not on stderr.
+ */
+function exec(cwd, args, onConflict) {
     try {
         return execFileSync('git', args, {
             cwd,
@@ -57,7 +61,9 @@ function exec(cwd, args) {
         // A child that never spawned has no exit code; `code` carries the errno
         // string instead, and that is the only thing worth reporting.
         const status = typeof e.status === 'number' ? e.status : null;
-        const said = e.stderr ?? (typeof e.code === 'string' ? `git could not be run (${e.code})` : '');
+        const said = onConflict !== undefined && status === 1
+            ? onConflict(e.stdout ?? '')
+            : (e.stderr ?? (typeof e.code === 'string' ? `git could not be run (${e.code})` : ''));
         throw new GitCommandError(cwd, args, status, redactCredentials(said));
     }
 }
@@ -72,6 +78,18 @@ export function runGit(cwd, args) {
 export function runGitRaw(cwd, args) {
     return exec(cwd, args);
 }
+/**
+ * `git merge-tree --write-tree` of two commits: the merged tree's id, with no
+ * working tree or index touched. A conflict (exit 1) throws GitCommandError
+ * carrying the conflicted paths and git's CONFLICT messages, which merge-tree
+ * prints on stdout rather than stderr.
+ */
+export function writeMergeTree(cwd, base, head) {
+    const args = ['merge-tree', '--write-tree', '--name-only', base, head];
+    // stdout on a conflict is the would-be tree id, then what conflicted.
+    const out = exec(cwd, args, (stdout) => stdout.split('\n').slice(1).join('\n'));
+    return out.split('\n')[0];
+}
 /**
  * The `origin` remote's URL, exactly as git reports it — credentials and
  * all, since redaction happens only on the error path inside `exec`. Throws

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 [];