@astrosheep/keiyaku 2.8.5 → 2.9.0

package/build/cli/parse.js

@@ -1,7 +1,9 @@
 import { FlowError } from "../flow-error.js";
-import { agentNameSchema } from "../config/settings.js";
+import { agentNameSchema } from "../config/settings/schema.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { BOOLEAN_FLAGS, CONTROL_FLAGS, HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
+import { commandParseOrder, getCommandMetadata } from "./commands/registry.js";
+import { TASK_SUBCOMMANDS } from "./types.js";
 /** Commands that may carry an explicit commission selector (@ or --contract). */
 const COMMISSION_SELECTOR_COMMANDS = new Set([
     "arc",
@@ -15,56 +17,11 @@ const COMMISSION_SELECTOR_COMMANDS = new Set([
     "petition",
     "forfeit",
 ]);
-const CLI_COMMAND_ORDER = [
-    "bind",
-    "arc",
-    "call",
-    "revive",
-    "wait",
-    "tell",
-    "kill",
-    "log",
-    "akuma list",
-    "akuma ls",
-    "akuma show",
-    "skills install",
-    "skills",
-    "akuma",
-    "amend",
-    "renew",
-    "forfeit",
-    "petition",
-    "guide",
-    "completion",
-    "status",
-    "dump-env",
-];
-const COMMAND_FLAGS = {
-    // contract is parseable on bind only so the mouth can reject it with bind-specific copy.
-    bind: ["cwd", "repo", "contract", "after", "exclusive", "draft-only"],
-    arc: ["cwd", "repo", "contract", "waive"],
-    call: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach", "alias"],
-    revive: ["cwd", "repo", "model", "effort"],
-    wait: ["cwd", "repo", "contract", "timeout"],
-    tell: ["cwd", "repo", "contract", "effort"],
-    kill: ["cwd", "repo", "contract"],
-    log: ["cwd", "repo", "contract"],
-    akuma: [],
-    "akuma ls": ["cwd", "repo"],
-    "akuma list": ["cwd", "repo"],
-    "akuma show": ["cwd", "repo"],
-    skills: [],
-    "skills install": ["force"],
-    amend: ["cwd", "repo", "contract"],
-    renew: ["cwd", "repo", "contract", "waive"],
-    petition: ["cwd", "repo", "contract", "waive"],
-    forfeit: ["cwd", "repo", "contract", "reason"],
-    guide: [],
-    completion: ["cwd", "repo", "shell", "word", "previous", "complete"],
-    status: ["cwd", "repo", "target", "all"],
-    "dump-env": [],
-};
-const STDIN_COMMANDS = new Set(["bind", "arc", "amend"]);
+/** Parse-time allowed flags; prefers meta.parseFlags when help flags omit a mouth-only flag. */
+function allowedFlagsForParse(command) {
+    const meta = getCommandMetadata(command);
+    return meta.parseFlags ?? meta.flags;
+}
 export function normalizeContractAddress(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
     if (!value.trim()) {
@@ -75,8 +32,35 @@ export function normalizeContractAddress(raw) {
 export function isCallCommand(command) {
     return command === "call";
 }
+/** Identify petition --dry-run before parsing without mistaking flag values or literal payload. */
+export function isPetitionDryRunInvocation(tokens) {
+    const boundary = tokens.indexOf("--");
+    const head = boundary === -1 ? tokens : tokens.slice(0, boundary);
+    if (!head.some((token) => token === "--dry-run" || token.startsWith("--dry-run=")))
+        return false;
+    for (let index = 0; index < head.length; index += 1) {
+        const token = head[index];
+        if (HELP_FLAGS.has(token) || token.startsWith("@"))
+            continue;
+        if (/^-[A-Za-z]$/.test(token)) {
+            const name = SHORT_FLAG_ALIASES[token.slice(1)];
+            if (name && VALUE_FLAGS.has(name))
+                index += 1;
+            continue;
+        }
+        if (token.startsWith("--")) {
+            const eq = token.indexOf("=");
+            const name = parseFlagName(eq === -1 ? token : token.slice(0, eq));
+            if (eq === -1 && VALUE_FLAGS.has(name))
+                index += 1;
+            continue;
+        }
+        return token === "petition";
+    }
+    return false;
+}
 export function commandUsesPromptInput(command) {
-    return isCallCommand(command) || command === "revive";
+    return isCallCommand(command) || command === "tell" || command === "revive";
 }
 export function parseWaitTimeout(value) {
     const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
@@ -92,24 +76,34 @@ export function parseWaitTimeout(value) {
     return timeoutMs;
 }
 export function commandPositionalRange(command) {
-    if (command === "akuma show")
+    if (command === "akuma view")
         return { min: 1, max: 1, label: "<name>" };
     if (command === "log")
         return { min: 0, max: 0, label: "" };
+    if (isCallCommand(command))
+        return { min: 1, max: 1, label: "<BODY|->" };
+    if (command === "tell")
+        return { min: 2, max: 2, label: "<PROJECTION> <BODY|->" };
     if (command === "revive")
-        return { min: 1, max: 1, label: "<artifact-id>" };
+        return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
     if (command === "wait")
         return { min: 1, max: 1, label: "<projection-address>" };
-    if (command === "tell")
-        return { min: 2, max: 2, label: "<projection> <message>" };
     if (command === "kill")
         return { min: 1, max: 1, label: "<projection-address>" };
-    if (isCallCommand(command))
-        return { min: 0, max: 1 };
+    if (command === "status")
+        return { min: 0, max: 1, label: "[projection-id]" };
+    if (command === "task add")
+        return { min: 1, max: 1, label: "<BODY|->" };
+    if (command === "task view" || command === "task start" || command === "task drop")
+        return { min: 1, max: 1, label: "<ID>" };
+    if (command === "task update")
+        return { min: 1, max: 1, label: "<ID>" };
+    if (command === "task stop" || command === "task done")
+        return { min: 0, max: 1, label: "[ID]" };
     return { min: 0, max: 0 };
 }
 function commandRequiresStdin(command) {
-    return STDIN_COMMANDS.has(command);
+    return getCommandMetadata(command).stdin === "required";
 }
 function commandTokens(command) {
     return command.split(" ");
@@ -139,6 +133,7 @@ function assignFlag(flags, name, value) {
             flags.alias = String(value);
             return;
         case "timeout":
+        case "wait":
             flags.timeoutMs = parseWaitTimeout(String(value));
             return;
         case "model":
@@ -164,6 +159,35 @@ function assignFlag(flags, name, value) {
         case "exclusive":
             flags.exclusive = Boolean(value);
             return;
+        case "place":
+            if (flags.bindPlace !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --place may only be specified once");
+            }
+            flags.bindPlace = String(value);
+            return;
+        case "objective":
+            if (flags.bindObjective !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --objective may only be specified once");
+            }
+            flags.bindObjective = String(value);
+            return;
+        case "scope":
+            if (flags.bindScope !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --scope may only be specified once");
+            }
+            flags.bindScope = String(value);
+            return;
+        case "checks":
+            if (flags.bindChecks !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --checks may only be specified once");
+            }
+            flags.bindChecks = String(value);
+            return;
+        case "task":
+            if (flags.bindTaskId !== undefined)
+                throw new FlowError("EMPTY_PARAM", "option --task may only be specified once");
+            flags.bindTaskId = String(value);
+            return;
         case "after":
             flags.after = [...(flags.after ?? []), String(value)];
             return;
@@ -200,12 +224,54 @@ function assignFlag(flags, name, value) {
             }
             flags.target = String(value);
             return;
+        case "json":
+            flags.json = Boolean(value);
+            return;
+        case "done":
+            flags.done = Boolean(value);
+            return;
+        case "pri": {
+            const raw = String(value);
+            if (!/^[0-3]$/.test(raw))
+                throw new FlowError("EMPTY_PARAM", "task priority must be an integer from 0 through 3");
+            if (flags.taskPri !== undefined)
+                throw new FlowError("EMPTY_PARAM", "option --pri may only be specified once");
+            flags.taskPri = Number(raw);
+            return;
+        }
+        case "needs":
+            flags.taskNeeds = [...(flags.taskNeeds ?? []), String(value)];
+            return;
+        case "drop-needs":
+            flags.taskDropNeeds = [...(flags.taskDropNeeds ?? []), String(value)];
+            return;
+        case "from":
+            flags.taskFrom = [...(flags.taskFrom ?? []), String(value)];
+            return;
+        case "parent":
+            if (flags.taskParent !== undefined)
+                throw new FlowError("EMPTY_PARAM", "option --parent may only be specified once");
+            flags.taskParent = String(value);
+            return;
+        case "no-parent":
+            flags.taskNoParent = Boolean(value);
+            return;
+        case "title":
+            if (flags.taskTitle !== undefined)
+                throw new FlowError("EMPTY_PARAM", "option --title may only be specified once");
+            flags.taskTitle = String(value);
+            return;
+        case "body":
+            if (flags.taskBody !== undefined)
+                throw new FlowError("EMPTY_PARAM", "option --body may only be specified once");
+            flags.taskBody = String(value);
+            return;
         default:
             throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
     }
 }
 function assertAllowedFlag(command, name) {
-    if (!COMMAND_FLAGS[command].includes(name)) {
+    if (!allowedFlagsForParse(command).includes(name)) {
         throw new FlowError("EMPTY_PARAM", `option --${name} is not valid for ${command}`);
     }
 }
@@ -213,7 +279,7 @@ function resolveCommand(tokens) {
     if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
         throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);
     }
-    for (const command of CLI_COMMAND_ORDER) {
+    for (const command of commandParseOrder()) {
         const parts = commandTokens(command);
         if (parts.every((part, index) => tokens[index] === part)) {
             return { command, rest: tokens.slice(parts.length) };
@@ -234,11 +300,11 @@ function splitAtLiteralBoundary(tokens) {
     return { head: tokens.slice(0, boundary), payload: tokens.slice(boundary + 1) };
 }
 function readValueFlag(name, token, eq, tokens, index) {
-    // --target alone owns emptiness in core; empty remains a supplied value.
+    // --target and task --body own emptiness in core; empty remains supplied.
     // Other value flags keep the historical requires-a-value rejection.
     if (eq !== -1) {
         const value = token.slice(eq + 1);
-        if (value === "" && name !== "target") {
+        if (value === "" && name !== "target" && name !== "body") {
             throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
         }
         return { value, nextIndex: index };
@@ -247,7 +313,7 @@ function readValueFlag(name, token, eq, tokens, index) {
     if (value === undefined || value === "--" || value.startsWith("--")) {
         throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
     }
-    if (value === "" && name !== "target") {
+    if (value === "" && name !== "target" && name !== "body") {
         throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
     }
     // Short-flag values may begin with @; they are flag values, not commission tokens.
@@ -322,9 +388,6 @@ export function parseCliArgs(tokens) {
         }
         const eq = token.indexOf("=");
         const name = parseFlagName(eq === -1 ? token : token.slice(0, eq));
-        if (name === "place") {
-            throw new FlowError("EMPTY_PARAM", "unknown option --place; use @addr or --contract <addr>");
-        }
         if (!CONTROL_FLAGS.has(name)) {
             throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
         }
@@ -376,14 +439,38 @@ export function parseCliArgs(tokens) {
         };
     }
     if (command === "akuma") {
-        throw new FlowError("EMPTY_PARAM", "akuma requires subcommand: list, ls, or show");
+        throw new FlowError("EMPTY_PARAM", "akuma requires subcommand: ls or view");
     }
     if (command === "skills") {
         throw new FlowError("EMPTY_PARAM", "skills requires subcommand: install");
     }
+    if (command === "task") {
+        throw new FlowError("EMPTY_PARAM", `task requires subcommand: ${TASK_SUBCOMMANDS.join(", ")}`);
+    }
+    // --place is bind's H1 domain flag; every other command keeps the retired-selector mouth.
+    if (command !== "bind" && seenFlagNames.has("place")) {
+        throw new FlowError("EMPTY_PARAM", "unknown option --place; use @addr or --contract <addr>");
+    }
     for (const name of seenFlagNames) {
         assertAllowedFlag(command, name);
     }
+    if (command === "call" && flags.detach && flags.timeoutMs !== undefined) {
+        throw new FlowError("EMPTY_PARAM", "call cannot combine --detach and --wait");
+    }
+    if (command === "task ls" && flags.all && flags.done) {
+        throw new FlowError("EMPTY_PARAM", "task ls cannot combine --all and --done");
+    }
+    if (command === "task update" && flags.taskParent !== undefined && flags.taskNoParent) {
+        throw new FlowError("EMPTY_PARAM", "task update cannot combine --parent and --no-parent");
+    }
+    if (command === "task update" && flags.taskTitle === undefined && flags.taskBody === undefined
+        && flags.taskPri === undefined && flags.taskNeeds === undefined && flags.taskDropNeeds === undefined
+        && flags.taskParent === undefined && !flags.taskNoParent && flags.taskFrom === undefined) {
+        throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
+    }
+    if (command === "petition" && flags.json && !flags.dryRun) {
+        throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
+    }
     if (flags.contractId !== undefined && !COMMISSION_SELECTOR_COMMANDS.has(command)) {
         throw new FlowError("EMPTY_PARAM", command === "bind"
             ? `bind creates a commission and does not accept @${flags.contractId}; use -C/--cwd to select the repository`
@@ -404,25 +491,25 @@ export function parseCliArgs(tokens) {
     if (isCallCommand(command)) {
         if (flags.akuma) {
             if (positional.length > 1) {
-                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one prompt argument when --akuma is used`);
+                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one <BODY|-> when --akuma is used`);
             }
         }
         else {
             const [name] = positional;
             if (!name) {
-                throw new FlowError("EMPTY_PARAM", `${command} requires an agent name; use \`keiyaku ${command} NAME [prompt|-]\``);
+                throw new FlowError("EMPTY_PARAM", `${command} requires an agent name; use \`keiyaku ${command} NAME <BODY|->\``);
             }
             if (isResponseArtifactId(name)) {
                 throw new FlowError("EMPTY_PARAM", `artifact ${name} is a response artifact; call expects an Akuma profile name`);
             }
             const parsedName = agentNameSchema.safeParse(name);
             if (!parsedName.success) {
-                throw new FlowError("EMPTY_PARAM", `${command} requires a valid agent name before the optional prompt`);
+                throw new FlowError("EMPTY_PARAM", `${command} requires a valid agent name before <BODY|->`);
             }
             flags.akuma = parsedName.data;
             positional.shift();
             if (positional.length > 1) {
-                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one prompt argument after the agent name`);
+                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one <BODY|-> after the agent name`);
             }
         }
     }

package/build/cli/projection-address.js

@@ -5,6 +5,7 @@ import { resolveProjectionCoordinate } from "../core/projection-coordinate.js";
 import { isProjectionId, projectionDir } from "../core/projection-core.js";
 import { isProjectionAlias, readProjectionAlias } from "../core/projection-alias.js";
 import { readProjectionIdentity } from "../core/projection-identity.js";
+import { isProjectionGenerationSchemaV1Residue } from "../core/projection/generation/store.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { isErrnoException } from "../errno.js";
 function isRealDirectory(directory) {
@@ -80,6 +81,10 @@ export async function resolveProjectionAddress(input) {
         const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
         throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
     }
+    if (isProjectionGenerationSchemaV1Residue(directory)) {
+        const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
+        throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
+    }
     let identity;
     try {
         identity = readProjectionIdentity(directory);

package/build/cli/render/arc.js

@@ -1,4 +1,4 @@
-import { shortCommitHash } from "../../core/render.js";
+import { shortCommitHash } from "../../git/commits.js";
 import { assembleResponse, buildPayload, buildSection, formatHints, formatList, formatMaybe, formatWarnings, } from "./format.js";
 import { DIFF_OVERVIEW_SECTION_TITLE, RESPONSE_MARKERS, WARNING_SECTION_TITLE } from "./response-style.js";
 import { appendPersistenceSummary, BRANCH_LABEL, CONTENT_SECTION_TITLE, HINTS_LIST_MAX_ITEMS, HINTS_SECTION_TITLE, INFO_BRANCH_MAX_CHARS, INFO_COMMIT_MAX_CHARS, INFO_PLEA_MAX_CHARS, INFO_SECTION_TITLE, } from "./shared.js";

package/build/cli/render/errors.js

@@ -1,6 +1,7 @@
 import { asMessage, isFlowError, pickHintsFromError } from "../../flow-error.js";
-import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../../config/settings.js";
-import { loadAkumaCatalogV2 } from "../../config/akuma-loader_v2.js";
+import { assertSettingsKnobUsable } from "../../config/settings/disease.js";
+import { loadKeiyakuSettings } from "../../config/settings/loader.js";
+import { loadAkumaCatalog } from "../../config/akuma-loader.js";
 import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { ACTOR_IDENTITY, TOOL_NAMES, BUILTIN_AGENT_NAMES } from "../../keiyaku.js";
 import { buildErrorResponse } from "./misc.js";
@@ -18,7 +19,7 @@ async function getAvailableActorNames(cwd, fallback) {
     try {
         const loaded = await loadKeiyakuSettings(cwd);
         assertSettingsKnobUsable(loaded, "agents");
-        return Object.keys((await loadAkumaCatalogV2(cwd)).selected);
+        return Object.keys((await loadAkumaCatalog(cwd)).selected);
     }
     catch {
         return [...fallback];

package/build/cli/render/format.js

@@ -6,6 +6,20 @@ export function shellQuote(value) {
         return value;
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
+export function formatAgeMs(ms) {
+    if (ms === undefined)
+        return undefined;
+    const seconds = Math.max(0, Math.floor(ms / 1_000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
 export const DISPLAY_TEXT_MAX_CHARS = 5000;
 export const FORMAT_MAYBE_MAX_CHARS = 1200;
 export const FORMAT_LIST_MAX_ITEMS = 20;

package/build/cli/render/kanshi.js

@@ -0,0 +1,106 @@
+import { formatAgeMs } from "./format.js";
+function shortHead(hash) {
+    if (!hash)
+        return "????????";
+    return hash.slice(0, 7);
+}
+function compactWhitespace(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function arcSparkline(arcs) {
+    if (arcs <= 0)
+        return "";
+    return Array.from({ length: arcs }, () => "·").join("──");
+}
+function pendingAfterIds(contract) {
+    return contract.after.filter((item) => !item.terminal).map((item) => item.id);
+}
+function kanshiGlyph(contract) {
+    if (contract.state.state === "corrupt")
+        return "×";
+    if (pendingAfterIds(contract).length > 0)
+        return "○";
+    if (contract.state.state === "petitioned")
+        return "◎";
+    return "●";
+}
+function renderDriftMark(drift) {
+    if (drift.state === "drift")
+        return `▲${drift.behindBy}`;
+    if (drift.state === "orphaned")
+        return "▲orphaned";
+    return undefined;
+}
+export function renderKanshiBoard(status) {
+    const head = shortHead(status.defaultHead);
+    if (status.contracts.length === 0) {
+        if (status.targetFilter !== null) {
+            return `現世 ${head} · target ${status.targetFilter}\nno commissions on target ${status.targetFilter}\n`;
+        }
+        return `現世 ${head} 无在飞契约\n`;
+    }
+    const header = status.targetFilter !== null
+        ? `現世 ${head} · target ${status.targetFilter}`
+        : `現世 ${head}`;
+    const lines = [header, ""];
+    for (const contract of status.contracts) {
+        const glyph = kanshiGlyph(contract);
+        const name = contract.slug;
+        const spark = arcSparkline(contract.arcs);
+        const facts = [];
+        const lifecycle = contract.state.state;
+        if (lifecycle === "bound" || lifecycle === "active" || lifecycle === "petitioned") {
+            facts.push(lifecycle);
+        }
+        if (contract.place) {
+            facts.push(`@${contract.place}`);
+        }
+        const arcObjective = compactWhitespace(contract.currentArc.objective || "(no arc objective)");
+        const arcMark = contract.currentArc.state === "open"
+            ? `a${contract.currentArc.number}+`
+            : `a${contract.currentArc.number}`;
+        facts.push(`${arcMark} ${arcObjective}`);
+        facts.push(`next ${contract.nextStep.detail}`);
+        const age = formatAgeMs(contract.lastActiveMs);
+        if (age)
+            facts.push(age);
+        if (contract.queuePosition)
+            facts.push(`Q${contract.queuePosition}`);
+        const drift = renderDriftMark(contract.baseDrift);
+        if (drift)
+            facts.push(drift);
+        if (contract.nextStep.hint)
+            facts.push(contract.nextStep.hint);
+        const pending = pendingAfterIds(contract);
+        if (pending.length > 0) {
+            facts.push(`⧗ ${pending.map((id) => {
+                const dot = id.indexOf(".");
+                return dot > 0 ? id.slice(0, dot) : id;
+            }).join(",")}`);
+        }
+        if (contract.state.state === "corrupt") {
+            facts.push(`corrupt (${contract.state.reason ?? contract.corruptReason ?? "unknown"})`);
+        }
+        if (contract.queueHeadStalled) {
+            facts.push("朱 stall 去广场");
+        }
+        const sparkCol = spark.padEnd(14);
+        const factText = facts.join(" · ");
+        lines.push(`${glyph} ${name.padEnd(18)} ${sparkCol} ${factText}`.trimEnd());
+        if (contract.bootstrapDiagnostics.some((diagnostic) => diagnostic.kind === "plan-without-result")) {
+            lines.push("  ! bootstrap · no result recorded · forfeit and re-bind");
+        }
+        for (const diagnostic of contract.queueDiagnostics) {
+            if (diagnostic.kind === "legacy-petition") {
+                lines.push("  ! legacy petition · no seat · reject then re-petition");
+                continue;
+            }
+            if (diagnostic.kind === "duplicate-seat") {
+                lines.push(`  ! seat ${diagnostic.seat} duplicated with ${diagnostic.with} · ordered by contract id`);
+                continue;
+            }
+            lines.push(`  ! target mismatch · petitioned ${diagnostic.petitioned} · derived ${diagnostic.derived}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}

package/build/cli/render/petition.js

@@ -1,8 +1,31 @@
-import { shortCommitHash } from "../../core/render.js";
+import { shortCommitHash } from "../../git/commits.js";
 import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnings, } from "./format.js";
 import { DIFF_OVERVIEW_SECTION_TITLE, RESPONSE_MARKERS, WARNING_SECTION_TITLE } from "./response-style.js";
 import { BRANCH_LABEL, INFO_BRANCH_MAX_CHARS, INFO_COMMIT_MAX_CHARS, INFO_PLEA_MAX_CHARS, } from "./shared.js";
 import { prependAddressReceipt } from "./address.js";
+export function buildPetitionPreviewResponse(preview, json) {
+    const failed = preview.gates.filter((gate) => gate.result === "failed").length;
+    const text = json
+        ? JSON.stringify(preview)
+        : [
+            `contract ${preview.contract}`,
+            `target ${preview.target}`,
+            `arc ${preview.arc.source}`,
+            ...preview.gates.map((gate) => {
+                if (gate.result === "not_evaluated")
+                    return `gate ${gate.name} · not evaluated`;
+                if (gate.result === "failed")
+                    return `gate ${gate.name} · failed · ${gate.detail ?? "failed"}`;
+                return `gate ${gate.name} · pass${gate.detail ? ` · ${gate.detail}` : ""}`;
+            }),
+            failed === 0 ? "would succeed" : `would fail (${failed} gates failed)`,
+        ].join("\n");
+    return {
+        text,
+        payload: preview,
+        ...(failed > 0 ? { exitCode: 1 } : {}),
+    };
+}
 export function buildPetitionClaimResponse(result, input) {
     const { status: _status, address: _address, ...resultData } = result;
     const renderedCommit = result.commit ? shortCommitHash(result.commit) : undefined;

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

@@ -41,6 +41,10 @@ function compactTokens(value) {
 }
 function warningText(row) {
     const warning = row.warning;
+    if (warning.reason === "retry") {
+        const status = warning.errorStatus === null ? "no response" : String(warning.errorStatus);
+        return `provider retrying ${warning.attempt}/${warning.maxRetries} · retry in ${formatTimelineDuration(warning.retryDelayMs)} · status ${status}${row.count > 1 ? ` (${row.count})` : ""}`;
+    }
     const modelRoute = warning.originalModel && warning.fallbackModel
         ? ` ${warning.originalModel}→${warning.fallbackModel}`
         : warning.direction
@@ -166,7 +170,7 @@ export function renderProjectionActivity(activity, input) {
                 ? ` · ${compactTokens(row.inputTokens)}▸${compactTokens(row.outputTokens)} tok`
                 : "";
             const cost = row.costUsd !== undefined ? ` · $${row.costUsd.toFixed(2)}` : "";
-            lines.push(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}├ `, `turn ${row.turn} sealed${usage}${cost}`, maxColumns));
+            lines.push(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}├ `, `turn ${row.turn}${usage}${cost}`, maxColumns));
         }
     }
     for (const row of activity.pinned) {

package/build/cli/render/shared.js

@@ -128,7 +128,7 @@ export function formatDurableReviveCommand(input) {
 export function projectionRejoinHintLines(projectionId) {
     return [
         "Come back for the result:",
-        `  » keiyaku wait ${projectionId}`,
+        `  » keiyaku wait ${projectionId} [--timeout DURATION]`,
         "Steer it while it works:",
         `  » keiyaku tell ${projectionId} "your words"`,
     ];
@@ -145,7 +145,7 @@ export function formatCallNextAction(input) {
             `  » keiyaku tell ${input.projection.alias ?? input.projection.id} "your words"`,
         ].join("\n");
     }
-    return "⟶ keiyaku status";
+    return "» keiyaku status";
 }
 export function appendPersistenceSummary(base, responsePath) {
     const persistence = formatPersistenceSummary(responsePath);