@juzser/blacksmith 0.1.1 → 0.2.0

package/factory/orchestrator/dist/cli.js

@@ -22,7 +22,7 @@ import { parseArgs } from './args.js';
 import { closeAudit, consolidateAudit, cutAudit, decideAudit, openAudit, recordAudit, resolveAudit, } from './audit.js';
 import { checkBudgetAlarm } from './budgetAlarm.js';
 import { loadBudgetPolicy } from './budgets.js';
-import { collectCommittedChanges, loadWorktreePolicy, postRunCheck, validateWave, writeRootCheck, } from './claims.js';
+import { collectCommittedChanges, loadWorktreePolicy, postRunCheck, readClaimList, validateWave, writeRootCheck, } from './claims.js';
 import { collectCoverageEvidence } from './coverage.js';
 import { loadCrosscheckPolicy } from './crosscheck.js';
 import { independentFinderRequest, reconcile, runIndependentFinder, } from './crossFinding.js';
@@ -32,11 +32,11 @@ import { loadDotEnv } from './dotenv.js';
 import { loadEffortPolicy, resolveEffort } from './effort.js';
 import { SmithError } from './errors.js';
 import { checkEscalationLadder } from './escalation.js';
-import { appendEvent, filterEvents, listSessionIds, mergeSessionLogs, readEvents, readLineageEvents, requireSession, sessionTree, startSession, tailEvents, } from './events.js';
+import { appendEvent, filterEvents, followEvents, listSessionIds, mergeSessionLogs, readEvents, readLineageEvents, requireSession, sessionTree, startSession, tailEvents, } from './events.js';
 import { findingsForDispatch } from './findingContext.js';
 import { AMEND_PENDING_STATUS, AMENDED_STATUS, findingScope, listFindings, mintFindings, OPEN_FINDING_STATUSES, raiseFinding, repairObligation, reverifyFinding, SPEC_FINDING_SCOPE, transition as transitionFinding, } from './findings.js';
 import { recordGoalCheck, resolveEpicGoal } from './goalCheck.js';
-import { loadHarnessPolicy, planWorkerTurn, summarizeHarnesses } from './harness.js';
+import { loadHarnessPolicy, planWorkerTurn, summarizeHarnesses, } from './harness.js';
 import { decideHookPayload } from './hookDecision.js';
 import { checkWorktreeImmutable, fingerprintWorktree, } from './immutability.js';
 import { collectExportDiffs, exportImpact, waveImpact } from './impact.js';
