@dinoxx/dinox-cli 2.3.0 → 2.4.0

package/dist/gateway/streamPublisher.js

@@ -0,0 +1,93 @@
+import { REMOTE_DEVICE_MAX_EVENT_BYTES, REMOTE_DEVICE_PROTOCOL_VERSION, } from '../vendor/electron/shared/remote-device-agent.js';
+import { TERMINAL_RUN_STATUSES } from './threadStore.js';
+const COALESCE_MS = 100;
+const MAX_APPROVALS = 32;
+function byteLength(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+/**
+ * Keeps an event under the NATS payload budget: drop parts (the snapshot is
+ * self-correcting and `run.status` recovers the rest), then drop extras.
+ */
+export function boundRunEvent(event) {
+    if (byteLength(event) <= REMOTE_DEVICE_MAX_EVENT_BYTES)
+        return event;
+    const metadata = event.assistant.message.metadata ?? {};
+    const stripped = {
+        ...event,
+        assistant: {
+            message: {
+                ...event.assistant.message,
+                parts: [],
+                metadata: { status: metadata.status, runId: metadata.runId },
+            },
+            truncated: true,
+        },
+        pendingApprovals: event.pendingApprovals?.slice(0, MAX_APPROVALS),
+    };
+    if (byteLength(stripped) <= REMOTE_DEVICE_MAX_EVENT_BYTES)
+        return stripped;
+    const minimal = { ...stripped, pendingApprovals: [], usage: null };
+    if (byteLength(minimal) <= REMOTE_DEVICE_MAX_EVENT_BYTES)
+        return minimal;
+    throw new Error('run.event exceeds the remote-device payload limit');
+}
+/**
+ * One per run. Streaming snapshots are coalesced to the latest per 100ms;
+ * approval and terminal states go out immediately (and supersede a pending one).
+ */
+export class RunStreamPublisher {
+    ids;
+    publish;
+    sequence = 0;
+    pending = null;
+    timer = null;
+    disposed = false;
+    constructor(ids, publish) {
+        this.ids = ids;
+        this.publish = publish;
+    }
+    push(snapshot) {
+        if (this.disposed)
+            return;
+        if (TERMINAL_RUN_STATUSES.has(snapshot.status) || snapshot.status === 'waiting_approval') {
+            this.clearTimer();
+            this.pending = null;
+            this.emit(snapshot);
+            return;
+        }
+        this.pending = snapshot;
+        this.timer ??= setTimeout(() => {
+            this.timer = null;
+            const latest = this.pending;
+            this.pending = null;
+            if (latest)
+                this.emit(latest);
+        }, COALESCE_MS);
+    }
+    dispose() {
+        this.disposed = true;
+        this.clearTimer();
+        this.pending = null;
+    }
+    clearTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    emit(snapshot) {
+        this.sequence += 1;
+        this.publish(boundRunEvent({
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'run.event',
+            runId: this.ids.runId,
+            threadId: this.ids.threadId,
+            sequence: this.sequence,
+            emittedAt: new Date().toISOString(),
+            revision: snapshot.revision,
+            status: snapshot.status,
+            assistant: { message: snapshot.assistant },
+            pendingApprovals: snapshot.pendingApprovals,
+        }));
+    }
+}

package/dist/gateway/threadStore.d.ts

@@ -0,0 +1,157 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { ChatUIMessage, ThreadRunCreateThreadRequest, ThreadRunEventStatus } from '../vendor/electron/shared/external-types.js';
+/**
+ * Persistence for gateway runs, written exactly like Dinox desktop's remote host
+ * (dinox-electron ThreadRunQueueService / ThreadRunCoordinatorHelpers) so every
+ * client reads identical rows:
+ * - the user message is written when the run is accepted;
+ * - live progress stays in the local-only `local_thread_run` snapshot;
+ * - the assistant message lands in `c_chat_message` once, when the run ends.
+ */
+type Tx = Pick<AbstractPowerSyncDatabase, 'execute' | 'getOptional' | 'getAll'>;
+export declare const TERMINAL_RUN_STATUSES: ReadonlySet<ThreadRunEventStatus>;
+export type StoredRun = {
+    id: string;
+    threadId: string;
+    status: ThreadRunEventStatus;
+    requestId: string | null;
+    assistant: ChatUIMessage | null;
+    updatedAt: string | null;
+};
+/** Mirrors desktop `withRunMetadata`: the UI reads `metadata.status` for streaming state. */
+export declare function withRunMetadata(message: ChatUIMessage, runId: string, status: ThreadRunEventStatus): ChatUIMessage;
+/**
+ * Synced queue marker on a user message (`metadata.queue`), shared by every
+ * client: the run that answers it has not started yet. It lives on the synced
+ * message because run rows (`local_thread_run`) are local to one process, so
+ * other devices could not otherwise show the queue. Removed when the run starts.
+ */
+export type MessageQueueMarker = {
+    state: 'queued' | 'withdrawn';
+    runId: string;
+    executor: 'gateway';
+    queuedAt: string;
+};
+/** The answering run merged this turn into a later one; it never gets its own reply. */
+export declare function withMergedInto(message: ChatUIMessage, mergedIntoRunId: string): ChatUIMessage;
+/** Next `order_index` after `parentId` (midpoint before its next sibling) or at the end. */
+export declare function resolveNextOrderIndex(tx: Tx, input: {
+    threadId: string;
+    parentId: string | null;
+}): Promise<number>;
+export declare function threadExists(db: Tx, threadId: string, userId: string): Promise<boolean>;
+export type EnqueueRunInput = {
+    runId: string;
+    threadId: string;
+    userId: string;
+    requestId: string;
+    userMessage: ChatUIMessage;
+    assistantMessage: ChatUIMessage;
+    parentMessageId: string | null;
+    createThread: ThreadRunCreateThreadRequest | null;
+    requestPayload: Record<string, unknown>;
+    /** Waits behind another turn of the same thread: marks the user message as queued. */
+    queued: boolean;
+    /** FIFO order within the thread. */
+    queueIndex: number;
+    /**
+     * Parent of a queued turn: the reply still being written, or the turn queued
+     * just before it. Absent for a turn that runs now, which follows the thread's
+     * last message.
+     */
+    queuedAfterMessageId?: string;
+};
+/** Persists the accepted turn atomically: thread (if new), user message, queued run. */
+export declare function enqueueRun(db: AbstractPowerSyncDatabase, input: EnqueueRunInput): Promise<{
+    threadCreated: boolean;
+}>;
+/** Live progress for `run.status` recovery; never touches synced tables. */
+export declare function updateRunSnapshot(db: Tx, input: {
+    runId: string;
+    status: ThreadRunEventStatus;
+    assistant: ChatUIMessage;
+}): Promise<void>;
+/** Ends the run and writes the final assistant message into the synced transcript. */
+export declare function commitRunTerminal(db: AbstractPowerSyncDatabase, input: {
+    runId: string;
+    threadId: string;
+    userId: string;
+    userMessageId: string;
+    status: ThreadRunEventStatus;
+    assistant: ChatUIMessage;
+    errorText: string | null;
+}): Promise<void>;
+export declare function findRun(db: Tx, input: {
+    runId: string;
+    userId: string;
+}): Promise<StoredRun | null>;
+/** The queued turns start now: their messages stop showing as queued. */
+export declare function startQueuedRuns(db: AbstractPowerSyncDatabase, userMessageIds: string[]): Promise<void>;
+/** Ends a queued turn that was merged into a later one: no reply of its own is written. */
+export declare function finishMergedRun(db: Tx, input: {
+    runId: string;
+    mergedIntoRunId: string;
+    assistant: ChatUIMessage;
+}): Promise<ChatUIMessage>;
+/**
+ * The user took a queued turn back before it ran: the run is cancelled and its
+ * message removed from the transcript (marked `withdrawn` so other devices can
+ * tell a withdrawal from a deletion).
+ */
+export declare function withdrawQueuedRun(db: AbstractPowerSyncDatabase, input: {
+    runId: string;
+    userMessageId: string;
+    assistant: ChatUIMessage;
+}): Promise<ChatUIMessage>;
+/** Runs left non-terminal by a previous process can never finish; mark them interrupted. */
+export declare function interruptOrphanedRuns(db: Tx, userId: string): Promise<number>;
+/** Agent session bound to a thread, scoped to the thread's current topic. */
+export type GatewaySessionBinding = {
+    sessionId: string;
+    topicId: string | null;
+    gatewayId: string;
+};
+export declare function readSessionBinding(db: Tx, threadId: string): Promise<GatewaySessionBinding | null>;
+export declare function writeSessionBinding(db: Tx, threadId: string, binding: GatewaySessionBinding): Promise<void>;
+/**
+ * The thread's current topic: the latest "new topic" marker the app wrote
+ * (`entry_type = 'internal'`, `meta_data.kind = 'context_reset'`). A new topic
+ * starts a fresh agent session.
+ */
+export declare function readCurrentTopicId(db: Tx, threadId: string): Promise<string | null>;
+/** File parts resolve only to resources this user owns with an https storage URL. */
+export declare function resolveTrustedResource(db: Tx, input: {
+    resourceId: string;
+    userId: string;
+}): Promise<{
+    url: string;
+    name: string;
+    mediaType: string | null;
+} | null>;
+/** Registers the gateway as a `c_robot` the app can list and bind agents to (no secrets). */
+export type RobotRegistration = {
+    id: string;
+    userId: string;
+    name: string;
+    deviceId: string;
+    agentType: string;
+    cwd: string | null;
+    /** This machine's hostname, shown with the robot. */
+    deviceName: string;
+    /** Marks the robot as hosted by this installation, for reconciliation. */
+    machineId: string;
+    agentId?: string;
+};
+export declare function upsertRobot(db: Tx, input: RobotRegistration): Promise<void>;
+/**
+ * Soft-deletes this machine's gateway robots that are no longer configured
+ * (removed, or replaced before ids were deterministic), so the app never
+ * offers an agent that nothing hosts. Robots from other machines are untouched.
+ */
+export declare function retireRemovedRobots(db: Tx, input: {
+    userId: string;
+    machineId: string;
+    keepIds: string[];
+}): Promise<string[]>;
+export declare function softDeleteRobot(db: Tx, robotId: string): Promise<void>;
+export {};

package/dist/gateway/threadStore.js

@@ -0,0 +1,430 @@
+import { withPowerSyncWriteTransaction } from '../powersync/runtime.js';
+const THREAD_CHAT_TYPE = 'thread';
+const MESSAGE_ENTRY_TYPE = 'message';
+const LEGACY_MESSAGE_ENTRY_TYPE = 'thread';
+const CONTEXT_RESET_ENTRY_TYPE = 'internal';
+const CHAT_MESSAGE_VERSION = 'v1';
+const ORDER_INDEX_STEP = 1024;
+const RUN_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const MESSAGE_ENTRY_FILTER = '(entry_type IS NULL OR entry_type = \'\' OR entry_type = ? OR entry_type = ?)';
+export const TERMINAL_RUN_STATUSES = new Set([
+    'succeeded',
+    'failed',
+    'cancelled',
+    'interrupted',
+    'expired',
+]);
+function safeJson(value) {
+    return JSON.stringify(value ?? null);
+}
+function parseJson(value) {
+    if (typeof value !== 'string' || !value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function toOrderIndex(value) {
+    const parsed = typeof value === 'string' ? Number(value) : value;
+    return typeof parsed === 'number' && Number.isSafeInteger(parsed) ? parsed : null;
+}
+/** Mirrors desktop `withRunMetadata`: the UI reads `metadata.status` for streaming state. */
+export function withRunMetadata(message, runId, status) {
+    const uiStatus = status === 'succeeded' || status === 'waiting_approval'
+        ? 'done'
+        : TERMINAL_RUN_STATUSES.has(status)
+            ? 'error'
+            : 'streaming';
+    return { ...message, metadata: { ...(message.metadata ?? {}), runId, status: uiStatus } };
+}
+function withQueueMarker(message, marker) {
+    const { queue: _previous, ...metadata } = (message.metadata ?? {});
+    return { ...message, metadata: marker ? { ...metadata, queue: marker } : metadata };
+}
+/** The answering run merged this turn into a later one; it never gets its own reply. */
+export function withMergedInto(message, mergedIntoRunId) {
+    return { ...message, metadata: { ...(message.metadata ?? {}), mergedIntoRunId } };
+}
+function messageCreatedAt(message, fallback) {
+    const raw = message.metadata?.createTime;
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return new Date(raw).toISOString();
+    if (typeof raw === 'string' && raw.trim())
+        return raw;
+    return fallback;
+}
+/** Next `order_index` after `parentId` (midpoint before its next sibling) or at the end. */
+export async function resolveNextOrderIndex(tx, input) {
+    const row = await tx.getOptional(`SELECT MAX(order_index) AS max_order_index, COUNT(*) AS message_count,
+       (SELECT order_index FROM c_chat_message
+         WHERE id = ? AND type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}
+         LIMIT 1) AS parent_order_index
+     FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}`, [
+        input.parentId ?? '',
+        THREAD_CHAT_TYPE,
+        input.threadId,
+        MESSAGE_ENTRY_TYPE,
+        LEGACY_MESSAGE_ENTRY_TYPE,
+        THREAD_CHAT_TYPE,
+        input.threadId,
+        MESSAGE_ENTRY_TYPE,
+        LEGACY_MESSAGE_ENTRY_TYPE,
+    ]);
+    const maxOrderIndex = toOrderIndex(row?.max_order_index);
+    const parentOrderIndex = toOrderIndex(row?.parent_order_index);
+    const countBased = Math.max(0, Number(row?.message_count ?? 0)) * ORDER_INDEX_STEP;
+    if (parentOrderIndex != null) {
+        const next = await tx.getOptional(`SELECT MIN(order_index) AS next_order_index FROM c_chat_message
+       WHERE type = ? AND source_id = ? AND deleted_at IS NULL AND order_index > ? AND ${MESSAGE_ENTRY_FILTER}`, [THREAD_CHAT_TYPE, input.threadId, parentOrderIndex, MESSAGE_ENTRY_TYPE, LEGACY_MESSAGE_ENTRY_TYPE]);
+        const nextOrderIndex = toOrderIndex(next?.next_order_index);
+        if (nextOrderIndex != null && nextOrderIndex - parentOrderIndex > 1) {
+            return parentOrderIndex + Math.floor((nextOrderIndex - parentOrderIndex) / 2);
+        }
+    }
+    return Math.max(maxOrderIndex ?? 0, parentOrderIndex ?? 0, countBased) + ORDER_INDEX_STEP;
+}
+/**
+ * The thread's last message, by transcript order. A new turn is appended after
+ * it: what the client believed was last can be stale or out of order (another
+ * device, a lagging sync, a display glitch), and trusting it would splice the
+ * turn into the middle of the conversation.
+ */
+async function resolveThreadTail(tx, threadId) {
+    const row = await tx.getOptional(`SELECT id FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}
+     ORDER BY order_index DESC, created_at DESC, id DESC LIMIT 1`, [THREAD_CHAT_TYPE, threadId, MESSAGE_ENTRY_TYPE, LEGACY_MESSAGE_ENTRY_TYPE]);
+    return row?.id ?? null;
+}
+export async function threadExists(db, threadId, userId) {
+    const row = await db.getOptional('SELECT id FROM c_thread WHERE id = ? AND user_id = ? AND is_del = 0 LIMIT 1', [threadId, userId]);
+    return Boolean(row?.id);
+}
+/** Creates (or revives) the thread a remote run targets. Returns true when a row was written. */
+async function ensureThread(tx, input, now) {
+    const existing = await tx.getOptional('SELECT id, is_del FROM c_thread WHERE id = ? LIMIT 1', [input.id]);
+    if (existing?.id && Number(existing.is_del) !== 1)
+        return false;
+    const name = (input.name ?? '').trim().slice(0, 120) || 'Untitled';
+    const values = [
+        name,
+        input.kind || 'chat',
+        input.userId,
+        input.projectId ?? null,
+        now,
+        now,
+        safeJson(input.metaData ?? {}),
+        input.cmdId ?? null,
+        safeJson(input.config ?? {}),
+    ];
+    if (existing?.id) {
+        await tx.execute(`UPDATE c_thread SET name = ?, kind = ?, user_id = ?, project_id = ?, last_opened_at = ?, updated_at = ?,
+         meta_data = ?, cmd_id = ?, config = ?, filter_condition = '{}', snapshot = '{}', memory = '{}',
+         is_del = 0, robot_session_id = NULL, compact_context = NULL
+       WHERE id = ?`, [...values, input.id]);
+        return true;
+    }
+    await tx.execute(`INSERT INTO c_thread (id, name, kind, user_id, project_id, last_opened_at, updated_at, meta_data, cmd_id, config,
+       created_at, messages, pinned_at, filter_condition, snapshot, memory, is_del, robot_session_id, compact_context)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '[]', NULL, '{}', '{}', '{}', 0, NULL, NULL)`, [input.id, ...values, now]);
+    return true;
+}
+async function writeChatMessage(tx, input) {
+    const existing = await tx.getOptional('SELECT id, order_index FROM c_chat_message WHERE id = ? LIMIT 1', [input.message.id]);
+    const orderIndex = toOrderIndex(existing?.order_index) ??
+        (await resolveNextOrderIndex(tx, { threadId: input.threadId, parentId: input.parentId }));
+    if (existing?.id) {
+        await tx.execute(`UPDATE c_chat_message SET role = ?, type = ?, entry_type = ?, source_id = ?, parent_id = ?, content = ?,
+         updated_at = ?, order_index = ?, version = ?, user_id = ?, deleted_at = NULL
+       WHERE id = ?`, [
+            input.message.role,
+            THREAD_CHAT_TYPE,
+            MESSAGE_ENTRY_TYPE,
+            input.threadId,
+            input.parentId,
+            safeJson(input.message),
+            input.updatedAt,
+            orderIndex,
+            CHAT_MESSAGE_VERSION,
+            input.userId,
+            input.message.id,
+        ]);
+        return;
+    }
+    await tx.execute(`INSERT INTO c_chat_message (id, role, type, entry_type, source_id, parent_id, content, created_at, updated_at,
+       order_index, meta_data, version, user_id, deleted_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, NULL)`, [
+        input.message.id,
+        input.message.role,
+        THREAD_CHAT_TYPE,
+        MESSAGE_ENTRY_TYPE,
+        input.threadId,
+        input.parentId,
+        safeJson(input.message),
+        input.createdAt,
+        input.updatedAt,
+        orderIndex,
+        CHAT_MESSAGE_VERSION,
+        input.userId,
+    ]);
+}
+/** Persists the accepted turn atomically: thread (if new), user message, queued run. */
+export async function enqueueRun(db, input) {
+    const now = new Date().toISOString();
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const threadCreated = input.createThread
+            ? await ensureThread(tx, { ...input.createThread, userId: input.userId }, now)
+            : false;
+        const createdAt = messageCreatedAt(input.userMessage, now);
+        const parentId = input.queuedAfterMessageId ?? (await resolveThreadTail(tx, input.threadId)) ?? input.parentMessageId;
+        const userMessage = input.queued
+            ? withQueueMarker(input.userMessage, { state: 'queued', runId: input.runId, executor: 'gateway', queuedAt: now })
+            : input.userMessage;
+        await writeChatMessage(tx, {
+            threadId: input.threadId,
+            userId: input.userId,
+            message: userMessage,
+            parentId,
+            createdAt,
+            updatedAt: createdAt,
+        });
+        await tx.execute(`INSERT INTO local_thread_run (id, thread_id, user_id, status, trigger, user_message_id, assistant_message_id,
+         parent_message_id, queued_at, permission_mode, request_payload_json, assistant_snapshot_json, queue_index,
+         created_at, updated_at)
+       VALUES (?, ?, ?, 'queued', 'submit-message', ?, ?, ?, ?, 'default', ?, ?, ?, ?, ?)`, [
+            input.runId,
+            input.threadId,
+            input.userId,
+            input.userMessage.id,
+            input.assistantMessage.id,
+            parentId,
+            now,
+            safeJson({ ...input.requestPayload, metadata: { remoteDevice: { requestId: input.requestId } } }),
+            safeJson(withRunMetadata(input.assistantMessage, input.runId, 'queued')),
+            input.queueIndex,
+            now,
+            now,
+        ]);
+        return { threadCreated };
+    });
+}
+/** Live progress for `run.status` recovery; never touches synced tables. */
+export async function updateRunSnapshot(db, input) {
+    const now = new Date().toISOString();
+    await db.execute(`UPDATE local_thread_run SET status = ?, assistant_snapshot_json = ?, updated_at = ?, last_heartbeat_at = ?,
+       started_at = COALESCE(started_at, ?)
+     WHERE id = ? AND status NOT IN ('succeeded', 'failed', 'cancelled', 'interrupted', 'expired')`, [input.status, safeJson(withRunMetadata(input.assistant, input.runId, input.status)), now, now, now, input.runId]);
+}
+/** Ends the run and writes the final assistant message into the synced transcript. */
+export async function commitRunTerminal(db, input) {
+    const finishedAt = new Date().toISOString();
+    const assistant = withRunMetadata(input.assistant, input.runId, input.status);
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        await writeChatMessage(tx, {
+            threadId: input.threadId,
+            userId: input.userId,
+            message: assistant,
+            parentId: input.userMessageId,
+            createdAt: messageCreatedAt(assistant, finishedAt),
+            updatedAt: finishedAt,
+        });
+        await tx.execute(`UPDATE local_thread_run SET status = ?, error_text = ?, finished_at = ?, updated_at = ?, expires_at = NULL,
+         cleanup_after_at = ?, assistant_snapshot_json = ?
+       WHERE id = ?`, [
+            input.status,
+            input.errorText,
+            finishedAt,
+            finishedAt,
+            new Date(Date.parse(finishedAt) + RUN_RETENTION_MS).toISOString(),
+            safeJson(assistant),
+            input.runId,
+        ]);
+    });
+}
+export async function findRun(db, input) {
+    const row = await db.getOptional(`SELECT id, thread_id, status, request_payload_json, assistant_snapshot_json, updated_at
+     FROM local_thread_run WHERE id = ? AND user_id = ? LIMIT 1`, [input.runId, input.userId]);
+    if (!row)
+        return null;
+    const payload = parseJson(row.request_payload_json);
+    const requestId = payload?.metadata?.remoteDevice?.requestId;
+    return {
+        id: row.id,
+        threadId: row.thread_id,
+        status: row.status,
+        requestId: typeof requestId === 'string' ? requestId : null,
+        assistant: parseJson(row.assistant_snapshot_json),
+        updatedAt: row.updated_at,
+    };
+}
+/** Rewrites a user message's queue marker in place; a missing message is ignored. */
+async function writeQueueMarker(tx, messageId, marker, extra = {}) {
+    const row = await tx.getOptional('SELECT content FROM c_chat_message WHERE id = ? LIMIT 1', [messageId]);
+    const message = parseJson(row?.content);
+    if (!message)
+        return;
+    const now = new Date().toISOString();
+    await tx.execute(`UPDATE c_chat_message SET content = ?, updated_at = ?${extra.deletedAt ? ', deleted_at = ?' : ''} WHERE id = ?`, extra.deletedAt
+        ? [safeJson(withQueueMarker(message, marker)), now, extra.deletedAt, messageId]
+        : [safeJson(withQueueMarker(message, marker)), now, messageId]);
+}
+/** The queued turns start now: their messages stop showing as queued. */
+export async function startQueuedRuns(db, userMessageIds) {
+    if (userMessageIds.length === 0)
+        return;
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        for (const messageId of userMessageIds)
+            await writeQueueMarker(tx, messageId, null);
+    });
+}
+/** Ends a queued turn that was merged into a later one: no reply of its own is written. */
+export async function finishMergedRun(db, input) {
+    const now = new Date().toISOString();
+    const assistant = withRunMetadata(withMergedInto(input.assistant, input.mergedIntoRunId), input.runId, 'succeeded');
+    await db.execute(`UPDATE local_thread_run SET status = 'succeeded', finished_at = ?, updated_at = ?, assistant_snapshot_json = ?,
+       cleanup_after_at = ?
+     WHERE id = ?`, [now, now, safeJson(assistant), new Date(Date.parse(now) + RUN_RETENTION_MS).toISOString(), input.runId]);
+    return assistant;
+}
+/**
+ * The user took a queued turn back before it ran: the run is cancelled and its
+ * message removed from the transcript (marked `withdrawn` so other devices can
+ * tell a withdrawal from a deletion).
+ */
+export async function withdrawQueuedRun(db, input) {
+    const now = new Date().toISOString();
+    const assistant = withRunMetadata(input.assistant, input.runId, 'cancelled');
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        await writeQueueMarker(tx, input.userMessageId, { state: 'withdrawn', runId: input.runId, executor: 'gateway', queuedAt: now }, { deletedAt: now });
+        await tx.execute(`UPDATE local_thread_run SET status = 'cancelled', finished_at = ?, updated_at = ?, assistant_snapshot_json = ?,
+         error_text = 'withdrawn by user', cleanup_after_at = ?
+       WHERE id = ?`, [now, now, safeJson(assistant), new Date(Date.parse(now) + RUN_RETENTION_MS).toISOString(), input.runId]);
+    });
+    return assistant;
+}
+/** Runs left non-terminal by a previous process can never finish; mark them interrupted. */
+export async function interruptOrphanedRuns(db, userId) {
+    const now = new Date().toISOString();
+    const rows = await db.getAll(`SELECT id, user_message_id FROM local_thread_run
+     WHERE user_id = ? AND status NOT IN ('succeeded', 'failed', 'cancelled', 'interrupted', 'expired')
+       AND request_payload_json LIKE '%"gatewayId"%'`, [userId]);
+    for (const row of rows) {
+        await db.execute(`UPDATE local_thread_run SET status = 'interrupted', error_text = ?, finished_at = ?, updated_at = ? WHERE id = ?`, ['gateway host restarted', now, now, row.id]);
+        // A turn that was still queued will never run: it must not show as queued forever.
+        if (row.user_message_id)
+            await writeQueueMarker(db, row.user_message_id, null);
+    }
+    return rows.length;
+}
+export async function readSessionBinding(db, threadId) {
+    const row = await db.getOptional('SELECT robot_session_id FROM c_thread WHERE id = ? LIMIT 1', [threadId]);
+    const parsed = parseJson(row?.robot_session_id);
+    if (parsed?.v !== 1 || typeof parsed.sessionId !== 'string' || typeof parsed.gatewayId !== 'string')
+        return null;
+    return {
+        sessionId: parsed.sessionId,
+        topicId: typeof parsed.topicId === 'string' ? parsed.topicId : null,
+        gatewayId: parsed.gatewayId,
+    };
+}
+export async function writeSessionBinding(db, threadId, binding) {
+    await db.execute('UPDATE c_thread SET robot_session_id = ?, updated_at = ? WHERE id = ?', [
+        safeJson({ v: 1, ...binding }),
+        new Date().toISOString(),
+        threadId,
+    ]);
+}
+/**
+ * The thread's current topic: the latest "new topic" marker the app wrote
+ * (`entry_type = 'internal'`, `meta_data.kind = 'context_reset'`). A new topic
+ * starts a fresh agent session.
+ */
+export async function readCurrentTopicId(db, threadId) {
+    const rows = await db.getAll(`SELECT id, meta_data FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND entry_type = ? AND deleted_at IS NULL
+     ORDER BY julianday(created_at) DESC, id DESC LIMIT 20`, [THREAD_CHAT_TYPE, threadId, CONTEXT_RESET_ENTRY_TYPE]);
+    for (const row of rows) {
+        if (parseJson(row.meta_data)?.kind === 'context_reset')
+            return row.id;
+    }
+    return null;
+}
+/** File parts resolve only to resources this user owns with an https storage URL. */
+export async function resolveTrustedResource(db, input) {
+    const row = await db.getOptional(`SELECT storage_url, name, mime_type FROM c_resource
+     WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0) AND deleted_at IS NULL LIMIT 1`, [input.resourceId, input.userId]);
+    if (!row?.storage_url?.startsWith('https://'))
+        return null;
+    return { url: row.storage_url, name: row.name ?? 'attachment', mediaType: row.mime_type };
+}
+function robotMetaData(input) {
+    return JSON.stringify({ gateway: { machineId: input.machineId, ...(input.agentId ? { agentId: input.agentId } : {}) } });
+}
+export async function upsertRobot(db, input) {
+    const now = new Date().toISOString();
+    // The backend rejects NULL c_robot columns, and PowerSync omits NULLs only from inserts.
+    const cwd = input.cwd ?? '';
+    const metaData = robotMetaData(input);
+    const existing = await db.getOptional('SELECT name, device_id, device_name, agent_type, cwd, meta_data, is_del FROM c_robot WHERE id = ? LIMIT 1', [
+        input.id,
+    ]);
+    if (existing) {
+        const unchanged = existing.name === input.name
+            && existing.device_id === input.deviceId
+            && existing.device_name === input.deviceName
+            && existing.agent_type === input.agentType
+            && (existing.cwd ?? '') === cwd
+            && sameJson(existing.meta_data, metaData)
+            && !existing.is_del;
+        // Every daemon start re-registers; skip no-op writes so they do not queue uploads.
+        if (unchanged)
+            return;
+        // A removed gateway that is added again revives its robot (ids are deterministic).
+        await db.execute(`UPDATE c_robot SET name = ?, device_id = ?, device_name = ?, agent_type = ?, cwd = ?, meta_data = ?,
+         updated_at = ?, is_del = 0
+       WHERE id = ?`, [input.name, input.deviceId, input.deviceName, input.agentType, cwd, metaData, now, input.id]);
+        return;
+    }
+    await db.execute(`INSERT INTO c_robot (id, name, device_id, device_name, agent_type, cwd, config, meta_data, created_at, updated_at,
+       user_id, is_del)
+     VALUES (?, ?, ?, ?, ?, ?, '{}', ?, ?, ?, ?, 0)`, [input.id, input.name, input.deviceId, input.deviceName, input.agentType, cwd, metaData, now, now, input.userId]);
+}
+/**
+ * Soft-deletes this machine's gateway robots that are no longer configured
+ * (removed, or replaced before ids were deterministic), so the app never
+ * offers an agent that nothing hosts. Robots from other machines are untouched.
+ */
+export async function retireRemovedRobots(db, input) {
+    const rows = await db.getAll(`SELECT id, meta_data FROM c_robot WHERE user_id = ? AND COALESCE(is_del, 0) = 0`, [input.userId]);
+    const keep = new Set(input.keepIds);
+    const retired = rows
+        .filter((row) => !keep.has(row.id) && robotMachineId(row.meta_data) === input.machineId)
+        .map((row) => row.id);
+    for (const id of retired)
+        await softDeleteRobot(db, id);
+    return retired;
+}
+/** The backend re-serializes JSON columns, so compare them parsed. */
+function sameJson(stored, expected) {
+    try {
+        return JSON.stringify(JSON.parse(stored ?? '')) === expected;
+    }
+    catch {
+        return false;
+    }
+}
+function robotMachineId(metaData) {
+    try {
+        const parsed = JSON.parse(metaData ?? '');
+        return typeof parsed?.gateway?.machineId === 'string' ? parsed.gateway.machineId : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function softDeleteRobot(db, robotId) {
+    await db.execute('UPDATE c_robot SET is_del = 1, updated_at = ? WHERE id = ?', [new Date().toISOString(), robotId]);
+}