@myagentroam/node 0.10.19 → 0.10.21

package/dist/capabilities.js

@@ -56,6 +56,7 @@ export function unavailableCapabilities() {
         openCode: { available: false },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
@@ -91,6 +92,7 @@ export function detectCapabilities(commands = {}) {
         },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
@@ -130,6 +132,7 @@ export async function detectCapabilitiesAsync(commands = {}) {
         },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()

package/dist/connector.js

@@ -102,6 +102,8 @@ import { ComputerUseEnablementService } from './service/computer-use-enablement-
 import { safeErrorCode } from './util/safe-error.js';
 import { RuntimeCredentialControlService } from './service/runtime-credential-control-service.js';
 import { MarAgentRuntimeModelFactory } from './runner/mar-agent/runtime-model-factory.js';
+import { PromptCompletionNodeService } from './service/prompt-completion-node-service.js';
+import { PromptCompletionWorkspaceSource } from './service/prompt-completion-workspace-source.js';
 import { MarAgentModelTransportTestService } from './service/mar-agent-model-transport-test-service.js';
 import { ChatgptLoginService } from './service/chatgpt-login-service.js';
 const HEARTBEAT_MS = 15_000;
@@ -219,6 +221,7 @@ export class NodeConnector {
     sessionIdentityService;
     nativeSessionProjectionService;
     conversationHistoryService;
+    promptCompletion;
     conversationSegmentService;
     runnerInteractionService;
     runnerChannelMessages;
@@ -1191,13 +1194,17 @@ export class NodeConnector {
             nativeIds: (session) => this.nativeSessionProjectionService.nativeIds(session),
             forget: (session, nativeIds) => {
                 this.nativeSessionProjectionService.forget(session, nativeIds);
+                this.promptCompletion.invalidateSession(session.workspaceId, session.id);
                 void this.runAttachmentService.releaseSession(session.id);
             },
             refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
             externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
             isWatching: (sessionId) => this.nativeSessionWatchService.isWatching(sessionId),
             history: (session, input) => this.conversationHistoryService.read(session, input),
-            invalidateHistory: (sessionId) => this.nativeSessionWatchService.invalidate(sessionId),
+            invalidateHistory: (sessionId, workspaceId) => {
+                this.nativeSessionWatchService.invalidate(sessionId);
+                this.promptCompletion.invalidateSession(workspaceId, sessionId);
+            },
             invalidateWorkspaceSessions: (workspaceId) => {
                 this.workspaceSessionService.invalidateCache(workspaceId);
                 void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions');
@@ -1297,6 +1304,7 @@ export class NodeConnector {
             onReconnectScheduled: () => this.metrics.reconnectScheduled(),
             onMessage: (raw) => this.handleMessage(raw),
             onClose: (code, reason) => {
+                this.promptCompletion?.disconnect();
                 this.usageOutbox?.disconnected();
                 this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
@@ -1477,6 +1485,7 @@ export class NodeConnector {
             this.workspaceCoordinator.invalidateChanges(workspaceId);
             this.workspaceSessionService.invalidate(workspaceId);
             this.workspaceCoordinator.clearWatches(workspaceId);
+            this.promptCompletion?.invalidateWorkspace(workspaceId);
         });
         this.workspaceWorkbenchService = new WorkspaceWorkbenchService({
             requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
@@ -1496,6 +1505,53 @@ export class NodeConnector {
             nodeGeneration: () => this.nodeGeneration,
             emitWatchEvent: (payload) => this.send('watch.event', payload)
         });
+        const completionWorkspace = new PromptCompletionWorkspaceSource({
+            requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
+            observesWorkspace: (workspaceId, actor, connectionId) => this.workspaceWatchService.observes(workspaceId, actor.sessionHash, connectionId),
+            observesSession: (workspaceId, sessionId, actor, connectionId) => this.nativeSessionWatchService.observes(actor.sessionHash, connectionId, workspaceId, sessionId),
+            resolveSession: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId),
+            cachedSessions: (workspaceId) => this.workspaceState.sessionCache.get(workspaceId)?.sessions ?? [],
+            readHistory: (session, limit) => this.conversationHistoryService.read(session, { limit })
+        });
+        this.promptCompletion = new PromptCompletionNodeService({
+            generation: () => this.nodeGeneration,
+            readAttentionFile: (input, _actor, event) => {
+                return this.workspaceWorkbenchService.readPredictionFile(input.target.workspaceId, event.path, event.worktreePath);
+            },
+            taskState: (input) => {
+                const id = input.sessionId;
+                if (!id || !this.runtime.getAgentSession(id))
+                    return { goal: 'UNKNOWN', queue: 'UNKNOWN' };
+                const queue = this.runtime.sessionQueue(id);
+                const run = this.runtime.activeSessionRun(id) ?? this.runtime.listRunsForSession(id)[0];
+                const goal = this.goalRuntime.get(id);
+                return {
+                    ...(run ? { runStatus: run.status } : {}),
+                    goal: goal
+                        ? {
+                            id: goal.id,
+                            objective: goal.objective,
+                            status: goal.status,
+                            revision: goal.revision
+                        }
+                        : null,
+                    queue: {
+                        version: queue.version,
+                        paused: queue.paused,
+                        items: queue.itemIds.flatMap((itemId) => {
+                            const item = this.runtime.getQueueItem(itemId);
+                            return item ? [{ queueItemId: item.id, content: item.content }] : [];
+                        })
+                    }
+                };
+            },
+            modelFactory: this.marAgentRuntimeModels,
+            usage: this.modelUsage,
+            observed: (input, actor) => completionWorkspace.observed(input, actor),
+            readPage: (input, actor, signal) => completionWorkspace.readPage(input, actor, signal),
+            references: (workspaceId, _actor, signal) => completionWorkspace.references(workspaceId, signal)
+        });
+        this.operationRouter.registerAll(this.promptCompletion.operations());
         for (const operation of CONVERSATION_TEMPLATE_OPERATIONS)
             this.operationRouter.register(operation, (data) => {
                 const handler = this.conversationTemplateOperations?.[operation];
@@ -1726,6 +1782,7 @@ export class NodeConnector {
         this.stopping = undefined;
         this.stopped = false;
         this.config ??= await loadNodeConfig(this.configPath);
+        this.promptCompletion.initializeJournal(nodeDataDirectory(this.config, this.configPath));
         await this.upgradeCoordinator.loadResult(resolve(dirname(nodeDatabasePath(this.config, this.configPath)), 'upgrade-result.json'));
         await assertLocalSqlitePath(nodeDatabasePath(this.config, this.configPath));
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
@@ -2083,6 +2140,7 @@ export class NodeConnector {
         }
         this.claudeClient.execution.userInputs.clear();
         this.nativeSessionWatchService.clear();
+        this.promptCompletion.dispose();
         this.sessionIdentityService.dispose();
         this.sessionLifecycleService.clear();
         this.continuousRunCoordinator.clear();

package/dist/service/model-usage-service.js

@@ -1,6 +1,7 @@
 import { modelUsageGrantSchema, modelUsageGrantClaimsSchema, modelUsageRecordSchema } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { normalizeMarAgentUsage } from '../runner/mar-agent/conversation-normalizer.js';
 /** Execution-private attribution never enters Run projections or browser Watch events. */
 export class NodeModelUsageService {
     outbox;
@@ -27,7 +28,13 @@ export class NodeModelUsageService {
             const claims = modelUsageGrantClaimsSchema.parse(JSON.parse(Buffer.from(parsedGrant.token.split('.')[0], 'base64url').toString()));
             if (claims.nodeId !== this.nodeId() || claims.scopeId !== parsedGrant.scopeId)
                 return;
-            this.bindings.set(runId, { grant: parsedGrant, scopeId: claims.scopeId, sessionId, runner });
+            this.bindings.set(runId, {
+                userId: claims.userId,
+                grant: parsedGrant,
+                scopeId: claims.scopeId,
+                sessionId,
+                runner
+            });
         }
         catch {
             nodeLog('model.usage.invalid', { code: 'USAGE_GRANT_INVALID' });
@@ -36,6 +43,27 @@ export class NodeModelUsageService {
     release(runId) {
         this.bindings.delete(runId);
     }
+    completion(executionId, grant, sessionId, expectedUserId) {
+        this.bind(executionId, grant, sessionId, 'mar-agent');
+        if (expectedUserId !== undefined && this.bindings.get(executionId)?.userId !== expectedUserId)
+            this.release(executionId);
+        if (!this.bindings.has(executionId))
+            throw new Error('PROMPT_COMPLETION_USAGE_GRANT_REQUIRED');
+        return {
+            onModelUsage: (usage) => this.record(executionId, {
+                ...normalizeMarAgentUsage({
+                    ...usage,
+                    sessionId,
+                    executionId,
+                    purpose: 'other',
+                    agentRole: 'root'
+                }),
+                purpose: 'prompt_completion'
+            }),
+            onModelUsageFailure: () => nodeLog('model.usage.invalid', { code: 'PROMPT_COMPLETION_USAGE_FAILED' }),
+            release: () => this.release(executionId)
+        };
+    }
     promoteSession(previousId, nextId) {
         for (const [runId, binding] of this.bindings)
             if (binding.sessionId === previousId)

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

@@ -199,6 +199,16 @@ export class NativeSessionWatchService {
     has(sessionId) {
         return this.watches.has(sessionId);
     }
+    observes(sessionHash, connectionId, workspaceId, sessionId) {
+        const ownerKey = `${sessionHash}:${connectionId}`;
+        const lease = this.leases.get(ownerKey);
+        return (lease !== undefined &&
+            lease.ready &&
+            lease.expiresAt > Date.now() &&
+            lease.sessionId === sessionId &&
+            lease.workspaceId === workspaceId &&
+            this.sessionWatchSlots.owns(ownerKey, lease.slotToken));
+    }
     isWatching(sessionId) {
         return this.has(sessionId);
     }

package/dist/service/prompt-completion-attention.js

@@ -0,0 +1,66 @@
+import { isAbsolute, win32 } from 'node:path';
+/** Browser observations are hints, not authority to read paths or execute instructions. */
+export async function projectPredictionAttention(events, read, signal, now = Date.now()) {
+    const result = [];
+    let remaining = 4096;
+    for (const event of events.slice(-20).reverse()) {
+        signal.throwIfAborted();
+        if (event.observedAt > now ||
+            now - event.observedAt >= 180_000 ||
+            isAbsolute(event.path) ||
+            win32.isAbsolute(event.path) ||
+            event.path.split(/[\\/]/u).includes('..') ||
+            event.path.includes('\0') ||
+            event.path.startsWith('mar-attachment:'))
+            continue;
+        const metadata = {
+            kind: event.kind,
+            path: event.path,
+            worktreePath: event.worktreePath,
+            source: event.source,
+            observedAt: event.observedAt
+        };
+        // Diff blocks without a verified content identity are metadata-only, never read in full.
+        if (event.kind === 'DIFF' || !event.revision || event.startLine === undefined) {
+            result.push(metadata);
+            if (result.length >= 8)
+                break;
+            continue;
+        }
+        try {
+            const value = (await read(event));
+            signal.throwIfAborted();
+            if (value.revision !== event.revision ||
+                value.encoding !== 'utf-8' ||
+                typeof value.content !== 'string')
+                continue;
+            const lines = value.content.split('\n');
+            // A bounded prefix can end mid-line. Never present that tail as a verified full line.
+            if (value.truncated)
+                lines.pop();
+            const endLine = Math.min(event.endLine, event.startLine + 79, lines.length);
+            if (event.startLine > endLine)
+                continue;
+            const text = lines
+                .slice(event.startLine - 1, endLine)
+                .join('\n')
+                .slice(0, Math.min(2048, remaining));
+            remaining -= text.length;
+            result.push({
+                ...metadata,
+                revision: value.revision,
+                startLine: event.startLine,
+                endLine,
+                text
+            });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            // Missing, moved, changed, binary or inaccessible optional references are omitted.
+        }
+        if (result.length >= 8 || remaining <= 0)
+            break;
+    }
+    return JSON.stringify(result);
+}

package/dist/service/prompt-completion-cache.js

@@ -0,0 +1,312 @@
+import { createHash, randomUUID } from 'node:crypto';
+const EMPTY_REFERENCES = Object.freeze({ epoch: 'empty', messages: [] });
+const MAX_SCOPES = 32;
+const MAX_SESSIONS = 16;
+const MAX_WORKSPACE_BYTES = 2 * 1024 * 1024;
+const MAX_BYTES = 32 * 1024 * 1024;
+/** Node-only material cache. Drafts, generated suggestions and credentials never enter it. */
+export class PromptCompletionCache {
+    scopes = new Map();
+    now;
+    refreshMs;
+    hardTtlMs;
+    disposed = false;
+    reads = 0;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.refreshMs = options.refreshMs ?? 5 * 60_000;
+        this.hardTtlMs = options.hardTtlMs ?? 15 * 60_000;
+    }
+    async references(scope, sessionId, lease, load) {
+        if (this.disposed || !this.authorized(lease))
+            return EMPTY_REFERENCES;
+        const entry = this.entry(scope);
+        entry.lease = lease;
+        entry.load = load;
+        const latest = entry.snapshots.at(-1);
+        if (!latest || this.now() - latest.verifiedAt >= this.refreshMs)
+            await this.build(entry);
+        if (!this.retained(entry) || !this.authorized(lease))
+            return EMPTY_REFERENCES;
+        const pin = sessionId === null ? undefined : entry.pins.get(sessionId);
+        const pinned = pin && this.now() - pin.pinnedAt < this.hardTtlMs
+            ? entry.snapshots.find((value) => value.epoch === pin.epoch)
+            : undefined;
+        const snapshot = pinned && this.now() - pinned.verifiedAt < this.hardTtlMs ? pinned : entry.snapshots.at(-1);
+        if (!snapshot || this.now() - snapshot.verifiedAt >= this.hardTtlMs)
+            return EMPTY_REFERENCES;
+        if (sessionId !== null && snapshot !== pinned) {
+            entry.pins.delete(sessionId);
+            entry.pins.set(sessionId, { epoch: snapshot.epoch, pinnedAt: this.now() });
+            trimMap(entry.pins, MAX_SESSIONS);
+        }
+        return {
+            epoch: snapshot.epoch,
+            messages: snapshot.messages
+                .filter((value) => value.sessionId !== sessionId)
+                .map((value) => value.text)
+        };
+    }
+    /** The caller supplies an authoritative bounded window, not an unverified delta. */
+    session(scope, sessionId, generation, messages) {
+        if (this.disposed)
+            return [];
+        const entry = this.entry(scope);
+        const previous = entry.sessions.get(sessionId);
+        const start = previous?.generation === generation && previous.messages[0]
+            ? messages.findIndex((value) => value.id === previous.messages[0].id)
+            : -1;
+        const bounded = boundMessages(start >= 0 ? messages.slice(start) : messages);
+        const unchangedPrefix = previous?.generation === generation &&
+            previous.messages.length <= bounded.length &&
+            previous.messages.every((old, index) => {
+                const next = bounded[index];
+                return (next?.id === old.id &&
+                    next.revision === old.revision &&
+                    next.role === old.role &&
+                    next.text === old.text);
+            });
+        const result = unchangedPrefix
+            ? [...previous.messages, ...bounded.slice(previous.messages.length)]
+            : bounded;
+        if (!unchangedPrefix)
+            entry.pins.delete(sessionId);
+        entry.sessions.delete(sessionId);
+        entry.lastUsed = this.now();
+        entry.sessions.set(sessionId, { generation, messages: result, refreshedAt: this.now() });
+        trimMap(entry.sessions, MAX_SESSIONS);
+        this.enforceLimits();
+        return result;
+    }
+    /** Maintenance only reclaims idle material; history reads require a manual request. */
+    sweep() {
+        for (const entry of this.scopes.values()) {
+            if (this.now() - entry.lastUsed >= this.hardTtlMs) {
+                this.evict(entry);
+                continue;
+            }
+            for (const [id, window] of entry.sessions)
+                if (this.now() - window.refreshedAt >= this.hardTtlMs) {
+                    entry.sessions.delete(id);
+                    entry.pins.delete(id);
+                }
+            if (!entry.lease || !this.authorized(entry.lease)) {
+                entry.build?.controller.abort();
+                delete entry.load;
+                delete entry.lease;
+                continue;
+            }
+        }
+    }
+    invalidateWorkspace(workspaceId) {
+        for (const entry of this.scopes.values())
+            if (entry.scope.workspaceId === workspaceId)
+                this.evict(entry);
+    }
+    invalidateSession(workspaceId, sessionId) {
+        for (const entry of this.scopes.values()) {
+            if (entry.scope.workspaceId !== workspaceId)
+                continue;
+            // A source removal also invalidates every pinned reference containing that source.
+            if (entry.build ||
+                entry.snapshots.some((snapshot) => snapshot.messages.some((message) => message.sessionId === sessionId)))
+                this.evict(entry);
+            else {
+                entry.sessions.delete(sessionId);
+                entry.pins.delete(sessionId);
+            }
+        }
+    }
+    invalidateView(authorizationView) {
+        for (const entry of this.scopes.values())
+            if (entry.scope.authorizationView === authorizationView)
+                this.evict(entry);
+    }
+    dispose() {
+        this.disposed = true;
+        this.clear();
+    }
+    clear() {
+        for (const entry of this.scopes.values())
+            this.evict(entry);
+    }
+    statistics() {
+        return {
+            scopes: this.scopes.size,
+            bytes: [...this.scopes.values()].reduce((total, entry) => total + bytes(entry), 0)
+        };
+    }
+    authorized(lease) {
+        return lease.expiresAt > this.now() && lease.valid();
+    }
+    entry(scope) {
+        const key = scopeKey(scope);
+        let entry = this.scopes.get(key);
+        if (entry && this.now() - entry.lastUsed >= this.hardTtlMs) {
+            this.evict(entry);
+            entry = undefined;
+        }
+        if (!entry) {
+            entry = {
+                scope: { ...scope },
+                snapshots: [],
+                pins: new Map(),
+                sessions: new Map(),
+                lastUsed: this.now()
+            };
+            this.scopes.set(key, entry);
+        }
+        entry.lastUsed = this.now();
+        // Map order is LRU across views as well as Workspaces.
+        this.scopes.delete(key);
+        this.scopes.set(key, entry);
+        this.enforceLimits();
+        return entry;
+    }
+    retained(entry) {
+        return !this.disposed && this.scopes.get(scopeKey(entry.scope)) === entry;
+    }
+    build(entry) {
+        if (entry.build)
+            return entry.build.promise;
+        const { lease, load } = entry;
+        if (this.reads >= 2 || !lease || !load || !this.authorized(lease) || !this.retained(entry))
+            return Promise.resolve();
+        const controller = new AbortController();
+        const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(1_000)]);
+        const promise = (async () => {
+            try {
+                this.reads++;
+                const loading = Promise.resolve().then(() => {
+                    signal.throwIfAborted();
+                    if (!this.retained(entry) || !this.authorized(lease))
+                        throw new Error('PROMPT_COMPLETION_UNAVAILABLE');
+                    return load(signal);
+                });
+                void loading
+                    .finally(() => {
+                    this.reads--;
+                })
+                    .catch(() => undefined);
+                const values = await abortable(loading, signal);
+                if (signal.aborted || !this.retained(entry) || !this.authorized(lease))
+                    return;
+                const messages = boundReferences(values);
+                const hash = createHash('sha256').update(JSON.stringify(messages)).digest('hex');
+                const latest = entry.snapshots.at(-1);
+                if (latest?.hash === hash)
+                    latest.verifiedAt = this.now();
+                else {
+                    entry.snapshots.push({ epoch: randomUUID(), hash, messages, verifiedAt: this.now() });
+                    if (entry.snapshots.length > 2)
+                        entry.snapshots.shift();
+                    for (const [id, pin] of entry.pins)
+                        if (!entry.snapshots.some((value) => value.epoch === pin.epoch))
+                            entry.pins.delete(id);
+                }
+                this.enforceLimits();
+            }
+            catch {
+                // Optional references may be omitted; failure never renews freshness.
+            }
+            finally {
+                if (entry.build?.controller === controller)
+                    delete entry.build;
+            }
+        })();
+        entry.build = { controller, promise };
+        return promise;
+    }
+    evict(entry) {
+        entry.build?.controller.abort();
+        this.scopes.delete(scopeKey(entry.scope));
+        delete entry.load;
+        delete entry.lease;
+        entry.snapshots.length = 0;
+        entry.sessions.clear();
+        entry.pins.clear();
+    }
+    enforceLimits() {
+        let total = 0;
+        const workspaceBytes = new Map();
+        for (const entry of [...this.scopes.values()].reverse()) {
+            const size = bytes(entry);
+            const workspaceSize = (workspaceBytes.get(entry.scope.workspaceId) ?? 0) + size;
+            if (total + size > MAX_BYTES || workspaceSize > MAX_WORKSPACE_BYTES)
+                this.evict(entry);
+            else {
+                total += size;
+                workspaceBytes.set(entry.scope.workspaceId, workspaceSize);
+            }
+        }
+        while (this.scopes.size > MAX_SCOPES)
+            this.evict(this.scopes.values().next().value);
+    }
+}
+function scopeKey(scope) {
+    return JSON.stringify([scope.workspaceId, scope.generation, scope.authorizationView]);
+}
+function bytes(entry) {
+    return Buffer.byteLength(JSON.stringify([entry.snapshots, [...entry.sessions], [...entry.pins]]));
+}
+function trimMap(map, size) {
+    while (map.size > size)
+        map.delete(map.keys().next().value);
+}
+function boundReferences(values) {
+    const seen = new Set();
+    const result = [];
+    let size = 0;
+    for (const value of values.slice(0, 100)) {
+        const key = JSON.stringify([value.sessionId, value.id]);
+        if (seen.has(key) || !value.text.trim())
+            continue;
+        seen.add(key);
+        const text = clip(value.text, 1_024);
+        if (size + Buffer.byteLength(text) > 8_192 || result.length >= 20)
+            break;
+        size += Buffer.byteLength(text);
+        result.push(Object.freeze({ sessionId: value.sessionId, id: value.id, revision: value.revision, text }));
+    }
+    return Object.freeze(result);
+}
+function boundMessages(values) {
+    const selected = values.slice(-64).map((value) => Object.freeze({
+        id: value.id,
+        revision: value.revision,
+        role: value.role,
+        text: clip(value.text, 4_096)
+    }));
+    let size = selected.reduce((sum, value) => sum + Buffer.byteLength(value.text), 0);
+    if (values.length > 64 || size > 32_768)
+        while (selected.length > 1 && (selected.length > 32 || size > 16_384))
+            size -= Buffer.byteLength(selected.shift().text);
+    return Object.freeze(selected);
+}
+function clip(text, max) {
+    if (text.length <= max)
+        return text;
+    const end = /[\uD800-\uDBFF]/u.test(text[max - 1]) ? max - 1 : max;
+    return `${text.slice(0, end)}\n[truncated]`;
+}
+function abortable(pending, signal) {
+    return new Promise((resolve, reject) => {
+        const aborted = () => {
+            cleanup();
+            reject(signal.reason);
+        };
+        const cleanup = () => signal.removeEventListener('abort', aborted);
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        signal.addEventListener('abort', aborted, { once: true });
+        pending.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}

package/dist/service/prompt-completion-context.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { composerVisibleText } from '@myagentroam/protocol';
+/** Consumes normalized conversation facts; never parses vendor logs or raw tool payloads. */
+export function projectCompletionContext(turns, historyGeneration) {
+    const history = [];
+    const references = [];
+    const seen = new Set();
+    const semantic = [];
+    const tools = [];
+    const waiting = [];
+    const partial = [];
+    let progressRevision = 0;
+    for (const turn of turns.slice(-12)) {
+        semantic.push([turn.id, turn.runId, turn.status]);
+        for (const item of turn.items.slice(-128)) {
+            progressRevision += item.revision;
+            const payload = record(item.payload);
+            if (item.kind === 'user_message') {
+                // Missing delivery is permitted only because the canonical history reader owns it.
+                if (payload.source !== undefined ||
+                    (payload.delivery !== undefined &&
+                        payload.delivery !== 'ACCEPTED' &&
+                        payload.delivery !== 'STEERED'))
+                    continue;
+                const text = typeof payload.text === 'string' ? composerVisibleText(payload.text) : '';
+                const id = typeof payload.clientMessageId === 'string' ? payload.clientMessageId : item.id;
+                if (!text.trim() || seen.has(id))
+                    continue;
+                seen.add(id);
+                const bounded = clip(text, 4_096);
+                history.push({ id, revision: item.revision, role: 'user', text: bounded });
+                references.push({ sessionId: item.sessionId, id, revision: item.revision, text: bounded });
+                semantic.push([id, item.revision, bounded]);
+            }
+            else if (item.kind === 'assistant_message' && typeof payload.text === 'string') {
+                if (item.status === 'COMPLETED') {
+                    if (seen.has(item.id))
+                        continue;
+                    seen.add(item.id);
+                    const text = clip(payload.text, 4_096);
+                    history.push({ id: item.id, revision: item.revision, role: 'assistant', text });
+                    semantic.push([item.id, item.revision, text]);
+                }
+                else if (item.status === 'IN_PROGRESS' && turn.id === turns.at(-1)?.id)
+                    partial.push(clip(payload.text, 1_024));
+            }
+            else if (['approval', 'user_input_request'].includes(item.kind)) {
+                semantic.push([item.id, item.revision, item.status]);
+                if (turn.id === turns.at(-1)?.id &&
+                    (item.status === 'PENDING' || item.status === 'IN_PROGRESS'))
+                    waiting.push({ kind: item.kind, status: item.status });
+            }
+            else if (['tool_call', 'command_execution', 'file_change'].includes(item.kind)) {
+                // Tool names, arguments, titles, paths, output and error bodies are not copied.
+                if (turn.id === turns.at(-1)?.id)
+                    tools.push({ category: item.kind, status: item.status });
+            }
+        }
+    }
+    const contextVersion = createHash('sha256')
+        .update(JSON.stringify([historyGeneration, semantic]))
+        .digest('hex');
+    return {
+        identity: { historyGeneration, contextVersion, progressRevision },
+        history: history.slice(-64),
+        references: references.slice(-20),
+        executionSnapshot: JSON.stringify({
+            status: turns.at(-1)?.status ?? 'IDLE',
+            tools: tools.slice(-6),
+            waiting: waiting.slice(-6),
+            partialAssistant: partial.slice(-3)
+        })
+    };
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function clip(text, max) {
+    if (text.length <= max)
+        return text;
+    const half = Math.floor((max - 32) / 2);
+    const head = text.slice(0, half).replace(/[\uD800-\uDBFF]$/u, '');
+    const tail = text.slice(-half).replace(/^[\uDC00-\uDFFF]/u, '');
+    return `${head}\n[excerpt omitted]\n${tail}`;
+}