@astrosheep/keiyaku 4.6.10 → 4.6.12

package/build/src/akuma/heart/rows.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { DatabaseSync } from "node:sqlite";
-import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
+import type { BodyEnd, BodyFact, CallFact, InterruptCompletion, KillFact, PauseFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
 import { type AgentEvent } from "./activity-schema.js";
 export type SealRow = Readonly<{
     evidence: string;
@@ -136,9 +136,16 @@ export declare function insertActivityFact(database: DatabaseSync, input: Readon
     at: string;
 }>): number;
 export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;
-export declare function insertPauseControl(database: DatabaseSync, at: string): void;
+export declare function insertInterruptBarrier(database: DatabaseSync, input: Readonly<{
+    bodySequence: number;
+    tellId: string;
+    at: string;
+}>): PauseFact;
+export declare function completeInterruptBarrier(database: DatabaseSync, expected?: PauseFact, consume?: boolean): InterruptCompletion;
 export declare function stopFact(database: DatabaseSync): StopFact | null;
 export declare function pauseFact(database: DatabaseSync): PauseFact | null;
+export declare function bodyFact(database: DatabaseSync, sequence: number): BodyFact | null;
+export declare function isTellProtectedByPause(database: DatabaseSync, tellId: string, bodySequence: number): boolean;
 export declare function insertKillFact(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function endBodyFact(database: DatabaseSync, input: Readonly<{
     sequence: number;

package/build/src/akuma/heart/rows.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { providerOptionsSchema, withoutModel } from "../provider-recipe.js";
 import { resumeCoordinateSchema } from "../coordinate.js";
+import { HeartAuthorityCorruptionError } from "./facts.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate as encodeCoordinate } from "../coordinate.js";
 import { agentEventSchema } from "./activity-schema.js";
 const sessionText = z.string().refine((value) => value.trim() !== "");
@@ -160,13 +161,40 @@ export function insertStopControl(database, bodySequence, at) {
         .prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', ?, ?)")
         .run(json({ bodySequence }), at);
 }
-export function insertPauseControl(database, at) {
-    const body = latestBodyFact(database);
-    if (body === null)
-        throw new Error("Akuma has no Body to interrupt");
-    database
-        .prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', ?, ?)")
-        .run(json({ bodySequence: body.sequence }), at);
+export function insertInterruptBarrier(database, input) {
+    const value = json({ bodySequence: input.bodySequence, frontierTellId: input.tellId });
+    database.prepare("INSERT INTO control(kind, value_json, at) VALUES ('pause', ?, ?)").run(value, input.at);
+    return { bodySequence: input.bodySequence, requestedAt: input.at, frontierTellId: input.tellId };
+}
+export function completeInterruptBarrier(database, expected, consume = true) {
+    const barrier = pauseFact(database);
+    if (expected !== undefined && barrier !== null && !samePause(barrier, expected))
+        return settledPreviousBarrier(database, expected);
+    if (barrier === null) {
+        if (expected === undefined)
+            return { kind: "clear" };
+        return settledPreviousBarrier(database, expected);
+    }
+    const latest = latestBodyFact(database);
+    if (latest?.sequence !== barrier.bodySequence)
+        return { kind: "unavailable", evidence: "untidy" };
+    if (latest.hung !== undefined)
+        return { kind: "unavailable", evidence: "hung" };
+    if (latest.end === undefined || !consume)
+        return { kind: "unavailable", evidence: "untidy" };
+    deletePauseControl(database);
+    return { kind: "completed", body: latest };
+}
+function settledPreviousBarrier(database, expected) {
+    const previous = bodyFact(database, expected.bodySequence);
+    if (previous?.hung !== undefined)
+        return { kind: "unavailable", evidence: "hung" };
+    if (previous?.end !== undefined)
+        return { kind: "completed", body: previous };
+    return { kind: "unavailable", evidence: "untidy" };
+}
+function samePause(left, right) {
+    return left.bodySequence === right.bodySequence && left.frontierTellId === right.frontierTellId;
 }
 export function stopFact(database) {
     const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'stop'").get();
@@ -178,15 +206,48 @@ export function stopFact(database) {
     }
     return { bodySequence: value.bodySequence, requestedAt: row.at };
 }
+const pauseControlSchema = z
+    .object({ bodySequence: z.number().int().positive(), frontierTellId: sessionText.optional() })
+    .strict();
 export function pauseFact(database) {
     const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'pause'").get();
     if (row === undefined)
         return null;
-    const value = parsed(row.value_json);
-    if (!Number.isSafeInteger(value.bodySequence) || value.bodySequence <= 0) {
-        throw new Error("Akuma pause control has an invalid Body sequence");
+    let value;
+    try {
+        value = pauseControlSchema.parse(parsed(row.value_json));
     }
-    return { bodySequence: value.bodySequence, requestedAt: row.at };
+    catch (error) {
+        throw new HeartAuthorityCorruptionError("Akuma pause control is malformed", { cause: error });
+    }
+    if (value.frontierTellId !== undefined) {
+        const tell = database.prepare("SELECT 1 FROM tells WHERE id = ?").get(value.frontierTellId);
+        if (tell === undefined)
+            throw new HeartAuthorityCorruptionError("Akuma pause control references a missing Tell frontier");
+    }
+    return {
+        bodySequence: value.bodySequence,
+        requestedAt: row.at,
+        ...(value.frontierTellId === undefined ? {} : { frontierTellId: value.frontierTellId }),
+    };
+}
+export function bodyFact(database, sequence) {
+    const row = database
+        .prepare(`SELECT sequence, leash_taken_at, hung_diagnostic, hung_at, end, ended_at FROM bodies WHERE sequence = ?`)
+        .get(sequence);
+    return row === undefined ? null : decodeBodyRow(row);
+}
+export function isTellProtectedByPause(database, tellId, bodySequence) {
+    const pause = pauseFact(database);
+    if (pause?.bodySequence !== bodySequence)
+        return false;
+    if (pause.frontierTellId === undefined)
+        return true;
+    const tell = database.prepare("SELECT sequence FROM tells WHERE id = ?").get(tellId);
+    const frontier = database.prepare("SELECT sequence FROM tells WHERE id = ?").get(pause.frontierTellId);
+    if (tell === undefined || frontier === undefined)
+        throw new HeartAuthorityCorruptionError("Akuma pause control references a missing Tell frontier");
+    return tell.sequence >= frontier.sequence;
 }
 export function insertKillFact(database, bodySequence, at) {
     database

package/build/src/akuma/heart/storage.d.ts

@@ -1,6 +1,6 @@
 import { DatabaseSync } from "node:sqlite";
 import type { AkumaPaths } from "../identity.js";
-import type { BodyFact, LeashProbe, SessionFact, Soul, StopFact, TellFact } from "./facts.js";
+import type { BodyFact, InterruptCompletion, LeashProbe, PauseFact, SessionFact, Soul, StopFact, TellFact } from "./facts.js";
 import { sealFact } from "./rows.js";
 export declare class HeartAbsentError extends Error {
     readonly path: string;
@@ -43,8 +43,8 @@ export declare class HeldAkumaLeash {
         at: string;
     }>): Promise<"born" | "sealed">;
     readSeal(): ReturnType<typeof sealFact>;
-    clearPause(paths: AkumaPaths): Promise<void>;
     clearStop(paths: AkumaPaths): Promise<void>;
+    completeInterruptBarrier(paths: AkumaPaths, expected?: PauseFact): Promise<InterruptCompletion>;
     recordBody(paths: AkumaPaths, input: Readonly<{
         leashTakenAt: string;
     }>): Promise<BodyFact>;
@@ -57,12 +57,6 @@ export declare class HeldAkumaLeash {
         target: StopFact;
         result: "recorded" | "already-killed";
     }> | null>;
-    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): Promise<Readonly<{
-        kind: "not-born";
-    } | {
-        kind: "recorded";
-        tell: TellFact;
-    }>>;
     release(): void;
 }
 export declare function probeLeash(paths: AkumaPaths): Promise<LeashProbe>;

package/build/src/akuma/heart/storage.js

@@ -2,8 +2,9 @@ import { DatabaseSync } from "node:sqlite";
 import { lstat } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { setTimeout } from "node:timers/promises";
+import { BodyControlledError } from "./facts.js";
 import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, heartSchemaIsCurrent, } from "./schema.js";
-import { deletePauseControl, deleteStopControl, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
+import { deleteStopControl, completeInterruptBarrier as judgeInterruptBarrier, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
 import { insertTellFact } from "./tells.js";
 import { pruneActivityFacts } from "./timeline.js";
 import { insertSoulFact, soulFact } from "./soul.js";
@@ -269,16 +270,23 @@ export class HeldAkumaLeash {
     readSeal() {
         return sealFact(this.database);
     }
-    async clearPause(paths) {
-        await withHeartTransaction(paths, deletePauseControl);
-    }
     async clearStop(paths) {
         await withHeartTransaction(paths, deleteStopControl);
     }
+    async completeInterruptBarrier(paths, expected) {
+        if (this.closed)
+            throw new Error("Akuma interrupt completion requires a held leash");
+        return await withHeartTransaction(paths, (heart) => judgeInterruptBarrier(heart, expected));
+    }
     async recordBody(paths, input) {
         if (this.closed || this.bodySequence !== undefined)
             throw new Error("Akuma leash cannot start another Body");
-        const sequence = await withHeartTransaction(paths, (heart) => insertBodyFact(heart, input));
+        const sequence = await withHeartTransaction(paths, (heart) => {
+            const completion = judgeInterruptBarrier(heart);
+            if (completion.kind === "unavailable")
+                throw new BodyControlledError();
+            return insertBodyFact(heart, input);
+        });
         this.bodySequence = sequence;
         return { sequence, leashTakenAt: input.leashTakenAt };
     }
@@ -314,14 +322,6 @@ export class HeldAkumaLeash {
             return { target, result };
         });
     }
-    async recordInterruptTell(paths, tell) {
-        return await withHeartTransaction(paths, (heart) => {
-            deletePauseControl(heart);
-            if (soulFact(heart) === null)
-                return { kind: "not-born" };
-            return recordPendingTell(heart, tell);
-        });
-    }
     release() {
         if (this.closed)
             return;

package/build/src/akuma/heart/tells.d.ts

@@ -1,3 +1,4 @@
+import type { PauseFact } from "./facts.js";
 import type { DatabaseSync } from "node:sqlite";
 import { type TellDelivery, type TellDeliveryInput, type TellFact, type TellReceiptInput } from "./facts.js";
 type TellRow = Readonly<{
@@ -37,6 +38,7 @@ export declare function tellBatchAtSequences(database: DatabaseSync, sequences:
 export declare function hasPendingTell(database: DatabaseSync): boolean;
 export declare function insertTellFact(database: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): number;
 export declare function tellFact(database: DatabaseSync, id: string): TellFact | null;
+export declare function sameTellInput(existing: TellFact, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): boolean;
 export declare function insertTellDeliveryFact(database: DatabaseSync, input: TellDeliveryInput): boolean;
 export declare function insertTellReceiptFact(database: DatabaseSync, input: TellReceiptInput): boolean;
 export declare function tellIdsForFence(database: DatabaseSync, turnSequence: number, fence: string): readonly string[];
@@ -58,6 +60,6 @@ export declare function insertTellBindingFact(database: DatabaseSync, input: Rea
     boundAt: string;
 }>): void;
 export declare function turnParticipants(database: DatabaseSync, turnSequence: number): readonly string[];
-export declare function drainPendingTells(pending: readonly TellFact[], activeTurnSequences?: readonly number[]): readonly TellFact[];
+export declare function drainPendingTells(pending: readonly TellFact[], activeTurnSequences?: readonly number[], pause?: PauseFact | null, bodySequence?: number): readonly TellFact[];
 export declare function openBoundTurns(database: DatabaseSync, bodySequence: number): readonly number[];
 export {};

package/build/src/akuma/heart/tells.js

@@ -92,6 +92,12 @@ export function tellFact(database, id) {
         .get(id);
     return row === undefined ? null : decodeTellRows(database, [row])[0];
 }
+export function sameTellInput(existing, tell) {
+    return (existing.body === tell.body &&
+        existing.recordedAt === tell.recordedAt &&
+        existing.schemaJson === tell.schemaJson &&
+        existing.initiator === tell.initiator);
+}
 export function insertTellDeliveryFact(database, input) {
     const result = database
         .prepare(`INSERT OR IGNORE INTO tell_deliveries(
@@ -228,8 +234,18 @@ export function turnParticipants(database, turnSequence) {
     }
     return [...participants];
 }
-export function drainPendingTells(pending, activeTurnSequences = []) {
-    const eligible = pending.filter((tell) => tell.binding === undefined || !activeTurnSequences.includes(tell.binding.turnSequence));
+export function drainPendingTells(pending, activeTurnSequences = [], pause, bodySequence) {
+    let available = pending;
+    if (pause !== undefined && pause !== null && pause.bodySequence === bodySequence) {
+        if (pause.frontierTellId === undefined) {
+            available = [];
+        }
+        else {
+            const frontier = pending.find((tell) => tell.id === pause.frontierTellId);
+            available = frontier === undefined ? [] : pending.filter((tell) => tell.sequence < frontier.sequence);
+        }
+    }
+    const eligible = available.filter((tell) => tell.binding === undefined || !activeTurnSequences.includes(tell.binding.turnSequence));
     if (eligible.length === 0)
         return [];
     const first = eligible[0];

package/build/src/akuma/provider.d.ts

@@ -37,6 +37,8 @@ export declare class AgentEventChannel implements AsyncIterable<AgentEvent> {
     private overflowCount;
     private ended;
     emit(event: AgentEvent): void;
+    /** Narration and protected slots; the reserved model slot is not one of them. */
+    private narrationCount;
     end(): void;
     [Symbol.asyncIterator](): AsyncIterator<AgentEvent>;
 }
@@ -88,10 +90,6 @@ export type Session = Readonly<{
     events: AsyncIterable<AgentEvent>;
     receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
-    /** Requests graceful adapter-owned cancellation. */
-    abort(): Promise<void>;
-    /** Fulfills only after forced adapter-owned disposal is proved. */
-    forceDispose(): Promise<void>;
     tell?(tell: Readonly<{
         id: string;
         text: string;

package/build/src/akuma/provider.js

@@ -213,8 +213,11 @@ export function unknownEvent(kind) {
     return { type: "unknown", kind };
 }
 // Slow consumers may lose reconstructible narration, but session coordinates,
-// notes, and error events stay observable. A full protected queue replaces one
-// protected item with a bounded aggregate note; `end` ignores later emission.
+// notes, error events, and the latest runtime-model observation stay
+// observable. The one queue reserves a single model slot, so that observation
+// never competes for narration admission and no overflow can hide the model a
+// Turn proved it ran. A full protected queue replaces one protected item with a
+// bounded aggregate note; `end` ignores later emission.
 function isErrorEvent(event) {
     if (event.type === "note")
         return true;
@@ -222,8 +225,11 @@ function isErrorEvent(event) {
         return event.result.status === "error";
     return event.type === "unknown" && /(?:error|fail|abort|cancel|stop|terminal)/iu.test(event.kind);
 }
+function isModelEvent(event) {
+    return event.type === "model";
+}
 function isReconstructibleEvent(event) {
-    return event.type !== "session" && !isErrorEvent(event);
+    return event.type !== "session" && !isModelEvent(event) && !isErrorEvent(event);
 }
 const AGENT_EVENT_OVERFLOW_PREFIX = "Agent event queue overflow";
 function overflowEvent(count) {
@@ -243,7 +249,20 @@ export class AgentEventChannel {
             waiter.resolve({ done: false, value: event });
             return;
         }
-        if (this.queued.length >= AGENT_EVENT_QUEUE_LIMIT) {
+        if (isModelEvent(event)) {
+            // Model evidence is control state, never narration: it occupies the
+            // queue's one reserved model slot, so a narration flood and a full
+            // protected queue both leave it observable. An unconsumed predecessor is
+            // obsolete, and superseding it is what keeps the newest fact, an unnamed
+            // one clearing the confirmation it disconfirms.
+            const obsolete = this.queued.findIndex(isModelEvent);
+            if (obsolete === -1)
+                this.queued.push(event);
+            else
+                this.queued[obsolete] = event;
+            return;
+        }
+        if (this.narrationCount() >= AGENT_EVENT_QUEUE_LIMIT) {
             const reconstructible = this.queued.findIndex(isReconstructibleEvent);
             if (reconstructible === -1) {
                 if (isReconstructibleEvent(event))
@@ -259,8 +278,8 @@ export class AgentEventChannel {
                     }
                     this.overflowMarker = undefined;
                 }
-                const protectedIndex = this.queued.findIndex((queued) => queued.type !== "session");
-                const replacement = protectedIndex === -1 ? 0 : protectedIndex;
+                const protectedItem = this.queued.findIndex((queued) => queued.type !== "session" && !isModelEvent(queued));
+                const replacement = protectedItem === -1 ? this.queued.findIndex((queued) => !isModelEvent(queued)) : protectedItem;
                 this.overflowCount += 1;
                 const marker = overflowEvent(this.overflowCount);
                 this.queued[replacement] = marker;
@@ -271,6 +290,10 @@ export class AgentEventChannel {
         }
         this.queued.push(event);
     }
+    /** Narration and protected slots; the reserved model slot is not one of them. */
+    narrationCount() {
+        return this.queued.length - Number(this.queued.some(isModelEvent));
+    }
     end() {
         if (this.ended)
             return;

package/build/src/akuma/providers/acp/core.js

@@ -160,25 +160,6 @@ function beginAcpPrompt(context, child, turn, sessionId, input) {
         admission: { fence: sessionId },
         events: turn.events,
         completion: turn.completion,
-        abort: async () => {
-            let result = { kind: "failed", diagnostic: "ACP turn cancelled" };
-            try {
-                await agent.notify(acp.methods.agent.session.cancel, { sessionId });
-            }
-            catch (error) {
-                result = { kind: "failed", diagnostic: diagnostic(acp, error) };
-            }
-            if (!turn.open())
-                await child.close(true);
-            else
-                await turn.finish(result, () => child.close(true));
-        },
-        forceDispose: async () => {
-            if (!turn.open())
-                await child.close(true);
-            else
-                await turn.finish({ kind: "failed", diagnostic: "ACP turn force-disposed" }, () => child.close(true));
-        },
     };
 }
 export async function startAcpSession(launch, input, dependencies = {}, custody) {
@@ -190,10 +171,12 @@ export async function startAcpSession(launch, input, dependencies = {}, custody)
         cwd: input.cwd,
         env: akumaExecutionEnvironment(globalThis.process.env, launch.env, input.requests?.dir),
     });
+    let abortOwned = async () => await child.close(true);
+    let forceDisposeOwned = async () => await child.close(true);
     custody?.own({
         closed: child.exited.then(() => undefined),
-        abort: async () => await child.close(true),
-        forceDispose: async () => await child.close(true),
+        abort: () => abortOwned(),
+        forceDispose: () => forceDisposeOwned(),
     });
     let sessionId;
     let turn;
@@ -205,6 +188,25 @@ export async function startAcpSession(launch, input, dependencies = {}, custody)
     try {
         sessionId = await abortable(establishSession(acp, connection.agent, input, dependencies, launch.sessionOptions ?? []), signal);
         turn.events.emit({ type: "session", coordinate: { sessionId } });
+        abortOwned = async () => {
+            let result = { kind: "failed", diagnostic: "ACP turn cancelled" };
+            try {
+                await connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: sessionId });
+            }
+            catch (error) {
+                result = { kind: "failed", diagnostic: diagnostic(acp, error) };
+            }
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish(result, () => child.close(true));
+        };
+        forceDisposeOwned = async () => {
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish({ kind: "failed", diagnostic: "ACP turn force-disposed" }, () => child.close(true));
+        };
         const session = beginAcpPrompt({ acp, agent: connection.agent }, child, turn, sessionId, input);
         return { session, agent: connection.agent, sessionId, open: turn.open };
     }

package/build/src/akuma/providers/claude/index.js

@@ -343,14 +343,6 @@ async function driveClaude(load, execution, drive, custody) {
         receipts,
         completion: observed.completion,
         tell: claudeTell(input, observed, accepted, driveState, run),
-        async abort() {
-            shutDown(new Error("Claude query aborted"));
-            await observed.completion;
-        },
-        async forceDispose() {
-            shutDown(new Error("Claude query force-disposed"));
-            await observed.completion;
-        },
     };
 }
 export function createClaudeProvider(loadOrExecution = async () => (await import("@anthropic-ai/claude-agent-sdk")), execution = {}) {

package/build/src/akuma/providers/codex-app-server/index.js

@@ -140,8 +140,6 @@ async function startCodex(execution, input, custody) {
     const events = new AgentEventChannel();
     const server = codexServer(execution, input);
     const closed = new Promise((resolve) => server.onExit(() => resolve()));
-    const close = async () => await server.close(true);
-    custody.own({ closed, abort: close, forceDispose: close });
     const state = { settled: false, tools: new Map() };
     let settle;
     const completion = new Promise((resolve) => {
@@ -159,6 +157,15 @@ async function startCodex(execution, input, custody) {
         };
         void server.endInputAndDrain().then(done, done);
     };
+    custody.own({
+        closed,
+        abort: async () => await abortTurn(server, state, finish),
+        forceDispose: async () => {
+            if (!state.settled)
+                settle({ kind: "failed", diagnostic: "codex app-server force-disposed" });
+            await server.close(true);
+        },
+    });
     server.onNotification((notification) => {
         const result = codexNotificationResult(notification, state, events);
         if (result !== undefined)
@@ -202,12 +209,6 @@ async function startCodex(execution, input, custody) {
         admission: { fence: state.turnId },
         events,
         completion,
-        abort: () => abortTurn(server, state, finish),
-        forceDispose: async () => {
-            if (!state.settled)
-                settle({ kind: "failed", diagnostic: "codex app-server force-disposed" });
-            await server.close(true);
-        },
         tell: (tell) => steerTurn(server, state, tell),
     };
 }

package/build/src/akuma/providers/execution-environment.d.ts

@@ -1,6 +1,6 @@
 export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export declare const AKUMA_REQUESTS_ENTRY_ENV = "AKUMA_REQUESTS_ENTRY";
-declare const PARENT_HARNESS_IDENTITY_KEYS: readonly ["CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDECODE", "CODEX_THREAD_ID", "OPENCODE_SESSION_ID", "PI_SESSION_ID", "PI_SESSION_FILE", "PASEO_AGENT_ID", "SQUARE_PARTICIPANT_NAME", "KEIYAKU_EXTERNAL_CALLER"];
+declare const PARENT_HARNESS_IDENTITY_KEYS: readonly ["CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDECODE", "CODEX_THREAD_ID", "OPENCODE_SESSION_ID", "PI_SESSION_ID", "PI_SESSION_FILE", "PASEO_AGENT_ID", "SQUARE_PARTICIPANT_NAME", "KEIYAKU_INITIATOR", "KEIYAKU_EXTERNAL_CALLER"];
 type Environment = Readonly<Record<string, string | undefined>>;
 /** Construct the environment for one isolated Akuma execution or native child. */
 export declare function akumaExecutionEnvironment(inherited: Environment, overrides?: Environment, requests?: string, nativeIdentity?: readonly (typeof PARENT_HARNESS_IDENTITY_KEYS)[number][]): Record<string, string>;

package/build/src/akuma/providers/execution-environment.js

@@ -10,6 +10,7 @@ const PARENT_HARNESS_IDENTITY_KEYS = [
     "PI_SESSION_FILE",
     "PASEO_AGENT_ID",
     "SQUARE_PARTICIPANT_NAME",
+    "KEIYAKU_INITIATOR",
     "KEIYAKU_EXTERNAL_CALLER",
 ];
 /** Construct the environment for one isolated Akuma execution or native child. */