@alisio/core 0.1.0-alpha.8 → 0.1.0

package/dist/commands/catalog.js

@@ -0,0 +1,304 @@
+import { agentCatalogFromState, agentCommandDescriptors, resolveActiveAgent, } from "../agents/active.js";
+import { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_USAGE, } from "../sessions/side-questions.js";
+import { BUILTIN_COMMANDS } from "./builtins.js";
+export { BUILTIN_COMMANDS };
+const builtinDescriptor = (c) => ({
+    name: c.name,
+    description: c.description,
+    ...(c.aliases ? { aliases: [...c.aliases] } : {}),
+    ...(c.argumentHint ? { argumentHint: c.argumentHint } : {}),
+    source: "builtin",
+    surfaces: [...c.surfaces],
+    execution: c.execution,
+});
+const ALL = ["tui", "web", "api"];
+/** Root sessions of this workspace bound to the current provider, newest first (as the TUI). */
+const workspaceSessions = (host) => host.store
+    .list()
+    .filter((s) => s.workspace === host.workspace && s.provider === host.provider.id);
+const firstPrompt = (host, id) => {
+    const first = host.store.messages(id).find((m) => m.role === "user" && !m.summary);
+    return first?.role === "user" ? first.text.replace(/\s+/g, " ").slice(0, 60) : "";
+};
+const HANDLERS = {
+    async tools(_args, _ctx, host) {
+        const policy = host.runner.policy;
+        const rows = host.registry
+            .list()
+            .map((t) => {
+            const effect = t.effect ?? "external";
+            const state = effect === "read" || effect === "internal" || policy[effect]
+                ? "enabled"
+                : host.runner.approvals && (effect === "write" || effect === "process")
+                    ? "ask"
+                    : "disabled";
+            return `| \`${t.name}\` | ${effect} | ${state} |`;
+        })
+            .join("\n");
+        return {
+            text: `**Tools**\n\n| Tool | Effect | State |\n| --- | --- | --- |\n${rows}\n\n\`ask\` prompts before running (allow once / session / deny). Use --allow-write / --allow-process to pre-allow; --read-only disables them. Paths outside the workspace ask per directory; pre-allow with --add-dir or the \`additionalDirectories\` config key. \`internal\` tools (built-in plugins) only write Alisio's own state.`,
+        };
+    },
+    async sessions(_args, ctx, host) {
+        const list = workspaceSessions(host).slice(0, 20);
+        if (!list.length)
+            return { text: "No sessions in this workspace", tone: "notice" };
+        return {
+            text: [
+                "**Recent sessions** (use `/resume <id-prefix>`)",
+                "",
+                ...list.map((s) => `- \`${s.id}\` ${s.id === ctx.sessionId ? "**(current)** " : ""}${s.model} · ${host.store.messages(s.id).length} msgs · ${firstPrompt(host, s.id) || "_empty_"}`),
+            ].join("\n"),
+            data: list,
+        };
+    },
+    async resume(args, _ctx, host) {
+        const target = args.trim();
+        if (!target)
+            throw new Error("Usage: /resume <id>");
+        const matches = workspaceSessions(host).filter((s) => s.id.startsWith(target));
+        if (matches.length !== 1)
+            throw new Error(matches.length
+                ? `Ambiguous session prefix: ${target}`
+                : `No session in this workspace matches ${target}`);
+        const found = matches[0];
+        return { text: `Resumed session ${found.id}`, tone: "notice", sessionId: found.id };
+    },
+    async clear(_args, ctx, host) {
+        const model = host.store.get(ctx.sessionId).model;
+        const created = host.store.create(host.workspace, host.provider.id, model);
+        return { text: `New session ${created.id}`, tone: "notice", sessionId: created.id };
+    },
+    async compact(args, ctx, host) {
+        const result = await host.runner.compact(ctx.sessionId, {
+            ...(args.trim() ? { focus: args.trim() } : {}),
+            ...(ctx.signal ? { signal: ctx.signal } : {}),
+        });
+        return result
+            ? {
+                text: `Compacted ${result.replaced} messages: ~${result.before} → ~${result.after} tokens`,
+                tone: "notice",
+                data: result,
+            }
+            : { text: "Not enough history to compact", tone: "notice" };
+    },
+    async model(args, ctx, host) {
+        const model = args.trim();
+        if (!model)
+            throw new Error("Usage: /model <model id>");
+        host.runner.setModel(ctx.sessionId, model);
+        return { text: `Model set to \`${model}\``, tone: "notice", data: { model } };
+    },
+    async effort(args, _ctx, host) {
+        const level = args.trim();
+        if (!level)
+            return {
+                text: `Reasoning effort: ${host.config?.agents.effort ?? "model default"}`,
+                tone: "notice",
+            };
+        if (!host.updateSetting)
+            throw new Error("Effort changes are unavailable here");
+        const value = level === "!clear" ? undefined : level;
+        await host.updateSetting("agents.effort", value);
+        return {
+            text: value ? `Reasoning effort set to ${value}` : "Reasoning effort cleared",
+            tone: "notice",
+            data: { effort: value },
+        };
+    },
+    async stats(_args, ctx, host) {
+        const session = host.store.get(ctx.sessionId);
+        const runs = host.store.runs?.(ctx.sessionId) ?? [];
+        const tokens = runs.reduce((sum, r) => ({
+            input: sum.input + (r.usage?.input ?? 0),
+            output: sum.output + (r.usage?.output ?? 0),
+        }), { input: 0, output: 0 });
+        return {
+            text: [
+                "**Session statistics**",
+                "",
+                `- Session: \`${session.id}\``,
+                `- Model: \`${session.model}\``,
+                `- Messages: ${host.store.messages(session.id).length}`,
+                `- Runs: ${runs.length}`,
+                `- Tokens: in ${tokens.input} · out ${tokens.output}`,
+            ].join("\n"),
+            data: { session, runs: runs.length, tokens },
+        };
+    },
+    async skills(_args, _ctx, host) {
+        const skills = host.skillCatalog?.() ?? [];
+        if (!skills.length)
+            return { text: "No skills found", tone: "notice" };
+        const state = (s) => s.effective ? "enabled" : s.shadowedBy ? `shadowed by ${s.shadowedBy}` : "disabled";
+        return {
+            text: `**Skills**\n\n| Skill | Scope | State |\n| --- | --- | --- |\n${skills
+                .map((s) => `| \`${s.displayId}\` | ${s.scope} | ${state(s)} |`)
+                .join("\n")}`,
+            data: skills,
+        };
+    },
+    async plugins(_args, _ctx, host) {
+        const plugins = host.pluginCatalog?.() ?? [];
+        if (!plugins.length)
+            return { text: "No plugins loaded", tone: "notice" };
+        return {
+            text: `**Plugins**\n\n| Plugin | Status | Enabled |\n| --- | --- | --- |\n${plugins
+                .map((p) => `| \`${p.id}\` | ${p.status} | ${p.enabled ? "yes" : "no"} |`)
+                .join("\n")}`,
+            data: plugins,
+        };
+    },
+    async mcps(_args, _ctx, host) {
+        const servers = host.mcp?.list() ?? [];
+        if (!servers.length)
+            return { text: "No MCP servers configured", tone: "notice" };
+        return {
+            text: `**MCP servers**\n\n| Server | Status | Tools |\n| --- | --- | --- |\n${servers
+                .map((s) => `| \`${s.name}\` | ${s.status} | ${s.counts.tools} |`)
+                .join("\n")}`,
+            data: servers,
+        };
+    },
+    async btw(args, ctx, host) {
+        const question = args.trim();
+        const side = host.sideQuestions;
+        if (!question) {
+            const history = side?.history(ctx.sessionId) ?? [];
+            const latest = history.at(-1);
+            if (!latest)
+                return {
+                    text: `${SIDE_QUESTION_USAGE}\n${SIDE_QUESTION_DESCRIPTION}`,
+                    tone: "notice",
+                    data: { history },
+                };
+            return {
+                text: formatSideQuestion(latest, history.length, history.length),
+                data: { history, entry: latest },
+            };
+        }
+        if (!side)
+            throw new Error("Side questions are unavailable here");
+        const entry = await side.ask(ctx.sessionId, question, ctx.signal ? { signal: ctx.signal } : {});
+        const total = side.history(ctx.sessionId).length;
+        return { text: formatSideQuestion(entry, total, total), data: { entry } };
+    },
+    async agents(args, ctx, host) {
+        // With arguments, `/agents <verb>` belongs to the subagents plugin's own command (as in the
+        // TUI); without them it lists the active-agent catalog.
+        const plugin = args.trim() ? host.plugins?.commands.get("agents") : undefined;
+        if (plugin)
+            return { text: await plugin(args.trim(), { sessionId: ctx.sessionId }) };
+        let state;
+        try {
+            state = host.plugins?.pluginState?.("subagents", "mainAgents");
+        }
+        catch {
+            /* agent contributions are best-effort */
+        }
+        const agents = agentCatalogFromState(state);
+        const active = resolveActiveAgent(agents, host.config?.agents.active);
+        return {
+            text: [
+                "**Agents**",
+                "",
+                ...agents.map((a) => `- **${a.name}**${a.id === active.id ? " (current)" : ""}${a.readOnly ? " · read-only" : ""} — ${a.description}`),
+            ].join("\n"),
+            data: { agents, active: active.id },
+        };
+    },
+};
+export class CommandCatalog {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    builtins() {
+        return BUILTIN_COMMANDS.map(builtinDescriptor);
+    }
+    /** Every descriptor (optionally for one surface). Precedence: builtin > plugin > prompt > skill. */
+    list(surface) {
+        const out = this.builtins();
+        const taken = new Set(out.flatMap((c) => [c.name, ...(c.aliases ?? [])]));
+        const push = (descriptor) => {
+            if (taken.has(descriptor.name))
+                return;
+            taken.add(descriptor.name);
+            out.push(descriptor);
+        };
+        const host = this.host;
+        if (host?.plugins)
+            for (const [name, info] of host.plugins.commandInfo)
+                push({
+                    name,
+                    description: info.description ?? `plugin ${info.plugin}`,
+                    ...(info.argumentHint ? { argumentHint: info.argumentHint } : {}),
+                    source: "plugin",
+                    owner: info.plugin,
+                    surfaces: [...ALL],
+                    execution: "core",
+                });
+        if (host?.prompts)
+            for (const template of host.prompts.templates.values())
+                push({
+                    name: template.name,
+                    description: template.description,
+                    ...(template.argumentHint ? { argumentHint: template.argumentHint } : {}),
+                    source: "prompt",
+                    owner: template.source,
+                    surfaces: [...ALL],
+                    execution: "surface",
+                });
+        for (const skill of host?.skillCatalog?.() ?? [])
+            if (skill.effective && skill.enabled)
+                push({
+                    name: `skill:${skill.id}`,
+                    description: skill.description,
+                    source: "skill",
+                    ...(skill.owner ? { owner: skill.owner.id } : {}),
+                    surfaces: [...ALL],
+                    execution: "surface",
+                });
+        // `/agent:<id>` activates a loaded agent (built-ins, project and global agent files).
+        if (host?.plugins) {
+            let state;
+            try {
+                state = host.plugins.pluginState?.("subagents", "mainAgents");
+            }
+            catch {
+                /* agent contributions are best-effort */
+            }
+            for (const descriptor of agentCommandDescriptors(agentCatalogFromState(state), taken))
+                push(descriptor);
+        }
+        return surface ? out.filter((c) => c.surfaces.includes(surface)) : out;
+    }
+    /** A command by name or alias (built-in names and aliases are case-insensitive). */
+    resolve(name) {
+        const lower = name.toLowerCase();
+        const all = this.list();
+        return (all.find((c) => c.source === "builtin" && (c.name === lower || c.aliases?.includes(lower))) ??
+            all.find((c) => c.source !== "builtin" && c.name === name));
+    }
+    /** Runs an `execution: "core"` command. Surface commands and unknown names throw. */
+    async execute(name, args, ctx) {
+        const descriptor = this.resolve(name);
+        if (!descriptor)
+            throw new Error(`Unknown command /${name}. Type /help.`);
+        if (descriptor.execution !== "core")
+            throw new Error(`/${descriptor.name} is handled by each surface, not by the core catalog`);
+        const host = this.host;
+        if (!host)
+            throw new Error(`/${descriptor.name} needs an application host`);
+        if (descriptor.source === "plugin") {
+            const handler = host.plugins?.commands.get(descriptor.name);
+            if (!handler)
+                throw new Error(`Unknown plugin command: ${descriptor.name}`);
+            return { text: await handler(args, { sessionId: ctx.sessionId }) };
+        }
+        const handler = HANDLERS[descriptor.name];
+        if (!handler)
+            throw new Error(`/${descriptor.name} has no core handler`);
+        return handler(args, ctx, host);
+    }
+}

package/dist/config.d.ts

@@ -12,6 +12,11 @@ declare const serverSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     url: z.ZodString;
     bearerTokenEnv: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>], "transport">;
+/**
+ * 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 declare const OCI_IMAGE_PATTERN: RegExp;
 export declare const configSchema: z.ZodPipe<z.ZodObject<{
     schemaVersion: z.ZodDefault<z.ZodLiteral<1>>;
     provider: z.ZodDefault<z.ZodObject<{
@@ -36,6 +41,7 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     }, z.core.$strict>>;
     plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
     skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    additionalDirectories: z.ZodDefault<z.ZodArray<z.ZodString>>;
     skillOverrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodBoolean;
     }, z.core.$strict>>>;
@@ -155,6 +161,7 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     websearch: z.ZodDefault<z.ZodObject<{
         provider: z.ZodOptional<z.ZodEnum<{
             brave: "brave";
+            "duckduckgo-html": "duckduckgo-html";
             "duckduckgo-instant": "duckduckgo-instant";
             native: "native";
             searxng: "searxng";
@@ -168,10 +175,71 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     limits: z.ZodDefault<z.ZodObject<{
         maxTurns: z.ZodDefault<z.ZodNumber>;
         timeoutMs: z.ZodDefault<z.ZodNumber>;
+        firstTokenTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        firstTokenRetries: z.ZodDefault<z.ZodNumber>;
+        truncationRecoveries: z.ZodDefault<z.ZodNumber>;
         maxContextChars: z.ZodDefault<z.ZodNumber>;
-        maxOutputTokens: z.ZodDefault<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    analysis: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        runtime: z.ZodDefault<z.ZodEnum<{
+            managed: "managed";
+            oci: "oci";
+        }>>;
+        oci: z.ZodDefault<z.ZodObject<{
+            engine: z.ZodDefault<z.ZodEnum<{
+                docker: "docker";
+                podman: "podman";
+            }>>;
+            image: z.ZodOptional<z.ZodString>;
+            memoryMb: z.ZodDefault<z.ZodNumber>;
+            cpus: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        limits: z.ZodDefault<z.ZodObject<{
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxFiles: z.ZodDefault<z.ZodNumber>;
+            maxFileBytes: z.ZodDefault<z.ZodNumber>;
+            maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+            maxLogBytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        data: z.ZodDefault<z.ZodObject<{
+            maxUploadBytes: z.ZodDefault<z.ZodNumber>;
+            maxRows: z.ZodDefault<z.ZodNumber>;
+            queryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxInteractiveRows: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        retention: z.ZodDefault<z.ZodObject<{
+            jobsDays: z.ZodDefault<z.ZodNumber>;
+            intermediateDays: z.ZodDefault<z.ZodNumber>;
+            artifactsDays: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    tasks: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxPerSession: z.ZodDefault<z.ZodNumber>;
+        maxRunMs: z.ZodDefault<z.ZodNumber>;
+        maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    goal: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxTurns: z.ZodDefault<z.ZodNumber>;
+        maxMinutes: z.ZodDefault<z.ZodNumber>;
+        repeatedReplyLimit: z.ZodDefault<z.ZodNumber>;
+        noToolTurnsLimit: z.ZodDefault<z.ZodNumber>;
+        blockedRepeats: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tui: z.ZodDefault<z.ZodObject<{
+        paddingX: z.ZodDefault<z.ZodNumber>;
+        contentPaddingX: z.ZodDefault<z.ZodNumber>;
+        skillSlashCommands: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    agents: z.ZodDefault<z.ZodObject<{
+        active: z.ZodDefault<z.ZodString>;
+        effort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodTransform<{
     schemaVersion: 1;
     provider: {
@@ -186,6 +254,7 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     };
     plugins: string[];
     skills: string[];
+    additionalDirectories: string[];
     skillOverrides: Record<string, {
         enabled: boolean;
     }>;
@@ -211,7 +280,7 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         maxOutputTokens: number;
     };
     websearch: {
-        provider?: "brave" | "duckduckgo-instant" | "native" | "searxng" | "serpapi" | "tavily" | undefined;
+        provider?: "brave" | "duckduckgo-html" | "duckduckgo-instant" | "native" | "searxng" | "serpapi" | "tavily" | undefined;
         searxngUrl?: string | undefined;
         apiKeyEnv?: string | undefined;
         nativeToolType: string;
@@ -219,10 +288,65 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     limits: {
         maxTurns: number;
         timeoutMs: number;
+        firstTokenTimeoutMs: number;
+        firstTokenRetries: number;
+        truncationRecoveries: number;
         maxContextChars: number;
-        maxOutputTokens: number;
+        maxOutputTokens?: number | undefined;
         maxTokens?: number | undefined;
     };
+    analysis: {
+        enabled: boolean;
+        runtime: "managed" | "oci";
+        oci: {
+            engine: "docker" | "podman";
+            image?: string | undefined;
+            memoryMb: number;
+            cpus: number;
+        };
+        limits: {
+            timeoutMs: number;
+            maxFiles: number;
+            maxFileBytes: number;
+            maxOutputBytes: number;
+            maxLogBytes: number;
+        };
+        data: {
+            maxUploadBytes: number;
+            maxRows: number;
+            queryTimeoutMs: number;
+            maxInteractiveRows: number;
+        };
+        retention: {
+            jobsDays: number;
+            intermediateDays: number;
+            artifactsDays: number;
+        };
+    };
+    tasks: {
+        enabled: boolean;
+        maxPerSession: number;
+        maxRunMs: number;
+        maxOutputBytes: number;
+        retentionDays: number;
+    };
+    goal: {
+        enabled: boolean;
+        maxTurns: number;
+        maxMinutes: number;
+        repeatedReplyLimit: number;
+        noToolTurnsLimit: number;
+        blockedRepeats: number;
+    };
+    tui: {
+        paddingX: number;
+        contentPaddingX: number;
+        skillSlashCommands: boolean;
+    };
+    agents: {
+        active: string;
+        effort?: string | undefined;
+    };
     mcp: {
         allow?: boolean | undefined;
         servers: {
@@ -267,6 +391,7 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     };
     plugins: string[];
     skills: string[];
+    additionalDirectories: string[];
     skillOverrides: Record<string, {
         enabled: boolean;
     }>;
@@ -345,7 +470,7 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         maxOutputTokens: number;
     };
     websearch: {
-        provider?: "brave" | "duckduckgo-instant" | "native" | "searxng" | "serpapi" | "tavily" | undefined;
+        provider?: "brave" | "duckduckgo-html" | "duckduckgo-instant" | "native" | "searxng" | "serpapi" | "tavily" | undefined;
         searxngUrl?: string | undefined;
         apiKeyEnv?: string | undefined;
         nativeToolType: string;
@@ -353,10 +478,65 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     limits: {
         maxTurns: number;
         timeoutMs: number;
+        firstTokenTimeoutMs: number;
+        firstTokenRetries: number;
+        truncationRecoveries: number;
         maxContextChars: number;
-        maxOutputTokens: number;
+        maxOutputTokens?: number | undefined;
         maxTokens?: number | undefined;
     };
+    analysis: {
+        enabled: boolean;
+        runtime: "managed" | "oci";
+        oci: {
+            engine: "docker" | "podman";
+            image?: string | undefined;
+            memoryMb: number;
+            cpus: number;
+        };
+        limits: {
+            timeoutMs: number;
+            maxFiles: number;
+            maxFileBytes: number;
+            maxOutputBytes: number;
+            maxLogBytes: number;
+        };
+        data: {
+            maxUploadBytes: number;
+            maxRows: number;
+            queryTimeoutMs: number;
+            maxInteractiveRows: number;
+        };
+        retention: {
+            jobsDays: number;
+            intermediateDays: number;
+            artifactsDays: number;
+        };
+    };
+    tasks: {
+        enabled: boolean;
+        maxPerSession: number;
+        maxRunMs: number;
+        maxOutputBytes: number;
+        retentionDays: number;
+    };
+    goal: {
+        enabled: boolean;
+        maxTurns: number;
+        maxMinutes: number;
+        repeatedReplyLimit: number;
+        noToolTurnsLimit: number;
+        blockedRepeats: number;
+    };
+    tui: {
+        paddingX: number;
+        contentPaddingX: number;
+        skillSlashCommands: boolean;
+    };
+    agents: {
+        active: string;
+        effort?: string | undefined;
+    };
 }>>;
 export type Config = z.infer<typeof configSchema>;
 export type ServerConfig = z.infer<typeof serverSchema>;
@@ -374,6 +554,8 @@ export interface ConfigProvenance {
         kind: "project" | "explicit";
         hasLegacyProvider: boolean;
     };
+    /** Keys a project or explicit layer set that only the global layer may decide (ignored). */
+    ignored?: string[];
 }
 export interface ConfigLoadResult {
     config: LoadedConfig;
@@ -416,6 +598,71 @@ 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.ZodOptional<z.ZodNumber>;
+    readonly "limits.maxContextChars": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.firstTokenTimeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.firstTokenRetries": z.ZodDefault<z.ZodNumber>;
+    readonly "limits.truncationRecoveries": z.ZodDefault<z.ZodNumber>;
+    readonly "pluginHooks.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "tui.paddingX": z.ZodDefault<z.ZodNumber>;
+    readonly "tui.contentPaddingX": z.ZodDefault<z.ZodNumber>;
+    readonly "tui.skillSlashCommands": z.ZodDefault<z.ZodBoolean>;
+    readonly "websearch.provider": z.ZodOptional<z.ZodEnum<{
+        brave: "brave";
+        "duckduckgo-html": "duckduckgo-html";
+        "duckduckgo-instant": "duckduckgo-instant";
+        native: "native";
+        searxng: "searxng";
+        serpapi: "serpapi";
+        tavily: "tavily";
+    }>>;
+    readonly "agents.active": z.ZodDefault<z.ZodString>;
+    readonly "agents.effort": z.ZodOptional<z.ZodString>;
+    readonly "analysis.enabled": z.ZodDefault<z.ZodBoolean>;
+    readonly "analysis.limits.timeoutMs": z.ZodDefault<z.ZodNumber>;
+    readonly "analysis.retention.jobsDays": z.ZodDefault<z.ZodNumber>;
+    readonly "analysis.retention.intermediateDays": z.ZodDefault<z.ZodNumber>;
+    readonly "analysis.retention.artifactsDays": z.ZodDefault<z.ZodNumber>;
+    readonly "tasks.enabled": z.ZodDefault<z.ZodBoolean>;
+    readonly "tasks.maxPerSession": z.ZodDefault<z.ZodNumber>;
+    readonly "tasks.maxRunMs": z.ZodDefault<z.ZodNumber>;
+    readonly "tasks.maxOutputBytes": z.ZodDefault<z.ZodNumber>;
+    readonly "tasks.retentionDays": z.ZodDefault<z.ZodNumber>;
+    readonly "goal.enabled": z.ZodDefault<z.ZodBoolean>;
+    readonly "goal.maxTurns": z.ZodDefault<z.ZodNumber>;
+    readonly "goal.maxMinutes": z.ZodDefault<z.ZodNumber>;
+    readonly "goal.repeatedReplyLimit": z.ZodDefault<z.ZodNumber>;
+    readonly "goal.noToolTurnsLimit": z.ZodDefault<z.ZodNumber>;
+    readonly "goal.blockedRepeats": z.ZodDefault<z.ZodNumber>;
+};
+export type SettableSettingKey = keyof typeof SETTABLE_KEYS;
+export declare function isSettableSettingKey(key: string): key is SettableSettingKey;
+export interface SettableSettingInfo {
+    key: SettableSettingKey;
+    kind: "boolean" | "number" | "string" | "enum";
+    options?: string[];
+}
+/** Every settable key with its value kind (and enum options), for settings editors. */
+export declare function settableSettings(): SettableSettingInfo[];
+/**
+ * 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;