@juzser/blacksmith 0.2.0 → 0.4.0

package/factory/orchestrator/dist/severity.js

@@ -182,21 +182,53 @@ export function parseLessons(markdown) {
     return rules;
 }
 /**
- * Scopes whose claim_path is meaningful for the per-file same-mistake match
- * (lessons.md convention). `security` is here because a security lesson is
- * written against the paths it guards ("src/auth/**") — a repeat security
- * finding on one of those paths is exactly what escalation is for. Left out, a
- * security lesson would compile and be read by agents but never escalate
- * anything (interview N-8).
+ * Whether each lesson scope's claim_path is meaningful for the per-file
+ * same-mistake match (lessons.md convention). `security` is true because a
+ * security lesson is written against the paths it guards ("src/auth/**") — a
+ * repeat security finding on one of those paths is exactly what escalation is
+ * for. Left out, a security lesson would compile and be read by agents but
+ * never escalate anything (interview N-8).
+ *
+ * The ruling stays hand-written: which scopes have a file to match against is
+ * a design decision, not something to derive. Only its COMPLETENESS stops
+ * being hand-kept. Keyed on LESSON_SCOPES, a sixth scope added to taxonomy.yml
+ * is a type error here until someone rules on it, instead of defaulting to
+ * `false` — which is silence, and silence is what interview N-8 was about.
+ *
+ * It is also the only copy. `lessons.ts` kept a second set of the same three
+ * strings under a comment saying it was "kept in sync"; nothing kept it. That
+ * is the N-8 failure the LESSON_SCOPES const above already fixed for the
+ * vocabulary, repeated one level down on its partition.
+ */
+const SCOPE_MATCHES_A_FILE = Object.freeze({
+    'agent-role': false,
+    'claim-path': true,
+    'case-type': false,
+    'stack-wide': true,
+    security: true,
+});
+/**
+ * The scopes it says yes to, in the order LESSON_SCOPES declares them.
+ * Exported because `lessons.ts` names them in a warning it shows the operator,
+ * and a sentence that lists them by hand is the same drift written in prose.
  */
