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

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

@@ -9,12 +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"> & {
+    /**
+     * 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;
@@ -30,12 +40,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 {};

package/dist/session-launch-operations.js

@@ -31,22 +31,63 @@ export class SessionLaunchOperationTargetDeletedError extends Error {
         this.name = "SessionLaunchOperationTargetDeletedError";
     }
 }
+/**
+ * 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 function replayPluginSessionLaunch(input) {
+    const pluginId = requiredId(input.pluginId, "pluginId");
+    const scopeId = requiredId(input.scopeId, "scopeId");
+    const operationId = requiredId(input.operationId, "operationId");
+    const requestHash = requiredRequestHash(input.requestHash);
+    const existing = readOperation(pluginId, scopeId, operationId);
+    if (!existing)
+        return undefined;
+    if (existing.request_hash !== requestHash &&
+        existing.raw_request_hash !== requestHash) {
+        if (input.allowRequestHashMismatch)
+            return undefined;
+        throw new SessionLaunchOperationConflictError(pluginId, scopeId, operationId);
+    }
+    if (existing.state === "deleted") {
+        throw new SessionLaunchOperationTargetDeletedError(pluginId, scopeId, operationId, existing.session_id);
+    }
+    if (!sessionExists(existing.session_id)) {
+        db().transaction(() => {
+            tombstoneOperations(existing.session_id, new Date().toISOString());
+        }).immediate();
+        throw new SessionLaunchOperationTargetDeletedError(pluginId, scopeId, operationId, existing.session_id);
+    }
+    return { disposition: "replayed", sessionId: existing.session_id };
+}
 /**
  * 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 function ensurePluginSessionLaunch(input) {
     const pluginId = requiredId(input.pluginId, "pluginId");
     const scopeId = requiredId(input.scopeId, "scopeId");
     const operationId = requiredId(input.operationId, "operationId");
     const requestHash = requiredRequestHash(input.requestHash);
+    const rawRequestHash = input.rawRequestHash
+        ? requiredRequestHash(input.rawRequestHash)
+        : requestHash;
     const ensure = db().transaction(() => {
         const existing = readOperation(pluginId, scopeId, operationId);
         if (existing) {
-            if (existing.request_hash !== requestHash) {
+            if (existing.request_hash !== requestHash &&
+                existing.raw_request_hash !== requestHash &&
+                existing.request_hash !== rawRequestHash &&
+                existing.raw_request_hash !== rawRequestHash) {
                 throw new SessionLaunchOperationConflictError(pluginId, scopeId, operationId);
             }
             if (existing.state === "deleted") {
@@ -78,10 +119,10 @@ export function ensurePluginSessionLaunch(input) {
         }
         db()
             .prepare(`INSERT INTO plugin_session_launch_operations
-           (plugin_id, scope_id, operation_id, request_hash, session_id, state,
+           (plugin_id, scope_id, operation_id, request_hash, raw_request_hash, session_id, state,
             created_at, updated_at, deleted_at)
-         VALUES (?, ?, ?, ?, ?, 'active', ?, ?, NULL)`)
-            .run(pluginId, scopeId, operationId, requestHash, sessionId, now, now);
+         VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, NULL)`)
+            .run(pluginId, scopeId, operationId, requestHash, rawRequestHash, sessionId, now, now);
         return { disposition: "created", sessionId };
     });
     const result = ensure.immediate();
@@ -92,7 +133,7 @@ export function ensurePluginSessionLaunch(input) {
 }
 function readOperation(pluginId, scopeId, operationId) {
     return db()
-        .prepare(`SELECT request_hash, session_id, state
+        .prepare(`SELECT request_hash, raw_request_hash, session_id, state
        FROM plugin_session_launch_operations
        WHERE plugin_id = ? AND scope_id = ? AND operation_id = ?`)
         .get(pluginId, scopeId, operationId);

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

@@ -1,15 +1,15 @@
 /**
  * The unified machine-session record (SQLite) — one row per session regardless
- * of origin (the web console AND every channel). Holds identity/meta (source /
- * provider / agent / inline config / model / title / …) so the **session list survives a
- * daemon restart**; the transcript lives in `session_items` (see
+ * of origin (the web console AND every channel). Holds immutable workspace /
+ * execution snapshots plus display metadata so the **session list survives a
+ * daemon restart** without re-reading a Project or Agent; the transcript lives
+ * in `session_items` (see
  * {@link import("./session-log-store.js")}). Runtime `status` is intentionally
  * not stored — it is reconstructed as `idle` after a restart.
  *
  * Exposes both the standalone functions the control-plane deps wire in and a
- * {@link SessionRegistry} adapter ({@link sessionRegistry}) injected into channels
- * via the `ChannelContext`, so a channel registers its sessions the same way the
- * console does.
+ * {@link SessionRegistry} adapter ({@link sessionRegistry}) used by daemon
+ * session services and capability-checked plugin Host RPC.
  */
 import { type MachineSessionRecord, type SessionRegistry } from "@rynx-ai/core";
 /** Back-compat alias for the unified record. */
