@astrosheep/keiyaku 2.9.12 → 2.9.13

package/build/agents/call-terms.js

@@ -19,6 +19,7 @@ export function buildCallTerms(snapshot, prompt, cwd, options) {
         maxCaptureChars: registration.maxCaptureChars(runtimeConfig),
         signal: options.signal,
         ...(options.initialTurn !== undefined ? { initialTurn: options.initialTurn } : {}),
+        ...(options.carrier !== undefined ? { carrier: options.carrier } : {}),
     };
     // Live registry only admits CallTerms-producing contributions; the open
     // registration surface returns structural RegistrationCallTerms.

package/build/agents/providers/claude-agent-sdk/adapter.js

@@ -162,7 +162,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                         // Claude's source pull is the provider-native launch-input fact.
                         // The adapter records its coordinate before asking heart to reduce
                         // the exact attributed receipt.
-                        const fence = { kind: "ordinal", ordinal: 0 };
+                        const fence = { kind: "ordinal", ordinal: completedResultOrdinal + 1 };
                         await options.onLaunchAdmission?.({ fence, tellIds: options.launchTellIds ?? [] });
                         const admissions = (options.listLaunchAdmissions?.() ?? []).filter((admission) => (admission.fence.kind === "ordinal" && admission.fence.ordinal === fence.ordinal));
                         for (const receipt of exactLaunchInputReceipts("seen", fence, admissions))
@@ -322,7 +322,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                                     }
                                     // Sync checkpoint: claim inbox tells and deliver them via steer control.
                                     options.onSyncCheckpoint?.({ enqueue }, checkpoint);
-                                    const admissions = (options.listLaunchAdmissions?.() ?? []).filter((admission) => (admission.fence.kind === "ordinal" && admission.fence.ordinal < checkpoint.fence.ordinal));
+                                    const admissions = (options.listLaunchAdmissions?.() ?? []).filter((admission) => (admission.fence.kind === "ordinal" && admission.fence.ordinal <= checkpoint.fence.ordinal));
                                     for (const receipt of exactLaunchInputReceipts("consumed", checkpoint.fence, admissions))
                                         options.onTellReceipt?.(receipt);
                                     options.onTellReceipt?.({ stage: "consumed", correlation: { kind: "fence", fence: checkpoint.fence } });

package/build/cli/commands/akuma/akuma/handler.js

@@ -1,4 +1,5 @@
 import { missingSubcommandError } from "../../../missing-subcommand.js";
+import { AKUMA_SUBCOMMANDS } from "../../../types.js";
 export const handler = async () => {
-    throw missingSubcommandError("akuma", ["ls", "show"]);
+    throw missingSubcommandError("akuma", AKUMA_SUBCOMMANDS);
 };

package/build/cli/commands/akuma/akuma/meta.js

@@ -1,16 +1,17 @@
+import { AKUMA_SUBCOMMANDS } from "../../../types.js";
 export const meta = {
     command: "akuma",
     summary: "Inspect Akuma profiles",
-    usage: ["keiyaku akuma ls|show"],
+    usage: ["keiyaku akuma list|show"],
     stdin: { mode: "argument" },
     flags: [],
     purpose: "Inspect configured helper profiles.",
-    subcommands: ["ls", "show"],
+    subcommands: AKUMA_SUBCOMMANDS,
     notes: [
         "Define user profiles in <KEIYAKU_HOME>/akuma/<name>.md.",
         "Define project profiles in .keiyaku/akuma/<name>.md.",
         "See README Configuration for the Markdown frontmatter format.",
     ],
-    examples: ["keiyaku akuma ls", "keiyaku akuma show akuma-codex"],
+    examples: ["keiyaku akuma list", "keiyaku akuma show akuma-codex"],
     completionRank: 6,
 };

package/build/cli/commands/akuma/catalog.js

@@ -1,8 +1,10 @@
 import { meta as akumaMeta } from "./akuma/meta.js";
+import { meta as listMeta } from "./list/meta-list.js";
 import { meta as lsMeta } from "./list/meta-ls.js";
 import { meta as showMeta } from "./show/meta.js";
 export const akumaCatalog = [
     { meta: akumaMeta, load: () => import("./akuma/handler.js") },
+    { meta: listMeta, load: () => import("./list/handler.js") },
     { meta: lsMeta, load: () => import("./list/handler.js") },
     { meta: showMeta, load: () => import("./show/handler.js") },
 ];

