@astrosheep/keiyaku 2.9.5 → 2.9.7

package/build/agents/harness/outcome.js

@@ -3,13 +3,17 @@ import { SUBAGENT_SESSION_VERSION, } from "../session.js";
 import { OUTCOME_ERROR_VERSION, SubagentFailure, } from "../types.js";
 import { isProviderTerminalError, } from "./provider-adapter.js";
 import { renderCapturedText } from "./runtime.js";
-export function createOutcomeState(maxCaptureChars) {
+export function createOutcomeState(maxCaptureChars, admittedSession) {
     return {
         outputBuffer: new StringTailBuffer(maxCaptureChars),
         diagnosticsBuffer: new StringTailBuffer(maxCaptureChars),
         warnings: [],
+        ...(admittedSession ? { session: admittedSession } : {}),
     };
 }
+export function recordSessionAdmission(state, session) {
+    state.session = session;
+}
 function mintOutcome(draft) {
     return draft;
 }
@@ -29,7 +33,6 @@ export function processEvent(state, event) {
             return;
         case "done":
             state.doneEvent = event;
-            state.session = event.session;
             if (event.finalMessage !== undefined) {
                 state.finalMessageCandidate = event.finalMessage;
             }
@@ -83,6 +86,16 @@ export function classifyFailure(shared, state, error, idleTimedOut, transportFai
             warnings: [...state.warnings],
         });
     }
+    if (shared.explicitlyAborted && isProviderTerminalError(error) && error.fact.kind === "aborted") {
+        return mintOutcome({
+            status: "interrupted",
+            finalMessage: state.finalMessageCandidate ?? "",
+            output: renderCapturedText(state.outputBuffer),
+            diagnostics: renderCapturedText(state.diagnosticsBuffer),
+            session: state.session ?? fallbackSession(shared),
+            warnings: [...state.warnings],
+        });
+    }
     if (transportFailure) {
         const message = transportFailure instanceof Error ? transportFailure.message : `${shared.terms.provider} session transport probe failed`;
         const timeoutMs = isProviderTerminalError(transportFailure) && transportFailure.fact.kind === "failed"
@@ -173,13 +186,16 @@ export function failWithError(shared, state, error, finalMessage, diagnostics =
         warnings: [...state.warnings],
     });
 }
