@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/providers/types.js

@@ -1,7 +1,7 @@
 // Provider-agnostic judge contract (architecture §6): "any model that can
 // honor the I/O contract can serve" — a JudgeRequest is a plain diff+spec+
 // prior-findings prompt already assembled by the caller from
-// .claude/agents/{reviewer,verifier}.md's own contract, plus a schema
+// .claude/agents/bs-{reviewer,verifier}.md's own contract, plus a schema
 // name the extracted response is validated against. Transports never see
 // more than `prompt` — the trust boundary (architecture §6 "External
 // providers judge; they never gain write access... their findings are

package/factory/orchestrator/dist/queue.js

@@ -11,7 +11,7 @@ import { buildSymbolGraph, collectSources } from './symbols.js';
 import { emitTaskBlocked, emitWaveMerged } from './taskEvents.js';
 import { projectCommandEnv } from './testgate.js';
 import { renderSelectedTestCmd, selectTests } from './testSelect.js';
-import { integrationBranchName } from './worktree.js';
+import { epicBranchPrefix, integrationBranchName } from './worktree.js';
 export class QueueError extends SmithError {
 }
 /**
@@ -141,7 +141,7 @@ async function certifyAndRebase(task, integrationBranch, logBlocked) {
  * non-merged outcome.
  */
 export async function step(task, opts) {
-    const integrationBranch = integrationBranchName(opts.epic);
+    const integrationBranch = integrationBranchName(opts.epic, epicBranchPrefix(opts.projectDir, opts.epic));
     const events = opts.events;
     // Refused before certifyAndRebase's real `git rebase` or the merge below
     // ever runs: both mutate git for real, and used to be discovered only by
@@ -523,7 +523,7 @@ async function runGroup(tasks, opts, integrationBranch, logBlocked, knownRed = f
  * failing every task in the group for one task's sake.
  */
 export async function batchStep(tasks, opts) {
-    const integrationBranch = integrationBranchName(opts.epic);
+    const integrationBranch = integrationBranchName(opts.epic, epicBranchPrefix(opts.projectDir, opts.epic));
     const events = opts.events;
     // Same envelope check as step(), and for the same reason: runGroup below
     // rebases and merges real git state for every task in the group before its
@@ -582,7 +582,7 @@ function isAncestor(projectDir, ancestor, descendant) {
  */
 export async function adopt(task, opts) {
     const { projectDir } = opts;
-    const integrationBranch = integrationBranchName(opts.epic);
+    const integrationBranch = integrationBranchName(opts.epic, epicBranchPrefix(projectDir, opts.epic));
     for (const ref of [integrationBranch, task.branch]) {
         if (!resolveCommit(projectDir, ref)) {
             throw new QueueError('queue.adopt-unknown-branch', `Branch "${ref}" does not exist in ${projectDir} — there is nothing to adopt against.`, { branch: ref, taskId: task.taskId });

package/factory/orchestrator/dist/quorum.js

@@ -15,14 +15,15 @@
 // behavior. This is the mechanism that makes "flip crosscheck.yml" the
 // entire promotion step (docs/runbooks/providers.md).
 import { loadCrosscheckPolicy, providerModel } from './crosscheck.js';
+import { sessionOwnerRole } from './delegation.js';
 import { SmithError } from './errors.js';
-import { appendEvent } from './events.js';
+import { appendEvent, readLineageEvents } from './events.js';
 import { runJudge } from './providers/index.js';
 const DEFAULT_QUORUM_POLICY = { minProviders: 2 };
 /**
  * Bridge a raw JudgeResult into the binary confirm/refute quorum needs.
  * `kind: review` has no explicit verdict field (its contract is a findings
- * array, .claude/agents/reviewer.md) — presence of any finding IS the
+ * array, .claude/agents/bs-reviewer.md) — presence of any finding IS the
  * claim being judged ("this task has a real blocking issue"), so a
  * non-empty array reads as `confirm`. `kind: verify`/`plan-critique` carry
  * an explicit judge-verdict.schema.json object instead.
@@ -172,9 +173,15 @@ const KIND_TO_AGENT = {
  */
 export async function recordJudgeRun(input, ctx, opts = {}) {
     const agentRole = KIND_TO_AGENT[input.kind];
+    // Explicit --actor is authoritative and skips this lookup entirely; only an
+    // absent actor reaches for the delegated session's owner (issue #218, same
+    // shape as judges.ts's recordJudgeDispatch -- see delegatedActor there).
+    const actor = ctx.actor ??
+        sessionOwnerRole(await readLineageEvents(ctx.sessionId, opts), ctx.sessionId) ??
+        undefined;
     const dispatch = await appendEvent({
         session_id: ctx.sessionId,
-        actor: ctx.actor ?? 'system',
+        actor: actor ?? 'system',
         event_type: 'dispatch_decision',
         task_id: input.taskId,
         plan_version: ctx.planVersion,
@@ -184,7 +191,7 @@ export async function recordJudgeRun(input, ctx, opts = {}) {
             provider: input.run.provider,
             model_tier: input.modelTier,
             model: input.model,
-            reason: `cross-provider judge (${input.run.mode})`,
+            reason: `cross-provider judge (${input.run.mode})${input.run.via === 'openrouter' ? ' via openrouter' : ''}`,
         },
     }, opts);
     const ok = input.run.outcome.ok;
@@ -213,6 +220,7 @@ export async function recordJudgeRun(input, ctx, opts = {}) {
             model: input.model,
             kind: input.kind,
             mode: input.run.mode,
+            via: input.run.via ?? null,
             ok,
             verdict: ok ? verdict?.verdict : null,
             rationale: ok
@@ -324,7 +332,12 @@ export async function runQuorumCase(input, ctx, opts = {}) {
                 },
             };
         }
-        const run = { provider: providerName, mode: config.mode, outcome };
+        const run = {
+            provider: providerName,
+            mode: config.mode,
+            outcome,
+            via: config.transport === 'api' ? config.via : undefined,
+        };
         external.push(run);
         await recordJudgeRun({
             taskId: input.taskId,

package/factory/orchestrator/dist/results.js

@@ -46,8 +46,7 @@ export function stampResultEnvelope(agentResult, envelope) {
     if (overstep.length > 0) {
         throw new ResultError('results.agent-wrote-owned-field', `Result set dispatcher-owned field(s) ${overstep.join(', ')}. Agents return run_status, structured_output and artifacts only.`, { fields: [...overstep] });
     }
-    const inputTokens = requireTokenCount('input_tokens', envelope.inputTokens);
-    const outputTokens = requireTokenCount('output_tokens', envelope.outputTokens);
+    const tokenUsage = deriveTokenUsage(envelope);
     return {
         ...half,
         task_id: envelope.taskId,
@@ -56,10 +55,29 @@ export function stampResultEnvelope(agentResult, envelope) {
         model_tier: envelope.modelTier,
         // Derived, not accepted: a third number that can contradict the other two
         // is a third thing to get wrong.
-        token_usage: {
-            input_tokens: inputTokens,
-            output_tokens: outputTokens,
-            total_tokens: inputTokens + outputTokens,
-        },
+        token_usage: tokenUsage,
+    };
+}
+/**
+ * `{input_tokens, output_tokens, total_tokens}` when the dispatcher has real
+ * numbers, or `{measured: false}` when it has neither (#220) — never one
+ * without the other, since half a measurement is not an honest "not measured"
+ * and not a count either.
+ */
+function deriveTokenUsage(envelope) {
+    const { inputTokens, outputTokens } = envelope;
+    if (inputTokens === undefined && outputTokens === undefined) {
+        return { measured: false };
+    }
+    if (inputTokens === undefined || outputTokens === undefined) {
+        const missing = inputTokens === undefined ? 'input_tokens' : 'output_tokens';
+        throw new ResultError('results.partial-token-count', `input_tokens and output_tokens must both be given or both omitted (an honest "not measured" is neither alone); ${missing} is missing.`, { field: missing });
+    }
+    const input = requireTokenCount('input_tokens', inputTokens);
+    const output = requireTokenCount('output_tokens', outputTokens);
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: input + output,
     };
 }

package/factory/orchestrator/dist/roadmap.js

@@ -12,6 +12,7 @@
 import { readFileSync } from 'node:fs';
 import { SmithError } from './errors.js';
 import { roadmapReadPath } from './paths.js';
+import { FACTORY_PROJECT_NAME, normalizeProjectName } from './projectName.js';
 export class RoadmapError extends SmithError {
 }
 /**
@@ -25,11 +26,12 @@ export class RoadmapError extends SmithError {
  * clone's parent holds a `black-smith` sibling that is a DIFFERENT repository,
  * so the factory's own checkout is `REPO_ROOT` and never a name lookup.
  *
- * Deliberately not imported from `db/queries.ts`'s `DEFAULT_PROJECT`, which
- * says the same word: that module reaches drizzle, and `test/cliBoot.test.ts`
- * pins that the CLI's module graph never does.
+ * Sourced from `projectName.ts`, not `db/queries.ts`'s `DEFAULT_PROJECT`,
+ * which says the same word: that module reaches drizzle, and
+ * `test/cliBoot.test.ts` pins that the CLI's module graph never does.
+ * `projectName.ts` has no dependency of its own, so both may import it.
  */
-export const FACTORY_PROJECT = 'black-smith';
+export const FACTORY_PROJECT = FACTORY_PROJECT_NAME;
 export const MILESTONE_STATUSES = [
     'planned',
     'in-progress',
@@ -249,7 +251,10 @@ export function parseRoadmap(markdown) {
             }
             const projectVal = bulletValue(line, 'project');
             if (projectVal !== null && projectVal !== '') {
-                project = projectVal;
+                // Old roadmap.md bullets may still spell the factory's own project
+                // the old way (history is immutable); normalized here so the
+                // projection built from it never stores the legacy name.
+                project = normalizeProjectName(projectVal);
                 continue;
             }
             // An empty `- kind:` is absent, not invalid -- the same reading

package/factory/orchestrator/dist/run-cli.js

@@ -7,12 +7,13 @@
 // test in test/runner.test.ts).
 import { readFileSync, writeFileSync } from 'node:fs';
 import { parseArgs } from './args.js';
+import { warnIfLegacyName } from './cliName.js';
 import { runInvocation } from './runner.js';
-const HELP = `Usage: smith-run <invocation.json | -> [--prompt-file <path>] [--timeout-ms <n>] [--out <file>]
+const HELP = `Usage: bs-run <invocation.json | -> [--prompt-file <path>] [--timeout-ms <n>] [--out <file>]
 
-Spawns ONE already-rendered worker invocation (the JSON \`smith harness plan\`
-prints) and reports what happened as JSON. This is not \`smith harness run\`:
-\`smith\` only ever renders an invocation and never starts it (§18 rule 3,
+Spawns ONE already-rendered worker invocation (the JSON \`bs harness plan\`
+prints) and reports what happened as JSON. This is not \`bs harness run\`:
+\`bs\` only ever renders an invocation and never starts it (§18 rule 3,
 "nothing that observes may dispatch"), so starting the process an invocation
 describes lives in its own binary instead.
 
@@ -60,6 +61,10 @@ function exitCodeFor(outcome) {
     return 0;
 }
 async function main() {
+    // bs-rename, operator decision 3: a no-op unless argv[1]'s basename is the
+    // deprecated `smith-run`, in which case it writes one line to stderr,
+    // never stdout -- stdout carries the JSON RunOutcome.
+    warnIfLegacyName(process.argv[1], 'smith-run', 'bs-run');
     const argv = process.argv.slice(2);
     const parsed = parseArgs(argv, FLAG_SPEC);
     if (parsed.flags.help === 'true') {
@@ -68,7 +73,7 @@ async function main() {
     }
     const source = parsed.positional[0];
     if (source === undefined) {
-        process.stderr.write('smith-run: missing <invocation.json | -> argument.\n\n');
+        process.stderr.write('bs-run: missing <invocation.json | -> argument.\n\n');
         process.stderr.write(HELP);
         return 1;
     }
@@ -78,14 +83,14 @@ async function main() {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`smith-run: could not read/parse invocation: ${message}\n`);
+        process.stderr.write(`bs-run: could not read/parse invocation: ${message}\n`);
         return 1;
     }
     const timeoutOverride = parsed.flags['timeout-ms'];
     if (timeoutOverride !== undefined && invocation.kind === 'cli') {
         const timeout_ms = Number.parseInt(timeoutOverride, 10);
         if (Number.isNaN(timeout_ms)) {
-            process.stderr.write(`smith-run: --timeout-ms must be a number, got "${timeoutOverride}".\n`);
+            process.stderr.write(`bs-run: --timeout-ms must be a number, got "${timeoutOverride}".\n`);
             return 1;
         }
         invocation = { ...invocation, budget: { ...invocation.budget, timeout_ms } };
@@ -98,7 +103,7 @@ async function main() {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`smith-run: could not read --prompt-file: ${message}\n`);
+            process.stderr.write(`bs-run: could not read --prompt-file: ${message}\n`);
             return 1;
         }
     }
@@ -108,7 +113,7 @@ async function main() {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`smith-run: ${message}\n`);
+        process.stderr.write(`bs-run: ${message}\n`);
         return 1;
     }
     const json = `${JSON.stringify(outcome, null, 2)}\n`;
@@ -125,6 +130,6 @@ main().then((code) => {
     process.exitCode = code;
 }, (err) => {
     const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
-    process.stderr.write(`smith-run: unexpected error: ${message}\n`);
+    process.stderr.write(`bs-run: unexpected error: ${message}\n`);
     process.exitCode = 1;
 });

package/factory/orchestrator/dist/runner.js

@@ -170,8 +170,8 @@ function validate(answer, schema) {
 export async function runInvocation(invocation, opts = {}) {
     if (invocation.kind === 'in-process') {
         throw new RunnerError('runner.in-process', `Invocation for role "${invocation.role}" is in-process (harness "${invocation.harness}") — ` +
-            'smith-run starts programs, not Agent-tool subagents. In-process harnesses run inside the ' +
-            'orchestrator session itself and have no separate binary for smith-run to spawn.', { harness: invocation.harness, role: invocation.role });
+            'bs-run starts programs, not Agent-tool subagents. In-process harnesses run inside the ' +
+            'orchestrator session itself and have no separate binary for bs-run to spawn.', { harness: invocation.harness, role: invocation.role });
     }
     const now = opts.now ?? Date.now;
     const start = now();

package/factory/orchestrator/dist/schemas.js

@@ -154,7 +154,40 @@ function assertEveryAnnotationReachable(name, schema, pointers) {
         'onto the property (or onto `items`) that carries the value.', { schema: name, paths: unreachable });
 }
 function ajvErrorToIssue(err) {
-    return { path: err.instancePath || '/', message: `${err.instancePath} ${err.message}`.trim() };
+    // additionalProperties names the offending key only in `params`, never in
+    // `instancePath`/`message` — without it, "must NOT have additional
+    // properties" is true of every extra key on the record at once, and an
+    // evidence file with three wrong field names (issue #233) reads as one
+    // undifferentiated complaint instead of three actionable ones.
+    const extra = err.keyword === 'additionalProperties'
+        ? err.params.additionalProperty
+        : undefined;
+    const base = `${err.instancePath} ${err.message}`.trim();
+    return { path: err.instancePath || '/', message: extra ? `${base}: ${extra}` : base };
+}
+/**
+ * The ajv-structural half of `validateRecord`, on its own: does this record
+ * have the shape the schema declares, with no taxonomy lookup at all.
+ *
+ * Split out for `validateEachShape` below, which checks a whole array of
+ * records (a judge's evidence file) against one schema before anything reads
+ * a taxonomy value out of any of them — a record that got the shape wrong
+ * (issue #233's wrong field names, a `failure_scenario` given as a string)
+ * must never reach code that assumes the shape is already right.
+ */
+export function validateSchemaShape(schemas, schemaName, record) {
+    const compiled = schemas.get(schemaName);
+    if (!compiled) {
+        throw new SchemaError('schema.unknown-name', `Unknown schema "${schemaName}".`, {
+            schemaName,
+            known: [...schemas.keys()],
+        });
+    }
+    const schemaValid = compiled.validate(record);
+    if (!schemaValid) {
+        return { valid: false, errors: (compiled.validate.errors ?? []).map(ajvErrorToIssue) };
+    }
+    return { valid: true };
 }
 /**
  * Validate a record against a compiled schema by name, then resolve every
@@ -169,13 +202,8 @@ export function validateRecord(schemas, taxonomy, schemaName, record) {
             known: [...schemas.keys()],
         });
     }
-    const errors = [];
-    const schemaValid = compiled.validate(record);
-    if (!schemaValid) {
-        for (const err of compiled.validate.errors ?? []) {
-            errors.push(ajvErrorToIssue(err));
-        }
-    }
+    const shape = validateSchemaShape(schemas, schemaName, record);
+    const errors = shape.valid ? [] : [...shape.errors];
     for (const pointer of compiled.taxonomyPointers) {
         for (const hit of resolveAtPath(record, pointer.segments)) {
             if (hit.value === undefined)
@@ -193,3 +221,23 @@ export function validateRecord(schemas, taxonomy, schemaName, record) {
         return { valid: false, errors };
     return { valid: true };
 }
+/**
+ * Validate every element of an array against one named schema, structurally
+ * (`validateSchemaShape`, no taxonomy lookup), collecting every index that
+ * fails rather than stopping at the first.
+ *
+ * Shared by `findings.ts` (evidence a judge hands `findings raise --evidence`
+ * or `gate run --evidence`) and `judges.ts` (the same evidence shape arriving
+ * as a judge's reported artifact) — one schema, one failure-collection rule,
+ * so the two intake paths cannot drift on what "malformed" means (issue
+ * #233).
+ */
+export function validateEachShape(schemas, schemaName, records) {
+    const failures = [];
+    records.forEach((record, index) => {
+        const result = validateSchemaShape(schemas, schemaName, record);
+        if (!result.valid)
+            failures.push({ index, errors: result.errors });
+    });
+    return failures;
+}

package/factory/orchestrator/dist/severity.js

@@ -69,11 +69,15 @@ export function parseSeverityPolicy(yamlText) {
 export function loadSeverityPolicy(filePath = SEVERITY_POLICY_PATH) {
     return parseSeverityPolicy(readFileSync(filePath, 'utf8'));
 }
-const ENTRY_HEADING = /^### /;
-const SECTION_HEADING = /^## (.+)$/;
-const BULLET = /^- ([a-z_]+):\s*(.*)$/;
+// Exported (not just used by parseLessons below): lessons.ts's compileLessons
+// reuses these four to salvage a pre-existing entry compileLessons() itself
+// can't regenerate (no store row) — one parser, shared by both directions of
+// the round-trip, so they can't drift apart on what an "entry" is.
+export const ENTRY_HEADING = /^### /;
+export const SECTION_HEADING = /^## (.+)$/;
+export const BULLET = /^- ([a-z_]+):\s*(.*)$/;
 /** An indented, non-bullet line — a continuation of the previous bullet's value. */
-const CONTINUATION = /^\s+(\S.*)$/;
+export const CONTINUATION = /^\s+(\S.*)$/;
 /**
  * taxonomy.yml `lesson_scope`, in compiled-section order — only entries under
  * one of these `##` sections are real lessons, which is also what stops a `##`