-const FILE_SCOPED = new Set(['claim-path', 'stack-wide', 'security']);
+export const FILE_SCOPED_SCOPES = Object.freeze(LESSON_SCOPES.filter((scope) => SCOPE_MATCHES_A_FILE[scope]));
+const FILE_SCOPED = new Set(FILE_SCOPED_SCOPES);
+/**
+ * Whether a scope makes a `claim_path` mean anything, asked by name — the same
+ * question as `isFileScoped`, for callers judging an entry that does not exist
+ * yet and so have no `LessonRule` to hand.
+ */
+export function isFileScopedScope(scope) {
+    return FILE_SCOPED.has(scope);
+}
 /**
  * Whether this lesson's scope makes its `claim_path` mean anything. An
  * `agent-role`/`case-type` entry has no file to check a finding against, so it
  * never participates in the per-file match however it is written.
  */
 export function isFileScoped(lesson) {
-    return FILE_SCOPED.has(lesson.scope);
+    return isFileScopedScope(lesson.scope);
 }
 /**
  * Whether this lesson's compiled `claim_path` covers `filePath` — the second

package/factory/orchestrator/dist/spec.js

@@ -68,6 +68,65 @@ export function latestSpecReview(events, epicId) {
     }
     return latest;
 }
+/**
+ * Old task id -> the replacement that superseded it, folded across every
+ * `plan-version-created` event this epic has (D-<successor-chain>). Not a
+ * last-wins fold like `latestSpecReview`: a task superseded in v2 and its own
+ * successor superseded again in v4 contributes two independent entries to
+ * the same map, and epic.ts's `resolveSupersededRow` walks the chain — each
+ * amendment only ever needs to know its own one hop.
+ *
+ * Only the rename-supersede case is ever present here: `amendPlan` records a
+ * pairing only when the replacement's `task_id` differs from the id it
+ * replaces (the same-id case needs no successor — the fold's own row already
+ * carries the work forward under the id everyone already has).
+ *
+ * Events on the log from before this field shipped carry no `successors` key
+ * at all — only the plan `diff` `amendPlan` has always written. For exactly
+ * that shape (no `successors` key, present or absent notwithstanding), fall
+ * back to inferring the pairing from `diff.superseded`/`diff.added`, but only
+ * when it is completely unambiguous: one id on each side, and they differ.
+ * Any other shape (0 or ≥2 ids on either side, a missing/malformed diff)
+ * infers nothing — the same fail-closed answer an unreadable `successors`
+ * gets. A present `successors` — even an explicit `{}` — always wins over
+ * inference; the fallback only ever runs when the key is absent entirely.
+ */
+export function taskSuccessors(events, epicId) {
+    const successors = new Map();
+    for (const event of events) {
+        if (event.record.event_type !== PLAN_AMENDED_EVENT)
+            continue;
+        const payload = event.record.payload;
+        if (payload.epic_id !== epicId)
+            continue;
+        const entries = payload.successors;
+        if (entries !== undefined) {
+            if (entries === null || typeof entries !== 'object')
+                continue;
+            for (const [oldId, newId] of Object.entries(entries)) {
+                if (typeof newId === 'string')
+                    successors.set(oldId, newId);
+            }
+            continue;
+        }
+        // Legacy fallback (no `successors` key at all) — see doc comment above.
+        const diff = payload.diff;
+        if (diff === null || typeof diff !== 'object')
+            continue;
+        const supersededIds = diff.superseded;
+        const addedIds = diff.added;
+        if (!Array.isArray(supersededIds) || !Array.isArray(addedIds))
+            continue;
+        if (supersededIds.length !== 1 || addedIds.length !== 1)
+            continue;
+        const [oldId] = supersededIds;
+        const [newId] = addedIds;
+        if (typeof oldId === 'string' && typeof newId === 'string' && oldId !== newId) {
+            successors.set(oldId, newId);
+        }
+    }
+    return successors;
+}
 /**
  * The epic gate refusing to certify a spec nobody re-read once the code
  * existed. Mirrors integrationBlockers exactly, including the fail-closed
@@ -345,6 +404,16 @@ export async function amendPlan(input, ctx, opts = {}) {
     // pure, so the two agree by construction, and there stays exactly one
     // function in this codebase that puts a plan version on disk.
     const amended = nextVersion(plan, input.changes ?? {}, opts);
+    // Old id -> replacement id, for the rename-supersede case only: a same-id
+    // supersede needs no pairing (the row already carries the work forward
+    // under the id everyone has). epic.ts's resolveSupersededRow/summarizeEpic
+    // is the reader — this is the one place an old task_id and its replacement
+    // are ever paired (PlanChanges.supersede), so it is recorded here or lost.
+    const successors = {};
+    for (const [oldId, replacement] of Object.entries(input.changes?.supersede ?? {})) {
+        if (replacement.task_id !== oldId)
+            successors[oldId] = replacement.task_id;
+    }
     await appendEvent({
         session_id: ctx.sessionId,
         actor: ctx.actor ?? 'system',
@@ -364,6 +433,7 @@ export async function amendPlan(input, ctx, opts = {}) {
             sites: namedSites,
             sites_unclaimed: unclaimedSites,
             diff,
+            successors,
         },
     }, opts);
     for (const finding of cited) {

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/taskStatus.js

@@ -0,0 +1,74 @@
+// The closed readings of the `task_status` dimension, in one place.
+//
+// taxonomy.yml declares the vocabulary; these are the two questions the
+// orchestrator asks *about* it that name a finite side. A roster belongs to
+// the dimension, not to whichever consumer first needed one: these two lived
+// in db/projector.ts and in waveNext.ts, epic.ts and db/queries.ts under four
+// names, and two of those names were the same name for different sets.
+//
+// The module is deliberately a leaf — it imports nothing, and nothing added
+// here may reach the database layer. waveNext.ts is in `dist/cli.js`'s static
+// graph, so anything it imports is loaded by every `smith` invocation;
+// cliBoot.test.ts pins that the db layer stays out of that graph, and it went
+// red the moment these constants were read from db/projector.ts.
+/**
+ * The five `task_status` values that mean the work is over — the ones
+ * db/projector.ts refuses to overwrite once a row reaches them. Read here
+ * by a reader asking "is this task still open?" (db/queries.ts's
+ * `inFlightEpics`) rather than keeping the complement by hand: taxonomy.yml
+ * can declare a thirteenth status tomorrow, and the answer `!has()` gives for
+ * one nobody has classified — still open — is the answer that loses nothing.
+ *
+ * Over is not the same as *well*: this set holds `failed` and `escalated`
+ * too. A reader that needs the other question asks TERMINAL_OK_TASK_STATUSES
+ * below, and the two are not interchangeable — waveNext.ts kept its own copy
+ * of that one under *this* name until both moved here, and reading this set
+ * there frees the claims on a worktree that still holds uncommitted work.
+ */
+export const TERMINAL_TASK_STATUSES = new Set([
+    'completed',
+    'superseded',
+    'failed',
+    'escalated',
+    'waived',
+]);
+/**
+ * The two terminal statuses that mean the work ended *well*: the task shipped,
+ * or the operator decided it would not and waived it (D-120). Three modules
+ * ask this question and each kept its own answer — waveNext.ts called it
+ * TERMINAL_TASK_STATUSES, which is the name above for a different set;
+ * epic.ts called it TERMINAL_OK_TASK_STATUSES; db/queries.ts called it
+ * MILESTONE_COMPLETE_TASK_STATUSES. The three agreed because someone typed
+ * the same two strings three times, not because anything held them together.
+ *
+ * Declared rather than subtracted from the set above, because "ended well" is
+ * a judgement about what a status MEANS, and which way the default falls
+ * decides what forgetting one costs. Subtracting a declared failure side
+ * would read a thirteenth terminal status as *well* until someone classified
+ * it: waveNext.ts would free the claims on a worktree nobody has finished
+ * with, the roadmap bar would count the task done, and closeEpic would close
+ * over it. Declared, an unclassified status is simply not done — every
+ * reader fails closed, and the drift is visible instead of silent.
+ */
+export const TERMINAL_OK_TASK_STATUSES = new Set(['completed', 'waived']);
+/**
+ * The two terminal statuses a person is still holding. `failed` and
+ * `escalated` are over in the projector's sense — it will not overwrite them —
+ * but somebody is expected to come back to them, so a reader asking "can work
+ * still land on this task?" answers yes for these two and no for every other
+ * terminal status.
+ *
+ * Declared as the exception rather than as a roster of the remainder, because
+ * the remainder is derivable and the exception is the judgement. claims.ts
+ * asked exactly this question and typed the answer out — `completed`,
+ * `waived`, `superseded` — with its docblock explaining in prose that "`failed`
+ * and `escalated` are deliberately NOT here". That is the subtraction, written
+ * where only a reader could find it; this is the same sentence written where
+ * the code reads it.
+ *
+ * Which way the default falls: a thirteenth terminal status nobody classified
+ * falls OUT of this exception, so it reads as closed to further work, and a
+ * finding about its files mints a follow-up task somebody can see rather than
+ * parking silently on a task nobody is working.
+ */
+export const HELD_OPEN_BY_AN_OPERATOR = new Set(['failed', 'escalated']);

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

