@abot-ai/runtime 1.6.0 → 1.7.0

package/dist/src/sessions/record/projection.js

@@ -1,4 +1,4 @@
-import { isAssistantInitiativeMessage } from "../assistant-initiative.js";
+import { isAssistantInitiativeMessage } from "../assistant-initiative-message.js";
 import { projectSessionRequestLifecycle } from "../request-lifecycle/projection.js";
 function getRequestEventCompactionKey(payload) {
     const type = typeof payload.type === "string" ? payload.type : "";
@@ -87,7 +87,7 @@ export function getRequestFinalState(request) {
     }
     return null;
 }
-function toMessageIdForUi(id) {
+export function toMessageIdForUi(id) {
     const match = /^msg-(\d+)$/.exec(id);
     if (match) {
         return Number(match[1]);
@@ -143,7 +143,7 @@ function messageSource(message) {
     }
     return message.role === "user" ? "user" : "request";
 }
-export function toSnapshotMessage(sessionId, message, requests) {
+export function toSnapshotMessage(sessionId, message, requests, resolveRequestId = createMessageRequestIdResolver(requests)) {
     return {
         ...(message.kind ? { kind: message.kind } : {}),
         ...(message.approvalRequest
@@ -155,7 +155,7 @@ export function toSnapshotMessage(sessionId, message, requests) {
         text: message.content,
         source: messageSource(message),
         createdAt: toEpochMs(message.createdAt),
-        requestId: message.requestId ?? inferMessageRequestId(message, requests),
+        requestId: resolveRequestId(message),
         cronJobId: message.cronJobId ?? null,
         ...(message.initiative ? { initiative: message.initiative } : {}),
         ...(message.schedule ? { schedule: message.schedule } : {}),
@@ -166,22 +166,30 @@ export function toSnapshotMessage(sessionId, message, requests) {
             : {}),
     };
 }
-function inferMessageRequestId(message, requests) {
-    if (isAssistantInitiativeMessage(message))
-        return null;
-    if (message.role !== "assistant") {
-        return null;
-    }
-    for (let index = requests.length - 1; index >= 0; index -= 1) {
-        const request = requests[index];
+export function createMessageRequestIdResolver(requests) {
+    let completedOutputs;
+    return (message) => {
+        if (message.requestId != null)
+            return message.requestId;
+        if (isAssistantInitiativeMessage(message))
+            return null;
+        if (message.role !== "assistant")
+            return null;
+        completedOutputs ??= indexCompletedRequestOutputs(requests);
+        return completedOutputs.get(message.content) ?? null;
+    };
+}
+function indexCompletedRequestOutputs(requests) {
+    const outputs = new Map();
+    for (const request of requests) {
         const finalState = getRequestFinalState(request);
-        if (finalState?.status === "completed" &&
-            typeof finalState.output === "string" &&
-            finalState.output === message.content) {
-            return request.requestId;
-        }
+        if (finalState?.status !== "completed")
+            continue;
+        if (typeof finalState.output !== "string")
+            continue;
+        outputs.set(finalState.output, request.requestId);
     }
-    return null;
+    return outputs;
 }
 export function toSnapshotRequest(request) {
     return {

package/dist/src/sessions/request-lifecycle/service.js

@@ -10,7 +10,7 @@ import { acceptedLifecycle, appendLifecycleEvent, lifecycleRequest, rejectLifecy
 /** Commands share SessionService's queue and file, never a parallel checkpoint store. */
 export function createSessionRequestLifecycle(dependencies) {
     const blobs = createSessionContinuationBlobs(dependencies.sessionsDir);
-    async function mutate(sessionId, operation) {
+    async function mutate(sessionId, operation, metadataChange = "projection") {
         assertValidSessionId(sessionId);
         return dependencies.enqueue(sessionId, async () => {
             const session = await dependencies.read(sessionId);
@@ -24,7 +24,7 @@ export function createSessionRequestLifecycle(dependencies) {
             });
             if (!result.accepted || result.duplicate)
                 return result;
-            await saveDurableSessionFile(dependencies.sessionsDir, session);
+            await saveDurableSessionFile(dependencies.sessionsDir, session, undefined, metadataChange);
             await cleanupConsumedSessionContinuations(dependencies.sessionsDir, session, previousBlobs);
             return result;
         });
@@ -59,7 +59,7 @@ export function createSessionRequestLifecycle(dependencies) {
             return acceptedLifecycle(request, [
                 appendLifecycleEvent(context, request, command.payload),
             ]);
-        }),
+        }, "request-only"),
         async get(sessionId, requestId) {
             const request = await readRequest(sessionId, requestId);
             return request ? (projectSessionRequestLifecycle(request) ?? null) : null;

package/dist/src/sessions/session-service.d.ts

@@ -1,3 +1,4 @@
+import { type SessionSnapshotOptions } from "./snapshot.js";
 import { type AutomationSessionHandle, type AutomationSessionOrigin } from "./automation-session-origin.js";
 import type { SessionRequestLifecycleStore } from "./request-lifecycle/contracts.js";
 import { type CreateAssistantConversationInput } from "./assistant-initiative.js";
@@ -31,10 +32,7 @@ export declare class SessionService {
         cursor?: string | null;
     }): Promise<SessionListResult>;
     getSessionById(sessionId: string): Promise<SessionRecord | null>;
-    getSessionSnapshot(sessionId: string, options?: {
-        afterMessageId?: string | number | null;
-        includeRequests?: boolean;
-    }): Promise<SessionSnapshot | null>;
+    getSessionSnapshot(sessionId: string, options?: SessionSnapshotOptions): Promise<SessionSnapshot | null>;
     getRequestReplayById(requestId: string, afterSeq?: number): Promise<SessionRequestReplay | null>;
     deleteSession(sessionId: string): Promise<boolean>;
     deleteSessionWithStats(sessionId: string): Promise<SessionDeleteResult>;

package/dist/src/sessions/session-service.js

@@ -1,3 +1,4 @@
+import { projectSessionSnapshot } from "./snapshot.js";
 import { randomUUID } from "node:crypto";
 import { AutomationSessionLockedError, createAutomationSessionAccess, hasAutomationSessionOrigin, } from "./automation-session-origin.js";
 import { createAutomationSessionStore } from "./automation-session-store.js";
@@ -9,7 +10,7 @@ import { createAssistantConversationRecord, } from "./assistant-initiative.js";
 import { assertSessionProjectUnchanged, copySessionProject, } from "./project-binding.js";
 import { getDefaultSessionsDir } from "../runtime/config/layout.js";
 import { assertValidSessionArtifactPathInputs, upsertSessionArtifactPaths, } from "./artifact-paths.js";
-import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, toSnapshotMessage, toSnapshotRequest, } from "./record/projection.js";
+import { compactRequestEvents, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, } from "./record/projection.js";
 import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "./record/rules.js";
 import { deleteSessionFile, ensureSessionsDir, loadAllSessionFiles, loadSessionFile, saveSessionFile, } from "./session-store.js";
 import { resolveSessionMemoryCheckpointCommit } from "./memory/rules.js";
@@ -115,20 +116,7 @@ export class SessionService {
     }
     async getSessionSnapshot(sessionId, options = {}) {
         const session = await this.getSessionById(sessionId);
-        if (!session) {
-            return null;
-        }
-        return {
-            sessionId,
-            ...(session.kind ? { kind: session.kind } : {}),
-            ...(session.project ? { project: session.project } : {}),
-            title: session.title,
-            messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),
-            requests: options.includeRequests === false
-                ? []
-                : (session.requests ?? []).map(toSnapshotRequest),
-            nextCursor: null,
-        };
+        return session ? projectSessionSnapshot(session, options) : null;
     }
     async getRequestReplayById(requestId, afterSeq = 0) {
         assertValidRequestId(requestId);
@@ -440,7 +428,7 @@ export class SessionService {
                 request.status = "streaming";
             }
             session.updatedAt = timestamp;
-            await saveSessionFile(this.sessionsDir, session);
+            await saveSessionFile(this.sessionsDir, session, undefined, "request-only");
             return session;
         });
     }

package/dist/src/sessions/session-store.d.ts

@@ -1,6 +1,7 @@
 import type { SessionRecord } from "./types.js";
+import type { SessionMetadataChange } from "./metadata/source-receipt.js";
 export declare function ensureSessionsDir(sessionsDir: string): Promise<void>;
 export declare function loadSessionFile(sessionsDir: string, sessionId: string): Promise<SessionRecord | null>;
-export declare function saveSessionFile(sessionsDir: string, session: SessionRecord, assertCurrent?: () => void): Promise<void>;
+export declare function saveSessionFile(sessionsDir: string, session: SessionRecord, assertCurrent?: () => void, metadataChange?: SessionMetadataChange): Promise<void>;
 export declare function deleteSessionFile(sessionsDir: string, sessionId: string): Promise<boolean>;
 export declare function loadAllSessionFiles(sessionsDir: string): Promise<SessionRecord[]>;

package/dist/src/sessions/session-store.js

@@ -1,8 +1,9 @@
-import { mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { saveDurableSessionFile, syncSessionDirectory, } from "./durable-session-commit.js";
 import { cleanupSessionContinuations } from "./request-lifecycle/continuation-cleanup.js";
+import { currentSourceStamp, deleteSessionMetadata, sessionSourceStamp, updateSessionMetadata } from "./metadata/store.js";
 function getSessionFilePath(sessionsDir, sessionId) {
     return join(sessionsDir, `${sessionId}.json`);
 }
@@ -22,14 +23,17 @@ export async function loadSessionFile(sessionsDir, sessionId) {
         throw error;
     }
 }
-export async function saveSessionFile(sessionsDir, session, assertCurrent) {
+export async function saveSessionFile(sessionsDir, session, assertCurrent, metadataChange = "projection") {
     if (session.requests?.some((request) => request.lifecycle)) {
-        return saveDurableSessionFile(sessionsDir, session, assertCurrent);
+        return saveDurableSessionFile(sessionsDir, session, assertCurrent, metadataChange);
     }
     const filePath = getSessionFilePath(sessionsDir, session.id);
+    const previousSource = metadataChange === "request-only" ? await currentSourceStamp(filePath) : undefined;
     const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    let source;
     try {
         await writeFile(tempPath, JSON.stringify(session, null, 2), "utf-8");
+        source = sessionSourceStamp(await stat(tempPath, { bigint: true }));
         assertCurrent?.();
         await rename(tempPath, filePath);
     }
@@ -37,12 +41,14 @@ export async function saveSessionFile(sessionsDir, session, assertCurrent) {
         await rm(tempPath, { force: true }).catch(() => undefined);
         throw error;
     }
+    await updateSessionMetadata(sessionsDir, session, source, previousSource);
 }
 export async function deleteSessionFile(sessionsDir, sessionId) {
     const filePath = getSessionFilePath(sessionsDir, sessionId);
     try {
         await rm(filePath);
         await syncSessionDirectory(sessionsDir);
+        await deleteSessionMetadata(sessionsDir, sessionId);
         await cleanupSessionContinuations(sessionsDir, sessionId);
         return true;
     }

package/dist/src/sessions/snapshot.d.ts

@@ -0,0 +1,17 @@
+import type { SessionRecord, SessionSnapshot, SessionSnapshotMessage } from "./types.js";
+export type SessionMessageIdentity = Pick<SessionSnapshotMessage, "id" | "role" | "createdAt" | "requestId">;
+export type SessionSnapshotOptions = {
+    afterMessageId?: string | number | null;
+    includeRequests?: boolean;
+    /** Web read receipts need identities, never message bodies or request events. */
+    identitiesOnly?: boolean;
+    page?: {
+        limit: number;
+        cursor?: string | null;
+        targetMessageId?: string;
+        targetCreatedAt?: number;
+        targetRequestId?: string;
+        waitingRequestId?: string;
+    };
+};
+export declare function projectSessionSnapshot(session: SessionRecord, options?: SessionSnapshotOptions): SessionSnapshot;

package/dist/src/sessions/snapshot.js

@@ -0,0 +1,105 @@
+import { clientVisibleMessages, filterMessagesAfter, createMessageRequestIdResolver, toEpochMs, toMessageIdForUi, toSnapshotMessage, toSnapshotRequest } from "./record/projection.js";
+function encodeAnchor(sessionId, message, direction) {
+    return Buffer.from(JSON.stringify({ sessionId, id: message.id, createdAt: message.createdAt, direction })).toString("base64url");
+}
+function decodeAnchor(cursor, sessionId) {
+    try {
+        const anchor = JSON.parse(Buffer.from(cursor, "base64url").toString());
+        if (anchor.sessionId !== sessionId)
+            throw new Error();
+        if (typeof anchor.id !== "string" || typeof anchor.createdAt !== "string")
+            throw new Error();
+        if (!["older", "newer"].includes(anchor.direction))
+            throw new Error();
+        return anchor;
+    }
+    catch {
+        throw new Error("history_cursor_stale");
+    }
+}
+function messageWindow(sessionId, messages, page, resolveRequestId) {
+    const limit = page.limit;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+        throw new Error("history_page_size_invalid");
+    let start = Math.max(0, messages.length - limit);
+    let end = messages.length;
+    if (page.targetMessageId != null) {
+        const target = messages.findIndex((message) => {
+            if (String(toMessageIdForUi(message.id)) !== page.targetMessageId)
+                return false;
+            if (page.targetCreatedAt == null)
+                return true;
+            if (toEpochMs(message.createdAt) !== page.targetCreatedAt)
+                return false;
+            return (resolveRequestId(message) || "") === (page.targetRequestId || "");
+        });
+        if (target >= 0) {
+            start = target;
+            end = Math.min(messages.length, start + limit);
+        }
+    }
+    else if (page.targetRequestId) {
+        const target = messages.findIndex((message) => resolveRequestId(message) === page.targetRequestId);
+        if (target >= 0) {
+            start = target;
+            end = Math.min(messages.length, start + limit);
+        }
+    }
+    if (page.cursor) {
+        const anchor = decodeAnchor(page.cursor, sessionId);
+        const index = messages.findIndex((message) => message.id === anchor.id && message.createdAt === anchor.createdAt);
+        if (index < 0)
+            throw new Error("history_cursor_stale");
+        start = anchor.direction === "older" ? Math.max(0, index - limit) : index + 1;
+        end = anchor.direction === "older" ? index : Math.min(messages.length, start + limit);
+    }
+    const selected = messages.slice(start, end);
+    return {
+        selected,
+        nextCursor: start > 0 && selected.length ? encodeAnchor(sessionId, selected[0], "older") : null,
+        newerCursor: end < messages.length && selected.length ? encodeAnchor(sessionId, selected.at(-1), "newer") : null,
+    };
+}
+function isRequiredPageRequest(request, ids, waitingRequestId, continuation = false) {
+    if (ids.has(request.requestId))
+        return true;
+    if (continuation)
+        return false;
+    if (request.requestId === waitingRequestId)
+        return true;
+    if (request.status === "streaming")
+        return true;
+    return request.status === "awaiting_approval";
+}
+export function projectSessionSnapshot(session, options = {}) {
+    const visible = clientVisibleMessages(session.messages);
+    const requests = session.requests ?? [];
+    const resolveRequestId = createMessageRequestIdResolver(requests);
+    const base = {
+        sessionId: session.id, title: session.title,
+        ...(session.kind ? { kind: session.kind } : {}),
+        ...(session.project ? { project: session.project } : {}),
+    };
+    // The default projection is kept intact for existing session consumers.
+    if (!options.page && !options.identitiesOnly)
+        return {
+            ...base,
+            messages: filterMessagesAfter(visible, options.afterMessageId).map((message) => toSnapshotMessage(session.id, message, requests, resolveRequestId)),
+            requests: options.includeRequests === false ? [] : requests.map(toSnapshotRequest),
+            nextCursor: null,
+        };
+    const messageIndex = visible.map((message) => ({
+        id: toMessageIdForUi(message.id), role: message.role, createdAt: toEpochMs(message.createdAt),
+        requestId: resolveRequestId(message),
+    }));
+    if (options.identitiesOnly)
+        return { ...base, messages: [], requests: [], nextCursor: null, messageIndex };
+    const page = messageWindow(session.id, visible, options.page, resolveRequestId);
+    const messages = page.selected.map((message) => toSnapshotMessage(session.id, message, requests, resolveRequestId));
+    const ids = new Set(messages.map((message) => message.requestId));
+    return {
+        ...base, messages, messageIndex, nextCursor: page.nextCursor, newerCursor: page.newerCursor,
+        requests: options.includeRequests === false ? [] : requests
+            .filter((request) => isRequiredPageRequest(request, ids, options.page?.waitingRequestId, Boolean(options.page?.cursor))).map(toSnapshotRequest),
+    };
+}

package/dist/src/sessions/types.d.ts

@@ -130,6 +130,8 @@ export type SessionSnapshot = {
     messages: SessionSnapshotMessage[];
     requests: SessionSnapshotRequest[];
     nextCursor: string | null;
+    newerCursor?: string | null;
+    messageIndex?: import("./snapshot.js").SessionMessageIdentity[];
 };
 export type SessionDeleteResult = {
     sessionId: string;

package/dist/src/shared/tool-selection.d.ts

@@ -0,0 +1,2 @@
+/** Matches the existing wildcard, owner, tool, and qualified tool selectors. */
+export declare function matchesToolSelectionId(ownerId: string, toolName: string, configuredId: string): boolean;

package/dist/src/shared/tool-selection.js

@@ -0,0 +1,7 @@
+/** Matches the existing wildcard, owner, tool, and qualified tool selectors. */
+export function matchesToolSelectionId(ownerId, toolName, configuredId) {
+    return (configuredId === "*" ||
+        configuredId === ownerId ||
+        configuredId === toolName ||
+        configuredId === `${ownerId}.${toolName}`);
+}

package/dist/src/web-ui/app/ARCHITECTURE.md

@@ -216,6 +216,20 @@ The server checks synchronous owner admission, refuses busy or externally owned
 environments, and refreshes its gateway through the owning lifecycle callback.
 Browser reload and saved selection are not evidence of live activation.
 
+Plugin configuration uses the existing manifest defaults and secret declarations.
+`components/plugins/configuration-fields.js` owns the shared install/edit form;
+`configuration-editor.js` keeps an editing dialog outside dashboard replacement.
+Installation drafts move their existing controls during rendering rather than
+serializing password values. Environment/workspace navigation respects unfinished
+configuration, and writes keep the existing external mutation guard.
+
+`plugin-configuration-service.ts` owns saved-value validation and the redacted
+projection. Its private store is installation-scoped, outside plugin packages,
+and survives removal. Saves and Apply acquire the canonical Runtime-file lock
+then the private-store lock. The plugin loader captures local values once per
+compiled configuration lifetime, preserving previous-owner rollback without
+changing plugin SDK or manifest contracts. No process environment is mutated.
+
 ### Additive model setup
 
 Configuration composes a separate Provider / Model / Ready dialog in

package/dist/src/web-ui/app/app.js

@@ -68,6 +68,7 @@ let projectsFeature;
 let workspaceRoutes;
 let notifications;
 const operationsController = createOperationsController({
+  onSummaryChange: () => configWorkspace?.syncSummary(),
   dom,
   client: runtimeClient,
   getEnvironmentId: selectedEnvironmentId,
@@ -100,7 +101,7 @@ const steerController = createSteerController({
 
 const shell = createWorkspaceShell({
   dom,
-  onNavigationChange: () => workspaceRoutes?.sync(),
+  onNavigationChange: () => { configWorkspace?.syncSummary(); workspaceRoutes?.sync(); },
   isWorkspaceAvailable: (destination) => {
     if (!notifications?.isWorkspaceAvailable(destination)) return false;
     return schedulesFeature?.isWorkspaceAvailable(destination) ?? false;
@@ -166,7 +167,7 @@ schedulesFeature = createSchedulesFeature({
   getCurrentSessionId: () => state.currentSessionId,
   getAgentModes: () => state.supportedAgentModes,
   isRuntimeReady: runtimeOnboarding.isReady,
-  openSession: (sessionId) => conversationSession.openSession(sessionId),
+  openSession: (sessionId, options) => conversationSession.openSession(sessionId, options),
 });
 passiveLearning = createPassiveLearningFeature({
   isRuntimeReady: runtimeOnboarding.isReady,
@@ -190,7 +191,7 @@ dashboardFeature = createDashboardFeature({
   schedules: schedulesFeature,
   selectedEnvironmentId,
   loadSessions,
-  openSession: (sessionId) => conversationSession.openSession(sessionId),
+  openSession: (sessionId, options) => conversationSession.openSession(sessionId, options),
   isComposerAvailable: runtimeOnboarding.isReady,
   passiveLearning,
 });
@@ -563,8 +564,10 @@ const appEventBindings = createAppEventBindings({
 });
 
 configWorkspace = createConfigurationFeature({
+  getOperationsSummary: () => operationsController.summary(shell.activeOperationsTab()),
   getLearningSnapshot: () => passiveLearning?.snapshot(),
   isRuntimeReady: runtimeOnboarding.isReady,
+  isComputerAccessAvailable: () => shell.isWorkspaceAvailable("config"),
   onNavigationChange: () => workspaceRoutes?.sync(),
   state,
   selection: runtimeSelection,

package/dist/src/web-ui/app/components/config-workspace/config-model.js

@@ -126,6 +126,8 @@ export function formattedConfig(config) {
 export function createConfigWorkspaceModel() {
   const state = {
     configDashboard: null,
+    configDashboardError: false,
+    modelPluginCatalog: null,
     baselinesByKey: new Map(),
     rawDraftsByKey: new Map(),
     appliedJsonRepairKeys: new Set(),

package/dist/src/web-ui/app/components/config-workspace/model-plugin-permissions.js

@@ -0,0 +1,130 @@
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+import {
+  modelPluginRulesNeedRepair,
+  projectModelPluginSelection,
+} from "./model-plugin-selection.js";
+
+export async function loadModelPluginCatalog(loadPlugins) {
+  if (!loadPlugins) return null;
+  try {
+    const snapshot = await loadPlugins();
+    return { plugins: snapshot.plugins || [], error: "" };
+  } catch (error) {
+    return {
+      plugins: [],
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function modelLabel(file) {
+  return file.config.label || file.id;
+}
+
+function renderCapabilitySwitch(file, plugin, capability) {
+  const reason = capability.blockedReason;
+  const reasonId = `model-tool-policy-${encodeURIComponent(file.id)}-${encodeURIComponent(plugin.id)}-${encodeURIComponent(capability.id)}`;
+  return `<li class="plugin-capability-row">
+    <div class="plugin-capability-copy">
+      <code>${escapeHtml(capability.id)}</code>
+      ${capability.description ? `<p class="plugin-capability-description" title="${escapeAttribute(capability.description)}">${escapeHtml(capability.description)}</p>` : ""}
+      ${reason ? `<p class="plugin-capability-policy" id="${escapeAttribute(reasonId)}">${escapeHtml(reason)}</p>` : ""}
+    </div>
+    <label class="plugin-capability-switch">
+      <input type="checkbox" role="switch" data-config-action="model-plugin-capability-enabled"
+        data-kind="model" data-id="${escapeAttribute(file.id)}"
+        data-plugin-id="${escapeAttribute(plugin.id)}" data-capability-id="${escapeAttribute(capability.id)}"
+        aria-label="${escapeAttribute(`Allow ${capability.id} in ${plugin.id} for ${modelLabel(file)}`)}"
+        ${reason ? `aria-describedby="${escapeAttribute(reasonId)}" disabled` : ""}
+        ${capability.enabled ? "checked" : ""} />
+      <span aria-hidden="true"></span>
+    </label>
+  </li>`;
+}
+
+function renderPluginRow(file, plugin, globalPlugin, viewState) {
+  const key = JSON.stringify([file.id, plugin.id]);
+  const open = viewState.expandedPlugins?.has(key);
+  const count = plugin.capabilities.length;
+  const reason = plugin.controlBlockedReason;
+  const pluginIdentity = `${encodeURIComponent(file.id)}-${encodeURIComponent(plugin.id)}`;
+  const summaryId = `model-plugin-summary-${pluginIdentity}`;
+  const reasonId = `model-plugin-policy-${pluginIdentity}`;
+  const globallyRestricted = ["partial", "disabled"].includes(
+    globalPlugin.state,
+  );
+  return `<article class="model-plugin-row">
+    <details data-model-plugin-details="${escapeAttribute(plugin.id)}" data-model-id="${escapeAttribute(file.id)}" ${open ? "open" : ""}>
+      <summary id="${escapeAttribute(summaryId)}">
+        <span class="model-plugin-name" title="${escapeAttribute(plugin.id)}">${escapeHtml(plugin.id)}</span>
+        <span class="model-plugin-row-status">
+          ${globallyRestricted ? '<span class="model-plugin-global-note">Global restrictions</span>' : ""}
+          <span class="plugin-selection-state" data-plugin-state="${escapeAttribute(plugin.state)}">${plugin.selectedCapabilityCount}/${count} tools</span>
+        </span>
+      </summary>
+      <div class="model-plugin-details-body">
+        ${plugin.description ? `<p class="model-plugin-description">${escapeHtml(plugin.description)}</p>` : ""}
+        ${reason ? `<p class="plugin-capability-policy model-plugin-policy" id="${escapeAttribute(reasonId)}">${escapeHtml(reason)}</p>` : ""}
+        <ul class="plugin-capability-list model-plugin-capability-list" aria-label="${escapeAttribute(`Tools in ${plugin.id} for ${modelLabel(file)}`)}">
+          ${count ? plugin.capabilities.map((capability) => renderCapabilitySwitch(file, plugin, capability)).join("") : '<li class="plugin-capability-empty">This plugin does not expose any tools.</li>'}
+        </ul>
+      </div>
+    </details>
+    <label class="plugin-capability-switch model-plugin-master-switch" title="${escapeAttribute(reason || `Allow ${plugin.id} for this model`)}">
+      <input type="checkbox" role="switch" data-config-action="model-plugin-enabled"
+        data-kind="model" data-id="${escapeAttribute(file.id)}" data-plugin-id="${escapeAttribute(plugin.id)}"
+        aria-label="${escapeAttribute(`Allow ${plugin.id} for ${modelLabel(file)}`)}"
+        ${reason ? `aria-describedby="${escapeAttribute(reasonId)}" disabled` : ""}
+        ${plugin.pluginEnabled ? "checked" : ""} />
+      <span aria-hidden="true"></span>
+    </label>
+  </article>`;
+}
+
+function renderSavedRules(file, viewState) {
+  const denied = file.config.plugins?.deny || [];
+  if (!denied.length) return "";
+  const open = viewState.expandedRetainedRules?.has(file.id);
+  return `<details class="model-plugin-saved-rules" data-model-plugin-retained="${escapeAttribute(file.id)}" ${open ? "open" : ""}>
+    <summary>Saved rules <span>${denied.length}</span></summary>
+    <p>Rules without an editable switch can be changed in the model configuration file shown above.</p>
+    <ul>${denied.map((selector) => `<li><code>${escapeHtml(selector)}</code></li>`).join("")}</ul>
+  </details>`;
+}
+
+export function renderModelPluginPermissions(file, catalog, viewState = {}) {
+  if (!catalog) return "";
+  const open = catalog.error || viewState.expandedSections?.has(file.id);
+  const summaryId = `model-plugin-access-${encodeURIComponent(file.id)}`;
+  if (modelPluginRulesNeedRepair(file.config)) {
+    return `<details class="model-plugin-permissions" data-model-plugin-section="${escapeAttribute(file.id)}" open>
+      <summary id="${escapeAttribute(summaryId)}">Plugin access</summary>
+      <p class="error-text">Repair plugins.deny in the model configuration file shown above before changing model plugin restrictions.</p>
+    </details>`;
+  }
+  const plugins = catalog.plugins.map((plugin) =>
+    projectModelPluginSelection(file.config, plugin, catalog.plugins),
+  );
+  const selectedCount = plugins.reduce(
+    (count, plugin) => count + plugin.selectedCapabilityCount,
+    0,
+  );
+  const capabilityCount = plugins.reduce(
+    (count, plugin) => count + plugin.capabilities.length,
+    0,
+  );
+  return `<details class="model-plugin-permissions" data-model-plugin-section="${escapeAttribute(file.id)}" aria-label="${escapeAttribute(`Plugin access for ${modelLabel(file)}`)}" ${open ? "open" : ""}>
+    <summary id="${escapeAttribute(summaryId)}">
+      <span>Plugin access</span>
+      <span class="model-plugin-summary-count">${plugins.length} plugins · ${selectedCount}/${capabilityCount} tools available</span>
+    </summary>
+    <div class="model-plugin-permissions-body">
+      <p class="model-plugin-help">Allow plugins and individual tools for <strong>${escapeHtml(modelLabel(file))}</strong>. Global restrictions still apply. Save this model, then apply changes.</p>
+      ${catalog.error ? `<p class="error-text">Plugin list unavailable: ${escapeHtml(catalog.error)}. Refresh configuration to retry; saved restrictions are retained.</p>` : ""}
+      <div class="model-plugin-list">
+        ${plugins.map((plugin, index) => renderPluginRow(file, plugin, catalog.plugins[index], viewState)).join("")}
+      </div>
+      ${renderSavedRules(file, viewState)}
+    </div>
+  </details>`;
+}