@alisio/core 0.2.1 → 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

@@ -20,6 +20,7 @@ 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";
@@ -122,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
@@ -131,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 = {
@@ -279,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,
@@ -300,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,
@@ -787,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),
@@ -916,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. */
@@ -1120,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;
@@ -1374,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()),
                             ]);
                         })());
                     }
@@ -1387,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,27 @@
 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",

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 });

package/dist/core/contracts.d.ts

@@ -1,4 +1,4 @@
-import type { AnalysisCapability, ArtifactPublisher, ArtifactPublishInput, ArtifactRef, CompactionCheckpoint, InstallPreview, Message, ToolCall, ToolResult } from "@alisio/sdk";
+import type { AnalysisCapability, ArtifactPublisher, ArtifactPublishInput, ArtifactRef, CompactionCheckpoint, InstallPreview, Message, RunEventDataMap, ToolCall, ToolDecisions, ToolResult } from "@alisio/sdk";
 export interface Session {
     id: string;
     workspace: string;
@@ -275,6 +275,15 @@ export type ArtifactPublisherFactory = (call: {
     runId: string;
     callId: string;
 }, announce: (published: PublishedArtifactInfo) => void) => CoreArtifactPublisher | undefined;
+/**
+ * Creates the `ToolContext.decisions` of one tool call; `announce` emits the decision event of
+ * the run (persisted and fanned out like any other). `undefined` leaves the context without it.
+ */
+export type DecisionsFactory = (call: {
+    sessionId: string;
+    runId: string;
+    callId: string;
+}, announce: <K extends "decision_completed" | "decision_fallback">(type: K, data: RunEventDataMap[K]) => void) => ToolDecisions | undefined;
 /** Optional interactive approval for write/process/external tools not pre-allowed by the Policy. */
 export type ApprovalHandler = (request: ApprovalRequest) => Promise<ApprovalDecision>;
 export interface HookFailure {

package/dist/core/runner.d.ts

@@ -1,6 +1,6 @@
 import { type Attachment, type DatasetRef, type Message, type ModelProvider, type RunEvent, type ToolDefinition, type ToolResult } from "@alisio/sdk";
 import type { PathAccess } from "../runtime/access.ts";
-import type { ApprovalHandler, ArtifactPublisherFactory, CapabilityGate, ContextSource, Policy, RunnerExtensions, SessionStore } from "./contracts.ts";
+import type { ApprovalHandler, ArtifactPublisherFactory, CapabilityGate, ContextSource, DecisionsFactory, Policy, RunnerExtensions, SessionStore } from "./contracts.ts";
 import { HumanWaits } from "./human-wait.ts";
 import type { ToolRegistry } from "./registry.ts";
 export interface CompactionSettings {
@@ -81,6 +81,8 @@ export interface RunnerOptions {
     capabilities?: CapabilityGate;
     /** Artifact publisher of each tool call (`ToolContext.artifacts`). */
     artifacts?: ArtifactPublisherFactory;
+    /** Decision Intelligence bound to each tool call (`ToolContext.decisions`). */
+    decisions?: DecisionsFactory;
     /**
      * Provider-native tool definitions (for example a hosted `web_search` tool) appended to every
      * request's `tools` alongside the registry's function tools. Opt-in, set once for the whole

package/dist/core/runner.js

@@ -529,6 +529,7 @@ export class AgentRunner {
                 callId: call.id,
                 ...(published.executionId ? { executionId: published.executionId } : {}),
             }));
+            const decisions = o.decisions?.({ sessionId, runId, callId: call.id }, (type, data) => emit(type, data));
             /**
              * `analysis.install`: always asks, `once` only, and no flag or earlier grant covers it. Where
              * nobody can be asked (headless, no approval handler) the answer is `deny`.
@@ -590,6 +591,7 @@ export class AgentRunner {
                 runId,
                 callId: call.id,
                 ...(publisher ? { artifacts: publisher } : {}),
+                ...(decisions ? { decisions } : {}),
                 approveInstall,
                 emit: (data) => emit("tool_progress", { id: call.id, data }),
                 // Only the built-in plan tool reports its durable events (never a plugin tool).