@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/run-workbench-service.js

@@ -0,0 +1,113 @@
+import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+export class RunWorkbenchService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'run.get': (data) => this.get(record(data)),
+            'run.snapshot': (data) => this.snapshot(record(data)),
+            'run.image.read': (data) => this.image(record(data)),
+            'run.user-input.respond': (data) => this.respond(record(data)),
+            'session.interrupt': (data) => this.interruptSession(record(data)),
+            'run.cancel': (data) => this.cancelOrInterrupt('run.cancel', record(data)),
+            'run.interrupt': (data) => this.cancelOrInterrupt('run.interrupt', record(data)),
+            'run.approvals': (data) => this.approvals(record(data)),
+            'run.approval.decide': (data) => this.decideApproval(record(data))
+        };
+    }
+    get(input) {
+        return { run: this.requireRun(input.runId) };
+    }
+    snapshot(input) {
+        const run = this.requireRun(input.runId);
+        return { snapshot: this.options.runtime.getSnapshot(run.id) ?? null };
+    }
+    async image(input) {
+        if (typeof input.runId !== 'string' ||
+            typeof input.imageIndex !== 'number' ||
+            !Number.isInteger(input.imageIndex) ||
+            input.imageIndex < 0)
+            throw new Error('RUN_IMAGE_INVALID');
+        const image = await this.options.readImage(input.runId, input.imageIndex);
+        if (image === undefined)
+            throw new Error('RUN_IMAGE_NOT_FOUND');
+        return { image };
+    }
+    respond(input) {
+        if (typeof input.runId !== 'string' ||
+            typeof input.requestId !== 'string' ||
+            !isPlainRecord(input.answers))
+            throw new Error('USER_INPUT_INVALID');
+        this.options.respondUserInput(input.runId, input.requestId, input.answers);
+        return { accepted: true };
+    }
+    interruptSession(input) {
+        if (typeof input.sessionId !== 'string')
+            throw new Error('SESSION_NOT_FOUND');
+        const session = this.options.runtime.getAgentSession(input.sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const run = this.options.runtime.activeSessionRun(session.id);
+        if (run === undefined || isTerminalRunStatus(run.status))
+            throw new Error('RUN_NOT_FOUND');
+        return this.cancelOrInterrupt('run.interrupt', { runId: run.id });
+    }
+    cancelOrInterrupt(operation, input) {
+        const run = this.requireRun(input.runId);
+        if (operation === 'run.cancel' &&
+            run.status === 'QUEUED' &&
+            this.options.runtime.isQueuedRun(run.id)) {
+            this.options.runtime.deleteQueuedRun(run.id);
+            this.options.deleteQueuedStart(run.id);
+            this.options.clearImages(run.id);
+            this.options.emitQueue(run.workspaceId, run.sessionId);
+            return { cancelled: true };
+        }
+        const next = this.options.runtime.transitionRun(run.id, operation === 'run.cancel' && run.status === 'QUEUED' ? 'CANCELLED' : 'CANCELLING');
+        if (operation === 'run.cancel' && next.status === 'CANCELLED') {
+            this.options.emitRun(run.id, 'run.completed', { status: 'CANCELLED' }, 'CANCELLED');
+            return { run: next };
+        }
+        if (operation === 'run.interrupt') {
+            this.options.runtime.pauseSessionQueue(run.sessionId);
+            this.options.emitQueue(run.workspaceId, run.sessionId);
+            this.options.markInterrupted(run.id);
+        }
+        this.options.control(operation, { runId: run.id });
+        return { run: next };
+    }
+    approvals(input) {
+        const run = this.requireRun(input.runId);
+        return { approvals: this.options.runtime.listApprovals(run.id) };
+    }
+    decideApproval(input) {
+        if (typeof input.approvalId !== 'string' ||
+            (input.decision !== 'APPROVED' && input.decision !== 'REJECTED'))
+            throw new Error('APPROVAL_DECISION_INVALID');
+        const approval = this.options.runtime.decideApproval(input.approvalId, input.decision);
+        this.options.emitRun(approval.runId, 'approval.decided', {
+            approvalId: approval.id,
+            decision: input.decision
+        });
+        this.options.control('run.approval.decision', {
+            runId: approval.runId,
+            approvalId: approval.id,
+            decision: input.decision
+        });
+        return { approval };
+    }
+    requireRun(runId) {
+        if (typeof runId !== 'string')
+            throw new Error('RUN_NOT_FOUND');
+        const run = this.options.runtime.getRun(runId);
+        if (run === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        return run;
+    }
+}
+function record(value) {
+    return isPlainRecord(value) ? value : {};
+}

package/dist/service/runner-channel-message-service.d.ts

@@ -0,0 +1,13 @@
+import type { NodeEnvelope } from '@myagentroam/protocol';
+import type { RunnerInteractionService } from './runner-interaction-service.js';
+interface RunnerChannelMessageServiceOptions {
+    readonly interactions: RunnerInteractionService;
+    readonly send: (type: string, payload: unknown, replyTo?: string) => void;
+}
+/** Validates shared-control channel messages before delivery to a Runner. */
+export declare class RunnerChannelMessageService {
+    private readonly options;
+    constructor(options: RunnerChannelMessageServiceOptions);
+    handle(envelope: NodeEnvelope): void;
+}
+export {};

package/dist/service/runner-channel-message-service.js

@@ -0,0 +1,20 @@
+/** Validates shared-control channel messages before delivery to a Runner. */
+export class RunnerChannelMessageService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    handle(envelope) {
+        const payload = envelope.payload;
+        if (typeof payload.sessionId !== 'string' ||
+            typeof payload.id !== 'string' ||
+            typeof payload.senderId !== 'string' ||
+            typeof payload.token !== 'string' ||
+            typeof payload.content !== 'string') {
+            this.options.send('error', { code: 'MESSAGE_INVALID' }, envelope.id);
+            return;
+        }
+        const delivery = this.options.interactions.deliverChannel('claude-code', payload.sessionId, payload.id, payload.senderId, payload.token, payload.content);
+        this.options.send('ack', { type: envelope.type, delivery }, envelope.id);
+    }
+}

