@alisio/core 0.2.0 → 0.3.0

package/dist/application.d.ts

@@ -14,6 +14,7 @@ import { type SettableSettingKey } from "./config.ts";
 import type { ApprovalHandler } from "./core/contracts.ts";
 import { ToolRegistry } from "./core/registry.ts";
 import { AgentRunner } from "./core/runner.ts";
+import { DecisionMetrics, DecisionRegistry, DecisionService } from "./decisions/index.ts";
 import { GoalService } from "./goal/service.ts";
 import { HerdrBridge } from "./integrations/herdr.ts";
 import { McpConnector } from "./mcp/connector.ts";
@@ -198,6 +199,12 @@ export declare function createApplication(options?: AppOptions): Promise<{
     /** Tabular datasets of every session (ingestion, read-only queries, pages). */
     datasets: DatasetService;
     registry: ToolRegistry;
+    /** Decision Intelligence: the provider catalog, the service and in-memory metrics. */
+    decisions: {
+        registry: DecisionRegistry;
+        service: DecisionService;
+        metrics: DecisionMetrics;
+    };
     context: ProjectContext;
     skills: Skills;
     /** Path- and content-safe metadata for the interactive skills manager. */

package/dist/application.js

@@ -16,9 +16,11 @@ import { subagentTasks } from "./background/mirror.js";
 import { BackgroundTasks } from "./background/service.js";
 import { configFile, configHome, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
 import { completeText } from "./core/compaction.js";
+import { HumanWaits } from "./core/human-wait.js";
 import { DEFAULT_MAX_OUTPUT_TOKENS } from "./core/output-limit.js";
 import { ToolRegistry } from "./core/registry.js";
 import { AgentRunner } from "./core/runner.js";
+import { bindDecisions, DecisionMetrics, DecisionRegistry, DecisionService, } from "./decisions/index.js";
 import { GoalService } from "./goal/service.js";
 import { GoalStore } from "./goal/store.js";
 import { HerdrBridge } from "./integrations/herdr.js";
@@ -86,11 +88,25 @@ export async function createApplication(options = {}) {
     const addDirs = options.readOnly
         ? []
         : await Promise.all((options.addDirs ?? []).map((dir) => realpath(resolve(cwd, dir)).catch(() => resolve(cwd, dir))));
+    // Waits for a person (approvals, questions, the plan review) do not count against the run's
+    // time limit. One registry serves the runner, the plugin host's interactive UI and the
+    // external-directory approval, so every host (TUI, web server, embedders) gets it for free.
+    const humanWaits = new HumanWaits((session) => {
+        try {
+            return store.get(session).parentId ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    });
+    const askExternalDirectory = options.approveExternalDirectory;
     const pathAccess = new PathAccess({
         workspace,
         extraRoots: [...config.additionalDirectories, ...addDirs],
-        ...(options.approveExternalDirectory && !options.readOnly
-            ? { approve: options.approveExternalDirectory }
+        ...(askExternalDirectory && !options.readOnly
+            ? {
+                approve: (request) => humanWaits.track(request.session, () => askExternalDirectory(request)),
+            }
             : {}),
         readOnly: !!options.readOnly,
     });
@@ -107,7 +123,19 @@ export async function createApplication(options = {}) {
         cwd,
         claudeMdFallback: config.context.claudeMdFallback,
         maxBytes: config.context.maxBytes,
-    }), providers = new ProviderRegistry(), plugins = new PluginHost(registry, store, config.pluginHooks, providers), mcp = new McpConnector(config.mcp.servers, registry, workspace, options.readOnly ? "read-only" : options.allowMcp || mcpAllow ? "allowed" : "disabled", config.mcpSources);
+    }), providers = new ProviderRegistry(), plugins = new PluginHost(registry, store, {
+        hookTimeoutMs: config.pluginHooks.timeoutMs,
+        sessionEndTimeoutMs: config.pluginHooks.sessionEndTimeoutMs,
+        disposeTimeoutMs: config.pluginHooks.disposeTimeoutMs,
+    }, providers), decisionRegistry = new DecisionRegistry(), decisionMetrics = new DecisionMetrics(), decisionService = new DecisionService({
+        registry: decisionRegistry,
+        // Read per call: `updateSetting("decisions.*")` mutates `config.decisions`.
+        config: () => config.decisions,
+        metrics: decisionMetrics,
+        // Failures never reach the terminal (they would garble the TUI): they are kept as
+        // `lastLifecycleError` in the service status.
+        lifecycle: { timeoutMs: () => config.pluginHooks.timeoutMs },
+    }), mcp = new McpConnector(config.mcp.servers, registry, workspace, options.readOnly ? "read-only" : options.allowMcp || mcpAllow ? "allowed" : "disabled", config.mcpSources);
     let mcpRuntimePermission = options.readOnly
         ? "read-only"
         : options.allowMcp || mcpAllow
@@ -116,6 +144,20 @@ export async function createApplication(options = {}) {
     const herdr = options.noHerdr
         ? new HerdrBridge({}, async () => "")
         : HerdrBridge.fromEnvironment(workspace, (error) => process.stderr.write(`${error}\n`));
+    // Decision providers and per-plugin directories/options are bound before any plugin loads.
+    plugins.setDecisions({ registry: decisionRegistry, service: decisionService });
+    const stateRoot = options.db && options.db !== ":memory:" ? dirname(options.db) : stateHome();
+    plugins.setPluginEnvironment({
+        stateRoot,
+        configHome: configHome(),
+        options: (id, builtin) => {
+            if (builtin) {
+                const { enabled: _enabled, ...rest } = config.builtinPlugins[id] ?? {};
+                return rest;
+            }
+            return config.pluginOverrides[id]?.options ?? {};
+        },
+    });
     try {
         // First-party built-ins load through the trusted path, also under --read-only.
         const builtinContext = {
@@ -264,6 +306,9 @@ export async function createApplication(options = {}) {
                 }
             }
         }
+        // Every plugin has registered its providers: start the configured one in the background
+        // (`activate` is bounded, never fatal and never awaited here).
+        decisionService.syncActive();
         // Project skills follow the config trust model (--trust-project or an explicit --config).
         await skills.discover(skillRoots({
             workspace,
@@ -285,7 +330,6 @@ export async function createApplication(options = {}) {
             resolveExtension: () => plugins.extensions.resolve("websearch"),
         }, pathAccess);
         // Python analysis and artifacts live next to the session database (like attachment blobs).
-        const stateRoot = options.db && options.db !== ":memory:" ? dirname(options.db) : stateHome();
         const artifacts = new ArtifactStore({
             root: stateRoot,
             db: store.db,
@@ -730,7 +774,9 @@ export async function createApplication(options = {}) {
                 : [];
             return declared.length ? Math.min(...declared) : undefined;
         };
+        plugins.setHumanWaits(humanWaits);
         const runner = new AgentRunner({
+            humanWaits,
             provider,
             providerFor,
             registry,
@@ -770,6 +816,7 @@ export async function createApplication(options = {}) {
                     },
                 }
                 : {}),
+            decisions: (call, announce) => bindDecisions(decisionService, () => config.decisions.telemetry, call, announce),
             artifacts: (call, announce) => createArtifactPublisher(artifacts, {
                 sessionId: call.sessionId,
                 rootSessionId: store.rootOf(call.sessionId),
@@ -899,6 +946,8 @@ export async function createApplication(options = {}) {
             /** Tabular datasets of every session (ingestion, read-only queries, pages). */
             datasets,
             registry,
+            /** Decision Intelligence: the provider catalog, the service and in-memory metrics. */
+            decisions: { registry: decisionRegistry, service: decisionService, metrics: decisionMetrics },
             context,
             skills,
             /** Path- and content-safe metadata for the interactive skills manager. */
@@ -1103,6 +1152,33 @@ export async function createApplication(options = {}) {
                         config.pluginHooks = { ...config.pluginHooks, timeoutMs: Number(value) };
                         plugins.applyTimeoutSettings({ hookTimeoutMs: Number(value) });
                         break;
+                    case "pluginHooks.disposeTimeoutMs":
+                        config.pluginHooks = { ...config.pluginHooks, disposeTimeoutMs: Number(value) };
+                        plugins.applyTimeoutSettings({ disposeTimeoutMs: Number(value) });
+                        break;
+                    case "decisions.enabled":
+                    case "decisions.telemetry": {
+                        // Read live by the service on its next call; `enabled` also drives the provider's
+                        // activate/deactivate lifecycle.
+                        const leaf = key.slice("decisions.".length);
+                        config.decisions = { ...config.decisions, [leaf]: value === true };
+                        decisionService.syncActive();
+                        break;
+                    }
+                    case "decisions.provider":
+                        // `!clear` (undefined) deactivates the feature.
+                        config.decisions = {
+                            ...config.decisions,
+                            provider: value === undefined || value === null ? null : String(value),
+                        };
+                        decisionService.syncActive();
+                        break;
+                    case "decisions.timeoutMs":
+                    case "decisions.minConfidence": {
+                        const leaf = key.slice("decisions.".length);
+                        config.decisions = { ...config.decisions, [leaf]: Number(value) };
+                        break;
+                    }
                     case "tui.paddingX":
                         config.tui = { ...config.tui, paddingX: Number(value) };
                         break;
@@ -1357,7 +1433,11 @@ export async function createApplication(options = {}) {
                                 ...[...runtimes]
                                     .filter((runtime) => runtime !== provider.currentProvider)
                                     .map((runtime) => Promise.resolve(runtime.dispose?.())),
-                                plugins.close(),
+                                // The active decision provider stops first (its own limit), then every plugin
+                                // is disposed in parallel, each bounded by `pluginHooks.disposeTimeoutMs`.
+                                decisionService
+                                    .shutdown(config.pluginHooks.disposeTimeoutMs)
+                                    .then(() => plugins.close()),
                             ]);
                         })());
                     }
@@ -1370,7 +1450,11 @@ export async function createApplication(options = {}) {
     }
     catch (e) {
         await Promise.race([
-            Promise.allSettled([herdr.close(), mcp.close(), plugins.close()]),
+            Promise.allSettled([
+                herdr.close(),
+                mcp.close(),
+                decisionService.shutdown(config.pluginHooks.disposeTimeoutMs).then(() => plugins.close()),
+            ]),
             delay(TEARDOWN_STAGE_TIMEOUT_MS),
         ]);
         store.close();

package/dist/changelog/data.js

@@ -2,6 +2,42 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.3.0",
+            date: "2026-10-03",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "Decision Intelligence: an optional provider contract that lets a plugin answer small, closed decisions (pick an option, yes/no, a level) without a full model generation. Alisio works the same without a provider; installing a provider plugin does not activate it.",
+                        "`/decisions` (terminal and web) shows whether decisions are enabled, the active provider, its health and the session metrics. `/stats` gains a Decision Intelligence section once a decision has run.",
+                        "New settings: the `decisions` block (`enabled`, `provider`, `timeoutMs`, `minConfidence`, `telemetry`), plugin options in `pluginOverrides.<id>.options` and `pluginHooks.disposeTimeoutMs`.",
+                    ],
+                },
+                {
+                    title: "Improved",
+                    items: [
+                        "Plugins are shut down in parallel, each with its own time limit, so one slow plugin no longer delays the others.",
+                        "`alisio run` now shuts plugins down cleanly on SIGTERM and SIGHUP, not only on Ctrl+C.",
+                    ],
+                },
+            ],
+        },
+        {
+            version: "0.2.1",
+            date: "2026-10-02",
+            sections: [
+                {
+                    title: "Fixed",
+                    items: [
+                        'A run no longer stops with "reached its 600 s limit" while you read a plan or answer a question. The run time limit (`limits.timeoutMs`) now counts only active time: the time the agent waits for you (the plan review, a question, a tool approval) is not counted. A model or tool that really stalls still hits the limit. The same applies to the `goal.maxMinutes` cap of a session goal.',
+                        'A run that ended or was stopped during a plan review no longer leaves the next message failing with an "Uncertain tool outcome" error.',
+                        "In the web, a plan review or a question can wait up to 60 minutes for your answer (tool approvals still expire after 10 minutes).",
+                        'The Settings label of `limits.timeoutMs` said "Provider request timeout"; it now says it is the run time limit.',
+                    ],
+                },
+            ],
+        },
         {
             version: "0.2.0",
             date: "2026-10-02",

package/dist/commands/builtins.js

@@ -151,6 +151,12 @@ export const BUILTIN_COMMANDS = [
         surfaces: INTERACTIVE,
         execution: "surface",
     },
+    {
+        name: "decisions",
+        description: "Show Decision Intelligence status, provider health and session metrics",
+        surfaces: ALL,
+        execution: "core",
+    },
     {
         name: "exit",
         description: "Exit Alisio",

package/dist/commands/catalog.d.ts

@@ -4,10 +4,11 @@
  * The catalog reads its sources live from the host on each call, so plugin/template/skill
  * changes show up without rebuilding it.
  */
-import type { CommandDescriptor, ToolDefinition } from "@alisio/sdk";
+import { type CommandDescriptor, type ToolDefinition } from "@alisio/sdk";
 import type { PluginCatalogEntry } from "../application.ts";
 import type { SessionStore } from "../core/contracts.ts";
 import type { AgentRunner } from "../core/runner.ts";
+import { type DecisionMetrics, type DecisionService, type DecisionsConfig } from "../decisions/index.ts";
 import type { McpServerInfo } from "../mcp/connector.ts";
 import type { PromptTemplate } from "../resources/prompts.ts";
 import type { SkillCatalogEntry } from "../resources/skills.ts";
@@ -54,6 +55,12 @@ export interface CommandHost {
             active?: string;
             effort?: string;
         };
+        decisions?: Pick<DecisionsConfig, "timeoutMs" | "minConfidence" | "telemetry">;
+    };
+    /** Decision Intelligence (`/decisions`, and the `/stats` section). */
+    decisions?: {
+        service: Pick<DecisionService, "status">;
+        metrics: Pick<DecisionMetrics, "snapshot">;
     };
     updateSetting?(key: "agents.effort", value: unknown): Promise<string>;
     /** `/btw` side questions (tool-less, outside the conversation). */

package/dist/commands/catalog.js

@@ -1,4 +1,12 @@
+/**
+ * One catalog of slash commands for every surface (TUI, web, API): built-ins, plugin commands,
+ * prompt templates and skills, with the pure core handlers of `execution: "core"` commands.
+ * The catalog reads its sources live from the host on each call, so plugin/template/skill
+ * changes show up without rebuilding it.
+ */
+import { summarizeDecisionEvents, } from "@alisio/sdk";
 import { agentCatalogFromState, agentCommandDescriptors, resolveActiveAgent, } from "../agents/active.js";
+import { formatDecisionStatsSection, formatDecisionsReport, } from "../decisions/index.js";
 import { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_USAGE, } from "../sessions/side-questions.js";
 import { BUILTIN_COMMANDS } from "./builtins.js";
 export { BUILTIN_COMMANDS };
@@ -20,7 +28,59 @@ const firstPrompt = (host, id) => {
     const first = host.store.messages(id).find((m) => m.role === "user" && !m.summary);
     return first?.role === "user" ? first.text.replace(/\s+/g, " ").slice(0, 60) : "";
 };
+const EVENT_PAGE = 5000;
+const MAX_EVENT_PAGES = 20;
+/**
+ * The session's persisted `decision_*` events as `RunEvent`s (`createdAt` becomes the timestamp,
+ * so `lastFallback.at` is right), paged through the store. Empty without a paging store.
+ */
+function decisionEvents(host, sessionId) {
+    const out = [];
+    let after = 0;
+    for (let page = 0; page < MAX_EVENT_PAGES; page++) {
+        const result = host.store.eventsPage?.(sessionId, { after, limit: EVENT_PAGE });
+        if (!result?.items.length)
+            break;
+        for (const item of result.items) {
+            if (item.type !== "decision_completed" && item.type !== "decision_fallback")
+                continue;
+            out.push({
+                schemaVersion: 1,
+                runId: item.runId,
+                sessionId,
+                seq: out.length + 1,
+                type: item.type,
+                timestamp: new Date(item.createdAt ?? 0).toISOString(),
+                data: item.data,
+                eventId: item.eventId,
+            });
+        }
+        if (!result.hasMore)
+            break;
+        after = Number(result.items.at(-1)?.eventId);
+        if (!Number.isFinite(after))
+            break;
+    }
+    return out;
+}
 const HANDLERS = {
+    async decisions(_args, ctx, host) {
+        const decisions = host.decisions;
+        if (!decisions)
+            return { text: "Decision Intelligence is unavailable here", tone: "notice" };
+        const status = await decisions.service.status(ctx.signal);
+        const session = decisions.metrics.snapshot(ctx.sessionId);
+        const processView = decisions.metrics.snapshot();
+        return {
+            text: formatDecisionsReport({
+                status,
+                config: host.config?.decisions ?? { timeoutMs: 0, minConfidence: 0, telemetry: false },
+                session,
+                process: processView,
+            }),
+            data: { status, session, process: processView },
+        };
+    },
     async tools(_args, _ctx, host) {
         const policy = host.runner.policy;
         const rows = host.registry
@@ -113,6 +173,7 @@ const HANDLERS = {
             input: sum.input + (r.usage?.input ?? 0),
             output: sum.output + (r.usage?.output ?? 0),
         }), { input: 0, output: 0 });
+        const decisionSection = formatDecisionStatsSection(summarizeDecisionEvents(decisionEvents(host, ctx.sessionId)));
         return {
             text: [
                 "**Session statistics**",
@@ -122,6 +183,7 @@ const HANDLERS = {
                 `- Messages: ${host.store.messages(session.id).length}`,
                 `- Runs: ${runs.length}`,
                 `- Tokens: in ${tokens.input} · out ${tokens.output}`,
+                ...(decisionSection ? ["", decisionSection] : []),
             ].join("\n"),
             data: { session, runs: runs.length, tokens },
         };

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from "@alisio/sdk";
 import { z } from "zod";
 declare const serverSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     transport: z.ZodLiteral<"stdio">;
@@ -142,11 +143,20 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>>;
     pluginOverrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        enabled: z.ZodBoolean;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
     }, z.core.$strict>>>;
     pluginHooks: z.ZodDefault<z.ZodObject<{
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         sessionEndTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        disposeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    decisions: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        minConfidence: z.ZodDefault<z.ZodNumber>;
+        telemetry: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>;
     context: z.ZodDefault<z.ZodObject<{
         claudeMdFallback: z.ZodDefault<z.ZodBoolean>;
@@ -267,11 +277,20 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         enabled?: boolean | undefined;
     }>;
     pluginOverrides: Record<string, {
-        enabled: boolean;
+        enabled?: boolean | undefined;
+        options?: Record<string, JsonValue> | undefined;
     }>;
     pluginHooks: {
         timeoutMs: number;
         sessionEndTimeoutMs: number;
+        disposeTimeoutMs: number;
+    };
+    decisions: {
+        enabled: boolean;
+        provider: string | null;
+        timeoutMs: number;
+        minConfidence: number;
+        telemetry: boolean;
     };
     context: {
         claudeMdFallback: boolean;
@@ -461,11 +480,20 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         enabled?: boolean | undefined;
     }>;
     pluginOverrides: Record<string, {
-        enabled: boolean;
+        enabled?: boolean | undefined;
+        options?: Record<string, JsonValue> | undefined;
     }>;
     pluginHooks: {
         timeoutMs: number;
         sessionEndTimeoutMs: number;
+        disposeTimeoutMs: number;
+    };
+    decisions: {
+        enabled: boolean;
+        provider: string | null;
+        timeoutMs: number;
+        minConfidence: number;
+        telemetry: boolean;
     };
     context: {
         claudeMdFallback: boolean;
@@ -625,6 +653,12 @@ declare const SETTABLE_KEYS: {
     readonly "limits.firstTokenRetries": z.ZodDefault<z.ZodNumber>;
     readonly "limits.truncationRecoveries": z.ZodDefault<z.ZodNumber>;
     readonly "pluginHooks.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "pluginHooks.disposeTimeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "decisions.enabled": z.ZodDefault<z.ZodBoolean>;
+    readonly "decisions.provider": z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    readonly "decisions.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "decisions.minConfidence": z.ZodDefault<z.ZodNumber>;
+    readonly "decisions.telemetry": z.ZodDefault<z.ZodBoolean>;
     readonly "tui.paddingX": z.ZodDefault<z.ZodNumber>;
     readonly "tui.contentPaddingX": z.ZodDefault<z.ZodNumber>;
     readonly "tui.skillSlashCommands": z.ZodDefault<z.ZodBoolean>;

package/dist/config.js

@@ -2,6 +2,7 @@ import { chmod, mkdir, open, readFile, realpath, rename, unlink } from "node:fs/
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
+import { DEFAULT_DECISIONS_CONFIG } from "./decisions/service.js";
 import { exists, readJson } from "./runtime/fs.js";
 import { isPathSpec } from "./runtime/modules.js";
 const providerSchema = z
@@ -82,6 +83,35 @@ const serversSchema = (value) => z.record(z.string(), value).superRefine((server
 export const OCI_IMAGE_PATTERN = /^[a-zA-Z0-9][^\s@]*@sha256:[a-f0-9]{64}$/;
 /** Analysis keys only the user (global) layer decides; a project layer cannot set them. */
 const GLOBAL_ONLY_ANALYSIS = ["runtime", "oci", "retention"];
+/** Decision Intelligence keys only the user (global) layer decides: the provider and telemetry. */
+const GLOBAL_ONLY_DECISIONS = ["provider", "telemetry"];
+/** JSON values a plugin may receive as options (`pluginOverrides[id].options`). */
+const jsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+]));
+const PLUGIN_OPTION_KEY = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/;
+const PLUGIN_OPTIONS_MAX_BYTES = 8 * 1024;
+const pluginOptionsSchema = z
+    .record(z.string(), jsonValueSchema)
+    .superRefine((options, context) => {
+    for (const key of Object.keys(options))
+        if (!PLUGIN_OPTION_KEY.test(key))
+            context.addIssue({
+                code: "custom",
+                path: [key],
+                message: "Plugin option names start with a letter and use letters, digits, dot, underscore or dash",
+            });
+    if (Buffer.byteLength(JSON.stringify(options), "utf8") > PLUGIN_OPTIONS_MAX_BYTES)
+        context.addIssue({
+            code: "custom",
+            message: "Plugin options may not exceed 8 KB serialized",
+        });
+});
 const configObjectSchema = z
     .object({
     schemaVersion: z.literal(1).default(1),
@@ -114,15 +144,43 @@ const configObjectSchema = z
         .record(z.string(), z.object({ enabled: z.boolean().optional() }).passthrough())
         .default({}),
     /** Project-local enable/disable overrides for configured external plugins, keyed by plugin id. */
-    pluginOverrides: z.record(z.string(), z.object({ enabled: z.boolean() }).strict()).default({}),
+    pluginOverrides: z
+        .record(z.string(), z
+        .object({
+        enabled: z.boolean().optional(),
+        /** Global-only, read-only options handed to the plugin as `api.options` (8 KB). */
+        options: pluginOptionsSchema.optional(),
+    })
+        .strict())
+        .default({}),
     /** Host-enforced timeouts for plugin hooks. */
     pluginHooks: z
         .object({
         timeoutMs: z.number().int().min(100).max(120_000).default(15_000),
         sessionEndTimeoutMs: z.number().int().min(100).max(120_000).default(10_000),
+        /** Per-plugin limit for `dispose()` (and the active decision provider's `deactivate()`). */
+        disposeTimeoutMs: z.number().int().min(100).max(10_000).default(2000),
     })
         .strict()
-        .default(() => ({ timeoutMs: 15_000, sessionEndTimeoutMs: 10_000 })),
+        .default(() => ({ timeoutMs: 15_000, sessionEndTimeoutMs: 10_000, disposeTimeoutMs: 2000 })),
+    /**
+     * Decision Intelligence: the active provider is chosen here and only here. `provider` and
+     * `telemetry` are global-only (a repository cannot pick the engine or the telemetry policy).
+     */
+    decisions: z
+        .object({
+        enabled: z.boolean().default(true),
+        provider: z
+            .string()
+            .regex(/^[a-z0-9][a-z0-9.-]{0,63}$/)
+            .nullable()
+            .default(null),
+        timeoutMs: z.number().int().min(50).max(10_000).default(DEFAULT_DECISIONS_CONFIG.timeoutMs),
+        minConfidence: z.number().min(0).max(1).default(DEFAULT_DECISIONS_CONFIG.minConfidence),
+        telemetry: z.boolean().default(true),
+    })
+        .strict()
+        .default(() => ({ ...DEFAULT_DECISIONS_CONFIG })),
     context: z
         .object({
         /** Use CLAUDE.md where a directory has no AGENTS.md (off by default). */
@@ -550,8 +608,20 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
         const tasksRaw = object.tasks && typeof object.tasks === "object" && !Array.isArray(object.tasks)
             ? object.tasks
             : {};
+        const decisionsRaw = object.decisions && typeof object.decisions === "object" && !Array.isArray(object.decisions)
+            ? object.decisions
+            : {};
+        const overridesRaw = object.pluginOverrides &&
+            typeof object.pluginOverrides === "object" &&
+            !Array.isArray(object.pluginOverrides)
+            ? object.pluginOverrides
+            : {};
         const ignored = [
             ...GLOBAL_ONLY_ANALYSIS.filter((key) => key in analysisRaw).map((key) => `analysis.${key}`),
+            ...GLOBAL_ONLY_DECISIONS.filter((key) => key in decisionsRaw).map((key) => `decisions.${key}`),
+            ...Object.entries(overridesRaw)
+                .filter(([, entry]) => !!entry && typeof entry === "object" && !Array.isArray(entry) && "options" in entry)
+                .map(([id]) => `pluginOverrides.${id}.options`),
             ...("retentionDays" in tasksRaw ? ["tasks.retentionDays"] : []),
         ];
         return { config, keys: new Set(Object.keys(object)), sources, ignored, file };
@@ -592,10 +662,19 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
             }
             // Additive records: merge by key, the selected layer wins per key.
             if (key === "pluginOverrides") {
-                overlaid.pluginOverrides = {
-                    ...overlaid.pluginOverrides,
-                    ...selected.config.pluginOverrides,
-                };
+                // `options` is global-only: a repository must not inject options into a plugin that has
+                // system access, so the selected entry keeps its `enabled` but never its `options`.
+                const merged = { ...overlaid.pluginOverrides };
+                for (const [id, entry] of Object.entries(selected.config.pluginOverrides)) {
+                    const options = global.config.pluginOverrides[id]?.options;
+                    const { options: _ignored, ...rest } = entry;
+                    merged[id] = { ...global.config.pluginOverrides[id], ...rest };
+                    if (options)
+                        merged[id].options = options;
+                    else
+                        delete merged[id].options;
+                }
+                overlaid.pluginOverrides = merged;
                 continue;
             }
             if (key === "skillOverrides") {
@@ -622,6 +701,16 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
                 };
                 continue;
             }
+            if (key === "decisions") {
+                // `provider` and `telemetry` are global-only (a repository cannot pick the decision
+                // engine nor its telemetry policy); the rest follows the selected layer.
+                overlaid.decisions = {
+                    ...selected.config.decisions,
+                    provider: global.config.decisions.provider,
+                    telemetry: global.config.decisions.telemetry,
+                };
+                continue;
+            }
             if (key === "tasks") {
                 // `retentionDays` is global-only (one sweep deletes the data of every workspace).
                 overlaid.tasks = {
@@ -773,6 +862,7 @@ const SETTABLE_SECTIONS = {
     context: configObjectSchema.shape.context.removeDefault(),
     limits: configObjectSchema.shape.limits.removeDefault(),
     pluginHooks: configObjectSchema.shape.pluginHooks.removeDefault(),
+    decisions: configObjectSchema.shape.decisions.removeDefault(),
     tui: configObjectSchema.shape.tui.removeDefault(),
     websearch: configObjectSchema.shape.websearch.removeDefault(),
     agents: configObjectSchema.shape.agents.removeDefault(),
@@ -798,6 +888,12 @@ const SETTABLE_KEYS = {
     "limits.firstTokenRetries": SETTABLE_SECTIONS.limits.shape.firstTokenRetries,
     "limits.truncationRecoveries": SETTABLE_SECTIONS.limits.shape.truncationRecoveries,
     "pluginHooks.timeoutMs": SETTABLE_SECTIONS.pluginHooks.shape.timeoutMs,
+    "pluginHooks.disposeTimeoutMs": SETTABLE_SECTIONS.pluginHooks.shape.disposeTimeoutMs,
+    "decisions.enabled": SETTABLE_SECTIONS.decisions.shape.enabled,
+    "decisions.provider": SETTABLE_SECTIONS.decisions.shape.provider,
+    "decisions.timeoutMs": SETTABLE_SECTIONS.decisions.shape.timeoutMs,
+    "decisions.minConfidence": SETTABLE_SECTIONS.decisions.shape.minConfidence,
+    "decisions.telemetry": SETTABLE_SECTIONS.decisions.shape.telemetry,
     "tui.paddingX": SETTABLE_SECTIONS.tui.shape.paddingX,
     "tui.contentPaddingX": SETTABLE_SECTIONS.tui.shape.contentPaddingX,
     "tui.skillSlashCommands": SETTABLE_SECTIONS.tui.shape.skillSlashCommands,
@@ -945,7 +1041,13 @@ export async function setProjectPluginEnabled(input) {
             !Array.isArray(raw.pluginOverrides)
             ? raw.pluginOverrides
             : {};
-        raw.pluginOverrides = { ...current, [input.id]: { enabled: input.enabled } };
+        const entry = current[input.id] &&
+            typeof current[input.id] === "object" &&
+            !Array.isArray(current[input.id])
+            ? current[input.id]
+            : {};
+        // Keep the other fields of the entry (`options`): toggling a plugin must not erase them.
+        raw.pluginOverrides = { ...current, [input.id]: { ...entry, enabled: input.enabled } };
     }
     raw.schemaVersion ??= 1;
     await mkdir(dirname(file), { recursive: true, mode: 0o700 });