@alisio/core 0.1.0-alpha.8 → 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/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

@@ -37,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;

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.8",
+  "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",