@astrosheep/keiyaku 4.6.19 → 4.6.20

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

@@ -15,6 +15,14 @@ declare const callRowSchema: z.ZodObject<{
     at: z.ZodString;
     text: z.ZodString;
 }, z.core.$strict>;
+declare const reportRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"report">;
+    sequence: z.ZodNumber;
+    bodySequence: z.ZodNumber;
+    turnSequence: z.ZodNumber;
+    text: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strict>;
 declare const textRowSchema: (kind: "said" | "thought" | "note") => z.ZodObject<{
     kind: z.ZodLiteral<"note" | "thought" | "said">;
     sequence: z.ZodNumber;
@@ -70,6 +78,9 @@ declare const outcomeRowSchema: z.ZodObject<{
         kind: z.ZodLiteral<"failed">;
         historyId: z.ZodString;
         diagnostic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"canceled">;
+        historyId: z.ZodString;
     }, z.core.$strict>]>;
 }, z.core.$strict>;
 declare const activeToolRowSchema: z.ZodObject<{
@@ -238,6 +249,13 @@ declare const unsettledToolRowSchema: z.ZodObject<{
     truncated: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"report">;
+    sequence: z.ZodNumber;
+    bodySequence: z.ZodNumber;
+    turnSequence: z.ZodNumber;
+    text: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"call">;
     sequence: z.ZodNumber;
     turnSequence: z.ZodNumber;
@@ -409,6 +427,13 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
     truncated: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>]>;
 declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"report">;
+    sequence: z.ZodNumber;
+    bodySequence: z.ZodNumber;
+    turnSequence: z.ZodNumber;
+    text: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"call">;
     sequence: z.ZodNumber;
     turnSequence: z.ZodNumber;
@@ -601,6 +626,13 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"row">;
         row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"report">;
+            sequence: z.ZodNumber;
+            bodySequence: z.ZodNumber;
+            turnSequence: z.ZodNumber;
+            text: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"call">;
             sequence: z.ZodNumber;
             turnSequence: z.ZodNumber;
@@ -806,6 +838,9 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"failed">;
             historyId: z.ZodString;
             diagnostic: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"canceled">;
+            historyId: z.ZodString;
         }, z.core.$strict>]>;
     }, z.core.$strict>>;
     entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -814,6 +849,13 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"row">;
         row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"report">;
+            sequence: z.ZodNumber;
+            bodySequence: z.ZodNumber;
+            turnSequence: z.ZodNumber;
+            text: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"call">;
             sequence: z.ZodNumber;
             turnSequence: z.ZodNumber;
@@ -941,7 +983,8 @@ type CallRow = z.infer<typeof callRowSchema>;
 type SaidRow = z.infer<ReturnType<typeof textRowSchema>>;
 type ThoughtRow = z.infer<ReturnType<typeof textRowSchema>>;
 type NoteRow = z.infer<ReturnType<typeof textRowSchema>>;
-type TurnNarrationRow = CallRow | SaidRow | ThoughtRow | NoteRow;
+export type ReportRow = z.infer<typeof reportRowSchema>;
+type TurnNarrationRow = CallRow | SaidRow | ThoughtRow | NoteRow | ReportRow;
 export type { TellRow } from "./heart/facts.js";
 export type OutcomeRow = z.infer<typeof outcomeRowSchema>;
 export type ActiveToolRow = z.infer<typeof activeToolRowSchema>;

package/build/src/akuma/projection.js

@@ -1,5 +1,5 @@
 import { toolCallSchema, toolResultSchema, toolInputSchema, fileChangeSchema, diffstatSchema, } from "./heart/activity-schema.js";
-import { projectTell } from "./heart/facts.js";
+import { projectTell, reportFactSchema } from "./heart/facts.js";
 import { z } from "zod";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
 const countSchema = z.number().int().nonnegative();
@@ -47,6 +47,7 @@ const callRowSchema = z
     text: z.string(),
 })
     .strict();
