@openforge-app/plugin-sdk 0.2.9 → 0.2.11

package/dist/backend.d.ts

@@ -1,3 +1,3 @@
-import type { BackendFileSystemAPI, BackendMethodRegistration, BackendMethodRegistry, BackendOpenForgeAPI, BackendPlugin, BackendPluginContext, BackgroundServiceRegistration, BackgroundServiceRegistry, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, Disposable, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, ExternalReadFileSystemAPI, UserDataDirectoryRequest, UserDataFileRequest, UserDataFileSystemAPI, UserDataFileWriteRequest, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot } from './types';
+import type { BackendFileSystemAPI, BackendMethodRegistration, BackendMethodRegistry, BackendOpenForgeAPI, BackendPlugin, BackendPluginContext, BackgroundServiceRegistration, BackgroundServiceRegistry, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, Disposable, ExternalFileMetadata, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, ExternalReadFileSystemAPI, UserDataDirectoryRequest, UserDataFileAppendResult, UserDataFileRequest, UserDataFileSystemAPI, UserDataFileWriteRequest, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot } from './types';
 export declare function defineBackendPlugin<const TPlugin extends BackendPlugin>(plugin: TPlugin): TPlugin;
-export type { BackendFileSystemAPI, BackendMethodRegistration, BackendMethodRegistry, BackendOpenForgeAPI, BackendPlugin, BackendPluginContext, BackgroundServiceRegistration, BackgroundServiceRegistry, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, Disposable, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, ExternalReadFileSystemAPI, UserDataDirectoryRequest, UserDataFileRequest, UserDataFileSystemAPI, UserDataFileWriteRequest, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, };
+export type { BackendFileSystemAPI, BackendMethodRegistration, BackendMethodRegistry, BackendOpenForgeAPI, BackendPlugin, BackendPluginContext, BackgroundServiceRegistration, BackgroundServiceRegistry, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, Disposable, ExternalFileMetadata, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, ExternalReadFileSystemAPI, UserDataDirectoryRequest, UserDataFileAppendResult, UserDataFileRequest, UserDataFileSystemAPI, UserDataFileWriteRequest, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, };

package/dist/collapsibleSectionState.js

@@ -2,6 +2,7 @@ import { writable } from 'svelte/store';
 // The store started life in the host app as src/lib/infoPanelSectionState.ts. The key is
 // deliberately unchanged: renaming it would reset every user's collapsed sections.
 export const COLLAPSED_SECTIONS_STORAGE_KEY = 'openforge.infoPanelSectionCollapse.v1';
+const SHARED_STATE_SYMBOL = Symbol.for('com.openforge.plugin-sdk.collapsible-section-state.v1');
 export function pluginSectionKey(pluginId, sectionKey) {
     return `plugin:${pluginId}:${sectionKey}`;
 }
@@ -13,10 +14,10 @@ function getLocalStorage() {
         return null;
     }
 }
