@rynx-ai/daemon 0.1.11-beta.2 → 0.1.11-beta.21

package/dist/pm2.js

@@ -10,14 +10,18 @@
 import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { userInfo } from "node:os";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { loadConfig, rynxHome } from "@rynx-ai/core";
 import { daemonEntryRestartRequired } from "./daemon-build-status.js";
+import { resolveDaemonEntry } from "./entry-path.js";
 const require = createRequire(import.meta.url);
 /** pm2 app name — single resident daemon per machine. */
 const APP_NAME = "rynx";
 const PM2_COMMAND_TIMEOUT_MS = 5_000;
+const LOGIN_SHELL_PATH_TIMEOUT_MS = 5_000;
+const LOGIN_SHELL_PATH_MAX_BYTES = 256 * 1024;
+const REFRESH_LOGIN_SHELL_PATH_ENV = "RYNX_REFRESH_LOGIN_SHELL_PATH";
 const DAEMON_PACKAGE_VERSION = require("../package.json").version;
 /**
  * Build a dialable control-console URL from the daemon's bind host/port. Bind-all
@@ -49,10 +53,6 @@ function pm2Bin() {
     // pm2 ships its CLI at bin/pm2; run it with our own node.
     return require.resolve("pm2/bin/pm2");
 }
-/** `index-daemon.js` sits next to this file in `dist/`. */
-function daemonEntryPath() {
-    return join(dirname(fileURLToPath(import.meta.url)), "index-daemon.js");
-}
 function logsDir() {
     const dir = join(rynxHome(), "logs");
     mkdirSync(dir, { recursive: true });
@@ -71,11 +71,58 @@ function nodeRuntimeEnv() {
             : {}),
     };
 }
