@juzser/blacksmith 0.3.0 → 0.5.0

package/factory/orchestrator/dist/waivers.js

@@ -1,8 +1,11 @@
+import { isOperatorActor } from './actors.js';
 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 {
 }
+/** The event `approveTaskWaiver` writes and epic.ts's withGateEvidence reads. */
+export const TASK_WAIVER_APPROVED_EVENT = 'task-waiver-approved';
 /**
  * Only S3/S4 findings are ever waived (severity.yml waiver_semantics) —
  * single source of truth, reused by findings.ts's transition() so `→ waived`
@@ -10,6 +13,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 +55,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 +79,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 +101,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 };
@@ -81,6 +132,33 @@ export async function grantWaiver(fingerprint, operatorNote, ctx, opts = {}) {
     await reconcileFindingsToWaived(fingerprint, waiverEvent.event_id, ctx, opts);
     return waiverEvent;
 }
+/**
+ * Record the operator's approval of one task's waiver. A task reaches
+ * `waived` through its plan row, which carries no gate run; this event is the
+ * evidence the epic gate (epic.ts's withGateEvidence) looks for instead.
+ *
+ * Refused unless the actor is the operator (actors.ts) and a rationale is
+ * given: the approval is only worth anything as a person's recorded decision.
+ * The default actor is the one every other operator decision defaults to.
+ */
+export async function approveTaskWaiver(taskId, operatorNote, ctx, opts = {}) {
+    const actor = ctx.actor ?? 'user';
+    if (!isOperatorActor(actor)) {
+        throw new WaiverError('waivers.not-operator', `Actor "${actor}" cannot approve a task waiver — only the operator can. Pass --actor operator.`, { actor, taskId });
+    }
+    if (operatorNote.trim() === '') {
+        throw new WaiverError('waivers.note-required', `Approving the waiver of task "${taskId}" needs a short rationale (--note).`, { taskId });
+    }
+    return appendEvent({
+        session_id: ctx.sessionId,
+        actor,
+        event_type: TASK_WAIVER_APPROVED_EVENT,
+        task_id: taskId,
+        plan_version: ctx.planVersion,
+        causal_parent: ctx.causalParent,
+        payload: { operator_note: operatorNote },
+    }, opts);
+}
 /**
  * The mirror of reconcileFindingsToWaived, and it exists for the same reason
  * (D-180). A denial that follows a grant revokes it — isWaived() folds
@@ -92,11 +170,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);
@@ -203,7 +286,7 @@ export async function applyBatch(decisions, ctx, opts = {}) {
                     `"${evidence.mergedTaskId}" has merged over since the finding was raised (matched by ` +
                     `${evidence.basis}: ${evidence.matched}). Its evidence describes code that no longer ` +
                     'exists, so this waiver would answer a question about a deleted file. Re-read it first: ' +
-                    `smith findings reverify --finding ${finding.finding_id}`, {
+                    `bs findings reverify --finding ${finding.finding_id}`, {
                     fingerprint: decision.fingerprint,
                     findingId: finding.finding_id,
                     filePath: evidence.filePath,
@@ -213,14 +296,18 @@ export async function applyBatch(decisions, ctx, opts = {}) {
             }
         }
     }
-    const results = [];
+    const events = [];
+    const findingIdsToCarry = new Set();
     for (const decision of decisions) {
         if (decision.decision === 'granted') {
-            results.push(await grantWaiver(decision.fingerprint, decision.operatorNote, ctx, opts));
+            events.push(await grantWaiver(decision.fingerprint, decision.operatorNote, ctx, opts));
         }
         else {
-            results.push(await denyWaiver(decision.fingerprint, decision.operatorNote, ctx, opts));
+            events.push(await denyWaiver(decision.fingerprint, decision.operatorNote, ctx, opts));
+            for (const finding of findingsByFingerprint.get(decision.fingerprint) ?? []) {
+                findingIdsToCarry.add(finding.finding_id);
+            }
         }
     }
-    return results;
+    return { events, findingIdsToCarry: [...findingIdsToCarry] };
 }

package/factory/orchestrator/dist/waveBudget.js

@@ -153,6 +153,7 @@ export function checkWaveBudget(events, policy, proposed, options) {
     if (options.epicId.trim().length === 0) {
         return {
             epicId: null,
+            tier: policy.tier,
             capTokens,
             measuredTokens: 0,
             projectedTokens: 0,
@@ -189,6 +190,7 @@ export function checkWaveBudget(events, policy, proposed, options) {
     const inFlight = inFlightTasks(events, epicId).length;
     const base = {
         epicId,
+        tier: policy.tier,
         capTokens,
         measuredTokens,
         projectedTokens,

package/factory/orchestrator/dist/waveConcurrency.js

@@ -1,4 +1,6 @@
-import { foldAgents } from './agents-registry.js';
+import { DISPATCH_EVENT_TYPE, foldAgents } from './agents-registry.js';
+import { eventTaskId } from './events.js';
+import { epicOfTaskId, isQualifiedTaskId, taskIdsMatch } from './taskId.js';
 /**
  * Did the wave that was admitted N wide actually run N wide?
  *
@@ -24,6 +26,7 @@ import { foldAgents } from './agents-registry.js';
  * intervals open forever and score every wave after one as parallel.
  */
 const ADMITTED_EVENT_TYPE = 'wave-admitted';