-function readPersisted() {
+function readPersisted(fallback = {}) {
     const storage = getLocalStorage();
     if (storage === null)
-        return {};
+        return fallback;
     try {
         const rawValue = storage.getItem(COLLAPSED_SECTIONS_STORAGE_KEY);
         if (rawValue === null)
@@ -32,7 +33,7 @@ function readPersisted() {
         return state;
     }
     catch {
-        return {};
+        return fallback;
     }
 }
 function writePersisted(state) {
@@ -56,23 +57,40 @@ function writePersisted(state) {
         // Persistence is best effort and must not block the section from rendering.
     }
 }
-const { subscribe, set, update } = writable(readPersisted());
+function updatePersistedSection(current, key, collapsed) {
+    // localStorage is the cross-realm source of truth. Re-read it for every mutation so
+    // a bundle that cannot share this page's singleton still cannot overwrite newer keys.
+    const next = { ...readPersisted(current) };
+    if (collapsed)
+        next[key] = true;
+    else
+        delete next[key];
+    writePersisted(next);
+    return next;
+}
+function getSharedState() {
+    const registry = globalThis;
+    const existing = registry[SHARED_STATE_SYMBOL];
+    if (existing !== undefined)
+        return existing;
+    // Trusted Plugin bundles contain their own copy of this module. Symbol.for gives those
+    // copies and the host one live access to the same Svelte store in this renderer realm.
+    const shared = { store: writable(readPersisted()) };
+    registry[SHARED_STATE_SYMBOL] = shared;
+    return shared;
+}
+const { subscribe, set, update } = getSharedState().store;
 export const collapsedSections = { subscribe };
 export function isSectionCollapsed(state, key) {
     return state[key] === true;
 }
 export function setSectionCollapsed(key, collapsed) {
-    update((current) => {
-        const next = { ...current, [key]: collapsed };
-        writePersisted(next);
-        return next;
-    });
+    update((current) => updatePersistedSection(current, key, collapsed));
 }
 export function toggleSection(key) {
     update((current) => {
-        const next = { ...current, [key]: !isSectionCollapsed(current, key) };
-        writePersisted(next);
-        return next;
+        const latest = readPersisted(current);
+        return updatePersistedSection(latest, key, !isSectionCollapsed(latest, key));
     });
 }
 export function clearCollapsedSections() {

package/dist/domain.d.ts

@@ -179,6 +179,7 @@ export interface MergeReadinessInfo extends MergeStatusInfo {
     review_status?: string | null;
     draft?: boolean;
     is_queued?: boolean;
+    merge_queue_required?: boolean | null;
     unaddressed_comment_count?: number;
     head_sha?: string | null;
     updated_at?: number | null;

package/dist/domain.js

@@ -199,7 +199,8 @@ export function getMergeReadiness(pr, options = {}) {
         warnings.push(mergeReadinessDetail('unprotected_fallback', 'Using simple mergeability because no protected-branch checks or review state are available.'));
     }
     if (hasDirectMergeability || isUnprotectedFallback) {
-        return mergeReadinessResult(pr, options.requireMergeQueue === true ? 'ready_to_enqueue' : 'ready_to_merge', options.requireMergeQueue === true ? 'enqueue' : 'merge', blockers, warnings);
+        const mergeQueueRequired = options.requireMergeQueue === true || pr.merge_queue_required === true;
+        return mergeReadinessResult(pr, mergeQueueRequired ? 'ready_to_enqueue' : 'ready_to_merge', mergeQueueRequired ? 'enqueue' : 'merge', blockers, warnings);
     }
     if (mergeableState === 'unknown' || pr.mergeable === null || (mergeableState === null && pr.mergeable !== false)) {
         warnings.push(mergeReadinessDetail('mergeability_unknown', 'GitHub has not reported definitive mergeability yet.'));

package/dist/frontend.d.ts

@@ -1,5 +1,5 @@
 import type { BrowserSurfaceCapture, BrowserDevToolsPanel, BrowserSurfaceFeedbackSelection, BrowserSurfaceVisualFeedback, BrowserSurfaceRegion, BrowserSurfaceErrorCode, BrowserSurfaceNavigationError, BrowserSurfacesAPI, GetOrCreateBrowserSurfaceRequest, TaskBrowserSurfaceController, TaskBrowserSurfaceState } from './browserSurfaces';
-import type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendInjectionPointRegistry, FrontendTaskStartRegistry, FrontendReviewUIRegistry, FrontendTaskUIRegistry, FrontendViewRegistry, InjectionPointLocation, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, TaskLinkHandler, TaskLinkHandlerResult, TaskLinkOpenRequest, TaskLinksAPI, PluginIcon, PluginSidebarNavigationProps, PluginSidebarViewIdentity, PluginInjectionPointProps, PluginInjectionPointRegistration, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsSectionScope, PluginStorageScope, PluginSvgIcon, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginReviewRowActionProps, PluginReviewRowActionRegistration, PluginTaskUISectionProps, PluginTaskUISectionRegistration, PluginViewProps, PluginViewRegistration, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, PtyBufferState, TerminalImageProtocol, TerminalViewSnapshot } from './types';
+import type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendInjectionPointRegistry, FrontendTaskStartRegistry, FrontendReviewUIRegistry, FrontendTaskUIRegistry, FrontendViewRegistry, InjectionPointLocation, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, PluginIcon, PluginSidebarNavigationProps, PluginSidebarViewIdentity, PluginInjectionPointProps, PluginInjectionPointRegistration, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsSectionScope, PluginStorageScope, PluginSvgIcon, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginReviewRowActionProps, PluginReviewRowActionRegistration, PluginTaskUISectionProps, PluginTaskUISectionRegistration, PluginViewProps, PluginViewRegistration, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, PtyBufferState, TerminalImageProtocol, TerminalViewSnapshot } from './types';
 export declare const OPENFORGE_FRONTEND_PLUGIN_MARKER = "__openforgeFrontendPlugin";
 export type MarkedFrontendPlugin<TPlugin extends FrontendPlugin = FrontendPlugin> = TPlugin & {
     readonly [OPENFORGE_FRONTEND_PLUGIN_MARKER]: true;
@@ -7,4 +7,4 @@ export type MarkedFrontendPlugin<TPlugin extends FrontendPlugin = FrontendPlugin
 export declare function defineFrontendPlugin<const TPlugin extends FrontendPlugin>(plugin: TPlugin): MarkedFrontendPlugin<TPlugin>;
 export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfaces';
 export type { BrowserSurfaceCapture, BrowserDevToolsPanel, BrowserSurfaceFeedbackSelection, BrowserSurfaceVisualFeedback, BrowserSurfaceRegion, BrowserSurfaceErrorCode, BrowserSurfaceNavigationError, BrowserSurfacesAPI, GetOrCreateBrowserSurfaceRequest, TaskBrowserSurfaceController, TaskBrowserSurfaceState, };
-export type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendInjectionPointRegistry, FrontendTaskStartRegistry, FrontendReviewUIRegistry, FrontendTaskUIRegistry, FrontendViewRegistry, InjectionPointLocation, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, TaskLinkHandler, TaskLinkHandlerResult, TaskLinkOpenRequest, TaskLinksAPI, PluginIcon, PluginSidebarNavigationProps, PluginSidebarViewIdentity, PluginInjectionPointProps, PluginInjectionPointRegistration, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsSectionScope, PluginStorageScope, PluginSvgIcon, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginReviewRowActionProps, PluginReviewRowActionRegistration, PluginTaskUISectionProps, PluginTaskUISectionRegistration, PluginViewProps, PluginViewRegistration, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, PtyBufferState, TerminalImageProtocol, TerminalViewSnapshot, };
+export type { CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, Disposable, FrontendBackendBridge, FrontendOpenForgeAPI, FrontendPlugin, FrontendPluginContext, FrontendSettingsRegistry, FrontendTaskPaneRegistry, FrontendInjectionPointRegistry, FrontendTaskStartRegistry, FrontendReviewUIRegistry, FrontendTaskUIRegistry, FrontendViewRegistry, InjectionPointLocation, NavigationAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, PluginIcon, PluginSidebarNavigationProps, PluginSidebarViewIdentity, PluginInjectionPointProps, PluginInjectionPointRegistration, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsSectionScope, PluginStorageScope, PluginSvgIcon, PluginTaskPaneProps, PluginTaskPaneTabRegistration, PluginReviewRowActionProps, PluginReviewRowActionRegistration, PluginTaskUISectionProps, PluginTaskUISectionRegistration, PluginViewProps, PluginViewRegistration, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, PtyBufferState, TerminalImageProtocol, TerminalViewSnapshot, };

package/dist/index.d.ts

@@ -2,8 +2,8 @@ export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfac
 export type { BrowserSurfaceCapture, BrowserSurfaceFeedbackSelection, BrowserSurfaceVisualFeedback, BrowserSurfaceRegion, BrowserSurfaceErrorCode, BrowserSurfaceNavigationError, BrowserSurfacesAPI, GetOrCreateBrowserSurfaceRequest, TaskBrowserSurfaceController, TaskBrowserSurfaceState, } from './browserSurfaces';
 export { OPENFORGE_PACKAGE_METADATA_SCHEMA, OPENFORGE_PLUGIN_CAPABILITIES, isOpenForgePackageMetadata, isPluginPackageMetadata, isSupportedOpenForgeApiVersion, validateOpenForgePackageMetadata, validatePluginPackageMetadata, } from './manifest';
 export { createMemoryPluginStorage, createMockBackendOpenForgeApi, createMockFrontendOpenForgeApi, createMockOpenForgeApi, createMockPluginContext, createOpenForgeRegistryFake, createTestingCalls, TestingOpenForgeRegistryFake, TestingSubscriptionSink, } from './testing';
-export { DEFAULT_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MAX_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MIN_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, TaskFollowUpError, MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, resolveExternalTextFileChunkSize, makePluginViewKey, parsePluginViewKey, } from './types';
-export type { AgentCommandDescriptor, AgentCommandMetadata, AgentCommandRuntime, AttentionAPI, BackendReadyState, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, ConfigureStartPromptContributionRequest, CreateTaskRequest, Disposable, BackendFileSystemAPI, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, ExternalReadFileSystemAPI, FileSystemAPI, UserDataDirectoryRequest, UserDataFileRequest, UserDataFileSystemAPI, UserDataFileWriteRequest, ImplementationRun, InjectionPointLocation, JsonObject, JsonPrimitive, JsonSchema, JsonValue, MaybePromise, KeyValueConfigAPI, NotificationRequest, NavigationAPI, NotificationsAPI, OpenForgeCommonAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, OpenForgePluginCapability, OpenForgePluginContext, OpenForgePluginPackageJson, PluginCommandInvocationContext, PluginCommandInvocationSource, PluginComponentLoader, PluginComponentModule, PluginEntry, PluginIcon, PluginSidebarNavigationProps, PluginSidebarViewIdentity, PluginInjectionPointProps, PluginSettingsSectionProps, PluginState, PluginSvgIcon, PluginTaskPaneProps, PluginTaskUISectionProps, PluginViewProps, PluginStorage, PluginStorageScope, PluginViewKey, ProjectsAPI, PtyBufferState, ShellAPI, ShellResizeRequest, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, TerminalImageProtocol, TerminalViewSnapshot, ShellSessionRequest, ShellSpawnRequest, ShellTerminalQueryResponseRequest, ShellWriteRequest, StartPromptContribution, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskFollowUpDisposition, TaskFollowUpErrorCode, TaskFollowUpReceipt, SubscriptionSink, SupportedOpenForgeApiVersion, SystemAPI, TaskLinkHandler, TaskLinkHandlerResult, TaskLinkOpenRequest, TaskLinksAPI, TasksAPI, ValidationError, } from './types';
+export { MAX_AGENT_SESSION_PAGE_SIZE, DEFAULT_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MAX_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MIN_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, TaskFollowUpError, MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, resolveExternalTextFileChunkSize, makePluginViewKey, parsePluginViewKey, } from './types';
+export type { AgentSessionCursor, AgentSessionOverlap, AgentSessionsAPI, AgentSessionSummary, AgentSessionSummaryPage, AgentSessionTaskSummary, AgentSessionWorkspace, AgentCommandDescriptor, AgentCommandMetadata, AgentCommandRuntime, AttentionAPI, BackendReadyState, CommandDescriptor, CommandRegistry, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ComposeTaskResult, ConfigureStartPromptContributionRequest, CreateTaskRequest, Disposable, BackendFileSystemAPI, ExternalFileMetadata, ExternalReadDirectoryRequest, ExternalReadFileRequest, ExternalReadTextFileChunksRequest, ExternalReadFileSystemAPI, FileSystemAPI, UserDataDirectoryRequest, UserDataFileAppendResult, UserDataFileRequest, UserDataFileSystemAPI, UserDataFileWriteRequest, ImplementationRun, ListAgentSessionsRequest, ListTaskSessionsRequest, InjectionPointLocation, JsonObject, JsonPrimitive, JsonSchema, JsonValue, MaybePromise, KeyValueConfigAPI, NotificationRequest, NavigationAPI, NotificationsAPI, OpenForgeCommonAPI, OpenForgeContextChangeHandler, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, OpenForgePluginCapability, OpenForgePluginContext, OpenForgePluginPackageJson, PluginCommandInvocationContext, PluginCommandInvocationSource, PluginComponentLoader, PluginComponentModule, PluginEntry, PluginIcon, PluginSidebarNavigationProps, PluginSidebarViewIdentity, PluginInjectionPointProps, PluginSettingsSectionProps, PluginState, PluginSvgIcon, PluginTaskPaneProps, PluginTaskUISectionProps, PluginViewProps, PluginStorage, PluginStorageScope, PluginViewKey, ProjectsAPI, PtyBufferState, ShellAPI, ShellResizeRequest, TaskStartPrefixContext, TaskStartPrefixProviderRegistration, TerminalImageProtocol, TerminalViewSnapshot, ShellSessionRequest, ShellSpawnRequest, ShellWriteRequest, StartPromptContribution, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskFollowUpDisposition, TaskFollowUpErrorCode, TaskFollowUpReceipt, SubscriptionSink, SupportedOpenForgeApiVersion, SystemAPI, TasksAPI, ValidationError, } from './types';
 export type { MockBackendOpenForgeAPI, MockFrontendOpenForgeAPI, TestingBackgroundServiceContribution, TestingBackendMethodContribution, TestingCommandContribution, TestingContributionBase, TestingExternalTextFile, TestingExternalTextFileChunksCall, TestingEventListenerContribution, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingOpenForgeRegistrySnapshot, TestingRuntimeKind, TestingRuntimeScope, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingTaskUISectionContribution, TestingViewContribution, } from './testing';
 export { parseStrictFiniteNumber } from './numberParsing';
 export { buildProjectFileTree, flattenVisibleProjectFileTree, formatProjectFileTreeSize, getProjectFileTreeDepth, getProjectFileTreeItemAccessibility, getProjectFileTreeKeyboardAction, getProjectFileTreeParentPath, hasProjectFileTreeShortcutModifier, projectFileTreePathToId, } from './projectFileTree';

package/dist/index.js

@@ -1,7 +1,7 @@
 export { BrowserSurfaceError, isAllowedBrowserSurfaceUrl } from './browserSurfaces';
 export { OPENFORGE_PACKAGE_METADATA_SCHEMA, OPENFORGE_PLUGIN_CAPABILITIES, isOpenForgePackageMetadata, isPluginPackageMetadata, isSupportedOpenForgeApiVersion, validateOpenForgePackageMetadata, validatePluginPackageMetadata, } from './manifest';
 export { createMemoryPluginStorage, createMockBackendOpenForgeApi, createMockFrontendOpenForgeApi, createMockOpenForgeApi, createMockPluginContext, createOpenForgeRegistryFake, createTestingCalls, TestingOpenForgeRegistryFake, TestingSubscriptionSink, } from './testing';
-export { DEFAULT_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MAX_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MIN_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, TaskFollowUpError, MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, resolveExternalTextFileChunkSize, makePluginViewKey, parsePluginViewKey, } from './types';
+export { MAX_AGENT_SESSION_PAGE_SIZE, DEFAULT_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MAX_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, MIN_EXTERNAL_TEXT_FILE_CHUNK_SIZE_BYTES, TaskFollowUpError, MAX_SUPPORTED_API_VERSION, MIN_SUPPORTED_API_VERSION, OPENFORGE_PLUGIN_API_VERSION, SUPPORTED_OPENFORGE_API_VERSIONS, isPluginViewKey, resolveExternalTextFileChunkSize, makePluginViewKey, parsePluginViewKey, } from './types';
 export { parseStrictFiniteNumber } from './numberParsing';
 export { buildProjectFileTree, flattenVisibleProjectFileTree, formatProjectFileTreeSize, getProjectFileTreeDepth, getProjectFileTreeItemAccessibility, getProjectFileTreeKeyboardAction, getProjectFileTreeParentPath, hasProjectFileTreeShortcutModifier, projectFileTreePathToId, } from './projectFileTree';
 export { canMergePullRequest, getMergeReadiness, hasMergeConflicts, isClosedUnmergedPullRequest, isMergedPullRequest, isQueuedForMerge, isReadyToMerge, parseCheckRuns, preservePullRequestState, splitCheckRuns, } from './domain';

package/dist/manifest.d.ts

@@ -117,6 +117,7 @@ export declare const OPENFORGE_PACKAGE_METADATA_SCHEMA: {
         backend: {
             type: string;
             minLength: number;
+            pattern: string;
             description: string;
         };
         requires: {

package/dist/manifest.js

@@ -28,6 +28,15 @@ function validateOptionalString(value, path) {
     }
     return [];
 }
+function validateBackendEntry(value) {
+    const errors = validateOptionalString(value, 'backend');
+    if (!isNonEmptyString(value))
+        return errors;
+    if (!['.mjs', '.js', '.cjs'].some(extension => value.endsWith(extension))) {
+        errors.push({ path: 'backend', message: 'Must point to a built .mjs, .js, or .cjs artifact' });
+    }
+    return errors;
+}
 function validateEnablement(value) {
     if (value === undefined || value === 'app' || value === 'project') {
         return [];
@@ -117,7 +126,7 @@ export function validateOpenForgePackageMetadata(data) {
     if (data.frontendStyles !== undefined && !isNonEmptyString(data.frontend)) {
         errors.push({ path: 'frontendStyles', message: 'Requires a frontend entry' });
     }
-    errors.push(...validateOptionalString(data.backend, 'backend'));
+    errors.push(...validateBackendEntry(data.backend));
     errors.push(...validateRequires(data.requires));
     if (data.enablement === 'app' && (!Array.isArray(data.requires) || !data.requires.includes('appEnablement'))) {
         errors.push({ path: 'requires', message: 'App enablement requires the appEnablement capability' });
@@ -125,9 +134,6 @@ export function validateOpenForgePackageMetadata(data) {
     if (Array.isArray(data.requires) && data.requires.includes('browserSurfaces') && !isNonEmptyString(data.frontend)) {
         errors.push({ path: 'requires', message: 'browserSurfaces capability requires a frontend entry' });
     }
-    if (Array.isArray(data.requires) && data.requires.includes('taskLinks') && !isNonEmptyString(data.frontend)) {
-        errors.push({ path: 'requires', message: 'taskLinks capability requires a frontend entry' });
-    }
     if (data.contributes !== undefined) {
         errors.push({ path: 'contributes', message: 'Manifest contribution arrays are not supported; register contributions at runtime' });
     }

package/dist/markdown.d.ts

@@ -11,6 +11,15 @@ export interface ResolvedMarkdownMedia {
 }
 /** Attribute holding the original URL of a `<img>`/`<a>` awaiting resolution. */
 export declare const MARKDOWN_REMOTE_MEDIA_ATTRIBUTE = "data-markdown-remote-src";
+export interface RenderedMarkdownCacheStats {
+    capacity: number;
+    size: number;
+    hits: number;
+    misses: number;
+    evictions: number;
+}
+export declare function getRenderedMarkdownCacheStats(): Readonly<RenderedMarkdownCacheStats>;
+export declare function clearRenderedMarkdownCache(): void;
 export declare function resolveMarkdownRepositoryPath(value: string | null, markdownFilePath: string): string | null;
 export declare function getMarkdownRepositoryLinkSuffix(value: string): string;
 export declare function resolveMarkdownImageSrc(src: string | null, imageBaseUrl: string | null | undefined, markdownFilePath?: string): string | null;

package/dist/markdown.js

@@ -6,6 +6,56 @@ const markedOptions = {
     gfm: true,
     breaks: true,
 };
+const RENDERED_MARKDOWN_CACHE_CAPACITY = 100;
+const renderedMarkdownCache = new Map();
+let renderedMarkdownCacheHits = 0;
+let renderedMarkdownCacheMisses = 0;
+let renderedMarkdownCacheEvictions = 0;
+function renderedMarkdownCacheKey(content, options) {
+    return JSON.stringify([
+        content,
+        options.imageBaseUrl ?? null,
+        options.markdownFilePath ?? null,
+        Boolean(options.deferRepositoryImages),
+        Boolean(options.deferRemoteMedia),
+    ]);
+}
+function readRenderedMarkdownCache(key) {
+    const cached = renderedMarkdownCache.get(key);
+    if (cached === undefined) {
+        renderedMarkdownCacheMisses++;
+        return undefined;
+    }
+    renderedMarkdownCacheHits++;
+    renderedMarkdownCache.delete(key);
+    renderedMarkdownCache.set(key, cached);
+    return cached;
+}
+function writeRenderedMarkdownCache(key, html) {
+    if (renderedMarkdownCache.size >= RENDERED_MARKDOWN_CACHE_CAPACITY) {
+        const oldestKey = renderedMarkdownCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            renderedMarkdownCache.delete(oldestKey);
+            renderedMarkdownCacheEvictions++;
+        }
+    }
+    renderedMarkdownCache.set(key, html);
+}
+export function getRenderedMarkdownCacheStats() {
+    return {
+        capacity: RENDERED_MARKDOWN_CACHE_CAPACITY,
+        size: renderedMarkdownCache.size,
+        hits: renderedMarkdownCacheHits,
+        misses: renderedMarkdownCacheMisses,
+        evictions: renderedMarkdownCacheEvictions,
+    };
+}
+export function clearRenderedMarkdownCache() {
+    renderedMarkdownCache.clear();
+    renderedMarkdownCacheHits = 0;
+    renderedMarkdownCacheMisses = 0;
+    renderedMarkdownCacheEvictions = 0;
+}
 function hasAbsoluteOrSpecialUrl(value) {
     return /^[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith('//') || value.startsWith('#');
 }
@@ -144,6 +194,12 @@ function prepareMarkdownMediaSources(html, options) {
     return template.innerHTML;
 }
 export function renderMarkdownHtml(content, options = {}) {
+    const cacheKey = renderedMarkdownCacheKey(content, options);
+    const cached = readRenderedMarkdownCache(cacheKey);
+    if (cached !== undefined)
+        return cached;
     const rawHtml = marked.parse(content, markedOptions);
-    return sanitizeHtml(prepareMarkdownMediaSources(rawHtml, options));
+    const html = sanitizeHtml(prepareMarkdownMediaSources(rawHtml, options));
+    writeRenderedMarkdownCache(cacheKey, html);
+    return html;
 }

package/dist/mermaid.d.ts

@@ -0,0 +1,13 @@
+export type MermaidTheme = 'default' | 'dark';
+export declare const MERMAID_DIAGRAM_CLASS = "mermaid-diagram";
+export declare const MERMAID_EXPAND_ACTION_CLASS = "mermaid-diagram-expand";
+export declare function resolveMermaidTheme(doc?: Document): MermaidTheme;
+export interface RenderedMermaidDiagram {
+    trigger: HTMLButtonElement;
+    wrapper: HTMLDivElement;
+    svg: string;
+}
+export declare function getRenderedMermaidSvg(wrapper: HTMLDivElement): string | null;
+export declare function getRenderedMermaidDiagram(target: Element): RenderedMermaidDiagram | null;
+export declare function renderMermaidDiagrams(root: HTMLElement, isCurrent?: () => boolean): Promise<void>;
+export declare function observeMermaidTheme(doc: Document, onChange: () => void): () => void;

package/dist/mermaid.js

@@ -0,0 +1,221 @@
+import { sanitizeMermaidSvg } from './sanitize';
+const MERMAID_CODE_SELECTOR = 'pre > code.language-mermaid';
+export const MERMAID_DIAGRAM_CLASS = 'mermaid-diagram';
+export const MERMAID_EXPAND_ACTION_CLASS = 'mermaid-diagram-expand';
+const MERMAID_FAILURE_CLASS = 'mermaid-diagram-fallback';
+const MERMAID_EXTERNAL_RESOURCE_PATTERN = /(?:\b(?:https?|ftp|file|data|javascript|vbscript):|(?:^|[\s("'=])\/\/|@import|\burl\s*\()/im;
+const MERMAID_ESCAPED_STYLE_PATTERN = /\b(?:classDef|style|linkStyle)\b[^\r\n]*\\/i;
+let diagramId = 0;
+let renderQueue = Promise.resolve();
+const mermaidThemeObservations = new WeakMap();
+function loadMermaid() {
+    return import('mermaid').then(module => module.default);
+}
+export function resolveMermaidTheme(doc = document) {
+    const themeName = doc.documentElement.getAttribute('data-theme');
+    if (themeName)
+        return themeName.includes('dark') ? 'dark' : 'default';
+    if (doc.defaultView?.matchMedia?.('(prefers-color-scheme: dark)').matches)
+        return 'dark';
+    return 'default';
+}
+function queueMermaidRender(operation) {
+    const result = renderQueue.then(operation, operation);
+    renderQueue = result.then(() => undefined, () => undefined);
+    return result;
+}
+function assertSafeMermaidSource(source) {
+    if (MERMAID_EXTERNAL_RESOURCE_PATTERN.test(source) || MERMAID_ESCAPED_STYLE_PATTERN.test(source)) {
+        throw new Error('Mermaid source contains an external resource');
+    }
+}
+async function renderMermaidSvg(source, theme) {
+    assertSafeMermaidSource(source);
+    return queueMermaidRender(async () => {
+        const mermaid = await loadMermaid();
+        mermaid.initialize({
+            startOnLoad: false,
+            securityLevel: 'strict',
+            suppressErrorRendering: true,
+            maxTextSize: 50_000,
+            maxEdges: 500,
+            secure: [
+                'secure',
+                'securityLevel',
+                'startOnLoad',
+                'suppressErrorRendering',
+                'maxTextSize',
+                'maxEdges',
+                'theme',
+                'themeVariables',
+                'themeCSS',
+                'fontFamily',
+                'altFontFamily',
+                'dompurifyConfig',
+                'htmlLabels',
+                'flowchart',
+            ],
+            theme,
+            htmlLabels: false,
+            flowchart: { htmlLabels: false },
+        });
+        const { svg } = await mermaid.render(`openforge-mermaid-${++diagramId}`, source);
+        return sanitizeMermaidSvg(svg);
+    });
+}
+function prepareDiagram(code) {
+    const fallback = code.parentElement;
+    if (!(fallback instanceof HTMLPreElement))
+        return null;
+    const existingWrapper = fallback.parentElement;
+    if (existingWrapper instanceof HTMLDivElement && existingWrapper.classList.contains(MERMAID_DIAGRAM_CLASS)) {
+        return { wrapper: existingWrapper, source: code.textContent?.trim() ?? '', fallback };
+    }
+    const wrapper = document.createElement('div');
+    wrapper.className = MERMAID_DIAGRAM_CLASS;
+    wrapper.setAttribute('role', 'group');
+    wrapper.setAttribute('aria-label', 'Mermaid diagram');
+    fallback.before(wrapper);
+    wrapper.append(fallback);
+    return { wrapper, source: code.textContent?.trim() ?? '', fallback };
+}
+function clearRenderedDiagram(wrapper, fallback) {
+    const expandAction = wrapper.querySelector(`:scope > button.${MERMAID_EXPAND_ACTION_CLASS}`);
+    for (const child of Array.from(wrapper.children)) {
+        if (child !== fallback && child !== expandAction)
+            child.remove();
+    }
+    if (expandAction)
+        expandAction.hidden = true;
+    fallback.hidden = false;
+    wrapper.classList.remove('mermaid-diagram-rendered', MERMAID_FAILURE_CLASS);
+}
+function showRenderFailure(wrapper, fallback) {
+    clearRenderedDiagram(wrapper, fallback);
+    const message = document.createElement('p');
+    message.className = 'mermaid-diagram-error';
+    message.setAttribute('role', 'status');
+    message.textContent = 'Unable to render Mermaid diagram. Showing source instead.';
+    wrapper.prepend(message);
+    wrapper.classList.add(MERMAID_FAILURE_CLASS);
+}
+function fitSvgToRenderedContent(svg) {
+    if (typeof svg.getBBox !== 'function')
+        return;
+    try {
+        const bounds = svg.getBBox();
+        if (![bounds.x, bounds.y, bounds.width, bounds.height].every(Number.isFinite))
+            return;
+        if (bounds.width <= 0 || bounds.height <= 0)
+            return;
+        const padding = 8;
+        const width = bounds.width + padding * 2;
+        const height = bounds.height + padding * 2;
+        svg.setAttribute('viewBox', [
+            bounds.x - padding,
+            bounds.y - padding,
+            width,
+            height,
+        ].join(' '));
+        svg.style.maxWidth = `${Math.ceil(width)}px`;
+    }
+    catch {
+        // Keep Mermaid's original viewport when the browser cannot measure SVG geometry.
+    }
+}
+function createDiagramExpandAction(doc) {
+    const button = doc.createElement('button');
+    button.type = 'button';
+    button.className = MERMAID_EXPAND_ACTION_CLASS;
+    button.setAttribute('aria-label', 'Expand Mermaid diagram');
+    button.title = 'Expand Mermaid diagram';
+    button.textContent = 'Expand';
+    return button;
+}
+export function getRenderedMermaidSvg(wrapper) {
+    if (!wrapper.isConnected || !wrapper.classList.contains('mermaid-diagram-rendered'))
+        return null;
+    return wrapper.querySelector(':scope > svg')?.outerHTML ?? null;
+}
+export function getRenderedMermaidDiagram(target) {
+    const trigger = target.closest(`button.${MERMAID_EXPAND_ACTION_CLASS}`);
+    if (!(trigger instanceof HTMLButtonElement))
+        return null;
+    const wrapper = trigger.closest(`.${MERMAID_DIAGRAM_CLASS}`);
+    if (!(wrapper instanceof HTMLDivElement))
+        return null;
+    const svg = getRenderedMermaidSvg(wrapper);
+    return svg ? { trigger, wrapper, svg } : null;
+}
+function showRenderedDiagram(wrapper, fallback, sanitizedSvg) {
+    const template = document.createElement('template');
+    template.innerHTML = sanitizedSvg;
+    const svg = template.content.querySelector('svg');
+    if (!svg)
+        return false;
+    if (!svg.hasAttribute('role'))
+        svg.setAttribute('role', 'img');
+    if (!svg.hasAttribute('aria-label') && !svg.hasAttribute('aria-labelledby')) {
+        svg.setAttribute('aria-label', 'Mermaid diagram');
+    }
+    clearRenderedDiagram(wrapper, fallback);
+    wrapper.insertBefore(template.content, fallback);
+    fitSvgToRenderedContent(svg);
+    const expandAction = wrapper.querySelector(`:scope > button.${MERMAID_EXPAND_ACTION_CLASS}`)
+        ?? createDiagramExpandAction(wrapper.ownerDocument);
+    expandAction.hidden = false;
+    if (!expandAction.parentElement)
+        wrapper.insertBefore(expandAction, fallback);
+    fallback.hidden = true;
+    wrapper.classList.add('mermaid-diagram-rendered');
+    return true;
+}
+export async function renderMermaidDiagrams(root, isCurrent = () => true) {
+    const diagrams = Array.from(root.querySelectorAll(MERMAID_CODE_SELECTOR))
+        .map(prepareDiagram)
+        .filter((diagram) => diagram !== null);
+    const theme = resolveMermaidTheme(root.ownerDocument);
+    await Promise.all(diagrams.map(async ({ wrapper, source, fallback }) => {
+        clearRenderedDiagram(wrapper, fallback);
+        if (!source) {
+            showRenderFailure(wrapper, fallback);
+            return;
+        }
+        try {
+            const svg = await renderMermaidSvg(source, theme);
+            if (!isCurrent() || !wrapper.isConnected)
+                return;
+            if (!showRenderedDiagram(wrapper, fallback, svg))
+                showRenderFailure(wrapper, fallback);
+        }
+        catch {
+            if (isCurrent() && wrapper.isConnected)
+                showRenderFailure(wrapper, fallback);
+        }
+    }));
+}
+export function observeMermaidTheme(doc, onChange) {
+    let observation = mermaidThemeObservations.get(doc);
+    if (!observation) {
+        const listeners = new Set();
+        const notify = () => listeners.forEach(listener => listener());
+        const observer = new MutationObserver((mutations) => {
+            if (mutations.some(mutation => mutation.attributeName === 'data-theme'))
+                notify();
+        });
+        observer.observe(doc.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
+        const media = doc.defaultView?.matchMedia?.('(prefers-color-scheme: dark)');
+        media?.addEventListener?.('change', notify);
+        observation = { listeners, observer, media, notify };
+        mermaidThemeObservations.set(doc, observation);
+    }
+    observation.listeners.add(onChange);
+    return () => {
+        observation.listeners.delete(onChange);
+        if (observation.listeners.size > 0)
+            return;
+        observation.observer.disconnect();
+        observation.media?.removeEventListener?.('change', observation.notify);
+        mermaidThemeObservations.delete(doc);
+    };
+}

package/dist/mermaidZoom.d.ts

@@ -0,0 +1,23 @@
+export declare const MIN_MERMAID_ZOOM = 0.25;
+export declare const MAX_MERMAID_ZOOM = 4;
+export declare const MERMAID_ZOOM_STEP = 0.25;
+export interface MermaidSize {
+    width: number;
+    height: number;
+}
+export type MermaidZoomState = {
+    mode: 'fit';
+} | {
+    mode: 'manual';
+    scale: number;
+};
+export declare const FIT_MERMAID_ZOOM: MermaidZoomState;
+export declare function calculateMermaidFitScale(content: MermaidSize, viewport: MermaidSize): number | null;
+export declare function createManualMermaidZoom(scale: number): MermaidZoomState;
+export declare function resolveMermaidZoomScale(state: MermaidZoomState, fitScale: number | null): number;
+export declare function zoomMermaidIn(state: MermaidZoomState, fitScale: number | null): MermaidZoomState;
+export declare function zoomMermaidOut(state: MermaidZoomState, fitScale: number | null): MermaidZoomState;
+export declare function resetMermaidZoom(): MermaidZoomState;
+export declare function canZoomMermaidIn(state: MermaidZoomState, fitScale: number | null): boolean;
+export declare function canZoomMermaidOut(state: MermaidZoomState, fitScale: number | null): boolean;
+export declare function formatMermaidZoomLabel(state: MermaidZoomState, fitScale: number | null): string;

package/dist/mermaidZoom.js

@@ -0,0 +1,52 @@
+export const MIN_MERMAID_ZOOM = 0.25;
+export const MAX_MERMAID_ZOOM = 4;
+export const MERMAID_ZOOM_STEP = 0.25;
+export const FIT_MERMAID_ZOOM = { mode: 'fit' };
+function isPositiveSize(size) {
+    return Number.isFinite(size.width)
+        && Number.isFinite(size.height)
+        && size.width > 0
+        && size.height > 0;
+}
+function clampManualScale(scale) {
+    if (!Number.isFinite(scale))
+        return 1;
+    return Math.min(MAX_MERMAID_ZOOM, Math.max(MIN_MERMAID_ZOOM, scale));
+}
+function normalizeScale(scale) {
+    return Math.round(scale * 10_000) / 10_000;
+}
+export function calculateMermaidFitScale(content, viewport) {
+    if (!isPositiveSize(content) || !isPositiveSize(viewport))
+        return null;
+    return Math.min(viewport.width / content.width, viewport.height / content.height);
+}
+export function createManualMermaidZoom(scale) {
+    return { mode: 'manual', scale: clampManualScale(scale) };
+}
+export function resolveMermaidZoomScale(state, fitScale) {
+    if (state.mode === 'manual')
+        return state.scale;
+    return fitScale && fitScale > 0 ? fitScale : 1;
+}
+export function zoomMermaidIn(state, fitScale) {
+    const currentScale = resolveMermaidZoomScale(state, fitScale);
+    return createManualMermaidZoom(normalizeScale(currentScale + MERMAID_ZOOM_STEP));
+}
+export function zoomMermaidOut(state, fitScale) {
+    const currentScale = resolveMermaidZoomScale(state, fitScale);
+    return createManualMermaidZoom(normalizeScale(currentScale - MERMAID_ZOOM_STEP));
+}
+export function resetMermaidZoom() {
+    return createManualMermaidZoom(1);
+}
+export function canZoomMermaidIn(state, fitScale) {
+    return resolveMermaidZoomScale(state, fitScale) < MAX_MERMAID_ZOOM;
+}
+export function canZoomMermaidOut(state, fitScale) {
+    return resolveMermaidZoomScale(state, fitScale) > MIN_MERMAID_ZOOM;
+}
+export function formatMermaidZoomLabel(state, fitScale) {
+    const percentage = Math.round(resolveMermaidZoomScale(state, fitScale) * 100);
+    return state.mode === 'fit' ? `Fit (${percentage}%)` : `${percentage}%`;
+}

package/dist/openforgePackageMetadataSchema.json

@@ -19,15 +19,6 @@
             },
             "then": { "required": ["frontend"] }
         },
-        {
-            "if": {
-                "properties": {
-                    "requires": { "contains": { "const": "taskLinks" } }
-                },
-                "required": ["requires"]
-            },
-            "then": { "required": ["frontend"] }
-        },
         {
             "if": {
                 "properties": { "enablement": { "const": "app" } },
@@ -106,7 +97,8 @@
         "backend": {
             "type": "string",
             "minLength": 1,
-            "description": "Path to the built backend JavaScript entry artifact."
+            "pattern": "\\.(?:mjs|js|cjs)$",
+            "description": "Path to the built backend JavaScript artifact. Use .mjs for new plugins; .js and .cjs remain supported for compatibility. The host runs each backend in a replaceable worker."
         },
         "requires": {
             "type": "array",
@@ -136,7 +128,6 @@
                     "config",
                     "projectConfig",
                     "browserSurfaces",
-                    "taskLinks",
                     "appEnablement",
                     "customSidebarNavigation",
                     "reviewUI"