package/dist/service/runner-interaction-service.d.ts

@@ -0,0 +1,40 @@
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { NodeAgentSession } from '../database.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { ClaudeCodeRunner } from '../runner/claude-code-runner.js';
+import type { CodexRunner } from '../runner/codex-runner.js';
+import { type PublicConversationItem } from '../runner/codex/conversation-parser.js';
+import type { RunDomainState } from './run-domain-state.js';
+interface RunnerInteractionServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly state: RunDomainState;
+    readonly codex: () => CodexRunner;
+    readonly claude: () => ClaudeCodeRunner;
+    readonly runners: RunnerRegistry;
+    readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED' | 'INTERRUPTED') => void;
+    readonly emitItem: (runId: string, item: PublicConversationItem) => void;
+    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
+    readonly approvalTimeoutMs: number;
+    readonly publishApproval: (input: {
+        readonly runId: string;
+        readonly approvalId: string;
+        readonly payload: unknown;
+        readonly expiresAt: number;
+    }) => void;
+}
+export declare class RunnerInteractionService {
+    private readonly options;
+    constructor(options: RunnerInteractionServiceOptions);
+    requestClaudeApproval(runId: string, toolName: string, toolInput: Record<string, unknown>): Promise<import("@anthropic-ai/claude-agent-sdk").PermissionResult>;
+    requestClaudeUserInput(runId: string, toolInput: Record<string, unknown>, toolUseId: string): Promise<import("@anthropic-ai/claude-agent-sdk").PermissionResult>;
+    deliverChannel(runner: NodeAgentSession['runner'], sessionId: string, messageId: string, senderId: string, token: string, content: string): import("../claude-channel.js").ChannelDelivery;
+    decideCodexApproval(approvalId: string, decision: 'APPROVED' | 'REJECTED'): boolean;
+    decideClaudeApproval(approvalId: string, decision: 'APPROVED' | 'REJECTED'): boolean;
+    cancelClaudeRun(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
+    cancelCodexTurn(runId: string, threadId: string, turnId: string, cwd: string, terminalStatus: 'CANCELLED' | 'INTERRUPTED'): Promise<void>;
+    respondUserInput(runId: string, requestId: string, rawAnswers: Record<string, unknown>): void;
+    completeCancelledRun(runId: string, cwd: string | undefined): boolean;
+    private respondCodexUserInput;
+    private answers;
+}
+export {};

package/dist/service/runner-interaction-service.js

@@ -0,0 +1,246 @@
+import { denyPermission } from '../claude-agent-sdk.js';
+import { boundedConversationItemId, claudeUserInputQuestions, isTerminalRunStatus } from '../runner/codex/conversation-parser.js';
+export class RunnerInteractionService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    requestClaudeApproval(runId, toolName, toolInput) {
+        const approvalId = `claude:${crypto.randomUUID()}`;
+        return new Promise((resolve) => {
+            const expiresAt = Date.now() + this.options.approvalTimeoutMs;
+            const settle = (decision) => resolve(decision === 'APPROVED'
+                ? { behavior: 'allow', updatedInput: toolInput }
+                : denyPermission());
+            try {
+                this.options.runtime.createApproval({
+                    runId,
+                    approvalId,
+                    payload: { toolName, input: toolInput },
+                    expiresAt
+                });
+            }
+            catch {
+                resolve(denyPermission('APPROVAL_STORE_FAILED'));
+                return;
+            }
+            const expire = () => {
+                const approvals = this.options.claude().execution.approvals;
+                const active = approvals.get(approvalId);
+                if (active === undefined)
+                    return;
+                try {
+                    this.options.runtime.expireApproval(approvalId);
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message === 'APPROVAL_NOT_EXPIRED') {
+                        const timer = setTimeout(expire, Math.max(1, expiresAt - Date.now()));
+                        approvals.set(approvalId, { ...active, timer });
+                        return;
+                    }
+                }
+                approvals.delete(approvalId);
+                this.options.emitRun(active.runId, 'approval.expired', { approvalId });
+                resolve(denyPermission('APPROVAL_EXPIRED'));
+            };
+            const timer = setTimeout(expire, this.options.approvalTimeoutMs);
+            this.options.claude().execution.approvals.set(approvalId, {
+                runId,
+                timer,
+                resolve: settle
+            });
+            this.options.publishApproval({
+                runId,
+                approvalId,
+                payload: { toolName, input: toolInput },
+                expiresAt
+            });
+        });
+    }
+    requestClaudeUserInput(runId, toolInput, toolUseId) {
+        const questions = claudeUserInputQuestions(toolInput);
+        if (questions.length === 0)
+            return Promise.resolve(denyPermission('USER_INPUT_INVALID'));
+        const requestId = `claude:${runId}:${toolUseId}`;
+        return new Promise((resolve) => {
+            const input = { ...toolInput };
+            const timer = setTimeout(() => {
+                const pending = this.options.claude().execution.userInputs.get(requestId);
+                if (pending === undefined)
+                    return;
+                this.options.claude().execution.userInputs.delete(requestId);
+                pending.reject('USER_INPUT_EXPIRED');
+                this.options.emitItem(runId, {
+                    itemId: boundedConversationItemId('claude-input', requestId),
+                    kind: 'user_input_request',
+                    status: 'FAILED',
+                    payload: { requestId, questions },
+                    merge: true
+                });
+            }, this.options.approvalTimeoutMs);
+            this.options.claude().execution.userInputs.set(requestId, {
+                runId,
+                requestId,
+                questions,
+                input,
+                resolve: (answers) => resolve({ behavior: 'allow', updatedInput: { ...input, answers } }),
+                reject: (message = 'USER_INPUT_EXPIRED') => resolve(denyPermission(message)),
+                timer
+            });
+            this.options.emitItem(runId, {
+                itemId: boundedConversationItemId('claude-input', requestId),
+                kind: 'user_input_request',
+                status: 'PENDING',
+                payload: { requestId, questions }
+            });
+        });
+    }
+    deliverChannel(runner, sessionId, messageId, senderId, token, content) {
+        return this.options.runners
+            .require(runner)
+            .deliverChannel(sessionId, messageId, senderId, token, content, (runId, deliveredMessageId, delivery) => this.options.emitRun(runId, 'channel.delivery', {
+            messageId: deliveredMessageId,
+            delivery
+        }));
+    }
+    decideCodexApproval(approvalId, decision) {
+        const codex = this.options.codex();
+        const requestId = codex.execution.approvals.get(approvalId);
+        if (requestId === undefined)
+            return false;
+        try {
+            codex.respond(requestId, { decision: decision === 'APPROVED' ? 'accept' : 'decline' });
+        }
+        catch {
+            // A disconnected App Server cannot safely receive a late approval.
+        }
+        codex.execution.approvals.delete(approvalId);
+        return true;
+    }
+    decideClaudeApproval(approvalId, decision) {
+        const approvals = this.options.claude().execution.approvals;
+        const approval = approvals.get(approvalId);
+        if (approval === undefined)
+            return false;
+        clearTimeout(approval.timer);
+        approvals.delete(approvalId);
+        approval.resolve(decision);
+        return true;
+    }
+    cancelClaudeRun(runId, intent) {
+        const claudeRun = this.options.claude().execution.runs.get(runId);
+        if (claudeRun === undefined)
+            return false;
+        if (intent === 'CANCEL')
+            claudeRun.handle.cancel();
+        else
+            void claudeRun.handle.interrupt().then(() => {
+                const run = this.options.runtime.getRun(runId);
+                if (run !== undefined && !isTerminalRunStatus(run.status))
+                    this.options.emitRun(runId, 'run.completed', { status: 'INTERRUPTED' }, 'INTERRUPTED');
+            }, () => {
+                const run = this.options.runtime.getRun(runId);
+                if (run !== undefined && !isTerminalRunStatus(run.status))
+                    this.options.emitRun(runId, 'run.failed', { code: 'CLAUDE_INTERRUPT_FAILED' }, 'FAILED');
+            });
+        return true;
+    }
+    async cancelCodexTurn(runId, threadId, turnId, cwd, terminalStatus) {
+        const codex = this.options.codex();
+        try {
+            await codex.interruptTurn(threadId, turnId);
+            const run = this.options.runtime.getRun(runId);
+            if (run !== undefined && !isTerminalRunStatus(run.status))
+                this.options.emitRun(runId, 'run.completed', { status: terminalStatus }, terminalStatus);
+        }
+        catch {
+            const run = this.options.runtime.getRun(runId);
+            if (run !== undefined && !isTerminalRunStatus(run.status))
+                this.options.emitRun(runId, 'run.failed', { code: 'CODEX_INTERRUPT_FAILED' }, 'FAILED');
+        }
+        finally {
+            codex.execution.runs.delete(runId);
+            codex.releaseEnvironment(runId);
+            this.options.state.active.delete(runId);
+            void this.options.captureSnapshot(runId, cwd);
+        }
+    }
+    respondUserInput(runId, requestId, rawAnswers) {
+        if (this.options.runners.respondUserInput(runId, requestId, rawAnswers))
+            return;
+        if (this.options.codex().execution.userInputs.has(requestId)) {
+            this.respondCodexUserInput(runId, requestId, rawAnswers);
+            return;
+        }
+        const userInputs = this.options.claude().execution.userInputs;
+        const pending = userInputs.get(requestId);
+        if (pending === undefined || pending.runId !== runId)
+            throw new Error('USER_INPUT_NOT_FOUND');
+        const answers = {};
+        for (const question of pending.questions) {
+            const normalized = this.answers(rawAnswers[question.id], question.allowOther, (value) => question.options.some((option) => option.value === value));
+            if (!question.multiSelect && normalized.length !== 1)
+                throw new Error('USER_INPUT_INVALID');
+            answers[question.prompt] = normalized.join(', ');
+        }
+        clearTimeout(pending.timer);
+        userInputs.delete(requestId);
+        pending.resolve(answers);
+        this.options.emitItem(runId, {
+            itemId: boundedConversationItemId('claude-input', requestId),
+            kind: 'user_input_request',
+            status: 'COMPLETED',
+            payload: { requestId, questions: pending.questions },
+            merge: true
+        });
+    }
+    completeCancelledRun(runId, cwd) {
+        const run = this.options.runtime.getRun(runId);
+        if (run === undefined)
+            return false;
+        if (run.status === 'CANCELLING') {
+            const status = this.options.state.interruptRequested.has(runId) ? 'INTERRUPTED' : 'CANCELLED';
+            this.options.emitRun(runId, 'run.completed', { status }, status);
+        }
+        else if (!isTerminalRunStatus(run.status))
+            return false;
+        this.options.codex().execution.runs.delete(runId);
+        this.options.state.active.delete(runId);
+        if (cwd !== undefined)
+            void this.options.captureSnapshot(runId, cwd);
+        return true;
+    }
+    respondCodexUserInput(runId, requestId, rawAnswers) {
+        const codex = this.options.codex();
+        const pending = codex.execution.userInputs.get(requestId);
+        if (pending === undefined ||
+            pending.runId !== runId ||
+            this.options.runtime.getRun(runId) === undefined)
+            throw new Error('USER_INPUT_NOT_FOUND');
+        const answers = {};
+        for (const question of pending.questions)
+            answers[question.id] = {
+                answers: this.answers(rawAnswers[question.id], question.allowOther, (value) => question.options.includes(value))
+            };
+        codex.respond(pending.requestId, { answers });
+        codex.execution.userInputs.delete(requestId);
+        this.options.emitItem(runId, {
+            itemId: boundedConversationItemId('codex-input', requestId),
+            kind: 'user_input_request',
+            status: 'COMPLETED',
+            payload: { requestId, questions: [] },
+            merge: true
+        });
+    }
+    answers(raw, allowOther, supported) {
+        if (!Array.isArray(raw) || raw.length === 0 || raw.length > 8)
+            throw new Error('USER_INPUT_INVALID');
+        return raw.map((value) => {
+            if (typeof value !== 'string' || value.length === 0 || value.length > 500)
+                throw new Error('USER_INPUT_INVALID');
+            if (!allowOther && !supported(value))
+                throw new Error('USER_INPUT_INVALID');
+            return value;
+        });
+    }
+}

