@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/cli/commands/task.js

@@ -1,4 +1,5 @@
 import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
+import { parseTaskNamespaceSelector } from "../../task/catalog.js";
 import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
 const COMMON = { json: "boolean" };
 const TASK_COMMAND_SPECS = {
@@ -18,39 +19,39 @@ const TASK_COMMAND_SPECS = {
             note: "value",
             actor: "value",
         },
-        usage: `task add <TITLE> [--namespace <ns>] [--priority 0..3]
+        usage: `task add <TITLE> [--namespace <ns>] [--priority 0..3] [--json]
   [--state open|in_progress|on_hold|done|drop]
   [--note <text>] [--actor <actor>]
   [--needs <TaskId>]... [--parent <TaskId>]
   [--supersedes <TaskId>]... [--relates <TaskId>]...
   [--body <text>]
-task add [--namespace <ns>] [--actor <actor>] -`,
+task add [--namespace <ns>] [--actor <actor>] [--json] -`,
         purpose: "Create one Task from flags or a canonical stdin document.",
     },
     show: {
         arity: [1, Number.POSITIVE_INFINITY],
         flags: COMMON,
-        usage: "task show <TaskId>...",
+        usage: "task show <TaskId>... [--json]",
         purpose: "Read one or more Tasks and their relationships.",
     },
     ls: {
-        arity: [0, 0],
+        arity: [0, 1],
         flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" },
-        usage: "task ls [--closed | --all] [--world] [--limit <n>]",
+        usage: "task ls [<namespace-selector>] [--closed | --all] [--world] [--limit <n>] [--json]",
         purpose: "List Tasks in the selected scope.",
         details: "--world lists every namespace in the current Task world.",
     },
     ready: {
         arity: [0, 0],
         flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
-        usage: "task ready [--world] [--parent <TaskId>] [--limit <n>]",
+        usage: "task ready [--world] [--parent <TaskId>] [--limit <n>] [--json]",
         purpose: "List open Tasks whose every need is terminal.",
         details: "--world lists every namespace in the current Task world.",
     },
     blocked: {
         arity: [0, 0],
         flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
-        usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>]",
+        usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>] [--json]",
         purpose: "List Tasks blocked by dependencies.",
         details: "--world lists every namespace in the current Task world.",
     },
