@juzser/blacksmith 0.2.0 → 0.4.0

package/factory/orchestrator/dist/db/queries.js

@@ -8,11 +8,14 @@ import { and, eq, gte, inArray, lte } from 'drizzle-orm';
 import { isOperatorActor } from '../actors.js';
 import { foldAgents, liveAgents as foldLiveAgents, isWorkingAt, REGISTRY_EVENT_TYPES, } from '../agents-registry.js';
 import { compareLogOrder, isLaterEvent, parseEventId, ROOT_EVENT_TYPE } from '../events.js';
+import { OPEN_FINDING_STATUSES, WAIVABLE_STATUSES } from '../findings.js';
 import { waveLayers } from '../graph.js';
 import { judgeFailureKind } from '../providers/types.js';
 import { severityRank } from '../severity.js';
 import { epicOfTaskId, taskIdsMatch } from '../taskId.js';
+import { TERMINAL_OK_TASK_STATUSES, TERMINAL_TASK_STATUSES } from '../taskStatus.js';
 import { loadTaxonomy } from '../taxonomy.js';
+import { WAIVABLE_SEVERITIES } from '../waivers.js';
 import { agents, artifacts, dispatches, edges, epics, errors, eventsRaw, findings, lessons, milestones, prompts, sessions, tasks, waivers, } from './schema.js';
 /** Phase 6b default: every event/task/etc. logged before the project dimension existed. */
 export const DEFAULT_PROJECT = 'black-smith';