package/build/cli/commands/akuma/list/handler.js

@@ -5,7 +5,7 @@ import { textResponse } from "../../../render/shared.js";
 import { projectDirectory } from "../../shared.js";
 import { renderAkumaList } from "../../akuma.js";
 export const handler = async (_stdin, flags) => {
-    const cwd = await projectDirectory(flags, "akuma ls");
+    const cwd = await projectDirectory(flags, "akuma list");
     const loaded = await loadKeiyakuSettings(cwd);
     // Role markers need settings pointers; catalog consumers keep legacy agents disease actionable.
     assertSettingsKnobUsable(loaded, "agents");

package/build/cli/commands/akuma/list/meta-list.js

@@ -0,0 +1,12 @@
+export const meta = {
+    command: "akuma list",
+    summary: "List Akuma profiles",
+    usage: ["keiyaku akuma list [-C|--cwd DIR] [--repo DIR]"],
+    stdin: { mode: "argument" },
+    flags: ["cwd", "repo"],
+    purpose: "List configured helper profiles.",
+    notes: [
+        "`keiyaku akuma ls` is a short alias.",
+        "Project profiles override user profiles, which override builtins.",
+    ],
+};

package/build/cli/commands/akuma/list/meta-ls.js

@@ -1,9 +1,9 @@
 export const meta = {
     command: "akuma ls",
-    summary: "List Akuma profiles",
+    summary: "Alias for akuma list",
     usage: ["keiyaku akuma ls [-C|--cwd DIR] [--repo DIR]"],
     stdin: { mode: "argument" },
     flags: ["cwd", "repo"],
-    purpose: "List configured helper profiles.",
+    purpose: "Short alias for the canonical `keiyaku akuma list` command.",
     notes: ["Project profiles override user profiles, which override builtins."],
 };

package/build/cli/commands/akuma.js

@@ -112,10 +112,13 @@ function chooseCallHintName(validNames, settings) {
 export function renderAkumaList(catalog, providerInstances, settings) {
     const lines = ["Available Akumas:", ""];
     const validNames = [];
+    const hasCustomSelectedCandidate = Object.values(catalog.selected).some((candidate) => candidate.source !== "builtin");
     for (const name of Object.keys(catalog.selected).sort((a, b) => a.localeCompare(b))) {
         const candidate = catalog.selected[name];
         if (candidate === undefined)
             continue;
+        if (hasCustomSelectedCandidate && candidate.source === "builtin")
+            continue;
         const resolved = resolveAkumaInspection(candidate, providerInstances);
         const markers = formatRoleMarkers(settings, resolved.name);
         if (resolved.status === "invalid") {
@@ -130,6 +133,8 @@ export function renderAkumaList(catalog, providerInstances, settings) {
         }
     }
     for (const shadow of catalog.shadows) {
+        if (hasCustomSelectedCandidate && shadow.source === "builtin")
+            continue;
         lines.push(`- ${shadow.name} [${shadow.source}] (shadowed by ${shadow.shadowedBy})`);
     }
     const hintName = chooseCallHintName(validNames, settings);

package/build/cli/commands/contract/amend/meta.js

@@ -2,11 +2,12 @@ export const meta = {
     command: "amend",
     summary: "Record an amendment",
     usage: [
+        "keiyaku amend [-C|--cwd DIR] [--repo DIR] [--contract ADDR] --append-scope PATTERN [--append-scope PATTERN ...]",
         "keiyaku amend [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--append-scope PATTERN] - < amendment.md",
-        "keiyaku @addr amend [-C|--cwd DIR] [--repo DIR] [--append-scope PATTERN] - < amendment.md",
+        "keiyaku @addr amend [-C|--cwd DIR] [--repo DIR] [--append-scope PATTERN] [-] < amendment.md",
     ],
-    stdin: { mode: "document", selector: { kind: "positional", index: 0, required: true, rejectBlank: true } },
+    stdin: { mode: "document", selector: { kind: "positional", index: 0, required: false, rejectBlank: true } },
     flags: ["cwd", "repo", "contract", "append-scope"],
-    purpose: "Append a prose amendment and one optional ordered scope-pattern delta from --append-scope or Scope Append.",
+    purpose: "Append narrative Markdown or ordered scope patterns. --append-scope is sufficient without Markdown; ## Replace Verifications replaces contract-only Verification declarations, with - (none) to clear them.",
     completionRank: 8,
 };

package/build/cli/commands/contract/arc/meta.js

@@ -21,6 +21,8 @@ export const meta = {
         "An empty seal is valid.",
         "The command does not create delivery commits.",
         "The first explicit arc seals a0; later arcs seal the previous open explicit arc.",
+        "Use arcs only for stages of one delivery and final settlement; an arc has no independent Scope, claim, or settlement.",
+        "--append-scope adds to the cumulative contract Scope, not an arc-local Scope.",
     ],
     completionRank: 1,
 };

package/build/cli/commands/contract/audit/handler.js

@@ -1,13 +1,39 @@
 import { auditContract } from "../../../../core/audit.js";
 import { resolveContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
+import { FlowError } from "../../../../flow-error.js";
 import { buildAuditConstructionFailure, buildAuditResponse } from "../../../render/audit.js";
 import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
+export function assertAuditPresentationOptions(options) {
+    if (options.skipDiffBody && options.diffBudgetBytes !== undefined) {
+        throw new FlowError("INVALID_USAGE", "audit --skip-diff-body cannot be used with --diff-budget");
+    }
+    if (options.skipDiffBody && options.json) {
+        throw new FlowError("INVALID_USAGE", "audit --skip-diff-body cannot be used with --json");
+    }
+}
+/** Shared ordinary audit pipeline for direct audit and renew's post-renew composition. */
+export async function runAuditCommand(options) {
+    assertAuditPresentationOptions(options);
+    return withResolvedAddress(options.address, async () => {
+        return buildAuditResponse(await auditContract({
+            cwd: options.cwd,
+            address: options.address,
+            diffBudgetBytes: options.skipDiffBody ? 0 : options.diffBudgetBytes,
+            signal: options.signal,
+        }), options.json === true);
+    });
+}
 export const handler = async (_stdin, flags, signal) => {
     try {
         const cwd = await repositoryDirectory(flags, "audit");
         const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
-        return await withResolvedAddress(address, async () => {
-            return buildAuditResponse(await auditContract({ cwd, address, diffBudgetBytes: flags.auditDiffBudgetBytes, signal }), flags.json === true);
+        return await runAuditCommand({
+            cwd,
+            address,
+            diffBudgetBytes: flags.auditDiffBudgetBytes,
+            skipDiffBody: flags.auditSkipDiffBody,
+            json: flags.json,
+            signal,
         });
     }
     catch (error) {

package/build/cli/commands/contract/audit/meta.js

@@ -2,14 +2,15 @@ export const meta = {
     command: "audit",
     summary: "Read settlement facts from one pinned delivery candidate",
     usage: [
-        "keiyaku audit [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--diff-budget BYTES] [--json]",
-        "keiyaku @<id> audit [--diff-budget BYTES] [--json]",
+        "keiyaku audit [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--diff-budget BYTES|--skip-diff-body] [--json]",
+        "keiyaku @<id> audit [--diff-budget BYTES|--skip-diff-body] [--json]",
     ],
     stdin: { mode: "argument" },
-    flags: ["cwd", "repo", "contract", "diff-budget", "json"],
+    flags: ["cwd", "repo", "contract", "diff-budget", "skip-diff-body", "json"],
     purpose: "Inspect one pinned delivery candidate, report settlement facts, and recheck its coordinates without mutating the source repository.",
     notes: [
         "Audit never invokes an Akuma or settles the contract.",
+        "--skip-diff-body suppresses only human raw-hunk presentation; it cannot be combined with --diff-budget or --json.",
         "Exit 0 means the report was constructed; exit 1 carries a typed construction cause.",
     ],
     completionRank: 9,

package/build/cli/commands/contract/petition/handler.js

@@ -18,11 +18,12 @@ export const handler = async (stdin, flags, signal) => {
     const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     return await withResolvedAddress(address, async () => {
         if (flags.dryRun) {
-            const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal });
+            const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal, appendScope: flags.appendScope });
             return buildPetitionPreviewResponse(await previewPetition({
                 cwd,
                 contractId: address.binding.commissionId,
                 oath: input.oath,
+                appendScope: input.appendScope,
                 signal,
             }), flags.json === true);
         }

package/build/cli/commands/contract/petition/meta.js

@@ -1,6 +1,6 @@
 export const meta = {
     command: "petition",
-    summary: "Run or preview the gated settlement pipeline",
+    summary: "Settle or preview settlement for a contract",
     usage: [
         "keiyaku petition [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--renew] [--append-scope PATTERN] [- < petition.md]",
         "keiyaku @<id> petition [-C|--cwd DIR] [--repo DIR] [--renew] [--append-scope PATTERN] [- < petition.md]",
@@ -8,7 +8,7 @@ export const meta = {
     ],
     stdin: { mode: "document", selector: { kind: "positional", index: 0, required: false, rejectBlank: false } },
     flags: ["cwd", "repo", "contract", "renew", "append-scope", "dry-run", "json"],
-    purpose: "Seal the current a0 or open explicit arc, queue the contract, and run verdict and claim processing; dry-run previews deterministic gates without mutation.",
+    purpose: "Seal the current delivery stage and run settlement checks before claiming the contract; dry-run previews deterministic checks without changing the contract.",
     input: [
         "## Oath",
         "<free first-person attestation>",

package/build/cli/commands/contract/renew/handler.js

@@ -2,23 +2,64 @@ import { resolveContractAddress, resolveExistingContractAddress } from "../../..
 import { abortRenewKeiyaku, continueRenewKeiyaku, renewKeiyaku } from "../../../../core/renew.js";
 import { buildRenewAbortResponse, buildRenewResponse } from "../../../render/arc.js";
 import { renderLifecycleResult } from "../../../render/lifecycle.js";
+import { buildAuditConstructionFailure } from "../../../render/audit.js";
+import { isCompleteLifecycleOutcome } from "../../../../core/outcome-base.js";
+import { writeCliOutput } from "../../../output-stream-error-policy.js";
+import { assertAuditPresentationOptions, runAuditCommand } from "../audit/handler.js";
+import { FlowError } from "../../../../flow-error.js";
 import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (_stdin, flags, signal) => {
+    if (flags.renewAbort && flags.renewAudit) {
+        throw new FlowError("INVALID_USAGE", "renew --audit cannot be used with --abort");
+    }
+    if (flags.auditSkipDiffBody && !flags.renewAudit) {
+        throw new FlowError("INVALID_USAGE", "renew --skip-diff-body requires --audit");
+    }
+    if (flags.renewAudit) {
+        assertAuditPresentationOptions({
+            diffBudgetBytes: flags.auditDiffBudgetBytes,
+            skipDiffBody: flags.auditSkipDiffBody,
+            json: flags.json,
+        });
+    }
     const cwd = await repositoryDirectory(flags, "renew");
     const resolveAddress = flags.renewContinue || flags.renewAbort
         ? resolveContractAddress
         : resolveExistingContractAddress;
     const address = await resolveAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     if (flags.renewContinue) {
-        return renderLifecycleResult(continueRenewKeiyaku({ cwd, address, appendScope: flags.appendScope, signal }), buildRenewResponse, { cwd, address });
+        const result = await continueRenewKeiyaku({ cwd, address, appendScope: flags.appendScope, signal });
+        if (!flags.renewAudit || !isCompleteLifecycleOutcome(result)) {
+            return renderLifecycleResult(Promise.resolve(result), buildRenewResponse, { cwd, address });
+        }
+        return renderRenewThenAudit({ cwd, address, result, flags, signal });
     }
     if (flags.renewAbort) {
         return renderLifecycleResult(abortRenewKeiyaku({ cwd, address, signal }), buildRenewAbortResponse, { cwd, address });
     }
-    return renderLifecycleResult(renewKeiyaku({
+    const result = await renewKeiyaku({
         cwd,
         address,
         appendScope: flags.appendScope,
         signal,
-    }), buildRenewResponse, { cwd, address });
+    });
+    if (!flags.renewAudit || !isCompleteLifecycleOutcome(result)) {
+        return renderLifecycleResult(Promise.resolve(result), buildRenewResponse, { cwd, address });
+    }
+    return renderRenewThenAudit({ cwd, address, result, flags, signal });
 };
+async function renderRenewThenAudit({ cwd, address, result, flags, signal, }) {
+    await writeCliOutput(process.stdout, `${buildRenewResponse(result).text}\n\n`);
+    try {
+        return await runAuditCommand({
+            cwd,
+            address,
+            diffBudgetBytes: flags.auditDiffBudgetBytes,
+            skipDiffBody: flags.auditSkipDiffBody,
+            signal,
+        });
+    }
+    catch (error) {
+        return buildAuditConstructionFailure(error, false);
+    }
+}

package/build/cli/commands/contract/renew/meta.js

@@ -2,17 +2,18 @@ export const meta = {
     command: "renew",
     summary: "Rewrite delivery onto the current base",
     usage: [
-        "keiyaku renew [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--append-scope PATTERN]",
-        "keiyaku @<id> renew --continue [--append-scope PATTERN]",
+        "keiyaku renew [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--append-scope PATTERN] [--audit [--skip-diff-body]]",
+        "keiyaku @<id> renew --continue [--append-scope PATTERN] [--audit [--skip-diff-body]]",
         "keiyaku @<id> renew --abort",
     ],
     stdin: { mode: "argument" },
-    flags: ["cwd", "repo", "contract", "append-scope", "continue", "abort"],
-    purpose: "Capture receipts, rewrite delivery onto the default branch, then seal the current a0 or open explicit arc and record the renewal.",
+    flags: ["cwd", "repo", "contract", "append-scope", "continue", "abort", "audit", "skip-diff-body"],
+    purpose: "Refresh committed contract changes onto the current target, then seal the refreshed delivery stage and record the renewal.",
     notes: [
         "After an explicit arc closes, refuses loose commits until another arc is open.",
         "Refuses while an Akuma is in flight.",
         "Conflicts create derived scratch without changing the ledger, delivery branch, or worktree; resolve that scratch with --continue or discard it with --abort.",
+        "--audit runs the ordinary read-only audit only after renew completes or reports already fresh; --skip-diff-body is available only with --audit.",
     ],
     completionRank: 9,
 };

package/build/cli/commands/metadata.js

@@ -1,12 +1,13 @@
 import { meta as bindMeta } from "./contract/bind/meta.js";
 import { meta as arcMeta } from "./contract/arc/meta.js";
 import { meta as callMeta } from "./projection/call/meta.js";
-import { meta as reviveMeta } from "./projection/revive/meta.js";
+import { meta as forkMeta } from "./projection/fork/meta.js";
 import { meta as waitMeta } from "./projection/wait/meta.js";
 import { meta as tellMeta } from "./projection/tell/meta.js";
 import { meta as killMeta } from "./projection/kill/meta.js";
 import { meta as logMeta } from "./contract/log/meta.js";
 import { meta as akumaMeta } from "./akuma/akuma/meta.js";
+import { meta as akumaListMeta } from "./akuma/list/meta-list.js";
 import { meta as akumaLsMeta } from "./akuma/list/meta-ls.js";
 import { meta as akumaShowMeta } from "./akuma/show/meta.js";
 import { meta as skillsMeta } from "./skills/skills/meta.js";
@@ -16,6 +17,7 @@ import { meta as auditMeta } from "./contract/audit/meta.js";
 import { meta as renewMeta } from "./contract/renew/meta.js";
 import { meta as petitionMeta } from "./contract/petition/meta.js";
 import { meta as forfeitMeta } from "./contract/forfeit/meta.js";
+import { meta as verificationMeta } from "./verification/meta.js";
 import { meta as guideMeta } from "./system/guide/meta.js";
 import { meta as completionMeta } from "./system/completion/meta.js";
 import { meta as statusMeta } from "./projection/status/meta.js";
@@ -31,24 +33,25 @@ import { meta as taskStopMeta } from "./task/stop/meta.js";
 import { meta as taskHoldMeta } from "./task/hold/meta.js";
 import { meta as taskResumeMeta } from "./task/resume/meta.js";
 import { meta as taskDoneMeta } from "./task/done/meta.js";
+import { meta as taskNoteMeta } from "./task/note/meta.js";
 import { meta as taskDropMeta } from "./task/drop/meta.js";
 import { meta as taskUpdateMeta } from "./task/update/meta.js";
 import { meta as taskDoctorMeta } from "./task/doctor/meta.js";
 import { meta as dumpEnvMeta } from "./system/dump-env/meta.js";
 export const COMMAND_METADATA_ORDER = [
-    "bind", "arc", "call", "revive", "wait", "tell", "kill", "log",
-    "akuma", "akuma ls", "akuma show", "skills", "skills install", "amend", "audit",
-    "renew", "petition", "forfeit", "guide", "completion", "status", "history", "task",
-    "task add", "task compose", "task show", "task ls", "task log", "task start", "task stop", "task hold", "task resume", "task done",
+    "bind", "arc", "call", "fork", "wait", "tell", "kill", "log",
+    "akuma", "akuma list", "akuma ls", "akuma show", "skills", "skills install", "amend", "audit",
+    "renew", "petition", "forfeit", "verification", "guide", "completion", "status", "history", "task",
+    "task add", "task compose", "task show", "task ls", "task log", "task start", "task stop", "task hold", "task resume", "task done", "task note",
     "task drop", "task update", "task doctor", "dump-env",
 ];
 const COMMAND_METADATA = [
-    bindMeta, arcMeta, callMeta, reviveMeta, waitMeta, tellMeta, killMeta, logMeta,
-    akumaMeta, akumaLsMeta, akumaShowMeta, skillsMeta, skillsInstallMeta, amendMeta, auditMeta,
-    renewMeta, petitionMeta, forfeitMeta, guideMeta, completionMeta, statusMeta, historyMeta,
+    bindMeta, arcMeta, callMeta, forkMeta, waitMeta, tellMeta, killMeta, logMeta,
+    akumaMeta, akumaListMeta, akumaLsMeta, akumaShowMeta, skillsMeta, skillsInstallMeta, amendMeta, auditMeta,
+    renewMeta, petitionMeta, forfeitMeta, verificationMeta, guideMeta, completionMeta, statusMeta, historyMeta,
     taskMeta, taskAddMeta, taskComposeMeta, taskShowMeta, taskLsMeta, taskLogMeta, taskStartMeta, taskStopMeta,
     taskHoldMeta, taskResumeMeta,
-    taskDoneMeta, taskDropMeta, taskUpdateMeta, taskDoctorMeta, dumpEnvMeta,
+    taskDoneMeta, taskNoteMeta, taskDropMeta, taskUpdateMeta, taskDoctorMeta, dumpEnvMeta,
 ];
 export const CLI_COMMAND_METADATA = Object.fromEntries(COMMAND_METADATA.map((meta) => [meta.command, meta]));
 export function getCommandMetadata(command) {

package/build/cli/commands/projection/call/handler.js

@@ -10,7 +10,7 @@ export const handler = async (stdin, flags, signal) => {
         // Bounded outer join: same durable launch/adoption as detach, without core's unbounded join.
         ...(flags.timeoutMs !== undefined ? { detach: true } : {}),
         signal,
-        ...(!flags.detach
+        ...(!flags.json && !flags.detach
             ? {
                 onLaunch: ({ address, projection, akumaName }) => {
                     process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget, akumaName)}\n`);

package/build/cli/commands/projection/call/meta.js

@@ -6,7 +6,7 @@ export const meta = {
         mode: "argument",
         selector: { kind: "positional", index: 0, required: true, rejectBlank: true },
     },
-    flags: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach", "alias", "wait"],
+    flags: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach", "alias", "wait", "json"],
     purpose: "Run a scoped helper task.",
     completionRank: 2,
 };

package/build/cli/commands/projection/catalog.js

@@ -1,5 +1,5 @@
 import { meta as callMeta } from "./call/meta.js";
-import { meta as reviveMeta } from "./revive/meta.js";
+import { meta as forkMeta } from "./fork/meta.js";
 import { meta as waitMeta } from "./wait/meta.js";
 import { meta as tellMeta } from "./tell/meta.js";
 import { meta as killMeta } from "./kill/meta.js";
@@ -7,7 +7,7 @@ import { meta as statusMeta } from "./status/meta.js";
 import { meta as historyMeta } from "./history/meta.js";
 export const projectionCatalog = [
     { meta: callMeta, load: () => import("./call/handler.js") },
-    { meta: reviveMeta, load: () => import("./revive/handler.js") },
+    { meta: forkMeta, load: () => import("./fork/handler.js") },
     { meta: waitMeta, load: () => import("./wait/handler.js") },
     { meta: tellMeta, load: () => import("./tell/handler.js") },
     { meta: killMeta, load: () => import("./kill/handler.js") },

package/build/cli/commands/projection/{revive → fork}/handler.js

@@ -3,13 +3,14 @@ import { FlowError } from "../../../../flow-error.js";
 import { buildArtifactResolutionAttempt, } from "../../../../core/addressing.js";
 import { runCallAndPersist } from "../../../../core/call-persist.js";
 import { locateResponseArtifact, reconcileResponseArtifactCatalog, } from "../../../../core/transcripts.js";
+import { resolveProjectionHistoryAddress } from "../../../../core/projection/index.js";
 import { observeGitRepository } from "../../../../git/branches.js";
 import { stableRepoRoot } from "../../../../core/worktree-path.js";
 import { buildCallResponse } from "../../../render/call.js";
-import { buildCallInput, effectiveDirectory, projectDirectory, revivePrompt } from "../../shared.js";
+import { buildCallInput, effectiveDirectory, forkPrompt, projectDirectory } from "../../shared.js";
 export const handler = async (stdin, flags, signal, positional) => {
     const cwd = effectiveDirectory(flags);
-    const artifactCwd = await projectDirectory(flags, "revive");
+    const artifactCwd = await projectDirectory(flags, "fork");
     const artifactId = positional[0];
     const repository = await observeGitRepository(artifactCwd);
     if (repository.capability === "unknown")
@@ -20,7 +21,7 @@ export const handler = async (stdin, flags, signal, positional) => {
         await reconcileResponseArtifactCatalog(responseStoreCwd);
     }
     catch {
-        // The catalog is disposable and cannot make an otherwise valid revive fail.
+        // The catalog is disposable and cannot make an otherwise valid fork fail.
     }
     const artifact = await locateResponseArtifact({
         cwd: responseStoreCwd,
@@ -34,6 +35,7 @@ export const handler = async (stdin, flags, signal, positional) => {
             inference: ["response artifact identity lookup"],
         }),
     });
+    const sourceProjectionId = await resolveProjectionHistoryAddress(responseStoreCwd, artifactId);
     let executionCwd;
     let repo;
     if (artifact.provenance.authority.kind === "repository") {
@@ -48,9 +50,12 @@ export const handler = async (stdin, flags, signal, positional) => {
         repo = undefined;
     }
     const outcome = await runCallAndPersist({
-        ...buildCallInput(revivePrompt(stdin), { ...flags, cwd: executionCwd, repo }, "revive"),
+        ...buildCallInput(forkPrompt(stdin), { ...flags, cwd: executionCwd, repo }, "revive"),
         reviveArtifact: artifact,
         signal,
     });
-    return buildCallResponse(outcome.result, { responsePath: outcome.responsePath, artifactId: outcome.artifactId, addressPlacement: "footer" });
+    return buildCallResponse({
+        ...outcome.result,
+        ...(sourceProjectionId ? { sourceProjectionId } : {}),
+    }, { responsePath: outcome.responsePath, artifactId: outcome.artifactId, addressPlacement: "footer" });
 };

package/build/cli/commands/projection/fork/meta.js

@@ -0,0 +1,12 @@
+export const meta = {
+    command: "fork",
+    summary: "Start an Akuma helper session from a response artifact",
+    usage: ["keiyaku fork ARTIFACT [BODY|-]"],
+    stdin: {
+        mode: "argument",
+        selector: { kind: "positional", index: 1, required: false, rejectBlank: true },
+    },
+    flags: ["cwd", "repo", "model", "effort", "json"],
+    purpose: "Start a new projection from a persisted helper session.",
+    completionRank: 4,
+};

package/build/cli/commands/projection/history/handler.js

@@ -3,19 +3,63 @@ import { FlowError } from "../../../../flow-error.js";
 import { projectionHistoryJson, renderProjectionHistoryDetail, renderProjectionHistoryList } from "../../../render/projection-history.js";
 import { textResponse } from "../../../render/shared.js";
 import { projectDirectory } from "../../shared.js";
+const DEFAULT_HISTORY_LIMIT = 20;
+function page(entries, offset, requestedLimit) {
+    const limit = requestedLimit ?? DEFAULT_HISTORY_LIMIT;
+    const selected = entries.slice(offset, offset + limit);
+    const nextOffset = offset + selected.length < entries.length ? offset + selected.length : null;
+    return { entries: selected, pagination: { offset, limit, total: entries.length, nextOffset } };
+}
+function rawAvailability() {
+    return { retention: "unavailable", reason: "provider-raw-body-not-retained" };
+}
 export const handler = async (_stdin, flags, _signal, positional) => {
     const cwd = await projectDirectory(flags, "history");
     const [address] = positional;
+    const offset = flags.historyOffset ?? 0;
     if (!address) {
+        if (flags.historyRaw || flags.historyEntry !== undefined) {
+            throw new FlowError("INVALID_USAGE", "history --raw and --entry require one projection, alias, or artifact address");
+        }
         const runs = selectProjectionHistory(await readProjectionHistory(cwd), {
             filters: flags.taskFilters,
             sort: flags.taskSort,
             nowMs: Date.now(),
         });
-        return textResponse(flags.json ? projectionHistoryJson(runs) : renderProjectionHistoryList(runs));
+        const result = page(runs, offset, flags.historyLimit);
+        return textResponse(flags.json ? projectionHistoryJson(result) : renderProjectionHistoryList(result.entries, result.pagination));
+    }
+    if (flags.historyRaw && !flags.json) {
+        throw new FlowError("INVALID_USAGE", "history --raw requires --json");
+    }
+    if (flags.historyRaw && flags.historyEntry === undefined) {
+        throw new FlowError("INVALID_USAGE", "history --raw requires --entry N");
+    }
+    if (flags.historyEntry !== undefined && (flags.historyLimit !== undefined || offset !== 0)) {
+        throw new FlowError("INVALID_USAGE", "history --entry cannot be combined with --limit or --offset");
     }
     const detail = await readProjectionHistoryAddress(cwd, address);
     if (!detail)
         throw new FlowError("PROJECTION_HISTORY_NOT_FOUND", `history has no retained run for '${address}'`);
-    return textResponse(flags.json ? projectionHistoryJson(detail) : renderProjectionHistoryDetail(detail));
+    const addressedDetail = {
+        ...detail,
+        inputToken: address,
+        canonicalId: detail.id,
+    };
+    if (flags.historyEntry !== undefined) {
+        const entry = detail.activity?.retainedTimeline[flags.historyEntry];
+        if (!entry)
+            throw new FlowError("PROJECTION_HISTORY_NOT_FOUND", `history entry ${flags.historyEntry} is not retained for '${address}'`);
+        const response = {
+            id: addressedDetail.id,
+            inputToken: addressedDetail.inputToken,
+            canonicalId: detail.id,
+            ...(detail.alias ? { alias: detail.alias } : {}),
+            entry: { index: flags.historyEntry, event: entry, ...(flags.historyRaw ? { raw: rawAvailability() } : {}) },
+        };
+        return textResponse(flags.json ? projectionHistoryJson(response) : renderProjectionHistoryDetail(detail, response.entry));
+    }
+    return textResponse(flags.json
+        ? projectionHistoryJson(addressedDetail)
+        : renderProjectionHistoryDetail(detail));
 };

package/build/cli/commands/projection/history/meta.js

@@ -1,9 +1,9 @@
 export const meta = {
     command: "history",
     summary: "Discover retained Akuma runs or inspect one run",
-    usage: ["keiyaku history [PROJECTION|ALIAS|ARTIFACT] [-C|--cwd DIR] [--filter EXPR] [--sort KEYS] [--json]"],
+    usage: ["keiyaku history [PROJECTION|ALIAS|ARTIFACT] [-C|--cwd DIR] [--limit COUNT] [--offset COUNT] [--entry N] [--raw --json] [--json]"],
     stdin: { mode: "argument" },
-    flags: ["cwd", "repo", "filter", "sort", "json"],
-    purpose: "Read retained projection history and the public response-file path without reading response content.",
+    flags: ["cwd", "repo", "limit", "offset", "entry", "raw", "json"],
+    purpose: "Read bounded retained projection history; raw provider bodies require --json --raw on one addressed entry.",
     completionRank: 15,
 };

package/build/cli/commands/projection/kill/meta.js

@@ -1,11 +1,11 @@
 export const meta = {
     command: "kill",
-    summary: "Stop the current projection generation",
+    summary: "Stop a projection's active run",
     usage: [
         "keiyaku kill <projection-address> [--wait DURATION]",
         "keiyaku @addr kill <projection-address> [--wait DURATION]",
     ],
     stdin: { mode: "argument" },
     flags: ["cwd", "repo", "contract", "wait"],
-    purpose: "Terminate the current generation while keeping the projection identity and tell ledger.",
+    purpose: "Stop the active run while keeping the projection available for inspection and follow-up messages.",
 };