@openforge-app/plugin-sdk 0.2.8 → 0.2.10

package/dist/testing/commonApiFake.js

@@ -1,6 +1,71 @@
-import { resolveExternalTextFileChunkSize } from '../types.js';
+import { MAX_AGENT_SESSION_PAGE_SIZE, resolveExternalTextFileChunkSize } from '../types.js';
 import { assertFunction, assertTitle, commandDescriptor, createDisposable, isJsonValue, normalizeAgentCommandMetadata, } from './support.js';
 const UTF8_ENCODER = new TextEncoder();
+const UTF8_DECODER = new TextDecoder('utf-8', { fatal: true });
+const TERMINAL_AGENT_SESSION_STATUSES = new Set(['completed', 'failed', 'interrupted']);
+function encodeAgentSessionCursor(payload) {
+    const bytes = UTF8_ENCODER.encode(JSON.stringify(payload));
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+}
+function parseAgentSessionCursor(cursor) {
+    try {
+        const base64 = cursor.replaceAll('-', '+').replaceAll('_', '/');
+        const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, '=');
+        const binary = atob(padded);
+        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+        const payload = JSON.parse(UTF8_DECODER.decode(bytes));
+        const filters = payload.filters;
+        if (payload.version !== 1
+            || !Number.isSafeInteger(payload.createdAt)
+            || typeof payload.id !== 'string'
+            || payload.id.length === 0
+            || !filters
+            || typeof filters.provider !== 'string'
+            || !Number.isSafeInteger(filters.startInclusive)
+            || !Number.isSafeInteger(filters.endExclusive)
+            || (filters.taskId !== null && typeof filters.taskId !== 'string')) {
+            throw new Error('invalid payload');
+        }
+        return payload;
+    }
+    catch {
+        throw new TypeError('cursor is malformed');
+    }
+}
+function providerSessionId(session) {
+    switch (session.provider) {
+        case 'opencode': return session.opencode_session_id;
+        case 'claude-code': return session.claude_session_id;
+        case 'pi': return session.pi_session_id;
+        case 'grok': return session.grok_session_id;
+        default: return null;
+    }
+}
+function assertNonNegativeSafeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+}
+function testingExternalFileIdentity(file) {
+    return file.identity ?? `${file.root}:${file.path}`;
+}
+function readTestingExternalTextRange(file, startOffsetBytes, maxBytes, expectedIdentity) {
+    assertNonNegativeSafeInteger(startOffsetBytes, 'startOffsetBytes');
+    if (maxBytes !== undefined)
+        assertNonNegativeSafeInteger(maxBytes, 'maxBytes');
+    const identity = testingExternalFileIdentity(file);
+    if (expectedIdentity !== undefined && expectedIdentity !== identity) {
+        throw new Error(`External file identity changed: expected ${expectedIdentity}, received ${identity}`);
+    }
+    const bytes = UTF8_ENCODER.encode(file.content);
+    const endOffsetBytes = maxBytes === undefined
+        ? bytes.byteLength
+        : Math.min(bytes.byteLength, startOffsetBytes + maxBytes);
+    return UTF8_DECODER.decode(bytes.slice(startOffsetBytes, endOffsetBytes));
+}
 function* splitExternalTextFile(content, maxBytes) {
     let chunk = '';
     let chunkBytes = 0;
@@ -45,6 +110,100 @@ export class TestingCommonApiFake {
             context: {
                 getSnapshot: () => this.services.getContextSnapshot(),
             },
+            agentSessions: {
+                list: async (request) => {
+                    if (typeof request.provider !== 'string' || request.provider.trim().length === 0) {
+                        throw new TypeError('provider must be a non-empty string');
+                    }
+                    if (request.taskId !== undefined && (typeof request.taskId !== 'string' || request.taskId.trim().length === 0)) {
+                        throw new TypeError('taskId must be a non-empty string');
+                    }
+                    if (request.cursor !== undefined && (typeof request.cursor !== 'string' || request.cursor.length === 0)) {
+                        throw new TypeError('cursor must be a non-empty string');
+                    }
+                    if (!request.overlaps || typeof request.overlaps !== 'object') {
+                        throw new TypeError('overlaps must contain startInclusive and endExclusive');
+                    }
+                    assertNonNegativeSafeInteger(request.overlaps.startInclusive, 'overlaps.startInclusive');
+                    assertNonNegativeSafeInteger(request.overlaps.endExclusive, 'overlaps.endExclusive');
+                    if (request.overlaps.startInclusive >= request.overlaps.endExclusive) {
+                        throw new RangeError('overlaps must satisfy startInclusive < endExclusive');
+                    }
+                    if (!Number.isSafeInteger(request.pageSize)
+                        || request.pageSize < 1
+                        || request.pageSize > MAX_AGENT_SESSION_PAGE_SIZE) {
+                        throw new RangeError(`pageSize must be between 1 and ${MAX_AGENT_SESSION_PAGE_SIZE}`);
+                    }
+                    const filters = {
+                        provider: request.provider,
+                        startInclusive: request.overlaps.startInclusive,
+                        endExclusive: request.overlaps.endExclusive,
+                        taskId: request.taskId ?? null,
+                    };
+                    const cursor = request.cursor === undefined ? null : parseAgentSessionCursor(request.cursor);
+                    if (cursor !== null
+                        && (cursor.filters.provider !== filters.provider
+                            || cursor.filters.startInclusive !== filters.startInclusive
+                            || cursor.filters.endExclusive !== filters.endExclusive
+                            || cursor.filters.taskId !== filters.taskId)) {
+                        throw new TypeError('cursor does not match request filters');
+                    }
+                    this.services.calls.agentSessionListRequests.push({
+                        ...request,
+                        overlaps: { ...request.overlaps },
+                    });
+                    const taskById = new Map(this.services.seededTasks.map((task) => [task.id, task]));
+                    const rows = this.services.seededAgentSessions
+                        .filter((session) => taskById.has(session.ticket_id))
+                        .filter((session) => session.provider === request.provider)
+                        .filter((session) => request.taskId === undefined || session.ticket_id === request.taskId)
+                        .filter((session) => session.created_at < request.overlaps.endExclusive
+                        && (!TERMINAL_AGENT_SESSION_STATUSES.has(session.status)
+                            || session.updated_at > request.overlaps.startInclusive))
+                        .filter((session) => cursor === null
+                        || session.created_at > cursor.createdAt
+                        || (session.created_at === cursor.createdAt && session.id > cursor.id))
+                        .slice()
+                        .sort((left, right) => left.created_at - right.created_at
+                        || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+                    const pageRows = rows.slice(0, request.pageSize);
+                    const items = pageRows.map((session) => {
+                        const task = taskById.get(session.ticket_id);
+                        if (!task)
+                            throw new Error(`Missing seeded Task for Agent Session ${session.id}`);
+                        const workspace = this.services.agentSessionWorkspaces[task.id];
+                        return {
+                            id: session.id,
+                            provider: session.provider,
+                            providerSessionId: providerSessionId(session),
+                            createdAt: session.created_at,
+                            updatedAt: session.updated_at,
+                            task: {
+                                id: task.id,
+                                title: task.title?.trim() || task.id,
+                                status: task.status,
+                                createdAt: task.created_at,
+                                updatedAt: task.updated_at,
+                            },
+                            workspace: workspace
+                                ? { rootPath: workspace.rootPath, kind: workspace.kind }
+                                : null,
+                        };
+                    });
+                    const last = pageRows.at(-1);
+                    return {
+                        items,
+                        nextCursor: rows.length > request.pageSize && last
+                            ? encodeAgentSessionCursor({
+                                version: 1,
+                                createdAt: last.created_at,
+                                id: last.id,
+                                filters,
+                            })
+                            : null,
+                    };
+                },
+            },
             tasks: {
                 list: async (request) => {
                     const projectId = request?.projectId ?? null;
@@ -125,6 +284,16 @@ export class TestingCommonApiFake {
                 },
                 getWorkspace: async () => null,
                 getLatestSession: async () => null,
+                listSessions: async (request) => {
+                    this.services.calls.taskSessionListRequests.push({ ...request });
+                    return this.services.seededAgentSessions
+                        .map((session, index) => ({ session, index }))
+                        .filter(({ session }) => session.ticket_id === request.taskId)
+                        .filter(({ session }) => request.provider === undefined || session.provider === request.provider)
+                        .filter(({ session }) => request.createdAtOrAfter === undefined || session.created_at >= request.createdAtOrAfter)
+                        .sort((left, right) => right.session.created_at - left.session.created_at || right.index - left.index)
+                        .map(({ session }) => session);
+                },
             },
             projects: {
                 list: async () => [],
@@ -146,7 +315,6 @@ export class TestingCommonApiFake {
                 write: async (request) => {
                     this.services.calls.shellWrites.push(request);
                 },
-                writeTerminalQueryResponse: async () => { },
                 resize: async (request) => {
                     this.services.calls.shellResizes.push(request);
                 },
@@ -215,10 +383,17 @@ export class TestingCommonApiFake {
                     },
                     readTextFile: async (request) => {
                         this.services.calls.fsUserDataReads.push(request);
-                        return '';
+                        return this.services.userDataTextFiles.get(request.path) ?? '';
                     },
                     writeTextFile: async (request) => {
                         this.services.calls.fsUserDataWrites.push(request);
+                        this.services.userDataTextFiles.set(request.path, request.content);
+                    },
+                    appendTextFile: async (request) => {
+                        this.services.calls.fsUserDataAppends.push(request);
+                        const content = `${this.services.userDataTextFiles.get(request.path) ?? ''}${request.content}`;
+                        this.services.userDataTextFiles.set(request.path, content);
+                        return { sizeBytes: UTF8_ENCODER.encode(content).byteLength };
                     },
                 },
                 external: {
@@ -230,14 +405,39 @@ export class TestingCommonApiFake {
                         this.services.calls.fsExternalReads.push(request);
                         return '';
                     },
+                    stat: async (request) => {
+                        this.services.calls.fsExternalStats.push(request);
+                        const file = this.services.externalTextFiles.find(candidate => candidate.root === request.root && candidate.path === request.path);
+                        if (!file)
+                            throw new Error(`External file not found: ${request.root}/${request.path}`);
+                        return {
+                            identity: testingExternalFileIdentity(file),
+                            sizeBytes: UTF8_ENCODER.encode(file.content).byteLength,
+                            modifiedAtMs: file.modifiedAtMs ?? null,
+                        };
+                    },
                     readTextFileChunks: (request) => {
                         const chunkSizeBytes = resolveExternalTextFileChunkSize(request.chunkSizeBytes);
-                        const { root, path, signal } = request;
-                        this.services.calls.fsExternalReadTextFileChunks.push({ root, path, chunkSizeBytes });
-                        const content = this.services.externalTextFiles.find(file => file.root === root && file.path === path)?.content ?? '';
+                        const { root, path, signal, expectedIdentity, startOffsetBytes = 0, maxBytes, } = request;
+                        this.services.calls.fsExternalReadTextFileChunks.push({
+                            root,
+                            path,
+                            chunkSizeBytes,
+                            ...(expectedIdentity === undefined ? {} : { expectedIdentity }),
+                            ...(request.startOffsetBytes === undefined ? {} : { startOffsetBytes }),
+                            ...(maxBytes === undefined ? {} : { maxBytes }),
+                        });
+                        const file = this.services.externalTextFiles.find(candidate => candidate.root === root && candidate.path === path);
                         return (async function* () {
+                            signal?.throwIfAborted();
+                            if (!file)
+                                throw new Error(`External file not found: ${root}/${path}`);
+                            const content = readTestingExternalTextRange(file, startOffsetBytes, maxBytes, expectedIdentity);
                             for (const chunk of splitExternalTextFile(content, chunkSizeBytes)) {
                                 signal?.throwIfAborted();
+                                if (expectedIdentity !== undefined && testingExternalFileIdentity(file) !== expectedIdentity) {
+                                    throw new Error(`External file identity changed: expected ${expectedIdentity}, received ${testingExternalFileIdentity(file)}`);
+                                }
                                 yield chunk;
                             }
                             signal?.throwIfAborted();

package/dist/testing/contracts.d.ts

@@ -1,14 +1,17 @@
 import type { BrowserSurfaceVisualFeedback } from '../browserSurfaces';
 import type { TestingOpenForgeRegistryFake } from './registryFake';
-import type { BackendMethodRegistration, BackendOpenForgeAPI, BackgroundServiceRegistration, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ConfigureStartPromptContributionRequest, CreateTaskRequest, FrontendOpenForgeAPI, InjectionPointLocation, JsonValue, NotificationRequest, OpenForgeNavigationRequest, OpenForgePackageMetadata, PluginSettingsSectionRegistration, PluginStorage, PluginTaskPaneTabRegistration, PluginTaskUISectionRegistration, PluginViewRegistration, ShellSpawnRequest, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskLinkOpenRequest, TaskStartPrefixContext, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, UserDataDirectoryRequest, UserDataFileRequest, UserDataFileWriteRequest } from '../types';
-import type { Task } from '../domain';
+import type { BackendMethodRegistration, BackendOpenForgeAPI, BackgroundServiceRegistration, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ConfigureStartPromptContributionRequest, CreateTaskRequest, FrontendOpenForgeAPI, InjectionPointLocation, AgentSessionWorkspace, ListAgentSessionsRequest, ListTaskSessionsRequest, JsonValue, NotificationRequest, OpenForgeNavigationRequest, OpenForgePackageMetadata, PluginSettingsSectionRegistration, PluginStorage, PluginTaskPaneTabRegistration, PluginReviewRowActionRegistration, PluginTaskUISectionRegistration, PluginViewRegistration, ShellSpawnRequest, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskStartPrefixContext, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, UserDataDirectoryRequest, UserDataFileRequest, UserDataFileWriteRequest } from '../types';
+import type { AgentSession, Task } from '../domain';
 export type TestingRuntimeScope = 'global' | 'project' | 'task';
-export type TestingRuntimeKind = 'commands' | 'events' | 'views' | 'taskPane' | 'taskUI' | 'settings' | 'backend' | 'background';
+export type TestingRuntimeKind = 'commands' | 'events' | 'views' | 'taskPane' | 'taskUI' | 'reviewUI' | 'settings' | 'backend' | 'background';
 export type TestingMaybePromise<T> = T | Promise<T>;
 export type TestingCommandHandler = (payload?: unknown) => TestingMaybePromise<unknown>;
 export type TestingEventHandler = (payload: unknown) => void;
 export interface TestingExternalTextFile extends ExternalReadFileRequest {
     content: string;
+    /** Defaults to a deterministic identity derived from root and path. */
+    identity?: string;
+    modifiedAtMs?: number | null;
 }
 export type TestingExternalTextFileChunksCall = Omit<ExternalReadTextFileChunksRequest, 'signal' | 'chunkSizeBytes'> & {
     chunkSizeBytes: number;
@@ -21,12 +24,18 @@ export interface TestingOpenForgeApiOptions {
     viewId?: string;
     packageMetadata?: OpenForgePackageMetadata;
     storage?: PluginStorage;
+    /** Initial files exposed through `fs.userData`. Defaults to none. */
+    userDataTextFiles?: UserDataFileWriteRequest[];
     /**
      * Tasks returned by `tasks.list`. The mock filters them by the requested
      * `projectId` (when given) and drops `done` tasks unless `includeDone: true`,
      * mirroring the host capability. Defaults to an empty list.
      */
     tasks?: Task[];
+    /** Agent Sessions returned by `tasks.listSessions`. Defaults to an empty list. */
+    agentSessions?: AgentSession[];
+    /** Compact workspace context keyed by Task ID for `agentSessions.list`. Defaults to none. */
+    agentSessionWorkspaces?: Readonly<Record<string, AgentSessionWorkspace>>;
     /** UTF-8 files returned by `fs.external.readTextFileChunks`. Defaults to none. */
     externalTextFiles?: TestingExternalTextFile[];
 }
@@ -56,7 +65,6 @@ export interface TestingOpenForgeApiCalls {
     }>;
     openUrl: string[];
     clipboardWrites: string[];
-    taskLinkOpenRequests: TaskLinkOpenRequest[];
     navigationRequests: OpenForgeNavigationRequest[];
     notify: NotificationRequest[];
     taskCreations: CreateTaskRequest[];
@@ -68,6 +76,8 @@ export interface TestingOpenForgeApiCalls {
         projectId: string | null;
         includeDone: boolean;
     }>;
+    agentSessionListRequests: ListAgentSessionsRequest[];
+    taskSessionListRequests: ListTaskSessionsRequest[];
     taskStatusUpdates: Array<{
         taskId: string;
         status: string;
@@ -85,8 +95,10 @@ export interface TestingOpenForgeApiCalls {
     fsUserDataReadDirs: UserDataDirectoryRequest[];
     fsUserDataReads: UserDataFileRequest[];
     fsUserDataWrites: UserDataFileWriteRequest[];
+    fsUserDataAppends: UserDataFileWriteRequest[];
     fsExternalReadDirs: ExternalReadDirectoryRequest[];
     fsExternalReads: ExternalReadFileRequest[];
+    fsExternalStats: ExternalReadFileRequest[];
     fsExternalReadTextFileChunks: TestingExternalTextFileChunksCall[];
     shellSpawns: ShellSpawnRequest[];
     shellWrites: Array<{
@@ -200,6 +212,7 @@ export type TestingEventListenerContribution = TestingContributionBase & {
 export type TestingViewContribution = TestingContributionBase & PluginViewRegistration;
 export type TestingTaskPaneTabContribution = TestingContributionBase & PluginTaskPaneTabRegistration;
 export type TestingTaskUISectionContribution = TestingContributionBase & PluginTaskUISectionRegistration;
+export type TestingReviewRowActionContribution = TestingContributionBase & PluginReviewRowActionRegistration;
 export type TestingSettingsSectionContribution = TestingContributionBase & PluginSettingsSectionRegistration;
 export type TestingBackendMethodContribution = TestingContributionBase & {
     registration: BackendMethodRegistration;
@@ -223,6 +236,7 @@ export interface TestingOpenForgeRegistrySnapshot {
     views: TestingViewContribution[];
     taskPaneTabs: TestingTaskPaneTabContribution[];
     taskUISections: TestingTaskUISectionContribution[];
+    reviewRowActions: TestingReviewRowActionContribution[];
     settingsSections: TestingSettingsSectionContribution[];
     commands: TestingCommandContribution[];
     eventListeners: TestingEventListenerContribution[];

package/dist/testing/frontendContributionFake.d.ts

@@ -1,19 +1,19 @@
-import { type TaskBrowserSurfaceState } from '../browserSurfaces.js';
+import type { TaskBrowserSurfaceState } from '../browserSurfaces';
 import type { FrontendOpenForgeAPI } from '../types';
 import { type TestingRegistryServices } from './support.js';
-import type { TestingInjectionPointContribution, TestingTaskStartPrefixProviderContribution, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingTaskUISectionContribution, TestingViewContribution } from './contracts';
-type TestingFrontendContributionApi = Pick<FrontendOpenForgeAPI, 'browserSurfaces' | 'taskLinks' | 'views' | 'taskUI' | 'taskPane' | 'settings' | 'backend' | 'injectionPoints' | 'taskStart'>;
+import type { TestingInjectionPointContribution, TestingTaskStartPrefixProviderContribution, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingReviewRowActionContribution, TestingTaskUISectionContribution, TestingViewContribution } from './contracts';
+type TestingFrontendContributionApi = Pick<FrontendOpenForgeAPI, 'browserSurfaces' | 'views' | 'taskUI' | 'reviewUI' | 'taskPane' | 'settings' | 'backend' | 'injectionPoints' | 'taskStart'>;
 export declare class TestingFrontendContributionFake {
     private readonly services;
     private readonly invokeBackendMethod;
     private readonly views;
     private readonly taskPaneTabs;
     private readonly taskUISections;
+    private readonly reviewRowActions;
     private readonly settingsSections;
     private readonly injectionPoints;
     private readonly taskStartPrefixProviders;
     private readonly browserSurfaces;
-    private taskLinkHandler;
     private api;
     constructor(services: TestingRegistryServices, invokeBackendMethod: (method: string, payload?: unknown) => Promise<unknown>);
     createApi(): TestingFrontendContributionApi;
@@ -22,6 +22,7 @@ export declare class TestingFrontendContributionFake {
         views: TestingViewContribution[];
         taskPaneTabs: TestingTaskPaneTabContribution[];
         taskUISections: TestingTaskUISectionContribution[];
+        reviewRowActions: TestingReviewRowActionContribution[];
         settingsSections: TestingSettingsSectionContribution[];
         injectionPoints: TestingInjectionPointContribution[];
         taskStartPrefixProviders: TestingTaskStartPrefixProviderContribution[];
@@ -29,6 +30,7 @@ export declare class TestingFrontendContributionFake {
     private registerView;
     private registerTaskPaneTab;
     private registerTaskUISection;
+    private registerReviewRowAction;
     private registerSettingsSection;
     private registerTaskStartPrefixProvider;
     private registerInjectionPoint;

package/dist/testing/frontendContributionFake.js

@@ -1,5 +1,4 @@
 import { createTestingBrowserSurfaces } from '../browserSurfacesTesting.js';
-import { isAllowedBrowserSurfaceUrl } from '../browserSurfaces.js';
 import { assertFunction, assertTitle, createDisposable, } from './support.js';
 export class TestingFrontendContributionFake {
     services;
@@ -7,11 +6,11 @@ export class TestingFrontendContributionFake {
     views = new Map();
     taskPaneTabs = new Map();
     taskUISections = new Map();
+    reviewRowActions = new Map();
     settingsSections = new Map();
     injectionPoints = new Map();
     taskStartPrefixProviders = new Map();
     browserSurfaces;
-    taskLinkHandler = null;
     api = null;
     constructor(services, invokeBackendMethod) {
         this.services = services;
@@ -23,36 +22,6 @@ export class TestingFrontendContributionFake {
             return this.api;
         const api = {
             browserSurfaces: this.browserSurfaces.api,
-            taskLinks: {
-                open: async (request) => {
-                    this.services.calls.taskLinkOpenRequests.push(request);
-                    if (!isAllowedBrowserSurfaceUrl(request.url)) {
-                        throw new Error('Task links must use a valid HTTP(S) URL');
-                    }
-                    if (this.taskLinkHandler === null) {
-                        this.services.calls.openUrl.push(request.url);
-                        return;
-                    }
-                    const result = await this.taskLinkHandler(request);
-                    if (result === 'declined') {
-                        this.services.calls.openUrl.push(request.url);
-                        return;
-                    }
-                    if (result !== 'handled') {
-                        throw new Error(`Task link handler returned an invalid result: ${String(result)}`);
-                    }
-                },
-                registerHandler: (handler) => {
-                    if (this.taskLinkHandler !== null) {
-                        throw new Error('A Task link handler is already registered');
-                    }
-                    this.taskLinkHandler = handler;
-                    return createDisposable(() => {
-                        if (this.taskLinkHandler === handler)
-                            this.taskLinkHandler = null;
-                    });
-                },
-            },
             views: {
                 register: (registration) => this.registerView(registration),
             },
@@ -60,6 +29,9 @@ export class TestingFrontendContributionFake {
                 registerTab: (registration) => this.registerTaskPaneTab(registration),
                 registerSection: (registration) => this.registerTaskUISection(registration),
             },
+            reviewUI: {
+                registerRowAction: (registration) => this.registerReviewRowAction(registration),
+            },
             taskPane: {
                 registerTab: (registration) => this.registerTaskPaneTab(registration),
             },
@@ -93,6 +65,7 @@ export class TestingFrontendContributionFake {
             views: Array.from(this.views.values()),
             taskPaneTabs: Array.from(this.taskPaneTabs.values()),
             taskUISections: Array.from(this.taskUISections.values()),
+            reviewRowActions: Array.from(this.reviewRowActions.values()),
             settingsSections: Array.from(this.settingsSections.values()),
             injectionPoints: Array.from(this.injectionPoints.values()),
             taskStartPrefixProviders: Array.from(this.taskStartPrefixProviders.values()).sort((left, right) => left.order - right.order || left.id.localeCompare(right.id)),
@@ -162,6 +135,23 @@ export class TestingFrontendContributionFake {
             this.services.claims.release('taskUI', qualifiedId);
         });
     }
+    registerReviewRowAction(registration) {
+        const qualifiedId = this.services.localQualifiedId('reviewUI', registration.id);
+        assertFunction('reviewUI', 'component', registration.component);
+        this.services.claims.claim('reviewUI', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.reviewRowActions.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.reviewRowActions.delete(qualifiedId);
+            this.services.claims.release('reviewUI', qualifiedId);
+        });
+    }
     registerSettingsSection(registration) {
         const qualifiedId = this.services.localQualifiedId('settings', registration.id);
         assertTitle('settings', registration.title);

package/dist/testing/support.d.ts

@@ -1,5 +1,5 @@
-import type { AgentCommandMetadata, CommandDescriptor, Disposable, JsonValue, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, PluginStorage, StartPromptContribution, SubscriptionSink } from '../types';
-import type { Task } from '../domain';
+import type { AgentSessionWorkspace, AgentCommandMetadata, CommandDescriptor, Disposable, JsonValue, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, PluginStorage, StartPromptContribution, SubscriptionSink } from '../types';
+import type { AgentSession, Task } from '../domain';
 import type { TestingCommandContribution, TestingMaybePromise, TestingExternalTextFile, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingRuntimeKind } from './contracts';
 export declare function createDisposable(dispose: () => TestingMaybePromise<void>): Disposable;
 export declare class TestingSubscriptionSink implements SubscriptionSink {
@@ -31,7 +31,10 @@ export declare class TestingRegistryServices {
     readonly storage: PluginStorage;
     readonly config: Map<string, JsonValue>;
     readonly seededTasks: Task[];
+    readonly seededAgentSessions: AgentSession[];
+    readonly agentSessionWorkspaces: Readonly<Record<string, AgentSessionWorkspace>>;
     readonly externalTextFiles: TestingExternalTextFile[];
+    readonly userDataTextFiles: Map<string, string>;
     readonly claims: TestingContributionClaims;
     constructor(options?: TestingOpenForgeApiOptions);
     localQualifiedId(kind: TestingRuntimeKind, id: string): string;

package/dist/testing/support.js

@@ -36,7 +36,6 @@ export function createTestingCalls() {
         emittedGlobalEvents: [],
         openUrl: [],
         clipboardWrites: [],
-        taskLinkOpenRequests: [],
         navigationRequests: [],
         notify: [],
         taskCreations: [],
@@ -45,14 +44,18 @@ export function createTestingCalls() {
         taskImplementationStarts: [],
         taskFollowUps: [],
         taskListRequests: [],
+        agentSessionListRequests: [],
+        taskSessionListRequests: [],
         taskStatusUpdates: [],
         configWrites: [],
         fsWrites: [],
         fsUserDataReadDirs: [],
         fsUserDataReads: [],
         fsUserDataWrites: [],
+        fsUserDataAppends: [],
         fsExternalReadDirs: [],
         fsExternalReads: [],
+        fsExternalStats: [],
         fsExternalReadTextFileChunks: [],
         shellSpawns: [],
         shellWrites: [],
@@ -202,7 +205,10 @@ export class TestingRegistryServices {
     storage;
     config = new Map();
     seededTasks;
+    seededAgentSessions;
+    agentSessionWorkspaces;
     externalTextFiles;
+    userDataTextFiles = new Map();
     claims = new TestingContributionClaims();
     constructor(options = {}) {
         this.pluginId = options.pluginId ?? 'test-plugin';
@@ -218,7 +224,12 @@ export class TestingRegistryServices {
         this.calls = createTestingCalls();
         this.storage = options.storage ?? createMemoryPluginStorage(this.calls);
         this.seededTasks = options.tasks ?? [];
+        this.seededAgentSessions = options.agentSessions ?? [];
+        this.agentSessionWorkspaces = options.agentSessionWorkspaces ?? {};
         this.externalTextFiles = options.externalTextFiles ?? [];
+        for (const file of options.userDataTextFiles ?? []) {
+            this.userDataTextFiles.set(file.path, file.content);
+        }
     }
     localQualifiedId(kind, id) {
         assertLocalId(kind, id);