+/**
+ * A detached plugin updater intentionally receives a reduced environment and
+ * therefore has no SHELL. Starting the replacement daemon with that reduced
+ * PATH would make user-installed runtimes (for example an fnm-managed Codex)
+ * disappear after every upgrade. Recover the user's login-shell PATH only at
+ * this boundary; normal interactive starts keep their exact caller environment.
+ */
+function daemonStartEnv() {
+    const env = nodeRuntimeEnv();
+    const refreshLoginPath = env[REFRESH_LOGIN_SHELL_PATH_ENV] === "1";
+    delete env[REFRESH_LOGIN_SHELL_PATH_ENV];
+    if (!refreshLoginPath)
+        return env;
+    const shell = userInfo().shell?.trim();
+    if (!shell) {
+        throw new Error("cannot refresh daemon PATH: the user login shell is unavailable");
+    }
+    const result = spawnSync(shell, ["-lic", `printf '\\036%s\\037' "$PATH"`], {
+        encoding: "utf8",
+        // Do not feed an fnm/nvm "multishell" directory inherited from the old
+        // daemon back into the next login shell. Version managers prepend a new
+        // directory on every shell startup, so reusing the old PATH would grow
+        // it indefinitely across upgrades.
+        env: { ...env, SHELL: shell, PATH: loginShellBaselinePath() },
+        timeout: LOGIN_SHELL_PATH_TIMEOUT_MS,
+        killSignal: "SIGTERM",
+        maxBuffer: LOGIN_SHELL_PATH_MAX_BYTES,
+    });
+    if (result.error) {
+        throw new Error(`cannot refresh daemon PATH: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        throw new Error(`cannot refresh daemon PATH: login shell exited ${result.status ?? "without status"}`);
+    }
+    const path = extractFramedPath(result.stdout);
+    if (!path) {
+        throw new Error("cannot refresh daemon PATH: login shell returned no framed PATH");
+    }
+    const npmPrefix = env.NPM_CONFIG_PREFIX?.trim();
+    const npmBin = npmPrefix && isAbsolute(npmPrefix)
+        ? join(npmPrefix, "bin")
+        : "";
+    const refreshedPath = npmBin === ""
+        ? path
+        : [npmBin, ...path.split(delimiter).filter((entry) => entry !== npmBin)].join(delimiter);
+    return { ...env, PATH: refreshedPath, SHELL: shell };
+}
 /** Run a pm2 command inheriting stdio; returns its exit code. */
-function runPm2(args, quiet = false) {
+function runPm2(args, quiet = false, env = nodeRuntimeEnv()) {
     const res = spawnSync(process.execPath, [pm2Bin(), ...args], {
         stdio: quiet ? "ignore" : "inherit",
-        env: nodeRuntimeEnv(),
+        env,
         timeout: PM2_COMMAND_TIMEOUT_MS,
         killSignal: "SIGTERM",
     });
@@ -117,7 +164,7 @@ function pm2ErrorMessage(error) {
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export function startDaemon({ force, quiet = false }) {
+export function startDaemon({ force, quiet = false, launchEnvironment, }) {
     let existing;
     try {
         existing = describe();
@@ -139,6 +186,20 @@ export function startDaemon({ force, quiet = false }) {
     if (staleBuild && !quiet) {
         console.log("A newer daemon build is present on disk; restarting Rynx.");
     }
+    let startEnv;
+    try {
+        // Resolve the replacement environment before deleting an existing app.
+        // A broken/hung login shell must leave the known-good daemon untouched.
+        startEnv = {
+            ...daemonStartEnv(),
+            ...launchEnvironment,
+        };
+    }
+    catch (error) {
+        if (!quiet)
+            console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
     const dir = logsDir();
     if (existing) {
         const removed = runPm2(["delete", APP_NAME], quiet);
@@ -147,7 +208,7 @@ export function startDaemon({ force, quiet = false }) {
     }
     const status = runPm2([
         "start",
-        daemonEntryPath(),
+        resolveDaemonEntry(),
         "--name",
         APP_NAME,
         // App and CLI share one daemon-owned state/workspace root.
@@ -163,7 +224,7 @@ export function startDaemon({ force, quiet = false }) {
         join(dir, "err.log"),
         "--merge-logs",
         "--time",
-    ], quiet);
+    ], quiet, startEnv);
     if (status === 0 && !quiet) {
         console.log(`rynx ${force ? "restarted" : "started"} (pm2 app "${APP_NAME}", logs: ${dir}).`);
         console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
@@ -173,16 +234,35 @@ export function startDaemon({ force, quiet = false }) {
 export function isPm2DaemonOnline() {
     return describe()?.pm2_env?.status === "online";
 }
-/** Stop and remove the daemon from pm2's process list. */
+/**
+ * Stop the daemon and terminate its dedicated pm2 supervisor.
+ *
+ * PM2_HOME lives below RYNX_HOME, so this supervisor cannot own unrelated
+ * applications. Leaving it alive across an npm replacement is unsafe: the
+ * daemon process container path is resolved inside the old pm2 package. Once
+ * npm swaps @rynx-ai/daemon, that cached path may no longer exist and every
+ * subsequent `rynx start` enters a restart loop before our code can run.
+ */
 export function stopDaemon() {
-    if (!describe()) {
+    const existing = describe();
+    if (!existing) {
+        // Even an empty process list can belong to a resident PM2 daemon whose
+        // module path is about to be replaced. `pm2 kill` is idempotent and is
+        // the only reliable package-upgrade boundary.
+        const killed = runPm2(["kill"], true);
+        if (killed !== 0)
+            return killed;
         console.log("rynx is not running.");
         return 0;
     }
-    const status = runPm2(["delete", APP_NAME]);
-    if (status === 0)
-        console.log("rynx stopped.");
-    return status;
+    const removed = runPm2(["delete", APP_NAME]);
+    if (removed !== 0)
+        return removed;
+    const killed = runPm2(["kill"]);
+    if (killed !== 0)
+        return killed;
+    console.log("rynx stopped.");
+    return 0;
 }
 /** Print a one-line status; exit 0 only when online. */
 export function statusDaemon() {
@@ -209,7 +289,7 @@ export function streamLogs() {
 }
 function residentBuildRestartRequired(app) {
     const runningEntry = app.pm2_env?.pm_exec_path;
-    if (runningEntry && !sameEntryPath(runningEntry, daemonEntryPath()))
+    if (runningEntry && !sameEntryPath(runningEntry, resolveDaemonEntry()))
         return true;
     const runningVersion = app.pm2_env?.version;
     if (runningVersion &&
@@ -220,7 +300,7 @@ function residentBuildRestartRequired(app) {
     const startedAt = app.pm2_env?.pm_uptime;
     return typeof startedAt === "number" &&
         Number.isFinite(startedAt) &&
-        daemonEntryRestartRequired(daemonEntryPath(), startedAt);
+        daemonEntryRestartRequired(resolveDaemonEntry(), startedAt);
 }
 function sameEntryPath(left, right) {
     try {
@@ -230,3 +310,20 @@ function sameEntryPath(left, right) {
         return resolve(left) === resolve(right);
     }
 }
+function extractFramedPath(stdout) {
+    if (!stdout)
+        return undefined;
+    const start = stdout.lastIndexOf("\x1e");
+    if (start < 0)
+        return undefined;
+    const end = stdout.indexOf("\x1f", start + 1);
+    if (end < 0)
+        return undefined;
+    const value = stdout.slice(start + 1, end);
+    return value.trim() ? value : undefined;
+}
+function loginShellBaselinePath() {
+    return process.platform === "darwin"
+        ? "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+        : "/usr/local/bin:/usr/bin:/bin";
+}

package/dist/process.d.ts

@@ -0,0 +1,12 @@
+interface SupervisorProcess {
+    connected?: boolean;
+    disconnect?: () => void;
+}
+/** Release a parent/supervisor IPC handle after graceful daemon shutdown. */
+export declare function disconnectSupervisorIpc(target?: SupervisorProcess): void;
+/**
+ * Run the daemon in the current process. Process ownership and executable
+ * selection belong to the caller (CLI standalone lifecycle or App lifecycle).
+ */
+export declare function runDaemonProcess(): Promise<void>;
+export {};

package/dist/process.js

@@ -0,0 +1,91 @@
+import { startRynxDaemonServer } from "./daemon-server.js";
+import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
+import { installStdioEpipeGuard } from "./stdio-epipe-guard.js";
+/** Release a parent/supervisor IPC handle after graceful daemon shutdown. */
+export function disconnectSupervisorIpc(target = process) {
+    if (target.connected && typeof target.disconnect === "function") {
+        target.disconnect();
+    }
+}
+/**
+ * Run the daemon in the current process. Process ownership and executable
+ * selection belong to the caller (CLI standalone lifecycle or App lifecycle).
+ */
+export async function runDaemonProcess() {
+    installStdioEpipeGuard();
+    const followsApp = process.env.RYNX_DAEMON_LIFECYCLE === "follow-app";
+    let parentDisconnected = followsApp && !process.connected;
+    const recordParentDisconnect = () => {
+        parentDisconnected = true;
+    };
+    if (followsApp)
+        process.once("disconnect", recordParentDisconnect);
+    const preparePlugins = async () => {
+        try {
+            const bundled = await ensureBundledOfficialPlugins({ reclaimHostLeases: true });
+            if (bundled.status === "ready") {
+                console.log(JSON.stringify({
+                    level: "info",
+                    type: "bundled_plugins_ready",
+                    installed: bundled.installed,
+                    updated: bundled.updated,
+                }));
+            }
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                level: "error",
+                type: "bundled_plugins_failed",
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    };
+    let server;
+    try {
+        server = await startRynxDaemonServer({
+            preparePlugins,
+            onShutdownComplete: () => disconnectSupervisorIpc(),
+        });
+    }
+    catch (error) {
+        process.off("disconnect", recordParentDisconnect);
+        throw error;
+    }
+    let shutdownPromise;
+    const shutdown = (signal) => {
+        if (shutdownPromise)
+            return shutdownPromise;
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+        process.off("disconnect", onDisconnect);
+        shutdownPromise = (async () => {
+            console.log(JSON.stringify({ level: "info", type: "shutdown", signal }));
+            await server.shutdown();
+        })();
+        shutdownPromise.catch((error) => {
+            process.exitCode = 1;
+            console.error(`Shutdown failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+        });
+        return shutdownPromise;
+    };
+    const onSigint = () => {
+        void shutdown("SIGINT");
+    };
+    const onSigterm = () => {
+        void shutdown("SIGTERM");
+    };
+    const onDisconnect = () => {
+        if (process.env.RYNX_DAEMON_LIFECYCLE === "follow-app") {
+            void shutdown("APP_DISCONNECT");
+        }
+    };
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    if (followsApp) {
+        process.once("disconnect", onDisconnect);
+        process.off("disconnect", recordParentDisconnect);
+        if (parentDisconnected || !process.connected) {
+            void shutdown("APP_DISCONNECT");
+        }
+    }
+}