@@ -58,6 +58,33 @@ function signalNote(code, signal) {
     }
     return null;
 }
+/**
+ * The environment a project's command runs in: this process's, minus the
+ * factory's own namespace.
+ *
+ * A command the factory launches on a project's behalf belongs to the
+ * project, not to the factory that launched it. Every `SMITH_*` variable in
+ * this process was set for *this* process, and letting one through silently
+ * makes the factory's own invocation part of the project's verdict.
+ * `SMITH_HOME` is the one that bites: it moves `WORK_ROOT` off the worktree,
+ * so a suite that asserts its own layout fails on the launcher's environment
+ * alone, and anything the suite writes to state lands in the factory's live
+ * `state/` instead of the worktree's. The verdict then depends on how the
+ * factory happened to be invoked, which is not a verdict about the branch.
+ *
+ * The strip is a rule rather than a roster, deliberately: a roster is a list
+ * that goes stale the next time a `SMITH_*` variable is added, and it goes
+ * stale silently. Not every one of them is the factory configuring itself —
+ * `SMITH_CROSSCHECK_OFFLINE` is an operator switch — but the runbook already
+ * says of that one "pass it per command"
+ * (`docs/runbooks/providers.md`, and it names an ambient copy of that switch
+ * as its own hazard). The command the operator means is the one running
+ * here, not the factory that spawned it, and stating it inside the command
+ * string works: the shell applies it after this strip.
+ */
+export function projectCommandEnv(env) {
+    return Object.fromEntries(Object.entries(env).filter(([name]) => !name.startsWith('SMITH_')));
+}
 /**
  * Run one check command in its own process group (POSIX `setsid`, via
  * `detached: true`) so a timeout can kill the WHOLE group — `process.kill`
@@ -67,13 +94,15 @@ function signalNote(code, signal) {
  * 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,
             detached: true,
             stdio: ['ignore', 'pipe', 'pipe'],
+            env: projectCommandEnv(process.env),
         });
         let output = '';
         let dropped = false;
@@ -148,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

@@ -30,6 +30,8 @@ const EVENTS_DIR = `${EVENTS} [--state-dir <dir>]`;
  * asked about.
  */
 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>] [--specs-dir <dir>]';
 export const COMMANDS = [
     {
         command: 'audit open',
@@ -64,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',
@@ -196,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.',
@@ -230,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',
@@ -273,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',
@@ -357,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>',
@@ -387,6 +397,23 @@ export const COMMANDS = [
         flags: '--task <task.json> [--policy <file>] [--case <case>] [--epic-tag <tag>...] [--recheck]',
         summary: 'Compute whether the security reviewer must be dispatched. A fired trigger is not a red.',
     },
+    // `issues`: the run's write path to a project's tracker. Preview is its
+    // own action, never a flag, so a typo cannot promote it into a write. Exit
+    // status for both: 0 when every candidate resolved to a recorded outcome
+    // (a skip is a recorded answer); non-zero only when the run could not be
+    // performed at all, e.g. the session log is unreadable.
+    {
+        command: 'issues report',
+        positionals: '',
+        flags: ISSUES,
+        summary: 'Report each candidate error to its project tracker through gh and record an issue-reported event per candidate. The only command that runs gh.',
+    },
+    {
+        command: 'issues preview',
+        positionals: '',
+        flags: ISSUES,
+        summary: 'Dry run of issues report: prints the argv that would run, spawns no gh and appends no event. The action an unattended agent uses.',
+    },
     {
         command: 'harness list',
         positionals: '',
@@ -399,6 +426,12 @@ export const COMMANDS = [
         flags: '--role <role> --task <id> --prompt-file <path> [--harness <name>] [--worktree <dir>] [--policy <file>] [--tier <frontier|mid|small>] [--schema <name>]',
         summary: 'Render the invocation that would run one worker turn, as JSON. Prints it; never starts it.',
     },
+    {
+        command: 'agents sync',
+        positionals: '',
+        flags: '[--dry-run] [--reset] [--agents-dir <dir>]',
+        summary: 'Set each agent template’s frontmatter maxTurns from SMITH_MAXTURNS_<ROLE> (role upper-cased, - as _); --reset restores git HEAD’s value; --dry-run prints role/from/to only. A local, uncommitted edit by design.',
+    },
     {
         command: 'sandbox open',
         positionals: '<worktree-dir>',

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 } from './findings.js';
+import { computeFingerprint, foldFindings, listFindings, preWaiverStatus, staleFindings, transition, WAIVABLE_STATUSES, } from './findings.js';
 export class WaiverError extends SmithError {
 }
 /**
@@ -10,8 +10,38 @@ export class WaiverError extends SmithError {
  * call or via a waiver grant).
  */
 export const WAIVABLE_SEVERITIES = ['S3-minor', 'S4-nit'];
-/** finding_status values transition() allows a "waived" edge from (findings.ts LEGAL_TRANSITIONS). */
-const WAIVABLE_STATUSES = ['raised', 'confirmed'];
+/**
+ * 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
@@ -22,13 +52,19 @@ const WAIVABLE_STATUSES = ['raised', 'confirmed'];
  * 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;
@@ -40,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'));
     });
 }
@@ -58,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 };
@@ -94,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/waveConcurrency.js

@@ -24,6 +24,35 @@ import { foldAgents } from './agents-registry.js';
  * intervals open forever and score every wave after one as parallel.
  */
 const ADMITTED_EVENT_TYPE = 'wave-admitted';
+/**
+ * What the log says a wave did.
+ *
+ * - `parallel`   — every admitted task was in flight at one instant.
+ * - `partial`    — two or more were, but never all of them.
+ * - `serialized` — work is recorded, and no two tasks ever overlapped.
+ * - `single`     — the wave admitted one task. Nothing to be parallel about,
+ *                  and scoring it against a width it never claimed would make
+ *                  the failing verdicts unreadable.
+ * - `unobserved` — the wave was admitted and the log records no work for any
+ *                  of its tasks. Not the same fact as `serialized`, and the
+ *                  whole point of separating them: one says the factory ran
+ *                  narrow, the other says nobody can tell.
+ */
+export const WAVE_VERDICTS = ['parallel', 'partial', 'serialized', 'single', 'unobserved'];
+/**
+ * A counter with one bucket per key, all at zero.
+ *
+ * The one place the `Record` cast lives, and here it is true by construction
+ * rather than asserted: the keys ARE the roster. Every caller that used to
+ * write `Object.fromEntries(SOME_LIST.map(...)) as Record<…>` was asserting a
+ * totality that only its own hand-written list was holding up.
+ */
+export function zeroedCounts(keys) {
+    const counts = {};
+    for (const key of keys)
+        counts[key] = 0;
+    return counts;
+}
 /**
  * Said when a wave was admitted and no agent was ever dispatched for it. The
  * two readings are genuinely different problems and the operator has to pick