@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/orchestrator/dist/symbols.js

@@ -539,6 +539,250 @@ function findFromSpecifier(masked, from, to) {
 function normalizeSignature(text) {
     return text.trim().replace(/\s+/g, ' ');
 }
+/** Type words after which a `{` opens an object type, as it does after `:`. */
+const TYPE_OPERATORS = new Set([
+    'is',
+    'extends',
+    'keyof',
+    'readonly',
+    'new',
+    'abstract',
+]);
+/**
+ * Whether the group `open`…`close` reads as a function type's parameters, as
+ * TypeScript decides it: empty, a rest parameter, or a name or binding pattern
+ * followed by `:`, `,`, `?`, `=` or the `)`. `(A | B)` is a parenthesised type.
+ */
+function isTypeParameterList(masked, open, close) {
+    const first = skipSpace(masked, open + 1);
+    if (first === close || masked.startsWith('...', first))
+        return true;
+    const ch = masked.charAt(first);
+    let after = first + readIdent(masked, first).length;
+    if (ch === '{' || ch === '[')
+        after = matchBracket(masked, first, close) + 1;
+    return after > first && ':,?=)'.includes(masked.charAt(skipSpace(masked, after)));
+}
+/**
+ * The index just past the template literal opening at `open`. Its text is
+ * already blanked, so the next backtick closes it, and a `${` interpolation
+ * is stepped over as a bracket group. An unclosed one runs to `limit`.
+ */
+function skipTemplate(masked, open, limit) {
+    let i = open + 1;
+    while (i < limit) {
+        const ch = masked.charAt(i);
+        if (ch === '`')
+            return i + 1;
+        if (ch === '$' && masked.charAt(i + 1) === '{') {
+            const close = matchBracket(masked, i + 1, limit);
+            if (close === -1)
+                return limit;
+            i = close + 1;
+        }
+        else
+            i += 1;
+    }
+    return limit;
+}
+/**
+ * Walk a return-type annotation (`from` is just past its `:`) and answer where
+ * it stops: the index of the function body's `{`, the index of the `=>`,
+ * `limit` when the type runs to it, or -1 when what follows the `:` is not a
+ * return type at all (a ternary branch, say). A `{` directly after `:`, `|`,
+ * `&`, `<`, `,`, `?`, a word in TYPE_OPERATORS or a function type's `=>` is an
+ * object type; a template literal type is skipped whole.
+ */
+function skipReturnType(masked, from, limit) {
+    let prev = ':';
+    let angle = 0;
+    let i = from;
+    while (i < limit) {
+        const ch = masked.charAt(i);
+        if (/\s/.test(ch)) {
+            i += 1;
+            continue;
+        }
+        if (ch === '`') {
+            // A template literal type is skipped whole: its `${…}` braces are not a body.
+            i = skipTemplate(masked, i, limit);
+            prev = 'a';
+            continue;
+        }
+        if (ch === '=' && masked.charAt(i + 1) === '>')
+            return i;
+        if (ch === '{' && !':|&<,?'.includes(prev))
+            return i;
+        if (ch === '{' || ch === '(' || ch === '[') {
+            const close = matchBracket(masked, i, limit);
+            if (close === -1)
+                return -1;
+            const arrow = skipSpace(masked, close + 1);
+            const functionType = ch === '(' &&
+                ':|&<,?>'.includes(prev) &&
+                masked.startsWith('=>', arrow) &&
+                isTypeParameterList(masked, i, close);
+            // A function type's `=>` is not the arrow function's; its return type follows.
+            i = functionType ? arrow + 2 : close + 1;
+            prev = functionType ? ':' : ')';
+            continue;
+        }
+        if (isIdentStart(ch)) {
+            const word = readIdent(masked, i);
+            prev = prev !== '.' && TYPE_OPERATORS.has(word) ? ':' : 'a';
+            i += word.length;
+            continue;
+        }
+        if (ch === '<')
+            angle += 1;
+        else if (ch === '>')
+            angle -= 1;
+        else if (ch === ')' || ch === ']' || ch === '}' || ch === ';')
+            return -1;
+        else if (ch === ',' && angle <= 0)
+            return -1;
+        prev = ch;
+        i += 1;
+    }
+    return limit;
+}
+/**
+ * Whether the call opening at `open` is a class heritage, `extends mixin(Base) {`,
+ * whose `{` is a class body. It reads back from `open` only as far as the
+ * heritage name and the `extends` before it, never to `start`.
+ */
+function isHeritageCall(masked, start, open) {
+    let i = open;
+    while (i > start && /\s/.test(masked.charAt(i - 1)))
+        i -= 1;
+    const nameEnd = i;
+    while (i > start && /[\w$.]/.test(masked.charAt(i - 1)))
+        i -= 1;
+    const nameStart = i;
+    while (i > start && /\s/.test(masked.charAt(i - 1)))
+        i -= 1;
+    const keyword = i - 'extends'.length;
+    return (nameStart < nameEnd &&
+        i < nameStart &&
+        keyword >= start &&
+        masked.startsWith('extends', keyword) &&
+        (keyword === start || !/\w/.test(masked.charAt(keyword - 1))));
+}
+/** Words after `export default` that make it a declaration, not an expression. */
+const DEFAULT_DECLARATIONS = new Set([
+    'function',
+    'class',
+    'interface',
+    'abstract',
+    'async',
+]);
+/**
+ * Where the clause's value starts — just past the `=` of `export const|let|var`
+ * or past `default` in `export default <expression>` — or -1 for any other
+ * clause. Only a value can hold a function body: a declaration's own body
+ * lies past the clause, and an annotation, a type alias, an interface or a
+ * `declare` is all types, where a `{` after `=>` is an object type.
+ */
+function valueStart(masked, from, end) {
+    const at = skipSpace(masked, from);
+    const word = readIdent(masked, at);
+    if (word === 'default') {
+        const next = readIdent(masked, skipSpace(masked, at + word.length));
+        return DEFAULT_DECLARATIONS.has(next) ? -1 : at + word.length;
+    }
+    if (word !== 'const' && word !== 'let' && word !== 'var')
+        return -1;
+    let depth = 0;
+    for (let i = at + word.length; i < end; i += 1) {
+        const ch = masked.charAt(i);
+        if (ch === '=' && masked.charAt(i + 1) === '>')
+            i += 1;
+        else if ('([{<'.includes(ch))
+            depth += 1;
+        else if (')]}>'.includes(ch))
+            depth -= 1;
+        else if (ch === '=' && depth === 0)
+            return i + 1;
+    }
+    return -1;
+}
+/** What a function body reads as in a signature. */
+const BODY_PLACEHOLDER = '{…}';
+/**
+ * The value text an importer can see (`start` is from valueStart): every
+ * function body in it becomes a placeholder, so an edit inside a body is not a
+ * signature edit, while what follows a body (a `memo` comparator, an `as` cast,
+ * a chained call) still is. A body is the `{` right after a parameter list,
+ * after its return type, or after `=>`; any other brace is text. The scan steps
+ * over a parameter list and its return type once it finds the body or the
+ * `=>` after them, or when they run to the `{` that ends the clause (that body
+ * lies past `end`); any other parenthesised group, a call or a ternary branch,
+ * it reads into. Nothing past `end` is read, and an unmatched bracket keeps the
+ * text whole.
+ *
+ * Known limits, both rare: a function type with an object return inside a type
+ * argument or an `as` type within the value, `memo(forwardRef<R, (a: A) => { b: B }>(…))`
+ * or `memo(C as (p: P) => { a: A })`, reads its object type as a body; and a
+ * heritage that is not `extends name(…) {`, such as `extends mixin(A)(B) {`,
+ * `extends (c ? A : B) {` or `extends mixin<T>(Base) {`, has its class body
+ * read as a function body.
+ */
+function signatureText(source, masked, start, end) {
+    let text = '';
+    let kept = start;
+    let i = start;
+    while (i < end) {
+        const ch = masked.charAt(i);
+        let body = -1;
+        if (ch === '=' && masked.charAt(i + 1) === '>') {
+            const next = skipSpace(masked, i + 2);
+            if (next >= end || masked.charAt(next) !== '{') {
+                i = next;
+                continue;
+            }
+            body = next;
+        }
+        else if (ch === '(') {
+            const close = matchBracket(masked, i, end);
+            if (close === -1)
+                return source.slice(start, end);
+            const after = skipSpace(masked, close + 1);
+            const next = after < end ? masked.charAt(after) : '';
+            const stop = next === ':' ? skipReturnType(masked, after + 1, end) : after;
+            if (stop >= end && masked.charAt(end) === '{') {
+                // The `{` that ends the clause is this function's body: keep its parameters whole.
+                i = end;
+                continue;
+            }
+            if (next === '{' && !isHeritageCall(masked, start, i))
+                body = after;
+            else if (next === '=' && masked.charAt(after + 1) === '>') {
+                i = after;
+                continue;
+            }
+            else if (next === ':' && stop !== -1 && stop < end) {
+                if (masked.charAt(stop) === '{')
+                    body = stop;
+                else {
+                    i = stop;
+                    continue;
+                }
+            }
+        }
+        if (body === -1) {
+            // A call, a group or plain text: look inside it.
+            i += 1;
+            continue;
+        }
+        const close = matchBracket(masked, body, end);
+        if (close === -1)
+            return source.slice(start, end);
+        text += source.slice(kept, body) + BODY_PLACEHOLDER;
+        kept = close + 1;
+        i = kept;
+    }
+    return text + source.slice(kept, end);
+}
 /**
  * Record the declaration text against every export the clause introduced.
  * Wrapping is what keeps this honest: the clause parsers below push export
@@ -548,7 +792,15 @@ function normalizeSignature(text) {
 function readClauseFacts(source, masked, start, clause, keyword, facts) {
     const before = facts.exports.length;
     readClauseExports(source, masked, start, clause, keyword, facts);
-    const signature = normalizeSignature(source.slice(start, clause.textEnd));
+    // An import introduces no export, so it has no signature to read.
+    if (facts.exports.length === before)
+        return;
+    const end = clause.textEnd;
+    const value = valueStart(masked, start + keyword.length, end);
+    const text = value === -1
+        ? source.slice(start, end)
+        : source.slice(start, value) + signatureText(source, masked, value, end);
+    const signature = normalizeSignature(text);
     for (let i = before; i < facts.exports.length; i += 1) {
         const name = facts.exports[i];
         if (name !== undefined)
@@ -664,13 +916,16 @@ function readStatementClauses(source, masked, facts) {
         i += 1;
     }
 }
-function matchParen(masked, open) {
+/** Index of the bracket closing the one at `open`, before `limit`; -1 when unclosed. */
+function matchBracket(masked, open, limit = masked.length) {
+    const opener = masked.charAt(open);
+    const closer = opener === '{' ? '}' : opener === '[' ? ']' : ')';
     let depth = 0;
-    for (let i = open; i < masked.length; i += 1) {
+    for (let i = open; i < limit; i += 1) {
         const ch = masked.charAt(i);
-        if (ch === '(')
+        if (ch === opener)
             depth += 1;
-        else if (ch === ')') {
+        else if (ch === closer) {
             depth -= 1;
             if (depth === 0)
                 return i;
@@ -683,7 +938,7 @@ function readDynamicImports(source, masked, facts) {
     let match = pattern.exec(masked);
     while (match !== null) {
         const open = match.index + match[0].length - 1;
-        const close = matchParen(masked, open);
+        const close = matchBracket(masked, open);
         const inner = close === -1 ? masked.length : close;
         const quoteStart = skipSpace(masked, open + 1);
         const quote = masked.charAt(quoteStart);

package/factory/orchestrator/dist/taskEvents.js

@@ -1,6 +1,8 @@
 import { appendEdge, appendEvent, readLineageEvents, } from './events.js';
 import { resolveTaskId } from './plan.js';
-import { taskBranchName } from './worktree.js';
+import { epicOfTaskId, taskIdsMatch } from './taskId.js';
+import { CLOSED_TO_FURTHER_WORK } from './taskStatus.js';
+import { BRANCH_PREFIX, epicBranchPrefix, taskBranchName } from './worktree.js';
 function envelope(ctx, eventType, payload, taskId) {
     return {
         session_id: ctx.sessionId,
@@ -22,7 +24,7 @@ function envelope(ctx, eventType, payload, taskId) {
  * emitTasksAdded, which used it for the epic id and the task specs and let the
  * project fall on the floor. Every event of a demo-rpg run therefore landed
  * with no project at all, and db/queries.ts's projectOf() resolves an absent
- * one to the default: a whole epic filed under black-smith, missing from the
+ * one to the default: a whole epic filed under blacksmith, missing from the
  * board of the project it was actually part of.
  *
  * The plan is the fallback and not an override, because a caller holding a
@@ -34,7 +36,7 @@ function planScoped(ctx, plan) {
     const project = ctx.project ?? plan.project;
     return project === undefined ? ctx : { ...ctx, project };
 }
-function addedPayload(plan, task) {
+function addedPayload(plan, task, branchPrefix) {
     const budget = task.budget;
     // A task spec is a `Record<string, unknown>`, so its `epic_id` is only a
     // string by convention. `taskBranchName` needs a real one, and a task
@@ -47,14 +49,20 @@ function addedPayload(plan, task) {
         task_status: task.task_status,
         plan_version: task.plan_version,
         objective: task.objective,
+        title: typeof task.title === 'string' ? task.title : undefined,
+        summary: typeof task.summary === 'string' ? task.summary : undefined,
         claims: task.claims,
         budget_tokens: budget?.tokens,
         // D-23/P9-12. Declared here rather than derived by the reader: the board
         // wants a branch link the moment a task is added, which is well before a
         // worktree exists, and worktree.ts's convention is the one that decides
-        // what `smith worktree create` will actually cut. Reading it off the same
-        // function that creates it means the two cannot say different things.
-        branch: taskBranchName(epicId, task.task_id),
+        // what `smith worktree create` will actually cut. `branchPrefix` is
+        // `epicBranchPrefix`'s answer for this epic when `emitTasksAdded` was
+        // handed a project dir (a legacy `smith/<epic>/integration` keeps this
+        // epic's new branches there too), or the plain `bs` default otherwise —
+        // the same choice `worktree create` makes, so the two cannot say
+        // different things.
+        branch: taskBranchName(epicId, task.task_id, branchPrefix),
     };
 }
 /**
@@ -108,6 +116,48 @@ async function addedPlanVersions(ctx, opts) {
     }
     return highest;
 }
+/**
+ * The plan record `plan amend` carries for a task only the log added, when it
+ * supersedes that task: a dead (`superseded`) record under the task's own id,
+ * so the next plan version can say what the log alone could not and
+ * `plan ingest` has a record to emit `task-superseded` from.
+ *
+ * Built from the `task-added` payload where it speaks (objective, claims,
+ * case, origin, title, summary, `budget_tokens`) and from honest placeholders
+ * where the schema demands a field a follow-up never carried
+ * (`output_schema_ref`, acceptance criteria, contract clauses, `diff_lines`):
+ * the record is never dispatched, only has to validate. `ui_affecting: false`
+ * is set for the same reason; the UI-path rule asks every record claiming one
+ * to say so, and this one will never change a screen. `claims` is passed
+ * through as written, so a payload with unreadable claims fails the plan's own
+ * validation and the amendment is refused, rather than a claim being invented.
+ */
+export function supersededStubFromLog(added, epicId, planVersion) {
+    const p = added.payload;
+    const str = (v) => typeof v === 'string' && v !== '' ? v : undefined;
+    const tokens = p.budget_tokens;
+    const note = `Added by the event log; superseded by plan v${planVersion}.`;
+    return {
+        task_id: added.taskId,
+        epic_id: epicId,
+        plan_version: planVersion,
+        objective: str(p.objective) ?? note,
+        output_schema_ref: 'result.schema.json',
+        acceptance_criteria: [note],
+        claims: added.claims,
+        budget: {
+            tokens: typeof tokens === 'number' && Number.isInteger(tokens) && tokens >= 1 ? tokens : 1,
+            diff_lines: 1,
+        },
+        contract: { functional_clauses: [note], nonfunctional_clauses: [] },
+        case: str(p.case) ?? 'chore',
+        origin: str(p.origin) ?? 'user',
+        task_status: 'superseded',
+        ui_affecting: false,
+        ...(str(p.title) ? { title: str(p.title) } : {}),
+        ...(str(p.summary) ? { summary: str(p.summary) } : {}),
+    };
+}
 /**
  * Read the lineage's log as a register of tasks — every id a `task-added`
  * has introduced, with the claims it was introduced with.
@@ -144,6 +194,7 @@ ctx, opts = {}) {
             taskId: record.task_id,
             claims: record.payload?.claims,
             epicId: typeof epicId === 'string' ? epicId : undefined,
+            payload: record.payload ?? {},
         });
     }
     return [...byId.values()];
@@ -182,23 +233,14 @@ function specsToIngest(plan) {
     return specs;
 }
 /**
- * Write the plan's backlog into the log: one `task-added` per task id the
- * session has not already recorded, plus a `task-superseded` for any id the
- * plan has no live spec left for (a v(n+1) cut records that as plan state,
- * and the projector needs it as an event to reach the same conclusion).
- *
- * Per id, not per record — see `specsToIngest`. Emitting the dead copies too
- * would say two false things at once: that a task the plan still lists as
- * `todo` was superseded, and that a 5-task backlog is 13 tasks.
- *
- * Returns only the events it actually appended, so a caller can report "5
- * added, 0 already present" truthfully rather than guessing from the plan.
+ * The events an ingest of `plan` would still write into this lineage, in the
+ * order it writes them — the whole of `emitTasksAdded`'s decision, kept apart
+ * from the appending so a reader can ask the question without writing.
  */
-export async function emitTasksAdded(plan, ctx, opts = {}) {
+async function pendingIngest(plan, ctx, opts) {
     const added = await addedPlanVersions(ctx, opts);
     const superseded = await idsAlreadyEmitted('task-superseded', ctx, opts);
-    const scoped = planScoped(ctx, plan);
-    const written = [];
+    const pending = [];
     // The ids the plan marks as superseded-and-replaced: a dead record beside a
     // live one under the same id is how `draftNextVersion` records an amendment.
     const supersededIds = new Set(plan.tasks.filter((r) => r.task_status === 'superseded').map((r) => r.task_id));
@@ -216,19 +258,103 @@ export async function emitTasksAdded(plan, ctx, opts = {}) {
         // the number would re-add tasks whose spec never changed. The amendment's
         // own marker is what counts — an id the amendment touched carries a dead
         // record beside its live one, which is exactly what `supersededIds` holds.
+        //
+        // And only for a task that still HAS a live record. A task every record of
+        // which is dead (a log-added follow-up `plan amend` retired, or a renamed-
+        // away id) has no spec worth adding again; re-adding it as `superseded`
+        // would only repeat the row the log already holds.
         const amended = recorded !== undefined &&
+            task.task_status !== 'superseded' &&
             supersededIds.has(taskId) &&
             typeof liveVersion === 'number' &&
             liveVersion > recorded;
-        if (recorded === undefined || amended) {
-            written.push(await appendEvent(envelope(scoped, 'task-added', addedPayload(plan, task), taskId), opts));
-        }
+        if (recorded === undefined || amended)
+            pending.push({ task, eventType: 'task-added' });
         if (task.task_status === 'superseded' && !superseded.has(taskId)) {
-            written.push(await appendEvent(envelope(scoped, 'task-superseded', { epic_id: plan.epic_id }, taskId), opts));
+            pending.push({ task, eventType: 'task-superseded' });
         }
     }
+    return pending;
+}
+/**
+ * What `plan ingest` would still write for `plan` into this lineage — empty
+ * exactly when the plan in hand has been ingested. Read-only.
+ *
+ * #250. `wave check --session` admits against the log's task rows, and a plan
+ * version that was never ingested has rows the log does not know about, or
+ * rows at an older version, so a wave admitted from it is admitted against a
+ * backlog nobody recorded. Asked through the same decision `emitTasksAdded`
+ * makes, so "ingested" cannot mean one thing here and another at the ingest.
+ */
+export async function planIngestGaps(plan, ctx, opts = {}) {
+    const pending = await pendingIngest(plan, ctx, opts);
+    return pending.map(({ task, eventType }) => ({ taskId: task.task_id, eventType }));
+}
+/**
+ * Write the plan's backlog into the log: one `task-added` per task id the
+ * session has not already recorded, plus a `task-superseded` for any id the
+ * plan has no live spec left for (a v(n+1) cut records that as plan state,
+ * and the projector needs it as an event to reach the same conclusion).
+ *
+ * Per id, not per record — see `specsToIngest`. Emitting the dead copies too
+ * would say two false things at once: that a task the plan still lists as
+ * `todo` was superseded, and that a 5-task backlog is 13 tasks.
+ *
+ * Returns only the events it actually appended, so a caller can report "5
+ * added, 0 already present" truthfully rather than guessing from the plan.
+ *
+ * `projectDir` is optional: the CLI's `--project` flag. Given, the branch
+ * prefix each `task-added` declares is resolved once per epic via
+ * `epicBranchPrefix` — a legacy `smith/<epic>/integration` epic keeps landing
+ * `smith/...` here, matching what `worktree create` will actually cut.
+ * Absent, every task gets the plain `bs` default — correct for a brand-new
+ * epic, which has no worktree convention to ask git about yet.
+ */
+export async function emitTasksAdded(plan, ctx, opts = {}, projectDir) {
+    const scoped = planScoped(ctx, plan);
+    const written = [];
+    const branchPrefixes = new Map();
+    for (const { task, eventType } of await pendingIngest(plan, ctx, opts)) {
+        let payload;
+        if (eventType === 'task-added') {
+            const epicId = typeof task.epic_id === 'string' ? task.epic_id : plan.epic_id;
+            let prefix = branchPrefixes.get(epicId);
+            if (prefix === undefined) {
+                prefix = projectDir ? epicBranchPrefix(projectDir, epicId) : BRANCH_PREFIX;
+                branchPrefixes.set(epicId, prefix);
+            }
+            payload = addedPayload(plan, task, prefix);
+        }
+        else {
+            payload = { epic_id: plan.epic_id };
+        }
+        written.push(await appendEvent(envelope(scoped, eventType, payload, task.task_id), opts));
+    }
     return written;
 }
+/**
+ * The ids in `taskIds` a wave may not admit, read against the lineage's task
+ * rows: `missing` has no row at all, `terminal` has one whose `task_status`
+ * is closed to further work (CLOSED_TO_FURTHER_WORK: completed, superseded,
+ * waived). A `failed` or `escalated` task is terminal but still held by an
+ * operator, and the escalation ladder re-admits it, so it passes. Pure; the
+ * caller folds the rows and canonicalizes the ids.
+ *
+ * #250. A superseded id admitted by `wave check --session` went on to be
+ * dispatched, gated and merged as if it were live work.
+ */
+export function unadmissibleTasks(taskIds, statusOf) {
+    const missing = [];
+    const terminal = [];
+    for (const taskId of taskIds) {
+        const taskStatus = statusOf.get(taskId);
+        if (taskStatus === undefined)
+            missing.push(taskId);
+        else if (CLOSED_TO_FURTHER_WORK.has(taskStatus))
+            terminal.push({ taskId, taskStatus });
+    }
+    return { missing, terminal };
+}
 /** One arrow's identity in the log: who depends on whom, and in what sense. */
 function edgeKey(task, dependsOn, edgeType) {
     return `${task}\u0000${dependsOn}\u0000${edgeType}`;
@@ -366,6 +492,24 @@ export async function emitTaskBlocked(taskId, error, ctx, opts = {}) {
 export function followUpTaskId(epicId, fingerprint) {
     return `${epicId}/followup-${fingerprint.slice(0, 8)}`;
 }
+/** The one project the lineage stamped on `fromTaskId`'s events, or undefined. */
+function fromTaskProject(lineage, fromTaskId) {
+    if (fromTaskId === undefined)
+        return undefined;
+    const fromEpic = epicOfTaskId(fromTaskId);
+    const stamped = new Set();
+    for (const { record } of lineage) {
+        if (!record.project || !record.task_id || !taskIdsMatch(record.task_id, fromTaskId))
+            continue;
+        // A bare id does not say which epic it is in; a record that names another
+        // epic (task events carry `payload.epic_id`) belongs to another task.
+        const named = record.payload?.epic_id;
+        if (fromEpic !== null && typeof named === 'string' && named !== fromEpic)
+            continue;
+        stamped.add(record.project);
+    }
+    return stamped.size === 1 ? [...stamped][0] : undefined;
+}
 /**
  * Record a follow-up task for a finding no open task can own: the file's
  * owner already merged, two tasks claim it equally, or nobody claims it at
@@ -383,10 +527,18 @@ export function followUpTaskId(epicId, fingerprint) {
  * (epic.ts's clearedFollowUpFindings).
  */
 export async function emitFollowUpTask(input, ctx, opts = {}) {
-    const added = await idsAlreadyEmitted('task-added', ctx, opts);
-    if (added.has(input.taskId))
+    const lineage = await readLineageEvents(ctx.sessionId, opts);
+    if (lineage.some(({ record }) => record.event_type === 'task-added' && record.task_id === input.taskId)) {
         return null;
-    return appendEvent(envelope(ctx, 'task-added', {
+    }
+    // A follow-up is minted inside a wave, where no plan is at hand and the
+    // wave-runner stamps nothing. So the caller's project wins (a caller holding
+    // the plan passes its project here, planScoped's fallback), then the one
+    // the log already holds for the task the finding came from. Two different
+    // stamps on that task settle nothing: the envelope stays absent rather
+    // than picking one.
+    const project = ctx.project ?? fromTaskProject(lineage, input.fromTaskId);
+    return appendEvent(envelope(project === undefined ? ctx : { ...ctx, project }, 'task-added', {
         epic_id: input.epicId,
         case: 'bugfix',
         origin: 'escalation',

package/factory/orchestrator/dist/taskStatus.js

@@ -72,3 +72,17 @@ export const TERMINAL_OK_TASK_STATUSES = new Set(['completed', 'waived']);
  * parking silently on a task nobody is working.
  */
 export const HELD_OPEN_BY_AN_OPERATOR = new Set(['failed', 'escalated']);
+/**
+ * Task statuses that mean "this task's diff is closed to further work": the
+ * branch already landed (`completed`), the team already accepted the gap
+ * (`waived`), or a later plan version replaced the task outright
+ * (`superseded`).
+ *
+ * That is every terminal status except the ones an operator is still holding,
+ * subtracted here so the remainder is derived from the two rosters above
+ * rather than typed out as a third. Read by claims.ts (a finding about a
+ * closed task's files mints a follow-up) and by `wave check --session` (a
+ * closed task is refused admission; a held one is re-admitted by the
+ * escalation ladder).
+ */
+export const CLOSED_TO_FURTHER_WORK = new Set([...TERMINAL_TASK_STATUSES].filter((status) => !HELD_OPEN_BY_AN_OPERATOR.has(status)));

package/factory/orchestrator/dist/testerAudit.js

@@ -8,18 +8,37 @@ import { taskIdsMatch } from './taskId.js';
  */
 const TEST_GATE_EVENT = 'testgate-result';
 /**
- * How a dispatched agent's turn is recorded as over, and which payload field
- * names the role that ended it. Falling back to the record's `actor` is not a
- * nicety: the older half of the log names the role there and nowhere else,
- * and reading only the payload would report those runs as testers that never
- * reported — an `unverifiable` about evidence the log is holding.
+ * How a dispatched agent's turn is recorded as over, and which payload
+ * field(s) name the role that ended it, tried in order. Falling back to the
+ * record's `actor` is not a nicety: the older half of the log names the role
+ * there and nowhere else, and reading only the payload would report those
+ * runs as testers that never reported — an `unverifiable` about evidence the
+ * log is holding.
+ *
+ * `error-logged` tries `agent` before `agent_role`: this reader's own
+ * historical key first, `agent_role` (the dispatch's) as the fallback for a
+ * hand-written event that only carries that one — the same either-key
+ * reading delegation.ts and agents-registry.ts already give this event type.
+ * Each of the three readers keeps its own historical key first rather than
+ * all agreeing on one order, since `agent` and `agent_role` were each the
+ * only key some reader ever had for this event type before the other was
+ * added as a fallback.
  */
 const TERMINAL_ROLE_EVENTS = {
-    'task-result-recorded': 'agent',
-    'error-logged': 'agent',
-    'judge-reported': 'agent_role',
-    'judge-verdict': 'agent',
+    'task-result-recorded': ['agent'],
+    'error-logged': ['agent', 'agent_role'],
+    'judge-reported': ['agent_role'],
+    'judge-verdict': ['agent'],
 };
+/** The first of `keys` that names a non-empty string in `payload`, or null. */
+function firstPayloadString(payload, keys) {
+    for (const key of keys) {
+        const value = payloadString(payload, key);
+        if (value !== null)
+            return value;
+    }
+    return null;
+}
 function payloadString(payload, key) {
     const value = payload[key];
     return typeof value === 'string' && value.length > 0 ? value : null;
@@ -46,11 +65,11 @@ export function readTerminalRoleRecords(events) {
     const records = [];
     for (const stored of events) {
         const record = stored.record;
-        const field = TERMINAL_ROLE_EVENTS[record.event_type];
-        if (!field)
+        const fields = TERMINAL_ROLE_EVENTS[record.event_type];
+        if (!fields)
             continue;
         const payload = (record.payload ?? {});
-        const role = payloadString(payload, field) ?? record.actor;
+        const role = firstPayloadString(payload, fields) ?? record.actor;
         if (!role)
             continue;
         records.push({