package/dist/service/runner-service.d.ts

@@ -0,0 +1,44 @@
+import { type NodeCapabilities } from '@myagentroam/protocol';
+import type { NodeDatabase } from '../database.js';
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { RunnerUsageReader } from '../runner-usage.js';
+export declare class RunnerService {
+    private readonly database;
+    private readonly capabilities;
+    private readonly runners;
+    private readonly usage;
+    constructor(database: () => NodeDatabase, capabilities: () => NodeCapabilities, runners: RunnerRegistry, usage: RunnerUsageReader);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    profiles(): readonly {
+        runner: "codex" | "claude-code" | "opencode";
+        capabilities: string[];
+        models: {
+            id: string;
+            label: string;
+            supportedEfforts: string[];
+        }[];
+        accessOptions: {
+            id: string;
+            label: string;
+            description: string;
+        }[];
+        commands: {
+            id: string;
+            available: boolean;
+            runner: "codex" | "claude-code" | "opencode";
+            reasonCode: string | null;
+            label: string;
+            description: string;
+            inputHint: string;
+            source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK" | "OPENCODE_SERVER";
+            interaction: "RUNNER_TEXT" | "IMMEDIATE_ACTION" | "TOGGLE" | "VALUE";
+            stateLabel?: string | undefined;
+        }[];
+    }[];
+    private refreshProfiles;
+    private usageStatuses;
+    private readUsage;
+    private listProfiles;
+    private saveDefaults;
+}

