@astrosheep/keiyaku 2.8.5 → 2.9.1

package/build/cli/parse.js

@@ -1,276 +1,11 @@
 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";
-/** Commands that may carry an explicit commission selector (@ or --contract). */
-const COMMISSION_SELECTOR_COMMANDS = new Set([
-    "arc",
-    "amend",
-    "call",
-    "wait",
-    "tell",
-    "kill",
-    "log",
-    "renew",
-    "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"]);
-export function normalizeContractAddress(raw) {
-    const value = raw.startsWith("@") ? raw.slice(1) : raw;
-    if (!value.trim()) {
-        throw new FlowError("EMPTY_PARAM", "contract address cannot be empty");
-    }
-    return value.trim();
-}
-export function isCallCommand(command) {
-    return command === "call";
-}
-export function commandUsesPromptInput(command) {
-    return isCallCommand(command) || command === "revive";
-}
-export function parseWaitTimeout(value) {
-    const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
-    if (!matched?.groups) {
-        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
-    }
-    const amount = Number(matched.groups.amount);
-    const multiplier = matched.groups.unit === "s" ? 1_000 : matched.groups.unit === "m" ? 60_000 : 3_600_000;
-    const timeoutMs = amount * multiplier;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs > 24 * 3_600_000) {
-        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
-    }
-    return timeoutMs;
-}
-export function commandPositionalRange(command) {
-    if (command === "akuma show")
-        return { min: 1, max: 1, label: "<name>" };
-    if (command === "log")
-        return { min: 0, max: 0, label: "" };
-    if (command === "revive")
-        return { min: 1, max: 1, label: "<artifact-id>" };
-    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 };
-    return { min: 0, max: 0 };
-}
-function commandRequiresStdin(command) {
-    return STDIN_COMMANDS.has(command);
-}
-function commandTokens(command) {
-    return command.split(" ");
-}
-function parseFlagName(raw) {
-    return raw.slice(2);
-}
-function assignFlag(flags, name, value) {
-    switch (name) {
-        case "cwd":
-            flags.cwd = String(value);
-            return;
-        case "repo":
-            flags.repo = String(value);
-            return;
-        case "contract":
-            flags.contractId = normalizeContractAddress(String(value));
-            flags.contractAddressSource = "explicit-flag";
-            return;
-        case "akuma":
-            flags.akuma = String(value);
-            return;
-        case "projection":
-            flags.projection = String(value);
-            return;
-        case "alias":
-            flags.alias = String(value);
-            return;
-        case "timeout":
-            flags.timeoutMs = parseWaitTimeout(String(value));
-            return;
-        case "model":
-            flags.model = String(value);
-            return;
-        case "effort": {
-            const effort = String(value);
-            flags.effort = effort;
-            return;
-        }
-        case "incognito":
-            flags.incognito = Boolean(value);
-            return;
-        case "bare":
-            flags.bare = Boolean(value);
-            return;
-        case "detach":
-            flags.detach = Boolean(value);
-            return;
-        case "draft-only":
-            flags.draftOnly = Boolean(value);
-            return;
-        case "exclusive":
-            flags.exclusive = Boolean(value);
-            return;
-        case "after":
-            flags.after = [...(flags.after ?? []), String(value)];
-            return;
-        case "force":
-            flags.force = Boolean(value);
-            return;
-        case "reason":
-            flags.reason = String(value);
-            return;
-        case "dry-run":
-            flags.dryRun = Boolean(value);
-            return;
-        case "waive":
-            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
-            return;
-        case "shell":
-            flags.shell = String(value);
-            return;
-        case "word":
-            flags.word = String(value);
-            return;
-        case "previous":
-            flags.previous = String(value);
-            return;
-        case "complete":
-            flags.complete = Boolean(value);
-            return;
-        case "all":
-            flags.all = Boolean(value);
-            return;
-        case "target":
-            if (flags.target !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
-            }
-            flags.target = String(value);
-            return;
-        default:
-            throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
-    }
-}
-function assertAllowedFlag(command, name) {
-    if (!COMMAND_FLAGS[command].includes(name)) {
-        throw new FlowError("EMPTY_PARAM", `option --${name} is not valid for ${command}`);
-    }
-}
-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) {
-        const parts = commandTokens(command);
-        if (parts.every((part, index) => tokens[index] === part)) {
-            return { command, rest: tokens.slice(parts.length) };
-        }
-    }
-    const [head] = tokens;
-    if (head === "skills") {
-        return { command: "skills", rest: tokens.slice(1) };
-    }
-    if (!head)
-        throw new FlowError("EMPTY_PARAM", "command cannot be empty");
-    throw new FlowError("UNKNOWN_COMMAND", `unknown command: ${head ?? ""}`.trim());
-}
-function splitAtLiteralBoundary(tokens) {
-    const boundary = tokens.indexOf("--");
-    if (boundary === -1)
-        return { head: tokens, payload: [] };
-    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.
-    // Other value flags keep the historical requires-a-value rejection.
-    if (eq !== -1) {
-        const value = token.slice(eq + 1);
-        if (value === "" && name !== "target") {
-            throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-        }
-        return { value, nextIndex: index };
-    }
-    const value = tokens[index + 1];
-    if (value === undefined || value === "--" || value.startsWith("--")) {
-        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-    }
-    if (value === "" && name !== "target") {
-        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
-    }
-    // Short-flag values may begin with @; they are flag values, not commission tokens.
-    return { value, nextIndex: index + 1 };
-}
-function commissionConflictMessage(atForm, contractForm) {
-    return `commission address supplied twice: ${atForm} and --contract ${contractForm}; use exactly one form`;
-}
-function formatSelectorList(items) {
-    if (items.length <= 1)
-        return items[0] ?? "";
-    if (items.length === 2)
-        return `${items[0]} and ${items[1]}`;
-    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
-}
-function multiCommissionSelectorMessage(command, spellings) {
-    return `${command} accepts one commission address; got ${formatSelectorList(spellings)}`;
-}
-function commissionSelectorSpelling(source, value, rawToken) {
-    if (source === "at-address")
-        return rawToken ?? `@${value}`;
-    return `--contract ${rawToken ?? value}`;
-}
+import { HELP_FLAGS } from "./flags.js";
+import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
+import { commandPositionalRange, commandRequiresStdin, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
+import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
+export { commandPositionalRange, commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
     const flags = {};
@@ -322,9 +57,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}`);
         }
@@ -348,81 +80,82 @@ export function parseCliArgs(tokens) {
         }
     }
     const { command, rest } = resolveCommand(free);
-    if (atTokens.length > 0 && contractFlagRaws.length > 0) {
-        throw new FlowError("EMPTY_PARAM", commissionConflictMessage(atTokens[0], contractFlagRaws[0]));
-    }
-    if (atTokens.length > 1) {
-        throw new FlowError("EMPTY_PARAM", multiCommissionSelectorMessage(command, atTokens));
-    }
-    if (contractFlagRaws.length > 1) {
-        throw new FlowError("EMPTY_PARAM", multiCommissionSelectorMessage(command, contractFlagRaws.map((raw) => `--contract ${raw}`)));
-    }
-    if (atTokens.length === 1) {
-        flags.contractId = normalizeContractAddress(atTokens[0]);
-        flags.contractAddressSource = "at-address";
-    }
-    else if (contractFlagRaws.length === 1) {
-        assignFlag(flags, "contract", contractFlagRaws[0]);
-    }
+    applyCommissionSelector(command, flags, atTokens, contractFlagRaws);
     if (helpRequested) {
         return {
             command,
-            flags: flags.contractId ? { contractId: flags.contractId, contractAddressSource: flags.contractAddressSource, ...(flags.cwd ? { cwd: flags.cwd } : {}), ...(flags.repo ? { repo: flags.repo } : {}) } : {
-                ...(flags.cwd ? { cwd: flags.cwd } : {}),
-                ...(flags.repo ? { repo: flags.repo } : {}),
-            },
+            flags: flags.contractId
+                ? {
+                    contractId: flags.contractId,
+                    contractAddressSource: flags.contractAddressSource,
+                    ...(flags.cwd ? { cwd: flags.cwd } : {}),
+                    ...(flags.repo ? { repo: flags.repo } : {}),
+                }
+                : {
+                    ...(flags.cwd ? { cwd: flags.cwd } : {}),
+                    ...(flags.repo ? { repo: flags.repo } : {}),
+                },
             positional: [],
             helpRequested: true,
         };
     }
     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(", ")}`);
+    }
+    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 (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`
-            : `contract address @${flags.contractId} is not valid for ${command}`);
+    if (command === "call" && flags.detach && flags.timeoutMs !== undefined) {
+        throw new FlowError("EMPTY_PARAM", "call cannot combine --detach and --wait");
     }
-    if ((command === "wait" || command === "tell") && flags.contractId !== undefined) {
-        const selectorSpelling = commissionSelectorSpelling(flags.contractAddressSource === "at-address" ? "at-address" : "explicit-flag", flags.contractId, flags.contractAddressSource === "at-address" ? atTokens[0] : contractFlagRaws[0]);
-        const scopeOnlyMessage = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
-        if (command === "wait" && rest.length + payload.length === 0) {
-            throw new FlowError("EMPTY_PARAM", scopeOnlyMessage);
-        }
-        if (command === "tell" && rest.length === 0) {
-            // Payload after -- is the message body, never the projection address.
-            throw new FlowError("EMPTY_PARAM", scopeOnlyMessage);
-        }
+    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");
     }
+    assertCommissionSelectorAllowed(command, flags);
+    assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, rest.length, payload.length);
     const positional = [...rest, ...payload];
     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);