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

package/dist/pm2.js

@@ -10,10 +10,9 @@
 import { spawn, spawnSync } from "node:child_process";
 import { mkdirSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadConfig } from "@rynx-ai/core";
+import { loadConfig, rynxHome } from "@rynx-ai/core";
 import { daemonEntryRestartRequired } from "./daemon-build-status.js";
 const require = createRequire(import.meta.url);
 /** pm2 app name — single resident daemon per machine. */
@@ -55,16 +54,22 @@ function daemonEntryPath() {
     return join(dirname(fileURLToPath(import.meta.url)), "index-daemon.js");
 }
 function logsDir() {
-    const home = process.env.RYNX_HOME?.trim() || join(homedir(), ".rynx");
-    const dir = join(home, "logs");
+    const dir = join(rynxHome(), "logs");
     mkdirSync(dir, { recursive: true });
     return dir;
 }
 function nodeRuntimeEnv() {
-    if (!process.versions.electron) {
-        return process.env;
-    }
-    return { ...process.env, ELECTRON_RUN_AS_NODE: "1" };
+    const home = rynxHome();
+    const pm2Home = join(home, "pm2");
+    mkdirSync(pm2Home, { recursive: true, mode: 0o700 });
+    return {
+        ...process.env,
+        RYNX_HOME: home,
+        PM2_HOME: pm2Home,
+        ...(process.versions.electron
+            ? { ELECTRON_RUN_AS_NODE: "1" }
+            : {}),
+    };
 }
 /** Run a pm2 command inheriting stdio; returns its exit code. */
 function runPm2(args, quiet = false) {
@@ -145,9 +150,9 @@ export function startDaemon({ force, quiet = false }) {
         daemonEntryPath(),
         "--name",
         APP_NAME,
-        // Resolve `.env` relative to where the user invoked `rynx start`.
+        // App and CLI share one daemon-owned state/workspace root.
         "--cwd",
-        process.cwd(),
+        rynxHome(),
         "--max-restarts",
         "10",
         "--restart-delay",

package/dist/runtime-project-store.d.ts

@@ -0,0 +1,9 @@
+import { type RuntimeProject, type RuntimeProjectInput, type RuntimeProjectStore } from "@rynx-ai/core";
+/** SQLite-backed Project catalog owned by the current target Runtime. */
+export declare class SqliteRuntimeProjectStore implements RuntimeProjectStore {
+    list(): Promise<RuntimeProject[]>;
+    get(id: string): Promise<RuntimeProject | undefined>;
+    create(input: RuntimeProjectInput): Promise<RuntimeProject>;
+    update(id: string, input: RuntimeProjectInput): Promise<RuntimeProject | undefined>;
+    remove(id: string): Promise<boolean>;
+}

package/dist/runtime-project-store.js

@@ -0,0 +1,83 @@
+import { randomUUID } from "node:crypto";
+import { canonicalizeRuntimeProjectInput, runtimeProjectSchema, } from "@rynx-ai/core";
+import { db } from "./db.js";
+const COLUMNS = "id, name, directories_json, primary_dir, created_at, updated_at";
+/** SQLite-backed Project catalog owned by the current target Runtime. */
+export class SqliteRuntimeProjectStore {
+    async list() {
+        return db()
+            .prepare(`SELECT ${COLUMNS} FROM runtime_projects ORDER BY updated_at DESC, id`)
+            .all()
+            .map((row) => rowToProject(row));
+    }
+    async get(id) {
+        const row = db()
+            .prepare(`SELECT ${COLUMNS} FROM runtime_projects WHERE id = ?`)
+            .get(id);
+        return row ? rowToProject(row) : undefined;
+    }
+    async create(input) {
+        const resolved = await canonicalizeRuntimeProjectInput(input);
+        const timestamp = new Date().toISOString();
+        const project = {
+            id: randomUUID(),
+            ...resolved,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        const parsed = runtimeProjectSchema.parse(project);
+        db()
+            .prepare(`INSERT INTO runtime_projects
+           (id, name, directories_json, primary_dir, created_at, updated_at)
+         VALUES (@id, @name, @directories, @primary, @createdAt, @updatedAt)`)
+            .run({
+            id: parsed.id,
+            name: parsed.name,
+            directories: JSON.stringify(parsed.directories),
+            primary: parsed.primary,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt,
+        });
+        return parsed;
+    }
+    async update(id, input) {
+        const current = await this.get(id);
+        if (!current)
+            return undefined;
+        const resolved = await canonicalizeRuntimeProjectInput(input);
+        const project = runtimeProjectSchema.parse({
+            id: current.id,
+            ...resolved,
+            createdAt: current.createdAt,
+            updatedAt: new Date().toISOString(),
+        });
+        db()
+            .prepare(`UPDATE runtime_projects
+         SET name = @name,
+             directories_json = @directories,
+             primary_dir = @primary,
+             updated_at = @updatedAt
+         WHERE id = @id`)
+            .run({
+            id: project.id,
+            name: project.name,
+            directories: JSON.stringify(project.directories),
+            primary: project.primary,
+            updatedAt: project.updatedAt,
+        });
+        return project;
+    }
+    async remove(id) {
+        return db().prepare("DELETE FROM runtime_projects WHERE id = ?").run(id).changes > 0;
+    }
+}
+function rowToProject(row) {
+    return runtimeProjectSchema.parse({
+        id: row.id,
+        name: row.name,
+        directories: JSON.parse(row.directories_json),
+        primary: row.primary_dir,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    });
+}

package/dist/session-fallback-workspace.d.ts

@@ -0,0 +1,22 @@
+import { type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+export interface SessionFallbackRootOptions {
+    platform?: NodeJS.Platform;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    readTextFile?: (path: string) => Promise<string>;
+}
+export interface SessionFallbackWorkspaceOptions extends SessionFallbackRootOptions {
+    now?: () => Date;
+    randomId?: () => string;
+}
+/**
+ * Resolve the user-visible root for Sessions created without a Project.
+ *
+ * Linux desktop environments can localize or relocate Documents through the
+ * XDG user-dirs file. Headless installations commonly omit that file, so they
+ * fall back to a visible `$HOME/Rynx` instead of creating an arbitrary
+ * `$HOME/Documents` tree. Other platforms retain the existing Documents root.
+ */
+export declare function resolveSessionFallbackRoot(options?: SessionFallbackRootOptions): Promise<string>;
+export declare function createSessionFallbackWorkspace(options?: SessionFallbackWorkspaceOptions): Promise<SessionWorkspaceSnapshot>;
+export declare function discardSessionFallbackWorkspace(workspace: SessionWorkspaceSnapshot, options?: SessionFallbackRootOptions): Promise<void>;

package/dist/session-fallback-workspace.js

@@ -0,0 +1,120 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, realpath, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, normalize, relative } from "node:path";
+import { sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
+/**
+ * Resolve the user-visible root for Sessions created without a Project.
+ *
+ * Linux desktop environments can localize or relocate Documents through the
+ * XDG user-dirs file. Headless installations commonly omit that file, so they
+ * fall back to a visible `$HOME/Rynx` instead of creating an arbitrary
+ * `$HOME/Documents` tree. Other platforms retain the existing Documents root.
+ */
+export async function resolveSessionFallbackRoot(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const home = normalize(options.home ?? homedir());
+    if (!isAbsolute(home))
+        throw new Error("Session fallback home must be absolute");
+    if (platform !== "linux")
+        return join(home, "Documents", "Rynx");
+    const env = options.env ?? process.env;
+    const configHome = env.XDG_CONFIG_HOME && isAbsolute(env.XDG_CONFIG_HOME)
+        ? normalize(env.XDG_CONFIG_HOME)
+        : join(home, ".config");
+    const readTextFile = options.readTextFile ?? ((path) => readFile(path, "utf8"));
+    try {
+        const contents = await readTextFile(join(configHome, "user-dirs.dirs"));
+        const documents = parseXdgDocumentsDirectory(contents, home);
+        if (documents)
+            return join(documents, "Rynx");
+    }
+    catch {
+        // Missing or unreadable XDG configuration is normal on headless Linux.
+    }
+    return join(home, "Rynx");
+}
+export async function createSessionFallbackWorkspace(options = {}) {
+    const now = (options.now ?? (() => new Date()))();
+    const date = [
+        now.getFullYear(),
+        String(now.getMonth() + 1).padStart(2, "0"),
+        String(now.getDate()).padStart(2, "0"),
+    ].join("-");
+    const fallbackRoot = await resolveSessionFallbackRoot(options);
+    await mkdir(fallbackRoot, { recursive: true });
+    const canonicalFallbackRoot = await realpath(fallbackRoot);
+    const dateDirectory = join(canonicalFallbackRoot, date);
+    await mkdir(dateDirectory, { recursive: true });
+    const canonicalDateDirectory = await realpath(dateDirectory);
+    if (relative(canonicalFallbackRoot, canonicalDateDirectory) !== date) {
+        throw new Error("Session fallback date directory resolves outside the managed root");
+    }
+    const randomId = options.randomId ?? randomUUID;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        const directory = join(canonicalDateDirectory, randomId().slice(0, 8));
+        try {
+            await mkdir(directory);
+            const canonical = await realpath(directory);
+            return sessionWorkspaceSnapshotSchema.parse({
+                cwd: canonical,
+                allowedDirs: [canonical],
+            });
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    throw new Error("could not allocate a unique Session workspace directory");
+}
+export async function discardSessionFallbackWorkspace(workspace, options = {}) {
+    if (workspace.allowedDirs.length !== 1
+        || workspace.allowedDirs[0] !== workspace.cwd) {
+        return;
+    }
+    let canonicalRoot;
+    try {
+        canonicalRoot = await realpath(await resolveSessionFallbackRoot(options));
+    }
+    catch {
+        return;
+    }
+    const relativePath = relative(canonicalRoot, workspace.cwd);
+    const segments = relativePath.split(/[\\/]/);
+    if (isAbsolute(relativePath)
+        || relativePath.startsWith("..")
+        || segments.length !== 2
+        || !/^\d{4}-\d{2}-\d{2}$/.test(segments[0] ?? "")
+        || !/^[0-9a-f]{8}$/.test(segments[1] ?? "")) {
+        return;
+    }
+    await rm(workspace.cwd, { recursive: true, force: true });
+}
+function parseXdgDocumentsDirectory(contents, home) {
+    for (const line of contents.split(/\r?\n/)) {
+        const match = line.match(/^\s*XDG_DOCUMENTS_DIR\s*=\s*"((?:\\.|[^"])*)"\s*(?:#.*)?$/);
+        if (!match)
+            continue;
+        const raw = match[1];
+        let expanded;
+        if (raw === "$HOME" || raw === "${HOME}") {
+            expanded = home;
+        }
+        else if (raw.startsWith("$HOME/")) {
+            expanded = join(home, decodeXdgPath(raw.slice("$HOME/".length)));
+        }
+        else if (raw.startsWith("${HOME}/")) {
+            expanded = join(home, decodeXdgPath(raw.slice("${HOME}/".length)));
+        }
+        else {
+            expanded = decodeXdgPath(raw);
+        }
+        if (!expanded.includes("\0") && isAbsolute(expanded))
+            return normalize(expanded);
+    }
+    return undefined;
+}
+function decodeXdgPath(value) {
+    return value.replace(/\\(.)/g, "$1");
+}

package/dist/session-fork-store.d.ts

@@ -0,0 +1,41 @@
+import { type MachineSessionRecord } from "@rynx-ai/core";
+import type { SessionItem } from "@rynx-ai/protocol";
+import { type MachineSessionForkOperationRecord, type MachineSessionForkStorePort } from "@rynx-ai/server";
+/**
+ * SQLite/resource-file implementation of the fork publication boundary.
+ *
+ * Provider context is prepared before {@link commit}; this store then publishes
+ * Session metadata, an independent canonical transcript, referenced committed
+ * resources, and the completed operation in one SQLite transaction. Resource
+ * files use deterministic target ids, so a crash before the transaction can be
+ * retried safely.
+ */
+export declare class SqliteSessionForkStore implements MachineSessionForkStorePort {
+    private readonly resourceRoot;
+    constructor(resourceRoot?: string);
+    claim(input: {
+        operationId: string;
+        requestHash: string;
+        sourceSessionId: string;
+        title?: string;
+    }): MachineSessionForkOperationRecord;
+    commit(input: {
+        operationId: string;
+        target: MachineSessionRecord;
+        items: SessionItem[];
+    }): void;
+    publishNativeFork(input: {
+        sourceSessionId: string;
+        target: MachineSessionRecord;
+        items: SessionItem[];
+    }): void;
+    private publishTarget;
+    markError(operationId: string, error: string): void;
+    listReserved(): MachineSessionForkOperationRecord[];
+    hasReservedSource(sessionId: string): boolean;
+    markTargetDeleted(sessionId: string): void;
+    private read;
+    private copyResourceFile;
+    private sessionDirectory;
+    private resourcePath;
+}

package/dist/session-fork-store.js

@@ -0,0 +1,288 @@
+import { createHash } from "node:crypto";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, } from "node:fs";
+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";
+const FORK_COLS = [
+    "operation_id",
+    "request_hash",
+    "source_session_id",
+    "target_session_id",
+    "title",
+    "fork_position",
+    "state",
+    "error",
+].join(", ");
+/**
+ * SQLite/resource-file implementation of the fork publication boundary.
+ *
+ * Provider context is prepared before {@link commit}; this store then publishes
+ * Session metadata, an independent canonical transcript, referenced committed
+ * resources, and the completed operation in one SQLite transaction. Resource
+ * files use deterministic target ids, so a crash before the transaction can be
+ * retried safely.
+ */
+export class SqliteSessionForkStore {
+    resourceRoot;
+    constructor(resourceRoot = join(rynxHome(), "resources")) {
+        this.resourceRoot = resourceRoot;
+    }
+    claim(input) {
+        const existing = this.read(input.operationId);
+        if (existing) {
+            if (existing.request_hash !== input.requestHash ||
+                existing.source_session_id !== input.sourceSessionId) {
+                throw new MachineSessionServiceFailure("conflict", "operationId was already used for a different Session fork");
+            }
+            return toOperation(existing);
+        }
+        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)) {
+            targetSessionId = newSessionId();
+        }
+        try {
+            db().prepare(`INSERT INTO session_fork_operations (
+           operation_id, request_hash, source_session_id, target_session_id,
+           title, state, created_at, updated_at
+         ) VALUES (?, ?, ?, ?, ?, 'reserved', ?, ?)`).run(input.operationId, input.requestHash, input.sourceSessionId, targetSessionId, normalizeSessionTitle(input.title) ?? null, now, now);
+        }
+        catch (error) {
+            const raced = this.read(input.operationId);
+            if (raced)
+                return this.claim(input);
+            const busy = db().prepare(`SELECT operation_id
+           FROM session_fork_operations
+          WHERE source_session_id = ? AND state = 'reserved'`).get(input.sourceSessionId);
+            if (busy) {
+                throw new MachineSessionServiceFailure("conflict", "source Session already has a fork in progress");
+            }
+            throw error;
+        }
+        return toOperation(this.read(input.operationId));
+    }
+    commit(input) {
+        const operation = this.read(input.operationId);
+        if (!operation) {
+            throw new MachineSessionServiceFailure("not_found", "Session fork operation not found");
+        }
+        if (operation.state === "target_deleted") {
+            throw new MachineSessionServiceFailure("conflict", "fork target was deleted");
+        }
+        if (operation.target_session_id !== input.target.id) {
+            throw new MachineSessionServiceFailure("conflict", "fork target identity changed");
+        }
+        if (operation.state === "completed")
+            return;
+        this.publishTarget({
+            sourceSessionId: operation.source_session_id,
+            target: input.target,
+            items: input.items,
+            operationId: input.operationId,
+        });
+    }
+    publishNativeFork(input) {
+        const existing = db().prepare("SELECT forked_from_session_id FROM sessions WHERE id = ?").get(input.target.id);
+        if (existing) {
+            if (existing.forked_from_session_id === input.sourceSessionId)
+                return;
+            throw new MachineSessionServiceFailure("conflict", "target Session already exists");
+        }
+        this.publishTarget(input);
+    }
+    publishTarget(input) {
+        const itemIds = new Map();
+        for (const item of input.items)
+            itemIds.set(item.id, newSessionItemId(item.type));
+        const resourceIds = referencedResourceIds(input.items);
+        const resourceMap = new Map();
+        const resources = resourceIds.map((resourceId) => {
+            const source = db().prepare(`SELECT * FROM session_resources
+          WHERE session_id = ? AND id = ? AND state = 'committed'`).get(input.sourceSessionId, resourceId);
+            if (!source) {
+                throw new MachineSessionServiceFailure("failed_precondition", `fork history references unavailable resource ${resourceId}`);
+            }
+            const targetId = deterministicId("res", input.target.id, source.id);
+            resourceMap.set(source.id, targetId);
+            const target = {
+                ...source,
+                id: targetId,
+                session_id: input.target.id,
+                client_upload_id: deterministicId("fork", input.target.id, source.client_upload_id),
+                upload_id: deterministicId("upl", input.target.id, source.upload_id),
+                message_item_id: source.message_item_id
+                    ? itemIds.get(source.message_item_id) ?? null
+                    : null,
+            };
+            this.copyResourceFile(source, target);
+            return target;
+        });
+        const clonedItems = input.items.map((item, position) => {
+            const remapped = remapItemResources(item, resourceMap);
+            return {
+                ...remapped,
+                id: itemIds.get(item.id),
+                sessionId: input.target.id,
+                position,
+            };
+        });
+        const conn = db();
+        conn.transaction(() => {
+            if (input.operationId) {
+                const current = this.read(input.operationId);
+                if (current?.state === "completed")
+                    return;
+                if (!current || current.state !== "reserved") {
+                    throw new MachineSessionServiceFailure("conflict", "Session fork state changed");
+                }
+            }
+            else {
+                const existing = conn.prepare("SELECT forked_from_session_id FROM sessions WHERE id = ?").get(input.target.id);
+                if (existing?.forked_from_session_id === input.sourceSessionId)
+                    return;
+                if (existing) {
+                    throw new MachineSessionServiceFailure("conflict", "target Session already exists");
+                }
+            }
+            conn.prepare(`INSERT INTO sessions (
+           id, workspace, execution, title, forked_from_session_id,
+           source, created_at, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.target.id, JSON.stringify(sessionWorkspaceSnapshotSchema.parse(input.target.workspace)), JSON.stringify(resolvedExecutionSnapshotSchema.parse(input.target.execution)), normalizeSessionTitle(input.target.title) ?? null, input.target.forkedFromSessionId ?? null, input.target.source, input.target.createdAt, input.target.updatedAt ?? input.target.createdAt);
+            const insertResource = conn.prepare(`INSERT INTO session_resources (
+           id, session_id, client_upload_id, upload_id, filename, media_type,
+           byte_length, uploaded_bytes, sha256, width, height, state,
+           message_item_id, created_at, committed_at
+         ) VALUES (
+           @id, @session_id, @client_upload_id, @upload_id, @filename, @media_type,
+           @byte_length, @uploaded_bytes, @sha256, @width, @height, 'committed',
+           @message_item_id, @created_at, @committed_at
+         )`);
+            for (const resource of resources)
+                insertResource.run(resource);
+            const insertItem = conn.prepare(`INSERT INTO session_items (
+           id, session_id, position, response_id, type, status,
+           data, created_by, created_at
+         ) VALUES (
+           @id, @session_id, @position, @response_id, @type, @status,
+           @data, @created_by, @created_at
+         )`);
+            for (const item of clonedItems) {
+                insertItem.run({
+                    id: item.id,
+                    session_id: item.sessionId,
+                    position: item.position,
+                    response_id: item.responseId,
+                    type: item.type,
+                    status: item.status,
+                    data: JSON.stringify(item.data),
+                    created_by: item.createdBy ?? null,
+                    created_at: item.createdAt,
+                });
+            }
+            if (input.operationId) {
+                const completedAt = new Date().toISOString();
+                conn.prepare(`UPDATE session_fork_operations
+              SET state = 'completed', fork_position = ?, error = NULL,
+                  updated_at = ?, completed_at = ?
+            WHERE operation_id = ? AND state = 'reserved'`).run(clonedItems.at(-1)?.position ?? -1, completedAt, completedAt, input.operationId);
+            }
+        }).immediate();
+    }
+    markError(operationId, error) {
+        db().prepare(`UPDATE session_fork_operations
+          SET error = ?, updated_at = ?
+        WHERE operation_id = ? AND state = 'reserved'`).run(error.slice(0, 4_096), new Date().toISOString(), operationId);
+    }
+    listReserved() {
+        return db().prepare(`SELECT ${FORK_COLS}
+         FROM session_fork_operations
+        WHERE state = 'reserved'
+        ORDER BY created_at`).all().map(toOperation);
+    }
+    hasReservedSource(sessionId) {
+        return Boolean(db().prepare(`SELECT 1
+         FROM session_fork_operations
+        WHERE source_session_id = ? AND state = 'reserved'`).pluck().get(sessionId));
+    }
+    markTargetDeleted(sessionId) {
+        const now = new Date().toISOString();
+        db().prepare(`UPDATE session_fork_operations
+          SET state = 'target_deleted', updated_at = ?, deleted_at = ?
+        WHERE target_session_id = ? AND state IN ('reserved', 'completed')`).run(now, now, sessionId);
+    }
+    read(operationId) {
+        return db().prepare(`SELECT ${FORK_COLS}
+         FROM session_fork_operations
+        WHERE operation_id = ?`).get(operationId);
+    }
+    copyResourceFile(source, target) {
+        const sourcePath = this.resourcePath(source);
+        if (!existsSync(sourcePath)) {
+            throw new MachineSessionServiceFailure("failed_precondition", `fork resource file is missing: ${source.id}`);
+        }
+        const targetDir = this.sessionDirectory(target.session_id);
+        mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+        chmodSync(targetDir, 0o700);
+        copyFileSync(sourcePath, this.resourcePath(target));
+        chmodSync(this.resourcePath(target), 0o600);
+    }
+    sessionDirectory(sessionId) {
+        const key = createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+        return join(this.resourceRoot, key);
+    }
+    resourcePath(row) {
+        return join(this.sessionDirectory(row.session_id), `${row.id}.${extension(row.media_type)}`);
+    }
+}
+function toOperation(row) {
+    return {
+        operationId: row.operation_id,
+        requestHash: row.request_hash,
+        sourceSessionId: row.source_session_id,
+        targetSessionId: row.target_session_id,
+        ...(row.title ? { title: row.title } : {}),
+        ...(row.fork_position === null ? {} : { forkPosition: row.fork_position }),
+        state: row.state,
+        ...(row.error ? { error: row.error } : {}),
+    };
+}
+function referencedResourceIds(items) {
+    const ids = new Set();
+    for (const item of items) {
+        if (item.type !== "message" || item.data.role !== "user")
+            continue;
+        for (const part of item.data.content) {
+            if (part.type === "input_image")
+                ids.add(part.resourceId);
+        }
+    }
+    return [...ids];
+}
+function remapItemResources(item, resources) {
+    const cloned = structuredClone(item);
+    if (cloned.type !== "message" || cloned.data.role !== "user")
+        return cloned;
+    cloned.data.content = cloned.data.content.map((part) => part.type === "input_image"
+        ? { ...part, resourceId: resources.get(part.resourceId) ?? part.resourceId }
+        : part);
+    return cloned;
+}
+function deterministicId(prefix, targetSessionId, sourceId) {
+    const digest = createHash("sha256")
+        .update(`${targetSessionId}\0${sourceId}`)
+        .digest("hex");
+    return `${prefix}_${digest.slice(0, 40)}`;
+}
+function extension(mediaType) {
+    switch (mediaType) {
+        case "image/png":
+            return "png";
+        case "image/jpeg":
+            return "jpg";
+        case "image/webp":
+            return "webp";
+    }
+}

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

@@ -15,6 +15,7 @@ export interface EnsurePluginSessionLaunchResult {
     sessionId: string;
     disposition: "created" | "replayed";
 }
+export type ReplayPluginSessionLaunchInput = Omit<EnsurePluginSessionLaunchInput, "session">;
 export declare class SessionLaunchOperationConflictError extends Error {
     readonly pluginId: string;
     readonly scopeId: string;
@@ -30,12 +31,23 @@ export declare class SessionLaunchOperationTargetDeletedError extends Error {
     readonly code = "SESSION_LAUNCH_OPERATION_TARGET_DELETED";
     constructor(pluginId: string, scopeId: string, operationId: string, sessionId: string);
 }
+/**
+ * Read the durable idempotency fence before resolving mutable launch selectors
+ * such as a Project or Agent. A replay must not fail merely because the
+ * original template was edited or deleted after the Session snapshot existed.
+ *
+ * `undefined` means the caller must resolve snapshots and proceed through
+ * {@link ensurePluginSessionLaunch}; that function remains the atomic race
+ * winner when two first attempts arrive concurrently.
+ */
+export declare function replayPluginSessionLaunch(input: ReplayPluginSessionLaunchInput): EnsurePluginSessionLaunchResult | undefined;
 /**
  * Atomically allocate a persisted machine session for one plugin operation.
  *
  * The durable operation row is the idempotency boundary across runner crashes,
- * daemon restarts, and remote lease re-delivery. It deliberately excludes any
- * Workspace concept: `scopeId` and `operationId` are opaque to the daemon.
+ * daemon restarts, and remote lease re-delivery. `scopeId` and `operationId`
+ * remain opaque; the Session row stores only the already-resolved workspace
+ * snapshot, never a Project identity.
  */
 export declare function ensurePluginSessionLaunch(input: EnsurePluginSessionLaunchInput): EnsurePluginSessionLaunchResult;
 export {};