@alisio/core 0.8.0 → 0.10.0

package/dist/analysis/data/engine-client.d.ts

@@ -7,6 +7,8 @@ export declare class DataError extends Error {
 }
 /** The engine script on disk (`<root>/analysis/engine/data-engine-<hash>.mjs`). */
 export declare function ensureEngineScript(root: string): Promise<string>;
+/** The whitelisted environment of an engine child, from `parent`. */
+export declare function engineChildEnv(parent?: NodeJS.ProcessEnv): Record<string, string>;
 export interface DataEngineOptions {
     /** State folder (`<root>/analysis/engine/…` holds the script). */
     root: string;

package/dist/analysis/data/engine-client.js

@@ -57,7 +57,17 @@ const ENV_KEYS = [
     "SYSTEMROOT",
     "WINDIR",
     "LANG",
+    // Set by hosts that run on the Electron binary (the desktop app): without it the worker, which is
+    // spawned from `process.execPath`, would start another GUI instance instead of plain Node.
+    "ELECTRON_RUN_AS_NODE",
 ];
+/** The whitelisted environment of an engine child, from `parent`. */
+export function engineChildEnv(parent = process.env) {
+    return {
+        ...Object.fromEntries(ENV_KEYS.flatMap((k) => (parent[k] ? [[k, parent[k]]] : []))),
+        BUN_BE_BUN: "1",
+    };
+}
 /** One engine child process and its pending request. */
 class EngineProcess {
     child;
@@ -74,10 +84,7 @@ class EngineProcess {
                 : [`--max-old-space-size=${memoryMb}`, "--disable-warning=ExperimentalWarning"]),
             script,
         ], {
-            env: {
-                ...Object.fromEntries(ENV_KEYS.flatMap((k) => (process.env[k] ? [[k, process.env[k]]] : []))),
-                BUN_BE_BUN: "1",
-            },
+            env: engineChildEnv(),
             stdio: ["pipe", "pipe", "pipe"],
             windowsHide: true,
         });

package/dist/application.d.ts

@@ -1,4 +1,4 @@
-import type { AvailableProviderModel, ModelInfo, ModelProvider, Plugin, PluginCategory, ProviderConfigurationValue, ResolvedProviderModel, RunEvent } from "@alisio/sdk";
+import type { AvailableProviderModel, ContextReport, ModelInfo, ModelProvider, Plugin, PluginCategory, ProviderConfigurationValue, ResolvedProviderModel, RunEvent } from "@alisio/sdk";
 import { AgentDefinitionService } from "./agents/service.ts";
 import { CapabilityGrants } from "./analysis/capabilities.ts";
 import { DatasetService } from "./analysis/data/datasets.ts";
@@ -148,6 +148,11 @@ export interface PluginCatalogEntry {
     enabled: boolean;
     manageable: boolean;
     diagnostic?: string;
+    /**
+     * The npm package name an external plugin was loaded from. Never a path: the catalog stays
+     * path-safe, so file and directory plugins carry no `spec`.
+     */
+    spec?: string;
 }
 export interface ConfiguredProviderCatalog {
     profile: string;
@@ -350,6 +355,11 @@ export declare function createApplication(options?: AppOptions): Promise<{
         basis: "window" | "unknown";
         compactionAt: number;
     };
+    /**
+     * The Context Governor's explanation of a session (spec 012 phase 5): the one `ContextReport`
+     * that `/context`, the web panel and the HTTP route render. Read only.
+     */
+    contextReport: (sessionId: string) => ContextReport;
     loadModels: (signal: AbortSignal) => Promise<ModelInfo[]>;
     /** Creates a provider for validation/model discovery without changing the active provider. */
     probeProvider(id: string, profile: Record<string, import("@alisio/sdk").ProviderConfigurationValue>, credentials: Record<string, string>, signal: AbortSignal): Promise<ModelInfo[]>;

package/dist/application.js

@@ -15,6 +15,9 @@ import { TaskJanitor } from "./background/janitor.js";
 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 { CONTEXT_POLICY_VERSION } from "./context/elide.js";
+import { buildContextReport } from "./context/report.js";
+import { createInvariantSources } from "./context/sources.js";
 import { completeText } from "./core/compaction.js";
 import { HumanWaits } from "./core/human-wait.js";
 import { DEFAULT_MAX_OUTPUT_TOKENS } from "./core/output-limit.js";
@@ -31,6 +34,7 @@ import { GoalService } from "./goal/service.js";
 import { GoalStore } from "./goal/store.js";
 import { HerdrBridge } from "./integrations/herdr.js";
 import { McpConnector } from "./mcp/connector.js";
+import { currentPlan } from "./plan/state.js";
 import { discoverPlugins, PluginHost } from "./plugins/host.js";
 import { ProofVerifierRegistry } from "./proof/plugin-verifiers.js";
 import { ProofRecorder } from "./proof/recorder.js";
@@ -328,6 +332,7 @@ export async function createApplication(options = {}) {
                         status: enabled ? "active" : "inactive",
                         enabled,
                         manageable: entry.manageable,
+                        ...(isPathSpec(entry.spec) ? {} : { spec: entry.spec }),
                     });
                     runtimePluginEnabled.set(candidate.plugin.id, enabled);
                 }