@@ -1126,13 +1126,17 @@ async function main() {
         // as "disjoint from everyone" — the answer that admits the wave. The shape
         // is that function's to judge, once, where the comparison happens.
         const claimsById = new Map(logged.map((t) => [t.taskId, t.claims]));
+        // A keeps_exports promise lives on the plan record alone: the log carries
+        // claims, and a promise the plan never made is not one this verb honours.
+        const promisesById = new Map();
         for (const t of plan.tasks) {
             claimsById.set(t.task_id, t.claims);
+            if (t.keeps_exports !== undefined)
+                promisesById.set(t.task_id, t.keeps_exports);
         }
-        const tasks = taskIds.map((id) => ({
-            task_id: id,
-            claims: claimsById.get(id),
-        }));
+        const tasks = taskIds.map((id) => promisesById.has(id)
+            ? { task_id: id, claims: claimsById.get(id), keeps_exports: promisesById.get(id) }
+            : { task_id: id, claims: claimsById.get(id) });
         const policy = loadWorktreePolicy();
         // D-212: the plan has been in hand since the top of this verb, and it is
         // the register that says which of these tasks may not run beside which.
@@ -1459,11 +1463,22 @@ async function main() {
         };
         process.once('SIGTERM', requestStop);
         process.once('SIGINT', requestStop);
-        const reports = await runDaemon({
+        // The loop prints as it goes and `--once` prints as it ends, and the two
+        // are different shapes on purpose. A loop that only answered when it
+        // ended answered nothing -- the foreground form was silent for as long as
+        // it ran, and the detached one wrote a `daemon.log` with nothing in it.
+        // One record per tick is what a log is; one record per run is what cron
+        // wants to parse, and `--once` keeps the shape it has always had.
+        const once = flags.once === 'true';
+        // `smith daemon run | head -1` closes the pipe under the second tick.
+        // That is the reader saying "enough", not a failure worth an error line
+        // -- and not one worth an uncaught exception that skips the lock release.
+        process.stdout.on('error', requestStop);
+        const run = await runDaemon({
             dir,
             intervalSeconds: interval,
             ...tickOpts,
-            ...(flags.once === 'true' ? { once: true } : {}),
+            ...(once ? { once: true } : { onTick: printJson }),
             shouldContinue: () => !stopping,
             sleep: (ms) => new Promise((resolve) => {
                 const timer = setTimeout(() => {
@@ -1477,8 +1492,7 @@ async function main() {
                 };
             }),
         });
-        const last = reports[reports.length - 1];
-        printJson({ ticks: reports.length, dir, ...(last === undefined ? {} : { last }) });
+        printJson({ ticks: run.ticks, dir, ...(once && run.last !== null ? { last: run.last } : {}) });
         return 0;
     }
     if (namespace === 'daemon' && action === 'start') {
@@ -1850,9 +1864,57 @@ async function main() {
         // last n events of a concatenation are the last n of the LAST session, so
         // an operator resuming an epic saw its newest events padded with nothing
         // from before the split. Now `--lineage` tails the epic in time order.
-        let events = flags.lineage
-            ? (await readLineageEvents(sessionId, opts)).slice(-n)
-            : await tailEvents(sessionId, n, opts);
+        const scope = async () => flags.lineage ? readLineageEvents(sessionId, opts) : readEvents(sessionId, opts);
+        if (flags.follow === 'true') {
+            // A stream is not an array, so `--follow` prints one event per line --
+            // the backlog included. A reader can pipe that into `jq -c` or `grep`
+            // from the first event, rather than waiting on a closing bracket that
+            // by definition never comes.
+            const start = await scope();
+            let backlog = start.slice(-n);
+            if (flags.task)
+                backlog = filterEvents(backlog, { taskId: flags.task });
+            for (const event of backlog)
+                printJson(event);
+            // The interrupt has to reach the sleep, not just the flag -- `daemon
+            // run` below wires the same pair for the same reason. An operator who
+            // hits ^C and then waits out an interval reaches for `kill -9`.
+            let stopping = false;
+            let wake = null;
+            const requestStop = () => {
+                stopping = true;
+                wake?.();
+            };
+            process.once('SIGINT', requestStop);
+            process.once('SIGTERM', requestStop);
+            // `smith event tail --follow | head -5` closes the pipe under us. That
+            // is the reader saying "enough", not a failure worth an error line. We
+            // only hear it on the next write, the way `tail -f` does: a quiet log
+            // keeps an orphaned follower polling until something lands in it.
+            process.stdout.on('error', requestStop);
+            await followEvents({
+                seen: start.map((event) => event.event_id),
+                read: async () => {
+                    const fresh = await scope();
+                    return flags.task ? filterEvents(fresh, { taskId: flags.task }) : fresh;
+                },
+                emit: printJson,
+                shouldContinue: () => !stopping,
+                sleep: (ms) => new Promise((resolve) => {
+                    const timer = setTimeout(() => {
+                        wake = null;
+                        resolve();
+                    }, ms);
+                    wake = () => {
+                        clearTimeout(timer);
+                        wake = null;
+                        resolve();
+                    };
+                }),
+            });
+            return 0;
+        }
+        let events = flags.lineage ? (await scope()).slice(-n) : await tailEvents(sessionId, n, opts);
         if (flags.task)
             events = filterEvents(events, { taskId: flags.task });
         printJson(events);
@@ -2000,14 +2062,18 @@ async function main() {
             if (positional.length === 0) {
                 throw new SmithError('cli.empty-wave', 'Usage: smith claims impact --plan <plan.json> <task-id>... — a wave with no tasks is not a wave.', { plan: plan.epic_id });
             }
-            const claimsById = new Map(plan.tasks.map((task) => [task.task_id, task.claims]));
+            const recordsById = new Map(plan.tasks.map((task) => [task.task_id, task]));
+            // Claims and keeps_exports are read through the one door validateWave
+            // uses (claims.ts readClaimList), so a promise that is not a list of file
+            // paths is refused here with the same code it would earn at admission.
             const tasks = positional.map((typed) => {
                 const id = resolveTaskId(plan, typed);
-                const claims = claimsById.get(id);
-                if (!Array.isArray(claims) || claims.some((claim) => typeof claim !== 'string')) {
-                    throw new SmithError('claims.unreadable-claims', `Task "${id}" does not declare its claims as a list of globs.`, { task_id: id, received: claims === undefined ? 'undefined' : typeof claims });
-                }
-                return { task_id: id, claims };
+                const record = recordsById.get(id);
+                const claims = record?.claims;
+                const keeps = record?.keeps_exports;
+                return readClaimList(keeps === undefined
+                    ? { task_id: id, claims }
+                    : { task_id: id, claims, keeps_exports: keeps });
             });
             // The declarations are read off the checkout, not off the plan: a claim
             // says which files a task may write, and only the tree says what those
@@ -2023,7 +2089,7 @@ async function main() {
         // the diff this task committed, and everyone in the repo who imports it.
         const diffs = collectExportDiffs(worktreeDir, collectCommittedChanges(worktreeDir));
         const graph = buildSymbolGraph(collectSources(worktreeDir));
-        const report = exportImpact(graph, diffs, spec.claims);
+        const report = exportImpact(graph, diffs, spec.claims, spec.keeps_exports ?? []);
         printJson(report);
         return report.ok ? 0 : 1;
     }
@@ -2111,21 +2177,24 @@ async function main() {
     // dispatch would end up reading its own output back as evidence that a turn
     // happened. The caller starts the process this prints.
     //
-    // No `--policy` means the built-in policy, which is the single in-process
-    // harness this factory actually runs. There is no harness.yml to default to,
-    // on purpose: shipping one is the operator's call, not a side effect of
-    // adding the seam.
+    // No `--policy` means factory/policies/harness.yml, the shipped policy
+    // (paths.ts's HARNESS_POLICY_PATH) — three harnesses as of this writing,
+    // `claude-code` still the default. `--policy <file>` overrides it, same
+    // shape `stack show` uses.
     if (namespace === 'harness' && action === 'list') {
         printJson(summarizeHarnesses({ policy: loadHarnessPolicy(flags.policy) }));
         return 0;
     }
     if (namespace === 'harness' && action === 'plan') {
+        const tier = flags.tier;
         const invocation = planWorkerTurn({
             harness: flags.harness,
             role: requireFlag(flags, 'role'),
             taskId: requireFlag(flags, 'task'),
             promptFile: requireFlag(flags, 'prompt-file'),
             worktree: flags.worktree ?? null,
+            ...(tier !== undefined ? { tier } : {}),
+            ...(flags.schema !== undefined ? { schema: flags.schema } : {}),
         }, { policy: loadHarnessPolicy(flags.policy) });
         printJson(invocation);
         return 0;

package/factory/orchestrator/dist/daemon.js

@@ -648,6 +648,11 @@ function defaultSleep(ms) {
  * The `finally` is the point of the whole function: a loop that exits still
  * holding its lock — because a tick threw, because the operator hit ^C — is a
  * loop nothing can restart without a human deleting a file.
+ *
+ * It hands each report to `onTick` and keeps only the last. A process meant
+ * to run for weeks cannot hold every tick it ever ran — at the default
+ * interval that array is ~290 reports a day, forever — and nothing that
+ * outlives the loop wants more than a count and the newest one.
  */
 export async function runDaemon(opts) {
     const pid = opts.pid ?? process.pid;
@@ -678,17 +683,23 @@ export async function runDaemon(opts) {
         writeFindingMemory(opts.dir, memoryOf(report.findings));
         return report;
     };
-    const reports = [];
+    const run = { ticks: 0, last: null };
+    const tickAndTell = async () => {
+        const report = await tickWithMemory();
+        run.ticks += 1;
+        run.last = report;
+        opts.onTick?.(report);
+    };
     try {
         if (opts.once === true) {
-            reports.push(await tickWithMemory());
-            return reports;
+            await tickAndTell();
+            return run;
         }
         while (shouldContinue()) {
-            reports.push(await tickWithMemory());
+            await tickAndTell();
             await sleep(intervalSeconds * 1000);
         }
-        return reports;
+        return run;
     }
     finally {
         releaseLock(opts.dir, pid);

package/factory/orchestrator/dist/events.js

@@ -1047,3 +1047,53 @@ export function filterEvents(events, filter) {
         return true;
     });
 }
+/**
+ * How often `--follow` re-reads a log it is following.
+ *
+ * A second is well under the interval an operator perceives as lag, and a
+ * re-read costs what one `smith event tail` costs -- the poll is not what
+ * makes a busy factory expensive. There is no flag for it on purpose: a
+ * knob no answer depends on is a knob every reader of `--help` pays for.
+ */
+export const FOLLOW_TICK_MS = 1000;
+/**
+ * The events in `events` that `seen` does not already hold, in `events`'
+ * order.
+ *
+ * The cursor is a set of ids rather than a count because `--lineage` merges
+ * several logs by `ts` (mergeSessionLogs above): an event appended now can
+ * sort BEHIND one already printed, and a stream cannot un-print. A length
+ * cursor would either re-emit the tail or skip the new event outright, and
+ * both are worse than holding the ids -- which cost what the read they came
+ * from already cost.
+ */
+export function unseenEvents(events, seen) {
+    return events.filter((event) => !seen.has(event.event_id));
+}
+/**
+ * Read, emit what is new, sleep, repeat -- until `shouldContinue` says stop.
+ *
+ * The seams are runDaemon's, for the same reason: the contract of a loop is
+ * what it does AROUND the read, and a loop that owns its own clock can only
+ * be tested by waiting. `sleep` is where an interrupt lands, so the caller
+ * that wires SIGINT resolves the sleep rather than waiting out the interval.
+ *
+ * Returns how many events it emitted, which is the only thing about a stream
+ * worth having after it ends.
+ */
+export async function followEvents(opts) {
+    const intervalMs = opts.intervalMs ?? FOLLOW_TICK_MS;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const shouldContinue = opts.shouldContinue ?? (() => true);
+    const seen = new Set(opts.seen ?? []);
+    let emitted = 0;
+    while (shouldContinue()) {
+        for (const event of unseenEvents(await opts.read(), seen)) {
+            seen.add(event.event_id);
+            opts.emit(event);
+            emitted += 1;
+        }
+        await sleep(intervalMs);
+    }
+    return emitted;
+}