@@ -17,9 +17,12 @@ export type StoredSessionMeta = MachineSessionRecord;
 export declare function listSessionMetas(): StoredSessionMeta[];
 export declare function getSessionMeta(id: string): StoredSessionMeta | undefined;
 export declare function createSessionMeta(meta: StoredSessionMeta): void;
-export declare function updateSessionMeta(meta: StoredSessionMeta): void;
 export declare function setSessionTitle(id: string, title: string): void;
+export declare function setSessionExecution(id: string, execution: MachineSessionRecord["execution"]): void;
 export declare function removeSessionMeta(id: string): void;
-/** {@link SessionRegistry} over the same `sessions` table — the form channels
- *  receive through their `ChannelContext`. */
+/** {@link SessionRegistry} over the same `sessions` table. */
 export declare const sessionRegistry: SessionRegistry;
+/** Generic plugin-principal ownership, including descendants forked from a
+ * plugin-created Session. Portal authorization calls this on every request so
+ * a grant cannot cross into console or another plugin's Sessions. */
+export declare function sessionBelongsToPlugin(pluginId: string, sessionId: string): boolean;

package/dist/session-meta-store.js

@@ -1,19 +1,19 @@
 /**
  * The unified machine-session record (SQLite) — one row per session regardless
- * of origin (the web console AND every channel). Holds identity/meta (source /
- * provider / agent / inline config / model / title / …) so the **session list survives a
- * daemon restart**; the transcript lives in `session_items` (see
+ * of origin (the web console AND every channel). Holds immutable workspace /
+ * execution snapshots plus display metadata so the **session list survives a
+ * daemon restart** without re-reading a Project or Agent; the transcript lives
+ * in `session_items` (see
  * {@link import("./session-log-store.js")}). Runtime `status` is intentionally
  * not stored — it is reconstructed as `idle` after a restart.
  *
  * Exposes both the standalone functions the control-plane deps wire in and a
- * {@link SessionRegistry} adapter ({@link sessionRegistry}) injected into channels
- * via the `ChannelContext`, so a channel registers its sessions the same way the
- * console does.
+ * {@link SessionRegistry} adapter ({@link sessionRegistry}) used by daemon
+ * session services and capability-checked plugin Host RPC.
  */
-import { normalizeSessionTitle, } from "@rynx-ai/core";
+import { normalizeSessionTitle, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { db } from "./db.js";
-const COLS = "id, provider, agent, config, model, reasoning_effort, title, source, created_at, updated_at";
+const COLS = "id, workspace, execution, title, forked_from_session_id, source, created_at, updated_at";
 export function listSessionMetas() {
     return db()
         .prepare(`SELECT ${COLS} FROM sessions ORDER BY created_at`)
@@ -27,50 +27,32 @@ export function getSessionMeta(id) {
 export function createSessionMeta(meta) {
     db()
         .prepare(`INSERT OR IGNORE INTO sessions
-         (id, provider, agent, config, model, reasoning_effort, title, source, created_at, updated_at)
-       VALUES (@id, @provider, @agent, @config, @model, @reasoning_effort, @title, @source, @created_at, @updated_at)`)
+         (id, workspace, execution, title, forked_from_session_id, source, created_at, updated_at)
+       VALUES (
+         @id, @workspace, @execution, @title, @forked_from_session_id,
+         @source, @created_at, @updated_at
+       )`)
         .run({
         id: meta.id,
-        provider: meta.provider ?? null,
-        agent: meta.agent ?? null,
-        config: meta.config ? JSON.stringify(meta.config) : null,
-        model: meta.model ?? null,
-        reasoning_effort: meta.reasoningEffort ?? null,
+        workspace: JSON.stringify(sessionWorkspaceSnapshotSchema.parse(meta.workspace)),
+        execution: JSON.stringify(resolvedExecutionSnapshotSchema.parse(meta.execution)),
         title: normalizeSessionTitle(meta.title) ?? null,
+        forked_from_session_id: meta.forkedFromSessionId ?? null,
         source: meta.source,
         created_at: meta.createdAt,
         updated_at: meta.updatedAt ?? meta.createdAt,
     });
 }
-export function updateSessionMeta(meta) {
-    db()
-        .prepare(`UPDATE sessions
-       SET provider = @provider,
-           agent = @agent,
-           config = @config,
-           model = @model,
-           reasoning_effort = @reasoning_effort,
-           title = @title,
-           source = @source,
-           updated_at = @updated_at
-       WHERE id = @id`)
-        .run({
-        id: meta.id,
-        provider: meta.provider ?? null,
-        agent: meta.agent ?? null,
-        config: meta.config ? JSON.stringify(meta.config) : null,
-        model: meta.model ?? null,
-        reasoning_effort: meta.reasoningEffort ?? null,
-        title: normalizeSessionTitle(meta.title) ?? null,
-        source: meta.source,
-        updated_at: meta.updatedAt ?? new Date().toISOString(),
-    });
-}
 export function setSessionTitle(id, title) {
     db()
         .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?")
         .run(normalizeSessionTitle(title), new Date().toISOString(), id);
 }
+export function setSessionExecution(id, execution) {
+    db()
+        .prepare("UPDATE sessions SET execution = ?, updated_at = ? WHERE id = ?")
+        .run(JSON.stringify(resolvedExecutionSnapshotSchema.parse(execution)), new Date().toISOString(), id);
+}
 export function removeSessionMeta(id) {
     db().transaction(() => {
         const now = new Date().toISOString();
@@ -79,32 +61,51 @@ export function removeSessionMeta(id) {
          SET state = 'deleted', updated_at = ?, deleted_at = ?
          WHERE session_id = ? AND state = 'active'`)
             .run(now, now, id);
+        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, id);
         db().prepare("DELETE FROM sessions WHERE id = ?").run(id);
     }).immediate();
 }
