@rynx-ai/daemon 0.1.11-beta.30 → 0.1.11-beta.31

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11-beta.30",
+  "version": "0.1.11-beta.31",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/daemon-server.js

@@ -17,8 +17,8 @@ import { REMOTE_RUNTIME_CORE_PROTOCOL } from "@rynx-ai/protocol/remote-runtime";
 import { RUNTIME_BROWSER_INSPECT_MAX_MESSAGE_BYTES, RUNTIME_BROWSER_INSPECT_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-browser-inspect";
 import { RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY } from "@rynx-ai/protocol/runtime-browser-surface";
 import { RUNTIME_EMULATOR_SURFACE_SEMANTIC_CAPABILITY } from "@rynx-ai/protocol/runtime-emulator-surface";
-import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, MachineSessionServiceFailure, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
-import { authorizeSessionPortalGrant, redeemSessionPortalTicket, } from "./session-portal-grant-store.js";
+import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, MachineSessionServiceFailure, RemoteRuntimeDispatcher, SessionPendingInputIndex, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
+import { authorizeSessionPortalGrant, inspectSessionPortalGrant, onSessionPortalGrantRevoked, redeemSessionPortalTicket, revokeEmbeddedWritableSessionPortalGrants, } from "./session-portal-grant-store.js";
 import { APP_BROWSER_HOST_BOOTSTRAP_TYPE, AppBrowserHostSupervisor, parseAppBrowserHostLaunchConfig, } from "./app-browser-host-supervisor.js";
 import { buildControlDeps, listControlAgentModels } from "./control-deps.js";
 import { createBrowserArtifactManagementService } from "./browser-artifact-management.js";
@@ -311,7 +311,9 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
                 "semantic.session.interaction.v1",
                 "semantic.project.manage.v1",
                 "semantic.provider-cli.status.v1",
-                ...(runtimeBrowserSupported ? ["semantic.browser.v1"] : []),
+                ...(runtimeBrowserSupported
+                    ? ["semantic.browser.v1", "semantic.browser.request-headers.v1"]
+                    : []),
                 ...(runtimeBrowserSupported && directHostingSupported
                     ? [
                         RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY,
@@ -387,6 +389,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
             };
         };
         let machineSessions;
+        let sessionBrowsers;
         const pluginRuntime = {
             bindHostServices: (services) => pluginSupervisor.bindHostServices({
                 ...services,
@@ -396,6 +399,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
                     publicKey: installationIdentity.publicKey,
                     sign: installationIdentity.sign,
                 },
+                sessionBrowserRequestHeaders: sessionBrowsers,
                 sessionLaunch: {
                     resolve: async (selection) => {
                         const workspace = await resolveSessionWorkspace(runtimeProjects, selection.projectId, selection.managedCwd, selection.workspace);
@@ -434,6 +438,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
         const directConnections = new DirectRuntimeConnectionHub();
         const sessionLog = new SqliteSessionLogStore();
         const sessionResources = new SqliteSessionResourceStore();
+        const sessionPendingInputs = new SessionPendingInputIndex();
         const sessionForks = new SqliteSessionForkStore();
         const runtimeProjects = new SqliteRuntimeProjectStore();
         const providerClis = new ProviderCliService();
@@ -446,6 +451,11 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
         const sessionRuntimeServices = createSessionRuntimeServices({
             config: appConfig,
             sessionLog,
+            pendingInputs: sessionPendingInputs,
+            onPendingInputPersisted: (input) => sessionResources.markMessageMirrored(input.sessionId, input.clientMessageId, {
+                responseId: input.responseId,
+                messageItemId: input.messageItemId,
+            }),
             sessionContextProvider: browserRunnerSessionContexts,
             admissionOpen,
             admissionReserve: reserveAdmission,
@@ -455,7 +465,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
         const sessionBrowserHost = appBrowserHostSupervisor
             ? createSupervisedAppSessionBrowserHost(durableDesktopBrowserHost, appBrowserHostSupervisor)
             : createDesktopFirstSessionBrowserHost(durableDesktopBrowserHost, createHeadlessBrowserHost());
-        const sessionBrowsers = new SessionBrowserService({
+        sessionBrowsers = new SessionBrowserService({
             host: sessionBrowserHost,
             sessions: {
                 exists: async (sessionId) => Boolean(sessionRegistry.get(sessionId) ??
@@ -556,6 +566,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
                 list: () => control.listAgents(),
             },
             pendingMessages: sessionPendingMessageStore,
+            pendingInputs: sessionPendingInputs,
             resources: sessionResources,
             forks: sessionForks,
             execution: {
@@ -769,6 +780,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
                 status: async () => asDaemonChromeInspectionStatus(await initializedChromeInspectionManager.status()),
                 configure: async (input) => asDaemonChromeInspectionStatus(await initializedChromeInspectionManager.configure(input)),
             };
+            revokeEmbeddedWritableSessionPortalGrants();
             server = await startServer({
                 config: appConfig,
                 control,
@@ -801,8 +813,10 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, onShut
                     daemonInstanceId,
                 },
                 sessionPortalAuthorization: {
-                    redeem: redeemSessionPortalTicket,
+                    redeem: (ticket, embedOrigin) => redeemSessionPortalTicket(ticket, new Date(), embedOrigin),
                     authorize: authorizeSessionPortalGrant,
+                    inspect: inspectSessionPortalGrant,
+                    subscribeRevocations: onSessionPortalGrantRevoked,
                     ownsSession: sessionBelongsToPlugin,
                 },
             });

package/dist/db.js

@@ -282,6 +282,17 @@ function migrate(conn) {
     );
     CREATE INDEX IF NOT EXISTS idx_session_portal_grants_expires
       ON session_portal_grants(expires_at);
+    CREATE TABLE IF NOT EXISTS session_timeline_projections (
+      plugin_id     TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      projection_id TEXT NOT NULL,
+      request_hash  TEXT NOT NULL,
+      response_id   TEXT NOT NULL,
+      item_id       TEXT NOT NULL UNIQUE,
+      state         TEXT NOT NULL DEFAULT 'pending' CHECK(state IN ('pending', 'completed')),
+      created_at    TEXT NOT NULL,
+      PRIMARY KEY(plugin_id, session_id, projection_id)
+    );
     CREATE TABLE IF NOT EXISTS runtime_pairing_claims (
       claim_id                   TEXT PRIMARY KEY,
       secret_hash                TEXT NOT NULL,
@@ -359,6 +370,17 @@ function migrate(conn) {
     addColumnIfMissing(conn, "session_message_operations", "response_id", "TEXT");
     addColumnIfMissing(conn, "session_message_operations", "message_item_id", "TEXT");
     addColumnIfMissing(conn, "session_message_operations", "execution_snapshot", "TEXT");
+    addColumnIfMissing(conn, "session_portal_tickets", "grant_handle", "TEXT");
+    addColumnIfMissing(conn, "session_portal_tickets", "embed_origin", "TEXT");
+    addColumnIfMissing(conn, "session_portal_grants", "grant_handle", "TEXT");
+    addColumnIfMissing(conn, "session_portal_grants", "embed_origin", "TEXT");
+    addColumnIfMissing(conn, "session_timeline_projections", "state", "TEXT NOT NULL DEFAULT 'pending'");
+    conn.exec(`
+    CREATE INDEX IF NOT EXISTS idx_session_portal_tickets_grant_handle
+      ON session_portal_tickets(plugin_id, grant_handle);
+    CREATE INDEX IF NOT EXISTS idx_session_portal_grants_grant_handle
+      ON session_portal_grants(plugin_id, grant_handle);
+  `);
 }
 /** Rebuild the original image-only table without losing committed resources. */
 function migrateSessionResourceFiles(conn) {

package/dist/headless-browser-host.js

@@ -34,6 +34,14 @@ const DEVTOOLS_BROWSER_PATH = /^\/devtools\/browser\/[A-Za-z0-9._~-]+$/;
 const DEVTOOLS_TARGET_ID_PATTERN = /^[A-Za-z0-9._~-]+$/;
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/;
 const CONTROL_CHARACTER_GLOBAL_PATTERN = /[\u0000-\u001f\u007f]/g;
+const NETWORK_AUTO_ATTACH_FILTER = [
+    { type: "page" },
+    { type: "iframe" },
+    { type: "worker" },
+    { type: "service_worker" },
+    { type: "shared_worker" },
+    { exclude: true },
+];
 export function createHeadlessBrowserHost(options = {}) {
     return new HeadlessBrowserHost(options);
 }
@@ -95,7 +103,7 @@ class HeadlessBrowserHost {
             throw error;
         }
         const ownerToken = randomBytes(32).toString("hex");
-        const args = chromeArguments(profileDir, ownerToken, input.url ?? "about:blank");
+        const args = chromeArguments(profileDir, ownerToken);
         let child;
         try {
             child = spawn(build.executablePath, args, {
@@ -198,6 +206,7 @@ class HeadlessBrowserHandle {
     closingTargetIds = new Set();
     pageSessions = new Map();
     targetBySession = new Map();
+    networkTargetTypeBySession = new Map();
     surfaceSources = new Map();
     loadingTargets = new Set();
     activeTargetId = null;
@@ -205,8 +214,11 @@ class HeadlessBrowserHandle {
     closing = false;
     closePromise;
     operations = Promise.resolve();
+    networkOperations = Promise.resolve();
+    requestHeaders;
     constructor(host) {
         this.host = host;
+        this.requestHeaders = cloneRequestHeadersConfig(host.input.requestHeaders ?? { enabled: false, headers: [] });
         this.events = this.eventQueue;
         this.host.connection.setEventHandler((event) => this.onCdpEvent(event));
         this.host.connection.setDisconnectHandler((reason) => this.markUnavailable(reason));
@@ -223,21 +235,22 @@ class HeadlessBrowserHandle {
     }
     async initialize() {
         await this.host.connection.command("Target.setDiscoverTargets", { discover: true });
-        await this.replaceRestoredStartupPages(this.host.input.url ?? "about:blank");
+        await this.host.connection.command("Target.setAutoAttach", {
+            autoAttach: true,
+            waitForDebuggerOnStart: true,
+            flatten: true,
+            filter: NETWORK_AUTO_ATTACH_FILTER,
+        });
+        await this.createFreshStartupPage();
         await this.refreshTargets();
         const requestedUrl = this.host.input.url;
         if (requestedUrl) {
-            let requestedTarget;
-            for (const target of this.targets.values()) {
-                if (target.url === requestedUrl)
-                    requestedTarget = target;
-            }
-            if (requestedTarget) {
-                await this.host.connection.command("Target.activateTarget", {
-                    targetId: requestedTarget.targetId,
-                });
-                this.activeTargetId = requestedTarget.targetId;
-            }
+            const targetId = this.activeTargetId;
+            if (!targetId)
+                throw new Error("Headless Browser startup Page is unavailable");
+            const pageSessionId = await this.pageSession(targetId);
+            await this.host.connection.command("Page.navigate", { url: requestedUrl }, pageSessionId);
+            await this.resetPageNavigationHistory(targetId);
         }
     }
     async getCdpEndpoint() {
@@ -336,10 +349,17 @@ class HeadlessBrowserHandle {
                 if (this.targets.size >= RUNTIME_BROWSER_MAX_PAGES) {
                     throw new SessionBrowserHostError("capacity", "Headless Browser Page capacity was reached");
                 }
-                const result = await this.host.connection.command("Target.createTarget", { url });
+                const result = await this.host.connection.command("Target.createTarget", {
+                    url: "about:blank",
+                });
                 const targetId = requiredCdpId(result.targetId, "Target.createTarget targetId");
                 this.activeTargetId = targetId;
                 await this.refreshTargets();
+                if (url !== "about:blank") {
+                    const pageSessionId = await this.pageSession(targetId);
+                    await this.host.connection.command("Page.navigate", { url }, pageSessionId);
+                    await this.resetPageNavigationHistory(targetId);
+                }
                 this.eventQueue.changed(this.browserGeneration);
             }
             catch (error) {
@@ -395,6 +415,18 @@ class HeadlessBrowserHandle {
     reload(hostPageId) {
         return this.pageCommand(hostPageId, "Page.reload", {});
     }
+    setRequestHeaders(config) {
+        return this.exclusive(async () => {
+            this.ensureAvailable();
+            await this.networkExclusive(async () => {
+                // Every target is permanently Fetch-intercepted before it is resumed.
+                // Swapping this immutable snapshot is therefore the single commit
+                // point for all current and future targets; already-paused/in-flight
+                // requests keep the snapshot they started with.
+                this.requestHeaders = cloneRequestHeadersConfig(config);
+            });
+        });
+    }
     close() {
         if (this.closePromise)
             return this.closePromise;
@@ -434,6 +466,24 @@ class HeadlessBrowserHandle {
             }
         });
     }
+    async resetPageNavigationHistory(targetId) {
+        let lastError;
+        for (let attempt = 0; attempt < PAGE_SNAPSHOT_TRANSITION_ATTEMPTS; attempt += 1) {
+            const sessionId = await this.pageSession(targetId);
+            try {
+                await this.host.connection.command("Page.resetNavigationHistory", {}, sessionId);
+                return;
+            }
+            catch (error) {
+                if (!isMissingTargetError(error) && !isTransientPageTransitionError(error))
+                    throw error;
+                lastError = error;
+                this.dropAttachedSession(sessionId);
+                await delay(PAGE_SNAPSHOT_TRANSITION_POLL_MS);
+            }
+        }
+        throw lastError ?? new Error("Headless Browser could not reset Page navigation history");
+    }
     pageCommand(hostPageId, method, params) {
         return this.exclusive(async () => {
             this.ensureAvailable();
@@ -491,13 +541,23 @@ class HeadlessBrowserHandle {
             throw this.mapOperationError(error);
         }
     }
-    async replaceRestoredStartupPages(url) {
+    async createFreshStartupPage() {
         const initialPages = await this.readPageTargets();
-        if (initialPages.length <= 1)
-            return;
-        const created = await this.host.connection.command("Target.createTarget", { url });
+        for (const page of initialPages) {
+            try {
+                await this.host.connection.command("Target.closeTarget", { targetId: page.targetId });
+            }
+            catch (error) {
+                if (!isMissingPageError(error))
+                    throw error;
+            }
+        }
+        const created = await this.host.connection.command("Target.createTarget", {
+            url: "about:blank",
+        });
         const freshTargetId = requiredCdpId(created.targetId, "Target.createTarget targetId");
         this.activeTargetId = freshTargetId;
+        await this.host.connection.command("Target.activateTarget", { targetId: freshTargetId });
         for (let attempt = 0; attempt < STARTUP_PAGE_CLEANUP_ATTEMPTS; attempt += 1) {
             const pages = await this.readPageTargets();
             if (!pages.some((page) => page.targetId === freshTargetId)) {
@@ -581,11 +641,21 @@ class HeadlessBrowserHandle {
             canGoForward: false,
         };
     }
-    async pageSession(targetId) {
+    async pageSession(targetId, retryMissing = true) {
         this.requireTarget(targetId);
         const existing = this.pageSessions.get(targetId);
-        if (existing)
-            return existing;
+        if (existing) {
+            try {
+                return await existing;
+            }
+            catch (error) {
+                if (!retryMissing || !isMissingPageError(error))
+                    throw error;
+                if (this.pageSessions.get(targetId) === existing)
+                    this.pageSessions.delete(targetId);
+                return this.pageSession(targetId, false);
+            }
+        }
         const pending = (async () => {
             const result = await this.host.connection.command("Target.attachToTarget", {
                 targetId,
@@ -593,7 +663,8 @@ class HeadlessBrowserHandle {
             });
             const sessionId = requiredCdpId(result.sessionId, "Target.attachToTarget sessionId");
             this.targetBySession.set(sessionId, targetId);
-            await this.host.connection.command("Page.enable", {}, sessionId);
+            this.networkTargetTypeBySession.set(sessionId, "page");
+            await this.networkExclusive(() => this.initializeAttachedTarget(sessionId, this.requireTarget(targetId), false));
             return sessionId;
         })();
         this.pageSessions.set(targetId, pending);
@@ -608,6 +679,67 @@ class HeadlessBrowserHandle {
     onCdpEvent(event) {
         if (this.closing || this.unavailableReason)
             return;
+        if (event.method === "Fetch.requestPaused" && event.sessionId) {
+            void this.continuePausedRequest(event.sessionId, event.params).catch((error) => {
+                if (isMissingFetchRequestError(error))
+                    return;
+                if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                    this.dropAttachedSession(event.sessionId);
+                    return;
+                }
+                this.markUnavailable("Headless Browser could not continue an intercepted request");
+            });
+            return;
+        }
+        if (event.method === "Target.attachedToTarget") {
+            const sessionId = optionalCdpId(event.params.sessionId);
+            const target = parseTargetInfo(event.params.targetInfo);
+            if (!sessionId)
+                return;
+            const waitingForDebugger = event.params.waitingForDebugger === true;
+            this.targetBySession.set(sessionId, target.targetId);
+            this.networkTargetTypeBySession.set(sessionId, target.type);
+            if (target.type === "page") {
+                this.targets.set(target.targetId, target);
+                let pending;
+                pending = this.networkExclusive(() => this.initializeAttachedTarget(sessionId, target, waitingForDebugger))
+                    .then(async () => {
+                    const selected = this.pageSessions.get(target.targetId);
+                    if (selected && selected !== pending) {
+                        let selectedSessionId;
+                        try {
+                            selectedSessionId = await selected;
+                        }
+                        catch {
+                            // The next Page operation will establish a replacement.
+                        }
+                        if (selectedSessionId !== sessionId &&
+                            this.targetBySession.get(sessionId) === target.targetId) {
+                            await this.networkExclusive(() => this.detachAuxiliaryPageSession(sessionId));
+                        }
+                    }
+                    return sessionId;
+                })
+                    .catch((error) => {
+                    if (this.pageSessions.get(target.targetId) === pending) {
+                        this.pageSessions.delete(target.targetId);
+                    }
+                    throw error;
+                });
+                void pending.catch(() => undefined);
+                // Chrome may deliver a waitForDebugger auto-attach session while a
+                // manual Target.attachToTarget for the same Page is still pending.
+                // Every physical session must be initialized and resumed even when a
+                // different session already owns semantic Page commands.
+                if (!this.pageSessions.has(target.targetId)) {
+                    this.pageSessions.set(target.targetId, pending);
+                }
+            }
+            else {
+                void this.networkExclusive(() => this.initializeAttachedTarget(sessionId, target, waitingForDebugger)).catch(() => undefined);
+            }
+            return;
+        }
         if (event.method === "Target.targetCreated" || event.method === "Target.targetInfoChanged") {
             const target = parseTargetInfo(event.params.targetInfo);
             if (target.type !== "page")
@@ -640,7 +772,7 @@ class HeadlessBrowserHandle {
         if (event.method === "Target.detachedFromTarget") {
             const sessionId = optionalCdpId(event.params.sessionId);
             if (sessionId)
-                this.dropPageSession(sessionId);
+                this.dropAttachedSession(sessionId);
             return;
         }
         const targetId = event.sessionId ? this.targetBySession.get(event.sessionId) : undefined;
@@ -683,22 +815,106 @@ class HeadlessBrowserHandle {
         this.loadingTargets.delete(targetId);
         const session = this.pageSessions.get(targetId);
         this.pageSessions.delete(targetId);
+        for (const [sessionId, attachedTargetId] of this.targetBySession) {
+            if (attachedTargetId === targetId)
+                this.dropAttachedSession(sessionId);
+        }
+        // A manual attach can resolve after targetDestroyed. Clean the late
+        // session as well instead of retaining it in the Network update set.
         if (session)
-            void session.then((id) => this.targetBySession.delete(id), () => undefined);
+            void session.then((id) => this.dropAttachedSession(id), () => undefined);
     }
     dropPageSession(sessionId) {
         const targetId = this.targetBySession.get(sessionId);
+        this.targetBySession.delete(sessionId);
+        this.networkTargetTypeBySession.delete(sessionId);
         if (!targetId)
             return;
-        this.targetBySession.delete(sessionId);
-        this.pageSessions.delete(targetId);
-        const surface = this.surfaceSources.get(targetId);
-        if (surface) {
-            this.surfaceSources.delete(targetId);
-            surface.closeAfterSourceLoss();
+        const selected = this.pageSessions.get(targetId);
+        if (selected) {
+            void selected.then((selectedSessionId) => {
+                if (selectedSessionId === sessionId &&
+                    this.pageSessions.get(targetId) === selected) {
+                    this.pageSessions.delete(targetId);
+                    const surface = this.surfaceSources.get(targetId);
+                    if (surface) {
+                        this.surfaceSources.delete(targetId);
+                        surface.closeAfterSourceLoss();
+                    }
+                }
+            }, () => undefined);
         }
         this.eventQueue.changed(this.browserGeneration);
     }
+    dropAttachedSession(sessionId) {
+        if (this.networkTargetTypeBySession.get(sessionId) === "page") {
+            this.dropPageSession(sessionId);
+            return;
+        }
+        this.networkTargetTypeBySession.delete(sessionId);
+        this.targetBySession.delete(sessionId);
+    }
+    async initializeAttachedTarget(sessionId, target, waitingForDebugger) {
+        try {
+            await this.host.connection.command("Network.enable", {}, sessionId);
+            await this.host.connection.command("Fetch.enable", {
+                patterns: [{ urlPattern: "*", requestStage: "Request" }],
+            }, sessionId);
+            if (target.type === "page" || target.type === "iframe") {
+                await this.host.connection.command("Target.setAutoAttach", {
+                    autoAttach: true,
+                    waitForDebuggerOnStart: true,
+                    flatten: true,
+                    filter: NETWORK_AUTO_ATTACH_FILTER,
+                }, sessionId);
+            }
+            if (target.type === "page") {
+                await this.host.connection.command("Page.enable", {}, sessionId);
+            }
+            if (waitingForDebugger) {
+                await this.host.connection.command("Runtime.runIfWaitingForDebugger", {}, sessionId);
+            }
+        }
+        catch (error) {
+            if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                this.dropAttachedSession(sessionId);
+                throw missingPage(error);
+            }
+            this.markUnavailable("Headless Browser could not initialize a network target");
+            throw this.mapOperationError(error);
+        }
+    }
+    async detachAuxiliaryPageSession(sessionId) {
+        try {
+            await this.host.connection.command("Target.detachFromTarget", { sessionId });
+        }
+        catch (error) {
+            if (!isMissingTargetError(error) && !isTransientPageTransitionError(error)) {
+                this.markUnavailable("Headless Browser could not fence a duplicate Page session");
+                throw this.mapOperationError(error);
+            }
+        }
+        finally {
+            this.dropAttachedSession(sessionId);
+        }
+    }
+    async continuePausedRequest(sessionId, params) {
+        const requestId = requiredCdpId(params.requestId, "Fetch.requestPaused requestId");
+        const config = this.requestHeaders;
+        const effective = config.enabled && config.headers.length > 0;
+        const request = effective && isRecord(params.request) ? params.request : {};
+        // This is a product-level baseline, not a security boundary: a caller
+        // holding the privileged native CDP endpoint can alter interception.
+        await this.host.connection.command("Fetch.continueRequest", {
+            requestId,
+            // Fetch treats `headers` as a full override. Omitting it is the only
+            // true pass-through path for disabled/empty policy and preserves
+            // Browser-managed Cookie, auth, redirect, and duplicate headers.
+            ...(effective
+                ? { headers: mergePausedRequestHeaders(pausedRequestHeaders(request.headers), config) }
+                : {}),
+        }, sessionId);
+    }
     ensureAvailable() {
         if (this.unavailableReason || this.closing || !this.host.connection.connected) {
             throw new SessionBrowserHostError("unavailable", "Headless Browser is unavailable");
@@ -729,6 +945,11 @@ class HeadlessBrowserHandle {
         this.operations = result.then(() => undefined, () => undefined);
         return result;
     }
+    networkExclusive(operation) {
+        const result = this.networkOperations.then(operation, operation);
+        this.networkOperations = result.then(() => undefined, () => undefined);
+        return result;
+    }
 }
 class HeadlessBrowserSurfaceSource {
     source;
@@ -1476,7 +1697,7 @@ class CdpConnection {
                 this.pending.delete(id);
                 rejectCommand(new CdpCommandTimeoutError(`Native CDP command ${method} timed out`));
             }, this.commandTimeoutMs);
-            this.pending.set(id, { resolve: resolveCommand, reject: rejectCommand, timer });
+            this.pending.set(id, { method, resolve: resolveCommand, reject: rejectCommand, timer });
             try {
                 this.socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
             }
@@ -1518,7 +1739,9 @@ class CdpConnection {
             this.pending.delete(value.id);
             clearTimeout(pending.timer);
             if (isRecord(value.error)) {
-                pending.reject(new CdpProtocolError(typeof value.error.code === "number" ? value.error.code : -1, typeof value.error.message === "string" ? value.error.message : "Native CDP command failed"));
+                pending.reject(new CdpProtocolError(typeof value.error.code === "number" ? value.error.code : -1, `Native CDP command ${pending.method} failed: ${typeof value.error.message === "string"
+                    ? value.error.message
+                    : "Native CDP command failed"}`));
             }
             else {
                 pending.resolve(value.result ?? {});
@@ -1887,7 +2110,7 @@ function readSmallRegularJson(path, maxBytes, label) {
         closeSync(descriptor);
     }
 }
-function chromeArguments(profileDir, ownerToken, url) {
+function chromeArguments(profileDir, ownerToken) {
     return [
         "--headless=new",
         "--use-mock-keychain",
@@ -1905,7 +2128,29 @@ function chromeArguments(profileDir, ownerToken, url) {
         "--metrics-recording-only",
         "--no-report-upload",
         "--window-size=1280,800",
-        url,
+        "--no-startup-window",
+    ];
+}
+function cloneRequestHeadersConfig(config) {
+    return {
+        enabled: config.enabled,
+        headers: config.headers.map((header) => ({ ...header })),
+    };
+}
+function pausedRequestHeaders(value) {
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value).flatMap(([name, headerValue]) => typeof headerValue === "string" ? [{ name, value: headerValue }] : []);
+}
+function mergePausedRequestHeaders(original, config) {
+    if (!config.enabled)
+        return original.map((header) => ({ ...header }));
+    const overriddenNames = new Set(config.headers.map((header) => header.name.toLowerCase()));
+    return [
+        ...original
+            .filter((header) => !overriddenNames.has(header.name.toLowerCase()))
+            .map((header) => ({ ...header })),
+        ...config.headers.map((header) => ({ ...header })),
     ];
 }
 function validateActiveExecutable(build) {
@@ -2118,6 +2363,10 @@ function isTransientPageTransitionError(error) {
         /cannot find (?:an )?execution context/i.test(error.message) ||
         /cannot find context with specified id/i.test(error.message));
 }
+function isMissingFetchRequestError(error) {
+    return error instanceof CdpProtocolError && (/invalid (?:interception|request)id/i.test(error.message) ||
+        /no resource with given identifier/i.test(error.message));
+}
 function isMissingPageError(error) {
     return (error instanceof SessionBrowserHostError && error.code === "page_not_found") || isMissingTargetError(error);
 }

package/dist/plugin-host-rpc.d.ts

@@ -1,7 +1,8 @@
 import { type AdmissionReservation, type AgentSpec, type AgentCapabilities, type AgentRuntimeId, type AgentSessionStore, type ResolvedExecutionSnapshot, type RuntimeCollaborationMode, type SessionRegistry, type SessionWorkspaceSnapshot, type SteerSignal } from "@rynx-ai/core";
 import { type PluginAgentSummary, type PluginHostEvent, type PluginSessionActivitySnapshot, type PluginResolvedSessionExecution, type PluginSessionExecutionSnapshot, type PluginSessionInteractionResolveDisposition } from "@rynx-ai/plugin-sdk";
 import type { SessionInteractionResolution } from "@rynx-ai/protocol";
-import type { MachineSessionMessageInput, StartedMachineSessionRun } from "@rynx-ai/server";
+import { type RuntimeBrowserRequestHeadersGetParams, type RuntimeBrowserRequestHeadersPolicy, type RuntimeBrowserRequestHeadersSetParams } from "@rynx-ai/protocol/runtime-browser";
+import { type MachineSessionMessageInput, type StartedMachineSessionRun } from "@rynx-ai/server";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
 export declare const MAX_PLUGIN_HOST_EVENT_BYTES: number;
@@ -48,6 +49,10 @@ export interface PluginHostServices {
     sessionFiles: {
         resolveResourcePath(sessionId: string, resourceId: string): Promise<string>;
     };
+    sessionBrowserRequestHeaders?: {
+        getRequestHeaders(input: RuntimeBrowserRequestHeadersGetParams): Promise<RuntimeBrowserRequestHeadersPolicy>;
+        setRequestHeaders(input: RuntimeBrowserRequestHeadersSetParams): Promise<RuntimeBrowserRequestHeadersPolicy>;
+    };
     capabilities: AgentCapabilities;
     sessionStore: AgentSessionStore;
     sessionRegistry: SessionRegistry;
@@ -65,6 +70,15 @@ export interface PluginHostServices {
     sessionActivity(sessionId: string): PluginSessionActivitySnapshot | Promise<PluginSessionActivitySnapshot>;
     interruptSession?(sessionId: string): Promise<boolean>;
     terminateSession?(sessionId: string): Promise<boolean>;
+    sessionTimeline?: {
+        hasItem(sessionId: string, itemId: string): Promise<boolean>;
+        projectText(input: {
+            sessionId: string;
+            responseId: string;
+            itemId: string;
+            text: string;
+        }): Promise<void>;
+    };
     resolveSessionInteraction?(sessionId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<{
         disposition: PluginSessionInteractionResolveDisposition;
     }>;
@@ -150,9 +164,12 @@ export declare class PluginHostRpc {
     private reserveAdmission;
     private withAdmission;
     private setSessionTitle;
+    private getSessionBrowserRequestHeaders;
+    private setSessionBrowserRequestHeaders;
     private resolveAgentExecution;
     private issueControlLink;
     private issueSessionPortalLink;
+    private projectTimelineText;
     private ownedSession;
     private isOwned;
 }

package/dist/plugin-host-rpc.js

@@ -3,10 +3,13 @@ import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { AgentRuntimeError, agentSpecSchema, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { PLUGIN_HOST_MAX_ACTIVE_RUNS, } from "@rynx-ai/plugin-sdk";
+import { parseRuntimeBrowserRequestHeadersGetParams, parseRuntimeBrowserRequestHeadersSetParams, } from "@rynx-ai/protocol/runtime-browser";
+import { SessionBrowserServiceError, } from "@rynx-ai/server";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
 import { ensurePluginSessionLaunch, replayPluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
 import { createControlLink } from "./control-link-store.js";
-import { issueSessionPortalTicket } from "./session-portal-grant-store.js";
+import { issueSessionPortalTicket, revokeSessionPortalGrant, } from "./session-portal-grant-store.js";
+import { claimSessionTimelineProjection, completeSessionTimelineProjection, } from "./session-timeline-projection-store.js";
 const MAX_MESSAGE_LENGTH = 1_000_000;
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
 export const MAX_PLUGIN_HOST_EVENT_BYTES = 512 * 1024;
@@ -119,6 +122,18 @@ export class PluginHostRpc {
                 capabilities: {
                     sessionRunContent: true,
                     sessionRunFiles: true,
+                    ...(this.services.sessionTimeline
+                        ? { sessionTimelineProjectText: true }
+                        : {}),
+                    ...(this.services.sessionBrowserRequestHeaders
+                        ? { sessionBrowserRequestHeaders: true }
+                        : {}),
+                    ...(this.services.sessionPortal
+                        ? {
+                            sessionPortalEmbedOrigin: true,
+                            sessionPortalGrantRevocation: true,
+                        }
+                        : {}),
                 },
                 ...(this.services.sessionPortal
                     ? { sessionPortal: { ...this.services.sessionPortal } }
@@ -176,18 +191,31 @@ export class PluginHostRpc {
                     return this.services.sessionRegistry.list().filter((session) => this.isOwned(session));
                 case "session.meta.setTitle":
                     return this.setSessionTitle(params);
+                case "session.browser.requestHeaders.get":
+                    return await this.getSessionBrowserRequestHeaders(params);
+                case "session.browser.requestHeaders.set":
+                    return await this.setSessionBrowserRequestHeaders(params);
                 case "control.link.issue":
                     return this.issueControlLink(params);
                 case "session.portal.plugin.issue": {
-                    const access = requiredSessionPortalAccess(params);
-                    return this.issueSessionPortalLink("plugin_sessions", access);
+                    const input = record(params);
+                    return this.issueSessionPortalLink("plugin_sessions", requiredSessionPortalAccess(input), undefined, optionalSessionPortalEmbedOrigin(input.embedOrigin), optionalString(input.grantHandle, "grantHandle", 128));
                 }
                 case "session.portal.session.issue": {
                     const input = record(params);
                     const sessionId = requiredSessionId(input);
                     this.ownedSession(sessionId);
-                    return this.issueSessionPortalLink("single_session", requiredSessionPortalAccess(input), sessionId);
+                    return this.issueSessionPortalLink("single_session", requiredSessionPortalAccess(input), sessionId, optionalSessionPortalEmbedOrigin(input.embedOrigin), optionalString(input.grantHandle, "grantHandle", 128));
+                }
+                case "session.portal.grant.revoke": {
+                    const grantHandle = requiredString(record(params).grantHandle, "grantHandle", 128);
+                    return revokeSessionPortalGrant({
+                        pluginId: this.principalId,
+                        grantHandle,
+                    });
                 }
+                case "session.timeline.projectText":
+                    return await this.projectTimelineText(params);
                 default:
                     throw new PluginHostCallError("METHOD_NOT_FOUND", `unknown host method: ${method}`);
             }
@@ -843,6 +871,36 @@ export class PluginHostRpc {
         this.services.sessionRegistry.setTitle(sessionId, title);
         return { updated: true };
     }
+    async getSessionBrowserRequestHeaders(params) {
+        let input;
+        try {
+            input = parseRuntimeBrowserRequestHeadersGetParams(params);
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "Session Browser request headers parameters are invalid");
+        }
+        this.ownedSession(input.sessionId);
+        const service = this.services.sessionBrowserRequestHeaders;
+        if (!service) {
+            throw new PluginHostCallError("METHOD_NOT_FOUND", "Session Browser request headers are unsupported by this Host");
+        }
+        return await service.getRequestHeaders(input);
+    }
+    async setSessionBrowserRequestHeaders(params) {
+        let input;
+        try {
+            input = parseRuntimeBrowserRequestHeadersSetParams(params);
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "Session Browser request headers parameters are invalid");
+        }
+        this.ownedSession(input.sessionId);
+        const service = this.services.sessionBrowserRequestHeaders;
+        if (!service) {
+            throw new PluginHostCallError("METHOD_NOT_FOUND", "Session Browser request headers are unsupported by this Host");
+        }
+        return await service.setRequestHeaders(input);
+    }
     resolveAgentExecution(params) {
         const input = record(params);
         const defaultAgent = optionalAgentId(input.defaultAgent, "defaultAgent");
@@ -862,7 +920,7 @@ export class PluginHostRpc {
             ...(ttlSeconds === undefined ? {} : { ttlMs: ttlSeconds * 1_000 }),
         });
     }
-    issueSessionPortalLink(scope, access, sessionId) {
+    issueSessionPortalLink(scope, access, sessionId, embedOrigin, grantHandle) {
         if (!this.services.sessionPortal) {
             throw new PluginHostCallError("HOST_CALL_FAILED", "the Session Portal is not configured");
         }
@@ -871,8 +929,47 @@ export class PluginHostRpc {
             scope,
             access,
             ...(sessionId ? { sessionId } : {}),
+            ...(embedOrigin ? { embedOrigin } : {}),
+            ...(grantHandle ? { grantHandle } : {}),
         });
     }
+    async projectTimelineText(params) {
+        const sessionTimeline = this.services.sessionTimeline;
+        if (!sessionTimeline) {
+            throw new PluginHostCallError("HOST_CALL_FAILED", "Session timeline projection is unavailable");
+        }
+        const input = record(params);
+        const sessionId = requiredSessionId(input);
+        this.ownedSession(sessionId);
+        const projection = claimSessionTimelineProjection({
+            pluginId: this.principalId,
+            sessionId,
+            projectionId: requiredString(input.projectionId, "projectionId", 256),
+            ...(input.responseId === undefined
+                ? {}
+                : { responseId: requiredString(input.responseId, "responseId", 256) }),
+            text: requiredText(input.text, "text", 64 * 1024),
+        });
+        if (!(await sessionTimeline.hasItem(sessionId, projection.itemId))) {
+            await sessionTimeline.projectText({
+                sessionId,
+                responseId: projection.responseId,
+                itemId: projection.itemId,
+                text: projection.text,
+            });
+        }
+        completeSessionTimelineProjection({
+            pluginId: this.principalId,
+            sessionId,
+            projectionId: projection.projectionId,
+        });
+        return {
+            projectionId: projection.projectionId,
+            responseId: projection.responseId,
+            itemId: projection.itemId,
+            disposition: projection.disposition,
+        };
+    }
     ownedSession(sessionId) {
         const session = this.services.sessionRegistry.get(sessionId);
         if (!session || !this.isOwned(session)) {
@@ -933,6 +1030,18 @@ export class PluginHostCallError extends PluginRunnerError {
 function toHostCallError(error) {
     if (error instanceof PluginHostCallError)
         return error;
+    if (error instanceof SessionBrowserServiceError) {
+        if (error.code === "revision_mismatch") {
+            return new PluginHostCallError("REVISION_CONFLICT", "Session Browser request headers changed since they were read");
+        }
+        if (error.code === "invalid_request") {
+            return new PluginHostCallError("INVALID_PARAMS", "Session Browser request headers parameters are invalid");
+        }
+        if (error.code === "not_found") {
+            return new PluginHostCallError("SESSION_NOT_FOUND", "plugin session not found");
+        }
+        return new PluginHostCallError("HOST_CALL_FAILED", "Session Browser request headers operation failed");
+    }
     if (error instanceof AgentRuntimeError && error.code === "live_unavailable") {
         // ConversationRuntime emits this code only before injectMessage is called:
         // the native live Session (including its exact Skill environment) could
@@ -1109,6 +1218,21 @@ function requiredSessionPortalAccess(params) {
         return access;
     throw new PluginHostCallError("INVALID_PARAMS", "access must be read_only or read_write");
 }
+function optionalSessionPortalEmbedOrigin(value) {
+    if (value === undefined)
+        return undefined;
+    const candidate = requiredString(value, "embedOrigin", 512);
+    try {
+        const parsed = new URL(candidate);
+        if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+            parsed.origin !== candidate)
+            throw new Error("invalid origin");
+        return parsed.origin;
+    }
+    catch {
+        throw new PluginHostCallError("INVALID_PARAMS", "embedOrigin must be an exact http(s) origin");
+    }
+}
 function sessionInteractionResolution(value) {
     const input = record(value);
     const keys = Object.keys(input);

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

@@ -5,6 +5,7 @@ export interface SessionPortalAuthorization {
     pluginId: string;
     scope: SessionPortalScope;
     access: SessionPortalAccess;
+    embedOrigin?: string;
     sessionId?: string;
     expiresAt: string;
 }
@@ -16,14 +17,39 @@ export declare function issueSessionPortalTicket(input: {
     scope: SessionPortalScope;
     access: SessionPortalAccess;
     sessionId?: string;
+    embedOrigin?: string;
+    grantHandle?: string;
     now?: Date;
 }): {
     path: string;
     expiresAt: string;
+    grantHandle: string;
 };
 /** Atomically consume a one-use ticket and mint a fixed-lifetime browser grant. */
-export declare function redeemSessionPortalTicket(ticket: string, now?: Date): (SessionPortalAuthorization & {
+export declare function redeemSessionPortalTicket(ticket: string, now?: Date, embedOrigin?: string): (SessionPortalAuthorization & {
     secret: string;
 }) | undefined;
+/** Read the public, still-active half of a grant without accepting its secret.
+ * Used only to bind an embedded SPA bootstrap and transport lifecycle to the
+ * exact grant that was issued; it does not authorize an API call. */
+export declare function inspectSessionPortalGrant(portalId: string, now?: Date): SessionPortalAuthorization | undefined;
 export declare function authorizeSessionPortalGrant(portalId: string, secret: string, now?: Date): SessionPortalAuthorization | undefined;
+/** Revoke one issued Portal link, whether its ticket is still unused or it has
+ * already become a browser grant. The opaque handle carries no product meaning. */
+export declare function revokeSessionPortalGrant(input: {
+    pluginId: string;
+    grantHandle: string;
+    now?: Date;
+}): Promise<{
+    revoked: boolean;
+}>;
+/** Subscribe to committed grant revocations. The notification is emitted only
+ * after SQLite commits, so a listener may synchronously tear down every
+ * transport admitted under the revoked portal id. */
+export declare function onSessionPortalGrantRevoked(listener: (portalIds: readonly string[]) => void | Promise<void>): () => void;
+/** Embedded writable grants are process-generation capabilities. A daemon
+ * restart has no surviving transport to drain and Plugin recovery may fail, so
+ * fail closed before the Portal listener is reopened; ordinary non-embedded
+ * Portal links retain their historical fixed-lifetime behavior. */
+export declare function revokeEmbeddedWritableSessionPortalGrants(now?: Date): void;
 export declare function pruneSessionPortalAuthorization(now?: Date): void;

package/dist/session-portal-grant-store.js

@@ -3,6 +3,7 @@ import { db } from "./db.js";
 import { transaction } from "./sqlite.js";
 const TICKET_TTL_MS = 5 * 60 * 1_000;
 const GRANT_TTL_MS = 30 * 60 * 1_000;
+const revocationListeners = new Set();
 /** 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. */
@@ -13,24 +14,34 @@ export function issueSessionPortalTicket(input) {
     const now = input.now ?? new Date();
     const expiresAt = new Date(now.getTime() + TICKET_TTL_MS).toISOString();
     const ticket = randomToken();
+    const grantHandle = input.grantHandle ?? randomUUID();
     pruneSessionPortalAuthorization(now);
     db().prepare(`INSERT INTO session_portal_tickets
-       (ticket_hash, plugin_id, scope, access, session_id, created_at, expires_at, used_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, NULL)`).run(hash(ticket), input.pluginId, input.scope, input.access, input.sessionId ?? null, now.toISOString(), expiresAt);
+       (ticket_hash, plugin_id, scope, access, session_id, created_at, expires_at, used_at,
+        grant_handle, embed_origin)
+     VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(hash(ticket), input.pluginId, input.scope, input.access, input.sessionId ?? null, now.toISOString(), expiresAt, grantHandle, input.embedOrigin ?? null);
+    const redeem = new URL("/session-portal/redeem", "http://session-portal.invalid");
+    if (input.embedOrigin)
+        redeem.searchParams.set("embed_origin", input.embedOrigin);
     return {
-        path: `/session-portal/redeem#ticket=${encodeURIComponent(ticket)}`,
+        path: `${redeem.pathname}${redeem.search}#ticket=${encodeURIComponent(ticket)}`,
         expiresAt,
+        grantHandle,
     };
 }
 /** Atomically consume a one-use ticket and mint a fixed-lifetime browser grant. */
-export function redeemSessionPortalTicket(ticket, now = new Date()) {
+export function redeemSessionPortalTicket(ticket, now = new Date(), embedOrigin) {
     const connection = db();
     return transaction(connection, () => {
         const ticketHash = hash(ticket);
-        const row = connection.prepare(`SELECT plugin_id, scope, access, session_id, expires_at, used_at
+        const row = connection.prepare(`SELECT plugin_id, scope, access, session_id, expires_at, used_at,
+              grant_handle, embed_origin
          FROM session_portal_tickets
         WHERE ticket_hash = ?`).get(ticketHash);
-        if (!row || row.used_at !== null || row.expires_at <= now.toISOString())
+        if (!row ||
+            row.used_at !== null ||
+            row.expires_at <= now.toISOString() ||
+            (row.embed_origin ?? "") !== (embedOrigin ?? ""))
             return undefined;
         const consumed = connection.prepare(`UPDATE session_portal_tickets SET used_at = ?
         WHERE ticket_hash = ? AND used_at IS NULL AND expires_at > ?`).run(now.toISOString(), ticketHash, now.toISOString());
@@ -40,21 +51,36 @@ export function redeemSessionPortalTicket(ticket, now = new Date()) {
         const secret = randomToken();
         const expiresAt = new Date(now.getTime() + GRANT_TTL_MS).toISOString();
         connection.prepare(`INSERT INTO session_portal_grants
-         (portal_id, secret_hash, plugin_id, scope, access, session_id, created_at, expires_at, revoked_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`).run(portalId, hash(secret), row.plugin_id, row.scope, row.access, row.session_id, now.toISOString(), expiresAt);
+         (portal_id, secret_hash, plugin_id, scope, access, session_id, created_at, expires_at,
+          revoked_at, grant_handle, embed_origin)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`).run(portalId, hash(secret), row.plugin_id, row.scope, row.access, row.session_id, now.toISOString(), expiresAt, row.grant_handle, row.embed_origin);
         return {
             portalId,
             secret,
             pluginId: row.plugin_id,
             scope: row.scope,
             access: row.access,
+            ...(row.embed_origin ? { embedOrigin: row.embed_origin } : {}),
             ...(row.session_id ? { sessionId: row.session_id } : {}),
             expiresAt,
         };
     })();
 }
+/** Read the public, still-active half of a grant without accepting its secret.
+ * Used only to bind an embedded SPA bootstrap and transport lifecycle to the
+ * exact grant that was issued; it does not authorize an API call. */
+export function inspectSessionPortalGrant(portalId, now = new Date()) {
+    const row = db().prepare(`SELECT portal_id, secret_hash, plugin_id, scope, access, session_id, expires_at, revoked_at,
+            grant_handle, embed_origin
+       FROM session_portal_grants
+      WHERE portal_id = ?`).get(portalId);
+    if (!row || row.revoked_at !== null || row.expires_at <= now.toISOString())
+        return undefined;
+    return publicGrant(row);
+}
 export function authorizeSessionPortalGrant(portalId, secret, now = new Date()) {
-    const row = db().prepare(`SELECT portal_id, secret_hash, plugin_id, scope, access, session_id, expires_at, revoked_at
+    const row = db().prepare(`SELECT portal_id, secret_hash, plugin_id, scope, access, session_id, expires_at, revoked_at,
+            grant_handle, embed_origin
        FROM session_portal_grants
       WHERE portal_id = ?`).get(portalId);
     if (!row || row.revoked_at !== null || row.expires_at <= now.toISOString())
@@ -63,14 +89,52 @@ export function authorizeSessionPortalGrant(portalId, secret, now = new Date())
     const expected = Buffer.from(row.secret_hash, "hex");
     if (actual.length !== expected.length || !timingSafeEqual(actual, expected))
         return undefined;
-    return {
-        portalId: row.portal_id,
-        pluginId: row.plugin_id,
-        scope: row.scope,
-        access: row.access,
-        ...(row.session_id ? { sessionId: row.session_id } : {}),
-        expiresAt: row.expires_at,
-    };
+    return publicGrant(row);
+}
+/** Revoke one issued Portal link, whether its ticket is still unused or it has
+ * already become a browser grant. The opaque handle carries no product meaning. */
+export async function revokeSessionPortalGrant(input) {
+    const now = input.now ?? new Date();
+    const connection = db();
+    const result = transaction(connection, () => {
+        const portalIds = connection.prepare(`SELECT portal_id FROM session_portal_grants
+        WHERE plugin_id = ? AND grant_handle = ? AND revoked_at IS NULL`).all(input.pluginId, input.grantHandle);
+        const tickets = connection.prepare(`UPDATE session_portal_tickets SET used_at = ?
+        WHERE plugin_id = ? AND grant_handle = ? AND used_at IS NULL`).run(now.toISOString(), input.pluginId, input.grantHandle);
+        const grants = connection.prepare(`UPDATE session_portal_grants SET revoked_at = ?
+        WHERE plugin_id = ? AND grant_handle = ? AND revoked_at IS NULL`).run(now.toISOString(), input.pluginId, input.grantHandle);
+        return {
+            revoked: tickets.changes > 0 || grants.changes > 0,
+            portalIds: portalIds.map((row) => row.portal_id),
+        };
+    })();
+    if (result.portalIds.length > 0) {
+        // Revocation is a barrier, not merely a database flag. Host RPC returns
+        // only after every Portal transport admitted under the committed grant has
+        // been aborted and drained.
+        await Promise.all([...revocationListeners].map((listener) => listener(result.portalIds)));
+    }
+    return { revoked: result.revoked };
+}
+/** Subscribe to committed grant revocations. The notification is emitted only
+ * after SQLite commits, so a listener may synchronously tear down every
+ * transport admitted under the revoked portal id. */
+export function onSessionPortalGrantRevoked(listener) {
+    revocationListeners.add(listener);
+    return () => revocationListeners.delete(listener);
+}
+/** Embedded writable grants are process-generation capabilities. A daemon
+ * restart has no surviving transport to drain and Plugin recovery may fail, so
+ * fail closed before the Portal listener is reopened; ordinary non-embedded
+ * Portal links retain their historical fixed-lifetime behavior. */
+export function revokeEmbeddedWritableSessionPortalGrants(now = new Date()) {
+    const connection = db();
+    transaction(connection, () => {
+        connection.prepare(`UPDATE session_portal_tickets SET used_at=?
+        WHERE access='read_write' AND embed_origin IS NOT NULL AND used_at IS NULL`).run(now.toISOString());
+        connection.prepare(`UPDATE session_portal_grants SET revoked_at=?
+        WHERE access='read_write' AND embed_origin IS NOT NULL AND revoked_at IS NULL`).run(now.toISOString());
+    })();
 }
 export function pruneSessionPortalAuthorization(now = new Date()) {
     const connection = db();
@@ -83,3 +147,14 @@ function randomToken() {
 function hash(value) {
     return createHash("sha256").update(value, "utf8").digest("hex");
 }
+function publicGrant(row) {
+    return {
+        portalId: row.portal_id,
+        pluginId: row.plugin_id,
+        scope: row.scope,
+        access: row.access,
+        ...(row.embed_origin ? { embedOrigin: row.embed_origin } : {}),
+        ...(row.session_id ? { sessionId: row.session_id } : {}),
+        expiresAt: row.expires_at,
+    };
+}

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

@@ -28,6 +28,10 @@ export declare class SqliteSessionResourceStore implements MachineSessionResourc
     markMessageInjected(sessionId: string, clientMessageId: string, identity?: {
         responseId: string;
     }): void;
+    markMessageMirrored(sessionId: string, clientMessageId: string, identity: {
+        responseId: string;
+        messageItemId: string;
+    }): void;
     markMessageOutcomeUnknown(sessionId: string, clientMessageId: string, reason: string): void;
     markMessageFailedNotStarted(sessionId: string, clientMessageId: string, reason: string): void;
     deleteSession(sessionId: string): void;

package/dist/session-resource-store.js

@@ -347,6 +347,28 @@ export class SqliteSessionResourceStore {
               response_id = COALESCE(response_id, ?),
               updated_at = ?
         WHERE session_id = ? AND client_message_id = ? AND state = 'injecting'`).run(identity?.responseId ?? null, Date.now(), sessionId, clientMessageId);
+        if (result.changes !== 1 && current.state !== "mirrored") {
+            throw conflict("Message operation state changed");
+        }
+    }
+    markMessageMirrored(sessionId, clientMessageId, identity) {
+        const current = db().prepare(`SELECT state, response_id, message_item_id
+         FROM session_message_operations
+        WHERE session_id = ? AND client_message_id = ?`).get(sessionId, clientMessageId);
+        if (!current ||
+            (current.response_id && current.response_id !== identity.responseId) ||
+            (current.message_item_id && current.message_item_id !== identity.messageItemId)) {
+            throw conflict("Message operation identity changed");
+        }
+        if (current.state === "mirrored")
+            return;
+        const result = db().prepare(`UPDATE session_message_operations
+          SET state = 'mirrored', error = NULL,
+              response_id = COALESCE(response_id, ?),
+              message_item_id = COALESCE(message_item_id, ?),
+              updated_at = ?
+        WHERE session_id = ? AND client_message_id = ?
+          AND state IN ('injecting', 'injected', 'outcome_unknown')`).run(identity.responseId, identity.messageItemId, Date.now(), sessionId, clientMessageId);
         if (result.changes !== 1)
             throw conflict("Message operation state changed");
     }

package/dist/session-timeline-projection-store.d.ts

@@ -0,0 +1,24 @@
+export interface SessionTimelineProjection {
+    pluginId: string;
+    sessionId: string;
+    projectionId: string;
+    responseId: string;
+    itemId: string;
+    text: string;
+    state: "pending" | "completed";
+    disposition: "created" | "replayed";
+}
+/** Durable identity for a narrow text projection. The text itself deliberately
+ * stays in the canonical Session item; this row only fences retries. */
+export declare function claimSessionTimelineProjection(input: {
+    pluginId: string;
+    sessionId: string;
+    projectionId: string;
+    responseId?: string;
+    text: string;
+}): SessionTimelineProjection;
+export declare function completeSessionTimelineProjection(input: {
+    pluginId: string;
+    sessionId: string;
+    projectionId: string;
+}): void;

package/dist/session-timeline-projection-store.js

@@ -0,0 +1,53 @@
+import { createHash, randomUUID } from "node:crypto";
+import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
+/** Durable identity for a narrow text projection. The text itself deliberately
+ * stays in the canonical Session item; this row only fences retries. */
+export function claimSessionTimelineProjection(input) {
+    const connection = db();
+    const requestHash = createHash("sha256")
+        .update(JSON.stringify({ responseId: input.responseId ?? null, text: input.text }), "utf8")
+        .digest("hex");
+    return transaction(connection, () => {
+        const existing = connection.prepare(`SELECT plugin_id, session_id, projection_id, request_hash, response_id, item_id, state
+         FROM session_timeline_projections
+        WHERE plugin_id = ? AND session_id = ? AND projection_id = ?`).get(input.pluginId, input.sessionId, input.projectionId);
+        if (existing) {
+            if (existing.request_hash !== requestHash) {
+                throw new Error("projection id was reused with different text");
+            }
+            return present(existing, input.text, "replayed");
+        }
+        const responseId = input.responseId?.trim() || `projection_response_${input.projectionId}`;
+        const itemId = `msg_projection_${randomUUID()}`;
+        connection.prepare(`INSERT INTO session_timeline_projections
+         (plugin_id, session_id, projection_id, request_hash, response_id, item_id, state, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, 'pending', ?)`).run(input.pluginId, input.sessionId, input.projectionId, requestHash, responseId, itemId, new Date().toISOString());
+        return {
+            pluginId: input.pluginId,
+            sessionId: input.sessionId,
+            projectionId: input.projectionId,
+            responseId,
+            itemId,
+            text: input.text,
+            state: "pending",
+            disposition: "created",
+        };
+    })();
+}
+export function completeSessionTimelineProjection(input) {
+    db().prepare(`UPDATE session_timeline_projections SET state = 'completed'
+      WHERE plugin_id = ? AND session_id = ? AND projection_id = ?`).run(input.pluginId, input.sessionId, input.projectionId);
+}
+function present(row, text, disposition) {
+    return {
+        pluginId: row.plugin_id,
+        sessionId: row.session_id,
+        projectionId: row.projection_id,
+        responseId: row.response_id,
+        itemId: row.item_id,
+        text,
+        state: row.state,
+        disposition,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.30",
+  "version": "0.1.11-beta.31",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -50,17 +50,17 @@
     "pm2": "^6.0.0",
     "tar": "^7.5.19",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.30",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.30",
-    "@rynx-ai/emulator": "0.1.11-beta.30",
-    "@rynx-ai/protocol": "0.1.11-beta.30",
-    "@rynx-ai/remote-runtime-client": "0.1.11-beta.30",
-    "@rynx-ai/plugin-runner": "0.1.11-beta.30",
-    "@rynx-ai/server": "0.1.11-beta.30"
+    "@rynx-ai/plugin-runner": "0.1.11-beta.31",
+    "@rynx-ai/emulator": "0.1.11-beta.31",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.31",
+    "@rynx-ai/protocol": "0.1.11-beta.31",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.31",
+    "@rynx-ai/server": "0.1.11-beta.31",
+    "@rynx-ai/core": "0.1.11-beta.31"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.30"
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.31"
   },
   "scripts": {
     "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",