@juzser/blacksmith 0.3.0 → 0.4.0

package/factory/orchestrator/dist/taskEvents.js

@@ -139,7 +139,12 @@ ctx, opts = {}) {
     for (const { record } of events) {
         if (record.event_type !== 'task-added' || !record.task_id)
             continue;
-        byId.set(record.task_id, { taskId: record.task_id, claims: record.payload?.claims });
+        const epicId = record.payload?.epic_id;
+        byId.set(record.task_id, {
+            taskId: record.task_id,
+            claims: record.payload?.claims,
+            epicId: typeof epicId === 'string' ? epicId : undefined,
+        });
     }
     return [...byId.values()];
 }
@@ -369,9 +374,13 @@ export function followUpTaskId(epicId, fingerprint) {
  *
  * Returns null when the session already carries this task, so a re-run is a
  * no-op rather than a duplicate. The task is `todo`, which is not terminal-OK,
- * so epic.ts's `summarizeEpic` blocks the epic verdict on it until an operator
- * plans or waives it — the "blocks the epic verdict instead of an unrelated
- * diff" half of P9-24, using the machinery that was already there.
+ * so epic.ts's `summarizeEpic` blocks the epic verdict on it — the "blocks the
+ * epic verdict instead of an unrelated diff" half of P9-24, using the
+ * machinery that was already there. Nothing writes a task to `waived`, so the
+ * two ways out are completing it (plan it, gate it) or waiving the findings
+ * it owns: summarizeEpic reads a follow-up terminal-OK once at least one
+ * finding is attributed to it and every one of them is `waived`
+ * (epic.ts's clearedFollowUpFindings).
  */
 export async function emitFollowUpTask(input, ctx, opts = {}) {
     const added = await idsAlreadyEmitted('task-added', ctx, opts);

package/factory/orchestrator/dist/taxonomy.js

@@ -15,6 +15,14 @@ const NON_DIMENSION_KEYS = new Set(['version', 'rules', 'error']);
 const PRESENCE_ONLY_FIELDS = new Set(['task_ref', 'provenance_event_ids', 'model']);
 /** The `error` dimension is validated as a `group.class` pair, not a flat tag. */
 const ERROR_CLASS_FIELD = 'error';
+// `task_ref` names exactly one task; it is otherwise presence-only (above),
+// which let a comma-joined "epic-1/task-1,epic-1/task-2" through as one
+// non-empty string. db/projector.ts's fold read that string as a single task
+// id and minted a phantom row for it that stayed `todo` forever, holding
+// epic verdict on a task that was never real. Reject the shape here so the
+// log never grows another one — a producer with two failing tasks logs two
+// error-logged events, not one with two ids stitched together.
+const TASK_REF_FIELD = 'task_ref';
 export function parseTaxonomy(yamlText) {
     const doc = parseYaml(yamlText);
     if (!doc || typeof doc !== 'object') {
@@ -102,6 +110,9 @@ export function validateRequiredDimensions(taxonomy, recordType, record) {
         if (isEmpty) {
             throw new TaxonomyError('taxonomy.missing-required-dimension', `Record type "${recordType}" is missing required field "${field}".`, { recordType, field });
         }
+        if (field === TASK_REF_FIELD && String(value).includes(',')) {
+            throw new TaxonomyError('taxonomy.multi-value-task-ref', `Record type "${recordType}" field "task_ref" names more than one task ("${String(value)}"). Log one error-logged event per task instead.`, { recordType, field, value });
+        }
         if (PRESENCE_ONLY_FIELDS.has(field))
             continue;
         if (field === ERROR_CLASS_FIELD) {

package/factory/orchestrator/dist/testgate.js

@@ -94,8 +94,9 @@ export function projectCommandEnv(env) {
  * jobs, long-lived children) running as orphans after the parent shell
  * dies — a real leak in a 24/7 factory (reproduced: manual kill -9 needed).
  */
-function runOne(check, cwd, timeoutMs) {
+function runOne(check, cwd, defaultTimeoutMs) {
     return new Promise((resolve) => {
+        const timeoutMs = check.timeout_ms ?? defaultTimeoutMs;
         const child = spawn(check.cmd, {
             cwd,
             shell: true,
@@ -176,10 +177,10 @@ function runOne(check, cwd, timeoutMs) {
  * no test-output parsing beyond the process exit code.
  */
 export async function run(checks, opts) {
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const defaultTimeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const results = [];
     for (const check of checks) {
-        const result = await runOne(check, opts.cwd, timeoutMs);
+        const result = await runOne(check, opts.cwd, defaultTimeoutMs);
         results.push(result);
         if (!result.pass && !opts.runAll)
             break;

package/factory/orchestrator/dist/usage.js

@@ -31,7 +31,7 @@ const EVENTS_DIR = `${EVENTS} [--state-dir <dir>]`;
  */
 const STATS = '[--db <file>] [--session <id>] [--lineage]';
 /** The scope both `issues` actions accept: a session's lineage, narrowed by epic and ISO since. */
-const ISSUES = '--session <id> [--epic <id>] [--since <iso>] [--state-dir <dir>] [--roadmap-path <file>]';
+const ISSUES = '--session <id> [--epic <id>] [--since <iso>] [--state-dir <dir>] [--roadmap-path <file>] [--specs-dir <dir>]';
 export const COMMANDS = [
     {
         command: 'audit open',
@@ -66,8 +66,8 @@ export const COMMANDS = [
     {
         command: 'audit resolve',
         positionals: '<project-dir>',
-        flags: `--epic <epic-id> ${EVENTS_DIR}`,
-        summary: 'Append a fixed line for every finding the epic carried. Run from the epic-close step.',
+        flags: `--epic <epic-id> [--except <fp[,fp...]>] [--plan <plan.json>] [--specs-dir <dir>] ${EVENTS_DIR}`,
+        summary: "Append a fixed line for every carried finding the epic's newest plan still claims; list the rest as deferred. Run from the epic-close step.",
     },
     {
         command: 'audit close',
@@ -198,7 +198,7 @@ export const COMMANDS = [
     {
         command: 'daemon run',
         positionals: '',
-        flags: `[--interval <seconds>] [--once] [--dir <dir>] [--project <dir>...] [--no-self] [--db <path>] [--no-db] [--state-dir <dir>]`,
+        flags: `[--interval <seconds>] [--once] [--dir <dir>] [--project <dir>...] [--no-self] [--db <path>] [--no-db] [--state-dir <dir>] [--specs-dir <dir>]`,
         summary: 'Watch the event log in the foreground: budgets, stale agents, work that is due. ' +
             'Prints one report per tick, one JSON line each; --once prints one document and exits. ' +
             'Never dispatches.',
@@ -232,21 +232,21 @@ export const COMMANDS = [
     {
         command: 'scheduler run',
         positionals: '',
-        flags: `[--dry] [--now <iso>] [--project <dir>...] [--no-self] ${EVENTS_DIR}`,
+        flags: `[--dry] [--now <iso>] [--project <dir>...] [--no-self] [--specs-dir <dir>] ${EVENTS_DIR}`,
         summary: 'Propose and enact the next scheduler moves for a session. --dry proposes only.',
     },
     {
         command: 'scheduler admit',
         positionals: '',
         flags: '--session <id> [--state-dir <dir>] [--now <iso>] [--project <dir>...] [--no-self] ' +
-            '[--policy <file>] [--crosscheck <file>]',
+            '[--specs-dir <dir>] [--policy <file>] [--crosscheck <file>]',
         summary: "Classify what's due into auto or operator per scheduler.yml autonomy. Enacts nothing.",
     },
     {
         command: 'worktree create',
         positionals: '<project-dir> <epic> <task-id>',
-        flags: '',
-        summary: 'Cut the isolated worktree and task branch one task is allowed to write in.',
+        flags: '[--from <predecessor-task-id> --session <id> [--state-dir <dir>]]',
+        summary: 'Cut the isolated worktree and task branch one task is allowed to write in. --from cuts it from a predecessor branch instead of integration, and requires --session (which supplies the log --from is checked against): refused unless that session records <epic>/<task-id> as the logged successor of <epic>/<predecessor-task-id>.',
     },
     {
         command: 'worktree rm',
@@ -275,8 +275,10 @@ export const COMMANDS = [
     {
         command: 'queue run',
         positionals: '<epic>',
-        flags: '--project <dir> --test-cmd <cmd> --tasks <tasks.json> [--select-test-cmd <cmd>] [--session <id> --causal-parent <event-id> --plan <plan.json> [--plan-version <n>] [--actor <name>]] [--state-dir <dir>]',
-        summary: 'Serially rebase, test, and merge task branches into the integration branch.',
+        flags: '--project <dir> --test-cmd <cmd> --tasks <tasks.json> [--select-test-cmd <cmd>] [--batch] [--session <id> --causal-parent <event-id> --plan <plan.json> [--plan-version <n>] [--actor <name>]] [--state-dir <dir>]',
+        summary: 'Serially rebase, test, and merge task branches into the integration branch. ' +
+            '--batch (roadmap merge-lanes) groups claim-disjoint tasks with groupForBatch and ' +
+            'tests each group once instead of once per task — see queue.ts and the operator guide.',
     },
     {
         command: 'queue adopt',
@@ -359,6 +361,12 @@ export const COMMANDS = [
         flags: '[--task <id>] [--policy <path>] [--state-dir <dir>]',
         summary: 'Assert crosscheck.yml’s role asymmetry against the log. Exit 1 on a violation OR an unverifiable answer.',
     },
+    {
+        command: 'dispatch lint',
+        positionals: '<prompt-file>',
+        flags: '--role <role> --task <id> --session <id> [--agents-dir <dir>] [--state-dir <dir>]',
+        summary: "Check a composed dispatch prompt's stated turn budget against the role template's maxTurns, and a judge prompt's declared-artifact line against the ledger. Exit 1 on a violation OR an unverifiable answer. `-` reads stdin.",
+    },
     {
         command: 'tester check',
         positionals: '<session-id>',

package/factory/orchestrator/dist/waivers.js

@@ -1,6 +1,6 @@
 import { SmithError } from './errors.js';
 import { appendEvent, readLineageEvents } from './events.js';
-import { listFindings, preWaiverStatus, staleFindings, transition, WAIVABLE_STATUSES, } from './findings.js';
+import { computeFingerprint, foldFindings, listFindings, preWaiverStatus, staleFindings, transition, WAIVABLE_STATUSES, } from './findings.js';
 export class WaiverError extends SmithError {
 }
 /**
@@ -10,6 +10,38 @@ export class WaiverError extends SmithError {
  * call or via a waiver grant).
  */
 export const WAIVABLE_SEVERITIES = ['S3-minor', 'S4-nit'];
+/**
+ * Every fingerprint that names the same finding as `fingerprint`, for each
+ * candidate in `findings` that could stand in for it: its own stored value,
+ * and what computeFingerprint would produce today from its persisted
+ * file_path/finding_category/summary. Mirrors audit.ts's
+ * suppressedFingerprints, for the same reason (issue #178): a `finding-raised`
+ * or waiver-decision record written before the normalizer widened to also
+ * strip line spans ("lines 1549-1576") fingerprints differently than the
+ * identical text does now, so a stored fingerprint and a freshly computed one
+ * for the same defect can legitimately disagree.
+ *
+ * Always includes `fingerprint` itself, so a caller with no backing finding
+ * yet (e.g. a batch decision not folded into findings) still gets an
+ * exact-match-only set — unchanged behaviour.
+ */
+function fingerprintAliases(fingerprint, findings) {
+    const aliases = new Set([fingerprint]);
+    for (const finding of findings) {
+        if (finding.file_path === undefined)
+            continue;
+        const recomputed = computeFingerprint({
+            filePath: finding.file_path,
+            category: finding.finding_category,
+            summary: finding.summary,
+        });
+        if (finding.fingerprint === fingerprint || recomputed === fingerprint) {
+            aliases.add(finding.fingerprint);
+            aliases.add(recomputed);
+        }
+    }
+    return aliases;
+}
 /**
  * Fold waiver-granted/waiver-denied events for one fingerprint: the last
  * decision wins (a denial can, in principle, be revisited by a later grant
@@ -20,13 +52,19 @@ export const WAIVABLE_SEVERITIES = ['S3-minor', 'S4-nit'];
  * would re-raise a finding the operator already waived the moment an epic
  * continued in a new session. "Last decision wins" is decided on the merged
  * order, which is `ts` between sessions and append order within one.
+ *
+ * Matches against `fingerprintAliases(fingerprint, ...)` rather than strict
+ * equality (issue #178): a decision recorded under the fingerprint's old
+ * spelling still answers a lookup under its current one, and vice versa.
  */
 export async function isWaived(fingerprint, ref, opts = {}) {
     const events = await readLineageEvents(ref.sessionId, opts);
+    const equivalents = fingerprintAliases(fingerprint, foldFindings(events));
     let waived = false;
     for (const { record } of events) {
         const payload = record.payload;
-        if (payload.fingerprint !== fingerprint)
+        const fp = payload.fingerprint;
+        if (fp === undefined || !equivalents.has(fp))
             continue;
         if (record.event_type === 'waiver-granted')
             waived = true;
@@ -38,13 +76,17 @@ export async function isWaived(fingerprint, ref, opts = {}) {
 /**
  * Has the operator recorded ANY waiver decision for this fingerprint (granted
  * or denied)? Lineage-wide, for isWaived's reason (D-119): a decision recorded
- * in the parent session is still a decision.
+ * in the parent session is still a decision. Same alias widening as isWaived,
+ * and for the same reason (issue #178).
  */
 async function hasDecision(fingerprint, ref, opts) {
     const events = await readLineageEvents(ref.sessionId, opts);
+    const equivalents = fingerprintAliases(fingerprint, foldFindings(events));
     return events.some(({ record }) => {
         const payload = record.payload;
-        return (payload.fingerprint === fingerprint &&
+        const fp = payload.fingerprint;
+        return (fp !== undefined &&
+            equivalents.has(fp) &&
             (record.event_type === 'waiver-granted' || record.event_type === 'waiver-denied'));
     });
 }
@@ -56,10 +98,16 @@ async function hasDecision(fingerprint, ref, opts) {
  * finding as open forever. Findings the state machine can't legally move
  * (already terminal, or a non-S3/S4 severity that somehow shares this
  * fingerprint) are left alone; this is reconciliation, not a mandate.
+ *
+ * Matched via fingerprintAliases (issue #178), not strict equality: a grant
+ * against a finding's current fingerprint also reconciles a row for the
+ * identical defect still carrying the pre-widening fingerprint it was raised
+ * under, and vice versa.
  */
 async function reconcileFindingsToWaived(fingerprint, waiverEventId, ctx, opts) {
     const findings = await listFindings(ctx.sessionId, {}, opts);
-    const reconcilable = findings.filter((f) => f.fingerprint === fingerprint &&
+    const equivalents = fingerprintAliases(fingerprint, findings);
+    const reconcilable = findings.filter((f) => equivalents.has(f.fingerprint) &&
         WAIVABLE_SEVERITIES.includes(f.severity) &&
         WAIVABLE_STATUSES.includes(f.finding_status));
     const transitionCtx = { ...ctx, causalParent: waiverEventId };
@@ -92,11 +140,16 @@ export async function grantWaiver(fingerprint, operatorNote, ctx, opts = {}) {
  *
  * Only findings this session's log actually shows at `waived` are touched, and
  * each goes back to the status its own grant recorded as from_status. A
- * finding waived under some other fingerprint is not this denial's business.
+ * finding waived under some other fingerprint is not this denial's business —
+ * "other" meaning a different defect, not merely a different spelling: matched
+ * via fingerprintAliases (issue #178), the same widening reconcileFindingsToWaived
+ * applies, so a row still carrying the pre-widening fingerprint it was raised
+ * under reopens alongside its current-fingerprint sibling.
  */
 async function reconcileFindingsFromWaived(fingerprint, denialEventId, ctx, opts) {
     const findings = await listFindings(ctx.sessionId, {}, opts);
-    const reopenable = findings.filter((f) => f.fingerprint === fingerprint && f.finding_status === 'waived');
+    const equivalents = fingerprintAliases(fingerprint, findings);
+    const reopenable = findings.filter((f) => equivalents.has(f.fingerprint) && f.finding_status === 'waived');
     const transitionCtx = { ...ctx, causalParent: denialEventId };
     for (const finding of reopenable) {
         const to = await preWaiverStatus(finding.finding_id, ctx.sessionId, opts);

package/factory/orchestrator/dist/waveSchedule.js

@@ -40,6 +40,8 @@
  * Pure, and it writes nothing. Like `waveNext`, admission stays where it was:
  * a round simulated here has been admitted by nobody.
  */
+import { claimsOverlap, readEdgeList } from './claims.js';
+import { planClaimedTasks } from './plan.js';
 import { computeNextWave, } from './waveNext.js';
 /**
  * Reported in this order, which is the order `computeNextWave` tests them in.
@@ -150,3 +152,85 @@ export function scheduleWaves(input) {
         exitCode: stalled.length > 0 ? 1 : constraints.length > 0 ? 2 : 0,
     };
 }
+/**
+ * Directed reachability over the plan's `depends_on` edges, both ways: the
+ * tasks reachable by walking forward (its descendants) and the tasks
+ * reachable by walking backward (its ancestors). Two tasks are connected —
+ * "a dependency path between them in either direction" — when either set
+ * contains the other, which a chain like C -> B -> A catches for A and C
+ * even though no edge names that pair directly.
+ */
+function connectedTaskIds(ids, edges) {
+    const descendantsOf = new Map();
+    const ancestorsOf = new Map();
+    for (const id of ids) {
+        descendantsOf.set(id, []);
+        ancestorsOf.set(id, []);
+    }
+    for (const edge of edges) {
+        if (!ids.has(edge.task) || !ids.has(edge.dependsOn))
+            continue;
+        descendantsOf.get(edge.dependsOn)?.push(edge.task);
+        ancestorsOf.get(edge.task)?.push(edge.dependsOn);
+    }
+    const reachable = (start, adjacency) => {
+        const seen = new Set();
+        const stack = [...(adjacency.get(start) ?? [])];
+        while (stack.length > 0) {
+            const next = stack.pop();
+            if (seen.has(next))
+                continue;
+            seen.add(next);
+            for (const n of adjacency.get(next) ?? [])
+                if (!seen.has(n))
+                    stack.push(n);
+        }
+        return seen;
+    };
+    const connected = new Map();
+    for (const id of ids) {
+        connected.set(id, new Set([...reachable(id, descendantsOf), ...reachable(id, ancestorsOf)]));
+    }
+    return connected;
+}
+const SMALL_MAX_TASKS = 3;
+const SMALL_MAX_CLAIMS = 10;
+/**
+ * Pure. Superseded tasks are absent from `planClaimedTasks` already (D-126),
+ * so they never enter `widest`, `parallelWith`, or `size` — no separate
+ * filter needed here.
+ */
+export function computePlanParallelism(plan, policy) {
+    const claimedTasks = planClaimedTasks(plan).filter((t) => t.task_id !== undefined);
+    const ids = new Set(claimedTasks.map((t) => t.task_id));
+    const edges = readEdgeList(plan.edges);
+    const connected = connectedTaskIds(ids, edges);
+    const parallelWith = {};
+    for (const a of claimedTasks) {
+        const withIds = [];
+        for (const b of claimedTasks) {
+            if (a.task_id === b.task_id)
+                continue;
+            if (connected.get(a.task_id)?.has(b.task_id))
+                continue;
+            if (claimsOverlap(a, b).overlaps)
+                continue;
+            withIds.push(b.task_id);
+        }
+        parallelWith[a.task_id] = withIds.sort();
+    }
+    const { widest } = scheduleWaves({ plan, policy });
+    const claimPaths = new Set();
+    for (const t of claimedTasks)
+        for (const c of t.claims)
+            claimPaths.add(c);
+    return {
+        widest,
+        parallel_with: parallelWith,
+        size: {
+            tasks: claimedTasks.length,
+            claims: claimPaths.size,
+            small: claimedTasks.length <= SMALL_MAX_TASKS && claimPaths.size <= SMALL_MAX_CLAIMS,
+        },
+    };
+}

package/factory/orchestrator/dist/worktree.js

@@ -127,18 +127,31 @@ function ensureIntegrationBranch(projectDir, epic) {
  * sibling of whatever directory the project was handed as, never a path of
  * this module's own choosing, so a project outside this clone keeps its
  * worktrees outside it too (see taskWorktreeDir)
- * on branch smith/<epic>/<task-id>, cut from the CURRENT head of
- * smith/<epic>/integration (creating the integration branch from the default
- * branch first if it doesn't exist yet).
+ * on branch smith/<epic>/<task-id>.
+ *
+ * Without `opts.from`, cut from the CURRENT head of smith/<epic>/integration
+ * (creating the integration branch from the default branch first if it
+ * doesn't exist yet). With `opts.from`, cut from smith/<epic>/<from> instead
+ * — the predecessor's branch, commits and all — and integration is never
+ * consulted.
  */
-export function createTaskWorktree(projectDir, epic, taskId) {
+export function createTaskWorktree(projectDir, epic, taskId, opts = {}) {
     if (taskId === RESERVED_TASK_ID) {
         throw new WorktreeError('worktree.reserved-task-id', `Task id "${RESERVED_TASK_ID}" is reserved for the integration branch itself.`, { taskId });
     }
-    const integrationBranch = ensureIntegrationBranch(projectDir, epic);
     const branch = taskBranchName(epic, taskId);
     const worktreeDir = taskWorktreeDir(projectDir, epic, taskId);
-    git(projectDir, ['worktree', 'add', '-b', branch, worktreeDir, integrationBranch]);
+    let sourceBranch;
+    if (opts.from !== undefined) {
+        sourceBranch = taskBranchName(epic, opts.from);
+        if (!localBranchExists(projectDir, sourceBranch)) {
+            throw new WorktreeError('worktree.from-missing', `Predecessor branch ${sourceBranch} does not exist; cannot cut ${taskId} from it.`, { epic, taskId, from: opts.from, branch: sourceBranch });
+        }
+    }
+    else {
+        sourceBranch = ensureIntegrationBranch(projectDir, epic);
+    }
+    git(projectDir, ['worktree', 'add', '-b', branch, worktreeDir, sourceBranch]);
     return { worktreeDir, branch, epic, taskId };
 }
 /** Remove a task's worktree and its local branch after it has merged. */

package/factory/specs/roadmap.md

@@ -175,3 +175,27 @@ all; write `- error_issues: off` by hand to opt a project's tracker out.
 - status: planned
 - epics: []
 - goal: Stop spending judge calls on outputs that a free check could have rejected, and stop grading a capped output as though it were a finished one. Four pieces, independent enough to land separately. **Free critics ahead of paid judges**: an empty diff, a missing structured completion, and claims touched without a single test added are all decidable without a model, and each one currently reaches a judge that pays full price to say so. The OpenHands SDK runs exactly this tier first and classifies what it rejects as behaviour, infrastructure or unclear-request — a taxonomy worth having because "the agent failed" and "the environment failed" are different bugs with different owners, and today they land in the same place. **Grade a budget-capped output as worth less**: SWE-agent's reviewer discards out-of-range verdicts and tie-breaks on cost; here the sharper version is that an output produced by an agent that hit its turn cap is a partial output, and a judge that does not know that is being asked to grade a fragment as a whole — which is how a capped run earns a passing verdict for the third of the task it finished. **Submit-gating and an honest forfeit**: show the worker its own diff before it may report done, with a checklist that names the mistakes workers actually make — test files touched, debug output left, claims exceeded — and give it a structured way to give up. A forfeit is strictly more useful than a confident wrong answer: it costs one round instead of a judge round plus a verifier round plus a rework round, and it is information the lessons pass can learn from. **Budget as an admission check**: `min_budget_for_dispatch` per role, so a role is never dispatched into a budget that cannot finish it, and a ring-fenced judging reserve so a capped epic still gets graded rather than spending its last tokens on more coding. Two things stay open. **Whether a free critic may block or only warn** — a false rejection that costs a whole round is worse than the judge call it saved, so the first critics should probably warn while their precision is measured against `agent-bench`. **What a forfeit does to the escalation ladder** — `budgets.yml` already declares one, and a forfeit is either its first rung or a separate path, but it must not become a cheap exit an agent prefers to the work. Researched 2026-09-18 across SWE-agent and the OpenHands SDK.
+
+## Self-audit 1 — event-log append cost, rename-blind claim diffs, one git entry point
+- id: bs-audit-1
+- status: planned
+- epics: [bs-audit-1]
+- project: black-smith
+- kind: factory
+- goal: Cut from audit 20260925-f336f5e4 of `blacksmith` (7 accepted findings: 3 S2-major, 3 S3-minor, 1 S4-nit). Each finding below is one acceptance criterion; the plan decides the tasks. **d7c644db (S2-major, performance)** `factory/orchestrator/src/events.ts` — appendEvent() re-reads and re-JSON.parses the entire session event log on every single append (readEventsAtPath inside appendEventLocked), while holding both an in-process queue and a cross-process poll lock, so writing to a session log is O(n) per event and O(n^2) for a session of n events.. **0f3f9c23 (S3-minor, performance)** `factory/orchestrator/src/worktree.ts` — listStale() spawns one synchronous `git merge-base --is-ancestor` subprocess per worktree entry in a loop instead of a single batched check, so merge-queue/worktree cleanup cost scales linearly with subprocess spawns rather than with one git invocation.. **ae8cb69e (S2-major, architecture)** `factory/orchestrator/src/queue.ts` — The queue module shells out to git directly with execFileSync instead of going through git.ts, the module the codebase documents as the one place this factory shells out to git, so queue git failures bypass credential redaction and the structured GitCommandError type.. **fd03e000 (S3-minor, architecture)** `factory/orchestrator/src/diffstat.ts` — diffstat.ts calls execFileSync('git', ...) directly for rev-parse/diff/branch instead of through git.ts, duplicating the single git-invocation boundary the codebase declares for itself and losing that module's credential redaction and GitCommandError typing.. **160cc3d7 (S3-minor, architecture)** `factory/orchestrator/src/commit.ts` — commit.ts, which certifies whether a task's work is safe to integrate, runs its own execFileSync('git', ...) calls rather than routing through git.ts, so the one module the codebase names as the sole git entry point has at least two siblings that re-implement direct git shell-outs.. **07c5d1b0 (S2-major, code-quality)** `factory/orchestrator/src/claims.ts` — collectCommittedChanges, the collector behind postRunCheck (the claim-confinement check for a task worktree), runs `git diff --name-only` without `--no-renames`, so a rename that crosses a claim boundary is reported only by its destination path.. **ad9ea9ba (S4-nit, code-quality)** `factory/orchestrator/src/waveNext.ts` — The one-line helper nameList (ids.join(', ')) is duplicated verbatim in waveNext.ts and waveSchedule.ts rather than shared, so the two wave-scheduling files carry two independent copies of the same id-list formatting rule..
+
+## Audit 2: bounded judges, parallel feedback, dashboard origin guard
+- id: bs-audit-2
+- status: planned
+- epics: [bs-audit-2]
+- project: black-smith
+- kind: factory
+- goal: Cut from audit 20260925-49bffa9b of `blacksmith` (5 accepted findings: 2 S2-major, 3 S3-minor). Each finding below is one acceptance criterion; the plan decides the tasks. **50acc356 (S3-minor, performance)** `factory/orchestrator/src/daemon.ts` — runTick() re-reads and re-JSON.parses every session's full .jsonl event log from disk on every daemon tick, with no incremental/fingerprint caching, so the daemon's per-tick cost grows linearly and unboundedly with the factory's total historical event volume.. **d50d4c1f (S3-minor, performance)** `ui/server/src/app.ts` — Every dashboard write route that omits an explicit causalParent (waivers apply-batch, lessons approve/reject/edit) triggers a full read-and-parse of that session's entire event log via resolveContext()/lessonContext() just to read the id of the last event.. **4c610e7c (S2-major, security)** `ui/server/src/app.ts` — The dashboard's write endpoints (waiver apply-batch, lesson approve/reject/edit) have no CSRF protection: there is no Origin/Referer check and Hono's `c.req.json()` parses the request body as JSON regardless of the Content-Type header, so a cross-origin `text/plain` form POST (a CORS-exempt 'simple request' that needs no preflight) is accepted and executed.. **1b8fe398 (S3-minor, architecture)** `.claude/skills/bs/wave.md` — The wave playbook's own loop (steps 2-10) never invokes the one instrument that measures whether a wave actually ran in parallel (auditWaveConcurrency/`smith wave check`, factory/orchestrator/src/waveConcurrency.ts), so the factory's central scaling claim goes unchecked for the entire time it could still be corrected.. **7ef3cd2f (S2-major, architecture)** `.claude/skills/bs/dispatch.md` — The one hard cap that bounds every subagent's work (`maxTurns`, enforced by the Claude Code harness itself) is transmitted into each dispatch prompt purely as prose the dispatching agent must copy correctly by hand from `.claude/agents/<role>.md` 'at dispatch time' — no module in factory/orchestrator/src validates that a dispatch's stated turn budget matches the template the harness will actually enforce, so the one enforcement path for this invariant is a human/LLM re-reading a file correctly every single time.. **Operator-added scope (2026-09-25, from GitHub research, ideas only)**: (6) a `SubagentStop` hook in the judge-class agent templates' frontmatter that blocks a judge from ending while its declared artifact file is absent — complements `agent-resume`, which handles the cap itself; (7) planning emits parallel width mechanically — at plan ingest, tasks with disjoint claims and no dependency edge are marked parallel and the plan's achievable width is reported, and a small epic takes a right-sized planning path with a bounded review focus. The per-task pipeline (no wave barrier) is deliberately out of scope until a pros/cons analysis is decided.
+
+## Self-audit 3: UI read boundary and fail-closed daemon state
+- id: bs-audit-3
+- status: planned
+- epics: [bs-audit-3]
+- project: black-smith
+- kind: factory
+- goal: Cut from audit 20260927-b61eaa7e of `black-smith` (2 accepted findings: 2 S3-minor). Each finding below is one acceptance criterion; the plan decides the tasks. **871ee8f7 (S3-minor, architecture)** `ui/server/src/app.ts` — lessonSession() builds its own drizzle query directly against the `lessons` schema table instead of going through db/queries.ts, the module the file's own header comment declares as the single 1:1 wrapper boundary between the UI and the projection.. **442cd7f2 (S3-minor, code-quality)** `factory/orchestrator/src/daemon.ts` — daemon.ts defines its own readJsonFile() that silently swallows any parse/read error and returns null, diverging from the fail-closed readJsonFile() in cli.ts that throws on malformed JSON, so a corrupted daemon lock/status/memory file is treated as absent rather than reported..

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juzser/blacksmith",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Autonomous agent factory — loop runner and worktree engine.",
   "keywords": [