@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/projectName.js

@@ -0,0 +1,25 @@
+// The factory's own project name, and the one place its old spelling
+// becomes the current one.
+//
+// Renamed from `black-smith` to `blacksmith` (operator decision, CHANGELOG
+// "rename the factory's own project"). History is immutable: already-logged
+// events, committed plan files and old roadmap.md bullets may still carry
+// the old name verbatim, so every reader of a project value normalizes it
+// through `normalizeProjectName` rather than comparing against two literals.
+//
+// A tiny module with no dependency of its own, so both `db/queries.ts`
+// (which reaches drizzle) and `roadmap.ts` (which `test/cliBoot.test.ts`
+// pins never does) can import the same constant and the same mapping.
+/** The factory's own project name, everywhere a reader needs the current spelling. */
+export const FACTORY_PROJECT_NAME = 'blacksmith';
+/** The name `blacksmith` replaced — still present verbatim in old events, plans and roadmap bullets. */
+export const LEGACY_FACTORY_PROJECT = 'black-smith';
+/**
+ * Maps the legacy project name to the current one; every other value passes
+ * through unchanged. The one place old data's project value becomes the
+ * current one, so a reader never has to compare against `'black-smith'`
+ * itself.
+ */
+export function normalizeProjectName(value) {
+    return value === LEGACY_FACTORY_PROJECT ? FACTORY_PROJECT_NAME : value;
+}

package/factory/orchestrator/dist/promptCapture.js

@@ -0,0 +1,306 @@
+/**
+ * Where an operator prompt is recorded, decided from the working directory.
+ *
+ * The UserPromptSubmit hook reaches this through two entries (`promptHook.ts`
+ * and `bs prompt capture`), and bs-mod asks the same resolver through
+ * `bs-prompt-hook --resolve`, so "is this cwd a store" has one answer. The
+ * import graph is kept small on purpose: no db layer, no `cli.ts`.
+ */
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { readEnv } from './env.js';
+import { appendWithin, listSessionIds, ROOT_EVENT_TYPE, readEvents, } from './events.js';
+import { IS_CLONE, REPO_ROOT, resolveProjectsDir, resolveWorkRoot, roadmapReadPath, } from './paths.js';
+import { factoryProjects } from './projects.js';
+import { isHarnessText } from './prompts.js';
+import { gitTop, hasEvents, storeRootAt } from './storeRoot.js';
+const realOr = (p) => {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+};
+/** The checkout's own roadmap, read only after M1 and M2 miss (Q5b). */
+const overlayRoadmapAt = (top) => path.join(top, '.blacksmith', 'factory', 'specs', 'roadmap.md');
+/** The name a roadmap gives the checkout at `top`, or undefined. Never throws. */
+function declaredAs(top, roadmapPath, roots) {
+    const want = realOr(top);
+    const ref = factoryProjects({ roadmapPath, roots }).find((r) => !r.self && realOr(r.dir) === want);
+    return ref?.name;
+}
+/**
+ * M1, M2, M4, M3 in that order; null when the cwd is not managed. Reads the
+ * environment, the file system and the roadmaps and writes nothing.
+ */
+export function resolveCaptureStore(input) {
+    const { cwd, env, repoRoot, isClone } = input;
+    const declaredHome = readEnv(env, 'BS_HOME')?.trim();
+    const workRoot = resolveWorkRoot(repoRoot, cwd, env, isClone);
+    // M1: BS_HOME names a store that exists.
+    if (declaredHome && hasEvents(workRoot)) {
+        return { eventsDir: path.join(workRoot, 'state', 'events'), rule: 'M1' };
+    }
+    // M2: the checkout (or the main clone of a linked worktree) has a store.
+    const top = gitTop(cwd);
+    const own = top === null ? null : storeRootAt(top);
+    if (own !== null)
+        return { eventsDir: path.join(own.root, 'state', 'events'), rule: 'M2' };
+    // M4: the factory's roadmap declares this checkout. A BS_HOME with no store
+    // means `bs` itself would write elsewhere, so it is a no-op rather than a
+    // fallback into the clone.
+    if (top !== null && isClone && !declaredHome && hasEvents(repoRoot)) {
+        const roots = [
+            resolveProjectsDir(repoRoot, cwd, isClone),
+            path.join(resolveWorkRoot(repoRoot, cwd, env, isClone), 'workspaces'),
+        ];
+        let project = declaredAs(top, input.roadmapPath, roots);
+        const overlay = overlayRoadmapAt(top);
+        if (project === undefined && existsSync(overlay))
+            project = declaredAs(top, overlay, roots);
+        if (project !== undefined) {
+            return { eventsDir: path.join(repoRoot, 'state', 'events'), project, rule: 'M4' };
+        }
+    }
+    // M3: a bare `/bs` where the work root already has a store.
+    if (input.command === 'bs' && hasEvents(workRoot)) {
+        return { eventsDir: path.join(workRoot, 'state', 'events'), rule: 'M3' };
+    }
+    return null;
+}
+/** The context both entries build from the running bin's own location. */
+export const captureContext = (cwd, env) => ({
+    cwd,
+    env,
+    repoRoot: REPO_ROOT,
+    isClone: IS_CLONE,
+    roadmapPath: roadmapReadPath(),
+});
+/** The `--resolve <cwd>` answer: one JSON line, or null when the cwd is not managed. */
+export function resolveLine(cwd, ctx) {
+    const store = resolveCaptureStore({ ...ctx, cwd });
+    if (store === null || store.rule === 'M3')
+        return null;
+    return JSON.stringify({
+        events_dir: store.eventsDir,
+        ...(store.project === undefined ? {} : { project: store.project }),
+        rule: store.rule,
+    });
+}
+export const CLI_ID = /^[0-9a-f-]{8,64}$/i;
+const COMMAND_NAME = /^[A-Za-z0-9_.:-]+$/;
+const MAIN_THREAD = new Set(['user', 'operator', 'orchestrator']);
+/** Wave logs belong to their wave-runner node (architecture §18 rule 4). */
+const WAVE_RUNNER = 'wave-runner';
+const FALLBACK_WINDOW_MS = 72 * 3600 * 1000;
+const DEDUPE_MS = 10_000;
+const SCAN_LIMIT = 20;
+export const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+export const str = (v) => (typeof v === 'string' ? v : undefined);
+/** The text an AskUserQuestion result puts on the timeline; null when no one answered. */
+export function answerOf(result) {
+    const answers = isObj(result.answers) ? result.answers : {};
+    const annotations = isObj(result.annotations) ? result.annotations : {};
+    const questions = Array.isArray(result.questions) ? result.questions.filter(isObj) : [];
+    const rows = [];
+    for (const q of questions) {
+        const question = str(q.question);
+        const answer = question === undefined ? undefined : str(answers[question]);
+        if (question === undefined || answer === undefined || answer === '')
+            continue;
+        const notes = isObj(annotations[question])
+            ? str(annotations[question].notes)
+            : undefined;
+        rows.push({
+            question,
+            header: str(q.header) ?? question,
+            answer,
+            ...(notes === undefined || notes === '' ? {} : { notes }),
+        });
+    }
+    const response = str(result.response);
+    const free = response === undefined || response === '' ? undefined : response;
+    if (rows.length === 0 && free === undefined)
+        return null;
+    const prompt = rows.length > 0 ? rows.map((r) => `${r.header}: ${r.answer}`).join('\n') : free;
+    return { prompt, answers: rows, ...(free === undefined ? {} : { response: free }) };
+}
+/** `/bs-mod off` -> `bs-mod`; no `command` for text that is not a command name. */
+export function commandOf(text) {
+    if (!text.startsWith('/'))
+        return undefined;
+    const token = /^\/(\S*)/.exec(text)?.[1] ?? '';
+    return COMMAND_NAME.test(token) ? token : undefined;
+}
+export const newestMain = (events, cli) => [...events]
+    .reverse()
+    .find((e) => e.record.cli_session_id === cli && MAIN_THREAD.has(e.record.actor));
+/** The epic main log this CLI session is driving, or null (design §2.1, target log). */
+async function findMainLog(eventsDir, cli, floorMs) {
+    const logs = listSessionIds(eventsDir)
+        .map((id) => {
+        try {
+            return {
+                id,
+                file: path.join(eventsDir, `${id}.jsonl`),
+                mtime: statSync(path.join(eventsDir, `${id}.jsonl`)).mtimeMs,
+            };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((l) => l !== null && l.mtime >= floorMs)
+        .sort((a, b) => b.mtime - a.mtime);
+    let best = null;
+    let stamped = 0;
+    for (const log of logs) {
+        if (stamped >= SCAN_LIMIT)
+            break;
+        try {
+            if (!readFileSync(log.file, 'utf8').includes(cli))
+                continue;
+            stamped++;
+            const events = await readEvents(log.id, { stateDir: eventsDir });
+            if (events[0]?.record.actor === WAVE_RUNNER)
+                continue;
+            if (events.some((e) => e.record.event_type === 'epic-closed'))
+                continue;
+            const hit = newestMain(events, cli);
+            if (hit !== undefined && (best === null || hit.record.ts > best.ts)) {
+                best = { id: log.id, ts: hit.record.ts };
+            }
+        }
+        catch {
+            // An unreadable log is not a candidate.
+        }
+    }
+    return best?.id ?? null;
+}
+/**
+ * Record one UserPromptSubmit hook payload. Returns the single stdout line on
+ * a write, null when nothing was written (not managed, skipped, duplicate,
+ * malformed). Throws only on a store failure; the entries swallow it.
+ * `answer` mode takes a PostToolUse AskUserQuestion payload instead and files
+ * the operator's answers as a `user_prompt` (design §2.8).
+ */
+export async function capturePrompt(raw, ctx, mode = 'prompt') {
+    let input;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        input = parsed;
+    }
+    catch {
+        return null;
+    }
+    const { session_id: cli } = input;
+    if (typeof cli !== 'string' || !CLI_ID.test(cli))
+        return null;
+    if (input.agent_id !== undefined)
+        return null;
+    let prompt;
+    let promptId = typeof input.prompt_id === 'string' ? input.prompt_id : undefined;
+    let extra = {};
+    if (mode === 'answer') {
+        const result = input.tool_response;
+        if (input.tool_name !== 'AskUserQuestion' || !isObj(result))
+            return null;
+        if (typeof input.tool_use_id !== 'string' || input.tool_use_id === '')
+            return null;
+        // A timeout answered nothing: no human chose.
+        if (result.afkTimeoutMs !== undefined && result.afkTimeoutMs !== null)
+            return null;
+        const got = answerOf(result);
+        if (got === null || isHarnessText(got.prompt))
+            return null;
+        prompt = got.prompt;
+        promptId = input.tool_use_id;
+        extra = {
+            kind: 'answer',
+            answers: got.answers,
+            ...(got.response === undefined ? {} : { response: got.response }),
+        };
+    }
+    else {
+        if (typeof input.prompt !== 'string' || isHarnessText(input.prompt))
+            return null;
+        prompt = input.prompt;
+    }
+    const command = mode === 'answer' ? undefined : commandOf(prompt);
+    const cwd = typeof input.cwd === 'string' ? input.cwd : ctx.cwd;
+    const store = resolveCaptureStore({ ...ctx, cwd, command });
+    if (store === null)
+        return null;
+    const { eventsDir, project: declared } = store;
+    let floorMs = Date.now() - FALLBACK_WINDOW_MS;
+    if (typeof input.transcript_path === 'string') {
+        try {
+            floorMs = statSync(input.transcript_path).birthtimeMs;
+        }
+        catch {
+            // Keep the 72 h fallback.
+        }
+    }
+    const home = `prompts-${cli}`;
+    const found = await findMainLog(eventsDir, cli, floorMs);
+    const write = (target) => appendWithin(target, (existing) => {
+        const nowMs = Date.now();
+        const duplicate = existing.some((e) => e.record.event_type === 'user_prompt' &&
+            ((promptId !== undefined && e.record.payload.prompt_id === promptId) ||
+                (mode === 'prompt' &&
+                    e.record.cli_session_id === cli &&
+                    e.record.payload.prompt === prompt &&
+                    nowMs - Date.parse(e.record.ts) <= DEDUPE_MS)));
+        if (duplicate)
+            return [];
+        const out = [];
+        if (existing.length === 0) {
+            out.push({
+                session_id: target,
+                actor: 'system',
+                event_type: ROOT_EVENT_TYPE,
+                plan_version: 1,
+                causal_parent: null,
+                payload: { kind: 'prompt-log' },
+                ...(declared === undefined ? {} : { project: declared }),
+            });
+        }
+        const parent = newestMain(existing, cli) ?? existing[0];
+        const project = parent?.record.project ?? declared ?? out[0]?.project;
+        out.push({
+            session_id: target,
+            actor: 'user',
+            event_type: 'user_prompt',
+            plan_version: parent?.record.plan_version ?? 1,
+            causal_parent: parent?.event_id ?? `${target}#0`,
+            payload: {
+                prompt,
+                source: 'hook',
+                ...extra,
+                ...(promptId === undefined ? {} : { prompt_id: promptId }),
+                ...(command === undefined ? {} : { command }),
+            },
+            ...(project === undefined ? {} : { project }),
+        });
+        return out;
+    }, { stateDir: eventsDir, cliSessionId: cli });
+    let target = found ?? home;
+    let stored;
+    try {
+        stored = await write(target);
+    }
+    catch (err) {
+        if (target === home)
+            throw err;
+        // The epic log the scan picked can no longer take the prompt: keep it in the home log.
+        target = home;
+        stored = await write(target);
+    }
+    const written = stored[stored.length - 1];
+    if (written === undefined)
+        return null;
+    return `bs prompt capture: ${JSON.stringify({ event_id: written.event_id, session_id: target })}`;
+}

package/factory/orchestrator/dist/promptHook.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// The prompt-capture hook, as an entry point and nothing else.
+//
+// The plugin's UserPromptSubmit hook execs this file on every prompt, so it
+// stays off `cli.ts` and the db layer, as `policyHook.ts` does for the guard.
+// The logic is `promptCapture.ts`; `bs prompt capture` reaches the same
+// function. Deliberately unconditional (no `import.meta.url` guard) for the
+// reason `policyHook.ts` gives.
+//
+// Never blocks a prompt: every failure is a silent exit 0.
+//   promptHook.js                 stdin = hook JSON; prints one line on a write
+//   promptHook.js answer          stdin = PostToolUse AskUserQuestion JSON; same line
+//   promptHook.js --resolve <cwd> prints the store this cwd records into, if any
+import { readFileSync } from 'node:fs';
+import { captureContext, capturePrompt, resolveLine } from './promptCapture.js';
+try {
+    const args = process.argv.slice(2);
+    if (args[0] === '--resolve') {
+        const cwd = args[1];
+        const line = cwd === undefined ? null : resolveLine(cwd, captureContext(cwd, process.env));
+        if (line !== null)
+            process.stdout.write(`${line}\n`);
+    }
+    else {
+        const line = await capturePrompt(readFileSync(0, 'utf8'), captureContext(process.cwd(), process.env), args[0] === 'answer' ? 'answer' : 'prompt');
+        if (line !== null)
+            process.stdout.write(`${line}\n`);
+    }
+}
+catch {
+    // A capture that fails loses one record; the prompt itself goes through.
+}
+process.exitCode = 0;

package/factory/orchestrator/dist/promptImport.js

@@ -0,0 +1,281 @@
+/**
+ * `bs prompt import`: replay a Claude Code transcript into the home prompt
+ * log, writing what the UserPromptSubmit and AskUserQuestion hooks would have
+ * written had they been installed (design/prompt-capture.md §2.7, §2.8).
+ */
+import { createReadStream } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { appendWithin, ROOT_EVENT_TYPE, readEvents, } from './events.js';
+import { answerOf, CLI_ID, commandOf, isObj, newestMain, resolveCaptureStore, str, } from './promptCapture.js';
+import { isHarnessText, PromptError } from './prompts.js';
+/** `/name args` (or just `/name`) from a command echo; null without a command name. */
+function commandText(content) {
+    const name = /<command-name>([\s\S]*?)<\/command-name>/.exec(content)?.[1]?.trim();
+    if (name === undefined || name === '')
+        return null;
+    const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(content)?.[1]?.trim() ?? '';
+    return args === '' ? name : `${name} ${args}`;
+}
+function classify(l) {
+    const ts = str(l.timestamp);
+    const ms = Date.parse(ts ?? '');
+    if (ts === undefined || Number.isNaN(ms))
+        return null;
+    const uuid = str(l.uuid);
+    const cwd = str(l.cwd);
+    const base = { ts, ms, cwd };
+    const origin = isObj(l.origin) ? str(l.origin.kind) : undefined;
+    const flagged = l.isMeta === true || l.isCompactSummary === true || l.isSidechain === true;
+    const result = isObj(l.toolUseResult) ? l.toolUseResult : undefined;
+    if (l.type === 'user' && result !== undefined && 'questions' in result && 'answers' in result) {
+        const message = isObj(l.message) ? l.message : {};
+        const first = Array.isArray(message.content) ? message.content[0] : undefined;
+        const toolUseId = isObj(first) ? str(first.tool_use_id) : undefined;
+        if (toolUseId === undefined || l.isSidechain === true)
+            return null;
+        if (result.afkTimeoutMs !== undefined && result.afkTimeoutMs !== null)
+            return 'afk';
+        const got = answerOf(result);
+        if (got === null)
+            return null;
+        if (isHarnessText(got.prompt))
+            return 'harness';
+        return {
+            ...base,
+            key: 'prompt_id',
+            keyValue: toolUseId,
+            command: undefined,
+            payload: {
+                prompt: got.prompt,
+                source: 'backfill',
+                kind: 'answer',
+                prompt_id: toolUseId,
+                answers: got.answers,
+                ...(got.response === undefined ? {} : { response: got.response }),
+            },
+        };
+    }
+    const text = (key, keyValue, t) => {
+        if (keyValue === undefined)
+            return null;
+        if (isHarnessText(t))
+            return 'harness';
+        const command = commandOf(t);
+        return {
+            ...base,
+            key,
+            keyValue,
+            command,
+            payload: {
+                prompt: t,
+                source: 'backfill',
+                [key]: keyValue,
+                ...(command === undefined ? {} : { command }),
+            },
+        };
+    };
+    if (l.type === 'user') {
+        const message = isObj(l.message) ? l.message : {};
+        if (origin !== 'human' || flagged || typeof message.content !== 'string')
+            return null;
+        const opening = message.content.trimStart();
+        const typedCommand = opening.startsWith('<command-message') || opening.startsWith('<command-name')
+            ? commandText(message.content)
+            : null;
+        return text('prompt_id', str(l.promptId) ?? uuid, typedCommand ?? message.content);
+    }
+    if (l.type === 'attachment') {
+        const a = isObj(l.attachment) ? l.attachment : {};
+        const aOrigin = isObj(a.origin) ? str(a.origin.kind) : undefined;
+        if (a.type !== 'queued_command' || a.commandMode !== 'prompt' || aOrigin !== 'human')
+            return null;
+        if (flagged || typeof a.prompt !== 'string')
+            return null;
+        return text('transcript_uuid', uuid, a.prompt);
+    }
+    if (l.type === 'system' && l.subtype === 'local_command') {
+        const content = str(l.content) ?? '';
+        const t = commandText(content);
+        if (t === null || uuid === undefined)
+            return null;
+        const command = commandOf(t);
+        return {
+            ...base,
+            key: 'transcript_uuid',
+            keyValue: uuid,
+            command,
+            payload: {
+                prompt: t,
+                source: 'backfill',
+                transcript_uuid: uuid,
+                ...(command === undefined ? {} : { command }),
+            },
+        };
+    }
+    return null;
+}
+/** Every line of a file, decoded as UTF-8, without ever holding the whole file. */
+async function* linesOf(file) {
+    yield* linesOfChunks(createReadStream(file));
+}
+/**
+ * Split byte chunks into `\n`-terminated lines (the terminator is dropped; a
+ * `\r` before it is kept). A final unterminated line is yielded, empty input
+ * yields nothing. UTF-8 is decoded across chunk boundaries, and a sequence cut
+ * off at EOF decodes to U+FFFD.
+ */
+export async function* linesOfChunks(chunks) {
+    const decoder = new StringDecoder('utf8');
+    // Pieces of the unfinished line; each chunk is searched once, from its start.
+    let pending = [];
+    for await (const chunk of chunks) {
+        const text = decoder.write(chunk);
+        let from = 0;
+        let nl = text.indexOf('\n');
+        while (nl !== -1) {
+            pending.push(text.slice(from, nl));
+            yield pending.length === 1 ? pending[0] : pending.join('');
+            pending = [];
+            from = nl + 1;
+            nl = text.indexOf('\n', from);
+        }
+        if (from < text.length)
+            pending.push(from === 0 ? text : text.slice(from));
+    }
+    pending.push(decoder.end());
+    const last = pending.join('');
+    if (last !== '')
+        yield last;
+}
+async function parseTranscript(file) {
+    const ids = new Set();
+    const candidates = [];
+    let harness = 0;
+    let afk = 0;
+    for await (const raw of linesOf(file)) {
+        if (raw.trim() === '')
+            continue;
+        let l;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!isObj(parsed))
+                continue;
+            l = parsed;
+        }
+        catch {
+            // A torn line (a transcript still being written) is not a prompt.
+            continue;
+        }
+        const id = str(l.sessionId);
+        if (id !== undefined)
+            ids.add(id);
+        const c = classify(l);
+        if (c === 'harness')
+            harness++;
+        else if (c === 'afk')
+            afk++;
+        else if (c !== null)
+            candidates.push(c);
+    }
+    const all = [...ids];
+    const cli = all[0];
+    if (all.length !== 1 || cli === undefined || !CLI_ID.test(cli)) {
+        throw new PromptError('prompts.import-session-id', `A transcript must carry exactly one valid sessionId; "${file}" has ${all.length === 0 ? 'none' : `${all.length} (${all.join(', ')})`}. Nothing was written.`, { transcript: file, session_ids: all });
+    }
+    candidates.sort((a, b) => a.ms - b.ms);
+    return { cli, candidates, harness, afk };
+}
+/**
+ * Import one transcript. With `dryRun` nothing is written; either way `events`
+ * is what is (or would be) appended, root included.
+ */
+export async function importTranscript(file, ctx, opts = {}) {
+    const { cli, candidates, harness, afk } = await parseTranscript(file);
+    const home = `prompts-${cli}`;
+    const summary = {
+        session_id: home,
+        imported: 0,
+        skipped: { duplicate: 0, older: 0, harness, afk },
+    };
+    const first = candidates[0];
+    if (first === undefined)
+        return { events: [], summary };
+    const store = resolveCaptureStore({
+        ...ctx,
+        cwd: first.cwd ?? ctx.cwd,
+        command: candidates.some((c) => c.command === 'bs') ? 'bs' : undefined,
+    });
+    if (store === null) {
+        throw new PromptError('prompts.import-unmanaged', `The first prompt of "${file}" ran in ${first.cwd ?? ctx.cwd}, which belongs to no Blacksmith store. Nothing was written.`, { transcript: file, cwd: first.cwd ?? ctx.cwd });
+    }
+    const plan = (existing) => {
+        summary.imported = 0;
+        summary.skipped.duplicate = 0;
+        summary.skipped.older = 0;
+        const seen = new Set();
+        for (const e of existing) {
+            for (const k of ['prompt_id', 'transcript_uuid']) {
+                const v = e.record.payload[k];
+                if (typeof v === 'string')
+                    seen.add(v);
+            }
+        }
+        const newest = existing.reduce((m, e) => Math.max(m, Date.parse(e.record.ts)), -Infinity);
+        const fresh = [];
+        for (const c of candidates) {
+            if (seen.has(c.keyValue))
+                summary.skipped.duplicate++;
+            else if (c.ms < newest)
+                summary.skipped.older++;
+            else {
+                seen.add(c.keyValue);
+                fresh.push(c);
+            }
+        }
+        summary.imported = fresh.length;
+        if (fresh.length === 0)
+            return [];
+        const out = [];
+        const head = fresh[0];
+        if (existing.length === 0) {
+            out.push({
+                session_id: home,
+                actor: 'system',
+                event_type: ROOT_EVENT_TYPE,
+                plan_version: 1,
+                causal_parent: null,
+                payload: { kind: 'prompt-log' },
+                cli_session_id: cli,
+                ts: head.ts,
+                ...(store.project === undefined ? {} : { project: store.project }),
+            });
+        }
+        const anchor = newestMain(existing, cli) ?? existing[0];
+        const project = anchor?.record.project ?? store.project;
+        let parent = anchor?.event_id ?? `${home}#0`;
+        for (const c of fresh) {
+            out.push({
+                session_id: home,
+                actor: 'user',
+                event_type: 'user_prompt',
+                plan_version: anchor?.record.plan_version ?? 1,
+                causal_parent: parent,
+                payload: c.payload,
+                cli_session_id: cli,
+                ts: c.ts,
+                ...(project === undefined ? {} : { project }),
+            });
+            parent = `${home}#${existing.length + out.length - 1}`;
+        }
+        return out;
+    };
+    const stateDir = store.eventsDir;
+    if (opts.dryRun)
+        return { events: plan(await readEvents(home, { stateDir })), summary };
+    let events = [];
+    await appendWithin(home, (existing) => {
+        events = plan(existing);
+        return events;
+    }, { stateDir, cliSessionId: cli, keepTs: true });
+    return { events, summary };
+}