package/dist/remote-runtime-access-store.d.ts

@@ -1,4 +1,4 @@
-import Database from "better-sqlite3";
+import { type DatabaseSync } from "node:sqlite";
 declare const DEFAULT_AUTHORITIES: readonly ["daemon.full"];
 export type RuntimeAuthority = (typeof DEFAULT_AUTHORITIES)[number];
 export type RemoteRuntimeAccessErrorCode = "invalid_claim" | "claim_expired" | "claim_used" | "grant_not_found" | "grant_revoked" | "grant_identity_mismatch" | "conflict" | "corrupt_state";
@@ -46,7 +46,7 @@ type Clock = () => Date;
 export declare class RemoteRuntimeAccessStore {
     private readonly connection;
     private readonly clock;
-    constructor(connection?: Database.Database, clock?: Clock);
+    constructor(connection?: DatabaseSync, clock?: Clock);
     createPairingClaim(input: CreatePairingClaimInput): RuntimePairingClaim;
     redeemPairingClaim(input: RedeemPairingClaimInput): RuntimeClientGrant;
     resolveActiveGrant(input: ResolveActiveGrantInput): RuntimeClientGrant;

package/dist/remote-runtime-access-store.js

@@ -1,5 +1,6 @@
 import { createHash, createPublicKey, randomBytes, timingSafeEqual, } from "node:crypto";
 import { db } from "./db.js";
+import { hasSqlitePrimaryCode, SQLITE_CONSTRAINT, transaction } from "./sqlite.js";
 const CLAIM_SECRET_HASH_DOMAIN = "rynx-runtime-pairing-claim-secret-v1\0";
 const DEFAULT_AUTHORITIES = Object.freeze(["daemon.full"]);
 const MIN_TTL_MS = 1_000;
@@ -35,7 +36,7 @@ export class RemoteRuntimeAccessStore {
         const created = this.now();
         const createdAt = created.toISOString();
         const expiresAt = new Date(created.getTime() + ttlMs).toISOString();
-        const create = this.connection.transaction(() => {
+        const create = transaction(this.connection, () => {
             this.deleteRetainedExpiredClaims(created);
             this.connection
                 .prepare(`INSERT INTO runtime_pairing_claims
@@ -60,7 +61,7 @@ export class RemoteRuntimeAccessStore {
         const clientId = validId(input.clientId, "clientId", "invalid_claim");
         const clientPublicKey = canonicalEd25519PublicKey(input.clientPublicKey, "invalid_claim");
         const requestedLabel = optionalLabel(input.label, "invalid_claim");
-        const redeem = this.connection.transaction(() => {
+        const redeem = transaction(this.connection, () => {
             const now = this.now().toISOString();
             const claim = this.connection
                 .prepare(`SELECT claim_id, secret_hash, authorities, client_label, created_at, expires_at,
@@ -124,7 +125,7 @@ export class RemoteRuntimeAccessStore {
         const grantId = validId(input.grantId, "grantId", "grant_not_found");
         const clientId = validId(input.clientId, "clientId", "grant_identity_mismatch");
         const clientPublicKey = canonicalEd25519PublicKey(input.clientPublicKey, "grant_identity_mismatch");
-        const resolve = this.connection.transaction(() => {
+        const resolve = transaction(this.connection, () => {
             const row = this.connection
                 .prepare(`SELECT grant_id, client_id, client_public_key, client_label, authorities,
                   created_at, revoked_at, last_used_at
@@ -180,7 +181,7 @@ export class RemoteRuntimeAccessStore {
     revokeClientGrant(grantIdInput) {
         const grantId = validId(grantIdInput, "grantId", "grant_not_found");
         const revokedAt = this.now().toISOString();
-        const revoke = this.connection.transaction(() => {
+        const revoke = transaction(this.connection, () => {
             const revoked = this.connection
                 .prepare(`UPDATE runtime_client_grants
            SET revoked_at = ?
@@ -382,11 +383,7 @@ function grantFromRow(row) {
     };
 }
 function isSqliteConstraint(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        typeof error.code === "string" &&
-        error.code.startsWith("SQLITE_CONSTRAINT"));
+    return hasSqlitePrimaryCode(error, SQLITE_CONSTRAINT);
 }
 function accessError(code, message, cause) {
     return new RemoteRuntimeAccessError(code, message, cause === undefined ? undefined : { cause });

package/dist/remote-runtime-target-store.d.ts

@@ -1,4 +1,4 @@
-import Database from "better-sqlite3";
+import { type DatabaseSync } from "node:sqlite";
 export interface RemoteRuntimeTarget {
     daemonId: string;
     displayName: string;
@@ -40,7 +40,7 @@ export interface CommitRemoteRuntimePendingEnrollmentOptions {
 export declare class RemoteRuntimeTargetStore {
     private readonly connection;
     private readonly clock;
-    constructor(connection?: Database.Database, clock?: () => Date);
+    constructor(connection?: DatabaseSync, clock?: () => Date);
     add(input: AddRemoteRuntimeTargetInput): RemoteRuntimeTarget;
     addPendingEnrollment(input: AddRemoteRuntimePendingEnrollmentInput): RemoteRuntimePendingEnrollment;
     getPendingEnrollment(claimIdInput: string): RemoteRuntimePendingEnrollment | undefined;

package/dist/remote-runtime-target-store.js

@@ -1,5 +1,6 @@
 import { createPublicKey } from "node:crypto";
 import { db } from "./db.js";
+import { hasSqlitePrimaryCode, SQLITE_CONSTRAINT, transaction } from "./sqlite.js";
 const OPAQUE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/;
 const CREDENTIAL_REF_PATTERN = /^credential_[A-Za-z0-9_-]{24}$/;
 const MAX_DISPLAY_NAME_CHARS = 128;
@@ -13,7 +14,7 @@ export class RemoteRuntimeTargetStore {
     add(input) {
         const normalized = normalizeTargetInput(input);
         const now = validNow(this.clock()).toISOString();
-        const insert = this.connection.transaction(() => {
+        const insert = transaction(this.connection, () => {
             this.connection.prepare(`INSERT INTO runtime_targets
            (daemon_id, display_name, identity_public_key, credential_ref, created_at, updated_at)
          VALUES (?, ?, ?, ?, ?, ?)`).run(normalized.daemonId, normalized.displayName, normalized.identityPublicKey, normalized.credentialRef, now, now);
@@ -67,7 +68,7 @@ export class RemoteRuntimeTargetStore {
     }
     removePendingEnrollment(claimIdInput) {
         const claimId = validId(claimIdInput, "claimId");
-        const remove = this.connection.transaction(() => {
+        const remove = transaction(this.connection, () => {
             const pending = this.getPendingEnrollment(claimId);
             if (!pending)
                 return undefined;
@@ -82,7 +83,7 @@ export class RemoteRuntimeTargetStore {
         const claimId = validId(claimIdInput, "claimId");
         const normalized = normalizeTargetInput(input);
         const now = validNow(this.clock()).toISOString();
-        const commit = this.connection.transaction(() => {
+        const commit = transaction(this.connection, () => {
             const pending = this.getPendingEnrollment(claimId);
             if (!pending)
                 throw new Error("pending Runtime enrollment was not found");
@@ -134,7 +135,7 @@ export class RemoteRuntimeTargetStore {
     }
     remove(daemonIdInput) {
         const daemonId = validId(daemonIdInput, "daemonId");
-        const remove = this.connection.transaction(() => {
+        const remove = transaction(this.connection, () => {
             const target = this.get(daemonId);
             if (!target)
                 return undefined;
@@ -321,6 +322,5 @@ function validNow(value) {
     return value;
 }
 function isSqliteConstraint(error) {
-    return typeof error === "object" && error !== null && "code" in error &&
-        typeof error.code === "string" && error.code.startsWith("SQLITE_CONSTRAINT");
+    return hasSqlitePrimaryCode(error, SQLITE_CONSTRAINT);
 }

package/dist/session-emulator-binding-store.js

@@ -1,5 +1,6 @@
 import { SessionEmulatorBindingConflictError, } from "@rynx-ai/server";
 import { db } from "./db.js";
+import { hasSqlitePrimaryCode, SQLITE_CONSTRAINT, transaction } from "./sqlite.js";
 export class SqliteSessionEmulatorBindingStore {
     get(sessionId) {
         const row = db().prepare(`SELECT session_id, binding_id, backend, device_id, device_name, attached_at
@@ -13,7 +14,7 @@ export class SqliteSessionEmulatorBindingStore {
     }
     bind(record) {
         const connection = db();
-        const replace = connection.transaction(() => {
+        const replace = transaction(connection, () => {
             connection.prepare("DELETE FROM session_emulator_bindings WHERE session_id = ?")
                 .run(record.sessionId);
             connection.prepare(`INSERT INTO session_emulator_bindings
@@ -40,7 +41,7 @@ export class SqliteSessionEmulatorBindingStore {
         return db().prepare("DELETE FROM session_emulator_bindings WHERE session_id = ?").run(sessionId).changes > 0;
     }
     releaseDevice(backend, deviceId) {
-        return db().prepare("DELETE FROM session_emulator_bindings WHERE backend = ? AND device_id = ?").run(backend, deviceId).changes;
+        return Number(db().prepare("DELETE FROM session_emulator_bindings WHERE backend = ? AND device_id = ?").run(backend, deviceId).changes);
     }
 }
 function bindingRecord(row) {
@@ -54,8 +55,5 @@ function bindingRecord(row) {
     };
 }
 function isSqliteConstraint(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const code = error.code;
-    return typeof code === "string" && code.startsWith("SQLITE_CONSTRAINT");
+    return hasSqlitePrimaryCode(error, SQLITE_CONSTRAINT);
 }

package/dist/session-fork-store.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { newSessionId, newSessionItemId, normalizeSessionTitle, resolvedExecutionSnapshotSchema, rynxHome, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { MachineSessionServiceFailure, } from "@rynx-ai/server";
 import { db } from "./db.js";
+import { scalar, transaction } from "./sqlite.js";
 const FORK_COLS = [
     "operation_id",
     "request_hash",
@@ -39,9 +40,8 @@ export class SqliteSessionForkStore {
         }
         const now = new Date().toISOString();
         let targetSessionId = newSessionId();
-        while (db().prepare("SELECT 1 FROM sessions WHERE id = ?").pluck().get(targetSessionId) ||
-            db().prepare("SELECT 1 FROM session_fork_operations WHERE target_session_id = ?")
-                .pluck().get(targetSessionId)) {
+        while (scalar(db().prepare("SELECT 1 FROM sessions WHERE id = ?")).get(targetSessionId) ||
+            scalar(db().prepare("SELECT 1 FROM session_fork_operations WHERE target_session_id = ?")).get(targetSessionId)) {
             targetSessionId = newSessionId();
         }
         try {
@@ -130,7 +130,7 @@ export class SqliteSessionForkStore {
             };
         });
         const conn = db();
-        conn.transaction(() => {
+        transaction(conn, () => {
             if (input.operationId) {
                 const current = this.read(input.operationId);
                 if (current?.state === "completed")
@@ -160,8 +160,24 @@ export class SqliteSessionForkStore {
            @byte_length, @uploaded_bytes, @sha256, @width, @height, 'committed',
            @message_item_id, @created_at, @committed_at
          )`);
-            for (const resource of resources)
-                insertResource.run(resource);
+            for (const resource of resources) {
+                insertResource.run({
+                    id: resource.id,
+                    session_id: resource.session_id,
+                    client_upload_id: resource.client_upload_id,
+                    upload_id: resource.upload_id,
+                    filename: resource.filename,
+                    media_type: resource.media_type,
+                    byte_length: resource.byte_length,
+                    uploaded_bytes: resource.uploaded_bytes,
+                    sha256: resource.sha256,
+                    width: resource.width,
+                    height: resource.height,
+                    message_item_id: resource.message_item_id,
+                    created_at: resource.created_at,
+                    committed_at: resource.committed_at,
+                });
+            }
             const insertItem = conn.prepare(`INSERT INTO session_items (
            id, session_id, position, response_id, type, status,
            data, created_by, created_at
@@ -203,9 +219,9 @@ export class SqliteSessionForkStore {
         ORDER BY created_at`).all().map(toOperation);
     }
     hasReservedSource(sessionId) {
-        return Boolean(db().prepare(`SELECT 1
+        return Boolean(scalar(db().prepare(`SELECT 1
          FROM session_fork_operations
-        WHERE source_session_id = ? AND state = 'reserved'`).pluck().get(sessionId));
+        WHERE source_session_id = ? AND state = 'reserved'`)).get(sessionId));
     }
     markTargetDeleted(sessionId) {
         const now = new Date().toISOString();

package/dist/session-launch-operations.d.ts

@@ -9,13 +9,22 @@ export interface EnsurePluginSessionLaunchInput {
     operationId: string;
     /** SHA-256 of the host-normalized, execution-affecting launch request. */
     requestHash: string;
+    /** SHA-256 before mutable filesystem selectors are canonicalized. */
+    rawRequestHash?: string;
     session: PluginSessionLaunchMeta;
 }
 export interface EnsurePluginSessionLaunchResult {
     sessionId: string;
     disposition: "created" | "replayed";
 }
-export type ReplayPluginSessionLaunchInput = Omit<EnsurePluginSessionLaunchInput, "session">;
+export type ReplayPluginSessionLaunchInput = Omit<EnsurePluginSessionLaunchInput, "session"> & {
+    /**
+     * A caller doing a pre-canonicalization lookup may treat a hash mismatch as
+     * a cache miss, then retry with the canonical hash. The canonical lookup
+     * must keep the default strict conflict behavior.
+     */
+    allowRequestHashMismatch?: boolean;
+};
 export declare class SessionLaunchOperationConflictError extends Error {
     readonly pluginId: string;
     readonly scopeId: string;