-/** {@link SessionRegistry} over the same `sessions` table — the form channels
- *  receive through their `ChannelContext`. */
+/** {@link SessionRegistry} over the same `sessions` table. */
 export const sessionRegistry = {
     create: createSessionMeta,
     get: getSessionMeta,
     list: listSessionMetas,
     setTitle: setSessionTitle,
+    setExecution: setSessionExecution,
     remove: removeSessionMeta,
 };
+/** Generic plugin-principal ownership, including descendants forked from a
+ * plugin-created Session. Portal authorization calls this on every request so
+ * a grant cannot cross into console or another plugin's Sessions. */
+export function sessionBelongsToPlugin(pluginId, sessionId) {
+    const seen = new Set();
+    let current = sessionRegistry.get(sessionId);
+    while (current && !seen.has(current.id)) {
+        if (current.source === `plugin:${pluginId}`)
+            return true;
+        seen.add(current.id);
+        current = current.forkedFromSessionId
+            ? sessionRegistry.get(current.forkedFromSessionId)
+            : undefined;
+    }
+    return false;
+}
 function rowToMeta(row) {
     return {
         id: row.id,
-        provider: row.provider === "codex" || row.provider === "traex" || row.provider === "claude"
-            ? row.provider
-            : undefined,
-        agent: row.agent ?? undefined,
-        config: row.config ? JSON.parse(row.config) : undefined,
-        model: row.model ?? undefined,
-        reasoningEffort: (row.reasoning_effort ?? undefined),
+        workspace: sessionWorkspaceSnapshotSchema.parse(JSON.parse(row.workspace)),
+        execution: resolvedExecutionSnapshotSchema.parse(JSON.parse(row.execution)),
         // Normalize on read as well so pre-boundary database rows cannot poison an
         // entire Remote Session list page after upgrading the daemon.
         title: normalizeSessionTitle(row.title ?? undefined),
-        source: row.source ?? "console",
+        ...(row.forked_from_session_id
+            ? { forkedFromSessionId: row.forked_from_session_id }
+            : {}),
+        source: row.source,
         createdAt: row.created_at,
         updatedAt: row.updated_at ?? row.created_at,
     };

package/dist/session-portal-grant-store.d.ts

@@ -0,0 +1,29 @@
+export type SessionPortalScope = "plugin_sessions" | "single_session";
+export type SessionPortalAccess = "read_only" | "read_write";
+export interface SessionPortalAuthorization {
+    portalId: string;
+    pluginId: string;
+    scope: SessionPortalScope;
+    access: SessionPortalAccess;
+    sessionId?: string;
+    expiresAt: string;
+}
+/** Issue a browser handoff into the native Session workbench. The Host knows
+ * only the generic Session scope and access level; product/user policy stays in
+ * the plugin that asks for the ticket. */
+export declare function issueSessionPortalTicket(input: {
+    pluginId: string;
+    scope: SessionPortalScope;
+    access: SessionPortalAccess;
+    sessionId?: string;
+    now?: Date;
+}): {
+    path: string;
+    expiresAt: string;
+};
+/** Atomically consume a one-use ticket and mint a fixed-lifetime browser grant. */
+export declare function redeemSessionPortalTicket(ticket: string, now?: Date): (SessionPortalAuthorization & {
+    secret: string;
+}) | undefined;
+export declare function authorizeSessionPortalGrant(portalId: string, secret: string, now?: Date): SessionPortalAuthorization | undefined;
+export declare function pruneSessionPortalAuthorization(now?: Date): void;