@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/cli/render/audit.js

@@ -0,0 +1,121 @@
+import { asMessage, FlowError } from "../../flow-error.js";
+function streamLines(name, result) {
+    const stream = result[name];
+    return [
+        `${name} tail (${stream.truncated ? `truncated, ${stream.omittedBytes} bytes omitted` : "complete, 0 bytes omitted"}):`,
+        stream.tail || "(empty)",
+    ];
+}
+function renderVerification(report) {
+    if (report.verification.status === "not_configured")
+        return ["not configured"];
+    if (report.verification.status === "not_evaluated")
+        return [`not evaluated: ${report.verification.reason}`];
+    if (report.verification.status === "unknown")
+        return [`unknown: ${report.verification.cause.code}: ${report.verification.cause.message}`];
+    const lines = [];
+    for (const result of report.verification.results) {
+        lines.push(`command ${result.label}`, `exec ${result.command}`, `argv ${JSON.stringify(result.argv)}`, `head ${result.head}`);
+        if (result.status === "unverifiable") {
+            lines.push(`not executable: ${result.cause}`, "");
+            continue;
+        }
+        lines.push(`\`\`\`${result.executor}`, result.body, "\`\`\`", `exit ${result.exitCode} · duration ${result.durationMs}ms`, ...streamLines("stdout", result), ...streamLines("stderr", result), "");
+    }
+    return lines;
+}
+function renderScope(report) {
+    if (!report.scope)
+        return ["not evaluated"];
+    return report.scope.flatMap((row) => {
+        const decisive = row.matcher.decisivePattern
+            ? `rule ${row.matcher.decisivePattern.index}:${row.matcher.decisivePattern.pattern} (${row.matcher.decisivePattern.effect})`
+            : `rule none (${row.matcher.outcome})`;
+        const explanations = row.explanations.map((item) => {
+            if (item.kind === "file-rename")
+                return `  explain file rename ${item.from} -> ${item.to} (${item.similarity}%)`;
+            if (item.kind === "symbol-rename")
+                return `  explain symbol rename ${item.from} -> ${item.to} at h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
+            return `  explain import at h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
+        });
+        const residue = row.residue.map((item) => `  residue h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"} ${item.kind} ${item.content}`);
+        return [`${row.class} ${row.path} · ${decisive}`, ...explanations, ...residue];
+    });
+}
+function renderReadiness(report) {
+    const readiness = report.readiness;
+    if (!readiness)
+        return ["not evaluated: coordinate race"];
+    return [
+        `delivery residue tracked=${readiness.deliveryResidue.tracked.length} staged=${readiness.deliveryResidue.staged.length} unstaged=${readiness.deliveryResidue.unstaged.length} untracked=${readiness.deliveryResidue.untracked.length}`,
+        `arc open=${readiness.arc.open ?? "none"} max=${readiness.arc.max} fence=${readiness.arc.fence} loose=${readiness.arc.looseCommits.length}`,
+        `renew session=${readiness.renewSession.open ? "open" : "none"}`,
+        `rewrite guard=${readiness.rewriteGuard.liveProjection ? "live projection" : "clear"}`,
+        ...readiness.dependencies.map((item) => `dependency ${item.id} ${item.satisfied ? "satisfied" : `open (${item.state})`}`),
+        `petition state=${readiness.petition.state}${readiness.petition.queue ? ` queue=${readiness.petition.queue.position ?? "?"}/${readiness.petition.queue.length}` : " queue=none"}`,
+    ];
+}
+function omissionLine(omission) {
+    const subject = omission.hunk === null ? "file" : `hunk ${omission.hunk}`;
+    return `omit ${subject} ${omission.path} · ${omission.bytes} bytes · ${omission.reason} · retrieve ${omission.retrieval.argv.map((part) => JSON.stringify(part)).join(" ")}`;
+}
+function renderDiff(report) {
+    if (!report.diff || !report.presentation)
+        return ["not evaluated"];
+    const selected = report.presentation.selected.map((item) => item.content);
+    const omissions = report.presentation.omissions.map(omissionLine);
+    const rows = report.files?.map((file) => `${file.status} ${file.oldPath ? `${file.oldPath} -> ` : ""}${file.path} · +${file.stats.insertions} -${file.stats.deletions} · ${file.class}`) ?? [];
+    return [
+        `${report.diff.stat.filesChanged} files · +${report.diff.stat.insertions} -${report.diff.stat.deletions}`,
+        `budget ${report.presentation.budget.limit} bytes · used ${report.presentation.budget.used} bytes · omissions ${report.presentation.omissions.length}`,
+        ...rows,
+        ...selected,
+        ...omissions,
+    ];
+}
+export function buildAuditResponse(report, json) {
+    const payload = report;
+    if (json)
+        return { text: JSON.stringify(report), payload };
+    const text = [
+        `Audit ${report.contract}`,
+        "",
+        "Coordinates",
+        `ledger ${report.coordinates.ledger.head}`,
+        `delivery ${report.coordinates.delivery.ref} ${report.coordinates.delivery.head} tree ${report.coordinates.delivery.tree}`,
+        `target ${report.coordinates.target.ref} ${report.coordinates.target.head} tree ${report.coordinates.target.tree}`,
+        "",
+        "Criteria",
+        ...report.terms.criteria.map((term) => `criterion ${term}`),
+        ...report.terms.scope.map((term) => `scope ${term}`),
+        ...report.terms.appendScope.map((term) => `append-scope ${term}`),
+        "",
+        "Renew Rehearsal",
+        JSON.stringify(report.rehearsal),
+        "",
+        "Diff",
+        ...renderDiff(report),
+        `counts files=${report.counts.files} selected=${report.counts.selected} omitted=${report.counts.omitted} in-scope=${report.counts.inScope} downgraded=${report.counts.downgraded} violated=${report.counts.violated} findings=${report.counts.findings}`,
+        "",
+        "Scope",
+        ...renderScope(report),
+        "",
+        "Verification",
+        ...renderVerification(report),
+        "Readiness",
+        ...renderReadiness(report),
+        "",
+        "Findings",
+        ...(report.findings.length === 0 ? ["none"] : report.findings.flatMap((finding) => [`${finding.code}: ${finding.detail}`, `Next: ${finding.nextCommand}`])),
+    ].join("\n");
+    return { text, payload };
+}
+export function buildAuditConstructionFailure(error, json) {
+    const cause = { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) };
+    const payload = { audit: { status: "construction_failed", cause } };
+    return {
+        text: json ? JSON.stringify(payload) : `Audit construction failure\n${cause.code}: ${cause.message}`,
+        payload,
+        exitCode: 1,
+    };
+}