@@ -216,15 +219,6 @@ function inLogOrder(rows) {
 function distinctProjects(...rowSets) {
     return [...new Set(rowSets.flat().map((r) => projectOf(r.project)))].sort();
 }
-const NON_TERMINAL_TASK_STATUSES = [
-    'todo',
-    'ready',
-    'in-progress',
-    'grading',
-    'reviewing',
-    'merging',
-    'blocked',
-];
 /** Every `tasks` row for `scope`, session-filtered in SQL and project-filtered in JS. */
 function allTasksForScope(db, scope) {
     const sessionCond = scopedToSessions(tasks.sessionId, scope);
@@ -343,8 +337,19 @@ function epicTokenMaps(db, scope, taskRows) {
     }
     return { budgetByEpic, spentByEpic };
 }
-const MILESTONE_COMPLETE_TASK_STATUSES = new Set(['completed', 'waived']);
-const MILESTONE_NEXT_EXCLUDED_STATUSES = new Set(['completed', 'waived', 'failed', 'superseded']);
+/**
+ * NEXT hides the statuses the plan has nothing left to ask of — every
+ * terminal one except `escalated`, which is terminal and still waiting on a
+ * person: an escalated task is precisely the next thing the operator has to
+ * act on, so the Roadmap keeps showing it.
+ *
+ * Derived from the write-protection roster rather than retyped, because the
+ * two answers move together: a status somebody declares terminal there is one
+ * NEXT has nothing to say about, and a status nobody has classified keeps
+ * appearing here — visible, rather than dropped off the Roadmap silently.
+ */
+const MILESTONE_NEXT_STILL_WANTS_A_PERSON = 'escalated';
+const MILESTONE_NEXT_EXCLUDED_STATUSES = new Set([...TERMINAL_TASK_STATUSES].filter((s) => s !== MILESTONE_NEXT_STILL_WANTS_A_PERSON));
 const MINI_TIMELINE_LIMIT = 3;
 /**
  * Operator directive 4 (Phase 6b, ui/docs/design-spec.md addendum): up to 3
@@ -363,10 +368,10 @@ function milestoneTaskRefs(milestoneTasks, allTaskRows, edgeRows) {
     }
     const dependencyReady = (taskId) => (dependsOnByTask.get(taskId) ?? []).every((dep) => {
         const status = statusById.get(dep);
-        return status !== undefined && MILESTONE_COMPLETE_TASK_STATUSES.has(status);
+        return status !== undefined && TERMINAL_OK_TASK_STATUSES.has(status);
     });
     const recentDone = milestoneTasks
-        .filter((t) => MILESTONE_COMPLETE_TASK_STATUSES.has(t.taskStatus))
+        .filter((t) => TERMINAL_OK_TASK_STATUSES.has(t.taskStatus))
         .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
         .slice(0, MINI_TIMELINE_LIMIT)
         .map((t) => ({
@@ -426,7 +431,7 @@ function milestoneProgressRows(db, scope = {}, opts = {}) {
         const epicIds = JSON.parse(m.epicIds);
         const epicSet = new Set(epicIds);
         const milestoneTasks = taskRows.filter((t) => t.epicId !== null && epicSet.has(t.epicId));
-        const tasksCompleted = milestoneTasks.filter((t) => MILESTONE_COMPLETE_TASK_STATUSES.has(t.taskStatus)).length;
+        const tasksCompleted = milestoneTasks.filter((t) => TERMINAL_OK_TASK_STATUSES.has(t.taskStatus)).length;
         let tokensSpent = 0;
         let tokensBudget = 0;
         let hasBudget = false;
@@ -454,6 +459,7 @@ function milestoneProgressRows(db, scope = {}, opts = {}) {
             tokensBudget: hasBudget ? tokensBudget : null,
             project: m.project,
             kind: m.kind,
+            errorIssuesEnabled: m.errorIssues,
             ...(refs ? { recentDone: refs.recentDone, nextUp: refs.nextUp } : {}),
         };
     });
@@ -616,17 +622,36 @@ function closedEpicsForScope(db, scope) {
  * so an epic closed by an operator overriding a hold (exactly the case where a
  * task stays non-terminal) read as in flight forever. A close on the log ends
  * the flight, whatever the task rows still say.
+ *
+ * The open side is asked as the complement of db/projector.ts's terminal set
+ * rather than listed here. Listing it inverts the default: a `task_status`
+ * taxonomy.yml declares and this list has not caught up with would answer
+ * "not in flight", and with no close on the log the epic falls out of
+ * `epicsInFlight` and `closedEpics` both — ui/src/lib/api.ts's
+ * `selectableEpics()` is their union, so the epic stops being pickable on
+ * either board, silently.
  */
 function inFlightEpics(taskRows, closed) {
     const closedIds = new Set(closed.map((e) => e.epicId));
     return [
         ...new Set(taskRows
-            .filter((t) => t.epicId &&
-            NON_TERMINAL_TASK_STATUSES.includes(t.taskStatus) &&
-            !closedIds.has(t.epicId))
+            .filter((t) => t.epicId && !TERMINAL_TASK_STATUSES.has(t.taskStatus) && !closedIds.has(t.epicId))
             .map((t) => t.epicId)),
     ].sort();
 }
+/**
+ * A finding the operator's pending-waiver count is about: one the waiver
+ * machinery would actually act on. Both rosters are imported from the modules
+ * that own them — the severities from waivers.ts, the statuses from findings.ts,
+ * where they are read off LEGAL_TRANSITIONS — rather than spelled out here.
+ * This count is a second *reader* of what can be waived and must not become a
+ * second opinion about it: a count that disagrees with the batch does not
+ * error, it just tells the operator a different number than `/bs waivers`
+ * will offer them.
+ */
+function awaitsWaiverDecision(f) {
+    return WAIVABLE_SEVERITIES.includes(f.severity) && WAIVABLE_STATUSES.includes(f.findingStatus);
+}
 /**
  * One project's overview slice, computed by the same logic overview() itself
  * uses (no drift). `nowIso` is the caller's single instant, not a fresh
@@ -643,8 +668,7 @@ function projectSummary(db, project, baseScope, nowIso) {
     const tokensSpent = [...spentByEpic.values()].reduce((s, v) => s + v, 0);
     const tokensBudget = budgetByEpic.size > 0 ? [...budgetByEpic.values()].reduce((s, v) => s + v, 0) : null;
     const escalations = taskRows.filter((t) => t.taskStatus === 'escalated').length;
-    const findingRows = allFindingsForScope(db, scope).filter((f) => (f.severity === 'S3-minor' || f.severity === 'S4-nit') &&
-        (f.findingStatus === 'raised' || f.findingStatus === 'confirmed'));
+    const findingRows = allFindingsForScope(db, scope).filter(awaitsWaiverDecision);
     const pendingWaivers = findingRows.filter((f) => f.waiverId === null).length;
     return {
         project,
@@ -829,8 +853,7 @@ export function overview(db, scope = {}, opts = {}) {
         tokensBudget: budgetByEpic.get(epicId) ?? null,
     }));
     const escalations = taskRows.filter((t) => t.taskStatus === 'escalated').length;
-    const pendingWaiverFindings = allFindingsForScope(db, scope).filter((f) => (f.severity === 'S3-minor' || f.severity === 'S4-nit') &&
-        (f.findingStatus === 'raised' || f.findingStatus === 'confirmed'));
+    const pendingWaiverFindings = allFindingsForScope(db, scope).filter(awaitsWaiverDecision);
     const pendingWaivers = pendingWaiverFindings.filter((f) => f.waiverId === null).length;
     const dispatchSessionCond = scopedToSessions(dispatches.sessionId, scope);
     const dispatchRows = dispatchSessionCond
@@ -979,15 +1002,21 @@ export const FREE_TIMELINE_EVENT_TYPES = [
     // shadow verdict nobody can see is a shadow deployment nobody can evaluate,
     // which is the whole reason the mode exists.
     'cross-finding-reconciled',
-    // The scheduler's three proposals. Architecture §12 has the scheduler
+    // The scheduler's four proposals. Architecture §12 has the scheduler
     // propose and the operator dispose, so the timeline is the only place the
     // offer is ever made -- drop the row and the proposal is never put to
     // anyone. They arrive through scheduler.ts eventTypeFor(), a helper return
     // rather than a literal at the `event_type:` position, which is how all
-    // three stayed off this list without failing the P9-37 lint (Rule D).
+    // four stayed off this list without failing the P9-37 lint (Rule D).
     'recheck-proposed',
     'maintenance-proposed',
     'growth-review-due',
+    // The scheduler's error-report proposal (task 6 of factory-error-log,
+    // scheduler.ts eventTypeFor()'s 'error-report' case). Task 5's issue
+    // reporter disposes it into 'issue-reported', which reaches the timeline
+    // via the taxonomy's gate_event dimension instead -- this entry is the
+    // proposal itself, not the outcome.
+    'error-report-proposed',
     // The audit verbs (audit.ts, docs/specs/audit-command-scope.md §6). An
     // audit runs against a project outside this factory and carries no task_id,
     // so nothing else on the timeline would show that it happened; each verb's
@@ -1186,18 +1215,6 @@ export function timeline(db, filter = {}) {
         entries = applyDecisionsLens(entries);
     return entries;
 }
-// D-127: `amend-pending` is open. The amendment has been written but the tasks
-// it obligates have not landed, so nothing is discharged yet. This query has no
-// obligation data — that lives in epic.ts's summary, which checks each named
-// task id — so it treats the status as unconditionally open: correct for a
-// per-task severity chip, and it fails closed.
-const OPEN_FINDING_STATUSES = new Set([
-    'raised',
-    'confirmed',
-    'fix-pending',
-    'fix-landed',
-    'amend-pending',
-]);
 function worstSeverity(severities) {
     let worst = null;
     let worstIndex = Number.POSITIVE_INFINITY;
@@ -1240,6 +1257,12 @@ export function kanban(db, epicId, scope = {}, opts = {}) {
     for (const f of findingRows) {
         if (f.epicId !== null && !epicIdsInScope.has(f.epicId))
             continue;
+        // D-127: `amend-pending` is one of these. The amendment has been written
+        // but the tasks it obligates have not landed, so nothing is discharged
+        // yet. This query has no obligation data — that lives in epic.ts's
+        // summary, which checks each named task id — so it treats the status as
+        // unconditionally open: correct for a per-task severity chip, and it fails
+        // closed.
         if (!OPEN_FINDING_STATUSES.has(f.findingStatus))
             continue;
         const list = openSeverityByTask.get(f.taskId) ?? [];

package/factory/orchestrator/dist/db/schema.js

@@ -298,7 +298,31 @@ export const milestones = sqliteTable('milestones', {
     // roadmap.ts resolves for a milestone that declares neither bullet, and
     // for those two that answer is the factory's own.
     kind: text('kind').notNull().default('factory'),
+    // Task 7 (factory-error-log) -- roadmap.ts's MilestoneDef.errorIssuesEnabled,
+    // resolved per-project from the roadmap's `- error_issues: on|off` bullet
+    // (default 'on' when absent, same default roadmap.ts itself applies).
+    errorIssues: integer('error_issues', { mode: 'boolean' }).notNull().default(true),
 }, (t) => [index('milestones_project_idx').on(t.project)]);
+/** `issue-reported` events (architecture §8, task 5 of factory-error-log). */
+export const issue_reports = sqliteTable('issue_reports', {
+    eventId: text('event_id').primaryKey(),
+    sessionId: text('session_id').notNull(),
+    ts: text('ts').notNull(),
+    taskRef: text('task_ref'),
+    errorClass: text('error_class').notNull(),
+    fingerprint: text('fingerprint').notNull(),
+    issueUrl: text('issue_url'),
+    latestEventId: text('latest_event_id').notNull(),
+    outcome: text('outcome').notNull(),
+    reason: text('reason'),
+    repoSlug: text('repo_slug'),
+    source: text('source').notNull(),
+    project: text('project'), // Phase 6b — see eventsRaw's project comment above.
+}, (t) => [
+    index('issue_reports_session_idx').on(t.sessionId),
+    index('issue_reports_fingerprint_idx').on(t.fingerprint),
+    index('issue_reports_outcome_idx').on(t.outcome),
+]);
 /** One row per artifact entry on a `task-result-recorded` event's payload. */
 export const artifacts = sqliteTable('artifacts', {
     id: text('id').primaryKey(), // `${event_id}#${index}`

package/factory/orchestrator/dist/dispatchAudit.js

@@ -1,4 +1,6 @@
 import { eventTaskId } from './events.js';
+import { GOAL_CHECK_EVENT } from './goalCheck.js';
+import { SPEC_REVIEW_EVENT } from './spec.js';
 import { taskIdsMatch } from './taskId.js';
 /**
  * Critic work that reaches the event log without a `dispatch_decision`.
@@ -7,14 +9,20 @@ import { taskIdsMatch } from './taskId.js';
  * is how the operator hears it in a detail line. Adding an entry widens the
  * audit's domain; leaving one off is how D-124 happened, so a new event type
  * that records a critic's output belongs here at the moment it is written.
+ *
+ * The keys are the producers' own exported constants, not copies of their
+ * values. `readCriticWorkRecords` skips any event type this map does not
+ * hold, so a key that had drifted from its producer would empty the domain
+ * rather than fail: the pair would fall to `not-applicable`, which `ok`
+ * counts as fine, and D-124 would go unchecked with nothing red to say so.
  */
 const CRITIC_WORK_EVENTS = {
-    'spec-review-recorded': { key: 'reviewed_by', label: 'spec review' },
+    [SPEC_REVIEW_EVENT]: { key: 'reviewed_by', label: 'spec review' },
     // `smith epic goal-check` reaches the log the same way `epic spec-review`
     // does — a judge's verdict on the planner's output, written by a command
     // rather than by a dispatch — so it is in the domain for the same reason,
     // and listed here at the moment it was written rather than after a D-124.
-    'goal-check-recorded': { key: 'checked_by', label: 'spec-vs-goal check' },
+    [GOAL_CHECK_EVENT]: { key: 'checked_by', label: 'spec-vs-goal check' },
 };
 function payloadString(payload, key) {
     const value = payload[key];

package/factory/orchestrator/dist/dispatchLint.js

@@ -0,0 +1,132 @@
+/**
+ * `smith dispatch lint` — check a dispatch prompt against two things a
+ * dispatcher can get wrong without any signal until the agent runs:
+ *
+ *   - the turn budget stated in the prompt vs the role template's
+ *     `maxTurns:`, read fresh off disk (dispatch.md "Carry into the
+ *     prompt" — a prompt that promises more than the template is a fiction
+ *     the agent plans against and gets cut in the middle of).
+ *   - a judge prompt's declared-artifact line vs what the ledger recorded
+ *     for its `judge dispatch` (dispatch.md "Declare each judge's
+ *     artifact" — a judge prompt missing that line is undetectable until
+ *     the report never lands).
+ *
+ * Both parsers and both comparisons live here so the two checks stay one
+ * source of truth for "what does a compliant dispatch prompt say", rather
+ * than every dispatcher re-deriving it.
+ */
+import path from 'node:path';
+import { readTemplateMaxTurns } from './agentsSync.js';
+import { readJudgeTurns } from './judges.js';
+import { AGENTS_DIR } from './paths.js';
+/**
+ * The epic criterion's six judge roles (task 5 and task 6 objectives both
+ * name this exact set: spec-reviewer, reviewer, verifier, grader,
+ * security-reviewer, auditor) -- the roles whose dispatch declares an
+ * artifact and whose SubagentStop is guarded by judge-stop.sh. Kept as its
+ * own list rather than read out of judges.ts: `foldJudgeTurns` folds any
+ * role with a `declared_artifact` on its dispatch into a turn, but this
+ * module is stricter on purpose — only these six get an artifact check, so
+ * a coder's dispatch (never carries one) reads `not-applicable` rather than
+ * a false `undeclared`.
+ *
+ * Not the same six as dispatch.md's "Fingerprint the worktree around every
+ * judge" list, which swaps `auditor` for `uiux`: that section is about
+ * which judges run inside a task's worktree (auditor runs over a whole
+ * project at HEAD, never per-task, so a worktree fingerprint does not apply
+ * to it; uiux does run per-task). This list is about which roles owe a
+ * declared artifact and a blocked Stop, and `auditor` is one of them.
+ */
+export const JUDGE_ROLES = [
+    'reviewer',
+    'verifier',
+    'grader',
+    'spec-reviewer',
+    'security-reviewer',
+    'auditor',
+];
+const JUDGE_ROLE_SET = new Set(JUDGE_ROLES);
+const TURN_BUDGET_LINE = /Turn budget:[ \t]*(\S*)/g;
+/**
+ * `Turn budget: <n>` in a dispatch prompt — mid-sentence or on its own
+ * line, since a dispatch's leading line names the role and the budget in
+ * one breath ("Role: coder. Turn budget: 40 ..."). Null for no occurrence,
+ * more than one (two numbers is no number), or a value that is not a bare
+ * non-negative integer — every one of those is "cannot state a turn count",
+ * not "states zero".
+ */
+export function parseStatedTurns(prompt) {
+    const matches = [...prompt.matchAll(TURN_BUDGET_LINE)];
+    if (matches.length !== 1)
+        return null;
+    const raw = matches[0]?.[1] ?? '';
+    return /^[0-9]+$/.test(raw) ? Number(raw) : null;
+}
+const DECLARED_ARTIFACT_LINE = /^Declared artifact:[ \t]*(\S+)[ \t]*$/m;
+/** `Declared artifact: <path>` in a dispatch prompt, or null when the line is not there. */
+export function parseDeclaredArtifactLine(prompt) {
+    const match = DECLARED_ARTIFACT_LINE.exec(prompt);
+    return match?.[1] ?? null;
+}
+/** The line a dispatch is expected to carry verbatim, given the ledger's declared path. */
+export function formatDeclaredArtifactLine(artifactPath) {
+    return `Declared artifact: ${artifactPath}`;
+}
+function checkTurns(prompt, role, agentsDir) {
+    const stated = parseStatedTurns(prompt);
+    const template = readTemplateMaxTurns(agentsDir, role) ?? null;
+    if (template === null)
+        return { status: 'unverifiable', stated, template: null };
+    if (stated === null)
+        return { status: 'missing', stated: null, template };
+    if (stated === template)
+        return { status: 'ok', stated, template };
+    return { status: stated < template ? 'under' : 'over', stated, template };
+}
+async function checkArtifact(prompt, role, taskId, sessionId, eventOpts) {
+    if (!JUDGE_ROLE_SET.has(role)) {
+        return { status: 'not-applicable', expected_line: null, declared_line: null };
+    }
+    const declaredLine = parseDeclaredArtifactLine(prompt);
+    const turns = await readJudgeTurns(taskId, { sessionId }, eventOpts);
+    const turn = turns.find((t) => t.role === role);
+    if (turn === undefined) {
+        return { status: 'undeclared', expected_line: null, declared_line: declaredLine };
+    }
+    const expectedLine = formatDeclaredArtifactLine(turn.declaredArtifact);
+    if (declaredLine === null) {
+        return { status: 'missing', expected_line: expectedLine, declared_line: null };
+    }
+    if (declaredLine === turn.declaredArtifact) {
+        return { status: 'ok', expected_line: expectedLine, declared_line: declaredLine };
+    }
+    if (!path.isAbsolute(declaredLine)) {
+        return { status: 'relative', expected_line: expectedLine, declared_line: declaredLine };
+    }
+    return { status: 'mismatch', expected_line: expectedLine, declared_line: declaredLine };
+}
+// Fail closed: every status but "ok" exits non-zero, including "under" (a
+// prompt that understates the template's budget still disagrees with it) and
+// "unverifiable" (an unreadable template is not a pass, exactly like `dispatch
+// check`, `tester check`, `delegation check`, and `escalation check` already
+// treat "cannot tell" as a failure, never a maybe).
+const TURNS_FAIL = new Set(['under', 'over', 'missing', 'unverifiable']);
+const ARTIFACT_FAIL = new Set([
+    'missing',
+    'relative',
+    'mismatch',
+    'undeclared',
+]);
+/**
+ * Lint one dispatch prompt. Never throws on a bad prompt — a bad prompt is
+ * exactly the finding this reports — only on a missing task/session (the
+ * caller's own mistake, same as every other verb that reads the ledger).
+ */
+export async function lintDispatchPrompt(input) {
+    const agentsDir = input.agentsDir ?? AGENTS_DIR;
+    const eventOpts = input.eventOpts ?? {};
+    const turns = checkTurns(input.prompt, input.role, agentsDir);
+    const artifact = await checkArtifact(input.prompt, input.role, input.taskId, input.sessionId, eventOpts);
+    const exitCode = TURNS_FAIL.has(turns.status) || ARTIFACT_FAIL.has(artifact.status) ? 1 : 0;
+    return { turns, artifact, exitCode };
+}