@code-yeongyu/senpi 2026.11.10 → 2026.11.11

package/dist/modes/rpc/host-observe-request.js

@@ -12,6 +12,8 @@
  * and the connection attaches, so a client cannot hold a session while its host idles out under it.
  * `warm` never attaches, marked or not: it opens nothing, so a host that only received it idles out
  * on its normal deadline (senpi#2314).
+ * `park_session` likewise holds no client attachment: its speculative runtime is discarded at host exit.
+ * `claim_session` takes an ordinary opener attachment and is never observing.
  * Hosts that predate the field ignore it (commands are parsed by `type`), so a marked read works
  * against every generation.
  *
@@ -59,7 +61,10 @@ export function isObservingRequest(line) {
     if (typeof request !== "object" || request === null || Array.isArray(request))
         return false;
     const record = request;
-    if (record.type === "warm" || record.type === "authenticate" || record.type === RPC_LAUNCH_PROOF_RECORD)
+    if (record.type === "warm" ||
+        record.type === "park_session" ||
+        record.type === "authenticate" ||
+        record.type === RPC_LAUNCH_PROOF_RECORD)
         return true;
     return record[OBSERVE_REQUEST_FIELD] === true && OBSERVING_COMMANDS.has(record.type);
 }

package/dist/modes/rpc/host-park-ledger.d.ts

@@ -0,0 +1,19 @@
+import type { OpenRpcSession } from "./session-registry.ts";
+/** Owns both in-flight builds and ready parks, including the races with claim, expiry and shutdown. */
+export declare class HostParkLedger {
+    private readonly parks;
+    private readonly replacements;
+    private stopped;
+    private readonly close;
+    constructor(close: (opened: OpenRpcSession) => Promise<void>);
+    get size(): number;
+    park(key: string, build: () => Promise<OpenRpcSession>): Promise<"parked" | "already_parked" | "full">;
+    /** A claim never waits for a build, and consumes the ready park synchronously. */
+    take(key: string): OpenRpcSession | undefined;
+    finish(key: string): void;
+    replace(key: string, build: () => Promise<OpenRpcSession>): void;
+    /** Fences new builds synchronously; every build already accepted is closed when it finishes. */
+    stop(): Promise<void>;
+    private retire;
+}
+//# sourceMappingURL=host-park-ledger.d.ts.map

package/dist/modes/rpc/host-park-ledger.js

@@ -0,0 +1,110 @@
+/** Speculation is bounded independently of the unlimited in-process session registry. */
+const MAX_PARKS = 4;
+const PARK_TTL_MS = 60_000;
+/** Owns both in-flight builds and ready parks, including the races with claim, expiry and shutdown. */
+export class HostParkLedger {
+    constructor(close) {
+        this.parks = new Map();
+        this.replacements = new Map();
+        this.stopped = false;
+        this.close = close;
+    }
+    get size() {
+        return this.parks.size;
+    }
+    async park(key, build) {
+        const existing = this.parks.get(key);
+        if (existing && !existing.claim && !existing.closing) {
+            await existing.ready;
+            return "already_parked";
+        }
+        // A park being claimed or closed is on its way out; the replacement scheduled after it builds the next.
+        if (existing)
+            return "full";
+        const replacement = this.replacements.get(key);
+        if (replacement !== undefined) {
+            clearTimeout(replacement);
+            this.replacements.delete(key);
+        }
+        if (this.stopped)
+            throw new Error("host_draining");
+        if (this.parks.size + this.replacements.size >= MAX_PARKS)
+            return "full";
+        const ready = Promise.withResolvers();
+        ready.promise.catch(() => { });
+        const park = { ready: ready.promise };
+        // Reserved before build's first await: a second request joins, never starts another runtime.
+        this.parks.set(key, park);
+        try {
+            park.opened = await build();
+            if (!this.stopped) {
+                park.expiry = setTimeout(() => void this.retire(key, park), PARK_TTL_MS);
+                park.expiry.unref?.();
+            }
+            ready.resolve();
+            if (this.stopped)
+                await this.retire(key, park);
+            return "parked";
+        }
+        catch (cause) {
+            this.parks.delete(key);
+            ready.reject(cause);
+            throw cause;
+        }
+    }
+    /** A claim never waits for a build, and consumes the ready park synchronously. */
+    take(key) {
+        const park = this.parks.get(key);
+        if (this.stopped || !park?.opened || park.claim || park.closing)
+            return undefined;
+        clearTimeout(park.expiry);
+        park.claim = Promise.withResolvers();
+        return park.opened;
+    }
+    finish(key) {
+        const park = this.parks.get(key);
+        this.parks.delete(key);
+        park?.claim?.resolve();
+    }
+    replace(key, build) {
+        if (this.stopped || this.replacements.has(key))
+            return;
+        const timer = setTimeout(() => {
+            this.replacements.delete(key);
+            void this.park(key, build).catch((cause) => {
+                process.stderr.write(`senpi rpc replacement park failed: ${String(cause)}\n`);
+            });
+        }, 0);
+        timer.unref?.();
+        this.replacements.set(key, timer);
+    }
+    /** Fences new builds synchronously; every build already accepted is closed when it finishes. */
+    async stop() {
+        this.stopped = true;
+        for (const timer of this.replacements.values())
+            clearTimeout(timer);
+        this.replacements.clear();
+        await Promise.all([...this.parks].map(async ([key, park]) => {
+            await park.ready.catch(() => { });
+            if (park.claim)
+                await park.claim.promise;
+            else
+                await this.retire(key, park);
+        }));
+    }
+    retire(key, park) {
+        clearTimeout(park.expiry);
+        park.closing ??= (async () => {
+            try {
+                if (park.opened)
+                    await this.close(park.opened);
+            }
+            finally {
+                if (this.parks.get(key) === park)
+                    this.parks.delete(key);
+            }
+        })();
+        return park.closing;
+    }
+}
+//# sourceMappingURL=host-park-ledger.js.map

package/dist/modes/rpc/lifecycle-delivery.js

@@ -15,7 +15,10 @@ export function observeLifecycleDelivery(record) {
         return record;
     if (record.command === "get_state")
         return { ...record, data: observeState(data) };
-    if (record.command === "open_session" && "state" in data && typeof data.state === "object" && data.state !== null)
+    if ((record.command === "open_session" || record.command === "claim_session") &&
+        "state" in data &&
+        typeof data.state === "object" &&
+        data.state !== null)
         return { ...record, data: { ...data, state: observeState(data.state) } };
     return record;
 }

package/dist/modes/rpc/loopless-tool-handlers.d.ts

@@ -25,6 +25,12 @@ export type LooplessLoopHooks = (event: string, payload: JsonValue) => Promise<J
  * (`errors`).
  */
 export declare function extensionLoopHooks(runner: ExtensionRunner, twoSidedHome: TwoSidedHome, cwd: string, call: LoopHookCall): LooplessLoopHooks;
+/**
+ * The user's loop hooks, which a hand runs for a hosted loop: its non-builtin extensions (C7(c), K5) and the hooks
+ * builtin, which runs the user's shell hooks (C8). Every other builtin is the loop's own machinery (model, compaction,
+ * todo, search): each side loads its own builtins, so those run where the loop runs, as S29 never forwards builtins.
+ */
+export declare const isUserLoopHook: (extensionPath: string) => boolean;
 /** A message a loop hook sent during its call, for the loop to send with the same options. */
 export interface SentLoopMessage {
     readonly message: Parameters<LoopHookCallFacts["sendMessage"]>[0];

package/dist/modes/rpc/loopless-tool-handlers.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { forwardToolEvents } from "../../core/extensions/two-sided-forwarding.js";
+import { hookModelOf, hookRequestOutputOf, parseHookRequestInput } from "../../core/hand/hook-contract.js";
 /**
  * A loopless runtime's own extensions' `tool_call`/`tool_result` handlers, emitted as a session emits them. On a hand
  * (a call that carries its nested requests), a two-sided extension's handlers are forwarded to the loop that owns the
@@ -78,6 +79,18 @@ export function extensionLoopHooks(runner, twoSidedHome, cwd, call) {
                 ...(preview === undefined ? {} : { preview }),
             })));
         }
+        if (event === "before_provider_request") {
+            // The hosted loop's request hooks (CK21): the user's hooks get the projected input (payload and effective model,
+            // no headers), and the reply's `output` carries the payload they produced.
+            const input = parseHookRequestInput(payload.input);
+            const model = hookModelOf(input);
+            return call.run(sessionId, cwd, idle, (effects) => dispatchLoopHook(runner, call, effects, async () => ({
+                output: hookRequestOutputOf(input, await runner.emitBeforeProviderRequest(structuredClone(input.payload), undefined, undefined, {
+                    only: isUserLoopHook,
+                    ...(model === undefined ? {} : { model }),
+                })),
+            })));
+        }
         throw new Error(`no loop hooks run on a hand for ${event}`);
     };
 }
@@ -86,7 +99,7 @@ export function extensionLoopHooks(runner, twoSidedHome, cwd, call) {
  * builtin, which runs the user's shell hooks (C8). Every other builtin is the loop's own machinery (model, compaction,
  * todo, search): each side loads its own builtins, so those run where the loop runs, as S29 never forwards builtins.
  */
-const isUserLoopHook = (extensionPath) => !extensionPath.startsWith("<builtin:") || extensionPath === "<builtin:hooks>";
+export const isUserLoopHook = (extensionPath) => !extensionPath.startsWith("<builtin:") || extensionPath === "<builtin:hooks>";
 const INPUT_SOURCES = ["interactive", "rpc", "extension"];
 const INPUT_ATTRIBUTIONS = ["user", "agent"];
 const STREAMING_BEHAVIORS = ["steer", "followUp"];

package/dist/modes/rpc/media-placeholders.js

@@ -39,6 +39,7 @@ const MEDIA_BEARING_RESPONSE_COMMANDS = new Set([
     "get_tree",
     "get_state",
     "open_session",
+    "claim_session",
 ]);
 /**
  * Decoded byte length of a base64 string, derived from its length alone.

package/dist/modes/rpc/method-classes-schema-host.d.ts

@@ -15,6 +15,38 @@ export declare const HOST_RECORD_SCHEMAS: {
         id: Type.TOptional<Type.TString>;
         admissionId: Type.TOptional<Type.TString>;
         type: Type.TLiteral<"open_session">;
+    } & {
+        retry: Type.TOptional<Type.TLiteral<true>>;
+        attended: Type.TOptional<Type.TLiteral<false>>;
+        spawnedBy: Type.TOptional<Type.TObject<{
+            parentSessionId: Type.TString;
+            rootSessionId: Type.TString;
+            taskId: Type.TString;
+        }>>;
+        expectedHostInstance: Type.TOptional<Type.TString>;
+        sessionPath: Type.TOptional<Type.TString>;
+        cwd: Type.TOptional<Type.TString>;
+        provider: Type.TOptional<Type.TString>;
+        modelId: Type.TOptional<Type.TString>;
+        thinkingLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        permissionPreset: Type.TOptional<Type.TString>;
+        retain_on_disconnect: Type.TOptional<Type.TBoolean>;
+        kind: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        context: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+        auto_title: Type.TOptional<Type.TBoolean>;
+        durableSessionId: Type.TOptional<Type.TString>;
+        promptSurface: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        browserEngine: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        retryFallback: Type.TOptional<Type.TObject<{
+            modelFallback: Type.TBoolean;
+            fallbackChains: Type.TRecord<"^.*$", Type.TImmutable<Type.TArray<Type.TString>>>;
+        }>>;
+        env: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+    }>;
+    claim_session: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        admissionId: Type.TOptional<Type.TString>;
+        type: Type.TLiteral<"claim_session">;
     } & {
         readonly retry: Type.TOptional<Type.TLiteral<true>>;
         readonly attended: Type.TOptional<Type.TLiteral<false>>;
@@ -25,7 +57,6 @@ export declare const HOST_RECORD_SCHEMAS: {
         }>>;
         readonly expectedHostInstance: Type.TOptional<Type.TString>;
         readonly sessionPath: Type.TOptional<Type.TString>;
-        readonly cwd: Type.TOptional<Type.TString>;
         readonly provider: Type.TOptional<Type.TString>;
         readonly modelId: Type.TOptional<Type.TString>;
         readonly thinkingLevel: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
@@ -42,6 +73,16 @@ export declare const HOST_RECORD_SCHEMAS: {
             fallbackChains: Type.TRecord<"^.*$", Type.TImmutable<Type.TArray<Type.TString>>>;
         }>>;
         readonly env: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
+        readonly cwd: Type.TString;
+    }>;
+    park_session: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        admissionId: Type.TOptional<Type.TString>;
+        type: Type.TLiteral<"park_session">;
+    } & {
+        readonly cwd: Type.TString;
+        readonly kind: Type.TOptional<Type.TUnion<[Type.TLiteral<string>, ...Type.TLiteral<string>[]]>>;
+        readonly context: Type.TOptional<Type.TRecord<"^.*$", Type.TString>>;
     }>;
     close_session: Type.TObject<{
         id: Type.TOptional<Type.TString>;

package/dist/modes/rpc/method-classes-schema-host.js

@@ -9,32 +9,35 @@ const uiResponseFrame = {
     uiRequestId: OptId,
     answerId: OptId,
 };
+const openProperties = {
+    retry: Opt(Type.Literal(true)),
+    attended: Opt(Type.Literal(false)),
+    spawnedBy: Opt(Type.Object({ parentSessionId: Id, rootSessionId: Id, taskId: Id })),
+    expectedHostInstance: OptId,
+    sessionPath: OptPath,
+    cwd: OptPath,
+    provider: OptId,
+    modelId: OptId,
+    thinkingLevel: Opt(ThinkingLevel),
+    permissionPreset: OptId,
+    retain_on_disconnect: OptBool,
+    kind: Opt(SessionKind),
+    context: Opt(SessionContext),
+    auto_title: OptBool,
+    durableSessionId: OptId,
+    promptSurface: Opt(literals("terminal", "app", "chat")),
+    browserEngine: Opt(literals("connected", "builtin", "none")),
+    retryFallback: Opt(RetryFallback),
+    env: Opt(SessionEnv),
+};
 export const HOST_RECORD_SCHEMAS = {
     get_protocol_info: command("get_protocol_info", {
         auth: Opt(Type.Object({ client_nonce: Id })),
         observe: OptBool,
     }),
-    open_session: command("open_session", {
-        retry: Opt(Type.Literal(true)),
-        attended: Opt(Type.Literal(false)),
-        spawnedBy: Opt(Type.Object({ parentSessionId: Id, rootSessionId: Id, taskId: Id })),
-        expectedHostInstance: OptId,
-        sessionPath: OptPath,
-        cwd: OptPath,
-        provider: OptId,
-        modelId: OptId,
-        thinkingLevel: Opt(ThinkingLevel),
-        permissionPreset: OptId,
-        retain_on_disconnect: OptBool,
-        kind: Opt(SessionKind),
-        context: Opt(SessionContext),
-        auto_title: OptBool,
-        durableSessionId: OptId,
-        promptSurface: Opt(literals("terminal", "app", "chat")),
-        browserEngine: Opt(literals("connected", "builtin", "none")),
-        retryFallback: Opt(RetryFallback),
-        env: Opt(SessionEnv),
-    }),
+    open_session: command("open_session", openProperties),
+    claim_session: command("claim_session", { ...openProperties, cwd: PathStr }),
+    park_session: command("park_session", { cwd: PathStr, kind: Opt(SessionKind), context: Opt(SessionContext) }),
     close_session: command("close_session", { sessionId: Id }),
     move_session: Type.Union([
         move({ op: Type.Literal("prepare"), moveId: Id }),

package/dist/modes/rpc/method-classes-schema-session.d.ts

@@ -850,6 +850,26 @@ export declare const SESSION_RECORD_SCHEMAS: {
         readonly key: Type.TString;
         readonly value: Type.TUnknown;
     }>;
+    read_project_file: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        admissionId: Type.TOptional<Type.TString>;
+        type: Type.TLiteral<"read_project_file">;
+    } & {
+        readonly sessionId: Type.TOptional<Type.TString>;
+    } & {
+        readonly path: Type.TString;
+    }>;
+    write_project_file: Type.TObject<{
+        id: Type.TOptional<Type.TString>;
+        admissionId: Type.TOptional<Type.TString>;
+        type: Type.TLiteral<"write_project_file">;
+    } & {
+        readonly sessionId: Type.TOptional<Type.TString>;
+    } & {
+        readonly path: Type.TString;
+        readonly content: Type.TString;
+        readonly ifEtag: Type.TUnion<[Type.TString, Type.TNull]>;
+    }>;
     extension_request: Type.TObject<{
         id: Type.TOptional<Type.TString>;
         admissionId: Type.TOptional<Type.TString>;

package/dist/modes/rpc/method-classes-schema-session.js

@@ -197,6 +197,12 @@ const SURFACE_AND_ACCOUNT_SCHEMAS = {
     set_project_trust: session("set_project_trust", { choice: literals("trust", "trust_parent", "do_not_trust") }),
     get_project_settings: session("get_project_settings", {}),
     set_project_setting: session("set_project_setting", { key: Id, value: Type.Unknown() }),
+    read_project_file: session("read_project_file", { path: PathStr }),
+    write_project_file: session("write_project_file", {
+        path: PathStr,
+        content: Str,
+        ifEtag: Type.Union([Id, Type.Null()]),
+    }),
     extension_request: session("extension_request", { name: Id, data: Opt(Type.Unknown()) }),
     "eval_cells.list": session("eval_cells.list", {}),
     "eval_cells.peek": session("eval_cells.peek", { cellId: Id, tailBytes: OptNum }),

package/dist/modes/rpc/method-classes-schema.d.ts

@@ -70,6 +70,38 @@ export declare const RPC_INBOUND_SCHEMAS: {
         id: import("typebox").TOptional<import("typebox").TString>;
         admissionId: import("typebox").TOptional<import("typebox").TString>;
         type: import("typebox").TLiteral<"open_session">;
+    } & {
+        retry: import("typebox").TOptional<import("typebox").TLiteral<true>>;
+        attended: import("typebox").TOptional<import("typebox").TLiteral<false>>;
+        spawnedBy: import("typebox").TOptional<import("typebox").TObject<{
+            parentSessionId: import("typebox").TString;
+            rootSessionId: import("typebox").TString;
+            taskId: import("typebox").TString;
+        }>>;
+        expectedHostInstance: import("typebox").TOptional<import("typebox").TString>;
+        sessionPath: import("typebox").TOptional<import("typebox").TString>;
+        cwd: import("typebox").TOptional<import("typebox").TString>;
+        provider: import("typebox").TOptional<import("typebox").TString>;
+        modelId: import("typebox").TOptional<import("typebox").TString>;
+        thinkingLevel: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        permissionPreset: import("typebox").TOptional<import("typebox").TString>;
+        retain_on_disconnect: import("typebox").TOptional<import("typebox").TBoolean>;
+        kind: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        context: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
+        auto_title: import("typebox").TOptional<import("typebox").TBoolean>;
+        durableSessionId: import("typebox").TOptional<import("typebox").TString>;
+        promptSurface: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        browserEngine: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        retryFallback: import("typebox").TOptional<import("typebox").TObject<{
+            modelFallback: import("typebox").TBoolean;
+            fallbackChains: import("typebox").TRecord<"^.*$", import("typebox").TImmutable<import("typebox").TArray<import("typebox").TString>>>;
+        }>>;
+        env: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
+    }>;
+    readonly claim_session: import("typebox").TObject<{
+        id: import("typebox").TOptional<import("typebox").TString>;
+        admissionId: import("typebox").TOptional<import("typebox").TString>;
+        type: import("typebox").TLiteral<"claim_session">;
     } & {
         readonly retry: import("typebox").TOptional<import("typebox").TLiteral<true>>;
         readonly attended: import("typebox").TOptional<import("typebox").TLiteral<false>>;
@@ -80,7 +112,6 @@ export declare const RPC_INBOUND_SCHEMAS: {
         }>>;
         readonly expectedHostInstance: import("typebox").TOptional<import("typebox").TString>;
         readonly sessionPath: import("typebox").TOptional<import("typebox").TString>;
-        readonly cwd: import("typebox").TOptional<import("typebox").TString>;
         readonly provider: import("typebox").TOptional<import("typebox").TString>;
         readonly modelId: import("typebox").TOptional<import("typebox").TString>;
         readonly thinkingLevel: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
@@ -97,6 +128,16 @@ export declare const RPC_INBOUND_SCHEMAS: {
             fallbackChains: import("typebox").TRecord<"^.*$", import("typebox").TImmutable<import("typebox").TArray<import("typebox").TString>>>;
         }>>;
         readonly env: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
+        readonly cwd: import("typebox").TString;
+    }>;
+    readonly park_session: import("typebox").TObject<{
+        id: import("typebox").TOptional<import("typebox").TString>;
+        admissionId: import("typebox").TOptional<import("typebox").TString>;
+        type: import("typebox").TLiteral<"park_session">;
+    } & {
+        readonly cwd: import("typebox").TString;
+        readonly kind: import("typebox").TOptional<import("typebox").TUnion<[import("typebox").TLiteral<string>, ...import("typebox").TLiteral<string>[]]>>;
+        readonly context: import("typebox").TOptional<import("typebox").TRecord<"^.*$", import("typebox").TString>>;
     }>;
     readonly close_session: import("typebox").TObject<{
         id: import("typebox").TOptional<import("typebox").TString>;
@@ -1224,6 +1265,26 @@ export declare const RPC_INBOUND_SCHEMAS: {
         readonly key: import("typebox").TString;
         readonly value: import("typebox").TUnknown;
     }>;
+    readonly read_project_file: import("typebox").TObject<{
+        id: import("typebox").TOptional<import("typebox").TString>;
+        admissionId: import("typebox").TOptional<import("typebox").TString>;
+        type: import("typebox").TLiteral<"read_project_file">;
+    } & {
+        readonly sessionId: import("typebox").TOptional<import("typebox").TString>;
+    } & {
+        readonly path: import("typebox").TString;
+    }>;
+    readonly write_project_file: import("typebox").TObject<{
+        id: import("typebox").TOptional<import("typebox").TString>;
+        admissionId: import("typebox").TOptional<import("typebox").TString>;
+        type: import("typebox").TLiteral<"write_project_file">;
+    } & {
+        readonly sessionId: import("typebox").TOptional<import("typebox").TString>;
+    } & {
+        readonly path: import("typebox").TString;
+        readonly content: import("typebox").TString;
+        readonly ifEtag: import("typebox").TUnion<[import("typebox").TString, import("typebox").TNull]>;
+    }>;
     readonly extension_request: import("typebox").TObject<{
         id: import("typebox").TOptional<import("typebox").TString>;
         admissionId: import("typebox").TOptional<import("typebox").TString>;

package/dist/modes/rpc/method-classes-schema.js

@@ -37,12 +37,15 @@ function fieldBoundsError(record) {
     const payload = rpcCommandPayloadError(record) ?? rpcMessageLengthError(record);
     if (payload !== undefined)
         return payload;
-    if (record.type === "open_session" || record.type === "warm") {
+    if (record.type === "open_session" ||
+        record.type === "warm" ||
+        record.type === "park_session" ||
+        record.type === "claim_session") {
         const context = sessionContextError(record.context);
         if (context !== undefined)
             return context;
     }
-    if (record.type === "open_session")
+    if (record.type === "open_session" || record.type === "claim_session")
         return sessionRetryFallbackError(record.retryFallback) ?? sessionEnvShapeError(record.env);
     if (record.type === "set_retry_fallback")
         return sessionRetryFallbackError(record.retryFallback);

package/dist/modes/rpc/method-classes.d.ts

@@ -163,6 +163,8 @@ export declare const RPC_METHOD_CLASS: {
         readonly classify: typeof openSessionClass;
         readonly version: 2;
     };
+    readonly claim_session: "device_admin";
+    readonly park_session: "device_admin";
     readonly resume_session: "thread";
     readonly fork: "thread";
     readonly clone: "thread";
@@ -202,6 +204,8 @@ export declare const RPC_METHOD_CLASS: {
     readonly set_project_trust: "device_admin";
     readonly get_project_settings: "device_admin";
     readonly set_project_setting: "device_admin";
+    readonly read_project_file: "device_admin";
+    readonly write_project_file: "device_admin";
     readonly edit_assistant_message: "device_admin";
     readonly send_custom_message: "device_admin";
     readonly switch_session: "device_admin";

package/dist/modes/rpc/method-classes.js

@@ -207,6 +207,9 @@ export const RPC_METHOD_CLASS = {
     // thread by id; device_admin when the record names a host path, a permission preset or a tool environment
     new_session: { classify: newSessionClass, version: 1 },
     open_session: { classify: openSessionClass, version: 2 },
+    // Both commands require a cwd; claim has the same device authority as a cwd-naming open.
+    claim_session: "device_admin",
+    park_session: "device_admin",
     resume_session: "thread",
     fork: "thread",
     clone: "thread",
@@ -254,6 +257,9 @@ export const RPC_METHOD_CLASS = {
     // reads a file from the session's cwd; writes one into it
     get_project_settings: "device_admin",
     set_project_setting: "device_admin",
+    // reads or replaces an instruction file in the session's cwd (AGENTS.md, CLAUDE.md, .omo/rules/**)
+    read_project_file: "device_admin",
+    write_project_file: "device_admin",
     // switch_session opens (and appends to) the named session file; import_jsonl reads any host file into a session
     // both write what the model reads as engine work: an assistant reply it never gave, a custom context message
     // (append_session_entry classes the same entries appended directly as device_admin)

package/dist/modes/rpc/multi-session-host.js

@@ -177,7 +177,7 @@ export function createHostCore(options, writer, capabilities = parseClientCapabi
             return;
         }
         const command = parsed;
-        const response = await gate.dispatch(command.type === "open_session" &&
+        const response = await gate.dispatch((command.type === "open_session" || command.type === "claim_session") &&
             (delegated
                 ? command.retain_on_disconnect !== true
                 : machineOwned && command.retain_on_disconnect === undefined)

package/dist/modes/rpc/project-file-commands.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `read_project_file` / `write_project_file`: read and edit the session workspace's instruction files over RPC, so a
+ * client with no filesystem access to the machine (a remote desktop) edits Rules the way a local one does.
+ *
+ * Reading runs nothing, so trust does not gate it; writing is refused while the project is untrusted, like
+ * `set_project_setting`. Every write names the version it replaces (`ifEtag`, `null` to create), is refused as a
+ * conflict carrying the current etag when the file moved on, and lands by temp file + rename so a reader never sees a
+ * half-written file. Writes to one file are serialized inside the engine.
+ */
+import type { AgentSession } from "../../core/agent-session.ts";
+export interface RpcProjectFile {
+    cwd: string;
+    /** The canonical workspace-relative path. */
+    path: string;
+    exists: boolean;
+    content: string | null;
+    /** Opaque version of the stored bytes; compare it, never parse it. */
+    etag: string | null;
+    projectTrusted: boolean;
+}
+export type ProjectFileResult = {
+    ok: true;
+    data: RpcProjectFile;
+} | {
+    ok: false;
+    message: string;
+    errorCode: string;
+    errorData?: Record<string, unknown>;
+};
+export declare function readProjectFile(session: AgentSession, path: unknown): Promise<ProjectFileResult>;
+export declare function writeProjectFile(session: AgentSession, path: unknown, content: unknown, ifEtag: unknown): Promise<ProjectFileResult>;
+//# sourceMappingURL=project-file-commands.d.ts.map