@@ -345,6 +350,7 @@ export async function createApplication(options = {}) {
                             enabled: true,
                             manageable: entry.manageable,
                             diagnostic: "Activation failed; registrations were rolled back",
+                            ...(isPathSpec(entry.spec) ? {} : { spec: entry.spec }),
                         });
                         continue;
                     }
@@ -360,6 +366,7 @@ export async function createApplication(options = {}) {
                         enabled: true,
                         manageable: false,
                         diagnostic: "Load failed; no path or credential details are shown here",
+                        ...(isPathSpec(entry.spec) ? {} : { spec: entry.spec }),
                     });
                 }
             }
@@ -982,6 +989,25 @@ export async function createApplication(options = {}) {
             policy: runtimePolicy,
             ...config.limits,
             compaction: config.compaction,
+            contextGovernor: {
+                mode: config.context.governor,
+                ...config.context.elide,
+                policyVersion: config.context.policyVersion ?? CONTEXT_POLICY_VERSION,
+                invariantMaxChars: config.context.invariants.maxChars,
+            },
+            invariantSources: createInvariantSources({
+                goal: (sessionId) => goals.get(sessionId),
+                plan: (sessionId) => currentPlan(store, sessionId),
+                criteria: (sessionId) => new ProofStore(store.db).criteria(sessionId),
+                ...(analysisEnabled
+                    ? {
+                        capabilities: {
+                            granted: (capability, sessionId) => capabilityGrants.granted(capability, sessionId),
+                        },
+                    }
+                    : {}),
+                externalDirectories: () => pathAccess.approvedDirectories().length,
+            }),
             extensions: plugins,
             contextWindow,
             modelOutputLimit: declaredOutputLimit,
@@ -1586,6 +1612,26 @@ export async function createApplication(options = {}) {
             contextWindow,
             /** Effective context budget + compaction point shared by the runner and the TUI bar. */
             contextBudget: (model) => runner.contextBudget(model),
+            /**
+             * The Context Governor's explanation of a session (spec 012 phase 5): the one `ContextReport`
+             * that `/context`, the web panel and the HTTP route render. Read only.
+             */
+            contextReport: (sessionId) => {
+                const inputs = runner.contextInputs(sessionId);
+                return buildContextReport({
+                    sessionId,
+                    governor: inputs?.governor ?? {
+                        mode: "off",
+                        minAgeTurns: 0,
+                        epochMessages: 0,
+                        policyVersion: CONTEXT_POLICY_VERSION,
+                    },
+                    messages: inputs?.messages ?? [],
+                    ...(inputs ? { invariants: inputs.invariants } : {}),
+                    ...(inputs?.ledger ? { ledger: inputs.ledger } : {}),
+                    ...(inputs?.governance ? { governance: inputs.governance } : {}),
+                });
+            },
             loadModels,
             /** Creates a provider for validation/model discovery without changing the active provider. */
             async probeProvider(id, profile, credentials, signal) {

package/dist/changelog/data.js

@@ -2,6 +2,48 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.10.0",
+            date: "2026-11-07",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "Settings → Plugins → **Plugin catalog**: browse the published plugins with search, category and tag filters and pages of 10, and install one with a click. The catalog is cached for 24 hours and only downloaded again when it changed; **Check for updates** checks now.",
+                        "**Install from file**: install a private plugin from a `.tgz` made with `npm pack` or `pnpm pack`. The file is validated first (an Alisio plugin, its SDK range, install scripts), the install shows its progress step by step, and temporary files are removed. The package is kept under `~/.config/alisio/plugins/local-packages`, so the original file can be moved or deleted.",
+                        "**Installed plugins**: uninstall a plugin, see when a catalog plugin has a newer version, and update one or all of them. Installing a plugin that is already there updates it in place.",
+                    ],
+                },
+                {
+                    title: "Improved",
+                    items: [
+                        "When `npm` is missing, installing a plugin says so clearly instead of failing with a spawn error. Alisio Desktop bundles its own `npm`, so plugins install without Node.js on the system.",
+                    ],
+                },
+            ],
+        },
+        {
+            version: "0.9.0",
+            date: "2026-11-07",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "Alisio Desktop: install Alisio like any other program on Windows, macOS or Linux, with no terminal and no Node.js. Download it from the documentation home page or the `desktop-v0.9.0` GitHub release. The desktop app shares its sessions and settings with the CLI.",
+                        "Context Governor (experimental, off by default): `context.governor` (`off`, `shadow`, `on`). In `on` mode, tool results made redundant by a later one (superseded reads, repeated identical `bg_output` polls, duplicate searches) are replaced by a one-line stub in the request, and your instructions, the live goal, the approved plan, Proof criteria and session grants survive compaction verbatim. `shadow` only measures and sends exactly what `off` sends.",
+                        "`/context`, a **Context** tab in the web UI and `GET /api/sessions/:sid/context/report`: what the next request carries and what the governor elides, with counts and token estimates only.",
+                        "`/stats` shows a Context Governor section, and the web trajectory shows each governed request.",
+                        "Reliability Lab: the `long-context-stress` suite, and runs record the provider's cached input tokens (`cachedInputTokens`), with a cached-input ratio in reports and `eval compare`.",
+                    ],
+                },
+                {
+                    title: "Improved",
+                    items: [
+                        "Alisio now presents itself as an assistant for everyday work (`alisio --help`, the web UI About text and the documentation); programming remains fully supported as an advanced use.",
+                    ],
+                },
+            ],
+        },
         {
             version: "0.8.0",
             date: "2026-10-14",

package/dist/commands/builtins.js

@@ -158,6 +158,12 @@ export const BUILTIN_COMMANDS = [
         surfaces: INTERACTIVE,
         execution: "surface",
     },
+    {
+        name: "context",
+        description: "Show what the next request carries and what the Context Governor elides",
+        surfaces: ALL,
+        execution: "core",
+    },
     {
         name: "decisions",
         description: "Show Decision Intelligence status, provider health and session metrics",

package/dist/commands/catalog.d.ts

@@ -4,7 +4,7 @@
  * 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, type ToolDefinition } from "@alisio/sdk";
+import { type CommandDescriptor, type ContextReport, 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";
@@ -26,7 +26,9 @@ type PluginCommandHandler = (args: string, context?: {
 export interface CommandHost {
     workspace: string;
     store: SessionStore;
-    runner: Pick<AgentRunner, "policy" | "approvals" | "compact" | "setModel">;
+    runner: Pick<AgentRunner, "policy" | "approvals" | "compact" | "setModel"> & Partial<Pick<AgentRunner, "governance" | "contextUsage">>;
+    /** The Context Governor's report of a session (`/context`); `createApplication` provides it. */
+    contextReport?(sessionId: string): ContextReport;
     registry: {
         list(): ToolDefinition[];
     };

package/dist/commands/catalog.js

@@ -6,6 +6,8 @@
  */
 import { summarizeDecisionEvents, } from "@alisio/sdk";
 import { agentCatalogFromState, agentCommandDescriptors, resolveActiveAgent, } from "../agents/active.js";
+import { formatContextGovernorStatsSection, formatContextReport } from "../context/format.js";
+import { governedEventData } from "../context/governance.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";
@@ -174,6 +176,12 @@ const HANDLERS = {
             output: sum.output + (r.usage?.output ?? 0),
         }), { input: 0, output: 0 });
         const decisionSection = formatDecisionStatsSection(summarizeDecisionEvents(decisionEvents(host, ctx.sessionId)));
+        const governance = host.runner?.governance?.(session.id);
+        const usage = host.runner?.contextUsage?.(session.id);
+        const governorSection = formatContextGovernorStatsSection({
+            ...(governance ? { governance } : {}),
+            ...(usage ? { usage } : {}),
+        });
         return {
             text: [
                 "**Session statistics**",
@@ -184,10 +192,24 @@ const HANDLERS = {
                 `- Runs: ${runs.length}`,
                 `- Tokens: in ${tokens.input} · out ${tokens.output}`,
                 ...(decisionSection ? ["", decisionSection] : []),
+                ...(governorSection ? ["", governorSection] : []),
             ].join("\n"),
-            data: { session, runs: runs.length, tokens },
+            data: {
+                session,
+                runs: runs.length,
+                tokens,
+                ...(governorSection
+                    ? { contextGovernor: governance ? governedEventData(governance, usage) : { usage } }
+                    : {}),
+            },
         };
     },
+    async context(_args, ctx, host) {
+        if (!host.contextReport)
+            return { text: "The context report is not available in this host.", tone: "notice" };
+        const report = host.contextReport(ctx.sessionId);
+        return { text: formatContextReport(report), data: report };
+    },
     async skills(_args, _ctx, host) {
         const skills = host.skillCatalog?.() ?? [];
         if (!skills.length)

package/dist/config.d.ts

@@ -161,6 +161,19 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     context: z.ZodDefault<z.ZodObject<{
         claudeMdFallback: z.ZodDefault<z.ZodBoolean>;
         maxBytes: z.ZodDefault<z.ZodNumber>;
+        governor: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            on: "on";
+            shadow: "shadow";
+        }>>;
+        policyVersion: z.ZodOptional<z.ZodNumber>;
+        elide: z.ZodDefault<z.ZodObject<{
+            minAgeTurns: z.ZodDefault<z.ZodNumber>;
+            epochMessages: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        invariants: z.ZodDefault<z.ZodObject<{
+            maxChars: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     compaction: z.ZodDefault<z.ZodObject<{
         auto: z.ZodDefault<z.ZodBoolean>;
@@ -351,6 +364,15 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     context: {
         claudeMdFallback: boolean;
         maxBytes: number;
+        governor: "off" | "on" | "shadow";
+        policyVersion?: number | undefined;
+        elide: {
+            minAgeTurns: number;
+            epochMessages: number;
+        };
+        invariants: {
+            maxChars: number;
+        };
     };
     compaction: {
         auto: boolean;
@@ -600,6 +622,15 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     context: {
         claudeMdFallback: boolean;
         maxBytes: number;
+        governor: "off" | "on" | "shadow";
+        policyVersion?: number | undefined;
+        elide: {
+            minAgeTurns: number;
+            epochMessages: number;
+        };
+        invariants: {
+            maxChars: number;
+        };
     };
     compaction: {
         auto: boolean;

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 { CONTEXT_POLICY_VERSION } from "./context/elide.js";
 import { DEFAULT_DECISIONS_CONFIG } from "./decisions/service.js";
 import { DEFAULT_FORGE_LIMITS, MAX_FORGE_LIMITS } from "./forge/limits.js";
 import { exists, readJson } from "./runtime/fs.js";
@@ -230,9 +231,38 @@ const configObjectSchema = z
             .min(1024)
             .max(1_048_576)
             .default(32 * 1024),
+        /**
+         * Context Governor (spec 012): `off` changes nothing, `shadow` computes what it would elide
+         * without changing what is sent, `on` sends the projected history.
+         */
+        governor: z.enum(["off", "shadow", "on"]).default("off"),
+        /** Optional pin of the elision rules; unset follows this build's current version. */
+        policyVersion: z.number().int().min(1).max(CONTEXT_POLICY_VERSION).optional(),
+        elide: z
+            .object({
+            /** Assistant messages a redundant result must be older than before it is replaced. */
+            minAgeTurns: z.number().int().min(1).max(20).default(2),
+            /** Projection grows in steps of this many messages (cache-friendly); 0 is eager. */
+            epochMessages: z.number().int().min(0).max(1000).default(32),
+        })
+            .strict()
+            .default(() => ({ minAgeTurns: 2, epochMessages: 32 })),
+        invariants: z
+            .object({
+            /** Size cap of the `<invariants>` block sent after a compaction (`on` mode only). */
+            maxChars: z.number().int().min(1000).max(20_000).default(4000),
+        })
+            .strict()
+            .default(() => ({ maxChars: 4000 })),
     })
         .strict()
-        .default(() => ({ claudeMdFallback: false, maxBytes: 32 * 1024 })),
+        .default(() => ({
+        claudeMdFallback: false,
+        maxBytes: 32 * 1024,
+        governor: "off",
+        elide: { minAgeTurns: 2, epochMessages: 32 },
+        invariants: { maxChars: 4000 },
+    })),
     compaction: z
         .object({
         auto: z.boolean().default(true),

package/dist/context/elide.d.ts

@@ -0,0 +1,50 @@
+import type { Message } from "@alisio/sdk";
+/**
+ * Deterministic elision by substitution (spec 012 phase 2). Pure functions over `Message[]`: they
+ * never touch the persisted transcript, only compute what a request MAY send instead.
+ */
+/** Version of the elision rules. Bump it whenever a rule or a stub format changes. */
+export declare const CONTEXT_POLICY_VERSION = 1;
+export type ElisionReason = "superseded_read" | "stale_bg_output" | "duplicate_search";
+export interface Elision {
+    /** Index of the elided tool message in the projected history. */
+    index: number;
+    callId: string;
+    /** Inventory id of the tool_result segment (same as `ContextSegment.id`). */
+    segmentId: string;
+    reason: ElisionReason;
+    /** Call id of the EARLIEST later result that justifies the elision (stable under append). */
+    witnessCallId: string;
+    /** Token ESTIMATE saved (`estimateTokens` of the original text minus that of the stub). */
+    tokensSaved: number;
+}
+export interface Projection {
+    /** The input array itself when nothing is elided, else a copy with only elided entries replaced. */
+    messages: Message[];
+    elisions: Elision[];
+    /** Estimate of the model-visible text of the history before and after the projection. */
+    tokensBefore: number;
+    tokensAfter: number;
+    /** Messages `[0, boundary)` are eligible; the rest is sent as is until the next epoch. */
+    boundary: number;
+}
+/**
+ * Which tool results a later result makes redundant, regardless of age. `witness` is the index of
+ * the EARLIEST later result that proves it, so it never changes when messages are appended. Every
+ * rule is existential ("some later result exists"), which is what makes the set grow monotonically.
+ * Error results are neither candidates nor witnesses.
+ */
+export declare function elisionCandidates(messages: Message[]): Map<number, {
+    reason: ElisionReason;
+    witness: number;
+}>;
+/**
+ * Projects the history a request would carry: tool results that a later result made redundant are
+ * replaced by a one-line stub once they are `minAgeTurns` assistant messages old (counted inside the
+ * eligible prefix). With `epochMessages` E > 0 only the prefix `floor(n / E) * E` is eligible, so the
+ * projected history grows by appending between epochs and a provider prompt cache stays valid.
+ */
+export declare function projectContext(messages: Message[], o: {
+    minAgeTurns: number;
+    epochMessages: number;
+}): Projection;