@alisio/core 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/application.d.ts

@@ -1,4 +1,5 @@
 import type { AvailableProviderModel, ModelInfo, ModelProvider, Plugin, PluginCategory, ProviderConfigurationValue, ResolvedProviderModel, RunEvent } from "@alisio/sdk";
+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";
@@ -163,6 +164,18 @@ export declare function createApplication(options?: AppOptions): Promise<{
     revokeGlobalMcpConsent(): Promise<void>;
     /** Persist an MCP toggle in its defining layer, then safely update this process. */
     setMcpEnabled(id: string, enabled: boolean, connect?: boolean): Promise<import("./index.ts").McpServerInfo>;
+    /**
+     * Persist one user-facing setting to the GLOBAL user config (`<config home>/config.json`)
+     * and apply it to this process where the value can change live. Compaction and limits land
+     * in the runner (honored by the next run/compact), `context.*` lands in the project context
+     * (next instructions load), `websearch.provider` mutates the shared config object the search
+     * chain reads per call, `pluginHooks.timeoutMs` lands in the plugin host (next hook call),
+     * and `tui.*` is persisted for the host to apply. Nothing in this set requires a restart.
+     * `mcp.allow` is deliberately not routed here: it flows through
+     * `rememberGlobalMcpConsent`/`revokeGlobalMcpConsent` instead.
+     * Throws under `--read-only`. Returns the written config file.
+     */
+    updateSetting(key: SettableSettingKey, value: unknown): Promise<string>;
     provider: ActiveProvider;
     providers: ProviderRegistry;
     providerSettings: ProviderSettingsStore;

package/dist/application.js

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { configFile, configHome, loadConfigWithProvenance, overridesSavedProviderProfile, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
+import { configFile, configHome, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
 import { completeText } from "./core/compaction.js";
 import { ToolRegistry } from "./core/registry.js";
 import { AgentRunner } from "./core/runner.js";
@@ -729,6 +729,69 @@ export async function createApplication(options = {}) {
                     : undefined);
                 return mcp.info(id);
             },
+            /**
+             * Persist one user-facing setting to the GLOBAL user config (`<config home>/config.json`)
+             * and apply it to this process where the value can change live. Compaction and limits land
+             * in the runner (honored by the next run/compact), `context.*` lands in the project context
+             * (next instructions load), `websearch.provider` mutates the shared config object the search
+             * chain reads per call, `pluginHooks.timeoutMs` lands in the plugin host (next hook call),
+             * and `tui.*` is persisted for the host to apply. Nothing in this set requires a restart.
+             * `mcp.allow` is deliberately not routed here: it flows through
+             * `rememberGlobalMcpConsent`/`revokeGlobalMcpConsent` instead.
+             * Throws under `--read-only`. Returns the written config file.
+             */
+            async updateSetting(key, value) {
+                if (options.readOnly)
+                    throw new Error("Settings changes are unavailable under --read-only");
+                const file = await setConfigValue({ key, value });
+                const compactionLeaf = (leaf) => ({ [leaf]: value });
+                const limitLeaf = (leaf) => ({ [leaf]: value });
+                switch (key) {
+                    case "compaction.auto":
+                    case "compaction.threshold":
+                    case "compaction.keepTurns":
+                    case "compaction.maxOutputTokens": {
+                        const patch = compactionLeaf(key.slice("compaction.".length));
+                        config.compaction = { ...config.compaction, ...patch };
+                        runner.applySettings({ compaction: patch });
+                        break;
+                    }
+                    case "context.claudeMdFallback":
+                        config.context = { ...config.context, claudeMdFallback: value === true };
+                        context.update({ claudeMdFallback: value === true });
+                        break;
+                    case "context.maxBytes":
+                        config.context = { ...config.context, maxBytes: Number(value) };
+                        context.update({ maxBytes: Number(value) });
+                        break;
+                    case "limits.maxTurns":
+                    case "limits.maxOutputTokens":
+                    case "limits.maxContextChars":
+                    case "limits.timeoutMs": {
+                        const patch = limitLeaf(key.slice("limits.".length));
+                        config.limits = { ...config.limits, ...patch };
+                        runner.applySettings(patch);
+                        break;
+                    }
+                    case "pluginHooks.timeoutMs":
+                        config.pluginHooks = { ...config.pluginHooks, timeoutMs: Number(value) };
+                        plugins.applyTimeoutSettings({ hookTimeoutMs: Number(value) });
+                        break;
+                    case "tui.paddingX":
+                        config.tui = { ...config.tui, paddingX: Number(value) };
+                        break;
+                    case "tui.skillSlashCommands":
+                        config.tui = { ...config.tui, skillSlashCommands: value === true };
+                        break;
+                    case "websearch.provider":
+                        // Mutated in place (same object identity) so the tool chain's per-call
+                        // `websearchCtx.config` sees the new provider on the very next search call.
+                        config.websearch.provider =
+                            value === undefined ? undefined : value;
+                        break;
+                }
+                return file;
+            },
             provider,
             providers,
             providerSettings,

package/dist/config.d.ts

@@ -172,6 +172,10 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         maxOutputTokens: z.ZodDefault<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    tui: z.ZodDefault<z.ZodObject<{
+        paddingX: z.ZodDefault<z.ZodNumber>;
+        skillSlashCommands: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodTransform<{
     schemaVersion: 1;
     provider: {
@@ -223,6 +227,10 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         maxOutputTokens: number;
         maxTokens?: number | undefined;
     };
+    tui: {
+        paddingX: number;
+        skillSlashCommands: boolean;
+    };
     mcp: {
         allow?: boolean | undefined;
         servers: {
@@ -357,6 +365,10 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         maxOutputTokens: number;
         maxTokens?: number | undefined;
     };
+    tui: {
+        paddingX: number;
+        skillSlashCommands: boolean;
+    };
 }>>;
 export type Config = z.infer<typeof configSchema>;
 export type ServerConfig = z.infer<typeof serverSchema>;
@@ -416,6 +428,41 @@ export declare function setMcpServerEnabled(input: {
 export declare function setGlobalMcpAllow(input: {
     allow: boolean;
 }): Promise<string>;
+declare const SETTABLE_KEYS: {
+    readonly "compaction.auto": z.ZodDefault<z.ZodBoolean>;
+    readonly "compaction.threshold": z.ZodDefault<z.ZodNumber>;
+    readonly "compaction.keepTurns": z.ZodDefault<z.ZodNumber>;
+    readonly "compaction.maxOutputTokens": z.ZodDefault<z.ZodNumber>;
+    readonly "context.claudeMdFallback": z.ZodDefault<z.ZodBoolean>;
+    readonly "context.maxBytes": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.maxTurns": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.maxOutputTokens": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.maxContextChars": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "pluginHooks.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "tui.paddingX": z.ZodDefault<z.ZodNumber>;
+    readonly "tui.skillSlashCommands": z.ZodDefault<z.ZodBoolean>;
+    readonly "websearch.provider": z.ZodOptional<z.ZodEnum<{
+        brave: "brave";
+        "duckduckgo-instant": "duckduckgo-instant";
+        native: "native";
+        searxng: "searxng";
+        serpapi: "serpapi";
+        tavily: "tavily";
+    }>>;
+};
+export type SettableSettingKey = keyof typeof SETTABLE_KEYS;
+export declare function isSettableSettingKey(key: string): key is SettableSettingKey;
+/**
+ * Atomically sets one user-facing setting in the global config file (`<config home>/config.json`)
+ * while preserving every unrelated JSON field. The value is validated against the same zod leaf
+ * used by `configSchema`, so a write can never produce a config the loader would reject. The
+ * caller is responsible for applying the change to the running process (see `application.ts`).
+ */
+export declare function setConfigValue(input: {
+    key: SettableSettingKey;
+    value: unknown;
+}): Promise<string>;
 /** Atomically updates one project plugin override while preserving every unrelated JSON field. */
 export declare function setProjectPluginEnabled(input: {
     workspace: string;

package/dist/config.js

@@ -164,6 +164,18 @@ const configObjectSchema = z
         maxContextChars: 160000,
         maxOutputTokens: 4096,
     })),
+    tui: z
+        .object({
+        /** Horizontal padding (columns) around the editor input box. */
+        paddingX: z.number().int().min(0).max(4).default(1),
+        /**
+         * Offer effective skills as first-class `skill:<id>` editor slash-autocomplete entries.
+         * Off hides those entries; the `/skills` manager and its argument completion stay available.
+         */
+        skillSlashCommands: z.boolean().default(true),
+    })
+        .strict()
+        .default(() => ({ paddingX: 1, skillSlashCommands: true })),
 })
     .strict()
     .superRefine((config, context) => {
@@ -398,6 +410,89 @@ export async function setGlobalMcpAllow(input) {
     }
     return file;
 }
+/**
+ * The user-facing settings writable through the atomic `setConfigValue` writer, with their zod
+ * leaf validators derived from the config schema. Only these keys are accepted; every other
+ * config path stays out of reach of the settings menu (unknown keys are rejected, never created).
+ */
+const SETTABLE_SECTIONS = {
+    compaction: configObjectSchema.shape.compaction.removeDefault(),
+    context: configObjectSchema.shape.context.removeDefault(),
+    limits: configObjectSchema.shape.limits.removeDefault(),
+    pluginHooks: configObjectSchema.shape.pluginHooks.removeDefault(),
+    tui: configObjectSchema.shape.tui.removeDefault(),
+    websearch: configObjectSchema.shape.websearch.removeDefault(),
+};
+const SETTABLE_KEYS = {
+    "compaction.auto": SETTABLE_SECTIONS.compaction.shape.auto,
+    "compaction.threshold": SETTABLE_SECTIONS.compaction.shape.threshold,
+    "compaction.keepTurns": SETTABLE_SECTIONS.compaction.shape.keepTurns,
+    "compaction.maxOutputTokens": SETTABLE_SECTIONS.compaction.shape.maxOutputTokens,
+    "context.claudeMdFallback": SETTABLE_SECTIONS.context.shape.claudeMdFallback,
+    "context.maxBytes": SETTABLE_SECTIONS.context.shape.maxBytes,
+    "limits.maxTurns": SETTABLE_SECTIONS.limits.shape.maxTurns,
+    "limits.maxOutputTokens": SETTABLE_SECTIONS.limits.shape.maxOutputTokens,
+    "limits.maxContextChars": SETTABLE_SECTIONS.limits.shape.maxContextChars,
+    "limits.timeoutMs": SETTABLE_SECTIONS.limits.shape.timeoutMs,
+    "pluginHooks.timeoutMs": SETTABLE_SECTIONS.pluginHooks.shape.timeoutMs,
+    "tui.paddingX": SETTABLE_SECTIONS.tui.shape.paddingX,
+    "tui.skillSlashCommands": SETTABLE_SECTIONS.tui.shape.skillSlashCommands,
+    "websearch.provider": SETTABLE_SECTIONS.websearch.shape.provider,
+};
+export function isSettableSettingKey(key) {
+    return Object.prototype.hasOwnProperty.call(SETTABLE_KEYS, key);
+}
+/**
+ * Atomically sets one user-facing setting in the global config file (`<config home>/config.json`)
+ * while preserving every unrelated JSON field. The value is validated against the same zod leaf
+ * used by `configSchema`, so a write can never produce a config the loader would reject. The
+ * caller is responsible for applying the change to the running process (see `application.ts`).
+ */
+export async function setConfigValue(input) {
+    const validator = SETTABLE_KEYS[input.key];
+    if (!validator)
+        throw new Error(`Unknown setting key: ${input.key}`);
+    const parsed = validator.safeParse(input.value);
+    if (!parsed.success) {
+        const detail = parsed.error.issues[0];
+        throw new Error(detail
+            ? `Invalid value for ${input.key}: ${detail.path.join(".") || "value"} ${detail.message}`
+            : `Invalid value for ${input.key}`);
+    }
+    const file = join(configHome(), "config.json");
+    let raw = {};
+    if (await exists(file)) {
+        const existing = JSON.parse(await readFile(file, "utf8"));
+        if (!existing || typeof existing !== "object" || Array.isArray(existing))
+            throw new Error("Global Alisio configuration must be a JSON object");
+        raw = existing;
+    }
+    const [section, leaf] = input.key.split(".");
+    const container = raw[section] && typeof raw[section] === "object" && !Array.isArray(raw[section])
+        ? raw[section]
+        : {};
+    raw[section] = { ...container, [leaf]: parsed.data };
+    raw.schemaVersion ??= 1;
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(raw, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, file);
+        await chmod(file, 0o600);
+    }
+    catch (error) {
+        await unlink(temporary).catch(() => { });
+        throw error;
+    }
+    return file;
+}
 /** Atomically updates one project plugin override while preserving every unrelated JSON field. */
 export async function setProjectPluginEnabled(input) {
     const file = join(input.workspace, ".alisio", "config.json");

package/dist/core/compaction.d.ts

@@ -69,6 +69,34 @@ export interface MessageReduction {
  * Checkpoint summaries (`summary: true`) are bounded by design and never truncated.
  */
 export declare function reduceMessageSizes(messages: Message[], options?: MessageReductionOptions): MessageReduction;
+export interface BudgetReductionOptions extends MessageReductionOptions {
+    /**
+     * Descending per-round caps for tool result text, replacing the default
+     * 8192 → 4096 → 2048 → 1024 → 512 sequence.
+     */
+    toolCapRounds?: number[];
+    /**
+     * Descending per-round caps for user/assistant text, replacing the default
+     * 16384 → 8192 → 4096 → 2048 → 1024 sequence.
+     */
+    textCapRounds?: number[];
+}
+/**
+ * Budget-based reduction: iteratively clips the LARGEST retained content (tool results in
+ * practice, then long texts) in descending cap rounds until the serialized transcript fits
+ * `targetChars` or the minimum caps are reached. Unlike `reduceMessageSizes` (which only clips
+ * messages whose INDIVIDUAL size exceeds its cap), this also handles sessions with many MEDIUM
+ * tool results (for example MCP outputs of a few thousand characters each) that stay under the
+ * per-message caps but together exhaust the context budget.
+ *
+ * The invariants match `reduceMessageSizes`: only message content changes (roles, call IDs,
+ * order and message boundaries stay identical, so a tool call is never separated from its
+ * results), checkpoint summaries are never truncated, and every cut carries the
+ * `… [truncated by context budget]` marker. Within a round the most expensive messages are
+ * clipped first (ties by position), so the smallest number of changes achieves the target; the
+ * order and the round caps make the result a deterministic total order of the input.
+ */
+export declare function reduceMessagesToBudget(messages: Message[], targetChars: number, options?: BudgetReductionOptions): MessageReduction;
 /**
  * Plain-text transcript used as summarizer input. Provider continuation data (for example
  * encrypted reasoning) is opaque and is intentionally not included.

package/dist/core/compaction.js

@@ -97,6 +97,41 @@ export const TRUNCATION_MARKER = "… [truncated by context budget]";
 export const MAX_TOOL_RESULT_CHARS = 8_000;
 /** Default per-message cap for kept user/assistant text after a failed compaction. */
 export const MAX_TEXT_CHARS = 16_000;
+/**
+ * Cuts ONE message's content down to the given per-message caps. Returns the same reference when
+ * nothing changes, so callers can detect a no-op by identity. See `reduceMessageSizes` for the
+ * invariants (roles/callIds/boundaries untouched, summaries never truncated).
+ */
+function clampMessage(message, maxToolResultChars, maxTextChars) {
+    if (message.role === "user") {
+        if (message.summary || message.text.length <= maxTextChars)
+            return message;
+        return { ...message, text: `${message.text.slice(0, maxTextChars)}\n${TRUNCATION_MARKER}` };
+    }
+    if (message.role === "assistant") {
+        if (message.text.length <= maxTextChars)
+            return message;
+        return { ...message, text: `${message.text.slice(0, maxTextChars)}\n${TRUNCATION_MARKER}` };
+    }
+    let used = 0;
+    let changed = false;
+    const content = message.result.content.map((part) => {
+        const room = maxToolResultChars - used;
+        const text = room <= 0
+            ? TRUNCATION_MARKER
+            : part.text.length > room
+                ? `${part.text.slice(0, room)}\n${TRUNCATION_MARKER}`
+                : part.text;
+        if (text !== part.text) {
+            changed = true;
+            used = maxToolResultChars;
+        }
+        else
+            used += part.text.length;
+        return { type: "text", text };
+    });
+    return changed ? { ...message, result: { ...message.result, content } } : message;
+}
 /**
  * Cuts oversized retained content so the session fits the context-budget hard limit after a
  * compaction could not. Only message CONTENT changes (user/assistant `text` and the text parts
@@ -109,42 +144,102 @@ export function reduceMessageSizes(messages, options = {}) {
     const maxTextChars = options.maxTextChars ?? MAX_TEXT_CHARS;
     let truncated = 0;
     const reduced = messages.map((m) => {
-        if (m.role === "user") {
-            if (m.summary || m.text.length <= maxTextChars)
-                return m;
-            truncated++;
-            return { ...m, text: `${m.text.slice(0, maxTextChars)}\n${TRUNCATION_MARKER}` };
-        }
-        if (m.role === "assistant") {
-            if (m.text.length <= maxTextChars)
-                return m;
-            truncated++;
-            return { ...m, text: `${m.text.slice(0, maxTextChars)}\n${TRUNCATION_MARKER}` };
-        }
-        let used = 0;
-        let changed = false;
-        const content = m.result.content.map((part) => {
-            const room = maxToolResultChars - used;
-            const text = room <= 0
-                ? TRUNCATION_MARKER
-                : part.text.length > room
-                    ? `${part.text.slice(0, room)}\n${TRUNCATION_MARKER}`
-                    : part.text;
-            if (text !== part.text) {
-                changed = true;
-                used = maxToolResultChars;
-            }
-            else
-                used += part.text.length;
-            return { type: "text", text };
-        });
-        if (!changed)
+        const cut = clampMessage(m, maxToolResultChars, maxTextChars);
+        if (cut === m)
             return m;
         truncated++;
-        return { ...m, result: { ...m.result, content } };
+        return cut;
     });
     return truncated ? { messages: reduced, truncated } : { messages, truncated: 0 };
 }
+/** Descending per-round tool-result caps used by `reduceMessagesToBudget` by default. */
+const DEFAULT_TOOL_CAP_ROUNDS = [MAX_TOOL_RESULT_CHARS, 4_096, 2_048, 1_024, 512];
+/** Descending per-round user/assistant text caps used by `reduceMessagesToBudget` by default. */
+const DEFAULT_TEXT_CAP_ROUNDS = [MAX_TEXT_CHARS, 8_192, 4_096, 2_048, 1_024];
+/** A strictly descending cap sequence starting at `start`, followed by the smaller defaults. */
+function capRounds(start, defaults) {
+    return [start, ...defaults.filter((c) => c < start)];
+}
+/**
+ * Budget-based reduction: iteratively clips the LARGEST retained content (tool results in
+ * practice, then long texts) in descending cap rounds until the serialized transcript fits
+ * `targetChars` or the minimum caps are reached. Unlike `reduceMessageSizes` (which only clips
+ * messages whose INDIVIDUAL size exceeds its cap), this also handles sessions with many MEDIUM
+ * tool results (for example MCP outputs of a few thousand characters each) that stay under the
+ * per-message caps but together exhaust the context budget.
+ *
+ * The invariants match `reduceMessageSizes`: only message content changes (roles, call IDs,
+ * order and message boundaries stay identical, so a tool call is never separated from its
+ * results), checkpoint summaries are never truncated, and every cut carries the
+ * `… [truncated by context budget]` marker. Within a round the most expensive messages are
+ * clipped first (ties by position), so the smallest number of changes achieves the target; the
+ * order and the round caps make the result a deterministic total order of the input.
+ */
+export function reduceMessagesToBudget(messages, targetChars, options = {}) {
+    const target = Math.max(1, Math.floor(targetChars));
+    const toolCapRounds = options.toolCapRounds ??
+        capRounds(options.maxToolResultChars ?? MAX_TOOL_RESULT_CHARS, DEFAULT_TOOL_CAP_ROUNDS);
+    const textCapRounds = options.textCapRounds ??
+        capRounds(options.maxTextChars ?? MAX_TEXT_CHARS, DEFAULT_TEXT_CAP_ROUNDS);
+    const rounds = Math.max(toolCapRounds.length, textCapRounds.length);
+    // Working transcript; `messages` keeps the untouched originals for re-clipping each round.
+    const working = [...messages];
+    const sizeOf = (m) => JSON.stringify(m).length;
+    const sizes = working.map(sizeOf);
+    // Serialized array length == sum of message lengths + n-1 commas + 2 brackets (+n+1 total).
+    let size = sizes.reduce((a, b) => a + b, 0) + working.length + 1;
+    if (size <= target)
+        return { messages, truncated: 0 };
+    const clipped = new Set();
+    for (let round = 0; round < rounds && size > target; round++) {
+        const toolCap = toolCapRounds[Math.min(round, toolCapRounds.length - 1)];
+        const textCap = textCapRounds[Math.min(round, textCapRounds.length - 1)];
+        if (toolCap === undefined || textCap === undefined)
+            break;
+        let shrank = true;
+        while (size > target && shrank) {
+            shrank = false;
+            // Largest (by current serialized size) clip-able message first; ties by position.
+            let best = -1, bestSize = -1;
+            for (let i = 0; i < working.length; i++) {
+                const current = sizes[i];
+                if (current === undefined || current <= bestSize)
+                    continue;
+                const m = messages[i];
+                if (!m)
+                    continue;
+                const over = m.role === "user"
+                    ? !m.summary && m.text.length > textCap
+                    : m.role === "assistant"
+                        ? m.text.length > textCap
+                        : m.role === "tool" &&
+                            m.result.content.reduce((a, p) => a + p.text.length, 0) > toolCap;
+                if (over) {
+                    best = i;
+                    bestSize = current;
+                }
+            }
+            if (best < 0)
+                break;
+            const original = messages[best];
+            const oldSize = sizes[best];
+            if (!original || oldSize === undefined)
+                break;
+            // Re-clip from the ORIGINAL content so earlier markers are never embedded mid-result.
+            const cut = clampMessage(original, toolCap, textCap);
+            const newSize = sizeOf(cut);
+            const delta = oldSize - newSize;
+            sizes[best] = newSize;
+            if (delta <= 0)
+                continue; // already at this round's caps; no room to shrink further
+            working[best] = cut;
+            clipped.add(best);
+            size -= delta;
+            shrank = true;
+        }
+    }
+    return clipped.size ? { messages: working, truncated: clipped.size } : { messages, truncated: 0 };
+}
 /**
  * Plain-text transcript used as summarizer input. Provider continuation data (for example
  * encrypted reasoning) is opaque and is intentionally not included.

package/dist/core/runner.d.ts

@@ -43,6 +43,19 @@ export interface RunnerOptions {
      */
     nativeTools?: Array<Record<string, unknown>>;
 }
+/** The settings a running TUI can change live; merged into the runner options on apply. */
+export interface RunnerSettingsPatch {
+    /** Compaction settings; merged over the current ones (any subset). */
+    compaction?: Partial<CompactionSettings>;
+    /** Maximum turns per run. */
+    maxTurns?: number;
+    /** Per-call max output tokens budget. */
+    maxOutputTokens?: number;
+    /** Post-compaction context budget in characters. */
+    maxContextChars?: number;
+    /** Per-run timeout in milliseconds; the next run honors it. */
+    timeoutMs?: number;
+}
 /**
  * Per-run overrides used by embedders and child sessions. Callers must only NARROW: `policy`
  * and `toolFilter` are applied on top of the runner's policy and tools.
@@ -92,6 +105,11 @@ export declare class AgentRunner {
     get policy(): Readonly<Policy>;
     /** Whether write/process tools can be approved interactively. */
     get approvals(): boolean;
+    /**
+     * Live-update runnable settings so the next `run`/`compact` call honors them without restarting
+     * Alisio. Every patch field is merged over the current options; unrelated settings are kept.
+     */
+    applySettings(patch: RunnerSettingsPatch): void;
     private emitter;
     /** Tools offered to the model under the current policy (and optional run narrowing). */
     availableTools(run?: RunOptions): ToolDefinition[];

package/dist/core/runner.js

@@ -1,5 +1,5 @@
 import { textResult, } from "@alisio/sdk";
-import { checkpointInstructions, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, reduceMessageSizes, shouldCompactContext, summarize, summaryMessage, } from "./compaction.js";
+import { checkpointInstructions, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, reduceMessagesToBudget, shouldCompactContext, summarize, summaryMessage, } from "./compaction.js";
 /**
  * Default cumulative token budget for one run: several context windows (each turn re-sends the
  * context), clamped; 1M tokens when the window is unknown.
@@ -11,6 +11,12 @@ export function defaultTokenBudget(contextWindow) {
 }
 /** Extension output appended to history is capped regardless of what hooks return. */
 const MAX_INJECT_CHARS = 24_000;
+/**
+ * Floor for the post-compaction transcript target: retained messages are never reduced below
+ * this many characters, so a pathological session (instructions + tools alone crowding out the
+ * limit) fails with an actionable error instead of silently losing the whole history.
+ */
+const MIN_MESSAGE_BUDGET_FLOOR = 4_000;
 const allowed = (policy, effect) => effect === "read" || effect === "internal" || !!policy[effect];
 export class AgentRunner {
     options;
@@ -31,6 +37,18 @@ export class AgentRunner {
     get approvals() {
         return !!this.options.approve;
     }
+    /**
+     * Live-update runnable settings so the next `run`/`compact` call honors them without restarting
+     * Alisio. Every patch field is merged over the current options; unrelated settings are kept.
+     */
+    applySettings(patch) {
+        const { compaction, ...rest } = patch;
+        this.options = {
+            ...this.options,
+            ...rest,
+            ...(compaction ? { compaction: { ...this.options.compaction, ...compaction } } : {}),
+        };
+    }
     emitter(sessionId) {
         const runId = crypto.randomUUID();
         let seq = 0;
@@ -358,13 +376,18 @@ export class AgentRunner {
                     messages = o.store.messages(sessionId);
                 }
                 // A compaction that still leaves the session over the hard limit (typically a kept tail
-                // holding huge tool outputs) is reduced in place instead of failing outright: oversized
-                // kept content is cut per message (roles/callIds/boundaries untouched, so the transcript
-                // stays valid and replayable). Only if even the reduced tail exceeds the limit the run
-                // fails with an actionable error; the reduction is persisted either way, so the session
-                // stays usable for later prompts.
+                // holding huge tool outputs) is reduced in place instead of failing outright: retained
+                // content is clipped against a TOTAL character target for the transcript
+                // (`limit − instructions − tools`), largest items first, tool results before texts, in
+                // descending cap rounds. That also covers sessions with many MEDIUM results (e.g. MCP
+                // outputs of a few thousand chars each) that individually stay under the per-message
+                // caps; roles/callIds/boundaries stay untouched, so the transcript remains valid and
+                // replayable. Only if even the reduction floor cannot fit (instructions + tools alone
+                // crowd out the limit) the run fails with an actionable error; the reduction is
+                // persisted either way, so the session stays usable for later prompts.
                 if (chars() > limit) {
-                    const reduction = reduceMessageSizes(messages);
+                    const targetChars = Math.max(MIN_MESSAGE_BUDGET_FLOOR, limit - instructions.length - toolsText.length);
+                    const reduction = reduceMessagesToBudget(messages, targetChars);
                     if (reduction.truncated > 0) {
                         o.store.overwrite(sessionId, reduction.messages);
                         messages = reduction.messages;

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
 export { type AppOptions, type BuiltinContext, type BuiltinPlugin, createApplication, enabledBuiltins, type PluginCatalogEntry, type PluginCatalogStatus, } from "./application.ts";
-export { type Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.ts";
+export { type Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, isSettableSettingKey, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, type SettableSettingKey, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.ts";
 export { type ContextBudget, checkpointInstructions, completeText, effectiveContextBudget, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, shouldCompactContext, summarize, } from "./core/compaction.ts";
 export type { ApprovalDecision, ApprovalHandler, ApprovalRequest, ContextSource, HookFailure, Policy, RunnerExtensions, Session, SessionStore, } from "./core/contracts.ts";
 export { ToolRegistry } from "./core/registry.ts";
-export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunOptions, } from "./core/runner.ts";
+export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunnerSettingsPatch, type RunOptions, } from "./core/runner.ts";
 export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
 export { HerdrBridge } from "./integrations/herdr.ts";
 export { McpConnector, type McpServerInfo, type McpStatus, type McpToolInfo, } from "./mcp/connector.ts";

package/dist/index.js

@@ -1,7 +1,7 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
 export { createApplication, enabledBuiltins, } from "./application.js";
-export { configFile, configHome, configSchema, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
+export { configFile, configHome, configSchema, isSettableSettingKey, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
 export { checkpointInstructions, completeText, effectiveContextBudget, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, shouldCompactContext, summarize, } from "./core/compaction.js";
 export { ToolRegistry } from "./core/registry.js";
 export { AgentRunner, defaultTokenBudget, } from "./core/runner.js";

package/dist/plugins/host.d.ts

@@ -91,6 +91,11 @@ export declare class PluginHost implements RunnerExtensions {
         getState(plugin: string, key: string): unknown;
         setState(plugin: string, key: string, value: unknown): void;
     }, options?: PluginHostOptions, providers?: ProviderRegistry | undefined);
+    /**
+     * Live-update host-enforced hook timeouts so the NEXT hook call honors them without restarting.
+     * Keeps the same options object reference the constructors of new hooks read at call time.
+     */
+    applyTimeoutSettings(patch: Partial<PluginHostOptions>): void;
     /** Binds the provider-agnostic completion service once a provider exists. */
     setCompleter(fn: (request: CompletionRequest & {
         signal: AbortSignal;

package/dist/plugins/host.js

@@ -93,6 +93,13 @@ export class PluginHost {
         this.options = options;
         this.providers = providers;
     }
+    /**
+     * Live-update host-enforced hook timeouts so the NEXT hook call honors them without restarting.
+     * Keeps the same options object reference the constructors of new hooks read at call time.
+     */
+    applyTimeoutSettings(patch) {
+        this.options = { ...this.options, ...patch };
+    }
     /** Binds the provider-agnostic completion service once a provider exists. */
     setCompleter(fn) {
         this.completer = fn;

package/dist/resources/context.d.ts

@@ -22,6 +22,11 @@ export declare class ProjectContext implements ContextSource {
     /** Per session: nested instruction file path → fingerprint already attached. */
     private attached;
     constructor(workspace: string, options?: ProjectContextOptions);
+    /**
+     * Live-update options so the next `instructions()` call honors them without restarting.
+     * Only runtime-read fields matter (`claudeMdFallback`, `maxBytes`); `cwd` stays fixed.
+     */
+    update(options: Partial<ProjectContextOptions>): void;
     private names;
     private readDir;
     /** Directories from the workspace root down to the directory containing `path`. */

package/dist/resources/context.js

@@ -28,6 +28,13 @@ export class ProjectContext {
         this.options = options;
         this.cwd = options.cwd ?? workspace;
     }
+    /**
+     * Live-update options so the next `instructions()` call honors them without restarting.
+     * Only runtime-read fields matter (`claudeMdFallback`, `maxBytes`); `cwd` stays fixed.
+     */
+    update(options) {
+        this.options = { ...this.options, ...options };
+    }
     names() {
         return [
             ["AGENTS.override.md", "override"],

package/dist/startup/screen.js

@@ -42,6 +42,7 @@ export function welcomeSection(ctx) {
 export function infoSection(ctx, width) {
     const t = ctx.terminal;
     const label = sgr(t.color, "2");
+    const pad = " ".repeat(2);
     const rows = [];
     if (ctx.model)
         rows.push(["model", ctx.model]);
@@ -54,9 +55,9 @@ export function infoSection(ctx, width) {
     rows.push(["plugins", plugins ? `${plugins} loaded` : "none"]);
     const labelWidth = Math.min(12, Math.max(...rows.map(([l]) => l.length)) + 1);
     return rows.map(([l, v]) => {
-        const room = Math.max(1, width - labelWidth - 1);
+        const room = Math.max(1, width - labelWidth - 1 - 4);
         const value = l === "cwd" ? shortenPath(v, room) : truncate(v, room);
-        return `${label(padEnd(l, labelWidth))} ${value}`;
+        return `${pad}${label(padEnd(l, labelWidth))} ${value}${pad}`;
     });
 }
 export function pluginsSection(ctx) {
@@ -72,12 +73,12 @@ export function pluginsSection(ctx) {
             .filter((p) => !p.categories?.includes("model-provider"))
             .map((p) => `${p.id}${p.builtin ? " (builtin)" : ""}`),
     ];
-    return [`${sgr(t.color, "2")("with")} ${names.join(", ")}`];
+    return [`  ${sgr(t.color, "2")("with")} ${names.join(", ")}  `];
 }
 export function tipsSection(ctx) {
     const t = ctx.terminal;
     const bullet = sgr(t.color, "33")(glyph(t, "›", ">"));
-    return ctx.tips.map((tip) => `${bullet} Tip: ${tip}`);
+    return ctx.tips.map((tip) => `  ${bullet} Tip: ${tip}  `);
 }
 export function mascotSection(ctx) {
     return [ctx.mascot.render({ terminal: ctx.terminal, version: ctx.version })].flat();
@@ -110,7 +111,7 @@ export const DefaultStartupScreen = {
             ...pluginsSection(ctx),
         ];
         const body = side ? composeSideBySide(mascot, info, columns) : [...mascot, ...info];
-        const rule = sgr(ctx.terminal.color, "2")(glyph(ctx.terminal, "─", "-").repeat(Math.min(columns, 60)));
+        const rule = sgr(ctx.terminal.color, "2")(glyph(ctx.terminal, "─", "-").repeat(columns - 2));
         return [...body, "", ...tipsSection(ctx), rule].map((line) => truncate(line, columns));
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/core",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.9",
   "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",