@astrosheep/keiyaku 2.9.9 → 2.9.10

package/build/cli/render/misc.js

@@ -3,6 +3,7 @@ import { RESPONSE_MARKERS } from "./response-style.js";
 import { formatReview, HINTS_LIST_MAX_ITEMS, REVIEW_SECTION_TITLE, toReviewPayload, } from "./shared.js";
 import { prependAddressReceipt, renderAddressCarrier } from "./address.js";
 import { commissionSlug } from "../../core/ids.js";
+import { renderAmendmentWarning } from "./amendment-warning.js";
 export function buildErrorResponse(input) {
     const shouldRaiseProtocolError = input.errorType === "runtime_error";
     const text = input.errorCode === "PROJECTION_INCOMPATIBLE"
@@ -28,14 +29,17 @@ export function buildErrorResponse(input) {
 }
 function buildErrorText(input) {
     const errorSection = buildSection("Error", input.message);
-    const recoverySection = input.facts?.kind === "renew_conflict"
-        ? buildSection("Recovery", [
+    const conflictSection = input.facts?.kind === "renew_conflict_scratch"
+        ? buildSection("Conflict scratch", [
+            input.facts.scratchPath,
+            "",
             "Conflicting paths:",
             ...input.facts.conflictPaths.map((filePath) => `  ${filePath}`),
-            ...(input.facts.conflictPathCapture.status === "failed"
-                ? [`Conflict-path capture failed: ${input.facts.conflictPathCapture.diagnostic}`]
-                : []),
-            "Delivery branch and worktree were restored; no ledger writes were appended.",
+            "",
+            `Ledger: ${input.facts.observedLedgerHead}`,
+            `Delivery: ${input.facts.deliveryRef} at ${input.facts.oldHead}`,
+            `Target: ${input.facts.targetRef} at ${input.facts.newBase}`,
+            "Authoritative ledger and delivery refs were unchanged.",
         ].join("\n"))
         : null;
     const reviewSection = input.review ? buildSection(REVIEW_SECTION_TITLE, formatReview(input.review)) : null;
@@ -43,32 +47,22 @@ function buildErrorText(input) {
         && input.addressCarrier.binding.kind === "commission"
         ? input.addressCarrier
         : undefined;
-    const recoveryAddress = commissionedCarrier
+    const renewAddress = commissionedCarrier
         ? `@${commissionedCarrier.place.display ?? commissionSlug(commissionedCarrier.binding.commissionId)}`
-        : input.facts?.kind === "renew_session"
-            ? `@${commissionSlug(input.facts.commission)}`
-            : undefined;
-    const nextActionSection = input.facts?.kind === "renew_session" && recoveryAddress
-        ? buildSection("Next action", input.facts.nextAction === "resolve-conflicts"
-            ? [
-                "Resolve and stage the conflicting delivery with ordinary Git, then:",
-                `» keiyaku ${recoveryAddress} renew --continue`,
-                "Or restore the pre-renew delivery:",
-                `» keiyaku ${recoveryAddress} renew --abort`,
-            ]
-            : input.facts.nextAction === "continue-or-abort" ? [
-                `» keiyaku ${recoveryAddress} renew --continue`,
-                `» keiyaku ${recoveryAddress} renew --abort`,
-            ] : [`» keiyaku ${recoveryAddress} renew --abort`])
+        : undefined;
+    const nextActionSection = input.facts?.kind === "renew_conflict_scratch" && renewAddress
+        ? buildSection("Next action", [
+            "Resolve files in the conflict scratch, then:",
+            `» keiyaku ${renewAddress} renew --continue`,
+            "Or discard the conflict scratch:",
+            `» keiyaku ${renewAddress} renew --abort`,
+        ])
         : null;
-    const hints = input.facts?.kind === "renew_session"
+    const hints = input.facts?.kind === "renew_conflict_scratch"
         ? []
         : formatHints(input.hints, { maxItems: HINTS_LIST_MAX_ITEMS, maxItemChars: FORMAT_LIST_MAX_ITEM_CHARS });
-    if (input.facts?.kind === "renew_conflict") {
-        hints.push("your old head survives:", `» git log ${input.facts.recoveryRef}`);
-    }
     const hintsSection = buildSection("Hints", hints);
-    const body = assembleResponse(colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`), "Request could not be completed.", [errorSection, recoverySection, nextActionSection, reviewSection, hintsSection].filter((section) => section !== null));
+    const body = assembleResponse(colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`), "Request could not be completed.", [errorSection, conflictSection, nextActionSection, reviewSection, hintsSection].filter((section) => section !== null));
     return input.addressCarrier ? `${renderAddressCarrier(input.addressCarrier)}\n${body}` : body;
 }
 export function buildHelpResponse(input) {
@@ -82,7 +76,9 @@ export function buildLogResponse(result) {
     const { address: _address, ...resultData } = result;
     const payload = resultData;
     return prependAddressReceipt({
-        text: result.markdown,
+        text: result.amendmentWarning
+            ? `${result.markdown.trimEnd()}\n\nWarning\n${renderAmendmentWarning(result.amendmentWarning)}\n`
+            : result.markdown,
         payload: buildPayload(payload),
     }, result.address);
 }

package/build/cli/render/petition.js

@@ -8,6 +8,11 @@ import { prependAddressReceipt } from "./address.js";
 export function renderPetitionRenewedConsequence(input) {
     return `renewed onto ${input.newBase.slice(0, 8)} · ${input.sealed?.receipts.length ?? 0} receipts replayed`;
 }
+export function renderPetitionRetryConsequence(reason) {
+    return reason === "target-drift"
+        ? "rejected petition after target drift · contract active"
+        : "rejected petition after delivery drift · contract active";
+}
 function formatPetitionSealSource(source) {
     return source.arc === null
         ? `no open arc · fence ${source.fence}`

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

@@ -210,6 +210,7 @@ export function renderProjectionActivity(activity, input) {
     let priorCompletedRan;
     let hasEndAnchor = false;
     let lastRunningTool;
+    const interrupted = input.state === "dead" || input.state === "lost" || input.state === "dismissed";
     const maxColumns = input.maxColumns ?? resolveLineColumns();
     const entries = timelineEntries(activity);
     const gapBeforeOrder = input.leadingOmittedCount ? activity.window[0]?.order : undefined;
@@ -244,14 +245,14 @@ export function renderProjectionActivity(activity, input) {
             priorMinute = minute;
         const spine = row.kind === "turn"
             ? "├"
-            : input.state === "dead" || input.state === "lost"
+            : interrupted
                 ? "┆"
                 : "│";
         if (row.kind === "ran") {
             const duration = formatActionDuration(row.durationMs);
             const activityState = row.state === "completed"
                 ? "completed"
-                : input.state === "dead" || input.state === "lost"
+                : interrupted
                     ? "interrupted"
                     : input.state === "stalled" || input.state === "unknown"
                         ? "unresolved"

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

@@ -0,0 +1,64 @@
+import { renderProjectionActivity } from "./projection-activity.js";
+function fact(value) {
+    return value ?? "unavailable";
+}
+function consequenceLines(run) {
+    const consequences = run.consequences;
+    if (consequences === null)
+        return [];
+    if (consequences.retention === "unavailable") {
+        return [`consequences: unavailable · ${consequences.reason}`];
+    }
+    const retained = (name, value, detail) => value.retention === "retained" ? `${name}: retained · ${detail}` : `${name}: unavailable · ${value.reason}`;
+    return [
+        `review: unavailable · ${consequences.review.reason}`,
+        retained("petition", consequences.petition, consequences.petition.retention === "retained" ? `${consequences.petition.intent} · ${consequences.petition.objectId}` : ""),
+        retained("verdict", consequences.verdict, consequences.verdict.retention === "retained" ? `${consequences.verdict.result} · ${consequences.verdict.objectId}` : ""),
+        retained("claim", consequences.claim, consequences.claim.retention === "retained" ? `${consequences.claim.objectId} · ${consequences.claim.mergeCommit}` : ""),
+        retained("landed commit", consequences.landedCommit, consequences.landedCommit.retention === "retained" ? consequences.landedCommit.commit : ""),
+    ];
+}
+function runLines(run) {
+    return [
+        `${run.id}${run.alias ? ` (${run.alias})` : ""} · ${run.outcome}`,
+        `akuma: ${fact(run.akuma)} · provider: ${fact(run.provider)}${run.pid === null ? "" : ` · pid: ${run.pid}`} · role: ${run.role}`,
+        `contract: ${fact(run.contractId)}`,
+        `created: ${fact(run.mintedAt)}${run.terminalAt ? ` · terminal: ${run.terminalAt}` : ""}`,
+        ...(run.generation ? [`generation: ${run.generation.executionId} · created: ${run.generation.createdAt}${run.generation.adoptedAt ? ` · adopted: ${run.generation.adoptedAt}` : ""}`] : []),
+        `activity: ${run.activityRetention} · ${run.activityCount} retained${run.activityRange ? ` · ${run.activityRange.first}-${run.activityRange.last}` : ""}`,
+        ...(run.telemetry ? [`telemetry: ${run.telemetry.inputTokens} in · ${run.telemetry.outputTokens} out${run.telemetry.cachedInputTokens !== undefined ? ` · ${run.telemetry.cachedInputTokens} cached` : ""}${run.telemetry.costUsd !== undefined ? ` · $${run.telemetry.costUsd.toFixed(2)}` : ""}`] : []),
+        ...(run.artifact ? [`artifact: ${fact(run.artifact.id)} · ${run.artifact.retention}${run.artifact.path ? ` · path: ${run.artifact.path}` : ""}`] : []),
+        ...consequenceLines(run),
+        ...run.diagnostics.map((diagnostic) => `diagnostic: ${diagnostic}`),
+    ];
+}
+export function renderProjectionHistoryList(runs) {
+    return runs.flatMap((run, index) => index === 0 ? runLines(run) : ["", ...runLines(run)]).join("\n");
+}
+export function renderProjectionHistoryDetail(detail) {
+    const lines = runLines(detail);
+    if (!detail.activity || detail.activity.retainedTimeline.length === 0)
+        return lines.join("\n");
+    const state = detail.outcome === "done" ? "returned"
+        : detail.outcome === "out" ? "running"
+            : detail.outcome === "failed" || detail.outcome === "dead" ? "dead"
+                : detail.outcome === "lost" ? "lost"
+                    : detail.outcome === "killed" || detail.outcome === "dismissed" ? "dismissed"
+                        : detail.outcome === "startup-timeout" ? "stalled"
+                            : "unknown";
+    const activity = renderProjectionActivity({
+        ...detail.activity,
+        timeline: detail.activity.retainedTimeline,
+        omittedSettledCount: 0,
+    }, {
+        anchorMs: Date.now(),
+        state,
+        showPlan: false,
+        showSilence: false,
+        showTerminalFiles: false,
+    });
+    return [...lines, "", ...activity.lines].join("\n");
+}
+export function projectionHistoryJson(value) {
+    return `${JSON.stringify(value)}\n`;
+}

package/build/cli/render/shared.js

@@ -1,4 +1,5 @@
 import { KEIYAKU_FILE } from "../../keiyaku.js";
+import { isCompleteLifecycleOutcome } from "../../core/outcome-base.js";
 import { commissionSlug, formatCommissionCoordinate } from "../../core/ids.js";
 import { assembleResponse, buildSection, DISPLAY_TEXT_MAX_CHARS, FORMAT_LIST_MAX_ITEM_CHARS, FORMAT_LIST_MAX_ITEMS, formatMaybe, formatWarnings, shellQuote, truncateForDisplay, } from "./format.js";
 import { WARNING_SECTION_TITLE } from "./response-style.js";
@@ -63,6 +64,26 @@ export function buildBindResponse(result, cwd) {
         ...(overlapWarnings.length > 0 ? ["Warnings:", ...overlapWarnings] : []),
     ].join("\n"), payload);
 }
+export function buildContainedBindResponse(result) {
+    const payload = {
+        family: result.family,
+        completion: result.completion,
+        committed: result.committed,
+        heads: result.heads,
+        reconciliationKey: result.reconciliationKey,
+        prerequisites: result.prerequisites,
+        downstream: result.downstream,
+        replay: result.replay,
+        carrier: result.carrier,
+        cancellationObserved: result.cancellationObserved,
+    };
+    return coreTextResponse(`Bind committed with incomplete replay · head ${result.committed.head} · reconcile ${result.reconciliationKey}`, payload);
+}
+export function buildBindOutcomeResponse(result, cwd) {
+    return isCompleteLifecycleOutcome(result)
+        ? buildBindResponse(result, cwd)
+        : buildContainedBindResponse(result);
+}
 function renderScopeOverlapWarnings(overlaps) {
     const overlapsByCounterparty = new Map();
     for (const overlap of overlaps) {
@@ -105,10 +126,8 @@ export function buildForfeitResponse(result) {
                 `Could not remove contract worktree ${result.cleanup.worktreeRemoveFailure.path}: ${result.cleanup.worktreeRemoveFailure.reason}`,
             ]
             : []),
-        ...(result.cleanup.branchDeleteFailure
-            ? [
-                `Could not delete contract branch: ${redactBranchReference(result.cleanup.branchDeleteFailure.reason, result.cleanup.branchDeleteFailure.name)}`,
-            ]
+        ...(result.cleanup.deliveryRef.status === "mismatch"
+            ? [`Delivery ref ${result.cleanup.deliveryRef.mismatch.ref} remains present at ${result.cleanup.deliveryRef.mismatch.observed.head}; terminal replay preserved it as a projected-surface mismatch.`]
             : []),
     ];
     if (warnings.length === 0) {
@@ -117,11 +136,6 @@ export function buildForfeitResponse(result) {
     const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(warnings));
     return prependAddressReceipt(coreTextResponse(assembleResponse(base, "", [warningSection].filter((section) => section !== null)), payload), result.address);
 }
-function redactBranchReference(message, branch) {
-    return message
-        .replaceAll(`refs/heads/${branch}`, "contract branch")
-        .replaceAll(branch, "contract branch");
-}
 export const RULES_SECTION_MAX_CHARS = 5000;
 export const INFO_SECTION_TITLE = "Info";
 export const HINTS_SECTION_TITLE = "Hints";

package/build/cli/render/status.js

@@ -7,7 +7,6 @@ import { renderTerminalFailureFace, terminalFailureCodeSuffix } from "./terminal
 import { formatTellCommand } from "./shared.js";
 export const STATUS_DISEASES_SECTION_TITLE = "Diseases";
 export const STATUS_PROJECTION_SECTION_TITLE = "akuma";
-export const STATUS_CLAIM_RECEIPTS_SECTION_TITLE = "claim receipts";
 function projectionGlyph(state) {
     switch (state) {
         case "out":
@@ -37,15 +36,19 @@ export function renderSettingsDiseasesSection(diseases, taskDiseases = []) {
     return `${STATUS_DISEASES_SECTION_TITLE}\n${lines.join("\n")}\n`;
 }
 function renderTaskStatusSection(tasks) {
-    if (!tasks || tasks.inProgress + tasks.ready + tasks.blocked === 0)
+    if (!tasks || tasks.inProgress + tasks.onHold + tasks.ready + tasks.blocked === 0)
         return "";
     const segments = [
         tasks.inProgress > 0 ? `${tasks.inProgress} in_progress` : undefined,
+        tasks.onHold > 0 ? `${tasks.onHold} on hold` : undefined,
         tasks.ready > 0 ? `${tasks.ready} ready` : undefined,
         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"} · age ${formatAgeMs(task.ageMs)} · active ${formatAgeMs(task.activityAgeMs)} · ${task.title}`));
+    lines.push(...tasks.topTasks.map((task) => {
+        const onHold = task.state === "on_hold";
+        return `  ${task.id} · P${task.pri} · ${onHold ? "on hold" : "in_progress"} · age ${formatAgeMs(task.ageMs)} · ${onHold ? "updated" : "active"} ${formatAgeMs(task.activityAgeMs)} · ${task.title}`;
+    }));
     if (tasks.omitted > 0) {
         lines.push(`  · +${tasks.omitted} more — keiyaku task ls`);
     }
@@ -99,10 +102,9 @@ function renderProjectionAge(row) {
     return facts;
 }
 function renderProjectionTellCounts(row) {
-    const { inbox, inflight, submitted, consumed } = row.tellCounts;
-    if (inbox === 0 && inflight === 0 && submitted === 0 && consumed === 0)
-        return "";
-    return ` tell ${inbox}▸${inflight}▸${submitted}▸${consumed}`;
+    const { inbox, inflight, submitted, seen, consumed } = row.tellCounts;
+    const total = inbox + inflight + submitted + seen + consumed;
+    return total === 0 ? "" : ` tell ${total} told`;
 }
 function projectionActivityState(row) {
     switch (row.state) {
@@ -194,15 +196,6 @@ export function renderProjectionStatusSection(board) {
         lines.push(omission);
     return `${STATUS_PROJECTION_SECTION_TITLE}\n${lines.join("\n")}\n`;
 }
-function renderClaimReconciliationSection(recon) {
-    if (!recon)
-        return "";
-    const lines = recon.unclaimedSegments.map((seg) => `${recon.defaultBranch} ${shortCommitHash(seg.oldHead)}▸${shortCommitHash(seg.newHead)} · ${seg.commitCount} commits · 无 claim 收据`);
-    lines.push(...recon.receiptIssues.map((issue) => `receipt line ${issue.line} · ${issue.reason}`));
-    if (lines.length === 0)
-        return "";
-    return `${STATUS_CLAIM_RECEIPTS_SECTION_TITLE}\n${lines.join("\n")}\n`;
-}
 /**
  * Status mouth: kanshi board plus optional diseases section.
  * Healthy boards (no diseases) are byte-identical to renderKanshiBoard alone.

package/build/cli/render/task.js

@@ -8,13 +8,29 @@ export function deriveTaskDisplay(task) {
     return display === "bound" ? `bound(${shortContractId(task.contractId)})` : display;
 }
 function renderTaskRowWithId(task, id) {
-    return `${id} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
+    return `${id} · ${task.namespace ?? "hub"} · P${task.pri} · ${deriveTaskDisplay(task)} · ${task.title}`;
 }
 export function renderTaskListRow(task) {
-    return renderTaskRowWithId(task, task.id);
+    return renderTaskRowWithId(task, task.coordinate);
 }
 export function renderTaskMutationRow(task) {
-    return renderTaskRowWithId(task, task.id);
+    return renderTaskRowWithId(task, task.coordinate);
+}
+export function renderTaskUpdate(result) {
+    const lines = [renderTaskMutationRow(result.task)];
+    if (result.bodyChange) {
+        lines.push(`body · +${result.bodyChange.diffstat.additions} −${result.bodyChange.diffstat.deletions} lines`);
+        for (const section of result.bodyChange.removedSections) {
+            lines.push(`▲ section removed: ${section}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function renderTaskUpdateJson(result) {
+    return JSON.stringify({
+        ...taskJson(result.task),
+        ...(result.bodyChange === undefined ? {} : { bodyChange: result.bodyChange }),
+    });
 }
 export function renderTaskRow(task, completeId = false) {
     return completeId ? renderTaskMutationRow(task) : renderTaskListRow(task);
@@ -28,24 +44,20 @@ export function renderTaskList(tasks, options = {}) {
 export function renderSelectedTaskList(tasks) {
     return tasks.map(renderTaskListRow).join("\n");
 }
-function renderIds(ids) {
-    return ids.length === 0 ? "(none)" : ids.join(", ");
-}
 function renderTaskDetails(task) {
     const released = new Set(task.releasedNeeds);
-    const needs = task.needs.length === 0
-        ? "(none)"
-        : task.needs
-            .map((id) => `${id}${released.has(id) ? " (dropped)" : ""}`)
-            .join(", ");
     return [
-        `${task.id} · ${task.title}`,
+        `${task.coordinate} · ${task.title}`,
+        `namespace: ${task.namespace ?? "(hub)"}`,
         `state: ${deriveTaskDisplay(task)}`,
         `priority: ${task.pri}`,
-        `needs: ${needs}`,
-        `blocks: ${renderIds(task.blocks)}`,
-        `parent: ${task.parent === null ? "(none)" : task.parent}`,
-        `from: ${renderIds(task.from)}`,
+        ...(task.needs.length === 0 ? [] : [`needs: ${task.needs.map((id) => `${id}${released.has(id) ? " (dropped)" : ""}`).join(", ")}`]),
+        ...(task.blocks.length === 0 ? [] : [`blocks: ${task.blocks.join(", ")}`]),
+        ...(task.parent === null ? [] : [`parent: ${task.parent}`]),
+        ...(task.from.length === 0 ? [] : [`from: ${task.from.join(", ")}`]),
+        ...(task.supersedes.length === 0 ? [] : [`supersedes: ${task.supersedes.join(", ")}`]),
+        ...(task.supersededBy.length === 0 ? [] : [`superseded by: ${task.supersededBy.join(", ")}`]),
+        ...(task.relatedTasks.length === 0 ? [] : [`relates to: ${task.relatedTasks.join(", ")}`]),
         `created: ${task.createdAt} by ${task.creator}`,
         "",
         task.body,
@@ -55,16 +67,24 @@ function renderTreeNode(node, prefix, last) {
     const branch = last ? "`- " : "|- ";
     const nestedPrefix = `${prefix}${last ? "   " : "|  "}`;
     const task = node.task;
-    const released = new Set(task.releasedNeeds);
-    const needs = task.needs.length === 0
-        ? "(none)"
-        : task.needs.map((id) => `${id}${released.has(id) ? " (dropped)" : ""}`).join(", ");
     const lines = [
-        `${prefix}${branch}${task.id} · ${deriveTaskDisplay(task)} · P${task.pri} · ${task.title}`,
-        `${nestedPrefix}needs: ${needs}`,
-        `${nestedPrefix}blocks: ${renderIds(task.blocks)}`,
-        `${nestedPrefix}from: ${renderIds(task.from)}`,
+        `${prefix}${branch}${task.coordinate} · ${deriveTaskDisplay(task)} · P${task.pri} · ${task.title}`,
     ];
+    const released = new Set(task.releasedNeeds);
+    if (task.needs.length > 0)
+        lines.push(`${nestedPrefix}needs: ${task.needs.map((id) => `${id}${released.has(id) ? " (dropped)" : ""}`).join(", ")}`);
+    if (task.blocks.length > 0)
+        lines.push(`${nestedPrefix}blocks: ${task.blocks.join(", ")}`);
+    if (task.parent !== null)
+        lines.push(`${nestedPrefix}parent: ${task.parent}`);
+    if (task.from.length > 0)
+        lines.push(`${nestedPrefix}from: ${task.from.join(", ")}`);
+    if (task.supersedes.length > 0)
+        lines.push(`${nestedPrefix}supersedes: ${task.supersedes.join(", ")}`);
+    if (task.supersededBy.length > 0)
+        lines.push(`${nestedPrefix}superseded by: ${task.supersededBy.join(", ")}`);
+    if (task.relatedTasks.length > 0)
+        lines.push(`${nestedPrefix}relates to: ${task.relatedTasks.join(", ")}`);
     node.children.forEach((child, index) => lines.push(...renderTreeNode(child, nestedPrefix, index === node.children.length - 1)));
     return lines;
 }
@@ -74,15 +94,17 @@ function treeDiagnostic(diagnostic) {
 }
 export function renderTaskShow(task, tree) {
     const treeLines = tree.descendants.length === 0
-        ? ["children tree: (empty)"]
+        ? []
         : ["children tree:", ...tree.descendants.flatMap((node, index) => renderTreeNode(node, "", index === tree.descendants.length - 1))];
     if (tree.diagnostics.length > 0)
         treeLines.push("tree diagnostics:", ...tree.diagnostics.map(treeDiagnostic));
-    return [...renderTaskDetails(task), "", ...treeLines].join("\n");
+    return [...renderTaskDetails(task), ...(treeLines.length === 0 ? [] : ["", ...treeLines])].join("\n");
 }
 export function taskJson(task) {
     return {
         id: task.id,
+        namespace: task.namespace,
+        coordinate: task.coordinate,
         title: task.title,
         state: task.state,
         display: deriveTaskDisplay(task),
@@ -91,6 +113,9 @@ export function taskJson(task) {
         blocks: [...task.blocks],
         parent: task.parent,
         from: [...task.from],
+        supersedes: [...task.supersedes],
+        supersededBy: [...task.supersededBy],
+        relatesTo: [...task.relatedTasks],
         contractId: task.contractId ?? null,
         createdAt: task.createdAt,
         updatedAt: task.updatedAt ?? task.createdAt,

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

@@ -3,7 +3,7 @@ export function terminalFailureCodeSuffix(code) {
     return code.startsWith("SUBAGENT_") ? code.slice("SUBAGENT_".length) : code;
 }
 export function terminalFailureColdStatement(failure) {
-    if (failure.publicCause?.kind === "rate_limit_exhausted") {
+    if (failure.publicCause?.code === "rate_limit_exhausted") {
         return "the provider rate limit is exhausted";
     }
     if (failure.class === "runner") {
@@ -33,6 +33,8 @@ function terminalFailureEvidence(failure, statement) {
         && failure.code === "SUBAGENT_NON_ZERO_EXIT"
         && failure.exitCode !== undefined;
     const parts = [];
+    if (failure.message)
+        parts.push(failure.message);
     if (failure.timeoutMs !== undefined) {
         parts.push(failure.code === "SUBAGENT_POLICY_BUDGET" ? `budget ${failure.timeoutMs}ms` : `idle ${failure.timeoutMs}ms`);
     }

package/build/cli/render/wait.js

@@ -1,8 +1,7 @@
 import { formatTimelineDuration, renderPendingProjectionTell, renderProjectionActivity, } from "./projection-activity.js";
 import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
-import { formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
+import { coreTextResponse, formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
-const WAIT_HEADER_MAX_COLUMNS = 60;
 function shortAddress(projectionId) {
     return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
 }
@@ -35,8 +34,7 @@ function projectionIdentityParts(projectionId) {
     const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
     return match ? { slug: match[1], shortId: match[2] } : { slug: "", shortId: projectionId };
 }
-function waitHeader(projectionId, akuma, snapshot, outputColumns) {
-    const maxColumns = Math.min(WAIT_HEADER_MAX_COLUMNS, outputColumns);
+function waitHeader(projectionId, akuma, snapshot, maxColumns) {
     const state = waitStateText(snapshot);
     const identity = projectionIdentityParts(projectionId);
     // Slug often mirrors the Akuma name; print once when they are the same fact.
@@ -237,7 +235,7 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);
-    const response = textResponse(lines.join("\n"));
+    const response = coreTextResponse(lines.join("\n"), result);
     if (snapshot.phase === "dismissed")
         return { ...response, exitCode: 130 };
     if (["failed", "lost", "startup-timeout", "unknown"].includes(snapshot.phase)) {

package/build/cli/subagent-guard.js

@@ -1,4 +1,4 @@
-const SUBAGENT_SAFE_COMMANDS = new Set(["status", "log", "guide", "dump-env", "wait"]);
+const SUBAGENT_SAFE_COMMANDS = new Set(["status", "history", "log", "guide", "dump-env", "wait"]);
 const SUBAGENT_SAFE_FLAGS = new Set(["--help", "-h", "--version"]);
 function isSubagentSafeCommand(args) {
     if (args.length === 0)

package/build/cli/types.js

@@ -1 +1 @@
-export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "done", "drop", "update", "doctor"];
+export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "hold", "resume", "done", "drop", "update", "doctor"];

package/build/config/env-keys.js

@@ -22,6 +22,7 @@ export const ENV_KEYS = {
     REVIEW_ENABLED: "KEIYAKU_REVIEW_ENABLED",
     REVIEW_MIN_LINES: "KEIYAKU_REVIEW_MIN_LINES",
     REVIEW_RESUME_SESSION: "KEIYAKU_REVIEW_RESUME_SESSION",
+    AMENDMENT_WARNING_THRESHOLD: "KEIYAKU_AMENDMENT_WARNING_THRESHOLD",
 };
 const ENV_KEY_ENTRIES = [
     { key: ENV_KEYS.AGENT_OVERRIDE, defaultValue: "", description: "Override default agent name", category: "subagent" },
@@ -34,6 +35,7 @@ const ENV_KEY_ENTRIES = [
     { key: ENV_KEYS.REVIEW_ENABLED, defaultValue: "1", description: "Run the reviewer gate when set to 1", category: "workflow" },
     { key: ENV_KEYS.REVIEW_MIN_LINES, defaultValue: "200", description: "Minimum changed lines required before running the reviewer gate", category: "workflow" },
     { key: ENV_KEYS.REVIEW_RESUME_SESSION, defaultValue: "1", description: "Resume reviewer sessions from the prior persisted response path when set to 1", category: "workflow" },
+    { key: ENV_KEYS.AMENDMENT_WARNING_THRESHOLD, defaultValue: "5", description: "Advisory amendment-count threshold for open contracts", category: "workflow" },
     { key: ENV_KEYS.DEBUG_LOG_PATH, defaultValue: "", description: "Optional debug log output file path", category: "debug" },
     { key: ENV_KEYS.TEST_SILENT, defaultValue: "0", description: "Suppress progress logs during tests when set to 1", category: "debug" },
     { key: ENV_KEYS.GIT_TIMEOUT_MS, defaultValue: "15000", description: "Git command timeout in milliseconds", category: "git" },

package/build/config/env.js

@@ -95,6 +95,22 @@ function positiveIntEnv(key) {
         }
     });
 }
+function strictPositiveIntEnv(key) {
+    return z
+        .string()
+        .default(getEnvDefaultValue(key))
+        .transform((value, ctx) => {
+        const trimmed = value.trim();
+        const parsed = Number(trimmed);
+        if (/^\d+$/.test(trimmed) && Number.isSafeInteger(parsed) && parsed > 0)
+            return parsed;
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${key} must be a positive integer, received '${value}'.`,
+        });
+        return z.NEVER;
+    });
+}
 function parseNonNegativeInt(value, key) {
     const trimmed = value.trim();
     const parsed = Number.parseInt(trimmed, 10);
@@ -166,6 +182,9 @@ const reviewSchema = z.object({
     minLines: nonNegativeIntEnv(ENV_KEYS.REVIEW_MIN_LINES),
     resumeSession: booleanFlagEnv(ENV_KEYS.REVIEW_RESUME_SESSION),
 });
+const amendmentWarningSchema = z.object({
+    threshold: strictPositiveIntEnv(ENV_KEYS.AMENDMENT_WARNING_THRESHOLD),
+});
 const terminalSchema = z.object({
     noColor: z.string().optional(),
     forceColor: z.string().optional(),
@@ -188,6 +207,7 @@ const envSchema = z
     [ENV_KEYS.REVIEW_ENABLED]: z.string().optional(),
     [ENV_KEYS.REVIEW_MIN_LINES]: z.string().optional(),
     [ENV_KEYS.REVIEW_RESUME_SESSION]: z.string().optional(),
+    [ENV_KEYS.AMENDMENT_WARNING_THRESHOLD]: z.string().optional(),
     NO_COLOR: z.string().optional(),
     FORCE_COLOR: z.string().optional(),
     TERM: z.string().optional(),
@@ -222,6 +242,9 @@ const envSchema = z
         minLines: rawEnv[ENV_KEYS.REVIEW_MIN_LINES],
         resumeSession: rawEnv[ENV_KEYS.REVIEW_RESUME_SESSION],
     }),
+    amendmentWarning: amendmentWarningSchema.parse({
+        threshold: rawEnv[ENV_KEYS.AMENDMENT_WARNING_THRESHOLD],
+    }),
     terminal: terminalSchema.parse({
         noColor: rawEnv.NO_COLOR,
         forceColor: rawEnv.FORCE_COLOR,

package/build/config/settings/schema.js

@@ -55,8 +55,10 @@ const gateCommandSchema = z
 const gateSchema = z
     .object({
     commands: z.array(gateCommandSchema).optional(),
+    timeoutMs: z.number().int("timeoutMs must be an integer.").min(1).max(3_600_000).optional(),
 })
-    .strict();
+    .strict()
+    .transform((value) => ({ ...value, timeoutMs: value.timeoutMs ?? 300_000 }));
 const WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS = 300_000;
 const WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS = 1;
 const WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS = 3_600_000;