@alisio/core 0.1.0-alpha.8 → 0.1.0

package/dist/config.js

@@ -1,4 +1,4 @@
-import { chmod, mkdir, open, readFile, rename, unlink } from "node:fs/promises";
+import { chmod, mkdir, open, readFile, realpath, rename, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
@@ -75,12 +75,25 @@ const serversSchema = (value) => z.record(z.string(), value).superRefine((server
                 message: "MCP server names may contain only letters, numbers, dot, underscore and dash",
             });
 });
+/**
+ * A container image reference pinned by digest. Anchored at the start with a letter or digit so a
+ * value can never be read as an option by the container CLI.
+ */
+export const OCI_IMAGE_PATTERN = /^[a-zA-Z0-9][^\s@]*@sha256:[a-f0-9]{64}$/;
+/** Analysis keys only the user (global) layer decides; a project layer cannot set them. */
+const GLOBAL_ONLY_ANALYSIS = ["runtime", "oci", "retention"];
 const configObjectSchema = z
     .object({
     schemaVersion: z.literal(1).default(1),
     provider: providerSchema.default(() => providerSchema.parse({})),
     plugins: z.array(z.string()).default([]),
     skills: z.array(z.string()).default([]),
+    /**
+     * Extra directories the mediated path policy may touch outside the workspace. Resolved
+     * relative to the defining configuration file and canonicalized on load. Additive across
+     * layers like `plugins`/`skills`: a lower layer can only ADD, never clear the global list.
+     */
+    additionalDirectories: z.array(z.string().trim().min(1)).default([]),
     /** Project-local enable/disable overrides for effective non-plugin skills. */
     skillOverrides: z.record(z.string(), z.object({ enabled: z.boolean() }).strict()).default({}),
     mcp: z
@@ -140,7 +153,15 @@ const configObjectSchema = z
     websearch: z
         .object({
         provider: z
-            .enum(["searxng", "duckduckgo-instant", "tavily", "brave", "serpapi", "native"])
+            .enum([
+            "searxng",
+            "duckduckgo-instant",
+            "duckduckgo-html",
+            "tavily",
+            "brave",
+            "serpapi",
+            "native",
+        ])
             .optional(),
         searxngUrl: z.string().optional(),
         apiKeyEnv: z.string().optional(),
@@ -151,19 +172,260 @@ const configObjectSchema = z
         .default(() => ({ nativeToolType: "web_search" })),
     limits: z
         .object({
-        maxTurns: z.number().int().min(1).max(100).default(20),
-        timeoutMs: z.number().int().min(100).default(300000),
-        maxContextChars: z.number().int().positive().default(160000),
-        maxOutputTokens: z.number().int().positive().default(4096),
+        maxTurns: z.number().int().min(1).max(100).default(100),
+        timeoutMs: z.number().int().min(100).default(600000),
+        /**
+         * Stop a model request that stays completely silent (no text, reasoning or tool-call
+         * delta) this long, so a queued or stuck provider is cut after 90 s instead of the
+         * whole-run `timeoutMs`. 0 disables it (models that do not stream their reasoning can stay
+         * silent for minutes: raise or disable it for those).
+         */
+        firstTokenTimeoutMs: z.number().int().min(0).default(90000),
+        /**
+         * How many times the SAME request is sent again after it stayed silent for
+         * `firstTokenTimeoutMs` (a stalled connection usually answers on the next try). 0
+         * disables the retry. Never counts as a turn.
+         */
+        firstTokenRetries: z.number().int().min(0).max(3).default(1),
+        /**
+         * How many times a turn is requested again after the model's response was cut off by
+         * `maxOutputTokens` before it was usable (no text and no tool call, or a tool call with
+         * incomplete arguments). The truncated calls are never executed. 0 disables the
+         * recovery. Never counts as a turn.
+         */
+        truncationRecoveries: z.number().int().min(0).max(5).default(2),
+        maxContextChars: z.number().int().positive().default(800000),
+        /**
+         * Per-call output token budget for one agent turn. Deliberately WITHOUT a schema default:
+         * when unset, the budget of each request is the model catalog's declared maximum (capped
+         * at 65536) or 16384 (see `core/output-limit.ts`), so "set by the user" stays
+         * distinguishable from "defaulted". A value set here always wins. 4096 starves
+         * reasoning-heavy models, which can spend the whole budget on `reasoning_content`
+         * before any usable text arrives.
+         */
+        maxOutputTokens: z.number().int().positive().optional(),
         /** Cumulative tokens per run; default is proportional to the context window. */
         maxTokens: z.number().int().positive().optional(),
     })
         .default(() => ({
-        maxTurns: 20,
-        timeoutMs: 300000,
-        maxContextChars: 160000,
-        maxOutputTokens: 4096,
+        maxTurns: 100,
+        timeoutMs: 600000,
+        firstTokenTimeoutMs: 90000,
+        firstTokenRetries: 1,
+        truncationRecoveries: 2,
+        maxContextChars: 800000,
     })),
+    /**
+     * Python analysis and downloadable artifacts. `enabled: false` registers none of the
+     * analysis tools. The interpreter is discovered automatically (or pinned with `--python`).
+     */
+    analysis: z
+        .object({
+        enabled: z.boolean().default(true),
+        /**
+         * Where `python_run` executes. `managed` is the discovered Python (not a sandbox); `oci`
+         * is a Docker or Podman container started from a pinned image. GLOBAL ONLY: a project
+         * layer cannot choose the runtime or the image (it is ignored with a diagnostic).
+         */
+        runtime: z.enum(["managed", "oci"]).default("managed"),
+        /** Container runtime settings (global only). Used when `runtime` is `oci`. */
+        oci: z
+            .object({
+            engine: z.enum(["docker", "podman"]).default("docker"),
+            /** `name@sha256:<digest>`: an image without a digest is rejected at load time. */
+            image: z
+                .string()
+                .regex(OCI_IMAGE_PATTERN, "analysis.oci.image must be pinned by digest: <name>@sha256:<64 hex characters>")
+                .optional(),
+            memoryMb: z.number().int().min(256).max(65_536).default(2048),
+            cpus: z.number().min(0.5).max(64).default(2),
+        })
+            .strict()
+            .default(() => ({ engine: "docker", memoryMb: 2048, cpus: 2 })),
+        limits: z
+            .object({
+            /** Default and maximum run time of one python_run call. */
+            timeoutMs: z.number().int().min(1000).max(900_000).default(120_000),
+            /** Files published by one execution. */
+            maxFiles: z.number().int().min(1).max(1000).default(200),
+            maxFileBytes: z
+                .number()
+                .int()
+                .positive()
+                .default(100 * 1024 * 1024),
+            /** Total bytes published by one execution. */
+            maxOutputBytes: z
+                .number()
+                .int()
+                .positive()
+                .default(500 * 1024 * 1024),
+            /** Size cap of each stdout/stderr log of a job. */
+            maxLogBytes: z
+                .number()
+                .int()
+                .positive()
+                .default(10 * 1024 * 1024),
+        })
+            .strict()
+            .default(() => ({
+            timeoutMs: 120_000,
+            maxFiles: 200,
+            maxFileBytes: 100 * 1024 * 1024,
+            maxOutputBytes: 500 * 1024 * 1024,
+            maxLogBytes: 10 * 1024 * 1024,
+        })),
+        /** Tabular data (CSV, TSV, JSON, JSONL, XLSX) ingested into one SQLite file per dataset. */
+        data: z
+            .object({
+            /** Largest file ingested (an upload or a workspace file). */
+            maxUploadBytes: z
+                .number()
+                .int()
+                .positive()
+                .default(200 * 1024 * 1024),
+            /** Rows per sheet; a larger file stops the ingestion and leaves no dataset. */
+            maxRows: z.number().int().positive().default(5_000_000),
+            /** Time limit of one `data_query` statement; the engine process is killed past it. */
+            queryTimeoutMs: z.number().int().min(100).max(60_000).default(5000),
+            /** Sorting and filtering are disabled above this many rows (the file has no indexes). */
+            maxInteractiveRows: z.number().int().positive().default(1_000_000),
+        })
+            .strict()
+            .default(() => ({
+            maxUploadBytes: 200 * 1024 * 1024,
+            maxRows: 5_000_000,
+            queryTimeoutMs: 5000,
+            maxInteractiveRows: 1_000_000,
+        })),
+        /**
+         * Retention of analysis data (`0` disables the automatic deletion of that class). Global
+         * only: one sweep covers every workspace, so a project layer cannot shorten it.
+         */
+        retention: z
+            .object({
+            /** Logs and staging of a job; its script and inputs once no artifact is `ready`. */
+            jobsDays: z.number().int().min(0).max(3650).default(30),
+            /** The scratch folder (`work/`) of a job. */
+            intermediateDays: z.number().int().min(0).max(3650).default(7),
+            /** Artifacts older than this become `expired` (folder deleted, row kept). 0 = keep. */
+            artifactsDays: z.number().int().min(0).max(3650).default(0),
+        })
+            .strict()
+            .default(() => ({ jobsDays: 30, intermediateDays: 7, artifactsDays: 0 })),
+    })
+        .strict()
+        .default(() => ({
+        enabled: true,
+        runtime: "managed",
+        oci: { engine: "docker", memoryMb: 2048, cpus: 2 },
+        retention: { jobsDays: 30, intermediateDays: 7, artifactsDays: 0 },
+        limits: {
+            timeoutMs: 120_000,
+            maxFiles: 200,
+            maxFileBytes: 100 * 1024 * 1024,
+            maxOutputBytes: 500 * 1024 * 1024,
+            maxLogBytes: 10 * 1024 * 1024,
+        },
+        data: {
+            maxUploadBytes: 200 * 1024 * 1024,
+            maxRows: 5_000_000,
+            queryTimeoutMs: 5000,
+            maxInteractiveRows: 1_000_000,
+        },
+    })),
+    /**
+     * Background tasks (`bg_run`, `bg_list`, `bg_output`, `bg_stop`). They are ordinary child
+     * processes of Alisio (not detached, not sandboxed): they end when Alisio ends. `enabled:
+     * false` registers none of the tools (applies from the next start). `retentionDays` is
+     * global-only: one sweep covers every workspace, so a project layer cannot shorten it.
+     */
+    tasks: z
+        .object({
+        enabled: z.boolean().default(true),
+        /** Live (queued, running or stopping) tasks per root session. */
+        maxPerSession: z.number().int().min(1).max(32).default(4),
+        /** Watchdog: a task still running after this long is stopped and fails with `timeout`. */
+        maxRunMs: z.number().int().min(1000).max(86_400_000).default(3_600_000),
+        /** Size limit of one task log (the head is kept, a short tail is added when it ends). */
+        maxOutputBytes: z.number().int().min(65_536).max(104_857_600).default(2_097_152),
+        /** Finished task rows and their logs are deleted after this many days (0 keeps them). */
+        retentionDays: z.number().int().min(0).max(3650).default(7),
+    })
+        .strict()
+        .default(() => ({
+        enabled: true,
+        maxPerSession: 4,
+        maxRunMs: 3_600_000,
+        maxOutputBytes: 2_097_152,
+        retentionDays: 7,
+    })),
+    /**
+     * `/goal`: a session objective the runtime keeps working on, with hard caps. The token budget
+     * is NOT a setting (none unless the user gives one with `budget=`); without it only the turn
+     * and time caps stop a goal. `maxTurns` counts runs (a goal turn is one run); `maxMinutes` is
+     * the time spent inside runs. The breakers pause a goal that makes no progress.
+     */
+    goal: z
+        .object({
+        enabled: z.boolean().default(true),
+        maxTurns: z.number().int().min(1).max(1000).default(50),
+        maxMinutes: z.number().int().min(1).max(1440).default(120),
+        /** Pause after this many consecutive identical replies (observed, nudged, then paused). */
+        repeatedReplyLimit: z.number().int().min(2).max(20).default(3),
+        /** Pause after this many consecutive turns without a tool call. */
+        noToolTurnsLimit: z.number().int().min(2).max(20).default(3),
+        /** Consecutive turns in which the model must report the same blocker before it stops. */
+        blockedRepeats: z.number().int().min(1).max(10).default(2),
+    })
+        .strict()
+        .default(() => ({
+        enabled: true,
+        maxTurns: 50,
+        maxMinutes: 120,
+        repeatedReplyLimit: 3,
+        noToolTurnsLimit: 3,
+        blockedRepeats: 2,
+    })),
+    tui: z
+        .object({
+        /** Horizontal padding (columns) around the editor input box. Editor-only. */
+        paddingX: z.number().int().min(0).max(4).default(1),
+        /**
+         * Horizontal inset (columns) applied to each side of the transcript content, so
+         * agent-written rows keep breathing room from the window borders. Independent of
+         * `paddingX` (which styles only the editor input box). Clamped on narrow terminals so the
+         * content column never collapses below a usable width.
+         */
+        contentPaddingX: z.number().int().min(0).max(12).default(2),
+        /**
+         * 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, contentPaddingX: 2, skillSlashCommands: true })),
+    /**
+     * The ACTIVE agent drives the main session: its system prompt is appended to every prompt and
+     * its optional model selector is offered when the agent is chosen (`/agents`). `build` is the
+     * built-in default (full-power, no added persona); `plan` is the built-in read-only planner.
+     * `effort` holds a reasoning effort level chosen with `/effort` for a model that advertises
+     * `effort.supportedLevels`; it is validated against the ACTIVE model on use, falling back to
+     * the model's default level when unsupported.
+     */
+    agents: z
+        .object({
+        active: z
+            .string()
+            .trim()
+            .min(1)
+            .max(100)
+            .regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/, "invalid agent name")
+            .default("build"),
+        effort: z.string().trim().min(1).max(50).optional(),
+    })
+        .strict()
+        .default(() => ({ active: "build" })),
 })
     .strict()
     .superRefine((config, context) => {
@@ -192,6 +454,26 @@ function isUsableLegacyModel(model) {
     const normalized = model.trim();
     return normalized !== "" && normalized !== LEGACY_PROVIDER_MODEL_PLACEHOLDER;
 }
+/**
+ * Appends the entries of `selected` after the `global` list, dropping exact duplicates so the
+ * global entries keep their order and the selected layer only ever ADDS to the collection. An
+ * empty `selected` list therefore leaves the global list intact. Entries were already resolved
+ * per layer by `parseLayer`, so deduplication happens on the resolved strings.
+ */
+function mergeUnique(global, selected) {
+    const seen = new Set(global);
+    const merged = [...global];
+    for (const entry of selected)
+        if (!seen.has(entry)) {
+            seen.add(entry);
+            merged.push(entry);
+        }
+    return merged;
+}
+/** Absolute, canonical directory when it exists; a missing path keeps its resolved absolute form. */
+async function canonicalDirectory(path) {
+    return realpath(path).catch(() => resolve(path));
+}
 /**
  * Whether legacy provider selection should take priority over a saved plugin profile for this
  * run: an explicit endpoint override, or a trusted project/explicit layer whose parsed root
@@ -224,6 +506,9 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
         const raw = (await readJson(file)) ?? {};
         const config = configSchema.parse(raw);
         config.skills = config.skills.map((p) => resolve(file, "..", p));
+        // Extra tool roots are paths relative to the config file; canonicalize so containment checks
+        // compare real directories (a symlinked root never escapes its declared location).
+        config.additionalDirectories = await Promise.all(config.additionalDirectories.map((p) => canonicalDirectory(resolve(file, "..", p))));
         // Plugin entries are paths (relative to the config file) or npm package names.
         config.plugins = config.plugins.map((p) => (isPathSpec(p) ? resolve(file, "..", p) : p));
         for (const server of Object.values(config.mcp.servers))
@@ -247,7 +532,17 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
                 form: canonical && name in canonical ? "canonical" : "alias",
             },
         ]));
-        return { config, keys: new Set(Object.keys(object)), sources };
+        const analysisRaw = object.analysis && typeof object.analysis === "object" && !Array.isArray(object.analysis)
+            ? object.analysis
+            : {};
+        const tasksRaw = object.tasks && typeof object.tasks === "object" && !Array.isArray(object.tasks)
+            ? object.tasks
+            : {};
+        const ignored = [
+            ...GLOBAL_ONLY_ANALYSIS.filter((key) => key in analysisRaw).map((key) => `analysis.${key}`),
+            ...("retentionDays" in tasksRaw ? ["tasks.retentionDays"] : []),
+        ];
+        return { config, keys: new Set(Object.keys(object)), sources, ignored, file };
     };
     const global = await parseLayer(globalFile, "global");
     // Skill activation is deliberately project-local; never carry a similarly named global field
@@ -258,15 +553,72 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
     // Parsed `provider.model` of the selected layer itself (before env/CLI overrides), used to
     // decide whether its legacy root `provider` is usable against a saved `/connect` profile.
     let selectedLegacyModel = "";
+    let ignoredKeys = [];
     if (selectedFile && selectedFile !== globalFile) {
         const selected = await parseLayer(selectedFile, options.file ? "explicit" : "project");
+        ignoredKeys = selected.ignored;
         selectedLegacyModel = selected.config.provider.model;
         const overlaid = { ...config };
         for (const key of selected.keys) {
             if (key === "mcp" || key === "mcpServers")
                 continue;
-            if (key in selected.config)
-                overlaid[key] = selected.config[key];
+            if (!(key in selected.config))
+                continue;
+            // Additive collections: the selected layer ADDS to the global list (global entries
+            // first, exact duplicates dropped); an empty selected list never clears the global one.
+            if (key === "plugins") {
+                overlaid.plugins = mergeUnique(overlaid.plugins, selected.config.plugins);
+                continue;
+            }
+            if (key === "skills") {
+                overlaid.skills = mergeUnique(overlaid.skills, selected.config.skills);
+                continue;
+            }
+            if (key === "additionalDirectories") {
+                overlaid.additionalDirectories = mergeUnique(overlaid.additionalDirectories, selected.config.additionalDirectories);
+                continue;
+            }
+            // Additive records: merge by key, the selected layer wins per key.
+            if (key === "pluginOverrides") {
+                overlaid.pluginOverrides = {
+                    ...overlaid.pluginOverrides,
+                    ...selected.config.pluginOverrides,
+                };
+                continue;
+            }
+            if (key === "skillOverrides") {
+                // Global skill overrides were reset above (skill activation is project-local); the
+                // selected overrides still merge into that empty record and win per key.
+                overlaid.skillOverrides = { ...overlaid.skillOverrides, ...selected.config.skillOverrides };
+                continue;
+            }
+            if (key === "builtinPlugins") {
+                // Per-plugin options merge by plugin id: the selected entry wins per id, so
+                // `{id: {enabled: false}}` in the selected layer still disables that built-in while
+                // every other global entry stays.
+                overlaid.builtinPlugins = { ...overlaid.builtinPlugins, ...selected.config.builtinPlugins };
+                continue;
+            }
+            if (key === "analysis") {
+                // `runtime`, `oci` and `retention` are global-only (a repository must not pick the binary
+                // that runs scripts, nor shorten the retention of every workspace's data).
+                overlaid.analysis = {
+                    ...selected.config.analysis,
+                    runtime: global.config.analysis.runtime,
+                    oci: global.config.analysis.oci,
+                    retention: global.config.analysis.retention,
+                };
+                continue;
+            }
+            if (key === "tasks") {
+                // `retentionDays` is global-only (one sweep deletes the data of every workspace).
+                overlaid.tasks = {
+                    ...selected.config.tasks,
+                    retentionDays: global.config.tasks.retentionDays,
+                };
+                continue;
+            }
+            overlaid[key] = selected.config[key];
         }
         if (selected.keys.has("mcp") || selected.keys.has("mcpServers"))
             // Only servers merge upward; `mcp.allow` is a global/user preference and is deliberately
@@ -304,6 +656,7 @@ export async function loadConfigWithProvenance(workspace, options = {}) {
                     },
                 }
                 : {}),
+            ...(ignoredKeys.length ? { ignored: ignoredKeys } : {}),
         },
     };
 }
@@ -398,6 +751,154 @@ 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(),
+    agents: configObjectSchema.shape.agents.removeDefault(),
+    analysis: configObjectSchema.shape.analysis.removeDefault(),
+    tasks: configObjectSchema.shape.tasks.removeDefault(),
+    goal: configObjectSchema.shape.goal.removeDefault(),
+};
+const ANALYSIS_LIMITS = SETTABLE_SECTIONS.analysis.shape.limits.removeDefault();
+const ANALYSIS_RETENTION = SETTABLE_SECTIONS.analysis.shape.retention.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,
+    "limits.firstTokenTimeoutMs": SETTABLE_SECTIONS.limits.shape.firstTokenTimeoutMs,
+    "limits.firstTokenRetries": SETTABLE_SECTIONS.limits.shape.firstTokenRetries,
+    "limits.truncationRecoveries": SETTABLE_SECTIONS.limits.shape.truncationRecoveries,
+    "pluginHooks.timeoutMs": SETTABLE_SECTIONS.pluginHooks.shape.timeoutMs,
+    "tui.paddingX": SETTABLE_SECTIONS.tui.shape.paddingX,
+    "tui.contentPaddingX": SETTABLE_SECTIONS.tui.shape.contentPaddingX,
+    "tui.skillSlashCommands": SETTABLE_SECTIONS.tui.shape.skillSlashCommands,
+    "websearch.provider": SETTABLE_SECTIONS.websearch.shape.provider,
+    "agents.active": SETTABLE_SECTIONS.agents.shape.active,
+    "agents.effort": SETTABLE_SECTIONS.agents.shape.effort,
+    "analysis.enabled": SETTABLE_SECTIONS.analysis.shape.enabled,
+    "analysis.limits.timeoutMs": ANALYSIS_LIMITS.shape.timeoutMs,
+    "analysis.retention.jobsDays": ANALYSIS_RETENTION.shape.jobsDays,
+    "analysis.retention.intermediateDays": ANALYSIS_RETENTION.shape.intermediateDays,
+    "analysis.retention.artifactsDays": ANALYSIS_RETENTION.shape.artifactsDays,
+    "tasks.enabled": SETTABLE_SECTIONS.tasks.shape.enabled,
+    "tasks.maxPerSession": SETTABLE_SECTIONS.tasks.shape.maxPerSession,
+    "tasks.maxRunMs": SETTABLE_SECTIONS.tasks.shape.maxRunMs,
+    "tasks.maxOutputBytes": SETTABLE_SECTIONS.tasks.shape.maxOutputBytes,
+    "tasks.retentionDays": SETTABLE_SECTIONS.tasks.shape.retentionDays,
+    "goal.enabled": SETTABLE_SECTIONS.goal.shape.enabled,
+    "goal.maxTurns": SETTABLE_SECTIONS.goal.shape.maxTurns,
+    "goal.maxMinutes": SETTABLE_SECTIONS.goal.shape.maxMinutes,
+    "goal.repeatedReplyLimit": SETTABLE_SECTIONS.goal.shape.repeatedReplyLimit,
+    "goal.noToolTurnsLimit": SETTABLE_SECTIONS.goal.shape.noToolTurnsLimit,
+    "goal.blockedRepeats": SETTABLE_SECTIONS.goal.shape.blockedRepeats,
+};
+export function isSettableSettingKey(key) {
+    return Object.prototype.hasOwnProperty.call(SETTABLE_KEYS, key);
+}
+/** Unwraps optional/default/nullable wrappers down to the value schema. */
+function settingLeaf(schema) {
+    let current = schema;
+    for (let depth = 0; depth < 8; depth++) {
+        const type = current.def?.type;
+        if ((type === "optional" || type === "default" || type === "nullable") &&
+            current.def?.innerType)
+            current = current.def.innerType;
+        else
+            break;
+    }
+    return current;
+}
+/** Every settable key with its value kind (and enum options), for settings editors. */
+export function settableSettings() {
+    return Object.keys(SETTABLE_KEYS).map((key) => {
+        const leaf = settingLeaf(SETTABLE_KEYS[key]);
+        const type = leaf.def?.type;
+        if (type === "enum")
+            return { key, kind: "enum", options: (leaf.options ?? []).map((o) => String(o)) };
+        if (type === "boolean")
+            return { key, kind: "boolean" };
+        if (type === "number" || type === "int")
+            return { key, kind: "number" };
+        return { key, kind: "string" };
+    });
+}
+/**
+ * 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;
+    }
+    // Keys are `section.leaf` or `section.group.leaf`: every object on the path keeps its other fields.
+    const path = input.key.split(".");
+    const setPath = (target, depth) => {
+        const name = path[depth];
+        if (depth === path.length - 1)
+            return { ...target, [name]: parsed.data };
+        const child = target[name];
+        return {
+            ...target,
+            [name]: setPath(child && typeof child === "object" && !Array.isArray(child)
+                ? child
+                : {}, depth + 1),
+        };
+    };
+    raw = setPath(raw, 0);
+    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.js

@@ -116,6 +116,10 @@ function clampMessage(message, maxToolResultChars, maxTextChars) {
     let used = 0;
     let changed = false;
     const content = message.result.content.map((part) => {
+        // Only the text projection is clipped: ui/image parts are display-only transcript data and
+        // are never truncated (raw bytes never reach the model, which only sees the projection).
+        if (part.type !== "text")
+            return part;
         const room = maxToolResultChars - used;
         const text = room <= 0
             ? TRUNCATION_MARKER
@@ -213,7 +217,8 @@ export function reduceMessagesToBudget(messages, targetChars, options = {}) {
                     : m.role === "assistant"
                         ? m.text.length > textCap
                         : m.role === "tool" &&
-                            m.result.content.reduce((a, p) => a + p.text.length, 0) > toolCap;
+                            m.result.content.reduce((a, p) => a + (p.type === "text" ? p.text.length : 0), 0) >
+                                toolCap;
                 if (over) {
                     best = i;
                     bestSize = current;
@@ -260,7 +265,12 @@ export function serializeForSummary(messages, maxItemChars = 4_000) {
                 lines.push(`TOOL CALL ${c.id} ${c.name}: ${clip(c.arguments, maxItemChars)}`);
         }
         else {
-            const text = m.result.content.map((c) => c.text).join("\n");
+            // Only the text projection is summarized: ui/image parts are display data and never
+            // reach the summarizer (raw image bytes in particular stay out of the checkpoint).
+            const text = m.result.content
+                .filter((p) => p.type === "text")
+                .map((c) => c.text)
+                .join("\n");
             lines.push(`TOOL RESULT ${m.callId}${m.result.isError ? " (error)" : ""}: ${clip(text, maxItemChars)}`);
         }
     }
@@ -381,6 +391,7 @@ async function completeTextWithMeta(provider, request) {
         signal: request.signal,
         ...(request.model ? { model: request.model } : {}),
         ...(request.sessionId ? { sessionId: request.sessionId } : {}),
+        ...(request.reasoningEffort ? { reasoningEffort: request.reasoningEffort } : {}),
     })) {
         request.signal.throwIfAborted();
         if (event.type === "completed") {