@myagentroam/node 0.11.38 → 0.11.40

package/dist/service/supervised-node-child.js

@@ -0,0 +1,153 @@
+import { spawn } from 'node:child_process';
+import { terminateProcessTree } from '../process-tree.js';
+/** Wait for the child process itself, not inherited output handles held by descendants. */
+export function runSupervisedNodeChild(entrypoint, configPath, accept, accepted, upgradeAttemptId) {
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [entrypoint, 'run', '--config', configPath], {
+            windowsHide: true,
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            env: {
+                ...process.env,
+                MAR_NODE_SUPERVISED: '1',
+                ...(upgradeAttemptId === undefined ? {} : { MAR_NODE_UPGRADE_ATTEMPT_ID: upgradeAttemptId })
+            },
+            detached: process.platform !== 'win32'
+        });
+        let done = false;
+        let signalled = false;
+        let channelId;
+        let accepting = false;
+        let handoff;
+        let forced = false;
+        let reclaiming = false;
+        let reclaimed = false;
+        let exited;
+        let deadline;
+        let reapDeadline;
+        const finish = (code, reclaimFailed = false) => {
+            if (done)
+                return;
+            done = true;
+            if (deadline !== undefined)
+                clearTimeout(deadline);
+            if (reapDeadline !== undefined)
+                clearTimeout(reapDeadline);
+            process.off('SIGINT', onSigint);
+            process.off('SIGTERM', onSigterm);
+            if (child.connected)
+                child.disconnect();
+            if (reclaimFailed)
+                child.unref();
+            resolve({
+                code,
+                signalled,
+                ...(handoff === undefined ? {} : { handoff }),
+                ...(forced ? { forced: true } : {}),
+                ...(reclaimFailed ? { reclaimFailed: true } : {})
+            });
+        };
+        const forward = (signal) => {
+            if (signalled)
+                return;
+            signalled = true;
+            child.kill(signal);
+        };
+        const onSigint = () => forward('SIGINT');
+        const onSigterm = () => forward('SIGTERM');
+        process.on('SIGINT', onSigint);
+        process.on('SIGTERM', onSigterm);
+        child.on('error', () => {
+            if (child.pid === undefined)
+                finish(null);
+        });
+        child.once('exit', (code) => {
+            exited = { code };
+            if (!reclaiming || reclaimed)
+                finish(code);
+        });
+        child.on('message', (message) => {
+            if (done || signalled || typeof message !== 'object' || message === null)
+                return;
+            const value = message;
+            if (value['type'] === 'node-upgrade-hello' &&
+                channelId === undefined &&
+                typeof value['channelId'] === 'string') {
+                channelId = value['channelId'];
+                send(child, { type: 'node-upgrade-ready', channelId });
+                return;
+            }
+            if (value['type'] !== 'node-upgrade-handoff' ||
+                value['channelId'] !== channelId ||
+                channelId === undefined ||
+                accepting ||
+                handoff !== undefined ||
+                typeof value['id'] !== 'string' ||
+                typeof value['attemptId'] !== 'string' ||
+                typeof value['targetVersion'] !== 'string' ||
+                typeof value['credential'] !== 'string')
+                return;
+            const id = value['id'];
+            const request = {
+                attemptId: value['attemptId'],
+                targetVersion: value['targetVersion'],
+                credential: value['credential']
+            };
+            accepting = true;
+            void accept(request)
+                .then((ok) => {
+                if (done || signalled)
+                    return;
+                if (!ok) {
+                    accepting = false;
+                    send(child, { type: 'node-upgrade-ack', channelId, id, accepted: false });
+                    return;
+                }
+                accepted(request);
+                handoff = request;
+                deadline = setTimeout(() => {
+                    if (done || signalled)
+                        return;
+                    forced = true;
+                    reclaiming = true;
+                    reapDeadline = setTimeout(() => finish(null, true), 10_000);
+                    void terminateProcessTree(child)
+                        .then(() => {
+                        reclaimed = true;
+                        if (exited !== undefined)
+                            finish(exited.code);
+                    })
+                        .catch(() => finish(null, true));
+                    if (process.platform !== 'win32' && child.pid !== undefined) {
+                        try {
+                            process.kill(-child.pid, 'SIGKILL');
+                        }
+                        catch {
+                            try {
+                                child.kill('SIGKILL');
+                            }
+                            catch {
+                                /* Wait for exit or timeout. */
+                            }
+                        }
+                    }
+                }, 25_000);
+                send(child, { type: 'node-upgrade-ack', channelId, id, accepted: true });
+            })
+                .catch(() => {
+                accepting = false;
+                if (!done && !signalled)
+                    send(child, { type: 'node-upgrade-ack', channelId, id, accepted: false });
+            });
+        });
+    });
+}
+function send(child, message) {
+    if (!child.connected)
+        return;
+    try {
+        child.send(message, () => undefined);
+    }
+    catch {
+        /* An absent ACK leaves the child blocked. */
+    }
+}