@@ -58,7 +59,7 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         arity: [0, 0],
         flags: { ...COMMON, where: "value", world: "boolean", sort: "value", limit: "value" },
         usage: `task query [--where <expression>] [--world]
-  [--sort priority|created|updated|id] [--limit <n>]`,
+  [--sort priority|created|updated|id] [--limit <n>] [--json]`,
         purpose: "Query Task facts with a typed boolean expression.",
         details: [
             "fields: state priority title id parent under needs blocks ready blocked created updated",
@@ -72,13 +73,13 @@ task add [--namespace <ns>] [--actor <actor>] -`,
     tree: {
         arity: [1, 1],
         flags: COMMON,
-        usage: "task tree <TaskId>",
+        usage: "task tree <TaskId> [--json]",
         purpose: "Read one Task parent decomposition tree.",
     },
     doctor: {
         arity: [0, 0],
         flags: COMMON,
-        usage: "task doctor",
+        usage: "task doctor [--json]",
         purpose: "Inspect Task authority without repairing it.",
     },
     update: {
@@ -104,45 +105,60 @@ task add [--namespace <ns>] [--actor <actor>] -`,
   [--priority 0..3] [--needs <TaskId>]... [--drop-needs <TaskId>]...
   [--parent <TaskId> | --no-parent]
   [--supersedes <TaskId>]... [--drop-supersedes <TaskId>]...
-  [--relates <TaskId>]... [--drop-relates <TaskId>]...`,
+  [--relates <TaskId>]... [--drop-relates <TaskId>]... [--json]`,
         purpose: "Apply one or more patches to a Task.",
     },
-    start: { arity: [1, 1], flags: COMMON, usage: "task start <TaskId>", purpose: "Move one open Task into progress." },
-    stop: { arity: [1, 1], flags: COMMON, usage: "task stop <TaskId>", purpose: "Return one in-progress Task to open." },
+    start: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: COMMON,
+        usage: "task start <TaskId>... [--json]",
+        purpose: "Move one or more open Tasks into progress.",
+    },
+    stop: {
+        arity: [1, 1],
+        flags: COMMON,
+        usage: "task stop <TaskId> [--json]",
+        purpose: "Return one in-progress Task to open.",
+    },
     hold: {
         arity: [1, Number.POSITIVE_INFINITY],
         flags: COMMON,
-        usage: "task hold <TaskId>...",
+        usage: "task hold <TaskId>... [--json]",
         purpose: "Put one or more Tasks on hold.",
     },
-    resume: { arity: [1, 1], flags: COMMON, usage: "task resume <TaskId>", purpose: "Return one held Task to open." },
+    resume: {
+        arity: [1, 1],
+        flags: COMMON,
+        usage: "task resume <TaskId> [--json]",
+        purpose: "Return one held Task to open.",
+    },
     done: {
         arity: [1, Number.POSITIVE_INFINITY],
         flags: { ...COMMON, note: "value" },
-        usage: "task done <TaskId>... [--note <text>]",
+        usage: "task done <TaskId>... [--note <text>] [--json]",
         purpose: "Mark one or more Tasks done.",
     },
     drop: {
         arity: [1, Number.POSITIVE_INFINITY],
         flags: { ...COMMON, note: "value" },
-        usage: "task drop <TaskId>... [--note <text>]",
+        usage: "task drop <TaskId>... [--note <text>] [--json]",
         purpose: "Drop one or more Tasks.",
     },
     context: {
         arity: [0, 1],
         flags: COMMON,
-        usage: "task context [<namespace>]",
+        usage: "task context [<namespace>] [--json]",
         purpose: "Read or replace the directory Task context.",
     },
     compose: {
         arity: [0, 0],
         stdin: "compose",
         flags: { ...COMMON, actor: "value", plan: "boolean" },
-        usage: "task compose [--actor <actor>] [--plan] -",
+        usage: "task compose [--actor <actor>] [--plan] [--json] -",
         purpose: "Plan or admit one explicit Task composition.",
         details: [
             "nodes: + <Title> creates; @task/<id> modifies a pre-existing Task",
-            "properties: as = <alias>; pri = 0..3; parent = <ref>|empty",
+            "properties: as = <alias>; state = open|in_progress|on_hold|done|drop; pri = 0..3; parent = <ref>|empty",
             "relations: needs|supersedes|relates with =, +=, or -=",
             "references: @task/... is pre-existing; ^alias is new in this document",
             "body: body = clears; body <<TOKEN reads exact content to TOKEN",
@@ -255,6 +271,9 @@ function validateUpdate(scanned, fail) {
 function validateTaskReadFlags(action, flags, fail) {
     if (action === "ls" && flags.closed === true && flags.all === true)
         fail("--closed and --all are mutually exclusive");
+    if (action === "ls" && flags.world === true) {
+        // An explicit selector is checked below, after positional shape is known.
+    }
     if (typeof flags.limit === "string") {
         try {
             validateTaskLimit(flags.limit);
@@ -291,6 +310,21 @@ function validateTaskScan(action, scanned, fail) {
         fail("task add document input owns its creation fields");
     if (action === "compose" && stdin !== "compose")
         fail("task compose requires '-' input");
+    if (action === "ls" && positionals.length === 1) {
+        const selector = positionals[0];
+        if (selector !== "task/" && (!selector.startsWith("task/") || !selector.endsWith("/")))
+            fail(`invalid Task namespace selector: ${selector}`);
+        if (selector !== "task/") {
+            try {
+                parseTaskNamespaceSelector(selector);
+            }
+            catch (error) {
+                fail(error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (flags.world === true)
+            fail("--world cannot be combined with an explicit Task namespace selector");
+    }
     validateTaskReadFlags(action, flags, fail);
     if (action === "update")
         validateUpdate(scanned, fail);

package/build/src/cli/invoke.js

@@ -3,6 +3,8 @@ import { isParsedAkumaCommand } from "./commands/akuma.js";
 import { invokeContractMutation } from "./commands/contract-invoke.js";
 import { assertExplicitRepoUse, CliUsageError, renderCommandUsage, } from "./parse.js";
 import { isBlankInput } from "./usage.js";
+import { AKUMA_REQUESTS_ENV } from "../akuma/provider.js";
+import { bodyRequestExecution, executionChannel, localExecutionContext, } from "../akuma/requests.js";
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)
@@ -56,6 +58,20 @@ async function settingsAt(root, home) {
     const { settings } = await import("../settings.js");
     return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined ? {} : { home }) });
 }
+function executionForEnvironment(environment) {
+    return environment[AKUMA_REQUESTS_ENV] === undefined
+        ? localExecutionContext()
+        : bodyRequestExecution({ directory: environment[AKUMA_REQUESTS_ENV] });
+}
+async function contractSettings(command, execution, world, home) {
+    const forwarded = executionChannel(execution).kind === "body-request" &&
+        (command.command === "audit" || command.command === "deliver" || command.command === "review");
+    if (forwarded)
+        return {};
+    const configuration = await settingsAt(world ?? undefined, home);
+    const { worktreeHooksFrom, SettingsError } = await import("../library/configuration.js");
+    return { configuration, hooks: consumeSettings(() => worktreeHooksFrom({ settings: configuration }), SettingsError) };
+}
 function consumeSettings(run, ErrorType) {
     try {
         return run();
@@ -76,6 +92,10 @@ function actorFromEdge(actor, environment) {
     }
     return resolved;
 }
+function taskActor(command, runtime, environment) {
+    return (runtime.actor ??
+        actorFromEdge(typeof command.flags.actor === "string" ? command.flags.actor : undefined, environment));
+}
 function gitPathFromEdge(environment) {
     const value = environment.KEIYAKU_GIT_PATH;
     if (value === undefined)
@@ -103,7 +123,7 @@ async function invokeAkumaFromEdge(parsed, input) {
         }
         const { invokeAkuma } = await import("./commands/akuma-invoke.js");
         const contract = parsed.command === "call" && parsed.contract !== undefined
-            ? (await import("./selectors.js")).contractFromInput(repo, parsed.contract).contract
+            ? (await import("./selectors.js")).contractFromInput(repo, parsed.contract, input.execution).contract
             : undefined;
         return await invokeAkuma(parsed, {
             path,
@@ -113,6 +133,7 @@ async function invokeAkumaFromEdge(parsed, input) {
             ...(contract === undefined ? (repo === undefined ? {} : { repo }) : { contract }),
             environment: edge.environment,
             readStdin: edge.readStdin,
+            execution: input.execution,
         });
     }
     catch (error) {
@@ -276,18 +297,6 @@ async function invokeContractHistory(repo, contract) {
         throw error;
     }
 }
-async function invokeForwardedContractMutation(parsed, repo, edge, scope, establishWorld) {
-    const { EMPTY_WORKTREE_HOOKS } = await import("../library/configuration.js");
-    return invokeContractMutation({
-        parsed,
-        repo,
-        edge,
-        scope,
-        hooks: EMPTY_WORKTREE_HOOKS,
-        establishWorld,
-        forwarded: true,
-    });
-}
 async function resolveInvocationCoordinates(invocation, runtime) {
     const environment = runtime.environment ?? process.env, gitPath = gitPathFromEdge(environment);
     const { resolveCliCoordinates } = await import("./coordinates.js");
@@ -302,6 +311,7 @@ async function resolveInvocationCoordinates(invocation, runtime) {
 // eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
 async function invokeParsed(invocation, runtime) {
     const environment = runtime.environment ?? process.env;
+    const execution = executionForEnvironment(environment);
     const coordinates = await resolveInvocationCoordinates(invocation, runtime);
     const { cwd, cwdSource, repo, world, candidateWorld, establishWorld, taskContext } = coordinates;
     const edge = { environment, readStdin: runtime.readStdin ?? readStdin };
@@ -313,8 +323,7 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "nuke")
         return await (await import("./commands/nuke.js")).invokeNuke(parsed, world);
     if (parsed.command === "task") {
-        const actor = runtime.actor ??
-            actorFromEdge(typeof parsed.flags.actor === "string" ? parsed.flags.actor : undefined, edge.environment);
+        const actor = taskActor(parsed, runtime, edge.environment);
         return await (await import("./commands/task-invoke.js")).invokeTaskFromEdge({
             parsed,
             world,
@@ -323,6 +332,7 @@ async function invokeParsed(invocation, runtime) {
             establish: coordinates.establishWorld,
             readStdin: edge.readStdin,
             actor,
+            execution,
         });
     }
     if (parsed.command === "history" && "contract" in parsed)
@@ -337,6 +347,7 @@ async function invokeParsed(invocation, runtime) {
             ...(repo === undefined ? {} : { repo }),
             ...(home === undefined ? {} : { home }),
             edge,
+            execution,
         });
     }
     if (parsed.command === "ls")
@@ -348,13 +359,7 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "region")
         return invokeRegion(parsed, world, repo);
     const scope = cwd;
-    if ((parsed.command === "deliver" || parsed.command === "review") &&
-        (await import("../akuma/requests.js")).injectedBodyRequests() !== null) {
-        return invokeForwardedContractMutation(parsed, repo, edge, scope, establishWorld);
-    }
-    const configuration = await settingsAt(world ?? undefined, home);
-    const { worktreeHooksFrom, SettingsError } = await import("../library/configuration.js");
-    const hooks = consumeSettings(() => worktreeHooksFrom({ settings: configuration }), SettingsError);
+    const { configuration, hooks } = await contractSettings(parsed, execution, world, home);
     if (parsed.command === "show") {
         const selected = await selectContract(repo, parsed.contract, scope);
         return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
@@ -364,17 +369,26 @@ async function invokeParsed(invocation, runtime) {
             return {
                 kind: "observation",
                 command: "reconcile",
-                report: await repo.reconcile({ hooks, retryHooks: parsed.retryHooks }),
+                report: await repo.reconcile({ ...(hooks === undefined ? {} : { hooks }), retryHooks: parsed.retryHooks }),
             };
         }
         const { contract } = await selectContract(repo, parsed.contract, scope);
         return {
             kind: "observation",
             command: "reconcile",
-            ...(await contract.reconcile({ hooks, retryHooks: parsed.retryHooks })),
+            ...(await contract.reconcile({ ...(hooks === undefined ? {} : { hooks }), retryHooks: parsed.retryHooks })),
         };
     }
-    return invokeContractMutation({ parsed, repo, edge, scope, configuration, hooks, establishWorld });
+    return invokeContractMutation({
+        parsed,
+        repo,
+        edge,
+        scope,
+        ...(configuration === undefined ? {} : { configuration }),
+        ...(hooks === undefined ? {} : { hooks }),
+        establishWorld,
+        execution,
+    });
 }
 function withResolvedTaskActor(command, runtime) {
     if (command.command !== "task" || (command.action !== "add" && command.action !== "compose"))

package/build/src/cli/main.js

@@ -3,7 +3,8 @@ export async function main(argv = process.argv.slice(2)) {
     try {
         const parsed = parseArgv(argv);
         if ("help" in parsed) {
-            const help = renderHelp(parsed.help);
+            const columns = process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : undefined;
+            const help = renderHelp(parsed.help, columns);
             process.stdout.write(help.endsWith("\n") ? help : `${help}\n`);
             return 0;
         }

package/build/src/cli/parse.d.ts

@@ -5,9 +5,9 @@ import { type ContractCommand as Command, type ParsedAbandon, type ParsedAmend,
 export { CliUsageError } from "./usage.js";
 export { renderContractHelp } from "./commands/contract.js";
 export type { Command };
-export declare function renderRootHelp(): string;
+export declare function renderRootHelp(columns?: number): string;
 export declare function renderCommandUsage(command: ParsedCommand): string;
-export declare function renderHelp(coordinate: CliHelpCoordinate): string;
+export declare function renderHelp(coordinate: CliHelpCoordinate, columns?: number): string;
 export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedShow | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 export type CliHelpCoordinate = Readonly<{
     kind: "root";

package/build/src/cli/parse.js

@@ -1,27 +1,53 @@
 import { isTaskAction, parseTaskCommand, renderTaskHelp, renderTaskUsage, } from "./commands/task.js";
 import { isAkumaAction, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
-import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp, } from "./commands/install.js";
+import { INSTALL_ROOT_PURPOSE, parseInstallCommand, renderInstallHelp, } from "./commands/install.js";
 import { CONTRACT_COMMAND_SPECS, parseContractCommand, renderContractHelp as renderContractHelpForOwner, renderContractUsage, } from "./commands/contract.js";
+import { renderTextBlock } from "./render/terminal.js";
 import { CliUsageError, isBlankInput } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 export { renderContractHelp } from "./commands/contract.js";
-const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
-export function renderRootHelp() {
-    return [
+const ROOT_USAGE = [
+    "usage: keiyaku <command> [options]",
+    "       keiyaku <command> --help   shows that command's complete usage",
+].join("\n");
+export function renderRootHelp(columns) {
+    return renderHelpText([
+        "keiyaku — Contract, Task, and Akuma control for one repository",
+        "",
         ROOT_USAGE,
         "",
-        "global options:",
-        "  -C, --cwd <path>  Set the invocation working directory.",
-        "  --repo <path>     Select the Git repository coordinate.",
+        "Contract — standing acceptance",
+        ...Object.entries(CONTRACT_COMMAND_SPECS)
+            .filter(([command]) => command !== "settings")
+            .map(([command, spec]) => `  ${command.padEnd(10)} ${spec.purpose}`),
+        "",
+        "Task — plan memory",
+        "  task       Task coordination; see `keiyaku task --help`.",
         "",
-        "commands:",
-        ...Object.values(CONTRACT_COMMAND_SPECS).flatMap((spec) => [`  ${spec.usage}`, `    ${spec.purpose}`]),
-        `  ${INSTALL_USAGE}`,
-        "    Install the Keiyaku skills into an agent harness.",
-        "  task ...",
-        "    Task coordination; see `keiyaku task --help`.",
+        "Akuma — invoke capability",
         ...renderAkumaRootRows(),
-    ].join("\n");
+        "",
+        "Workspace",
+        `  install   ${INSTALL_ROOT_PURPOSE}`,
+        `  settings  ${CONTRACT_COMMAND_SPECS.settings.purpose}`,
+        "",
+        "Global options:",
+        "  -C, --cwd <path>  Set the invocation working directory.",
+        "  --repo <path>     Select the Git repository coordinate.",
+    ].join("\n"), columns);
+}
+function renderHelpText(help, columns) {
+    if (columns === undefined || !Number.isFinite(columns) || columns <= 0)
+        return help;
+    return help
+        .split("\n")
+        .flatMap((line) => {
+        if (line.trim().length === 0)
+            return [line];
+        const indent = line.match(/^\s*/u)?.[0] ?? "";
+        return renderTextBlock(line.slice(indent.length), indent, columns);
+    })
+        .join("\n");
 }
 function contractUsage(command) {
     return renderContractUsage(command);
@@ -35,19 +61,22 @@ export function renderCommandUsage(command) {
         return renderAkumaUsage(command.command);
     return contractUsage(command.command);
 }
-export function renderHelp(coordinate) {
-    switch (coordinate.kind) {
-        case "root":
-            return renderRootHelp();
-        case "contract":
-            return renderContractHelpForOwner(coordinate.command);
-        case "task":
-            return renderTaskHelp(coordinate.action);
-        case "install":
-            return renderInstallHelp();
-        case "akuma":
-            return renderAkumaHelp(coordinate.action);
-    }
+export function renderHelp(coordinate, columns) {
+    const help = (() => {
+        switch (coordinate.kind) {
+            case "root":
+                return renderRootHelp();
+            case "contract":
+                return renderContractHelpForOwner(coordinate.command);
+            case "task":
+                return renderTaskHelp(coordinate.action);
+            case "install":
+                return renderInstallHelp();
+            case "akuma":
+                return renderAkumaHelp(coordinate.action);
+        }
+    })();
+    return renderHelpText(help, columns);
 }
 export function commandRepoPolicy(command) {
     switch (command.command) {

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

@@ -1,3 +1,4 @@
+import type { KillEvidence } from "../../akuma/index.js";
 import type { AkumaObservation, AkumaObservationStage, CreatedTaskObservation, DispatchAssociation } from "../../index.js";
 import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";
@@ -15,6 +16,8 @@ type SnapshotCoreOptions = Readonly<{
     facts?: readonly string[];
 }>;
 export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): string;
+export declare function killObservationText(id: string, evidence: KillEvidence, observation: AkumaObservationStage, context: TextRenderContext, alias?: string): string;
+export declare function killResultText(id: string, evidence: KillEvidence, alias?: string): string;
 export declare function mutationObservationStageText(id: string, observation: AkumaObservationStage, context: TextRenderContext, options?: SnapshotCoreOptions & Readonly<{
     showLife?: boolean;
 }>): string;

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

@@ -1,4 +1,4 @@
-import { defaultWaitComplete } from "../../akuma/index.js";
+import { parseAkumaStatus } from "../../akuma/akuma.js";
 import { toolRepr } from "./akuma-tool.js";
 import { displayColumns, renderBoundedTextBlock, safeText, truncateMiddleDisplayText, } from "./terminal.js";
 export const DEFAULT_CONTEXT = { columns: 80, color: false };
@@ -37,11 +37,6 @@ function lifeLabel(life) {
         return "× killed";
     return `? ${life}`;
 }
-function pendingWithoutLiveBody(status) {
-    if (status.life === "running")
-        return 0;
-    return status.timeline.entries.reduce((count, entry) => count + (entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending" ? 1 : 0), 0);
-}
 function clock(at) {
     const date = new Date(at);
     return Number.isFinite(date.getTime())
@@ -58,16 +53,20 @@ function label(row) {
     if (row.kind === "call")
         return "call";
     if (row.kind === "tell")
-        return "tell";
+        return row.state === "told" ? "told" : "tell";
     if (row.kind === "outcome")
         return row.outcome.kind === "answered" ? "say" : "error";
     if (row.kind === "turn")
         return "call";
+    if (row.kind !== "tool")
+        return row.kind;
     return toolRepr(row).label;
 }
 function mark(row) {
     if (row.kind === "outcome")
         return row.outcome.kind === "answered" ? "✓" : "!";
+    if (row.kind === "tell" && row.state === "told")
+        return "✓";
     if (row.kind === "tell" && row.state === "pending")
         return "⧗";
     if (row.kind === "tool") {
@@ -96,6 +95,8 @@ function rowText(row) {
             : { text: row.outcome.diagnostic, lines: 2 };
     if (row.kind === "turn")
         return { text: "", lines: 1 };
+    if (row.kind !== "tool")
+        return { text: "", lines: 1 };
     const repr = toolRepr(row);
     return {
         text: repr.text,
@@ -261,15 +262,9 @@ function snapshotCore(view, context, options) {
         ...contractFacts(view.contract),
         ...(options.facts ?? []),
     ];
-    const pending = pendingWithoutLiveBody(view.status);
     return {
         activity,
-        lines: [
-            ...snapshotHeading(view.status.id, options.alias, view.contract),
-            ...facts,
-            ...activity,
-            ...(pending === 0 ? [] : [`pending ${pending} tells · no live body`]),
-        ],
+        lines: [...snapshotHeading(view.status.id, options.alias, view.contract), ...facts, ...activity],
     };
 }
 export function snapshotText(view, context, options = {}) {
@@ -288,13 +283,35 @@ function mutationSnapshotText(view, context, options = {}) {
     const core = snapshotCore(view, context, options);
     return [...core.lines, ...(options.showLife === false ? [] : ["", lifeLabel(view.status.life)])].join("\n");
 }
+function killResultLabel(evidence) {
+    if (evidence === "killed")
+        return "✓ killed";
+    if (evidence === "already-killed")
+        return "✓ already killed";
+    if (evidence === "already-stopped")
+        return "✓ already stopped";
+    return `! not killed · ${evidence}`;
+}
+function latestKillActivity(snapshot, context) {
+    const rows = snapshot.entries.flatMap((entry) => (entry.kind === "row" ? [entry.row] : []));
+    const latest = rows.reduce((selected, row) => (selected === undefined || row.sequence > selected.sequence ? row : selected), undefined);
+    return latest === undefined ? [] : groupedRows([latest], context);
+}
+export function killObservationText(id, evidence, observation, context, alias) {
+    const heading = snapshotHeading(id, alias, observation.kind === "observed" ? observation.contract : undefined);
+    const activity = observation.kind === "observed" ? latestKillActivity(observation.status.timeline, context) : [];
+    return [...heading, ...activity, "", killResultLabel(evidence)].join("\n");
+}
+export function killResultText(id, evidence, alias) {
+    return [...snapshotHeading(id, alias, undefined), "", killResultLabel(evidence)].join("\n");
+}
 export function mutationObservationStageText(id, observation, context, options = {}) {
     if (observation.kind === "unobserved")
         return unobservedText(id, observation.diagnostic);
     return mutationSnapshotText(observation, context, options);
 }
 export function statusAnswer(view) {
-    if (!defaultWaitComplete(view.status))
+    if (!waitComplete(view.status))
         return undefined;
     if (view.status.life !== "asleep")
         return undefined;
@@ -305,6 +322,10 @@ 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";
 }
@@ -312,7 +333,7 @@ export function akumaRawAnswer(result) {
     if (result.action === "call") {
         if (answerCallFailed(result.result) || result.result.observation.kind !== "observed")
             return undefined;
-        return statusAnswer({ status: result.result.observation.status });
+        return statusAnswer({ status: parseAkumaStatus(result.result.observation.status) });
     }
     if (result.action === "wait" && result.result.observations.length === 1)
         return statusAnswer(result.result.observations[0]);
@@ -326,7 +347,7 @@ export function akumaRawAnswer(result) {
 export function waitText(result, context) {
     const alias = result.alias;
     const total = result.result.observations.length + result.result.unobserved.length;
-    const done = result.result.observations.filter((observation) => defaultWaitComplete(observation.status)).length;
+    const done = result.result.observations.filter((observation) => waitComplete(observation.status)).length;
     const blocks = [
         ...result.result.observations.map((observation) => {
             const answer = statusAnswer(observation);
@@ -358,16 +379,11 @@ export function historyText(command, result, context) {
 }
 export function tellText(result, context) {
     const wake = result.result.tell.wake;
-    const facts = wake.kind === "failed"
-        ? [
-            `! wake failed · ${safeText(wake.diagnostic)}${wake.child === undefined ? "" : ` · log ${wake.child.log.path} ${wake.child.log.from}..${wake.child.log.to}`}`,
-        ]
-        : wake.kind === "pursuing"
-            ? []
-            : [`wake ${wake.kind}`];
-    return mutationObservationStageText(result.result.akuma, result.result.observation, context, {
-        ...(result.alias === undefined ? {} : { alias: result.alias }),
-        facts,
-        showLife: false,
-    });
+    const target = identity(result.result.akuma, result.alias);
+    const row = groupedRows([result.result.tell.row], context).join("\n");
+    if (wake.kind === "failed") {
+        const child = "child" in wake ? wake.child : undefined;
+        return `${target}\n${SNAPSHOT_RULER}\n${row}\n! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
+    }
+    return `${target}\n${SNAPSHOT_RULER}\n${row}`;
 }

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

@@ -1,5 +1,9 @@
 import type { ActivityRow, SnapshotRow } from "../../akuma/index.js";
-type ToolRow = Extract<ActivityRow | SnapshotRow, {
+import type { AkumaObservation } from "../../index.js";
+type FleetTimelineRow = Extract<AkumaObservation["status"]["timeline"]["entries"][number], {
+    kind: "row";
+}>["row"];
+type ToolRow = Extract<ActivityRow | SnapshotRow | FleetTimelineRow, {
     kind: "tool";
 }>;
 export type ToolRepr = Readonly<{