+const MERGED_EVENT_TYPE = 'wave-merged';
 /**
  * What the log says a wave did.
  *
@@ -33,12 +36,29 @@ const ADMITTED_EVENT_TYPE = 'wave-admitted';
  * - `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.
+ * - `unlinked`   — this fold's intervals hold nothing, but the lineage still
+ *                  has proof the work happened: a `wave-merged` for one of
+ *                  the admitted tasks, or a `dispatch_decision` parented
+ *                  directly on the admission. A wave-runner session started
+ *                  without `--continues` has `causal_parent: null` on its
+ *                  root, so its own dispatch_decisions never reach this fold
+ *                  even though its agents genuinely ran. Width is unmeasured
+ *                  here, not zero — a different fact from `unobserved`, which
+ *                  is exactly why it is not folded into it.
  * - `unobserved` — the wave was admitted and the log records no work for any
- *                  of its tasks. Not the same fact as `serialized`, and the
+ *                  of its tasks, and nothing else on the lineage says
+ *                  otherwise. 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'];
+export const WAVE_VERDICTS = [
+    'parallel',
+    'partial',
+    'serialized',
+    'single',
+    'unlinked',
+    'unobserved',
+];
 /**
  * A counter with one bucket per key, all at zero.
  *
@@ -61,6 +81,17 @@ export function zeroedCounts(keys) {
 export const UNOBSERVED_HINT = 'A wave admitted with no dispatch_decision under any of its tasks ran nowhere this log can ' +
     'see. Either the dispatcher never started it, or the agents ran outside the lineage that was ' +
     'read — narrow with --epic, or check that the run wrote its dispatches to this state dir.';
+/**
+ * Said when a wave came back `unlinked`: this fold has no dispatch interval
+ * for it, but the lineage holds a `wave-merged` for one of its tasks or a
+ * dispatch_decision parented on the admission itself, so the work is real —
+ * only its width is unmeasured. The usual cause is a wave-runner session
+ * started without `--continues`, which leaves its own dispatches outside the
+ * lineage this read walks even though they ran.
+ */
+export const UNLINKED_HINT = 'A wave admitted with merged work or a dispatch on record, but not inside this lineage, so ' +
+    'its width cannot be measured. Likely a wave-runner session started without --continues — ' +
+    'its dispatches are real but outside the chain this read walked.';
 function readAdmission(event) {
     const payload = event.record.payload;
     const raw = payload.task_ids;
@@ -119,17 +150,109 @@ function peakOverlap(runs) {
     }
     return peak;
 }