package/dist/service/supervisor-upgrade-handoff.js

@@ -0,0 +1,104 @@
+import { randomUUID } from 'node:crypto';
+/** Parent capability is established once at startup; a handoff is never retried. */
+export class SupervisorUpgradeHandoff {
+    parent;
+    channelId = randomUUID();
+    supported = false;
+    uncertain = false;
+    handshakeResolve;
+    pending;
+    constructor(parent = process) {
+        this.parent = parent;
+        parent.on('message', this.onMessage);
+    }
+    async handshake() {
+        if (!this.parent.connected || this.parent.send === undefined)
+            return false;
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.handshakeResolve = undefined;
+                resolve(false);
+            }, 1_000);
+            timer.unref();
+            this.handshakeResolve = (supported) => {
+                clearTimeout(timer);
+                this.handshakeResolve = undefined;
+                resolve(supported);
+            };
+            try {
+                this.parent.send({ type: 'node-upgrade-hello', channelId: this.channelId }, (error) => {
+                    if (error !== null)
+                        this.handshakeResolve?.(false);
+                });
+            }
+            catch {
+                this.handshakeResolve?.(false);
+            }
+        });
+    }
+    async handoff(input) {
+        if (!this.supported || !this.parent.connected || this.parent.send === undefined)
+            throw new Error('NODE_UPGRADE_HANDOFF_UNAVAILABLE');
+        if (this.uncertain)
+            throw new Error('NODE_UPGRADE_HANDOFF_UNCERTAIN');
+        if (this.pending !== undefined)
+            throw new Error('NODE_UPGRADE_HANDOFF_ALREADY_PENDING');
+        const id = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending = undefined;
+                this.uncertain = true;
+                reject(new Error('NODE_UPGRADE_HANDOFF_UNCERTAIN'));
+            }, 5_000);
+            timer.unref();
+            this.pending = {
+                id,
+                resolve: () => {
+                    clearTimeout(timer);
+                    this.pending = undefined;
+                    resolve();
+                },
+                reject: (error) => {
+                    clearTimeout(timer);
+                    this.pending = undefined;
+                    reject(error);
+                }
+            };
+            try {
+                this.parent.send({ type: 'node-upgrade-handoff', channelId: this.channelId, id, ...input }, (error) => {
+                    if (error !== null && this.pending?.id === id)
+                        this.pending.reject(new Error('NODE_UPGRADE_HANDOFF_UNAVAILABLE'));
+                });
+            }
+            catch {
+                this.pending?.reject(new Error('NODE_UPGRADE_HANDOFF_UNAVAILABLE'));
+            }
+        });
+    }
+    close() {
+        this.parent.off('message', this.onMessage);
+        this.handshakeResolve?.(false);
+        this.pending?.reject(new Error('NODE_UPGRADE_HANDOFF_UNCERTAIN'));
+    }
+    onMessage = (message) => {
+        if (typeof message !== 'object' || message === null)
+            return;
+        const value = message;
+        if (value['channelId'] !== this.channelId)
+            return;
+        if (value['type'] === 'node-upgrade-ready' && this.handshakeResolve !== undefined) {
+            this.supported = true;
+            this.handshakeResolve?.(true);
+            this.handshakeResolve = undefined;
+        }
+        else if (value['type'] === 'node-upgrade-ack') {
+            const pending = this.pending;
+            if (pending === undefined || value['id'] !== pending.id)
+                return;
+            if (value['accepted'] === true)
+                pending.resolve();
+            else
+                pending.reject(new Error('NODE_UPGRADE_HANDOFF_REJECTED'));
+        }
+    };
+}

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

@@ -22,9 +22,19 @@ export class NativeSessionProjectionService {
             createProjection: (input) => this.project(input)
         }, workspace);
         const ordered = deduplicateDirectSessions(sessions);