+const reportRowSchema = reportFactSchema;
 const textRowSchema = (kind) => z
     .object({
     kind: z.literal(kind),
@@ -78,6 +79,7 @@ const outcomeSchema = z.union([
     })
         .strict(),
     z.object({ kind: z.literal("failed"), historyId: nonblankTextSchema, diagnostic: z.string() }).strict(),
+    z.object({ kind: z.literal("canceled"), historyId: nonblankTextSchema }).strict(),
 ]);
 const outcomeRowSchema = z
     .object({
@@ -129,6 +131,7 @@ const unsettledToolRowSchema = z
 })
     .strict();
 const snapshotFactRowSchema = z.union([
+    reportRowSchema,
     callRowSchema,
     textRowSchema("said"),
     textRowSchema("thought"),
@@ -200,6 +203,8 @@ function publicOutcome(turnSequence, outcome) {
     const historyId = `turn/${turnSequence}`;
     if (outcome.kind === "answered")
         return { kind: "answered", historyId, answer: outcome.answer };
+    if (outcome.kind === "canceled")
+        return { kind: "canceled", historyId };
     return { kind: "failed", historyId, diagnostic: outcome.diagnostic };
 }
 export function selectExactHistory(rows, id) {
@@ -409,6 +414,13 @@ export function projectTurns(facts, retained = {
             else
                 turn.rows.push(row);
         }
+        else if (fact.kind === "report") {
+            const turn = state.turnsBySequence.get(fact.turnSequence);
+            if (turn === undefined)
+                state.orphanRows.push(fact);
+            else
+                turn.rows.push(fact);
+        }
         else if (fact.kind === "tell") {
             state.tells.push(projectTell(fact));
         }

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

@@ -1,4 +1,5 @@
 import { type ResumeCoordinate } from "./coordinate.js";
+import type { ExecutionCoordinate } from "./providers/execution-environment.js";
 import type { ProviderOptions } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
 export { AKUMA_REQUESTS_ENV, AKUMA_REQUESTS_ENTRY_ENV } from "./providers/execution-environment.js";
@@ -130,7 +131,10 @@ export type DriveInput = Readonly<{
     }>[];
     cwd: string;
     options: ProviderOptions;
+    /** Fresh execution context, never part of the persisted personality recipe. */
+    runtimeInstructions?: string;
     signal: AbortSignal;
+    execution?: ExecutionCoordinate;
     requests: Readonly<{
         dir: string;
         entry?: string;

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

@@ -169,7 +169,7 @@ export async function startAcpSession(launch, input, dependencies = {}, custody)
     const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
         argv: launch.argv,
         cwd: input.cwd,
-        env: akumaExecutionEnvironment(globalThis.process.env, launch.env, input.requests?.dir),
+        env: akumaExecutionEnvironment(globalThis.process.env, launch.env, input.requests?.dir, [], input.execution),
     });
     let abortOwned = async () => await child.close(true);
     let forceDisposeOwned = async () => await child.close(true);

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

@@ -47,6 +47,9 @@ export function createAcpProvider(execution, dependencies = {}) {
         throw new TypeError("ACP provider execution requires executable");
     const config = decodeAcpConfig(execution.config);
     const drive = async (input, custody) => {
+        if (input.runtimeInstructions !== undefined) {
+            throw new Error("ACP has no verified native runtime-instruction channel; call with bare to omit the Keiyaku section");
+        }
         const launch = {
             argv: argv(execution, config, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),

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

@@ -54,24 +54,27 @@ function claudeSessionId(coordinate) {
     return coordinate.sessionId;
 }
 function claudeQueryOptions(input, execution, abortController) {
+    const instructions = [input.options.systemPrompt, input.runtimeInstructions]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join("\n\n");
     return {
         ...(execution.config ?? {}),
         cwd: input.cwd,
         abortController,
         ...(input.requests === undefined ? {} : { additionalDirectories: [input.requests.dir] }),
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
-        env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir),
+        env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir, [], input.execution),
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
         settingSources: ["user", "project", "local"],
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
-        ...(input.options.systemPrompt === undefined || input.options.systemPrompt.length === 0
+        ...(instructions.length === 0
             ? {}
             : {
-                systemPrompt: input.options.systemPromptMode === "replace"
-                    ? input.options.systemPrompt
-                    : { type: "preset", preset: "claude_code", append: input.options.systemPrompt },
+                systemPrompt: input.options.systemPromptMode === "replace" && (input.options.systemPrompt?.length ?? 0) > 0
+                    ? instructions
+                    : { type: "preset", preset: "claude_code", append: instructions },
             }),
         ...(input.session.kind === "fresh" ? {} : { resume: claudeSessionId(input.session.coordinate) }),
         ...(input.schemaJson === undefined

package/build/src/akuma/providers/codex-app-server/configuration.d.ts

@@ -0,0 +1,5 @@
+import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
+import { type ProviderExecution } from "../../provider-recipe.js";
+export declare function initializeCodex(server: LineRpcProcess): Promise<void>;
+/** Native config precedence belongs to Codex, including profiles and dotted overrides. */
+export declare function withCodexWritableDirectories(execution: ProviderExecution, cwd: string, directories: readonly string[], signal?: AbortSignal): Promise<ProviderExecution>;

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

@@ -0,0 +1,72 @@
+import { LineRpcProcess } from "../../../runtime/proc/line-rpc.js";
+import { createProviderAttempt } from "../../provider.js";
+import { decodeProviderRecipe } from "../../provider-recipe.js";
+import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { codexObject } from "./events.js";
+export async function initializeCodex(server) {
+    await server.request("initialize", {
+        clientInfo: { name: "keiyaku", title: "keiyaku", version: "4" },
+        capabilities: { experimentalApi: true, requestAttestation: false },
+    });
+    server.notify("initialized");
+}
+/** Native config precedence belongs to Codex, including profiles and dotted overrides. */
+export async function withCodexWritableDirectories(execution, cwd, directories, signal) {
+    const attempt = createProviderAttempt(signal, async (custody) => {
+        custody.signal.throwIfAborted();
+        const server = new LineRpcProcess({
+            argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
+            cwd,
+            env: akumaExecutionEnvironment(process.env, execution.env),
+        });
+        const closed = new Promise((resolve) => server.onExit(() => resolve()));
+        custody.own({ closed, forceDispose: () => server.close(true) });
+        try {
+            custody.signal.throwIfAborted();
+            await initializeCodex(server);
+            const response = codexObject(await server.request("thread/start", {
+                cwd,
+                ephemeral: true,
+                ...(execution.config === undefined ? {} : { config: execution.config }),
+            }));
+            custody.signal.throwIfAborted();
+            const sandbox = codexObject(response?.sandbox);
+            if (sandbox?.type !== "workspaceWrite" || response?.activePermissionProfile != null)
+                throw new TypeError("writableDirectories requires Codex native workspace-write sandbox configuration");
+            const roots = sandbox.writableRoots;
+            if (!Array.isArray(roots) ||
+                !roots.every((root) => typeof root === "string") ||
+                typeof sandbox.networkAccess !== "boolean" ||
+                typeof sandbox.excludeTmpdirEnvVar !== "boolean" ||
+                typeof sandbox.excludeSlashTmp !== "boolean")
+                throw new TypeError("Codex did not return its effective workspace-write configuration");
+            const config = { ...execution.config };
+            // Remove conflicting spellings of only the fields this native snapshot owns.
+            for (const key of ["writable_roots", "network_access", "exclude_tmpdir_env_var", "exclude_slash_tmp"])
+                delete config[`sandbox_workspace_write.${key}`];
+            return decodeProviderRecipe({
+                ...execution,
+                config: {
+                    ...config,
+                    sandbox_mode: "workspace-write",
+                    sandbox_workspace_write: {
+                        ...codexObject(config.sandbox_workspace_write),
+                        writable_roots: [...new Set([...roots, ...directories])],
+                        network_access: sandbox.networkAccess,
+                        exclude_tmpdir_env_var: sandbox.excludeTmpdirEnvVar,
+                        exclude_slash_tmp: sandbox.excludeSlashTmp,
+                    },
+                },
+            });
+        }
+        finally {
+            await server.endInputAndDrain();
+        }
+    });
+    try {
+        return await attempt.result;
+    }
+    finally {
+        await attempt.closed;
+    }
+}

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

@@ -3,17 +3,11 @@ import { AgentEventChannel, createProviderAttempt, launchPrompt, modelEvent, } f
 import { akumaExecutionEnvironment } from "../execution-environment.js";
 import { providerLifecycle } from "../lifecycle.js";
 import { codexNotificationResult, codexObject, codexText } from "./events.js";
+import { initializeCodex } from "./configuration.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-async function initialize(server) {
-    await server.request("initialize", {
-        clientInfo: { name: "keiyaku", title: "keiyaku", version: "4" },
-        capabilities: { experimentalApi: false, requestAttestation: false },
-    });
-    server.notify("initialized");
-}
 function threadId(result, fallback) {
     const value = codexObject(result);
     const thread = codexObject(value?.thread) ?? value;
@@ -56,7 +50,7 @@ async function steerTurn(server, state, tell) {
     return { kind: "accepted", fence: `${accepted}:${tell.id}` };
 }
 async function admitTurn(server, input, state, events, config) {
-    await initialize(server);
+    await initializeCodex(server);
     const threadParams = {
         cwd: input.cwd,
         ...(config === undefined ? {} : { config }),
@@ -90,6 +84,9 @@ async function admitTurn(server, input, state, events, config) {
         ...(input.options.model === undefined ? {} : { model: input.options.model }),
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         approvalPolicy: "never",
+        ...(input.runtimeInstructions === undefined
+            ? {}
+            : { additionalContext: { keiyaku_execution: { kind: "application", value: input.runtimeInstructions } } }),
         ...(input.schemaJson === undefined ? {} : { outputSchema: JSON.parse(input.schemaJson) }),
     }));
 }
@@ -108,7 +105,7 @@ async function forkCodex(execution, input, custody) {
         forceDispose: async () => await server.close(true),
     });
     try {
-        await initialize(server);
+        await initializeCodex(server);
         const child = threadId(await server.request("thread/fork", {
             threadId: input.session.sessionId,
             lastTurnId: input.at,
@@ -130,7 +127,7 @@ function codexServer(execution, input) {
     return new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
         cwd: input.cwd,
-        env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir),
+        env: akumaExecutionEnvironment(process.env, execution.env, input.requests?.dir, [], input.execution),
     });
 }
 async function startCodex(execution, input, custody) {

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

@@ -1,7 +1,13 @@
 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_INITIATOR", "KEIYAKU_EXTERNAL_CALLER"];
+export type ExecutionCoordinate = Readonly<{
+    akumaId: string;
+    world: string;
+    bodySequence: number;
+    turnSequence: number;
+}>;
+declare const PARENT_HARNESS_IDENTITY_KEYS: readonly ["KEIYAKU_BODY_SEQUENCE", "KEIYAKU_TURN_SEQUENCE", "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>;
+export declare function akumaExecutionEnvironment(inherited: Environment, overrides?: Environment, requests?: string, nativeIdentity?: readonly (typeof PARENT_HARNESS_IDENTITY_KEYS)[number][], execution?: ExecutionCoordinate): Record<string, string>;
 export {};

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

@@ -1,6 +1,8 @@
 export const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export const AKUMA_REQUESTS_ENTRY_ENV = "AKUMA_REQUESTS_ENTRY";
 const PARENT_HARNESS_IDENTITY_KEYS = [
+    "KEIYAKU_BODY_SEQUENCE",
+    "KEIYAKU_TURN_SEQUENCE",
     "CLAUDE_CODE_SESSION_ID",
     "CLAUDE_CODE_CHILD_SESSION",
     "CLAUDECODE",
@@ -14,7 +16,7 @@ const PARENT_HARNESS_IDENTITY_KEYS = [
     "KEIYAKU_EXTERNAL_CALLER",
 ];
 /** Construct the environment for one isolated Akuma execution or native child. */
-export function akumaExecutionEnvironment(inherited, overrides = {}, requests, nativeIdentity = []) {
+export function akumaExecutionEnvironment(inherited, overrides = {}, requests, nativeIdentity = [], execution) {
     const preserved = Object.fromEntries(nativeIdentity.flatMap((key) => (inherited[key] === undefined ? [] : [[key, inherited[key]]])));
     const environment = Object.fromEntries(Object.entries({ ...inherited, ...overrides }).flatMap(([key, value]) => value === undefined ? [] : [[key, value]]));
     for (const key of PARENT_HARNESS_IDENTITY_KEYS)
@@ -24,5 +26,12 @@ export function akumaExecutionEnvironment(inherited, overrides = {}, requests, n
     delete environment[AKUMA_REQUESTS_ENTRY_ENV];
     if (requests !== undefined)
         environment[AKUMA_REQUESTS_ENV] = requests;
+    if (execution !== undefined)
+        Object.assign(environment, {
+            KEIYAKU_ACTOR_ID: execution.akumaId,
+            KEIYAKU_ACTOR_WORLD: execution.world,
+            KEIYAKU_BODY_SEQUENCE: String(execution.bodySequence),
+            KEIYAKU_TURN_SEQUENCE: String(execution.turnSequence),
+        });
     return environment;
 }

package/build/src/akuma/providers/grok-build/index.js

@@ -65,24 +65,31 @@ function optionAdmission(options) {
         options,
     };
 }
-function grokSessionMeta(config, options) {
-    // Keiyaku does not implement Grok's reverse ask_user_question request, so
-    // keep that unsupported tool out of every session's advertised toolset.
+function grokSessionMeta(config, input) {
+    // Grok appends rules only when creating a session; ordinary load preserves
+    // that immutable execution context without requiring a hot-update channel.
+    const options = input.options;
     const sessionMeta = { ...(config ?? {}), askUserQuestion: false };
-    const configured = { freshSessionMeta: sessionMeta, loadSessionMeta: sessionMeta };
-    if (options.systemPrompt === undefined || options.systemPrompt.length === 0)
-        return configured;
-    if (options.systemPromptMode === "append")
-        return { ...configured, freshSessionMeta: { ...sessionMeta, rules: options.systemPrompt } };
-    if (options.systemPromptMode === "replace") {
-        const meta = { systemPromptOverride: options.systemPrompt };
-        return {
-            ...configured,
-            freshSessionMeta: { ...sessionMeta, ...meta },
-            loadSessionMeta: { ...sessionMeta, ...meta },
+    const replacement = options.systemPromptMode === "replace" && options.systemPrompt?.trim()
+        ? options.systemPrompt
+        : typeof config?.systemPromptOverride === "string" && config.systemPromptOverride.trim()
+            ? config.systemPromptOverride
+            : undefined;
+    if (replacement !== undefined) {
+        const meta = {
+            ...sessionMeta,
+            systemPromptOverride: [replacement, input.runtimeInstructions].filter((part) => part !== undefined).join("\n\n"),
         };
+        return { freshSessionMeta: meta, loadSessionMeta: meta };
     }
-    return configured;
+    const rules = options.systemPromptMode === "append" ? options.systemPrompt : config?.rules;
+    const appended = [typeof rules === "string" ? rules : undefined, input.runtimeInstructions]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join("\n\n");
+    return {
+        freshSessionMeta: { ...sessionMeta, ...(appended === "" ? {} : { rules: appended }) },
+        loadSessionMeta: sessionMeta,
+    };
 }
 function argv(execution, options) {
     if (execution.executable === undefined)
@@ -127,7 +134,7 @@ export function createGrokBuildProvider(execution, dependencies = {}) {
             argv: argv(execution, input.options),
             ...(execution.env === undefined ? {} : { env: execution.env }),
         };
-        const sessionMeta = grokSessionMeta(execution.config, input.options);
+        const sessionMeta = grokSessionMeta(execution.config, input);
         live = await startAcpSession(launch, input, {
             ...dependencies,
             configureClient: (client) => {

package/build/src/akuma/providers/index.d.ts

@@ -1,6 +1,7 @@
 import type { ProviderAdapter } from "../provider.js";
 import type { ProviderExecution } from "../provider-recipe.js";
 export { decodeProviderRecipe as decodeProviderExecution } from "../provider-recipe.js";
+export declare function withWritableDirectories(execution: ProviderExecution, cwd: string, directories: readonly string[], signal?: AbortSignal): Promise<ProviderExecution>;
 export declare function resolveProviderExecution(execution: ProviderExecution): Promise<Readonly<{
     execution: ProviderExecution;
     adapter: ProviderAdapter;

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

@@ -20,6 +20,14 @@ async function adapterFor(execution) {
         return (await import("./pi/index.js")).createPiProvider(execution);
     throw new TypeError(`unknown Akuma provider kind ${execution.kind}`);
 }
+export async function withWritableDirectories(execution, cwd, directories, signal) {
+    if (directories.length === 0)
+        return execution;
+    if (execution.kind !== "codex-app-server")
+        throw new TypeError(`writableDirectories is unsupported by provider ${execution.kind}`);
+    const { withCodexWritableDirectories } = await import("./codex-app-server/configuration.js");
+    return await withCodexWritableDirectories(execution, cwd, directories, signal);
+}
 export async function resolveProviderExecution(execution) {
     return Object.freeze({ execution, adapter: await adapterFor(execution) });
 }

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -181,6 +181,14 @@ async function configureSession(runtime, input, id, info, model) {
         // and fork. Updating the same entry announces an upstream instruction change.
         await session.instructions({ id, text: input.options.systemPrompt });
     }
+    if (input.runtimeInstructions === undefined) {
+        // Native forks copy current entries. Absence must remove the inherited
+        // runtime entry, not leave the source identity active in a bare child.
+        await session.removeInstruction({ id, key: "keiyaku.runtime" });
+    }
+    else {
+        await session.instructions({ id, key: "keiyaku.runtime", text: input.runtimeInstructions });
+    }
 }
 async function openSession(runtime, input) {
     const model = input.options.model === undefined
@@ -217,6 +225,7 @@ async function openResources(execution, input, loader, custody) {
         onRuntime: (ready) => {
             runtimeOwner = ownRuntime(custody, ready);
         },
+        ...(input.execution === undefined ? {} : { executionCoordinate: input.execution }),
         ...(input.requests === undefined ? {} : { requests: input.requests.dir }),
     });
     const stream = ownEventStream({

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -15,6 +15,11 @@ export type OpencodeSdkSession = Readonly<{
     instructions(input: {
         id: string;
         text: string;
+        key?: string;
+    }): Promise<unknown>;
+    removeInstruction(input: {
+        id: string;
+        key: string;
     }): Promise<unknown>;
     active(): Promise<unknown>;
     fork(input: {
@@ -75,6 +80,7 @@ type LoadOpencodeInput = Readonly<{
     signal: AbortSignal;
     loader?: OpencodeSdkLoader;
     onRuntime?: (runtime: OpencodeRuntime) => void;
+    executionCoordinate?: import("../execution-environment.js").ExecutionCoordinate;
     requests?: string;
 }>;
 export declare function loadOpencode(input: LoadOpencodeInput): Promise<OpencodeRuntime>;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -80,7 +80,7 @@ async function loadInjectedOpencode(input, loader) {
     const { execution, cwd, signal, onRuntime, requests } = input;
     const loaded = await abortable(loader(cwd, {
         ...execution,
-        env: akumaExecutionEnvironment(process.env, execution.env, requests),
+        env: akumaExecutionEnvironment(process.env, execution.env, requests, [], input.executionCoordinate),
     }, signal), signal);
     let closing;
     const runtime = {
@@ -117,7 +117,7 @@ async function loadNativeOpencode(input) {
             ...execution.env,
             OPENCODE_PASSWORD: password,
             OPENCODE_SERVER_PASSWORD: password,
-        }, requests),
+        }, requests, [], input.executionCoordinate),
         log: `${cwd}/.opencode.log`,
     });
     const native = createNativeClient(`http://127.0.0.1:${port}`, password);
@@ -129,7 +129,8 @@ async function loadNativeOpencode(input) {
                 create: async ({ body }) => ({ data: await native.sdk.session.create(body, options) }),
                 get: async ({ id }) => ({ data: await native.sdk.session.get({ sessionID: id }, options) }),
                 switchModel: ({ id, model }) => native.sdk.session.switchModel({ sessionID: id, model }, options),
-                instructions: ({ id, text }) => native.sdk.session.instructions.entry.put({ sessionID: id, key: "keiyaku.system", value: text }, options),
+                instructions: ({ id, text, key = "keiyaku.system" }) => native.sdk.session.instructions.entry.put({ sessionID: id, key, value: text }, options),
+                removeInstruction: ({ id, key }) => native.sdk.session.instructions.entry.remove({ sessionID: id, key }, options),
                 active: async () => ({ data: await native.sdk.session.active(options) }),
                 fork: async ({ id, before }) => ({ data: await native.sdk.session.fork({ sessionID: id, before }, options) }),
                 interrupt: ({ id }) => native.sdk.session.interrupt({ sessionID: id, resume: false }),

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

@@ -207,6 +207,9 @@ class PaseoDrive {
         });
     }
     async establish(input, config, coordinate) {
+        const systemPrompt = [input.options.systemPrompt, input.runtimeInstructions]
+            .filter((part) => part !== undefined && part.length > 0)
+            .join("\n\n");
         const entry = input.requests.entry;
         if (entry === undefined || !isAbsolute(entry) || resolve(entry) !== entry)
             throw new Error("Paseo requires the Body's stable request entry");
@@ -216,8 +219,11 @@ class PaseoDrive {
             ? await setup(input.signal, () => this.client.createAgent({
                 provider: config.provider,
                 cwd: input.cwd,
-                ...(input.options.systemPrompt === undefined ? {} : { systemPrompt: input.options.systemPrompt }),
-                env: { ...akumaExecutionEnvironment(process.env, this.environment), [AKUMA_REQUESTS_ENTRY_ENV]: entry },
+                ...(systemPrompt === "" ? {} : { systemPrompt }),
+                env: {
+                    ...akumaExecutionEnvironment(process.env, this.environment, undefined, [], input.execution),
+                    [AKUMA_REQUESTS_ENTRY_ENV]: entry,
+                },
                 autoArchive: false,
             }))
             : await this.existingAgent(coordinate, input.signal);