package/build/cli/render/errors.js

@@ -1,4 +1,4 @@
-import { asMessage, isFlowError, pickHintsFromError } from "../../flow-error.js";
+import { asMessage, isFlowError, pickHintsFromError, } from "../../flow-error.js";
 import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../../config/settings/loader.js";
 import { loadAkumaCatalog } from "../../config/akuma-loader.js";
@@ -6,6 +6,20 @@ import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { ACTOR_IDENTITY, TOOL_NAMES, BUILTIN_AGENT_NAMES } from "../../keiyaku.js";
 import { buildErrorResponse } from "./misc.js";
 import { addressCarrierFromError } from "../../core/addressing.js";
+import { shellQuote } from "./format.js";
+const TASK_FILTER_GRAMMAR_EXAMPLE = "title~audit,scope";
+function formatTaskFilterExpression(terms) {
+    return terms.map((term) => `${term.field}${term.operator}${term.values.join(",")}`).join("|");
+}
+function renderInvalidTaskFilterMessage(facts) {
+    const guidance = facts.recoveredTerms.length === 0
+        ? `Grammar example: keiyaku task ls --filter ${shellQuote(TASK_FILTER_GRAMMAR_EXAMPLE)}`
+        : `Paste-ready equivalent for parsed terms: keiyaku task ls --filter ${shellQuote(formatTaskFilterExpression(facts.recoveredTerms))}`;
+    return `invalid task filter: ${facts.detail}. Valid fields: ${facts.fields.join(", ")}. `
+        + `Valid operators: ${facts.operators.join(", ")}. `
+        + `Repeat --filter for AND; use commas for same-field OR or | between complete filters. `
+        + guidance;
+}
 function renderScopeViolation(evidence) {
     if (evidence.outcome === "no-positive-match") {
         return `  ${evidence.path}\n    no positive pattern matched`;
@@ -35,6 +49,9 @@ export function renderScopeAuditMessage(scope, evidence) {
     ].join("\n");
 }
 function renderErrorMessage(error) {
+    if (isFlowError(error) && error.facts?.kind === "invalid_task_filter") {
+        return renderInvalidTaskFilterMessage(error.facts);
+    }
     if (isFlowError(error) && error.facts?.kind === "scope_violation") {
         return renderScopeAuditMessage(error.facts.scope, error.facts.violations);
     }

package/build/cli/render/format.js

@@ -1,10 +1,13 @@
 import { getConfig } from "../../config/env.js";
 import { SECTION_ICONS } from "./response-style.js";
-/** Quote a shell argument only when the token is not already a single safe word. */
+// Command-copy output is POSIX shell syntax: close the quote, emit a literal
+// apostrophe, then reopen the quote. Other shell dialects are not supported.
+const POSIX_SINGLE_QUOTE_ESCAPE = "'\\''";
+/** Quote a POSIX shell argument only when the token is not already a single safe word. */
 export function shellQuote(value) {
     if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value))
         return value;
-    return `'${value.replace(/'/g, "'\\''")}'`;
+    return `'${value.replace(/'/g, POSIX_SINGLE_QUOTE_ESCAPE)}'`;
 }
 export function formatAgeMs(ms) {
     if (ms === undefined)

package/build/cli/render/misc.js

@@ -5,7 +5,9 @@ import { prependAddressReceipt, renderAddressCarrier } from "./address.js";
 import { commissionSlug } from "../../core/ids.js";
 export function buildErrorResponse(input) {
     const shouldRaiseProtocolError = input.errorType === "runtime_error";
-    const text = buildErrorText(input);
+    const text = input.errorCode === "PROJECTION_INCOMPATIBLE"
+        ? `${colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`)}\n  ${input.message}`
+        : buildErrorText(input);
     const payload = {
         error: {
             code: input.errorCode,

package/build/cli/render/projection-activity.js

@@ -71,9 +71,19 @@ function summarizeProjectionToolLedger(activity, workspaceRoot) {
 function toolCountSegments(summary) {
     return summary.counts.map(({ semanticClass, count }) => `${count} ${rollupCountLabel(semanticClass)}`);
 }
+function projectionSummarySegments(summary) {
+    const segments = toolCountSegments(summary);
+    if (summary.tokens !== undefined) {
+        segments.push(`${compactTokens(summary.tokens)} tok`);
+    }
+    if (summary.costUsd !== undefined) {
+        segments.push(`$${summary.costUsd.toFixed(2)}`);
+    }
+    return segments;
+}
 export function renderProjectionActivitySummary(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = toolCountSegments(summary);
+    const segments = projectionSummarySegments(summary);
     if (segments.length === 0)
         return undefined;
     const spine = input.state === "dead" || input.state === "lost" ? "┆" : "│";
@@ -81,11 +91,7 @@ export function renderProjectionActivitySummary(activity, input) {
 }
 function renderTerminalRollup(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = [
-        ...toolCountSegments(summary),
-        ...(summary.tokens === undefined ? [] : [`${compactTokens(summary.tokens)} tok`]),
-        ...(summary.costUsd === undefined ? [] : [`$${summary.costUsd.toFixed(2)}`]),
-    ];
+    const segments = projectionSummarySegments(summary);
     const lines = input.diagnostic
         ? [fitVariableLine(`${elapsedLabel(input.anchorMs, input.diagnostic.at).padStart(TIME_GUTTER_WIDTH)}┆ ${"warning".padEnd(VERB_WIDTH)} `, compactText(input.diagnostic.text), input.maxColumns)]
         : [];

package/build/cli/render/status.js

@@ -25,6 +25,7 @@ function projectionGlyph(state) {
         case "startup-timeout":
             return "!";
         case "unknown":
+        case "incompatible":
             return "?";
     }
 }
@@ -44,9 +45,9 @@ function renderTaskStatusSection(tasks) {
         tasks.blocked > 0 ? `${tasks.blocked} blocked` : undefined,
     ].filter((segment) => segment !== undefined);
     const lines = [`tasks · ${segments.join(" / ")}`];
-    lines.push(...tasks.topTasks.map((task) => `  ${task.id} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · ${task.title}`));
+    lines.push(...tasks.topTasks.map((task) => `  ${task.id} · P${task.pri} · ${task.state === "in_progress" ? "in_progress" : "ready"} · age ${formatAgeMs(task.ageMs)} · active ${formatAgeMs(task.activityAgeMs)} · ${task.title}`));
     if (tasks.omitted > 0) {
-        lines.push(`  · +${tasks.omitted} more · shown in_progress then ready; each by priority, created, id`);
+        lines.push(`  · +${tasks.omitted} more — keiyaku task ls`);
     }
     return `${lines.join("\n")}\n`;
 }
@@ -68,30 +69,34 @@ function terminalFailureSuffix(row) {
 function renderProjectionOmission(board) {
     if (!board.omitted)
         return undefined;
-    const counts = ["failed", "dead", "done", "killed", "dismissed"]
+    const counts = ["failed", "dead", "done", "killed", "dismissed", "incompatible"]
         .flatMap((state) => {
         const count = board.omitted?.byState[state] ?? 0;
         return count > 0 ? [`${count} ${state}`] : [];
     });
-    return `  · +${board.omitted.total} not shown (${counts.join(" · ")}) — keiyaku status --all`;
+    return `  · +${board.omitted.total} historical projections not shown (${counts.join(" · ")}) — keiyaku status --all`;
 }
 function renderProjectionAge(row) {
-    const age = formatAgeMs(row.activityAgeMs);
+    const duration = formatAgeMs(row.durationMs) ?? "?";
+    const activity = formatAgeMs(row.activityAgeMs) ?? "?";
+    const facts = `dur ${duration} · active ${activity}`;
     if (row.state === "done")
-        return age ? `done ${age}` : "done";
+        return `done · ${facts}`;
     if (row.state === "killed")
-        return age ? `killed ${age}` : "killed";
+        return `killed · ${facts}`;
     if (row.state === "dismissed")
-        return age ? `dismissed ${age}` : "dismissed";
+        return `dismissed · ${facts}`;
     if (row.state === "failed")
-        return age ? `failed ${age}` : "failed";
+        return `failed · ${facts}`;
     if (row.state === "dead")
-        return age ? `dead ${age}` : "dead";
+        return `dead · ${facts}`;
     if (row.state === "startup-timeout")
-        return "startup timed out";
+        return `startup timed out · ${facts}`;
     if (row.state === "unknown")
-        return "unknown";
-    return formatAgeMs(row.activityAgeMs) ?? "";
+        return `unknown · ${facts}`;
+    if (row.state === "incompatible")
+        return "incompatible history";
+    return facts;
 }
 function renderProjectionTellCounts(row) {
     const { inbox, inflight, submitted, consumed } = row.tellCounts;
@@ -111,10 +116,11 @@ function projectionActivityState(row) {
         case "out": return "running";
         case "startup-timeout": return "stalled";
         case "unknown": return "unknown";
+        case "incompatible": return "unknown";
     }
 }
 function renderProjectionActivityLine(row) {
-    if (row.state === "startup-timeout" || row.state === "unknown")
+    if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible")
         return undefined;
     if (!row.activity)
         return undefined;
@@ -133,15 +139,15 @@ function renderProjectionRow(row) {
                 : row.state);
     const identity = row.alias ? `${row.id} (${row.alias})` : row.id;
     let heading;
-    if (row.state === "startup-timeout" || row.state === "unknown") {
+    if (row.state === "startup-timeout" || row.state === "unknown" || row.state === "incompatible") {
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
         heading = `  ${glyph} ${identity}    ${akuma} ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else if (row.state === "minting") {
-        heading = `  ${glyph} ${identity.padEnd(18)} (minting)${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity.padEnd(18)} (minting) · ${renderProjectionAge(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else {
-        const age = renderProjectionAge(row).padEnd(9);
+        const age = renderProjectionAge(row);
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
         heading = `  ${glyph} ${identity}    ${akuma} ${age}${renderProjectionTellCounts(row)}${terminalFailureSuffix(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
@@ -154,7 +160,8 @@ function isTerminalProjectionStatus(row) {
         || row.state === "killed"
         || row.state === "dismissed"
         || row.state === "failed"
-        || row.state === "dead";
+        || row.state === "dead"
+        || row.state === "incompatible";
 }
 export function renderProjectionFilteredStatus(board, projectionId) {
     const head = board.defaultHead ? shortCommitHash(board.defaultHead) : "(no HEAD)";
@@ -167,6 +174,9 @@ export function renderProjectionFilteredStatus(board, projectionId) {
         return renderTerminalFailureFace(projectionId, row.terminalFailure).join("\n");
     }
     const lines = [heading, "", ...renderProjectionRow(row), ""];
+    if (row.observation.compatibility === "incompatible") {
+        return `${lines.join("\n")}\n`;
+    }
     if (!isTerminalProjectionStatus(row))
         lines.push(`» ${formatTellCommand(projectionId, '"..."')}`);
     lines.push(`» keiyaku wait ${projectionId}`);

package/build/cli/render/success-response.js

@@ -1,4 +1,5 @@
 import { repositoryCoordinateFromAddress } from "../commands/shared.js";
+import { writeCliOutput } from "../output-stream-error-policy.js";
 import { renderResolvedAddressReceipt } from "./address.js";
 import { formatCallNextAction } from "./shared.js";
 function responseText(response) {
@@ -54,24 +55,24 @@ function conversationalFooter(response) {
     }
     return lines.join("\n");
 }
-export function writeSuccessResponse(command, flags, response) {
+export async function writeSuccessResponse(command, flags, response) {
     // Plain tell is always silent; tell --wait owns the ordinary wait response.
     if (command === "tell" && flags.timeoutMs === undefined)
         return;
     if (command === "bind" && flags.dryRun) {
         // Canonical Markdown already ends with exactly one newline.
-        process.stdout.write(responseText(response));
+        await writeCliOutput(process.stdout, responseText(response));
         return;
     }
     if (command !== "revive") {
-        process.stdout.write(`${responseText(response)}\n`);
+        await writeCliOutput(process.stdout, `${responseText(response)}\n`);
         return;
     }
     const data = responseData(response);
     const answer = typeof data.summary === "string" ? data.summary.trim() : responseText(response).trim();
     const footer = conversationalFooter(response);
-    process.stdout.write(`${answer}\n`);
+    await writeCliOutput(process.stdout, `${answer}\n`);
     if (footer) {
-        process.stderr.write(`${footer}\n`);
+        await writeCliOutput(process.stderr, `${footer}\n`);
     }
 }

package/build/cli/render/task.js

@@ -1,17 +1,11 @@
 import { commissionSlug } from "../../core/ids.js";
+import { deriveTaskDisplay as deriveStructuredTaskDisplay, selectTaskList, } from "../../core/task/index.js";
 export function shortContractId(contractId) {
     return commissionSlug(contractId);
 }
 export function deriveTaskDisplay(task) {
-    if (task.state === "done")
-        return "done";
-    if (task.state === "drop")
-        return "dropped";
-    if (task.contractId !== undefined)
-        return `bound(${shortContractId(task.contractId)})`;
-    if (task.state === "in_progress")
-        return "in_progress";
-    return task.blocked ? "blocked" : "ready";
+    const display = deriveStructuredTaskDisplay(task);
+    return display === "bound" ? `bound(${shortContractId(task.contractId)})` : display;
 }
 function renderTaskRowWithId(task, id) {
     return `${id} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
@@ -25,43 +19,14 @@ export function renderTaskMutationRow(task) {
 export function renderTaskRow(task, completeId = false) {
     return completeId ? renderTaskMutationRow(task) : renderTaskListRow(task);
 }
-function displayOrder(display) {
-    if (display === "in_progress")
-        return 0;
-    if (display === "ready")
-        return 1;
-    if (display === "blocked")
-        return 2;
-    if (display.startsWith("bound("))
-        return 3;
-    return display === "done" ? 4 : 5;
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function compareTasks(left, right) {
-    const displayDifference = displayOrder(deriveTaskDisplay(left)) - displayOrder(deriveTaskDisplay(right));
-    if (displayDifference !== 0)
-        return displayDifference;
-    if (left.pri !== right.pri)
-        return left.pri - right.pri;
-    const createdDifference = compareText(left.createdAt, right.createdAt);
-    return createdDifference || compareText(left.id, right.id);
-}
-function selected(task, selection) {
-    const display = deriveTaskDisplay(task);
-    const terminal = display === "done" || display === "dropped";
-    if (selection === "done")
-        return terminal;
-    if (selection === "default")
-        return !terminal;
-    return true;
-}
 export function groupAndSortTasks(tasks, selection = "default") {
-    return tasks.filter((task) => selected(task, selection)).sort(compareTasks);
+    return selectTaskList(tasks, { selection });
 }
 export function renderTaskList(tasks, options = {}) {
-    return groupAndSortTasks(tasks, options.selection).map(renderTaskListRow).join("\n");
+    return selectTaskList(tasks, options).map(renderTaskListRow).join("\n");
+}
+export function renderSelectedTaskList(tasks) {
+    return tasks.map(renderTaskListRow).join("\n");
 }
 function renderIds(ids) {
     return ids.length === 0 ? "(none)" : ids.join(", ");
@@ -128,6 +93,7 @@ export function taskJson(task) {
         from: [...task.from],
         contractId: task.contractId ?? null,
         createdAt: task.createdAt,
+        updatedAt: task.updatedAt ?? task.createdAt,
         creator: task.creator,
     };
 }
@@ -151,3 +117,6 @@ export function renderTaskShowJson(task, tree) {
 export function renderTaskListJson(tasks, selection = "default") {
     return `${JSON.stringify(groupAndSortTasks(tasks, selection).map(taskJson))}\n`;
 }
+export function renderSelectedTaskListJson(tasks) {
+    return `${JSON.stringify(tasks.map(taskJson))}\n`;
+}

package/build/cli/render/terminal-failure.js

@@ -14,6 +14,10 @@ export function terminalFailureColdStatement(failure) {
     switch (failure.code) {
         case "SUBAGENT_TIMEOUT":
             return "the akuma went silent";
+        case "SUBAGENT_TRANSPORT_ERROR":
+            return "the provider transport failed";
+        case "SUBAGENT_POLICY_BUDGET":
+            return "the execution policy budget expired";
         case "SUBAGENT_PROVIDER_UNAVAILABLE":
             return "the provider did not answer";
         case "SUBAGENT_NON_ZERO_EXIT":
@@ -29,8 +33,9 @@ function terminalFailureEvidence(failure, statement) {
         && failure.code === "SUBAGENT_NON_ZERO_EXIT"
         && failure.exitCode !== undefined;
     const parts = [];
-    if (failure.timeoutMs !== undefined)
-        parts.push(`idle ${failure.timeoutMs}ms`);
+    if (failure.timeoutMs !== undefined) {
+        parts.push(failure.code === "SUBAGENT_POLICY_BUDGET" ? `budget ${failure.timeoutMs}ms` : `idle ${failure.timeoutMs}ms`);
+    }
     if (failure.signal)
         parts.push(`signal ${failure.signal}`);
     if (!exitAlreadyInStatement && failure.exitCode !== undefined)

package/build/cli/render/wait.js

@@ -1,4 +1,4 @@
-import { formatTimelineDuration, renderProjectionActivity, } from "./projection-activity.js";
+import { formatTimelineDuration, renderProjectionActivity, renderProjectionActivitySummary, } from "./projection-activity.js";
 import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
 import { formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
@@ -220,7 +220,22 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (rendered.lines.length === 0 && state === "running") {
         lines.push("   not a word out of it yet — pulse is steady");
     }
-    const nextActions = nextActionLines(options.alias ?? projectionId, result, state);
+    // Live/timeout observation faces keep the bounded activity window and add the
+    // existing compact rollup after those rows. Terminal faces already own end└
+    // and must not duplicate it; returned response-only faces never reach here.
+    if (!rendered.hasEndAnchor) {
+        const summary = renderProjectionActivitySummary(snapshot.activity, {
+            state,
+            ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
+            maxColumns,
+        });
+        if (summary) {
+            lines.push(summary);
+        }
+    }
+    const nextActions = state === "running" && options.runningActions === false
+        ? []
+        : nextActionLines(options.alias ?? projectionId, result, state);
     if (nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);
@@ -237,15 +252,28 @@ export function buildProjectionWaitSetResponse(result) {
     const rendered = result.results
         .slice()
         .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
-        .map((member) => ({ id: member.id, response: buildWaitResponse(member.id, member.result) }));
-    const text = rendered.map(({ id, response }) => `${id}\n${response.text}`).join("\n\n");
-    const selectionSucceeded = result.selection === "all"
-        ? result.results.every((member) => member.result.state === "terminal" && member.result.verdict.state === "completed")
-        : result.selectedId !== undefined;
+        .map((member) => ({
+        id: member.id,
+        result: member.result,
+        response: buildWaitResponse(member.id, member.result, { runningActions: false }),
+    }));
+    const liveIds = rendered
+        .filter((member) => member.result.state === "timeout")
+        .map((member) => member.id);
+    const blocks = rendered.map(({ id, response }) => `${id}\n${response.text}`);
+    if (liveIds.length > 0) {
+        blocks.push([
+            "Come back for the result:",
+            `  » keiyaku wait ${liveIds.join(" ")} --${result.selection} [--timeout DURATION]`,
+            "Steer them while they work:",
+            `  » ${formatTellCommand("<projection-id>", '"your words"')}`,
+        ].join("\n"));
+    }
+    const text = blocks.join("\n\n");
     const exitCode = rendered.reduce((current, { response }) => {
         if (response.exitCode === 130)
             return 130;
         return response.exitCode === 1 ? 1 : current;
-    }, selectionSucceeded ? undefined : 1);
+    }, undefined);
     return exitCode === undefined ? textResponse(text) : { ...textResponse(text), exitCode };
 }

package/build/config/env-keys.js

@@ -10,6 +10,7 @@ export const ENV_KEYS = {
     AGENT_OVERRIDE: "KEIYAKU_AGENT_OVERRIDE",
     DISABLE_SUBAGENT_SPAWN: DISABLE_SUBAGENT_SPAWN_ENV_KEY,
     SUBAGENT_EXEC_IDLE_TIMEOUT_MS: "KEIYAKU_SUBAGENT_EXEC_IDLE_TIMEOUT_MS",
+    SUBAGENT_EXEC_MAX_DURATION_MS: "KEIYAKU_SUBAGENT_EXEC_MAX_DURATION_MS",
     CODEX_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_CODEX_EXEC_MAX_CAPTURE_CHARS",
     CLAUDE_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_CLAUDE_EXEC_MAX_CAPTURE_CHARS",
     OPENCODE_EXEC_MAX_CAPTURE_CHARS: "KEIYAKU_OPENCODE_EXEC_MAX_CAPTURE_CHARS",
@@ -26,6 +27,7 @@ const ENV_KEY_ENTRIES = [
     { key: ENV_KEYS.AGENT_OVERRIDE, defaultValue: "", description: "Override default agent name", category: "subagent" },
     { key: ENV_KEYS.DISABLE_SUBAGENT_SPAWN, defaultValue: "0", description: "Disable subprocess subagent spawning when set to 1", category: "subagent" },
     { key: ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS, defaultValue: "300000", description: "Subagent provider-ingress idle timeout in milliseconds", category: "subagent" },
+    { key: ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS, defaultValue: "3600000", description: "Subagent absolute execution policy budget in milliseconds", category: "subagent" },
     { key: ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Codex runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Claude runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "OpenCode runtime output/diagnostics capture cap", category: "subagent" },

package/build/config/env.js

@@ -141,6 +141,7 @@ const subagentSchema = z.object({
     nameOverride: z.string().default(getEnvDefaultValue(ENV_KEYS.AGENT_OVERRIDE)).transform((value) => value.trim()),
     disableSpawn: booleanFlagEnv(ENV_KEYS.DISABLE_SUBAGENT_SPAWN),
     execIdleTimeoutMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS),
+    execMaxDurationMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS),
 });
 const codexSchema = z.object({
     execMaxCaptureChars: positiveIntEnv(ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS),
@@ -175,6 +176,7 @@ const envSchema = z
     [ENV_KEYS.AGENT_OVERRIDE]: z.string().optional(),
     [ENV_KEYS.DISABLE_SUBAGENT_SPAWN]: z.string().optional(),
     [ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS]: z.string().optional(),
+    [ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS]: z.string().optional(),
     [ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
     [ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
     [ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS]: z.string().optional(),
@@ -195,6 +197,7 @@ const envSchema = z
         nameOverride: rawEnv[ENV_KEYS.AGENT_OVERRIDE],
         disableSpawn: rawEnv[ENV_KEYS.DISABLE_SUBAGENT_SPAWN],
         execIdleTimeoutMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS],
+        execMaxDurationMs: rawEnv[ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS],
     }),
     codex: codexSchema.parse({
         execMaxCaptureChars: rawEnv[ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS],