@myagentroam/node 0.10.20 → 0.10.21

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

@@ -0,0 +1,241 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { PromptCompletionJournal } from './prompt-completion-journal.js';
+import { promptCompletionContextInputSchema, promptCompletionGenerateInputSchema, promptCompletionRuntimeSchema, promptCompletionCancelSchema, modelUsageGrantSchema } from '@myagentroam/protocol';
+import { PromptCompletionCache } from './prompt-completion-cache.js';
+import { projectCompletionContext } from './prompt-completion-context.js';
+import { withPredictionTaskState } from './prompt-completion-task-context.js';
+import { projectPredictionAttention } from './prompt-completion-attention.js';
+import { PromptCompletionService } from './prompt-completion-service.js';
+/** Owns the auxiliary domain; Connector only supplies existing readers and lifecycle hooks. */
+export class PromptCompletionNodeService {
+    options;
+    cache;
+    journal;
+    requests;
+    contextReaders = new Map();
+    disposed = false;
+    refreshTimer;
+    generations = new Map();
+    now;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.cache = new PromptCompletionCache({ now: this.now });
+        this.requests = new PromptCompletionService({
+            record: async (entry) => {
+                await this.journal?.record(entry);
+            },
+            now: this.now,
+            modelFactory: options.modelFactory,
+            ...(options.generate ? { generate: options.generate } : {}),
+            authorized: (raw) => {
+                const authorization = raw;
+                return this.options.observed(authorization.input, authorization.actor);
+            },
+            context: async (raw, request, signal) => {
+                const authorization = raw;
+                signal.throwIfAborted();
+                const context = await this.readContext(authorization.input, authorization.actor, signal);
+                const sessionId = authorization.input.sessionId;
+                return {
+                    ...context,
+                    ...(request.attention?.length && this.options.readAttentionFile
+                        ? {
+                            attention: await projectPredictionAttention(request.attention, (event) => this.options.readAttentionFile(authorization.input, authorization.actor, event), signal, this.now())
+                        }
+                        : {}),
+                    history: sessionId === null
+                        ? context.history
+                        : this.cache.session(authorization.scope, sessionId, context.identity.historyGeneration, context.history)
+                };
+            },
+            references: async (raw, _request, signal) => {
+                const authorization = raw;
+                // The refresh closure captures only authorized resource metadata, never the draft.
+                const { actor, input, scope, expiresAt } = authorization;
+                const lease = { expiresAt, valid: () => this.options.observed(input, actor) };
+                const result = await this.cache.references(scope, input.sessionId, lease, (readSignal) => this.options.references(scope.workspaceId, actor, readSignal));
+                signal.throwIfAborted();
+                return result.messages;
+            },
+            usage: (raw) => {
+                const authorization = raw;
+                return this.options.usage.completion(authorization.executionId, authorization.usageGrant, authorization.input.sessionId ?? authorization.executionId, authorization.actor.userId);
+            }
+        });
+        this.refreshTimer = setInterval(() => {
+            this.cache.sweep();
+        }, 30_000);
+        this.refreshTimer.unref?.();
+    }
+    operations() {
+        return {
+            'prompt-completion.context': (raw) => this.context(raw),
+            'prompt-completion.generate': (raw) => this.generate(raw),
+            'prompt-completion.cancel': (raw) => this.cancel(raw)
+        };
+    }
+    async context(raw) {
+        if (this.disposed)
+            throw new Error('PROMPT_COMPLETION_UNAVAILABLE');
+        const { actor, data } = unpack(raw);
+        const input = promptCompletionContextInputSchema.parse(data);
+        if (this.contextReaders.has(actor.userId) || this.contextReaders.size >= 2)
+            throw new Error('PROMPT_COMPLETION_CONTEXT_BUSY');
+        const controller = new AbortController();
+        this.contextReaders.set(actor.userId, controller);
+        const timer = setTimeout(() => controller.abort(), 1_000);
+        timer.unref?.();
+        const signal = controller.signal;
+        const pending = this.readContext(input, actor, signal)
+            .then((context) => context.identity)
+            .finally(() => {
+            clearTimeout(timer);
+            this.contextReaders.delete(actor.userId);
+        });
+        return new Promise((resolve, reject) => {
+            const abort = () => reject(new Error('PROMPT_COMPLETION_CONTEXT_TIMEOUT'));
+            signal.addEventListener('abort', abort, { once: true });
+            pending.then((value) => {
+                signal.removeEventListener('abort', abort);
+                resolve(value);
+            }, (error) => {
+                signal.removeEventListener('abort', abort);
+                reject(error);
+            });
+            if (signal.aborted)
+                abort();
+        });
+    }
+    generate(raw) {
+        const { actor, data, usageGrant } = unpack(raw);
+        const { runtime: rawRuntime, ...publicInput } = data;
+        const input = promptCompletionGenerateInputSchema.parse(publicInput);
+        const runtime = promptCompletionRuntimeSchema.parse(rawRuntime);
+        if (runtime.expiresAt > this.now() + 30_000)
+            throw new Error('PROMPT_COMPLETION_AUTHORIZATION_INVALID');
+        if (input.target.kind === 'WORKSPACE' && input.target.workspaceId !== runtime.workspaceId)
+            throw new Error('PROMPT_COMPLETION_AUTHORIZATION_INVALID');
+        const descriptor = {
+            target: input.target,
+            runner: input.request.runner,
+            sessionId: input.request.sessionId,
+            workbenchConnectionId: input.workbenchConnectionId,
+            pageEpoch: input.request.pageEpoch
+        };
+        const authorization = {
+            ...runtime,
+            usageGrant: modelUsageGrantSchema.parse(usageGrant),
+            userId: String(actor.userId),
+            actor,
+            input: descriptor,
+            runtime,
+            scope: {
+                workspaceId: runtime.workspaceId,
+                generation: this.options.generation(),
+                authorizationView: digest([runtime.authorizationView, input.target])
+            },
+            executionId: randomUUID()
+        };
+        return this.requests.generate({ ...input.request, pageEpoch: epoch(actor, descriptor.pageEpoch) }, authorization);
+    }
+    cancel(raw) {
+        const { actor, data } = unpack(raw);
+        const input = promptCompletionCancelSchema.parse(data);
+        this.requests.cancel(String(actor.userId), {
+            ...input,
+            pageEpoch: epoch(actor, input.pageEpoch)
+        });
+        return { cancelled: true };
+    }
+    async readContext(input, actor, signal) {
+        if (!this.options.observed(input, actor))
+            throw new Error('PROMPT_COMPLETION_CONTEXT_UNAVAILABLE');
+        const generation = this.historyGeneration(input.target, input.sessionId, input.runner);
+        const turns = await this.options.readPage(input, actor, signal);
+        signal.throwIfAborted();
+        if (!this.options.observed(input, actor) ||
+            generation !== this.historyGeneration(input.target, input.sessionId, input.runner))
+            throw new Error('PROMPT_COMPLETION_CONTEXT_UNAVAILABLE');
+        const context = projectCompletionContext(turns, generation);
+        return this.options.taskState
+            ? withPredictionTaskState(context, this.options.taskState(input, actor))
+            : context;
+    }
+    initializeJournal(dataDirectory) {
+        this.journal?.dispose();
+        this.journal = new PromptCompletionJournal(dataDirectory, this.now);
+    }
+    sweep() {
+        this.cache.sweep();
+    }
+    disconnect() {
+        for (const controller of this.contextReaders.values())
+            controller.abort();
+        this.requests.disconnect();
+        this.cache.clear();
+        this.generations.clear();
+    }
+    invalidateWorkspace(workspaceId) {
+        this.cache.invalidateWorkspace(workspaceId);
+        this.requests.invalidateWorkspace(workspaceId);
+        for (const [key, entry] of this.generations)
+            if (entry.target.kind === 'WORKSPACE' && entry.target.workspaceId === workspaceId)
+                this.generations.delete(key);
+    }
+    invalidateUser(userId) {
+        this.requests.invalidateUser(String(userId));
+        // Permission changes retire all reference views; they can be rebuilt after fresh authorization.
+        this.cache.clear();
+    }
+    invalidateSession(workspaceId, sessionId) {
+        // Retire source material without interrupting an already frozen prediction request.
+        this.cache.invalidateSession(workspaceId, sessionId);
+    }
+    releasePage(actor, pageEpoch) {
+        this.requests.releasePage(String(actor.userId), epoch(actor, pageEpoch));
+    }
+    dispose() {
+        this.disposed = true;
+        clearInterval(this.refreshTimer);
+        for (const controller of this.contextReaders.values())
+            controller.abort();
+        this.requests.dispose();
+        this.journal?.dispose();
+        this.cache.dispose();
+        this.generations.clear();
+    }
+    historyGeneration(target, sessionId, runner) {
+        const key = digest([this.options.generation(), target, sessionId, runner]);
+        let entry = this.generations.get(key);
+        if (!entry) {
+            entry = { generation: randomUUID(), target };
+            this.generations.set(key, entry);
+        }
+        while (this.generations.size > 256)
+            this.generations.delete(this.generations.keys().next().value);
+        return entry.generation;
+    }
+}
+function unpack(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        throw new Error('MESSAGE_INVALID');
+    const { __requestUserId, __workspaceWatchSessionHash, __usageGrant, ...data } = raw;
+    if (typeof __requestUserId !== 'number' ||
+        !Number.isSafeInteger(__requestUserId) ||
+        __requestUserId <= 0 ||
+        typeof __workspaceWatchSessionHash !== 'string' ||
+        !__workspaceWatchSessionHash)
+        throw new Error('USER_AUTHORIZATION_REQUIRED');
+    return {
+        actor: { userId: __requestUserId, sessionHash: __workspaceWatchSessionHash },
+        data,
+        usageGrant: __usageGrant
+    };
+}
+function epoch(actor, pageEpoch) {
+    return digest([actor.sessionHash, pageEpoch]);
+}
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}

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

@@ -0,0 +1,311 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { generatePromptCompletion } from './prompt-completion-generator.js';
+import { promptCompletionRequestSchema, promptCompletionCancelSchema } from '@myagentroam/protocol';
+/** One manual auxiliary request; it never mutates a Session or enqueues a Run. */
+export class PromptCompletionService {
+    options;
+    pages = new Map();
+    rates = new Map();
+    affinities = new Map();
+    now;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+    }
+    async generate(raw, authorization) {
+        const request = promptCompletionRequestSchema.parse(raw);
+        const startedAt = this.now();
+        const analysis = {};
+        let result;
+        let failed = false;
+        let failureCode;
+        try {
+            result = await this.execute(request, authorization, analysis);
+            return result;
+        }
+        catch (error) {
+            failed = true;
+            const code = error?.code;
+            failureCode =
+                typeof code === 'string' && /^[A-Z][A-Z0-9_]{0,95}$/.test(code)
+                    ? code
+                    : 'PROMPT_COMPLETION_FAILED';
+            throw error;
+        }
+        finally {
+            const context = JSON.stringify(analysis);
+            try {
+                await this.options.record?.({
+                    schemaVersion: 1,
+                    startedAt,
+                    finishedAt: this.now(),
+                    durationMs: this.now() - startedAt,
+                    requestId: request.requestId,
+                    workspaceId: authorization.scope.workspaceId,
+                    userId: authorization.userId,
+                    runner: request.runner,
+                    sessionId: request.sessionId,
+                    modelId: authorization.model.id,
+                    providerModelId: authorization.model.modelId,
+                    reasoningEffort: authorization.reasoningEffort,
+                    input: {
+                        trigger: request.trigger,
+                        draft: request.draft,
+                        cursorPosition: request.cursorPosition,
+                        mode: request.completionMode
+                    },
+                    context: context.slice(0, 96_000),
+                    contextTruncated: context.length > 96_000,
+                    output: result?.status === 'ready' ? result.suggestion : null,
+                    status: failed ? 'failed' : result?.status,
+                    reason: failed ? failureCode : result?.status === 'skipped' ? result.reason : undefined
+                });
+            }
+            catch {
+                console.warn('PROMPT_COMPLETION_JOURNAL_WRITE_FAILED');
+            }
+        }
+    }
+    async execute(request, authorization, analysis) {
+        const identity = responseIdentity(request);
+        this.prune();
+        if (!this.allowed(authorization))
+            return { ...identity, status: 'skipped', reason: 'UNAVAILABLE' };
+        const pageKey = JSON.stringify([authorization.userId, request.pageEpoch]);
+        const previous = this.pages.get(pageKey);
+        if (previous && (previous.closed || request.intentSequence <= previous.sequence))
+            return { ...identity, status: 'cancelled' };
+        if (previous?.active)
+            return { ...identity, status: 'skipped', reason: 'IN_FLIGHT' };
+        if (!previous && !this.hasPageCapacity(authorization.userId))
+            return { ...identity, status: 'skipped', reason: 'CAPACITY' };
+        const active = [...this.pages.values()].filter((page) => page.active);
+        if (active.some((page) => page.userId === authorization.userId))
+            return { ...identity, status: 'skipped', reason: 'IN_FLIGHT' };
+        if (active.length >= 2)
+            return { ...identity, status: 'skipped', reason: 'CAPACITY' };
+        const controller = new AbortController();
+        const page = {
+            userId: authorization.userId,
+            requestId: request.requestId,
+            sequence: request.intentSequence,
+            expiresAt: this.now() + 60_000,
+            closed: false,
+            active: { controller, workspaceId: authorization.scope.workspaceId }
+        };
+        this.pages.set(pageKey, page);
+        const timeout = setTimeout(() => controller.abort(), Math.min(this.options.timeoutMs ?? 12_000, authorization.expiresAt - this.now()));
+        const signal = controller.signal;
+        // Retain physical capacity until cleanup finishes, even if a slow reader ignores abort.
+        const running = (async () => {
+            try {
+                const context = await this.options.context(authorization, request, signal);
+                if (!this.allowed(authorization) || signal.aborted)
+                    return { ...identity, status: 'cancelled' };
+                if (context.identity.historyGeneration !== request.historyGeneration)
+                    return { ...identity, status: 'cancelled' };
+                analysis.context = context;
+                const references = await this.options.references(authorization, request, signal);
+                analysis.references = references;
+                if (!this.allowed(authorization) || signal.aborted)
+                    return { ...identity, status: 'cancelled' };
+                if (!request.draft && context.history.length === 0 && references.length === 0)
+                    return { ...identity, status: 'empty' };
+                const calls = (this.rates.get(authorization.userId) ?? []).filter((time) => time > this.now() - 60_000);
+                if (!this.rates.has(authorization.userId) && this.rates.size >= 4096)
+                    return { ...identity, status: 'skipped', reason: 'CAPACITY' };
+                const wait = Math.max(0, 2_000 - (this.now() - (calls.at(-1) ?? -Infinity)), calls.length >= 20 ? 60_000 - (this.now() - calls[0]) : 0);
+                if (wait > 0)
+                    return { ...identity, status: 'skipped', reason: 'RATE_LIMITED', retryAfterMs: wait };
+                calls.push(this.now());
+                this.rates.set(authorization.userId, calls);
+                const [model] = this.options.modelFactory.create([authorization.model], {
+                    runtimeScopeId: authorization.runtimeScopeId,
+                    executionId: authorization.executionId
+                });
+                if (!model)
+                    throw new Error('PROMPT_COMPLETION_MODEL_UNAVAILABLE');
+                let usage;
+                let suggestion;
+                try {
+                    usage = this.options.usage(authorization);
+                    ({ suggestion } = await (this.options.generate ?? generatePromptCompletion)({
+                        model,
+                        reasoningEffort: authorization.reasoningEffort,
+                        history: context.history,
+                        referenceMessages: references,
+                        executionSnapshot: context.executionSnapshot,
+                        onPreparedInput: (value) => {
+                            analysis.preparedInput = value;
+                        },
+                        onPredictionOutput: (value) => {
+                            analysis.modelOutput = value;
+                        },
+                        ...(context.attention ? { attention: context.attention } : {}),
+                        draft: request.draft,
+                        cursorPosition: request.cursorPosition,
+                        completionMode: request.completionMode,
+                        promptCacheKey: this.affinity(authorization),
+                        signal,
+                        ...(usage.onModelUsage ? { onModelUsage: usage.onModelUsage } : {}),
+                        ...(usage.onModelUsageFailure ? { onModelUsageFailure: usage.onModelUsageFailure } : {})
+                    }));
+                }
+                finally {
+                    try {
+                        usage?.release();
+                    }
+                    finally {
+                        await model.credentialProvider?.close();
+                    }
+                }
+                if (!this.allowed(authorization) || signal.aborted)
+                    return { ...identity, status: 'cancelled' };
+                await this.options.validateAuthorization?.(authorization);
+                if (!this.allowed(authorization) || signal.aborted)
+                    return { ...identity, status: 'cancelled' };
+                const expiresAt = Math.min(this.now() + 30_000, authorization.expiresAt);
+                return suggestion === null
+                    ? { ...identity, status: 'empty' }
+                    : { ...identity, status: 'ready', suggestion, source: 'generated', expiresAt };
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return { ...identity, status: 'cancelled' };
+                throw error;
+            }
+            finally {
+                clearTimeout(timeout);
+                delete page.active;
+            }
+        })();
+        return new Promise((resolve, reject) => {
+            const aborted = () => {
+                cleanup();
+                resolve({ ...identity, status: 'cancelled' });
+            };
+            const cleanup = () => signal.removeEventListener('abort', aborted);
+            // Transport errors remain rejections; no response body or draft is logged here.
+            void running.then((value) => {
+                cleanup();
+                resolve(value);
+            }, (error) => {
+                cleanup();
+                reject(error);
+            });
+            if (signal.aborted)
+                aborted();
+            else
+                signal.addEventListener('abort', aborted, { once: true });
+        });
+    }
+    /** Identity is authenticated separately; cancellation does not require generation rights. */
+    cancel(userId, raw) {
+        const request = promptCompletionCancelSchema.parse(raw);
+        this.prune();
+        const key = JSON.stringify([userId, request.pageEpoch]);
+        const page = this.pages.get(key);
+        if (page && request.intentSequence < page.sequence)
+            return;
+        if (page && request.intentSequence === page.sequence && page.requestId !== request.requestId)
+            throw new Error('PROMPT_COMPLETION_INTENT_CONFLICT');
+        if (!page && !this.hasPageCapacity(userId))
+            throw new Error('PROMPT_COMPLETION_CAPACITY');
+        page?.active?.controller.abort();
+        if (page) {
+            page.sequence = request.intentSequence;
+            page.requestId = request.requestId;
+            page.expiresAt = this.now() + 60_000;
+        }
+        else
+            this.pages.set(key, {
+                userId,
+                requestId: request.requestId,
+                sequence: request.intentSequence,
+                expiresAt: this.now() + 60_000,
+                closed: false
+            });
+    }
+    invalidateWorkspace(workspaceId) {
+        for (const page of this.pages.values())
+            if (page.active?.workspaceId === workspaceId)
+                page.active.controller.abort();
+        this.affinities.clear();
+    }
+    invalidateUser(userId) {
+        for (const [key, page] of this.pages)
+            if (JSON.parse(key)[0] === userId)
+                page.active?.controller.abort();
+        this.affinities.clear();
+    }
+    releasePage(userId, pageEpoch) {
+        const page = this.pages.get(JSON.stringify([userId, pageEpoch]));
+        if (!page)
+            return;
+        page.closed = true;
+        page.expiresAt = this.now() + 60_000;
+        page.active?.controller.abort();
+    }
+    disconnect() {
+        for (const page of this.pages.values())
+            page.active?.controller.abort();
+        this.affinities.clear();
+    }
+    dispose() {
+        this.disposed = true;
+        for (const page of this.pages.values())
+            page.active?.controller.abort();
+        this.rates.clear();
+        this.affinities.clear();
+        this.pages.clear();
+    }
+    allowed(authorization) {
+        return (!this.disposed &&
+            authorization.expiresAt > this.now() &&
+            this.options.authorized(authorization));
+    }
+    affinity(authorization) {
+        const identity = digest([
+            authorization.userId,
+            authorization.scope,
+            authorization.modelRevision,
+            authorization.credentialScope
+        ]);
+        const found = this.affinities.get(identity);
+        if (found && found.expiresAt > this.now())
+            return found.key;
+        const entry = { key: randomUUID(), expiresAt: this.now() + 15 * 60_000 };
+        this.affinities.set(identity, entry);
+        while (this.affinities.size > 128)
+            this.affinities.delete(this.affinities.keys().next().value);
+        return entry.key;
+    }
+    prune() {
+        for (const [key, page] of this.pages)
+            if (!page.active && page.expiresAt <= this.now())
+                this.pages.delete(key);
+        for (const [key, value] of this.affinities)
+            if (value.expiresAt <= this.now())
+                this.affinities.delete(key);
+        for (const [key, calls] of this.rates)
+            if ((calls.at(-1) ?? 0) <= this.now() - 60_000)
+                this.rates.delete(key);
+    }
+    hasPageCapacity(userId) {
+        return (this.pages.size < 4096 &&
+            [...this.pages.values()].filter((page) => page.userId === userId).length < 128);
+    }
+}
+function responseIdentity(request) {
+    return {
+        requestId: request.requestId,
+        contextVersion: request.contextVersion,
+        historyGeneration: request.historyGeneration,
+        draftRevision: request.draftRevision,
+        cursorPosition: request.cursorPosition
+    };
+}
+function digest(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}

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

@@ -0,0 +1,51 @@
+import { createHash } from 'node:crypto';
+import { composerVisibleText } from '@myagentroam/protocol';
+/** Uses canonical task state only; pending work is the existing Goal/Queue/waiting projection. */
+export function withPredictionTaskState(context, task) {
+    const snapshot = JSON.parse(context.executionSnapshot);
+    const runStatus = task.runStatus ?? snapshot.status;
+    const waiting = snapshot.waiting;
+    const phase = waiting.some((item) => item.kind === 'approval')
+        ? 'WAITING_APPROVAL'
+        : waiting.some((item) => item.kind === 'user_input_request')
+            ? 'WAITING_INPUT'
+            : ['RUNNING', 'STARTING', 'QUEUED', 'IN_PROGRESS'].includes(runStatus)
+                ? 'RUNNING'
+                : ['COMPLETED', 'SUCCEEDED'].includes(runStatus)
+                    ? 'COMPLETED'
+                    : runStatus === 'FAILED'
+                        ? 'FAILED'
+                        : runStatus === 'IDLE'
+                            ? 'IDLE'
+                            : 'UNKNOWN';
+    const goal = typeof task.goal === 'object' && task.goal !== null
+        ? { ...task.goal, objective: composerVisibleText(task.goal.objective).slice(0, 2048) }
+        : task.goal;
+    const queue = task.queue === 'UNKNOWN'
+        ? 'UNKNOWN'
+        : {
+            version: task.queue.version,
+            paused: task.queue.paused,
+            total: task.queue.items.length,
+            items: task.queue.items.slice(0, 8).map((item) => ({
+                id: item.queueItemId,
+                text: composerVisibleText(item.content).slice(0, 768),
+                status: 'QUEUED_NOT_EXECUTED'
+            }))
+        };
+    const tasks = { phase, goal, queue, pendingWork: { source: 'GOAL_QUEUE_WAITING', waiting } };
+    return {
+        ...context,
+        identity: {
+            ...context.identity,
+            contextVersion: createHash('sha256')
+                .update(JSON.stringify([context.identity.contextVersion, tasks]))
+                .digest('hex')
+        },
+        executionSnapshot: JSON.stringify({
+            ...snapshot,
+            status: task.runStatus ?? snapshot.status,
+            ...tasks
+        })
+    };
+}

package/dist/service/prompt-completion-workspace-source.js

@@ -0,0 +1,62 @@
+import { projectCompletionContext } from './prompt-completion-context.js';
+/** Uses the existing Workspace catalog and normalized history readers; never scans a second index. */
+export class PromptCompletionWorkspaceSource {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    observed(input, actor) {
+        if (input.target.kind !== 'WORKSPACE')
+            return false;
+        return input.sessionId === null
+            ? this.options.observesWorkspace(input.target.workspaceId, actor, input.workbenchConnectionId)
+            : this.options.observesSession(input.target.workspaceId, input.sessionId, actor, input.workbenchConnectionId);
+    }
+    async readPage(input, actor, signal) {
+        if (input.target.kind !== 'WORKSPACE' || !this.observed(input, actor))
+            throw new Error('PROMPT_COMPLETION_CONTEXT_UNAVAILABLE');
+        this.options.requireWorkspace(input.target.workspaceId);
+        signal.throwIfAborted();
+        if (input.sessionId === null)
+            return [];
+        const session = await this.options.resolveSession(input.sessionId);
+        if (!session ||
+            session.workspaceId !== input.target.workspaceId ||
+            session.runner !== input.runner)
+            throw new Error('PROMPT_COMPLETION_CONTEXT_UNAVAILABLE');
+        signal.throwIfAborted();
+        if (!this.observed(input, actor))
+            throw new Error('PROMPT_COMPLETION_CONTEXT_UNAVAILABLE');
+        const page = await this.options.readHistory(session, 20);
+        signal.throwIfAborted();
+        if (!this.observed(input, actor))
+            throw new Error('PROMPT_COMPLETION_CONTEXT_UNAVAILABLE');
+        return page.turns;
+    }
+    async references(workspaceId, signal) {
+        this.options.requireWorkspace(workspaceId);
+        signal.throwIfAborted();
+        const sessions = this.options
+            .cachedSessions(workspaceId)
+            .filter((session) => session.workspaceId === workspaceId && session.externalDiscovered !== false)
+            .sort((left, right) => right.lastActivityAt - left.lastActivityAt || left.id.localeCompare(right.id))
+            .slice(0, 4);
+        const messages = [];
+        for (const session of sessions) {
+            signal.throwIfAborted();
+            try {
+                const page = await this.options.readHistory(session, 20);
+                signal.throwIfAborted();
+                const projection = projectCompletionContext(page.turns, 'reference');
+                messages.push(...projection.references
+                    .slice(-20)
+                    .map((message) => ({ ...message, sessionId: session.id })));
+            }
+            catch {
+                signal.throwIfAborted();
+                // Reference history is optional; an unavailable source does not block the current draft.
+            }
+        }
+        return messages;
+    }
+}

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

@@ -142,7 +142,7 @@ export class SessionCatalogService {
                 ? { ...source, lastActivityAt }
                 : this.options.runtime.resetAgentSessionHistory(runtimeSession.id, lastActivityAt);
             this.options.projection.remember([session]);
-            this.options.invalidateHistory(session.id);
+            this.options.invalidateHistory(session.id, session.workspaceId);
             this.options.invalidateWorkspaceSessions(session.workspaceId);
             this.options.emitSession(session);
             return { session: this.options.present(session) };