@alisio/core 0.4.3 → 0.4.5

package/dist/application.js

@@ -321,6 +321,22 @@ export async function createApplication(options = {}) {
                 }
             }
         }
+        /**
+         * Plugin resources (`api.resources.agents`) register during activation, but the built-in
+         * subagents plugin discovers agent files in its own setup, which runs BEFORE external plugins
+         * (config, command line, plugin directories) are activated. Re-run its discovery once every
+         * plugin has registered, so the first `/api/agents` (web selector and Agents page, TUI cycle)
+         * already lists the plugin primary agents instead of waiting for a manual `/agents reload`.
+         */
+        const rediscoverAgents = plugins.commands.get("agents");
+        if (rediscoverAgents) {
+            try {
+                await rediscoverAgents("reload");
+            }
+            catch {
+                /* keeps the built-ins: agent discovery is best-effort */
+            }
+        }
         // Every plugin has registered its providers: start the configured one in the background
         // (`activate` is bounded, never fatal and never awaited here).
         decisionService.syncActive();

package/dist/changelog/data.js

@@ -2,6 +2,32 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.4.5",
+            date: "2026-10-07",
+            sections: [
+                {
+                    title: "Fixed",
+                    items: [
+                        "The chat agent selector, the Agents page and Shift+Tab list a plugin's `primary` agents on the first open, instead of only the built-ins until you visited the Agents window and came back.",
+                        'Choosing "Full access" applies to the session that is already running: it stops asking for approvals from the next tool call, not only on the following turn.',
+                    ],
+                },
+            ],
+        },
+        {
+            version: "0.4.4",
+            date: "2026-10-04",
+            sections: [
+                {
+                    title: "Fixed",
+                    items: [
+                        'Automatic compaction now also triggers at 85 % of `limits.maxContextChars`, so a long conversation with a large-window model is compacted before the run fails instead of stopping with "Context budget exceeded" until you ran `/compact` yourself. A last-chance compaction runs once before a run fails, and the final error now says whether compaction ran, was skipped, failed or is disabled.',
+                        'The web shows "Compacting context…" during a manual `/compact` or an automatic one, and blocks sending (keeping your draft) until it finishes.',
+                    ],
+                },
+            ],
+        },
         {
             version: "0.4.3",
             date: "2026-10-04",

package/dist/core/contracts.d.ts

@@ -302,7 +302,7 @@ export interface HookFailure {
 export interface RunnerExtensions {
     beforeCompact(input: {
         sessionId: string;
-        reason: "manual" | "auto";
+        reason: "manual" | "auto" | "budget";
         messages: readonly Message[];
         focus?: string;
     }): Promise<{
@@ -316,7 +316,7 @@ export interface RunnerExtensions {
     }>;
     afterCompact(input: {
         sessionId: string;
-        reason: "manual" | "auto";
+        reason: "manual" | "auto" | "budget";
         messages: readonly Message[];
         focus?: string;
         model: string;

package/dist/core/runner.d.ts

@@ -189,6 +189,8 @@ export declare class AgentRunner {
     private inbox;
     /** Last provider-reported context size per session and the history length it covered. */
     private reported;
+    /** Conversation size in characters right after the last automatic compaction, per session. */
+    private compactedChars;
     /** Where human waits are opened; the clocks of the active runs listen to it. */
     readonly humanWaits: HumanWaits;
     constructor(options: RunnerOptions);

package/dist/core/runner.js

@@ -41,6 +41,13 @@ const MAX_INJECT_CHARS = 24_000;
  * fails with an actionable error instead of silently losing the whole history.
  */
 const MIN_MESSAGE_BUDGET_FLOOR = 4_000;
+/**
+ * Fraction of the character limit the conversation must grow beyond its post-compaction size
+ * before the CHARACTER-based auto-compaction trigger may fire again. When the kept tail alone
+ * sits at or above the trigger, summarizing gains nothing, so without this margin every turn
+ * would pay for a summarizer call. The hard-limit last-chance compaction ignores it.
+ */
+const RECOMPACT_GROWTH_MARGIN = 0.1;
 const allowed = (policy, effect) => effect === "read" ||
     effect === "internal" ||
     ((effect === "write" || effect === "process" || effect === "external") && !!policy[effect]);
@@ -62,6 +69,8 @@ export class AgentRunner {
     inbox = new Map();
     /** Last provider-reported context size per session and the history length it covered. */
     reported = new Map();
+    /** Conversation size in characters right after the last automatic compaction, per session. */
+    compactedChars = new Map();
     /** Where human waits are opened; the clocks of the active runs listen to it. */
     humanWaits;
     constructor(options) {
@@ -907,11 +916,24 @@ export class AgentRunner {
                 // unknown (or absurdly large, see MAX_TRUSTED_WINDOW) window falls back to the char
                 // estimate (`chars / 4 >= maxContextChars / 4`). `maxContextChars` below stays as the
                 // post-compaction hard limit.
+                // The character budget is an independent trigger: `maxContextChars` is a hard limit for
+                // every model, so a large-window model must compact at `limit * threshold` characters
+                // too instead of reaching the hard check with compaction never having run.
+                const threshold = compaction.threshold ?? 0.85;
+                // What automatic compaction did this turn (at most ONE attempt per turn).
+                let attempt = "none";
+                let attemptError = "";
                 if (compaction.auto !== false &&
-                    shouldCompactContext(used(), chars(), o.contextWindow?.(model), limit, compaction.threshold ?? 0.85)) {
-                    await this.compactLocked(sessionId, emit, model, combined, "auto");
+                    (shouldCompactContext(used(), chars(), o.contextWindow?.(model), limit, threshold) ||
+                        (charsConversation() >= limit * threshold &&
+                            charsConversation() >=
+                                (this.compactedChars.get(sessionId) ?? 0) + limit * RECOMPACT_GROWTH_MARGIN))) {
+                    const result = await this.compactLocked(sessionId, emit, model, combined, "auto");
+                    attempt = result ? "ran" : "skipped";
                     instructions = await withPersona();
                     messages = o.store.messages(sessionId);
+                    if (result)
+                        this.compactedChars.set(sessionId, charsConversation());
                 }
                 // A compaction that still leaves the session over the hard limit is reduced in place
                 // instead of failing outright: retained content is clipped against a TOTAL character
@@ -925,15 +947,45 @@ export class AgentRunner {
                 // prompts. Only if even the reduction floor cannot fit (instructions alone crowd out the
                 // limit) the run fails with an actionable error.
                 if (charsConversation() > limit) {
-                    const targetChars = Math.max(MIN_MESSAGE_BUDGET_FLOOR, limit - instructions.length);
-                    const reduction = reduceMessagesToBudget(messages, targetChars);
-                    if (reduction.truncated > 0) {
-                        o.store.overwrite(sessionId, reduction.messages);
-                        messages = reduction.messages;
-                        emit("context_reduced", { messages: reduction.truncated });
+                    const reduceInPlace = () => {
+                        const targetChars = Math.max(MIN_MESSAGE_BUDGET_FLOOR, limit - instructions.length);
+                        const reduction = reduceMessagesToBudget(messages, targetChars);
+                        if (reduction.truncated > 0) {
+                            o.store.overwrite(sessionId, reduction.messages);
+                            messages = reduction.messages;
+                            emit("context_reduced", { messages: reduction.truncated });
+                        }
+                    };
+                    reduceInPlace();
+                    // Last chance: clipping alone was not enough and no compaction was attempted this
+                    // turn, so summarize history once (reason "budget") and reduce again before failing.
+                    if (charsConversation() > limit && compaction.auto !== false && attempt === "none") {
+                        try {
+                            const result = await this.compactLocked(sessionId, emit, model, combined, "budget");
+                            attempt = result ? "ran" : "skipped";
+                        }
+                        catch (error) {
+                            combined.throwIfAborted();
+                            attempt = "failed";
+                            attemptError = error instanceof Error ? error.message : String(error);
+                        }
+                        instructions = await withPersona();
+                        messages = o.store.messages(sessionId);
+                        if (charsConversation() > limit)
+                            reduceInPlace();
+                        if (attempt === "ran")
+                            this.compactedChars.set(sessionId, charsConversation());
+                    }
+                    if (charsConversation() > limit) {
+                        const what = compaction.auto === false
+                            ? "Automatic compaction is disabled (compaction.auto is false)."
+                            : attempt === "ran"
+                                ? "Automatic compaction ran but could not reduce it enough."
+                                : attempt === "failed"
+                                    ? `Automatic compaction failed (${attemptError}).`
+                                    : "Automatic compaction was skipped because there is no safe boundary to summarize (the conversation is a single long turn or too short).";
+                        throw new Error(`Context budget exceeded (approximately ${charsConversation()} characters of conversation; limit ${limit}). ${what} Run /compact, trim large tool outputs, start a new session, or disable unneeded MCP servers with /plugins.`);
                     }
-                    if (charsConversation() > limit)
-                        throw new Error(`Context budget exceeded and compaction could not reduce it (approximately ${charsConversation()} characters of conversation; limit ${limit}). Run /compact, trim large tool outputs, start a new session, or disable unneeded MCP servers with /plugins.`);
                 }
                 let completion;
                 let truncated = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/core",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "Embeddable provider-agnostic Alisio agent core: tool loop, context compaction, local tools, MCP, plugin host and SQLite session store. Runs on Node >=22.16 and Bun.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "node": ">=22.16"
   },
   "dependencies": {
-    "@alisio/sdk": "0.4.3",
+    "@alisio/sdk": "0.4.5",
     "@mixmark-io/domino": "2.2.0",
     "@modelcontextprotocol/client": "2.1.0",
     "ajv": "8.20.0",