@astrosheep/keiyaku 4.5.24 → 4.5.26

package/build/src/akuma/publication.js

@@ -185,8 +185,11 @@ async function settleLaunch(allocated, owned, failure) {
         throw new Error("Akuma birth settled without a seal");
     return "sealed";
 }
-async function awaitAsleepBirth(paths) {
-    const leash = await acquireLeash(paths, { deadline: performance.now() + BIRTH_TIMEOUT_MS });
+async function awaitAsleepBirth(paths, signal) {
+    const leash = await acquireLeash(paths, {
+        deadline: performance.now() + BIRTH_TIMEOUT_MS,
+        ...(signal === undefined ? {} : { signal }),
+    });
     if (leash === null)
         throw new Error("Forked Akuma did not finish its birth body");
     try {
@@ -241,7 +244,7 @@ export async function launchAkuma(input) {
         if (soul.id !== allocated.id)
             throw new Error("Akuma birth returned a different identity");
         if (input.awaitAsleep === true)
-            await awaitAsleepBirth(allocated.paths);
+            await awaitAsleepBirth(allocated.paths, input.signal);
         owned?.release();
         return allocated;
     }
@@ -256,7 +259,7 @@ export async function launchAkuma(input) {
             }
             if (outcome === "born" && input.signal?.aborted && error === input.signal.reason) {
                 if (input.awaitAsleep === true)
-                    await awaitAsleepBirth(allocated.paths);
+                    await awaitAsleepBirth(allocated.paths, input.signal);
                 return allocated;
             }
             throw error;

package/build/src/akuma-body.js

@@ -93,6 +93,7 @@ function fleetRequestPort(world) {
             schema: Schema.json(JSON.parse(input.schemaJson), (value) => value),
             ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            signal: input.signal,
         }),
         kill: async (input) => {
             const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -99,6 +99,7 @@ type InvokeInput = Readonly<{
     environment: NodeJS.ProcessEnv;
     readStdin(): Promise<string>;
     execution?: ExecutionContext;
+    signal?: AbortSignal;
 }>;
 export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
 export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;

package/build/src/cli/commands/akuma-invoke.js

@@ -13,6 +13,9 @@ import { executionChannel } from "../../akuma/requests.js";
 import { requestForwardedFleetTellAnswer } from "../../akuma/fleet-request.js";
 /** The window a call observes for when the caller gives no `--wait` duration. */
 const CALL_TIMEOUT_MS = 300_000;
+function callSignalOption(signal) {
+    return signal === undefined ? {} : { signal };
+}
 function integrationFailure(error) {
     return {
         kind: error instanceof AuthorityCorruptionError ? "authority-corruption" : "infrastructure",
@@ -39,20 +42,23 @@ function writeProgress(body) {
 async function observeCallUntilComplete(command, input, born) {
     const stream = callObservationStream(resultContext(), callObservationHead(born));
     try {
-        const status = await observeAkumaStatus(input.path, born.akuma, {
+        const observed = await observeAkumaStatus(input.path, born.akuma, {
             timeoutMs: command.timeoutMs ?? CALL_TIMEOUT_MS,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
             observe: (observed) => {
                 const lines = stream.observe(observed);
                 if (lines.length > 0)
                     writeProgress(lines.join("\n"));
             },
         });
-        const conclusion = stream.conclude({ kind: "observed", status });
+        const conclusion = stream.conclude({ kind: "observed", reason: observed.reason, status: observed.status });
         if (conclusion.length > 0)
             writeProgress(conclusion);
-        return { kind: "observed", status };
+        return { kind: "observed", reason: observed.reason, status: observed.status };
     }
     catch (error) {
+        if (input.signal?.aborted)
+            throw error;
         const failure = integrationFailure(error);
         const conclusion = stream.conclude({ kind: "failed", failure });
         if (conclusion.length > 0)
@@ -111,6 +117,7 @@ async function invokeWait(command, input) {
         ...(input.repo === undefined ? {} : { repo: input.repo }),
         ...(command.completion === undefined ? {} : { completion: command.completion }),
         ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
     }, input.execution ?? localExecutionContext(), observer);
     const frozen = {
         startedAt,
@@ -177,11 +184,13 @@ async function invokeTell(command, input) {
                 schema,
                 interrupt: command.interrupt,
                 ...initiator,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
             })
             : await Akuma.select(addressed.path, addressed.id).tell(body, {
                 schema,
                 ...initiator,
                 ...(command.interrupt ? { interrupt: true } : {}),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
             });
         const alias = inputAlias(command.akuma);
         return {
@@ -201,6 +210,7 @@ async function invokeTell(command, input) {
             akuma: command.akuma,
             body,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
         const alias = inputAlias(command.akuma);
         return {
@@ -218,6 +228,7 @@ async function invokeTell(command, input) {
         akuma: command.akuma,
         body,
         ...(input.repo === undefined ? {} : { repo: input.repo }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
     }, input.execution ?? localExecutionContext());
     const alias = inputAlias(command.akuma);
     return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
@@ -269,6 +280,7 @@ async function invokeKill(command, input) {
             path: input.path,
             akuma: command.akuma,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
         }, input.execution ?? localExecutionContext()),
         ...(alias === undefined ? {} : { alias }),
     };
@@ -291,6 +303,7 @@ export async function invokeAkuma(command, input) {
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
                 ...(schema === undefined ? {} : { schema }),
+                ...callSignalOption(input.signal),
             };
             const observing = schema === undefined && command.mode === "wait" && command.output === "text";
             const born = await caller.call(observing

package/build/src/cli/invoke.js

@@ -140,6 +140,7 @@ async function invokeAkumaFromEdge(parsed, input) {
             environment: edge.environment,
             readStdin: edge.readStdin,
             execution: input.execution,
+            ...(edge.signal === undefined ? {} : { signal: edge.signal }),
         });
     }
     catch (error) {

package/build/src/cli/render/akuma-activity.d.ts

@@ -1,4 +1,4 @@
-import type { AkumaStatus, KillEvidence } from "../../akuma/akuma.js";
+import type { ActivityRow, AkumaStatus, KillEvidence } from "../../akuma/akuma.js";
 import type { CallObservation } from "../../library/akuma-creation.js";
 import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
@@ -13,6 +13,10 @@ export declare const DEFAULT_CONTEXT: TextRenderContext;
 export declare function frameRule(headLines: readonly string[]): string;
 type FleetTimeline = AkumaObservation["status"]["timeline"];
 type RenderedSnapshot = FleetTimeline;
+type RenderedActivity = Readonly<{
+    snapshot: RenderedSnapshot;
+    rows: readonly ActivityRow[];
+}>;
 export declare function associatedIdentity(id: string, alias?: string, _contract?: DispatchAssociation): string;
 export declare function snapshotHeading(id: string, alias: string | undefined, contract: DispatchAssociation | undefined): readonly string[];
 /**
@@ -34,9 +38,9 @@ export declare function snapshotActivityLines(snapshot: RenderedSnapshot, contex
     latest?: boolean;
 }>): readonly string[];
 /** One command's append-only activity view, with a baseline and a final tail flush. */
-export type ActivityStream = ((snapshot: RenderedSnapshot) => readonly string[]) & Readonly<{
-    /** Seed the sequence cursor without spending the command's live evidence budget. */
-    seed: (snapshot: RenderedSnapshot) => readonly string[];
+export type ActivityStream = ((activity: RenderedActivity) => readonly string[]) & Readonly<{
+    /** Establish a wait baseline without spending the command's live tool budget. */
+    seed: (activity: RenderedActivity) => readonly string[];
     /** Emit the deferred tail exactly once before the command's conclusion. */
     flush: () => readonly string[];
 }>;
@@ -50,6 +54,7 @@ export type ActivityStream = ((snapshot: RenderedSnapshot) => readonly string[])
 export declare function activityStream(context: TextRenderContext, layout?: RowLayout): ActivityStream;
 /** What a wait conclusion renders over: its observed and unobserved members. */
 export type WaitConclusionResult = Readonly<{
+    reason: "completed" | "deadline";
     observations: readonly AkumaObservation[];
     unobserved: readonly Readonly<{
         id: string;
@@ -93,7 +98,10 @@ export type ObservedCallHead = Readonly<{
     facts: readonly string[];
 }>;
 export type CallObservationStream = Readonly<{
-    observe: (status: AkumaStatus) => readonly string[];
+    observe: (observation: Readonly<{
+        status: AkumaStatus;
+        rows: readonly ActivityRow[];
+    }>) => readonly string[];
     conclude: (observation: CallObservation) => string;
     opened: () => boolean;
 }>;

package/build/src/cli/render/akuma-activity.js

@@ -1,4 +1,5 @@
 import { parseAkumaStatus } from "../../akuma/akuma.js";
+import { defaultWaitComplete } from "../../akuma/akuma-observe.js";
 import { toolRepr } from "./akuma-tool.js";
 import { displayColumns, renderBoundedTextBlock, safeText, takeDisplayColumns, truncateMiddleDisplayText, } from "./terminal.js";
 export const DEFAULT_CONTEXT = { columns: 80, color: false };
@@ -68,7 +69,7 @@ function label(row) {
     if (row.kind === "tell")
         return row.state === "told" ? "told" : "tell";
     if (row.kind === "outcome")
-        return row.outcome.kind === "answered" ? "say" : "error";
+        return row.outcome.kind === "answered" ? "answer" : "error";
     if (row.kind === "turn")
         return "call";
     if (row.kind !== "tool")
@@ -91,18 +92,6 @@ function mark(row) {
     }
     return "│";
 }
-/** Strip Markdown decoration from preview prose without rewriting the words. */
-function undecorated(text) {
-    return (text
-        .replace(/^ {0,3}#{1,6}[ \t]+/gmu, "")
-        .replace(/^ {0,3}(?:[-*+]|\d+\.)[ \t]+/gmu, "")
-        .replace(/\*\*([^*\n]+?)\*\*/gu, "$1")
-        // A single pair of asterisks is emphasis only when it does not sit inside a word, path, or glob.
-        .replace(/(?<![\w*/\\])\*([^\s*/\\](?:[^*/\\\n]*[^\s*/\\])?)\*(?![\w*/\\])/gu, "$1")
-        .replace(/`([^`\n]+?)`/gu, "$1")
-        .replace(/\s+/gu, " ")
-        .trim());
-}
 function rowText(row) {
     if (row.kind === "said" ||
         row.kind === "thought" ||
@@ -110,13 +99,13 @@ function rowText(row) {
         row.kind === "call" ||
         row.kind === "tell") {
         return {
-            text: undecorated(row.text),
+            text: row.text,
             lines: row.kind === "said" || row.kind === "thought" ? 2 : row.kind === "tell" || row.kind === "call" ? 1 : 2,
         };
     }
     if (row.kind === "outcome")
         return row.outcome.kind === "answered"
-            ? { text: undecorated(row.outcome.answer), lines: 3 }
+            ? { text: row.outcome.answer, lines: 3 }
             : { text: row.outcome.diagnostic, lines: 2 };
     if (row.kind === "turn")
         return { text: "", lines: 1 };
@@ -235,37 +224,21 @@ function orderedSnapshotEntries(snapshot) {
         entries.push({ kind: "row", row: snapshot.outcome });
     return entries;
 }
-/**
- * The current open turn starts from either its initial commission or a Tell
- * delivered when the Body launched it. A live Tell belongs to an already
- * pursuing turn and is not its boundary.
- */
-function currentTurnBoundary(snapshot) {
-    if (snapshot.kind !== "open")
+function currentTurnBoundary(activity) {
+    const snapshot = activity.snapshot;
+    if (snapshot.kind !== "open" || snapshot.openingSequence === undefined)
         return undefined;
-    const rows = snapshot.entries.flatMap((entry) => (entry.kind === "row" ? [entry.row] : []));
-    const wake = rows.findLast((row) => row.kind === "tell" &&
-        row.state === "told" &&
-        row.deliveries.some((delivery) => delivery.route === "launch" && delivery.turnSequence === snapshot.turn.turnSequence));
-    if (wake !== undefined)
-        return { row: wake, turnSequence: snapshot.turn.turnSequence };
-    const call = rows.find((row) => row.kind === "call" && row.turnSequence === snapshot.turn.turnSequence);
-    return call === undefined ? undefined : { row: call, turnSequence: snapshot.turn.turnSequence };
-}
-/** Move the visible current-turn boundary ahead of activity without duplicating it. */
-function boundaryFirstSnapshotEntries(snapshot) {
-    const entries = orderedSnapshotEntries(snapshot);
-    const boundary = currentTurnBoundary(snapshot);
-    if (boundary === undefined)
-        return entries;
-    return [
-        { kind: "row", row: boundary.row },
-        ...entries.filter((entry) => entry.kind !== "row" || entry.row !== boundary.row),
-    ];
+    const row = activity.rows.find((candidate) => candidate.sequence === snapshot.openingSequence);
+    if (row === undefined)
+        return undefined;
+    // The projector selects a typed opening: its call or delivered launch Tell.
+    if (row.kind !== "call" && !(row.kind === "tell" && row.state === "told"))
+        return undefined;
+    return { row, turnSequence: snapshot.turn.turnSequence };
 }
 /** Open status hides internal thought narration without selecting a second activity window. */
 function visibleOpenSnapshotEntries(snapshot) {
-    return boundaryFirstSnapshotEntries(snapshot).filter((entry) => entry.kind !== "row" || entry.row.kind !== "thought");
+    return snapshot.entries.filter((entry) => entry.kind !== "row" || entry.row.kind !== "thought");
 }
 /** Adjacent omitted spans are one continuous unknown portion of the retained timeline. */
 function coalesceAdjacentGaps(entries) {
@@ -294,25 +267,45 @@ export function snapshotActivityLines(snapshot, context, selection = {}) {
     const latest = entries.filter((entry) => entry.kind === "row").at(-1);
     return latest === undefined ? [] : groupedEntries([latest], context);
 }
-/**
- * One status' timeline without its conclusion: the newest open entry is still
- * moving, and an idle outcome is the command's final result rather than a
- * settled row.
- */
-function settledTimeline(snapshot) {
-    switch (snapshot.kind) {
-        case "unborn":
-            return snapshot;
-        case "open":
-            return { ...snapshot, entries: snapshot.entries.slice(0, -1) };
-        case "idle": {
-            const { outcome: _outcome, ...rest } = snapshot;
-            return { ...rest, entries: snapshot.entries };
+function isSettledStreamRow(row) {
+    if (row.kind === "turn" || row.kind === "outcome")
+        return false;
+    if (row.kind === "tell")
+        return row.state === "told";
+    return row.kind !== "tool" || (row.state !== "active" && row.state !== "unsettled");
+}
+/** A pending Tell or active tool retains its sequence when it later becomes eligible. */
+function isMutableStreamRow(row) {
+    return (row.kind === "tell" && row.state === "pending") || (row.kind === "tool" && row.state === "active");
+}
+function settledRows(activity) {
+    return activity.rows.filter(isSettledStreamRow);
+}
+function isProtectedStreamRow(row) {
+    return row.kind === "said" || (row.kind === "tool" && row.call.kind === "fileChange");
+}
+function isBoundedStreamTool(row) {
+    return row.kind === "tool" && !isProtectedStreamRow(row);
+}
+function rememberMutableRows(state, activity) {
+    for (const row of activity.rows)
+        if (isMutableStreamRow(row))
+            state.mutableSequences.add(row.sequence);
+}
+/** A seeded wait counts its skipped settled companion evidence after its typed opening. */
+function baselineOmissionCount(activity, boundary) {
+    let afterBoundary = false;
+    let count = 0;
+    for (const row of activity.rows) {
+        if (!afterBoundary) {
+            if (row.sequence === boundary.row.sequence)
+                afterBoundary = true;
+            continue;
         }
+        if (isSettledStreamRow(row))
+            count += 1;
     }
-}
-function settledRows(snapshot) {
-    return orderedSnapshotEntries(settledTimeline(snapshot)).flatMap((entry) => entry.kind === "row" ? [entry.row] : []);
+    return count;
 }
 function renderStreamRow(state, row, lines, context, layout) {
     const at = clock(row.at);
@@ -333,7 +326,7 @@ function coalesceDeferredGaps(state) {
     }, []);
 }
 function omitOldestDeferredTool(state) {
-    const index = state.deferred.findIndex((entry) => entry.kind === "row" && entry.row.kind === "tool");
+    const index = state.deferred.findIndex((entry) => entry.kind === "row" && isBoundedStreamTool(entry.row));
     if (index === -1)
         throw new Error("activity tail lost its pending tool");
     state.deferred[index] = { kind: "gap", count: 1 };
@@ -343,7 +336,7 @@ function omitOldestDeferredTool(state) {
 function flushSafeActivityPrefix(state, lines, context, layout) {
     for (;;) {
         const first = state.deferred[0];
-        if (first === undefined || (first.kind === "row" && first.row.kind === "tool"))
+        if (first === undefined || (first.kind === "row" && isBoundedStreamTool(first.row)))
             return;
         if (first.kind === "row") {
             state.deferred.shift();
@@ -351,44 +344,55 @@ function flushSafeActivityPrefix(state, lines, context, layout) {
             continue;
         }
         const next = state.deferred[1];
-        if (next === undefined || (next.kind === "row" && next.row.kind === "tool"))
+        if (next === undefined || (next.kind === "row" && isBoundedStreamTool(next.row)))
             return;
         state.deferred.shift();
         lines.push(layout.marker(first.count));
     }
 }
-function renderCurrentTurnBoundary(state, snapshot, lines, context, layout) {
-    const boundary = currentTurnBoundary(snapshot);
+function renderCurrentTurnBoundary(state, activity, lines, context, layout) {
+    const boundary = currentTurnBoundary(activity);
     if (boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence)) {
-        renderStreamRow(state, boundary.row, lines, context, layout);
         state.renderedBoundaries.add(boundary.turnSequence);
+        if (boundary.row.kind !== "thought")
+            renderStreamRow(state, boundary.row, lines, context, layout);
     }
     return boundary;
 }
-function observeActivitySnapshot(state, snapshot, context, layout) {
+function observeActivitySnapshot(state, activity, context, layout) {
     const lines = [];
-    const boundary = renderCurrentTurnBoundary(state, snapshot, lines, context, layout);
-    const rows = settledRows(snapshot)
-        .filter((row) => row !== boundary?.row)
-        .filter((row) => state.newestSequence === undefined || row.sequence > state.newestSequence)
-        // Thoughts remain retained activity, but are ineligible for default live progress.
-        .filter((row) => row.kind !== "thought");
-    if (rows.length === 0)
+    const boundary = currentTurnBoundary(activity);
+    rememberMutableRows(state, activity);
+    // A row newly selected as this Turn's typed opening must still respect the
+    // settled cursor, even if its earlier pending form was remembered as mutable.
+    if (boundary !== undefined)
+        state.mutableSequences.delete(boundary.row.sequence);
+    const observedRows = settledRows(activity)
+        .filter((row) => boundary === undefined ||
+        !state.renderedBoundaries.has(boundary.turnSequence) ||
+        row.sequence !== boundary.row.sequence)
+        .filter((row) => state.mutableSequences.has(row.sequence) ||
+        state.newestSettledSequence === undefined ||
+        row.sequence > state.newestSettledSequence);
+    if (observedRows.length === 0)
         return lines;
-    state.newestSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), state.newestSequence ?? rows[0].sequence);
+    for (const row of observedRows)
+        state.mutableSequences.delete(row.sequence);
+    state.newestSettledSequence = observedRows.reduce((newest, row) => Math.max(newest, row.sequence), state.newestSettledSequence ?? observedRows[0].sequence);
+    const rows = observedRows.filter((row) => row.kind !== "thought");
     for (const row of rows) {
-        if (row.kind === "tool" && state.openingTools < OPENING_TOOL_BUDGET) {
+        if (isBoundedStreamTool(row) && state.openingTools < OPENING_TOOL_BUDGET) {
             state.openingTools += 1;
             renderStreamRow(state, row, lines, context, layout);
             continue;
         }
-        if (row.kind !== "tool" && state.deferred.length === 0) {
+        if (!isBoundedStreamTool(row) && state.deferred.length === 0) {
             renderStreamRow(state, row, lines, context, layout);
             continue;
         }
         state.deferred.push({ kind: "row", row });
-        if (row.kind === "tool") {
-            const pendingTools = state.deferred.filter((entry) => entry.kind === "row" && entry.row.kind === "tool").length;
+        if (isBoundedStreamTool(row)) {
+            const pendingTools = state.deferred.filter((entry) => entry.kind === "row" && isBoundedStreamTool(entry.row)).length;
             if (pendingTools > RECENT_TOOL_BUDGET)
                 omitOldestDeferredTool(state);
         }
@@ -416,31 +420,45 @@ function flushActivityTail(state, context, layout) {
  */
 export function activityStream(context, layout = plainLayout()) {
     const state = {
-        newestSequence: undefined,
+        newestSettledSequence: undefined,
+        mutableSequences: new Set(),
         previousClock: undefined,
         renderedBoundaries: new Set(),
         openingTools: 0,
         deferred: [],
     };
-    const seed = (snapshot) => {
+    const seed = (activity) => {
         const lines = [];
-        renderCurrentTurnBoundary(state, snapshot, lines, context, layout);
-        const rows = settledRows(snapshot);
+        const boundary = currentTurnBoundary(activity);
+        const unseenBoundary = boundary !== undefined && !state.renderedBoundaries.has(boundary.turnSequence);
+        if (unseenBoundary) {
+            renderCurrentTurnBoundary(state, activity, lines, context, layout);
+            const omitted = baselineOmissionCount(activity, boundary);
+            if (omitted > 0)
+                lines.push(layout.marker(omitted));
+        }
+        rememberMutableRows(state, activity);
+        const rows = settledRows(activity);
         if (rows.length > 0)
-            state.newestSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), rows[0].sequence);
+            state.newestSettledSequence = rows.reduce((newest, row) => Math.max(newest, row.sequence), rows[0].sequence);
         return lines;
     };
-    const observe = (snapshot) => observeActivitySnapshot(state, snapshot, context, layout);
+    const observe = (activity) => observeActivitySnapshot(state, activity, context, layout);
     const flush = () => flushActivityTail(state, context, layout);
     return Object.assign(observe, { seed, flush });
 }
 function conclusionMarkVerb(status, answered) {
-    if (status.life === "running")
-        return { mark: "●", verb: "still running" };
+    if (failedOutcomeDiagnostic(status) !== undefined)
+        return { mark: "!", verb: "failed" };
     if (answered)
         return { mark: "✓", verb: "answered" };
+    if (status.life === "running")
+        return { mark: "●", verb: "still running" };
+    if (!defaultWaitComplete(status)) {
+        return { mark: "⧗", verb: "pending tell" };
+    }
     if (status.life === "asleep")
-        return { mark: "!", verb: "failed" };
+        return { mark: "✓", verb: "completed" };
     if (status.life === "killed")
         return { mark: "×", verb: "killed" };
     if (status.life === "hung")
@@ -525,10 +543,10 @@ function observeWaitRound(state, round, context, now) {
             lines.push(...snapshotHeading(sole.status.id, sole.alias, sole.contract));
         }
     }
-    for (const { status } of round) {
+    for (const { status, rows } of round) {
         const known = state.streams.get(status.id);
         if (known !== undefined) {
-            lines.push(...known(status.timeline));
+            lines.push(...known({ snapshot: status.timeline, rows }));
         }
         else {
             // Only a plural wait attributes its rows; a single-target stream keeps the plain row grammar.
@@ -536,10 +554,10 @@ function observeWaitRound(state, round, context, now) {
                 ? sourceLayout(state.sources.get(status.id) ?? status.id, () => state.sourceWidth)
                 : plainLayout());
             state.streams.set(status.id, stream);
-            // A wait starts at the current settled frontier: its backlog is neither evidence nor budget.
-            lines.push(...stream.seed(status.timeline));
+            // Seed marks skipped retained evidence without spending this command's live tool budget.
+            lines.push(...stream.seed({ snapshot: status.timeline, rows }));
         }
-        if (!state.settledAt.has(status.id) && waitComplete(status))
+        if (!state.settledAt.has(status.id) && defaultWaitComplete(status))
             state.settledAt.set(status.id, settleMoment(status) ?? now());
     }
     return lines;
@@ -574,13 +592,6 @@ function orderedWaitIds(state, result) {
 }
 function concludeWaitStream(state, result, startedAt, now) {
     const tail = [];
-    // The returned observation can be newer than the final callback. Advance every known stream
-    // before flushing it, while still flushing members that became unobserved at the end.
-    for (const observation of result.observations) {
-        const stream = state.streams.get(observation.status.id);
-        if (stream !== undefined)
-            tail.push(...stream(observation.status.timeline));
-    }
     for (const stream of state.streams.values())
         tail.push(...stream.flush());
     const end = now();
@@ -598,7 +609,7 @@ function concludeWaitStream(state, result, startedAt, now) {
         if (observation === undefined)
             return [];
         const status = observation.status;
-        const complete = waitComplete(status);
+        const complete = defaultWaitComplete(status);
         const at = complete ? (state.settledAt.get(id) ?? end) : end;
         const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
         const target = multi ? ` ${padToDisplay(state.sources.get(id) ?? id, state.sourceWidth)}` : "";
@@ -659,17 +670,15 @@ export function callObservationStream(context, head, options = {}) {
         opened = true;
         lines.push(...snapshotHeading(head.id, head.alias, head.contract), ...head.facts);
     };
-    const observe = (status) => {
+    const observe = (observation) => {
         const lines = [];
         open(lines);
-        lines.push(...stream(status.timeline));
+        lines.push(...stream({ snapshot: observation.status.timeline, rows: observation.rows }));
         return lines;
     };
     const conclude = (observation) => {
         const lines = [];
         open(lines);
-        if (observation.kind === "observed")
-            lines.push(...stream(observation.status.timeline));
         lines.push(...stream.flush());
         if (observation.kind === "failed") {
             lines.push(`! error ${safeText(observation.failure.diagnostic)}`);
@@ -680,7 +689,7 @@ export function callObservationStream(context, head, options = {}) {
         const end = now();
         const status = observation.status;
         const answered = statusAnswer({ status }) !== undefined;
-        const complete = waitComplete(status);
+        const complete = defaultWaitComplete(status);
         const at = complete ? (settleMoment(status) ?? end) : end;
         const { mark, verb } = conclusionMarkVerb(status, answered);
         lines.push(`${clockFromMs(at)} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`);
@@ -798,7 +807,7 @@ export function mutationObservationStageText(id, observation, context, options =
     return mutationSnapshotText(observation, context, options);
 }
 export function statusAnswer(view) {
-    if (!waitComplete(view.status))
+    if (!defaultWaitComplete(view.status))
         return undefined;
     if (view.status.life !== "asleep")
         return undefined;
@@ -809,10 +818,6 @@ export function statusAnswer(view) {
         return undefined;
     return timeline.outcome.outcome.answer;
 }
-function waitComplete(status) {
-    return (status.life !== "running" &&
-        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
-}
 function answerCallFailed(result) {
     return result.dispatch.kind === "failed" || result.alias.kind === "failed" || result.readonly?.enforcement === "none";
 }
@@ -835,7 +840,8 @@ export function akumaRawAnswer(result) {
             const single = total === 1 ? result.result.observations[0] : undefined;
             return single === undefined ? "" : (statusAnswer(single) ?? "");
         }
-        if (result.result.observations.length === 1)
+        const total = result.result.observations.length + result.result.unobserved.length;
+        if (total === 1)
             return statusAnswer(result.result.observations[0]);
     }
     if (result.action === "history" && result.mode === "exact" && result.historyResult.kind === "exact") {
@@ -906,7 +912,7 @@ export function waitText(result, context) {
         if (observation === undefined)
             return [];
         const status = observation.status;
-        const complete = waitComplete(status);
+        const complete = defaultWaitComplete(status);
         const at = complete ? (settleMoment(status) ?? end) : end;
         const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined);
         return [

package/build/src/cli/render/akuma-tool.js

@@ -52,15 +52,17 @@ function searchText(call) {
         ...(call.glob === undefined ? [] : [oneLine(call.glob)]),
     ].join(" · ");
 }
-function fileChange(call) {
+function fileChange(call, state) {
     const first = call.changes[0];
     if (first === undefined)
         return { label: "edit", text: "files" };
     const label = call.changes.length === 1 ? (first.op === "add" ? "write" : first.op === "delete" ? "delete" : "edit") : "edit";
     const subject = call.changes.length === 1 ? oneLine(first.path) : `${call.changes.length} files · ${oneLine(first.path)} ...`;
     const complete = call.changes.every((change) => change.diffstat !== undefined);
-    if (!complete)
+    if (!complete && (state === "active" || state === "unsettled"))
         return { label, text: subject };
+    if (!complete)
+        return { label, text: `${subject} — +? -?` };
     const totals = call.changes.reduce((sum, change) => ({
         added: sum.added + change.diffstat.added,
         removed: sum.removed + change.diffstat.removed,
@@ -85,7 +87,7 @@ export function toolRepr(row) {
             core = { label: searchLabel(row.call.scope), text: searchText(row.call) };
             break;
         case "fileChange":
-            core = fileChange(row.call);
+            core = fileChange(row.call, row.state);
             break;
         case "other":
             core = { label: "use", text: oneLine(row.call.display || row.name) };