package/factory/orchestrator/dist/prompts.js

@@ -22,6 +22,19 @@ import { appendEvent } from './events.js';
  */
 export class PromptError extends SmithError {
 }
+/**
+ * True when `text` is harness-injected rather than something the operator
+ * typed: blank, or a record opening with one of the CLI's own tags (reminders,
+ * local and shell command echoes, task notifications, memory input, and a
+ * subagent's hand-back, which is model output delivered as a user turn). The
+ * one list, shared by the dashboard's reader and any writer of operator
+ * prompts.
+ */
+export function isHarnessText(text) {
+    const trimmed = text.trim();
+    return (trimmed === '' ||
+        /^<(system-reminder|local-command|command-message|bash-input|bash-stdout|bash-stderr|task-notification|user-memory-input|agent-message)/.test(trimmed));
+}
 /**
  * Append one `user_prompt`, returning the stored event.
  *

package/factory/orchestrator/dist/providers/schema-validate.js

@@ -93,7 +93,7 @@ export function extractBalancedJson(text) {
 /**
  * Schemas that describe ONE item a `kind: review` judge returns MANY of. Both
  * of them: `finding` is the stored record (the native reviewer's contract,
- * .claude/agents/reviewer.md), `finding-evidence` is the judge's half of it —
+ * .claude/agents/bs-reviewer.md), `finding-evidence` is the judge's half of it —
  * the same evidence without the six identity fields the orchestrator owns.
  * A set, not a comparison, because the second entry was added a year after the
  * first and the `=== 'finding'` it replaced would have silently validated an
@@ -136,7 +136,7 @@ function describeShape(parsed) {
 /**
  * Extract + schema-validate a judge's raw text response. `finding.schema.json`
  * describes ONE finding, but a `kind: review` judge's contract
- * (.claude/agents/reviewer.md) returns an ARRAY of findings — so against an
+ * (.claude/agents/bs-reviewer.md) returns an ARRAY of findings — so against an
  * ARRAY_VALUED_SCHEMAS name the top-level value must be that array, bare or
  * wrapped in one single-key object (see `unwrapArray`), and validates
  * element-wise; the value returned is the array itself, unwrapped. A bare