-        if (!cleanup)
+        if (!cleanup) {
             this.remember(ordered);
-        return ordered;
+            return ordered.flatMap((session) => {
+                const accepted = this.directNative.get(session.id);
+                return accepted === undefined ? [] : [accepted];
+            });
+        }
+        return ordered.flatMap((session) => {
+            const record = database.getSessionRecord(session.id);
+            if (record === undefined && session.parentSessionId != null)
+                return [];
+            return [{ ...session, parentSessionId: record?.metadata.parentSessionId ?? null }];
+        });
     }
     async discoverCodex(workspaceId) {
         const sessions = await this.discover('codex', workspaceId);
@@ -209,7 +219,9 @@ export class NativeSessionProjectionService {
             access: metadata?.access ?? null,
             customTitle: metadata?.customTitle ?? null,
             sessionPrompt: metadata?.sessionPrompt ?? null,
-            parentSessionId: metadata?.parentSessionId ?? null,
+            parentSessionId: metadata === undefined
+                ? (input.parentSessionId ?? null)
+                : (metadata.parentSessionId ?? null),
             runnerTitle,
             pinnedAt: metadata?.pinnedAt ?? null,
             pinOrder: metadata?.pinOrder ?? null,
@@ -227,7 +239,57 @@ export class NativeSessionProjectionService {
     }
     remember(sessions) {
         const database = this.options.database();
-        for (const session of sessions) {
+        const candidates = new Map(sessions.map((session) => [session.id, session]));
+        const validParent = (session) => {
+            const visited = new Set([session.id]);
+            let parentId = session.parentSessionId ?? null;
+            let depth = 1;
+            while (parentId !== null) {
+                if (visited.has(parentId) || ++depth > 3)
+                    return false;
+                visited.add(parentId);
+                const stored = database?.getSessionRecord(parentId);
+                const candidate = stored === undefined ? candidates.get(parentId) : undefined;
+                if ((stored?.workspaceId ?? candidate?.workspaceId) !== session.workspaceId)
+                    return false;
+                parentId =
+                    stored === undefined
+                        ? (candidate?.parentSessionId ?? null)
+                        : (stored.metadata.parentSessionId ?? null);
+            }
+            return true;
+        };
+        const valid = new Map(sessions.map((session) => [session.id, validParent(session)]));
+        const accepted = sessions.flatMap((proposed) => {
+            const metadata = database === undefined || proposed.externalSessionId === null
+                ? undefined
+                : database.getNativeSessionMetadata(proposed.runner, proposed.externalSessionId, proposed.workspaceId);
+            if (metadata === undefined &&
+                proposed.parentSessionId != null &&
+                (database === undefined || !valid.get(proposed.id)))
+                return [];
+            const parentSessionId = metadata !== undefined
+                ? (metadata.parentSessionId ?? null)
+                : database !== undefined && valid.get(proposed.id)
+                    ? (proposed.parentSessionId ?? null)
+                    : null;
+            return [{ ...proposed, parentSessionId }];
+        });
+        const acceptedById = new Map(accepted.map((session) => [session.id, session]));
+        const ordered = [];
+        const visited = new Set();
+        const visit = (session) => {
+            if (visited.has(session.id))
+                return;
+            visited.add(session.id);
+            const parent = session.parentSessionId == null ? undefined : acceptedById.get(session.parentSessionId);
+            if (parent !== undefined)
+                visit(parent);
+            ordered.push(session);
+        };
+        for (const session of accepted)
+            visit(session);
+        for (const session of ordered) {
             this.directNative.set(session.id, session);
             if (database === undefined || session.externalSessionId === null)
                 continue;
@@ -239,6 +301,9 @@ export class NativeSessionProjectionService {
                     runner: session.runner,
                     externalSessionId: session.externalSessionId,
                     workspaceId: session.workspaceId,
+                    ...(metadata === undefined && session.parentSessionId != null
+                        ? { parentSessionId: session.parentSessionId }
+                        : {}),
                     ...(title === undefined || metadata?.runnerTitlePending ? {} : { runnerTitle: title })
                 });
         }
@@ -327,8 +392,6 @@ export class NativeSessionProjectionService {
         return ids;
     }
     forget(session, knownNativeIds) {
-        if (session.externalSessionId === null)
-            return;
         const projectionIds = new Set([session.id]);
         const nativeIds = new Set(knownNativeIds);
         const runner = this.options.runners.require(session.runner);

package/dist/session/operation-admission.js

@@ -0,0 +1,7 @@
+/** Internal-only signal: caller cancellation is checked until the Session owner accepts work. */
+export const SESSION_ADMISSION_SIGNAL = Symbol('session-admission-signal');
+export function checkSessionAdmission(input) {
+    const signal = input[SESSION_ADMISSION_SIGNAL];
+    if (signal instanceof AbortSignal)
+        signal.throwIfAborted();
+}

package/dist/session/runtime/conversation-projection.js

@@ -218,7 +218,10 @@ export function conversationItemFromEvent(event) {
             : {}),
         ...(permissionStop.success ? { permissionStop: permissionStop.data } : {}),
         merge: event.payload.merge === true,
-        ...(append === 'sections' || append === 'outputPreview' || append === 'outputSummary'
+        ...(append === 'sections' ||
+            append === 'outputPreview' ||
+            append === 'outputSummary' ||
+            append === 'output'
             ? { append }
             : {})
     };
@@ -257,7 +260,7 @@ function projectableConversationStatus(value) {
         'INTERRUPTED'
     ].includes(value);
 }
-function mergeConversationItemPayload(existing, next) {
+export function mergeConversationItemPayload(existing, next) {
     const base = next.merge && isRecord(existing) ? existing : {};
     const value = { ...base, ...next.payload };
     if (next.append === 'sections') {
@@ -287,11 +290,30 @@ function mergeConversationItemPayload(existing, next) {
         const incoming = typeof next.payload.outputSummary === 'string' ? next.payload.outputSummary : '';
         value.outputSummary = appendProjectionText(prior, incoming);
     }
+    if (next.append === 'output' &&
+        isRecord(next.payload.output) &&
+        typeof next.payload.output.text === 'string') {
+        const prior = isRecord(base.output) && typeof base.output.text === 'string' ? base.output : undefined;
+        const text = `${prior?.text ?? ''}${next.payload.output.text}`;
+        value.output = {
+            text: boundedOutputTail(text),
+            truncated: prior?.truncated === true || next.payload.output.truncated === true || text.length > 10_000
+        };
+        if (typeof next.payload.outputPreview === 'string') {
+            value.outputPreview = boundedOutputTail(`${typeof base.outputPreview === 'string' ? base.outputPreview : ''}${next.payload.outputPreview}`);
+        }
+    }
     return value;
 }
+function boundedOutputTail(text) {
+    if (text.length <= 10_000)
+        return text;
+    const tail = text.slice(-10_000);
+    return /^[\uDC00-\uDFFF]/u.test(tail) ? tail.slice(1) : tail;
+}
 function appendProjectionText(previous, next) {
     const text = `${previous}${next}`;
-    return text.length <= 10_000 ? text : `${text.slice(0, 9_999)}…`;
+    return text.length <= 10_000 ? text : `${text.slice(0, 9_999).replace(/[\uD800-\uDBFF]$/, '')}…`;
 }
 export function activeConversationItem(status) {
     return status === 'PENDING' || status === 'IN_PROGRESS';

package/dist/session/session-catalog-service.js

@@ -57,34 +57,47 @@ export class SessionCatalogService {
             throw new Error('WORKSPACE_NOT_FOUND');
         if (typeof input.sessionId !== 'string')
             throw new Error('SESSION_INVALID');
+        if (input.includeAncestors !== undefined && typeof input.includeAncestors !== 'boolean')
+            throw new Error('SESSION_INVALID');
         const limit = input.limit === undefined ? 100 : input.limit;
         if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > 100)
             throw new Error('SESSION_INVALID');
-        const sessions = await this.collect({ workspaceId: input.workspaceId, registeredOnly: true });
-        const root = sessions.find((session) => session.id === input.sessionId);
-        if (root === undefined)
+        const database = this.options.database();
+        let root = database.getSessionRecord(input.sessionId);
+        if (root === undefined || root.workspaceId !== input.workspaceId)
             throw new Error('SESSION_NOT_FOUND');
-        const children = new Map();
-        for (const session of sessions) {
-            if (session.parentSessionId == null)
-                continue;
-            const siblings = children.get(session.parentSessionId) ?? [];
-            siblings.push(session);
-            children.set(session.parentSessionId, siblings);
+        const ancestors = new Set([root.id]);
+        while (input.includeAncestors === true && typeof root.metadata.parentSessionId === 'string') {
+            const parent = database.getSessionRecord(root.metadata.parentSessionId);
+            if (parent === undefined ||
+                parent.workspaceId !== input.workspaceId ||
+                ancestors.has(parent.id))
+                throw new Error('SESSION_PARENT_INVALID');
+            ancestors.add(parent.id);
+            root = parent;
         }
         const queue = [root];
         const visited = new Set([root.id]);
         const nodes = [];
         for (let index = 0; index < queue.length && index < limit; index += 1) {
             const session = queue[index];
+            const active = this.options.runtime.getAgentSession(session.id);
+            const live = active === undefined ? undefined : this.options.present(active);
             nodes.push({
                 id: session.id,
-                parentSessionId: session.parentSessionId ?? null,
-                title: session.customTitle ?? session.runnerTitle ?? 'Untitled session',
+                parentSessionId: session.metadata.parentSessionId ?? null,
+                title: live?.customTitle ??
+                    session.metadata.customTitle ??
+                    live?.runnerTitle ??
+                    session.metadata.runnerTitle ??
+                    'Untitled session',
                 runner: session.runner,
-                ...('activity' in session ? { activity: session.activity } : {})
+                activity: live && 'activity' in live ? live.activity : 'IDLE'
             });
-            for (const child of children.get(session.id) ?? []) {
+            const children = [...database.listChildSessionRecords(input.workspaceId, session.id)];
+            if (input.includeAncestors === true)
+                children.sort((left, right) => Number(ancestors.has(right.id)) - Number(ancestors.has(left.id)));
+            for (const child of children) {
                 if (visited.has(child.id))
                     continue;
                 visited.add(child.id);
@@ -302,13 +315,98 @@ export class SessionCatalogService {
         if (session === undefined)
             throw new Error('SESSION_NOT_FOUND');
         try {
-            await this.removeResolved(session);
+            await this.removeTree(session);
             return { deleted: true };
         }
         finally {
             this.options.invalidateWorkspaceSessions(session.workspaceId);
         }
     }
+    async removeTree(root) {
+        if (root.externalSessionId === null)
+            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        const database = this.options.database();
+        const live = this.options.runtime
+            .listAgentSessions()
+            .filter((session) => session.workspaceId === root.workspaceId);
+        const liveChildren = new Map();
+        for (const session of live) {
+            if (session.parentSessionId == null)
+                continue;
+            const children = liveChildren.get(session.parentSessionId) ?? [];
+            children.push(session.externalSessionId ?? session.id);
+            liveChildren.set(session.parentSessionId, children);
+        }
+        const ids = [root.externalSessionId];
+        const seen = new Set(ids);
+        const parents = new Map();
+        const releases = [];
+        const locked = new Set();
+        const lock = (id) => {
+            const actual = this.options.runtime.getAgentSession(id)?.id ?? id;
+            if (locked.has(actual))
+                return;
+            releases.push(this.options.runtime.beginSessionHistoryMutation(actual, { allowQueued: true }));
+            locked.add(actual);
+        };
+        try {
+            lock(root.id);
+            for (let index = 0; index < ids.length; index += 1) {
+                const parent = ids[index];
+                const children = [
+                    ...database.listChildSessionRecords(root.workspaceId, parent).map((record) => record.id),
+                    ...(liveChildren.get(parent) ?? [])
+                ];
+                for (const child of children) {
+                    if (seen.has(child)) {
+                        if (parents.get(child) !== parent)
+                            throw new Error('SESSION_RELATION_INVALID');
+                        continue;
+                    }
+                    seen.add(child);
+                    parents.set(child, parent);
+                    lock(child);
+                    ids.push(child);
+                }
+            }
+            const sessions = [];
+            for (const id of ids) {
+                const session = this.options.runtime.getAgentSession(id) ??
+                    (await this.options.projection.resolve(id, true));
+                if (session === undefined || session.workspaceId !== root.workspaceId)
+                    throw new Error('SESSION_NOT_FOUND');
+                sessions.push(session);
+            }
+            // Validate every member before performing any irreversible native deletion.
+            for (const session of sessions)
+                await this.assertRemovable(session);
+            const batches = new Map();
+            for (const session of [...sessions].reverse()) {
+                if (session.externalSessionId === null)
+                    continue;
+                const runner = this.options.runners.require(session.runner);
+                if (runner.supportsNativeBatchRemoval?.() === true) {
+                    const members = batches.get(session.runner) ?? [];
+                    members.push(session);
+                    batches.set(session.runner, members);
+                }
+                else
+                    await this.removeNativeHistories(session, this.options.nativeIds(session));
+            }
+            for (const [runner, members] of batches)
+                await this.options.runners.require(runner).removeNativeMembers(members);
+            // Preserve every relationship if any native owner fails, so retries cannot
+            // lose sight of descendants whose native cleanup was already attempted.
+            for (const session of sessions.reverse()) {
+                this.options.database().deleteSessionRecord(session.id);
+                this.options.forget(session, this.options.nativeIds(session));
+            }
+        }
+        finally {
+            for (const release of releases.reverse())
+                release();
+        }
+    }
     async cleanupWorkspaceSessions(input) {
         const inactiveDays = input.inactiveDays;
         if (typeof input.workspaceId !== 'string' ||
@@ -360,6 +458,7 @@ export class SessionCatalogService {
                 candidates.set(session.id, session);
             }
             this.mergePersisted(candidates, workspaceId, false);
+            const candidateParents = new Set([...candidates.values()].flatMap((candidate) => candidate.parentSessionId === null ? [] : [candidate.parentSessionId]));
             candidateCount = candidates.size;
             for (const session of candidates.values()) {
                 budget.check();
@@ -373,6 +472,14 @@ export class SessionCatalogService {
                         session.lastActivityAt > 0 &&
                         session.lastActivityAt >= cutoff) ||
                     (session.pinOrder !== null && session.pinOrder !== undefined) ||
+                    (session.externalSessionId !== null &&
+                        (this.options.database().listChildSessionRecords(workspaceId, session.externalSessionId)
+                            .length > 0 ||
+                            candidateParents.has(session.externalSessionId) ||
+                            this.options.runtime
+                                .listAgentSessions()
+                                .some((child) => child.workspaceId === workspaceId &&
+                                child.parentSessionId === session.externalSessionId))) ||
                     this.options.isWatching(session.id) ||
                     this.options.isRecovering?.(session.id) ||
                     this.options.runtime.sessionQueue(session.id).itemIds.length > 0 ||
@@ -452,6 +559,39 @@ export class SessionCatalogService {
             lastActivityAt: latestSessionActivityAt(projected.lastActivityAt, native.lastActivityAt)
         };
     }
+    async assertRemovable(session) {
+        if (this.options.isRecovering?.(session.id))
+            throw new Error('SESSION_RESTART_PENDING');
+        if (this.options.runtime
+            .listRunsForSession(session.id)
+            .some((run) => !isTerminalRunStatus(run.status)))
+            throw new Error('SESSION_ACTIVE');
+        if (session.externalSessionId !== null && session.nativeControl === 'EXTERNAL') {
+            await this.options.refreshActivity(session);
+            if (this.options.externalActivity(session.id) === 'BUSY')
+                throw new Error('SESSION_ACTIVE');
+        }
+    }
+    async removeNativeHistories(session, nativeIds) {
+        const runner = this.options.runners.require(session.runner);
+        let deleted = false;
+        for (const externalSessionId of nativeIds) {
+            try {
+                const result = await runner.removeNative(session, externalSessionId);
+                if (result === true)
+                    deleted = true;
+                else if (result === false) {
+                    await removeNativeSession(session.runner, session.cwd, externalSessionId);
+                    deleted = true;
+                }
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.message !== 'NATIVE_TRANSCRIPT_UNAVAILABLE')
+                    throw error;
+            }
+        }
+        return deleted;
+    }
     async removeResolved(session, requireCleanupSafety = false, budget) {
         if (session.externalSessionId === null)
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
@@ -493,23 +633,7 @@ export class SessionCatalogService {
                 this.options.forget(session, nativeIds);
                 return 'deleted';
             }
-            const runner = this.options.runners.require(session.runner);
-            let deleted = false;
-            for (const externalSessionId of nativeIds) {
-                try {
-                    const result = await runner.removeNative(session, externalSessionId);
-                    if (result === true)
-                        deleted = true;
-                    else if (result === false) {
-                        await removeNativeSession(session.runner, session.cwd, externalSessionId);
-                        deleted = true;
-                    }
-                }
-                catch (error) {
-                    if (!(error instanceof Error) || error.message !== 'NATIVE_TRANSCRIPT_UNAVAILABLE')
-                        throw error;
-                }
-            }
+            const deleted = await this.removeNativeHistories(session, nativeIds);
             this.options.database().deleteSessionRecord(session.id);
             this.options.forget(session, nativeIds);
             return deleted ? 'deleted' : 'skipped';