@astrosheep/keiyaku 4.6.8 → 4.6.9

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

@@ -2,9 +2,8 @@ import type { AkumaStatus } from "../../akuma/akuma.js";
 import type { KillEvidence } from "../../akuma/heart/index.js";
 import type { ActivityRow } from "../../akuma/projection.js";
 import type { AkumaAskObservation, AkumaAskResult, AkumaTellResult, AkumaWaitResult } from "../../akuma/selection-observation.js";
-import type { AkumaObservation, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
+import type { AkumaObservation, CreatedDebtObservation, DispatchAssociation } from "../../index.js";
 import type { CallObservation, CallResult } from "../../library/akuma-creation.js";
-import type { WaitObservedAkuma } from "../../library/akumas.js";
 import type { AkumaHistoryResult } from "../../library/selection.js";
 import { type TextRenderContext } from "./terminal.js";
 export declare const DEFAULT_CONTEXT: TextRenderContext;
@@ -14,10 +13,6 @@ export declare const DEFAULT_CONTEXT: TextRenderContext;
  */
 export declare function frameRule(headLines: readonly string[]): string;
 type StatusTimeline = AkumaObservation["status"]["timeline"];
-type StatusTimelineEntry = StatusTimeline["entries"][number];
-type RenderRow = ActivityRow | Extract<StatusTimelineEntry, {
-    kind: "row";
-}>["row"];
 type RenderedSnapshot = StatusTimeline;
 type RenderedActivity = Readonly<{
     snapshot: RenderedSnapshot;
@@ -26,9 +21,7 @@ type RenderedActivity = Readonly<{
 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[];
 /**
- * The one place row prefixes live: time, optional source, mark, verb, content.
- * A plain layout is the single-target grammar; a source layout adds the frozen
- * source column a plural wait aligns across its selected set.
+ * The one place row prefixes live: time, mark, verb, content.
  */
 type RowLayout = Readonly<{
     head: (time: string | undefined, glyph: string, verb: string, columns: number) => string;
@@ -36,14 +29,10 @@ type RowLayout = Readonly<{
     marker: (count: number) => string;
     history?: true;
     compactRun?: true;
-    /** Plural wait keeps ordinary rows on one line; speech can use its two-line budget. */
+    /** A one-row receipt keeps that row on one line; speech can use its two-line budget. */
     singleLine?: true;
     /** World-board answer previews keep the conclusion at the tail. */
     tailAnswer?: true;
-    /** A plural wait shares one minute clock across all of its attributed rows. */
-    clock?: {
-        previous?: string;
-    };
 }>;
 /**
  * Shared snapshot activity rendering. Full snapshots render the selected
@@ -56,29 +45,12 @@ export declare function snapshotActivityLines(snapshot: RenderedSnapshot, contex
 }>): readonly string[];
 /** One command's append-only activity view, with a baseline and a final tail flush. */
 export type ActivityStream = ((activity: RenderedActivity) => readonly string[]) & Readonly<{
-    /** Establish a wait baseline without spending the command's live tool budget. */
+    /** Establish a live baseline without spending the command's live tool budget. */
     seed: (activity: RenderedActivity, alreadyRenderedSequence?: number) => readonly string[];
     /** Current live rows for the redrawable frame; never part of append-only output. */
     frame: () => readonly string[];
     /** Emit the pending omission count and unsettled rows once before the command's conclusion. */
     flush: () => readonly string[];
-    /** The same decisions undrawn, so concurrent streams can merge before rendering. */
-    emissions: Readonly<{
-        observe: (activity: RenderedActivity) => readonly StreamEmission[];
-        seed: (activity: RenderedActivity, alreadyRenderedSequence?: number) => readonly StreamEmission[];
-        flush: () => readonly StreamEmission[];
-    }>;
-    render: (emissions: readonly StreamEmission[]) => readonly string[];
-}>;
-/** One decided piece of append-only output: a settled row, or an untimed omission count. */
-export type StreamEmission = Readonly<{
-    kind: "gap";
-    count: number;
-}> | Readonly<{
-    kind: "row";
-    row: RenderRow;
-    inFlightSay?: boolean;
-    unsettled?: boolean;
 }>;
 /**
  * Append-only live view over one command's successive settled snapshots.
@@ -87,54 +59,12 @@ export type StreamEmission = Readonly<{
  * always print.
  */
 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;
-        diagnostic: string;
-    }>[];
-}>;
-/** One selected Akuma's frozen identity, resolved before the first observation round. */
-export type WaitSelectedIdentity = Readonly<{
-    id: string;
-    alias?: string;
-    contract?: DispatchAssociation;
-}>;
-export type WaitObservationStream = Readonly<{
-    /** Freeze the selected set's identities so the source column is stable before the first row. */
-    select: (selected: readonly WaitSelectedIdentity[]) => void;
-    /** One observation round; returns the head frames and newly settled rows to print. */
-    observe: (observed: readonly WaitObservedAkuma[]) => readonly string[];
-    /** Current live rows from all selected streams; never part of append-only output. */
-    frame: () => readonly string[];
-    /** In-flight rows with their unresolved marks, emitted by a close that never concluded. */
-    flush: () => readonly string[];
-    /** The wait's closing scoreboard, or the empty string when there is nothing to print. */
-    conclude: (result: WaitConclusionResult) => string;
-    streamed: () => boolean;
-}>;
 export declare function inputWaitConclusion(observation: AkumaAskObservation, input: Readonly<{
     startedAt: number;
     completedAt?: string | null;
     now?: number;
     status?: AkumaStatus;
 }>): readonly string[];
-/**
- * Live view over a wait's successive observation rounds, one append-only
- * stream per selected Akuma. A plural wait opens one aggregate frame naming
- * its selected set before any activity row and never opens a per-target frame
- * during observation; a single-target wait opens that Akuma's own identity
- * frame — the identity and Contract association the observed facts carry —
- * and an already settled Akuma prints that frame while replaying no backlog
- * rows. `conclude` renders the closing rows once the wait ends: one row per
- * observed Akuma in `<clock> <mark> <verb> — <duration>` grammar, with a target
- * named for a multi-target scoreboard and no activity replay.
- */
-export declare function waitObservationStream(context: TextRenderContext, options?: Readonly<{
-    now?: () => number;
-}>): WaitObservationStream;
 /** The identity a streamed observing call's head frame renders from its resolved birth. */
 export type ObservedCallHead = Readonly<{
     id: string;
@@ -190,7 +120,7 @@ export declare function callObservationStream(context: TextRenderContext, head:
 type SnapshotView = Readonly<{
     status: AkumaObservation["status"];
     contract: DispatchAssociation;
-    createdTasks?: CreatedTaskObservation;
+    createdDebts?: CreatedDebtObservation;
 }>;
 type SnapshotCoreOptions = Readonly<{
     alias?: string;
@@ -199,21 +129,19 @@ type SnapshotCoreOptions = Readonly<{
 }>;
 export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): string;
 export declare function killResultText(id: string, evidence: KillEvidence, alias?: string): string;
-export declare function statusAnswer(view: Readonly<{
-    status: AkumaObservation["status"];
-}>): string | undefined;
 /** Presentation-only state for one akuma invocation; it never reaches JSON. */
 type AkumaPresentation = Readonly<{
     alias?: string;
-    streamed?: boolean;
-    structured?: boolean;
-    startedAt?: number;
-    selection?: readonly WaitSelectedIdentity[];
 }>;
 export declare function askRawAnswer(result: AkumaAskResult, structured: boolean | undefined): string | undefined;
 export declare function callRawAnswer(result: CallResult, streamed: boolean): string | undefined;
-export declare function waitRawAnswer(result: AkumaWaitResult, streamed: boolean): string | undefined;
 export declare function historyRawAnswer(result: AkumaHistoryResult, historyId: string | undefined): string | undefined;
+/**
+ * One wait's final text: each observed Akuma's own status snapshot, then one
+ * failure fact per member the wait could not read. A wait observes to its
+ * completion judgment and streams nothing, so an answer is visible only as the
+ * snapshot's own outcome row.
+ */
 export declare function waitText(result: AkumaWaitResult, presentation: AkumaPresentation, context: TextRenderContext): string;
 export declare function historyText(result: AkumaHistoryResult, presentation: AkumaPresentation & Readonly<{
     id?: string;

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

@@ -1,6 +1,6 @@
 import { defaultWaitComplete } from "../../akuma/akuma-observe.js";
 import { renderDiffstat, toolContent, toolRepr } from "./akuma-tool.js";
-import { taskDispositionMark } from "./marks.js";
+import { debtDispositionMark } from "./marks.js";
 import { DEFAULT_CLI_COLUMNS, displayColumns, padToDisplay, renderBoundedPayload, renderBoundedTextBlock, safeText, takeDisplayColumns, takeDisplayColumnsFromEnd, truncateDisplayText, truncateMiddleDisplayText, } from "./terminal.js";
 export const DEFAULT_CONTEXT = { columns: DEFAULT_CLI_COLUMNS, color: false };
 const TIME_WIDTH = 5;
@@ -30,10 +30,6 @@ export function snapshotHeading(id, alias, contract) {
     const head = [identity(id, alias), ...(contractId === undefined ? [] : [`└─ ${contractId}`])];
     return [...head, frameRule(head)];
 }
-function answeredHeading(id, alias) {
-    const heading = `✓ answered ${identity(id, alias)}`;
-    return [heading, frameRule([heading])];
-}
 function contractFacts(contract) {
     return contract.kind === "failed" ? [`! contract failed ${safeText(contract.diagnostic)}`] : [];
 }
@@ -145,16 +141,6 @@ function compactLayout() {
 function historyLayout() {
     return { ...compactLayout(), history: true };
 }
-function sourceLayout(source, width, clock) {
-    const gutter = () => `${" ".repeat(TIME_WIDTH)} ${padToDisplay(source, width())} `;
-    return {
-        head: (time, glyph, verb, columns) => actionCell(`${time === undefined ? " ".repeat(TIME_WIDTH) : time.padEnd(TIME_WIDTH)} ${padToDisplay(source, width())} ${glyph}`, verb, columns),
-        continuation: () => `${" ".repeat(TIME_WIDTH)} ${" ".repeat(width())} │ ${" ".repeat(VERB_WIDTH)} `,
-        marker: (count) => `${gutter()}⋮ ${count} omitted`,
-        clock,
-        singleLine: true,
-    };
-}
 function quotedBody(row) {
     return (row.kind === "said" ||
         row.kind === "thought" ||
@@ -408,16 +394,12 @@ function baselineOmissionCount(activity, after, before) {
 function renderStreamRow(state, row, lines, options) {
     const { context, layout, inFlightSay = false, unsettled = false } = options;
     const at = clock(row.at);
-    const previousClock = layout.clock?.previous ?? state.previousClock;
-    const changed = previousClock === undefined || at !== previousClock;
+    const changed = state.previousClock === undefined || at !== state.previousClock;
     lines.push(...renderTimelineRow(row, context, layout, changed ? at : undefined, {
         inFlightSay,
         unsettled,
     }));
-    if (layout.clock !== undefined)
-        layout.clock.previous = at;
-    else
-        state.previousClock = at;
+    state.previousClock = at;
 }
 /**
  * A say is in-flight only while it is the newest row of the open turn: it may still be streaming, so it
@@ -598,12 +580,6 @@ export function activityStream(context, layout = plainLayout()) {
         seed: (activity, alreadyRenderedSequence) => render(seed(activity, alreadyRenderedSequence)),
         frame,
         flush: () => render(flush()),
-        emissions: {
-            observe: (activity) => observeActivitySnapshot(state, activity),
-            seed,
-            flush,
-        },
-        render,
     });
 }
 function conclusionMarkVerb(status, outcome) {
@@ -630,18 +606,6 @@ function conclusionMarkVerb(status, outcome) {
         return { mark: "!", verb: "untidy" };
     return { mark: "!", verb: "stranded" };
 }
-/**
- * The durable moment an Akuma settled, read from the outcome row its own timeline
- * retained. Absent for an ending that leaves no outcome row, so the caller falls
- * back to the observation that noticed it.
- */
-function settleMoment(status) {
-    const outcome = status.timeline.kind === "idle" ? status.timeline.outcome : undefined;
-    if (outcome === undefined)
-        return undefined;
-    const at = new Date(outcome.at).getTime();
-    return Number.isFinite(at) ? at : undefined;
-}
 function clockFromMs(at) {
     return clock(new Date(at).toISOString());
 }
@@ -651,156 +615,6 @@ function durationText(durationMs) {
         return `${seconds}s`;
     return `${Math.floor(seconds / 60)}m${String(seconds % 60)}s`;
 }
-function createWaitObservationState() {
-    return {
-        streams: new Map(),
-        sources: new Map(),
-        tags: new Map(),
-        contracts: new Map(),
-        settledAt: new Map(),
-        sourceWidth: 0,
-        clock: {},
-        plural: undefined,
-        headerEmitted: false,
-        observed: false,
-    };
-}
-function shortestUniquePrefix(value, values) {
-    for (let length = 4; length <= value.length; length += 1) {
-        const tag = value.slice(0, length);
-        if (values.filter((candidate) => candidate.slice(0, length) === tag).length === 1)
-            return tag;
-    }
-    return undefined;
-}
-function shortestUniqueSegmentSuffix(id, ids) {
-    const segments = id.split("/");
-    for (let start = segments.length - 2; start >= 0; start -= 1) {
-        const tag = segments.slice(start).join("/");
-        if (ids.filter((candidate) => candidate.endsWith(`/${tag}`) || candidate === tag).length === 1)
-            return tag;
-    }
-    return undefined;
-}
-function waitIdentityTag(id, ids) {
-    const finals = ids.map((candidate) => candidate.slice(candidate.lastIndexOf("/") + 1));
-    const index = ids.indexOf(id);
-    const own = finals[index];
-    if (own === undefined)
-        return id;
-    return (shortestUniquePrefix(own, finals) ?? shortestUniqueSegmentSuffix(id, ids) ?? shortestUniquePrefix(id, ids) ?? id);
-}
-/** The selected set fixes identity tags before its first attributed row. */
-function freezeWaitTags(state) {
-    const ids = [...state.sources.keys()];
-    state.tags = new Map(ids.map((id) => [id, waitIdentityTag(id, ids)]));
-    state.sourceWidth = Math.max(0, ...Array.from(state.tags.values(), displayColumns));
-}
-function sourceTag(state, id) {
-    return state.tags.get(id) ?? waitIdentityTag(id, [...state.sources.keys()]);
-}
-/** Register one selected or newly observed source; the set freezes the column before the first row. */
-function registerWaitSource(state, id, alias, contract) {
-    if (state.sources.has(id))
-        return;
-    const label = alias ?? id;
-    state.sources.set(id, label);
-    if (contract !== undefined)
-        state.contracts.set(id, contract);
-}
-/**
- * The one aggregate head a plural wait prints before any activity row: the
- * selected set read as a list, each target on its own line named by the alias
- * addressing it, otherwise its complete identity, with its `· kei/<contract>`
- * association inline when one exists, all closed by the frame's single rule.
- */
-function aggregateHeading(state) {
-    const head = [...state.sources].map(([id, label]) => {
-        const contractId = associatedContractId(state.contracts.get(id) ?? { kind: "none" });
-        const named = `${sourceTag(state, id)} ${label}`;
-        return contractId === undefined ? named : `${named} · ${contractId}`;
-    });
-    return [...head, frameRule(head)];
-}
-function observeWaitRound(state, round, context, now) {
-    state.observed = true;
-    // Establish the whole round's sources before any row so widths stay aligned within it.
-    for (const member of round)
-        registerWaitSource(state, member.status.id, member.alias, member.contract);
-    if (!state.headerEmitted)
-        freezeWaitTags(state);
-    const lines = [];
-    // The observation subject opens once: an aggregate head for a plural set, the observed
-    // identity frame for a single target. Every later round only appends attributed rows.
-    if (!state.headerEmitted && round.length > 0) {
-        state.headerEmitted = true;
-        state.plural ??= state.sources.size > 1;
-        if (state.plural) {
-            lines.push(...aggregateHeading(state));
-        }
-        else {
-            const sole = round[0];
-            lines.push(...snapshotHeading(sole.status.id, sole.alias, sole.contract));
-        }
-    }
-    const parts = [];
-    for (const { status, rows } of round) {
-        const known = state.streams.get(status.id);
-        if (known !== undefined) {
-            parts.push({ stream: known, emissions: known.emissions.observe({ snapshot: status.timeline, rows }) });
-        }
-        else {
-            // Only a plural wait attributes its rows; a single-target stream keeps the plain row grammar.
-            const stream = activityStream(context, state.plural === true
-                ? sourceLayout(sourceTag(state, status.id), () => state.sourceWidth, state.clock)
-                : plainLayout());
-            state.streams.set(status.id, stream);
-            // Seed marks skipped retained evidence without spending this command's live tool budget.
-            parts.push({ stream, emissions: stream.emissions.seed({ snapshot: status.timeline, rows }) });
-        }
-        if (!state.settledAt.has(status.id) && defaultWaitComplete(status))
-            state.settledAt.set(status.id, settleMoment(status) ?? now());
-    }
-    lines.push(...mergeStreamEmissions(parts));
-    return lines;
-}
-/**
- * Merge one observation's decided output across sources by row time. Each
- * source keeps its own order; an omission count travels with the row after it,
- * or with the row before it when it trails. Ties keep selection order.
- */
-function mergeStreamEmissions(parts) {
-    const queues = parts.map(({ stream, emissions }) => {
-        const units = [];
-        let pending = [];
-        for (const emission of emissions) {
-            pending.push(emission);
-            if (emission.kind !== "row")
-                continue;
-            const at = Date.parse(emission.row.at);
-            units.push({ at: Number.isFinite(at) ? at : (units.at(-1)?.at ?? Number.NEGATIVE_INFINITY), emissions: pending });
-            pending = [];
-        }
-        if (pending.length > 0) {
-            const last = units.at(-1);
-            if (last === undefined)
-                units.push({ at: Number.NEGATIVE_INFINITY, emissions: pending });
-            else
-                last.emissions.push(...pending);
-        }
-        return { stream, units };
-    });
-    const lines = [];
-    for (;;) {
-        let next;
-        for (const queue of queues)
-            if (queue.units.length > 0 && (next === undefined || queue.units[0].at < next.units[0].at))
-                next = queue;
-        if (next === undefined)
-            return lines;
-        lines.push(...next.stream.render(next.units.shift().emissions));
-    }
-}
 /**
  * A conclusion clause asserts real waiting: a target that settled at or after
  * this wait began keeps its duration, a target already settled names no
@@ -842,91 +656,6 @@ export function inputWaitConclusion(observation, input) {
             : []),
     ];
 }
-/** Present ids in frozen selection order, then any result member the selection never named. */
-function orderedWaitIds(state, result) {
-    const ids = [...state.sources.keys()];
-    const known = new Set(ids);
-    for (const observation of result.observations) {
-        if (!known.has(observation.status.id)) {
-            known.add(observation.status.id);
-            ids.push(observation.status.id);
-        }
-    }
-    for (const member of result.unobserved) {
-        if (!known.has(member.id)) {
-            known.add(member.id);
-            ids.push(member.id);
-        }
-    }
-    return ids;
-}
-function flushWaitStreams(state) {
-    return mergeStreamEmissions([...state.streams.values()].map((stream) => ({ stream, emissions: stream.emissions.flush() })));
-}
-function concludeWaitStream(state, result, startedAt, now) {
-    const tail = flushWaitStreams(state);
-    const end = now();
-    for (const observation of result.observations)
-        registerWaitSource(state, observation.status.id, undefined, observation.contract);
-    for (const member of result.unobserved)
-        registerWaitSource(state, member.id, undefined);
-    if (!state.headerEmitted)
-        freezeWaitTags(state);
-    const order = orderedWaitIds(state, result);
-    const multi = order.length > 1;
-    const observationById = new Map(result.observations.map((observation) => [observation.status.id, observation]));
-    const unobservedById = new Map(result.unobserved.map((member) => [member.id, member]));
-    // A failure fact keeps the complete identity even where the scoreboard attributes a target by its identity tag.
-    const unobservedLines = order
-        .filter((id) => unobservedById.has(id))
-        .map((id) => unobservedText(id, unobservedById.get(id).diagnostic));
-    const conclusions = order.flatMap((id) => {
-        const observation = observationById.get(id);
-        if (observation === undefined)
-            return [];
-        const status = observation.status;
-        const complete = defaultWaitComplete(status);
-        const at = complete ? (state.settledAt.get(id) ?? end) : end;
-        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined ? "answered" : "life");
-        const target = multi ? ` ${padToDisplay(sourceTag(state, id), state.sourceWidth)}` : "";
-        return [waitConclusionRow({ at, startedAt, complete, end, mark, verb, target })];
-    });
-    const answeredSingle = !multi && result.observations.length === 1 && statusAnswer(result.observations[0]) !== undefined;
-    const blocks = [
-        ...(conclusions.length > 0 ? [conclusions.join("\n")] : []),
-        ...(unobservedLines.length > 0 ? [unobservedLines.join("\n")] : []),
-    ];
-    const body = [...tail, ...blocks].join("\n");
-    // One blank line keeps the bare stdout answer visually separate from the stream.
-    return answeredSingle ? `${body}\n\n` : body;
-}
-/**
- * Live view over a wait's successive observation rounds, one append-only
- * stream per selected Akuma. A plural wait opens one aggregate frame naming
- * its selected set before any activity row and never opens a per-target frame
- * during observation; a single-target wait opens that Akuma's own identity
- * frame — the identity and Contract association the observed facts carry —
- * and an already settled Akuma prints that frame while replaying no backlog
- * rows. `conclude` renders the closing rows once the wait ends: one row per
- * observed Akuma in `<clock> <mark> <verb> — <duration>` grammar, with a target
- * named for a multi-target scoreboard and no activity replay.
- */
-export function waitObservationStream(context, options = {}) {
-    const now = options.now ?? (() => Date.now());
-    const startedAt = now();
-    const state = createWaitObservationState();
-    const select = (selected) => {
-        for (const member of selected)
-            registerWaitSource(state, member.id, member.alias, member.contract);
-        state.plural ??= selected.length > 1;
-        freezeWaitTags(state);
-    };
-    const observe = (round) => observeWaitRound(state, round, context, now);
-    const frame = () => [...state.streams.values()].flatMap((stream) => stream.frame());
-    const flush = () => flushWaitStreams(state);
-    const conclude = (result) => concludeWaitStream(state, result, startedAt, now);
-    return { select, observe, frame, flush, conclude, streamed: () => state.observed };
-}
 function failedOutcomeDiagnostic(status) {
     const outcome = status.timeline.kind === "idle" ? status.timeline.outcome : undefined;
     return outcome !== undefined && outcome.outcome.kind === "failed" ? outcome.outcome.diagnostic : undefined;
@@ -1032,8 +761,8 @@ function renderReportedChangeLines(snapshot) {
         ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} more files`] : []),
     ];
 }
-function renderTaskRow(row, columns) {
-    const prefix = `  ${taskDispositionMark(row.disposition)} ${row.id} · `;
+function renderDebtRow(row, columns) {
+    const prefix = `  ${debtDispositionMark(row.disposition)} ${row.id} · `;
     const body = `${safeText(row.title)} · ${row.disposition} · P${row.priority}`;
     const inline = `${prefix}${body}`;
     if (displayColumns(inline) <= columns)
@@ -1045,28 +774,14 @@ function renderTaskRow(row, columns) {
         lines: Number.MAX_SAFE_INTEGER,
     });
 }
-function renderTaskContextLines(created, columns) {
+function renderDebtContextLines(created, columns) {
     if (created === undefined)
         return [];
     if (created.kind === "failed")
-        return [`! tasks failed ${safeText(created.diagnostic)}`];
+        return [`! debts failed ${safeText(created.diagnostic)}`];
     if (created.rows.length === 0)
         return [];
-    return [`tasks ${created.rows.length}`, ...created.rows.flatMap((row) => renderTaskRow(row, columns))];
-}
-function answerContextLines(observation, columns) {
-    return [
-        ...renderTaskContextLines(observation.createdTasks, columns),
-        ...renderReportedChangeLines(observation.status.timeline),
-    ];
-}
-function answeredBlock(observation, answer, alias, columns) {
-    const frame = answeredHeading(observation.status.id, alias).join("\n");
-    const context = answerContextLines(observation, columns).join("\n");
-    if (context.length === 0)
-        return `${frame}\n${answer}`;
-    const separator = answer.endsWith("\n") ? "\n" : "\n\n";
-    return `${frame}\n${answer}${separator}${context}`;
+    return [`debts ${created.rows.length}`, ...created.rows.flatMap((row) => renderDebtRow(row, columns))];
 }
 function snapshotCore(view, context, options) {
     const activity = snapshotActivityLines(view.status.timeline, context);
@@ -1094,12 +809,12 @@ function snapshotConclusion(status) {
 }
 export function snapshotText(view, context, options = {}) {
     const core = snapshotCore(view, context, options);
-    const taskContext = renderTaskContextLines(view.createdTasks, context.columns);
+    const debtContext = renderDebtContextLines(view.createdDebts, context.columns);
     const conclusion = snapshotConclusion(view.status);
     return [
         ...core.lines,
         ...(conclusion.length === 0 ? [] : [conclusion]),
-        ...(taskContext.length > 0 ? ["", ...taskContext] : []),
+        ...(debtContext.length > 0 ? ["", ...debtContext] : []),
         ...(view.status.timeline.reportedChanges.length > 0 || view.status.timeline.reportedChangesOmitted > 0 ? [""] : []),
         ...renderReportedChangeLines(view.status.timeline),
         ...(core.facts.length > 0 ? ["", ...core.facts] : []),
@@ -1117,16 +832,6 @@ function killResultLabel(evidence) {
 export function killResultText(id, evidence, alias) {
     return [...snapshotHeading(id, alias, undefined), "", killResultLabel(evidence)].join("\n");
 }
-export function statusAnswer(view) {
-    if (!defaultWaitComplete(view.status))
-        return undefined;
-    if (view.status.life !== "asleep")
-        return undefined;
-    const timeline = view.status.timeline;
-    if (timeline.kind !== "idle" || timeline.outcome?.outcome.kind !== "answered")
-        return undefined;
-    return timeline.outcome.outcome.answer;
-}
 function answerBytes(answer, structured) {
     return !structured && typeof answer === "string" ? answer : JSON.stringify(answer);
 }
@@ -1141,90 +846,23 @@ export function callRawAnswer(result, streamed) {
         return streamed ? "" : undefined;
     return answerBytes(observation.observation.answer, result.structured === true);
 }
-export function waitRawAnswer(result, streamed) {
-    const total = result.observations.length + result.unobserved.length;
-    if (streamed) {
-        // Plural waits leave stdout empty so one answer can never be mistaken for the whole result.
-        if (total !== 1)
-            return "";
-        const single = result.observations[0];
-        return single === undefined ? "" : (statusAnswer(single) ?? "");
-    }
-    if (total !== 1)
-        return undefined;
-    return statusAnswer(result.observations[0]);
-}
 export function historyRawAnswer(result, historyId) {
     if (historyId === undefined || result.kind !== "exact")
         return undefined;
     const outcome = result.outcome.outcome;
     return outcome.kind === "answered" ? outcome.answer : outcome.diagnostic;
 }
+/**
+ * One wait's final text: each observed Akuma's own status snapshot, then one
+ * failure fact per member the wait could not read. A wait observes to its
+ * completion judgment and streams nothing, so an answer is visible only as the
+ * snapshot's own outcome row.
+ */
 export function waitText(result, presentation, context) {
-    const alias = presentation.alias;
-    const observations = result.observations;
-    const unobserved = result.unobserved;
-    const total = observations.length + unobserved.length;
-    if (total <= 1) {
-        const single = [
-            ...observations.map((observation) => {
-                const answer = statusAnswer(observation);
-                if (answer !== undefined)
-                    return answeredBlock(observation, answer, alias, context.columns);
-                return snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) });
-            }),
-            ...unobserved.map((member) => unobservedText(member.id, member.diagnostic)),
-        ];
-        return single.join("\n\n");
-    }
-    const end = Date.now();
-    const startedAt = presentation.startedAt ?? end;
-    const order = [];
-    const remember = (id) => {
-        if (!order.includes(id))
-            order.push(id);
-    };
-    for (const member of presentation.selection ?? [])
-        remember(member.id);
-    for (const observation of observations)
-        remember(observation.status.id);
-    for (const member of unobserved)
-        remember(member.id);
-    const observationById = new Map(observations.map((observation) => [observation.status.id, observation]));
-    const unobservedById = new Map(unobserved.map((member) => [member.id, member]));
-    const sourceWidth = Math.max(0, ...order.map((id) => displayColumns(waitIdentityTag(id, order))));
-    const blocks = [
-        ...order.flatMap((id) => {
-            const observation = observationById.get(id);
-            if (observation === undefined)
-                return [];
-            const answer = statusAnswer(observation);
-            if (answer !== undefined)
-                return [answeredBlock(observation, answer, undefined, context.columns)];
-            return [snapshotText(observation, context)];
-        }),
-        ...(unobserved.length > 0
-            ? [
-                order
-                    .filter((id) => unobservedById.has(id))
-                    .map((id) => unobservedText(id, unobservedById.get(id).diagnostic))
-                    .join("\n"),
-            ]
-            : []),
-    ];
-    const rows = order.flatMap((id) => {
-        const observation = observationById.get(id);
-        if (observation === undefined)
-            return [];
-        const status = observation.status;
-        const complete = defaultWaitComplete(status);
-        const at = complete ? (settleMoment(status) ?? end) : end;
-        const { mark, verb } = conclusionMarkVerb(status, statusAnswer(observation) !== undefined ? "answered" : "life");
-        return [
-            `${clockFromMs(at)} ${padToDisplay(waitIdentityTag(id, order), sourceWidth)} ${mark} ${verb}${conclusionClause(at, startedAt, complete, end)}`,
-        ];
-    });
-    return rows.length > 0 ? [...blocks, rows.join("\n")].join("\n\n") : blocks.join("\n\n");
+    const alias = result.observations.length === 1 && result.unobserved.length === 0 ? presentation.alias : undefined;
+    const blocks = result.observations.map((observation) => snapshotText(observation, context, { ...(alias === undefined ? {} : { alias }) }));
+    const unobserved = result.unobserved.map((member) => unobservedText(member.id, member.diagnostic));
+    return [...blocks, ...(unobserved.length === 0 ? [] : [unobserved.join("\n")])].join("\n\n");
 }
 export function historyText(result, presentation, context) {
     if (presentation.id !== undefined) {