-function verdictFor(declared, observed, peak) {
+function verdictFor(declared, observed, peak, offLineageEvidence) {
     if (declared <= 1)
         return 'single';
-    if (observed === 0)
+    if (observed === 0) {
+        if (offLineageEvidence)
+            return 'unlinked';
         return 'unobserved';
+    }
     if (peak >= declared)
         return 'parallel';
     if (peak <= 1)
         return 'serialized';
     return 'partial';
 }
+/**
+ * Whether `admission` is the one a `wave-merged` id names.
+ *
+ * A qualified id ("A/task-1") must match the admission's epic exactly — no
+ * falling back to the bare half, because that fallback is exactly how a bare
+ * merge under one epic used to mark an unrelated epic's qualified admission
+ * as having merge evidence. A bare id ("task-1") carries no epic of its own,
+ * so it may match any admission's declared task by its bare half; which
+ * admission it actually belongs to is for {@link latestMatchingAdmission} to
+ * decide, not this predicate.
+ */
+function admissionClaims(admission, mergedId) {
+    if (isQualifiedTaskId(mergedId) && epicOfTaskId(mergedId) !== admission.epicId)
+        return false;
+    return admission.taskIds.some((taskId) => taskIdsMatch(taskId, mergedId));
+}
+/**
+ * The one admission a `wave-merged` id belongs to: the latest whose `ts` is
+ * at or before the merge's `ts` and whose declared tasks match it — the same
+ * "nearest preceding admission" rule `admittedAtByTask` uses to close a
+ * task's window, reused here rather than re-derived, so a task re-admitted in
+ * a later wave sends its merge to that wave and not the one before it. A
+ * merge timestamped before every candidate admission belongs to none of them;
+ * returning null rather than the earliest is what keeps that merge from
+ * counting at all.
+ */
+function latestMatchingAdmission(mergedId, mergeTs, admissions) {
+    let best = null;
+    for (const admission of admissions) {
+        if (admission.ts > mergeTs)
+            continue;
+        if (!admissionClaims(admission, mergedId))
+            continue;
+        if (best === null || admission.ts > best.ts)
+            best = admission;
+    }
+    return best;
+}
+/**
+ * The `wave-admitted` event ids that own at least one `wave-merged` id,
+ * attributed one merge at a time over the whole log so each admission can ask
+ * "is my work here" without rescanning — and so an admission the epic filter
+ * excludes must not narrow what another admission can see.
+ *
+ * Both the envelope's `task_id` and the payload's `task_ids` are read,
+ * because `emitWaveMerged` writes the same id to both; either is enough.
+ */
+function admissionsWithMergeEvidence(events, admissions) {
+    const credited = new Set();
+    for (const event of events) {
+        if (event.record.event_type !== MERGED_EVENT_TYPE)
+            continue;
+        const ids = [];
+        const fromEnvelope = eventTaskId(event.record);
+        if (fromEnvelope)
+            ids.push(fromEnvelope);
+        const payload = event.record.payload;
+        if (Array.isArray(payload?.task_ids)) {
+            for (const id of payload.task_ids) {
+                if (typeof id === 'string' && id.length > 0)
+                    ids.push(id);
+            }
+        }
+        for (const id of ids) {
+            const owner = latestMatchingAdmission(id, event.record.ts, admissions);
+            if (owner)
+                credited.add(owner.eventId);
+        }
+    }
+    return credited;
+}
+/**
+ * The `wave-admitted` event ids that a `dispatch_decision` names as its
+ * direct causal parent — the shape a wave-runner's own agent takes when it is
+ * dispatched straight off the admission rather than through a task. Read from
+ * raw events rather than `foldAgents`, because that fold only keeps agents
+ * with a task id, and this dispatch has none.
+ */
+function dispatchedDirectlyOn(events) {
+    const parents = new Set();
+    for (const event of events) {
+        if (event.record.event_type !== DISPATCH_EVENT_TYPE)
+            continue;
+        const parent = event.record.causal_parent;
+        if (typeof parent === 'string' && parent.length > 0)
+            parents.add(parent);
+    }
+    return parents;
+}
 /**
  * Fold one task's agents into the interval it was worked on. Every role counts,
  * not just the coder's: a task whose reviewer is still running is still work
@@ -199,6 +322,14 @@ export function auditWaveConcurrency(events, options = {}) {
         else
             agentsByTask.set(agent.taskId, [agent]);
     }
+    // Also built from every event, unfiltered: off-lineage evidence for a wave
+    // the caller narrowed away must not leak in, but an admission's own window
+    // must see all of it regardless of which epic the caller asked for. Merge
+    // attribution needs every admission as a candidate, not just the ones the
+    // caller's epic filter kept — the same reason `admissions` above is built
+    // before that filter is applied.
+    const mergeCredited = admissionsWithMergeEvidence(events, admissions);
+    const directDispatchParents = dispatchedDirectlyOn(events);
     const waves = [];
     for (const admission of admissions) {
         if (options.epicId !== undefined && admission.epicId !== options.epicId)
@@ -219,6 +350,7 @@ export function auditWaveConcurrency(events, options = {}) {
         }
         observed.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
         const peak = peakOverlap(observed);
+        const offLineageEvidence = directDispatchParents.has(admission.eventId) || mergeCredited.has(admission.eventId);
         waves.push({
             eventId: admission.eventId,
             admittedAt: admission.ts,
@@ -227,7 +359,7 @@ export function auditWaveConcurrency(events, options = {}) {
             observed,
             unobserved,
             peak,
-            verdict: verdictFor(admission.taskIds.length, observed.length, peak),
+            verdict: verdictFor(admission.taskIds.length, observed.length, peak, offLineageEvidence),
         });
     }
     return waves;
@@ -264,16 +396,20 @@ function labelsWith(waves, verdict) {
 export function summariseWaveConcurrency(waves) {
     const serialized = labelsWith(waves, 'serialized');
     const unobserved = labelsWith(waves, 'unobserved');
+    const unlinked = labelsWith(waves, 'unlinked');
     return {
         waves: [...waves],
         serialized,
         partial: labelsWith(waves, 'partial'),
         unobserved,
+        unlinked,
         widest: {
             declared: waves.reduce((max, wave) => Math.max(max, wave.declared.length), 0),
             observed: waves.reduce((max, wave) => Math.max(max, wave.peak), 0),
         },
-        hint: unobserved.length > 0 ? UNOBSERVED_HINT : '',
+        hint: unobserved.length > 0 ? UNOBSERVED_HINT : unlinked.length > 0 ? UNLINKED_HINT : '',
+        // `unlinked` is real work off-lineage, not a failure to judge, so it never
+        // worsens the exit code the way `unobserved` does.
         exitCode: serialized.length > 0 ? 1 : unobserved.length > 0 ? 2 : 0,
     };
 }

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

@@ -37,7 +37,7 @@ const WORK_DIRS = [
  * the roadmap and the stack answers are declarations the operator made, and a
  * team sharing the repository should share them.
  */
-const WORK_ROOT_GITIGNORE = `# Written by \`smith init\`. Blacksmith's state is a cache of its event log
+const WORK_ROOT_GITIGNORE = `# Written by \`bs init\`. Blacksmith's state is a cache of its event log
 # and belongs to this machine; the answers under factory/ are declarations
 # this project made, so they are tracked.
 state/