-export function completeOutcome(shared, state, finalMessage, session) {
+export function completeOutcome(state, finalMessage) {
+    if (!state.session) {
+        throw new Error("Cannot complete an outcome before session admission");
+    }
     return mintOutcome({
         status: "completed",
         finalMessage,
         output: renderCapturedText(state.outputBuffer),
         diagnostics: renderCapturedText(state.diagnosticsBuffer),
-        session,
+        session: state.session,
         warnings: [...state.warnings],
     });
 }

package/build/agents/harness/projection.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { FlowError } from "../../flow-error.js";
 import { createEventChannel } from "./event-channel.js";
 import { overflowMarkerFromDropped, prepareAgentEventForPersistence, } from "./execution-handle.js";
-import { classifyFailure, classifySettlementFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, renderOutcomeCapturedText, } from "./outcome.js";
+import { classifyFailure, classifySettlementFailure, completeOutcome, createOutcomeState, failFromFailEvent, failWithError, processEvent, recordSessionAdmission, renderOutcomeCapturedText, } from "./outcome.js";
 import { startLiveProjection } from "./router.js";
 import { createAbortError } from "./runtime.js";
 const POLICY_BUDGET_CLEANUP_GRACE_MS = 5_000;
@@ -198,7 +198,7 @@ function deliverDriverEvent(shared, state, live, event, refreshIdleTimeout, know
     processEvent(state, event);
 }
 async function settleProjection(shared) {
-    const state = createOutcomeState(shared.terms.maxCaptureChars);
+    const state = createOutcomeState(shared.terms.maxCaptureChars, shared.reviveTerms?.session);
     let idleTimedOut = false;
     let transportFailure;
     let policyBudgetExceeded = false;
@@ -245,7 +245,6 @@ async function settleProjection(shared) {
         resolvePolicyBudget();
     }, shared.terms.executionTimeoutMs);
     executionTimeout.unref?.();
-    refreshIdleTimeout();
     const requestLiveAbort = () => {
         if (shared.explicitlyAborted)
             return;
@@ -257,7 +256,10 @@ async function settleProjection(shared) {
     shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
     const providerSettlement = (async () => {
         try {
-            const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer);
+            const live = await startLiveProjection(shared.terms, shared.lifecycleAbort.signal, shared.reviveTerms, refreshIdleTimeout, shared.observer, (admission) => {
+                recordSessionAdmission(state, admission.session);
+                refreshIdleTimeout();
+            });
             liveDriver = live;
             shared.onLive(live);
             resolveForceWaiters(shared, live);
@@ -324,8 +326,7 @@ async function settleProjection(shared) {
                 completionOutcome?.finalMessage ??
                 state.finalMessageCandidate ??
                 renderOutcomeCapturedText(state.outputBuffer).trim();
-            const session = state.doneEvent?.session ?? completionOutcome?.session;
-            if (!session) {
+            if (!state.session) {
                 return failWithError(shared, state, {
                     code: "SUBAGENT_EXEC_ERROR",
                     message: `${shared.terms.provider} exec ended without a session handle`,
@@ -333,7 +334,7 @@ async function settleProjection(shared) {
                     exitCode: null,
                 }, finalMessage);
             }
-            return completeOutcome(shared, state, finalMessage, session);
+            return completeOutcome(state, finalMessage);
         }
         catch (error) {
             if (error instanceof FlowError) {

package/build/agents/harness/router.js

@@ -1,5 +1,5 @@
 import { getProviderRegistration } from "../providers/registry.js";
-export async function startLiveProjection(terms, signal, reviveTerms, onIngress, observer) {
+export async function startLiveProjection(terms, signal, reviveTerms, onIngress, observer, onSessionAdmission) {
     const onSyncCheckpoint = observer
         ? (control, checkpoint) => {
             observer.onCheckpoint(control, checkpoint);
@@ -19,6 +19,7 @@ export async function startLiveProjection(terms, signal, reviveTerms, onIngress,
         reviveTerms,
         onSyncCheckpoint,
         onDeliveryOpportunity,
+        onSessionAdmission,
         onIngress,
         observer,
     });

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

@@ -198,6 +198,7 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 queryActive = true;
                 notifyActive();
                 let resumedSessionId = sessionId;
+                let admittedSessionId;
                 let finalMessage;
                 let latestAssistantMessageModel;
                 // Provider acceptance / pre-terminal retry evidence for no-turn classification.
@@ -207,7 +208,18 @@ export async function startClaudeAgentSdk(prompt, cwd, options) {
                 const seenToolUses = new Map();
                 for await (const event of query) {
                     builder.ingress(CLAUDE_AGENT_SDK_PROVIDER, event.type, event, claudeIngressDisposition(event.type), () => {
-                        resumedSessionId = extractResumeToken(event) ?? resumedSessionId;
+                        const providerSessionId = extractResumeToken(event);
+                        resumedSessionId = providerSessionId ?? resumedSessionId;
+                        if (providerSessionId && providerSessionId !== admittedSessionId) {
+                            admittedSessionId = providerSessionId;
+                            options.onSessionAdmission?.({
+                                session: {
+                                    provider: CLAUDE_AGENT_SDK_PROVIDER,
+                                    version: SUBAGENT_SESSION_VERSION,
+                                    handle: { sessionId: providerSessionId },
+                                },
+                            });
+                        }
                         if (isClaudeApiRetryEvent(event)) {
                             lastPreTerminalEvidenceWasRetry = true;
                             builder.emit({ type: "warning", warning: mapClaudeApiRetryWarning(event) });

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

@@ -179,7 +179,7 @@ export const claudeAgentSdkRegistration = {
         return loader ? { ...terms, loader } : terms;
     },
     nativePolicyOwnership: () => null,
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onIngress }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onSessionAdmission, onIngress }) => {
         if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
             throw new Error(`startLive expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
         }
@@ -197,6 +197,7 @@ export const claudeAgentSdkRegistration = {
             systemPrompt: claudeTerms.systemPrompt,
             onSyncCheckpoint,
             onEvidence: claudeTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: claudeTerms.initialTurn,
             loader: claudeTerms.loader,

package/build/agents/providers/codex-app-server/adapter.js

@@ -304,6 +304,15 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                     builder.emit({ type: "fail", message });
                     throw createProviderFailure(message);
                 }
+                const admittedSession = {
+                    provider: "codex-app-server",
+                    version: SUBAGENT_SESSION_VERSION,
+                    handle: {
+                        threadId: activeThreadId,
+                        ...(serverCodexHome ? { codexHome: serverCodexHome } : {}),
+                    },
+                };
+                options.onSessionAdmission?.({ session: admittedSession });
                 if (options.onEvidence)
                     emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_APP_SERVER_PROVIDER, threadId: activeThreadId }, builderDiagnostic);
                 // Policy A defaults, but omit when config.* already owns that surface (thread/start config wins).
@@ -351,17 +360,9 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                     throw createProviderFailure(message);
                 }
                 // Successful turn/completed is consumption evidence; interrupt ack alone is not terminal proof.
-                const session = {
-                    provider: "codex-app-server",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: {
-                        threadId: activeThreadId,
-                        ...(serverCodexHome ? { codexHome: serverCodexHome } : {}),
-                    },
-                };
                 const finalMessage = turnState.lastAgentMessage;
-                builder.emit({ type: "done", finalMessage, session });
-                return { finalMessage, session };
+                builder.emit({ type: "done", finalMessage, session: admittedSession });
+                return { finalMessage, session: admittedSession };
             }
             finally {
                 activeTurnCompletion = undefined;

package/build/agents/providers/codex-app-server/registration.js

@@ -212,7 +212,7 @@ export const codexAppServerRegistration = {
             webSearch: Object.freeze(webSearch),
         });
     },
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onIngress, }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onSessionAdmission, onIngress, }) => {
         if (terms.provider !== CODEX_APP_SERVER_PROVIDER) {
             throw new Error(`startLive expected ${CODEX_APP_SERVER_PROVIDER}`);
         }
@@ -231,6 +231,7 @@ export const codexAppServerRegistration = {
             onSyncCheckpoint,
             onDeliveryOpportunity,
             onEvidence: codexTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: codexTerms.initialTurn,
         };

package/build/agents/providers/opencode-sdk/adapter.js

@@ -264,6 +264,13 @@ export async function startOpencode(prompt, cwd, options = {}) {
                     builder.emit({ type: "fail", message });
                     throw createProviderFailure(message);
                 }
+                options.onSessionAdmission?.({
+                    session: {
+                        provider: OPENCODE_SDK_PROVIDER,
+                        version: SUBAGENT_SESSION_VERSION,
+                        handle: { sessionId: activeSessionId },
+                    },
+                });
                 idleMonitor = new OpencodeIdleMonitor(sdk.client.v2.session, activeSessionId, combined.signal);
                 eventController = createOpencodeEventController({
                     builder,

package/build/agents/providers/opencode-sdk/registration.js

@@ -104,7 +104,7 @@ export const opencodeSdkRegistration = {
         return loader ? { ...terms, loader } : terms;
     },
     nativePolicyOwnership: () => null,
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onIngress, }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onSessionAdmission, onIngress, }) => {
         if (terms.provider !== OPENCODE_SDK_PROVIDER) {
             throw new Error(`startLive expected ${OPENCODE_SDK_PROVIDER}`);
         }
@@ -118,6 +118,7 @@ export const opencodeSdkRegistration = {
             onSyncCheckpoint,
             onDeliveryOpportunity,
             onEvidence: opencodeTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: opencodeTerms.initialTurn,
             loader: opencodeTerms.loader,

package/build/agents/providers/pi/adapter.js

@@ -1,5 +1,6 @@
 import { FlowError } from "../../../flow-error.js";
 import { appendDebugLog } from "../../../telemetry/debug-log.js";
+import { SUBAGENT_SESSION_VERSION, } from "../../session.js";
 import { createProjectionDriver } from "../../harness/execution-handle.js";
 import { createProviderFailure, toProviderTerminalError, } from "../../harness/provider-adapter.js";
 import { createAbortError, emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
@@ -103,6 +104,15 @@ async function openPiProjectionDriver(prompt, cwd, options) {
         ...(resourceLoader ? { resourceLoader } : {}),
     });
     const session = created.session;
+    if (session.sessionFile) {
+        options.onSessionAdmission?.({
+            session: {
+                provider: PI_PROVIDER,
+                version: SUBAGENT_SESSION_VERSION,
+                handle: { sessionId: session.sessionId, sessionFile: session.sessionFile },
+            },
+        });
+    }
     if (options.onEvidence)
         emitProviderEvidence(options.onEvidence, { type: "session", provider: PI_PROVIDER, sessionId: session.sessionId, ...(session.sessionFile ? { sessionFile: session.sessionFile } : {}) }, reportEvidenceDiagnostic);
     session.setSteeringMode("one-at-a-time");

package/build/agents/providers/pi/registration.js

@@ -109,7 +109,7 @@ export const piRegistration = {
         return loader ? { ...terms, loader } : terms;
     },
     nativePolicyOwnership: () => null,
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onIngress }) => {
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onSessionAdmission, onIngress }) => {
         if (terms.provider !== PI_PROVIDER) {
             throw new Error(`startLive expected ${PI_PROVIDER}`);
         }
@@ -125,6 +125,7 @@ export const piRegistration = {
                 appendSystemPromptOverride: piTerms.appendSystemPromptOverride,
                 onSyncCheckpoint,
                 onEvidence: piTerms.onEvidence,
+                onSessionAdmission,
                 onIngress,
                 initialTurn: piTerms.initialTurn,
                 loader: piTerms.loader,
@@ -137,6 +138,7 @@ export const piRegistration = {
             appendSystemPromptOverride: piTerms.appendSystemPromptOverride,
             onSyncCheckpoint,
             onEvidence: piTerms.onEvidence,
+            onSessionAdmission,
             onIngress,
             initialTurn: piTerms.initialTurn,
             loader: piTerms.loader,

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

@@ -1,13 +1,19 @@
-import { bindContract } from "../../../../core/bind.js";
+import { bindContract, previewBindContract } from "../../../../core/bind.js";
 import { defaultActorClock } from "../../../../core/outcome-base.js";
 import { writeDraftArtifact } from "../../../draft-artifact.js";
-import { buildBindDraftResponse, buildBindResponse, textResponse } from "../../../render/shared.js";
+import { buildBindDraftResponse, buildBindPreviewResponse, buildBindResponse } from "../../../render/shared.js";
 import { repositoryDirectory } from "../../shared.js";
 export const handler = async (stdin, flags, signal) => {
+    const cwd = await repositoryDirectory(flags, "bind");
     if (flags.dryRun) {
-        return textResponse(stdin);
+        const preview = await previewBindContract({
+            cwd, draft: stdin, ...defaultActorClock(), workspace: "worktree",
+            after: flags.after ?? [], exclusive: flags.exclusive,
+            ...(flags.bindTaskIds === undefined ? {} : { taskIds: flags.bindTaskIds }),
+            signal,
+        });
+        return buildBindPreviewResponse(preview);
     }
-    const cwd = await repositoryDirectory(flags, "bind");
     if (flags.draftOnly) {
         return buildBindDraftResponse(await writeDraftArtifact({ cwd, title: "bind-draft", content: stdin }));
     }

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

@@ -17,10 +17,10 @@ export const meta = {
         "<what the commission should accomplish>",
         "",
         "## Scope",
-        "```",
+        "~~~",
         "<pattern>",
         "<another-pattern>",
-        "```",
+        "~~~",
         "",
         "## Checks",
         "- <verification>",
@@ -40,10 +40,10 @@ export const meta = {
             "<what the commission should accomplish>",
             "",
             "## Scope",
-            "```",
+            "~~~",
             "<pattern>",
             "<another-pattern>",
-            "```",
+            "~~~",
             "",
             "## Checks",
             "- <verification>",
@@ -52,10 +52,10 @@ export const meta = {
         [
             "keiyaku bind --task fix-flaky-pump - <<'KEIYAKU'",
             "## Scope",
-            "```",
+            "~~~",
             "<pattern>",
             "<another-pattern>",
-            "```",
+            "~~~",
             "",
             "## Checks",
             "- <verification>",

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

@@ -1,23 +1,36 @@
 import { FlowError } from "../../../../flow-error.js";
 import { resolveExistingContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
 import { buildPetitionClaimInput, petitionKeiyaku, previewPetition, } from "../../../../core/settlement/index.js";
-import { buildPetitionClaimResponse, buildPetitionPreviewResponse } from "../../../render/petition.js";
+import { renewKeiyaku } from "../../../../core/renew.js";
+import { buildPetitionClaimResponse, buildPetitionPreviewResponse, renderPetitionRenewedConsequence, } from "../../../render/petition.js";
+import { writeCliOutput } from "../../../output-stream-error-policy.js";
 import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (stdin, flags, signal) => {
     if (flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
+    if (flags.renewBeforePetition && flags.dryRun) {
+        throw new FlowError("EMPTY_PARAM", "petition --renew cannot be used with --dry-run");
+    }
     const cwd = await repositoryDirectory(flags, "petition");
     const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     return await withResolvedAddress(address, async () => {
-        const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal, appendScope: flags.appendScope });
         if (flags.dryRun) {
+            const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal });
             return buildPetitionPreviewResponse(await previewPetition({
                 cwd,
                 contractId: address.binding.commissionId,
                 oath: input.oath,
             }), flags.json === true);
         }
-        return buildPetitionClaimResponse({ ...await petitionKeiyaku(input), address }, input);
+        const renewed = flags.renewBeforePetition
+            ? await renewKeiyaku({ cwd, address, appendScope: flags.appendScope })
+            : undefined;
+        if (renewed && !renewed.alreadyFresh) {
+            await writeCliOutput(process.stdout, `${renderPetitionRenewedConsequence(renewed)}\n`);
+        }
+        const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal, appendScope: flags.appendScope });
+        const petitionInput = renewed ? { ...input, appendScope: undefined } : input;
+        return buildPetitionClaimResponse({ ...await petitionKeiyaku(petitionInput), address }, input);
     });
 };

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

@@ -2,12 +2,12 @@ export const meta = {
     command: "petition",
     summary: "Run or preview the gated settlement pipeline",
     usage: [
-        "keiyaku petition [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--append-scope PATTERN] [- < petition.md]",
-        "keiyaku @<id> petition [-C|--cwd DIR] [--repo DIR] [--append-scope PATTERN] [- < petition.md]",
+        "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]",
         "keiyaku @<id> petition --dry-run [--json] [- < petition.md]",
     ],
     stdin: { mode: "document", selector: { kind: "positional", index: 0, required: false, rejectBlank: false } },
-    flags: ["cwd", "repo", "contract", "append-scope", "dry-run", "json"],
+    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.",
     input: [
         "## Oath",
@@ -16,7 +16,7 @@ export const meta = {
     notes: [
         "Petition stdin is optional and read only when literal - is supplied; a missing, empty, or blank oath is rejected by the settlement gate with OATH_MISSING.",
         "The machine checks only that the oath is present. Accepted oath text is persisted in the petition entry and hidden from the reviewer.",
-        "Base drift requires explicit `keiyaku renew` before petition.",
+        "Use --renew to run ordinary renew before petition; renew failures stop the command before settlement.",
         "Dry-run never runs verification or review and exits 0, 1, or 2.",
     ],
     completionRank: 10,

package/build/cli/commands/metadata.js

@@ -23,6 +23,7 @@ import { meta as taskMeta } from "./task/task/meta.js";
 import { meta as taskAddMeta } from "./task/add/meta.js";
 import { meta as taskShowMeta } from "./task/show/meta.js";
 import { meta as taskLsMeta } from "./task/ls/meta.js";
+import { meta as taskLogMeta } from "./task/log/meta.js";
 import { meta as taskStartMeta } from "./task/start/meta.js";
 import { meta as taskStopMeta } from "./task/stop/meta.js";
 import { meta as taskDoneMeta } from "./task/done/meta.js";
@@ -34,14 +35,14 @@ export const COMMAND_METADATA_ORDER = [
     "bind", "arc", "call", "revive", "wait", "tell", "kill", "log",
     "akuma", "akuma ls", "akuma view", "skills", "skills install", "amend", "audit",
     "renew", "petition", "forfeit", "guide", "completion", "status", "task",
-    "task add", "task show", "task ls", "task start", "task stop", "task done",
+    "task add", "task show", "task ls", "task log", "task start", "task stop", "task done",
     "task drop", "task update", "task doctor", "dump-env",
 ];
 const COMMAND_METADATA = [
     bindMeta, arcMeta, callMeta, reviveMeta, waitMeta, tellMeta, killMeta, logMeta,
     akumaMeta, akumaLsMeta, akumaViewMeta, skillsMeta, skillsInstallMeta, amendMeta, auditMeta,
     renewMeta, petitionMeta, forfeitMeta, guideMeta, completionMeta, statusMeta,
-    taskMeta, taskAddMeta, taskShowMeta, taskLsMeta, taskStartMeta, taskStopMeta,
+    taskMeta, taskAddMeta, taskShowMeta, taskLsMeta, taskLogMeta, taskStartMeta, taskStopMeta,
     taskDoneMeta, taskDropMeta, taskUpdateMeta, taskDoctorMeta, dumpEnvMeta,
 ];
 export const CLI_COMMAND_METADATA = Object.fromEntries(COMMAND_METADATA.map((meta) => [meta.command, meta]));

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

@@ -1,5 +1,5 @@
 import { FlowError } from "../../../../flow-error.js";
-import { assertTellEffortSupported, tellProjection, writeInboxTell } from "../../../../core/projection/index.js";
+import { assertTellEffortSupported, interruptProjectionGeneration, tellProjection, writeInboxTell } from "../../../../core/projection/index.js";
 import { waitForProjection } from "../../../../core/projection/index.js";
 import { prependAddressReceipt } from "../../../render/address.js";
 import { buildSilentTellResponse } from "../../../render/tell.js";
@@ -13,7 +13,15 @@ export const handler = async (body, flags, signal, positional) => runProjectionC
     assertTellEffortSupported(projection.directory, flags.effort);
     // Address admission and any effort validation precede the durable mailbox write.
     writeInboxTell(projection.directory, body, Date.now(), { effort: flags.effort });
-    await tellProjection(projection.directory, projection.id, flags.effort);
+    if (flags.interrupt) {
+        const interrupted = interruptProjectionGeneration(projection.directory);
+        if (interrupted.status === "already-closed") {
+            await tellProjection(projection.directory, projection.id, flags.effort);
+        }
+    }
+    else {
+        await tellProjection(projection.directory, projection.id, flags.effort);
+    }
     if (flags.timeoutMs === undefined)
         return buildSilentTellResponse();
     return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projection.directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), ctx.address, { projectionId: projection.id, projectionAlias: projection.alias });

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

@@ -1,12 +1,12 @@
 export const meta = {
     command: "tell",
     summary: "Send intent to a projection mailbox",
-    usage: ["keiyaku tell PROJECTION [--wait DURATION] [--] <BODY|->"],
+    usage: ["keiyaku tell PROJECTION [--interrupt] [--wait DURATION] [--] <BODY|->"],
     stdin: {
         mode: "argument",
         selector: { kind: "positional", index: 1, required: true, rejectBlank: true },
     },
-    flags: ["cwd", "repo", "contract", "effort", "wait"],
-    purpose: "Write intent to the mailbox and wake only when eligible.",
+    flags: ["cwd", "repo", "contract", "effort", "interrupt", "wait"],
+    purpose: "Write intent to the mailbox; --interrupt terminates the active turn before successor wake.",
     completionRank: 3,
 };

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

@@ -2,6 +2,7 @@ import { meta as taskMeta } from "./task/meta.js";
 import { meta as addMeta } from "./add/meta.js";
 import { meta as showMeta } from "./show/meta.js";
 import { meta as lsMeta } from "./ls/meta.js";
+import { meta as logMeta } from "./log/meta.js";
 import { meta as startMeta } from "./start/meta.js";
 import { meta as stopMeta } from "./stop/meta.js";
 import { meta as doneMeta } from "./done/meta.js";
@@ -13,6 +14,7 @@ export const taskCatalog = [
     { meta: addMeta, load: () => import("./add/handler.js") },
     { meta: showMeta, load: () => import("./show/handler.js") },
     { meta: lsMeta, load: () => import("./ls/handler.js") },
+    { meta: logMeta, load: () => import("./log/handler.js") },
     { meta: startMeta, load: () => import("./start/handler.js") },
     { meta: stopMeta, load: () => import("./stop/handler.js") },
     { meta: doneMeta, load: () => import("./done/handler.js") },

package/build/cli/commands/task/log/handler.js

@@ -0,0 +1,12 @@
+import { FlowError } from "../../../../flow-error.js";
+import { readTaskBoard, readTaskHistory, resolveTaskReadId, } from "../../../../core/task/index.js";
+import { textResponse } from "../../../render/shared.js";
+import { withTaskCommandRepository } from "../shared.js";
+export const handler = async (_stdin, flags, _signal, positional) => withTaskCommandRepository(flags, async (repository, cwd) => {
+    const board = await readTaskBoard(repository);
+    const task = board.byId.get(resolveTaskReadId(board, positional[0]));
+    if (!task)
+        throw new FlowError("INTERNAL_STATE", "resolved task disappeared from the board");
+    const rows = await readTaskHistory(cwd, task.id);
+    return textResponse(rows.map(({ timestamp, actor, subject }) => `${timestamp}\t${actor}\t${subject}`).join("\n"));
+});

package/build/cli/commands/task/log/meta.js

@@ -0,0 +1,8 @@
+export const meta = {
+    command: "task log",
+    summary: "Show one task's Git history",
+    usage: ["keiyaku task log [-C|--cwd DIR] ID"],
+    stdin: { mode: "argument" },
+    flags: ["cwd"],
+    purpose: "Read the current hub branch's task micro-commit history.",
+};

package/build/cli/completion.js

@@ -2,6 +2,7 @@ import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { loadAkumaCatalog } from "../config/akuma-loader.js";
 import { listContractIds } from "../core/ledger.js";
+import { TASK_FILTER_COMPLETION } from "../core/task/query.js";
 import { allCommandMetadata, getCommandMetadata } from "./commands/metadata.js";
 function topLevelCommands() {
     return allCommandMetadata()
@@ -46,6 +47,9 @@ export async function renderCompletionCandidates(input) {
     if (input.previous === "task") {
         return filterPrefix(subcommandsFor("task"), word).join("\n");
     }
+    if (input.previous === "--filter") {
+        return filterPrefix([TASK_FILTER_COMPLETION], word).join("\n");
+    }
     return filterPrefix(topLevelCommands(), word).join("\n");
 }
 export function renderCompletionScript(shell = "bash") {
@@ -54,7 +58,7 @@ export function renderCompletionScript(shell = "bash") {
             "#compdef keiyaku",
             "_keiyaku() {",
             "  local -a candidates",
-            "  candidates=(${(f)\"$(keiyaku completion --complete --word \"${words[CURRENT]}\" --previous \"${words[CURRENT-1]}\" 2>/dev/null)\"})",
+            "  candidates=(${(f)\"$(keiyaku completion --complete --word=\"${words[CURRENT]}\" --previous=\"${words[CURRENT-1]}\" 2>/dev/null)\"})",
             "  compadd -- $candidates",
             "}",
             "_keiyaku \"$@\"",
@@ -65,7 +69,10 @@ export function renderCompletionScript(shell = "bash") {
         "  local cur prev",
         "  cur=\"${COMP_WORDS[COMP_CWORD]}\"",
         "  prev=\"${COMP_WORDS[COMP_CWORD-1]}\"",
-        "  COMPREPLY=( $(compgen -W \"$(keiyaku completion --complete --word \"$cur\" --previous \"$prev\" 2>/dev/null)\" -- \"$cur\") )",
+        "  COMPREPLY=()",
+        "  while IFS= read -r candidate; do",
+        "    COMPREPLY+=(\"$candidate\")",
+        "  done < <(keiyaku completion --complete --word=\"$cur\" --previous=\"$prev\" 2>/dev/null)",
         "}",
         "complete -F _keiyaku_completion keiyaku",
     ].join("\n");

package/build/cli/flags.js

@@ -1,4 +1,5 @@
 import { ACTOR_IDENTITY } from "../keiyaku.js";
+import { TASK_FILTER_GRAMMAR } from "../core/task/query.js";
 export const HELP_FLAGS = new Set(["--help", "-h"]);
 export const FLAG_SPECS = {
     cwd: {
@@ -67,6 +68,10 @@ export const FLAG_SPECS = {
         kind: "boolean",
         description: "Return after durable launch instead of waiting for completion.",
     },
+    interrupt: {
+        kind: "boolean",
+        description: "Interrupt the current projection turn after saving the tell.",
+    },
     "draft-only": {
         kind: "boolean",
         description: "Write a draft artifact without creating a contract workspace.",
@@ -123,6 +128,10 @@ export const FLAG_SPECS = {
         placeholder: "PATTERN",
         description: "Append one ordered scope pattern to the contract before audit. May be repeated.",
     },
+    renew: {
+        kind: "boolean",
+        description: "Renew onto the current target before petitioning.",
+    },
     resolve: {
         kind: "boolean",
         description: "Open a durable Keiyaku-owned renew recovery session when the rewrite conflicts.",
@@ -178,8 +187,8 @@ export const FLAG_SPECS = {
     },
     filter: {
         kind: "value",
-        placeholder: "FIELD OP VALUE",
-        description: "Filter structured task facts. Repeat for AND; comma-separated values are OR.",
+        placeholder: TASK_FILTER_GRAMMAR,
+        description: "Filter structured task facts. Repeat --filter for AND; comma values or | terms are OR.",
     },
     sort: {
         kind: "value",