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

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.32",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -49,18 +49,19 @@
     "@electron-internal/extract-zip": "1.0.5",
     "pm2": "^6.0.0",
     "tar": "^7.5.19",
+    "undici": "^7.28.0",
     "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/core": "0.1.11-beta.32",
+    "@rynx-ai/emulator": "0.1.11-beta.32",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.32",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.32",
+    "@rynx-ai/protocol": "0.1.11-beta.32",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.32",
+    "@rynx-ai/server": "0.1.11-beta.32"
   },
   "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.32"
   },
   "scripts": {
     "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",