@myagentroam/node 0.10.61 → 0.10.62

package/dist/service/native-session-watch-service.js

@@ -1,17 +1,16 @@
-import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { ConversationObservation } from './conversation-observation.js';
 import { safeErrorCode } from '../util/safe-error.js';
 import { SessionWatchSlotCoordinator } from './session-watch-slot-coordinator.js';
 const INTERVAL_MS = 2_000;
 const TTL_MS = 45_000;
 const MAX_FAILURES = 3;
-const INITIAL_TURN_LIMIT = 30;
-const EMITTED_TURN_LIMIT = 10;
 export class NativeSessionWatchService {
     options;
     watches = new Map();
     leases = new Map();
     sessionWatchSlots;
-    snapshotSequence = 0;
+    snapshotNumber = 0;
     constructor(options) {
         this.options = options;
         this.sessionWatchSlots = options.sessionWatchSlots ?? new SessionWatchSlotCoordinator();
@@ -111,23 +110,11 @@ export class NativeSessionWatchService {
             return { expiresAt: existing.expiresAt };
         }
         const watch = {
-            session,
-            mode: this.options.managedActive(session) ? 'RUNNING' : 'HISTORY',
+            observation: new ConversationObservation(session, this.options),
             expiresAt: Date.now() + TTL_MS,
             refresh: undefined,
-            refreshMode: undefined,
             sessionSignature: undefined,
-            signature: undefined,
-            page: undefined,
-            runtimePage: undefined,
-            runtimeRevision: undefined,
-            runtimeRead: undefined,
-            historyRead: undefined,
-            observedPage: undefined,
-            authority: undefined,
-            eventRevision: 0,
             failures: 0,
-            transitionGeneration: 0,
             timer: undefined
         };
         watch.timer = this.refreshTimer(session.id);
@@ -136,25 +123,16 @@ export class NativeSessionWatchService {
     }
     emitRealtime(sessionId, event) {
         const watch = this.watches.get(sessionId);
-        if (watch !== undefined)
-            watch.eventRevision = event.sequence;
         const leases = [...this.leases.values()].filter((lease) => lease.sessionId === sessionId);
-        const activity = sessionActivity(event);
-        if (watch !== undefined && activity === 'RUNNING' && watch.mode !== 'RUNNING') {
-            watch.mode = 'RUNNING';
-            watch.transitionGeneration += 1;
+        const transition = watch?.observation.observe(event);
+        if (transition !== undefined && watch !== undefined) {
             for (const lease of leases)
                 lease.ready = false;
-            void this.publishRuntimeSnapshot(watch, watch.transitionGeneration);
-        }
-        else if (watch !== undefined && activity === 'IDLE' && watch.mode === 'RUNNING') {
-            watch.mode = 'CONVERGING';
-            const generation = ++watch.transitionGeneration;
-            for (const lease of leases)
-                lease.ready = false;
-            setTimeout(() => void this.convergeHistory(watch, generation), 0);
+            void this.completeRefresh(sessionId, watch, transition, 'observation');
         }
         for (const lease of leases) {
+            if (watch?.observation.snapshotPending === true)
+                lease.ready = false;
             if (!lease.ready) {
                 // Observations are useful only to an already watching page, never after a snapshot.
                 if (event.category !== 'conversation' ||
@@ -181,6 +159,7 @@ export class NativeSessionWatchService {
         if (watch === undefined)
             return;
         clearTimeout(watch.timer);
+        watch.observation.close();
         this.watches.delete(sessionId);
     }
     invalidate(sessionId) {
@@ -190,8 +169,10 @@ export class NativeSessionWatchService {
         this.stop(sessionId);
     }
     clear() {
-        for (const watch of this.watches.values())
+        for (const watch of this.watches.values()) {
             clearTimeout(watch.timer);
+            watch.observation.close();
+        }
         this.watches.clear();
         for (const ownerKey of [...this.leases.keys()])
             this.removeLease(ownerKey);
@@ -228,58 +209,26 @@ export class NativeSessionWatchService {
             this.stop(sessionId);
             return undefined;
         }
-        const refresh = this.performRefresh(sessionId, watch, limit, mode).finally(() => {
-            if (this.watches.get(sessionId) === watch) {
-                watch.refresh = undefined;
-                watch.refreshMode = undefined;
-                clearTimeout(watch.timer);
-                watch.timer = this.refreshTimer(sessionId);
-            }
-        });
-        watch.refresh = refresh;
-        watch.refreshMode = mode;
-        return refresh;
+        return this.completeRefresh(sessionId, watch, this.readObservation(sessionId, watch, limit, mode), mode);
     }
-    async performRefresh(sessionId, watch, limit, mode) {
-        let stage = 'resolve';
-        let session;
-        const readHistoricalPage = watch.mode === 'HISTORY' && this.options.readHistoryPage !== undefined;
-        try {
-            if (this.options.suspended?.(sessionId) === true)
-                return watch.page;
-            session = await this.options.resolve(sessionId);
-            if (session === undefined || session.externalSessionId === null) {
-                this.releaseSessionLeases(sessionId);
+    async readObservation(sessionId, watch, limit, mode) {
+        const session = await this.options.resolve(sessionId);
+        if (this.watches.get(sessionId) !== watch)
+            return undefined;
+        if (session === undefined || session.externalSessionId === null) {
+            this.releaseSessionLeases(sessionId);
+            return undefined;
+        }
+        watch.observation.session = session;
+        return watch.observation.refresh(mode, limit);
+    }
+    completeRefresh(sessionId, watch, read, mode) {
+        const current = () => this.watches.get(sessionId) === watch && watch.refresh === refresh;
+        const refresh = read
+            .then((update) => {
+            if (!current() || update === undefined)
                 return undefined;
-            }
-            watch.session = session;
-            if (mode === 'observation' && this.options.managedActive(session))
-                return watch.page;
-            stage = 'refresh_activity';
-            await this.options.refreshActivity(session);
-            if (this.options.suspended?.(sessionId) === true)
-                return watch.page;
-            stage = 'read_page';
-            const revisionBeforeRead = watch.eventRevision;
-            const page = await (readHistoricalPage
-                ? this.options.readHistoryPage(session, limit)
-                : this.options.readPage(session, limit));
-            if (revisionBeforeRead !== watch.eventRevision) {
-                // Initial still needs a full page for its new lease, whose pending events will
-                // replay above that page's sequence. Never publish this invalidated read to
-                // existing leases or replace their shared observation state.
-                if (mode !== 'initial')
-                    return watch.page;
-                const initial = this.options.convergePage(watch.page, watch.observedPage, page, watch.authority).page;
-                if (watch.page === undefined && watch.signature === undefined)
-                    watch.signature = JSON.stringify({
-                        source: initial.source,
-                        turns: initial.turns.slice(-(EMITTED_TURN_LIMIT + 1))
-                    });
-                return initial;
-            }
-            stage = 'present_session';
-            const presented = this.options.present(session);
+            const presented = this.options.present(watch.observation.session);
             const sessionSignature = JSON.stringify(presented);
             if (sessionSignature !== watch.sessionSignature) {
                 watch.sessionSignature = sessionSignature;
@@ -287,63 +236,48 @@ export class NativeSessionWatchService {
                     this.options.emitSession(presented);
             }
             watch.failures = 0;
-            const turns = page.turns.length <= EMITTED_TURN_LIMIT
-                ? page.turns
-                : page.turns.slice(-EMITTED_TURN_LIMIT);
-            const observed = { ...page, turns };
-            stage = 'converge_page';
-            const convergence = this.options.convergePage(watch.page, watch.observedPage, page, watch.authority);
-            const converged = convergence.page;
-            const accepted = converged.turns.length <= EMITTED_TURN_LIMIT + 1
-                ? converged
-                : {
-                    ...converged,
-                    turns: converged.turns.slice(-(EMITTED_TURN_LIMIT + 1))
-                };
-            watch.observedPage = observed;
-            watch.authority = convergence.authority;
-            const completingConvergence = watch.mode === 'CONVERGING' && !this.options.managedActive(session);
-            if (completingConvergence) {
-                watch.mode = 'HISTORY';
-                watch.runtimePage = undefined;
-                watch.runtimeRevision = undefined;
-            }
-            const signature = JSON.stringify({ source: accepted.source, turns: accepted.turns });
-            const changed = signature !== watch.signature;
-            if (changed) {
-                watch.signature = signature;
-            }
-            if (changed || watch.page === undefined)
-                watch.page = accepted;
-            stage = 'emit_page';
-            if (completingConvergence && accepted.source === 'runtime') {
-                if (changed)
-                    this.emitSnapshotToLeases(session, accepted, true);
-                else
-                    this.releasePendingEvents(session.id);
-            }
-            else if (completingConvergence)
-                this.emitSnapshotToLeases(session, accepted, true);
-            else if (changed)
-                this.emitObservedPage(session, accepted);
-            // Initial uses the full result of the same authority decision as observation.
-            return mode === 'initial' ? converged : accepted;
-        }
-        catch (error) {
+            this.deliverObservation(watch, update);
+            return update.page;
+        })
+            .catch((error) => {
+            if (!current())
+                return undefined;
             watch.failures += 1;
             this.options.log?.('session.watch.refresh.failed', {
                 nodeId: this.options.nodeId?.() ?? 'local-test-node',
                 sessionId,
-                ...(session === undefined ? {} : { runner: session.runner }),
-                stage,
+                runner: watch.observation.session.runner,
+                stage: watch.observation.stage,
                 errorCode: diagnosticErrorCode(error, 'SESSION_WATCH_REFRESH_FAILED'),
                 failureCount: watch.failures,
                 terminal: watch.failures >= MAX_FAILURES
             });
             if (watch.failures >= MAX_FAILURES)
                 this.failSession(sessionId);
+            else
+                this.releasePendingEvents(sessionId);
             return undefined;
-        }
+        })
+            .finally(() => {
+            if (!current())
+                return;
+            watch.refresh = undefined;
+            clearTimeout(watch.timer);
+            watch.timer = this.refreshTimer(sessionId);
+        });
+        watch.refresh = refresh;
+        return refresh;
+    }
+    deliverObservation(watch, update) {
+        const session = watch.observation.session;
+        if (this.watches.get(session.id) !== watch || update === undefined)
+            return;
+        if (update.snapshot)
+            this.emitSnapshotToLeases(session, update.page, true);
+        else if (update.handoff)
+            this.releasePendingEvents(session.id);
+        else if (update.changed)
+            this.emitObservedPage(session, update.page);
     }
     sessionHash(input) {
         return typeof input.__workspaceWatchSessionHash === 'string'
@@ -375,41 +309,36 @@ export class NativeSessionWatchService {
             stage = 'initial_refresh';
             this.watch(session);
             const watch = this.watches.get(session.id);
-            if (watch !== undefined)
-                watch.session = session;
-            const activeAtStart = this.options.managedActive(session);
-            if (watch !== undefined)
-                watch.mode = activeAtStart ? 'RUNNING' : watch.mode;
-            let page;
-            if (watch !== undefined) {
-                if (activeAtStart)
-                    page = this.composeRuntimePage(watch.page, await this.readRuntimePage(watch, session));
-                else {
-                    // An initial subscription must read after any older observation, not join its
-                    // potentially smaller or already-stale page.
-                    if (watch.refresh !== undefined &&
-                        (watch.page !== undefined || watch.refreshMode === 'observation'))
-                        await watch.refresh;
-                    page = await this.refresh(session.id, INITIAL_TURN_LIMIT, 'initial');
-                }
-            }
-            if (page === undefined)
+            if (watch === undefined)
+                return;
+            watch.observation.session = session;
+            const update = await watch.observation.initial();
+            if (this.leases.get(lease.ownerKey) !== lease || this.watches.get(session.id) !== watch)
+                return;
+            if (update === undefined)
                 throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+            watch.failures = 0;
+            this.deliverObservation(watch, update);
             if (lease.snapshotSent)
                 return;
-            const active = this.options.managedActive(session);
-            if (active && !activeAtStart && watch !== undefined) {
-                watch.mode = 'RUNNING';
-                page = this.composeRuntimePage(page, await this.readRuntimePage(watch, session));
-            }
             stage = 'project_snapshot';
+            const page = update.page;
             const payload = lease.unit === 'SEGMENT' ? projectInitialPage(session, page, 'SEGMENT', 10) : page;
-            if (this.leases.get(lease.ownerKey) !== lease)
-                return;
             this.emitSnapshot(lease, session, payload);
             this.releaseSnapshotPendingEvents(lease, page);
-            if (active && watch !== undefined && watch.page === undefined)
-                void this.hydrateRunningHistory(watch, session);
+            const hydration = watch.observation.hydrate();
+            if (hydration !== undefined)
+                void hydration
+                    .then((result) => this.deliverObservation(watch, result))
+                    .catch((error) => {
+                    if (this.watches.get(session.id) !== watch)
+                        return;
+                    this.options.log?.('session.watch.running-history.failed', {
+                        sessionId: session.id,
+                        errorCode: diagnosticErrorCode(error, 'SESSION_WATCH_HISTORY_FAILED')
+                    });
+                    this.releasePendingEvents(session.id);
+                });
         }
         catch (error) {
             if (this.leases.get(lease.ownerKey) !== lease)
@@ -453,100 +382,6 @@ export class NativeSessionWatchService {
         else if (observer !== undefined)
             observer.expiresAt = nextExpiry;
     }
-    composeRuntimePage(history, runtime) {
-        return this.options.composeRuntimePage?.(history, runtime) ?? runtime;
-    }
-    async readRuntimePage(watch, session) {
-        if (watch.runtimePage !== undefined && watch.runtimeRevision === watch.eventRevision)
-            return watch.runtimePage;
-        if (watch.runtimeRead !== undefined)
-            return watch.runtimeRead;
-        const revision = watch.eventRevision;
-        const read = this.options.readPage(session, INITIAL_TURN_LIMIT);
-        watch.runtimeRead = read;
-        try {
-            const page = await read;
-            if (this.watches.get(session.id) === watch) {
-                watch.runtimePage = page;
-                watch.runtimeRevision = revision;
-            }
-            return page;
-        }
-        finally {
-            if (this.watches.get(session.id) === watch && watch.runtimeRead === read)
-                watch.runtimeRead = undefined;
-        }
-    }
-    async publishRuntimeSnapshot(watch, generation) {
-        const session = watch.session;
-        if (session === undefined)
-            return;
-        try {
-            const runtime = await this.readRuntimePage(watch, session);
-            if (this.watches.get(session.id) !== watch ||
-                watch.mode !== 'RUNNING' ||
-                watch.transitionGeneration !== generation)
-                return;
-            watch.runtimePage = runtime;
-            this.emitSnapshotToLeases(session, this.composeRuntimePage(watch.page, runtime), true);
-        }
-        catch (error) {
-            this.options.log?.('session.watch.runtime-snapshot.failed', {
-                nodeId: this.options.nodeId?.() ?? 'local-test-node',
-                sessionId: session.id,
-                runner: session.runner,
-                errorCode: diagnosticErrorCode(error, 'SESSION_WATCH_RUNTIME_SNAPSHOT_FAILED')
-            });
-            this.releasePendingEvents(session.id);
-        }
-    }
-    async hydrateRunningHistory(watch, session) {
-        if (this.options.readHistoryPage === undefined || watch.historyRead !== undefined)
-            return;
-        const read = this.options.readHistoryPage(session, INITIAL_TURN_LIMIT);
-        watch.historyRead = read;
-        try {
-            const history = await read;
-            if (this.watches.get(session.id) !== watch || watch.mode !== 'RUNNING')
-                return;
-            watch.page = history;
-            watch.authority = history.source;
-            const generation = watch.transitionGeneration;
-            for (const lease of this.leases.values())
-                if (lease.sessionId === session.id)
-                    lease.ready = false;
-            await this.publishRuntimeSnapshot(watch, generation);
-        }
-        catch (error) {
-            this.options.log?.('session.watch.running-history.failed', {
-                nodeId: this.options.nodeId?.() ?? 'local-test-node',
-                sessionId: session.id,
-                runner: session.runner,
-                errorCode: diagnosticErrorCode(error, 'SESSION_WATCH_HISTORY_FAILED')
-            });
-        }
-        finally {
-            if (this.watches.get(session.id) === watch && watch.historyRead === read)
-                watch.historyRead = undefined;
-        }
-    }
-    async convergeHistory(watch, generation) {
-        if (watch.historyRead !== undefined) {
-            try {
-                await watch.historyRead;
-            }
-            catch {
-                // The running snapshot remains usable; the authoritative convergence below retries.
-            }
-        }
-        const session = watch.session;
-        if (session === undefined ||
-            this.watches.get(session.id) !== watch ||
-            watch.mode !== 'CONVERGING' ||
-            watch.transitionGeneration !== generation)
-            return;
-        await this.refresh(session.id, INITIAL_TURN_LIMIT);
-    }
     emitLeaseEvent(lease, event) {
         this.options.emitWatchEvent?.({
             type: 'watch.session.event',
@@ -583,7 +418,7 @@ export class NativeSessionWatchService {
                 workspaceId: session.workspaceId,
                 sessionId: session.id,
                 revision: 1,
-                snapshotSequence: ++this.snapshotSequence,
+                snapshotSequence: ++this.snapshotNumber,
                 expiresAt: lease.expiresAt,
                 payload
             });
@@ -617,7 +452,7 @@ export class NativeSessionWatchService {
             workspaceId: session.workspaceId,
             sessionId: session.id,
             revision: 1,
-            snapshotSequence: ++this.snapshotSequence,
+            snapshotSequence: ++this.snapshotNumber,
             expiresAt: lease.expiresAt,
             payload
         });
@@ -635,8 +470,7 @@ export class NativeSessionWatchService {
         }
     }
     releaseSnapshotPendingEvents(lease, page) {
-        const pageRecord = isPlainRecord(page) ? page : undefined;
-        const candidateSequence = pageRecord?.snapshotSequence;
+        const candidateSequence = page.snapshotSequence;
         const snapshotSequence = typeof candidateSequence === 'number' &&
             Number.isSafeInteger(candidateSequence) &&
             candidateSequence >= 0
@@ -704,19 +538,3 @@ function diagnosticErrorCode(error, fallback) {
         return error.code;
     return fallback;
 }
-function sessionActivity(event) {
-    if (!isPlainRecord(event.payload))
-        return undefined;
-    if (event.category === 'run' && isPlainRecord(event.payload.run)) {
-        const status = event.payload.run.status;
-        if (status === 'STARTING' || status === 'RUNNING' || status === 'CANCELLING')
-            return 'RUNNING';
-        return undefined;
-    }
-    if (event.category !== 'session')
-        return undefined;
-    const session = event.payload.session;
-    if (!isPlainRecord(session) || typeof session.activity !== 'string')
-        return undefined;
-    return session.activity === 'MANAGED_ACTIVE' ? 'RUNNING' : 'IDLE';
-}

package/dist/service/restart-session-restorer.js

@@ -115,7 +115,7 @@ export class RestartSessionRestorer {
                     deliveryIntent: 'QUEUE',
                     content: `${goals.prompt(session.id, 'continue')}
 ${RESTART_NOTICE}`,
-                    goal: { id: entry.goal.goal.id, revision: entry.goal.goal.revision, epoch: 0 },
+                    goal: this.options.goalReference(session.id),
                     initiatedByUserId: entry.ownerUserId,
                     suppressNotifications: entry.suppressNotifications === true,
                     secretEnvironment: context.secretEnvironment,

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

@@ -5,6 +5,32 @@ export class RunnerInteractionService {
     constructor(options) {
         this.options = options;
     }
+    publishApproval(input) {
+        const run = this.options.runtime.getRun(this.options.runtime.canonicalRunId(input.runId));
+        if (run?.source !== 'SCHEDULED') {
+            this.options.publishApproval(input);
+            return;
+        }
+        this.options.emitRun(input.runId, 'approval.request', input);
+        queueMicrotask(() => {
+            try {
+                this.options.runtime.decideApproval(input.approvalId, 'APPROVED');
+                this.options.emitRun(input.runId, 'approval.decided', {
+                    approvalId: input.approvalId,
+                    decision: 'APPROVED',
+                    source: 'SCHEDULED'
+                });
+                this.options.runners.decideApproval({
+                    runId: input.runId,
+                    approvalId: input.approvalId,
+                    decision: 'APPROVED'
+                });
+            }
+            catch {
+                // A cancelled execution cannot receive an approval after its pending request expires.
+            }
+        });
+    }
     requestClaudeApproval(runId, toolName, toolInput) {
         const approvalId = `claude:${crypto.randomUUID()}`;
         return new Promise((resolve) => {
@@ -49,7 +75,7 @@ export class RunnerInteractionService {
                 timer,
                 resolve: settle
             });
-            this.options.publishApproval({
+            this.publishApproval({
                 runId,
                 approvalId,
                 payload: { toolName, input: toolInput },