package/dist/service/runner-service.js

@@ -0,0 +1,68 @@
+import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
+import { parseSecretEnvironment } from '../util/secret-environment.js';
+export class RunnerService {
+    database;
+    capabilities;
+    runners;
+    usage;
+    constructor(database, capabilities, runners, usage) {
+        this.database = database;
+        this.capabilities = capabilities;
+        this.runners = runners;
+        this.usage = usage;
+    }
+    operations() {
+        return {
+            'runner.usage.status': () => this.usageStatuses(),
+            'runner.usage.read': (data) => this.readUsage(data),
+            'runner.profiles.list': (data) => this.listProfiles(data),
+            'runner.defaults.save': (data) => this.saveDefaults(data)
+        };
+    }
+    profiles() {
+        return this.runners.profiles(this.capabilities());
+    }
+    refreshProfiles(workspaceId, environment = {}) {
+        const workspace = workspaceId === undefined ? undefined : this.database().getWorkspace(workspaceId);
+        if (workspaceId !== undefined && workspace === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        return this.runners.refreshProfiles(this.capabilities(), workspace, environment);
+    }
+    async usageStatuses() {
+        return {
+            statuses: await Promise.all(this.runners
+                .advertised()
+                .flatMap((runner) => runner.name === 'codex' || runner.name === 'claude-code'
+                ? [this.usage.status(runner.name)]
+                : []))
+        };
+    }
+    async readUsage(data) {
+        const input = data;
+        const runner = this.runners.product(input.runner);
+        if (runner === undefined || runner.name === 'opencode')
+            throw new Error('RUNNER_USAGE_INVALID');
+        return { usage: await this.usage.read(runner.name) };
+    }
+    async listProfiles(data) {
+        const input = data;
+        const workspaceId = typeof input.workspaceId === 'string' && input.workspaceId.length > 0
+            ? input.workspaceId
+            : undefined;
+        const environment = parseSecretEnvironment(input.secretEnvironment);
+        return {
+            profiles: await this.refreshProfiles(workspaceId, environment),
+            defaults: this.database()
+                .getRunnerDefaults()
+                .filter((value) => this.runners.supportsConfiguration(value))
+        };
+    }
+    saveDefaults(data) {
+        const parsed = runnerDefaultConfigurationSchema.safeParse(data);
+        if (!parsed.success)
+            throw new Error('RUNNER_DEFAULT_INVALID');
+        if (!this.runners.supportsConfiguration(parsed.data))
+            throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
+        return { defaults: this.database().saveRunnerDefaults(parsed.data) };
+    }
+}

package/dist/service/session-catalog-service.d.ts

@@ -0,0 +1,45 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeAgentSession, NodeConversationTurn, NodeDatabase } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { ExternalSessionResumeService } from './external-session-resume-service.js';
+import type { NativeSessionProjectionService } from './native-session-projection-service.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+interface SessionCatalogServiceOptions {
+    readonly database: () => NodeDatabase;
+    readonly nodeId: () => string;
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly projection: NativeSessionProjectionService;
+    readonly resume: ExternalSessionResumeService;
+    readonly cachedNative: () => readonly NodeAgentSession[];
+    readonly cachedWorkspace: (workspaceId: string) => Promise<readonly NodeAgentSession[]>;
+    readonly present: (session: NodeAgentSession) => NodeAgentSession;
+    readonly projectionForNative: (session: NodeAgentSession) => NodeAgentSession | undefined;
+    readonly nativeIds: (session: NodeAgentSession) => ReadonlySet<string>;
+    readonly forget: (session: NodeAgentSession, nativeIds: ReadonlySet<string>) => void;
+    readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
+    readonly externalActivity: (sessionId: string) => unknown;
+    readonly history: (session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }) => Promise<{
+        readonly turns: readonly NodeConversationTurn[];
+        readonly nextCursor: string | null;
+    }>;
+    readonly emitSession: (session: NodeAgentSession) => void;
+}
+export declare class SessionCatalogService {
+    private readonly options;
+    private rewindQueue;
+    constructor(options: SessionCatalogServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private list;
+    private mergePersisted;
+    private resume;
+    private enqueueRewind;
+    private rewind;
+    private findTurn;
+    private remove;
+}
+export declare function rewindTitle(sourceTitle: string, existingTitles?: readonly string[]): string;
+export {};