@alisio/core 0.1.0-alpha.9 → 0.1.0

package/README.md

@@ -1,9 +1,24 @@
 # @alisio/core
 
-Embeddable core of [Alisio](https://github.com/GustavoGutierrez/alisio): the agent tool loop, structured
-context compaction, the OpenAI-compatible provider (Chat Completions and Responses), local tools with
-explicit permissions, the MCP client, the plugin host (with hook timeouts and failure isolation) and a
-SQLite session store. Runs on Node.js >= 22.16 (`node:sqlite` with FTS5) and on Bun.
+**The embeddable core of [Alisio](https://github.com/GustavoGutierrez/alisio): a provider-agnostic
+agent you can drive from your own program.** No TUI, no CLI — just the tool loop, compaction, MCP
+and plugin host as a library.
+
+## What it is
+
+`@alisio/core` wires the agent tool loop, structured context compaction, the OpenAI-compatible
+provider (Chat Completions and Responses), local tools behind explicit permissions, the MCP client,
+the plugin host (hook timeouts and failure isolation) and a SQLite session store into one
+`createApplication` entry point. It runs on Node.js >= 22.16 (`node:sqlite` with FTS5) and on Bun,
+and uses only portable Node APIs.
+
+## Installation
+
+```sh
+npm i @alisio/core        # or: pnpm add @alisio/core · bun add @alisio/core
+```
+
+## Quick start
 
 ```ts
 import { createApplication } from "@alisio/core";
@@ -18,8 +33,38 @@ try {
 }
 ```
 
+## What you get
+
+- **Runner**: `AgentRunner` with turn limits, timeouts, token budgets and versioned `RunEvent`
+  output (`schemaVersion: 1`).
+- **Context compaction**: `planCompaction`, `summarize`, `renderCheckpoint`,
+  `shouldCompactContext` and checkpoint helpers; memory plugins hook in via `CompactionHooks`.
+- **Providers**: `ProviderRegistry` / `ActiveProvider` for OpenAI-compatible, DeepSeek, OpenCode
+  Console and OpenCode Go; `ProviderSettingsStore` for non-secret profiles plus a separate
+  credentials store.
+- **Local tools**: reads by default, `--allow-write`/`--allow-process`-style policy, path checks
+  and standard tools (`ToolRegistry`, `registerStandard`).
+- **MCP**: `McpConnector`, server discovery and tool projection.
+- **Plugin host**: `PluginHost` with built-in plugin catalogs, npm install (`installPlugin`,
+  `cliInstall`), hook timeouts and failure isolation.
+- **Sessions**: `SQLiteStore` with reconciliation and crash recovery.
+- **Skills and prompts**: `Skills`, `ProjectContext` (`AGENTS.md`), `loadPromptTemplates`.
+- **Trust**: `resolveTrust` / `setTrust` / `listTrust` for per-directory project trust.
+- **Startup screen**: reusable `renderStartup` sections and the default mascot.
+
 Built-in plugins are opt-in for embedders: pass `builtins` (the `alisio` CLI wires
-`@alisio/plugin-memory`). See the [architecture](https://gustavogutierrez.github.io/alisio/architecture) and
-[configuration](https://gustavogutierrez.github.io/alisio/configuration) docs.
+`@alisio/plugin-memory` and `@alisio/plugin-subagents`).
+
+## Docs
+
+Architecture: <https://gustavogutierrez.github.io/alisio/architecture> ·
+Configuration: <https://gustavogutierrez.github.io/alisio/configuration>.
+
+## Requirements
+
+Node.js **>= 22.16** or Bun **>= 1.4.2**.
+
+## License
 
-Maintainer: Gustavo Gutiérrez · License: MIT
+MIT. Maintained by Gustavo Gutiérrez Mercado. Source: <https://github.com/GustavoGutierrez/alisio> ·
+npm: <https://www.npmjs.com/settings/alisio/packages>.

package/dist/agents/active.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Pure logic for the ACTIVE (main-session) agent: the built-in catalog, user/plugin
+ * contributions, resolution and the per-run options an agent implies. No terminal or pi-tui
+ * imports here — the Picker and status-line rendering live in each surface (e.g. the TUI shell).
+ *
+ * The active agent drives the MAIN session (its `instructions` are appended per run and an
+ * agent-specific `model` is offered on selection). This is deliberately separate from the
+ * delegated child-session agents of the subagents plugin: a subagent definition becomes a main
+ * agent only when it is marked main-capable (`mode: primary|all`), which the subagents plugin
+ * publishes for the host to read.
+ */
+import type { CommandDescriptor } from "@alisio/sdk";
+export interface ActiveAgent {
+    /** Stable id, also the persisted `agents.active` value. */
+    id: string;
+    name: string;
+    description: string;
+    /** System prompt appended to the main session's instructions on every run. */
+    instructions?: string;
+    /** Optional default model selector (`provider/model` or an unambiguous model id). */
+    model?: string;
+    /** Read-only agents run with write/process/external tools disabled and approvals off. */
+    readOnly?: boolean;
+    /** Default reasoning effort (`alisio.reasoning.effort`); an explicit session/user effort wins. */
+    effort?: string;
+    /** Definition file of a contributed agent (shows its Project/Global scope). */
+    path?: string;
+    /** Product built-ins are shown as built-in and never shadowed by contributed definitions. */
+    source: "builtin" | "user" | "plugin";
+}
+export declare const DEFAULT_AGENT_ID = "build";
+export declare const PLAN_AGENT_ID = "plan";
+/** Product built-ins. `build` keeps the CURRENT behavior exactly: no added persona, full power. */
+export declare const BUILTIN_AGENTS: ActiveAgent[];
+export interface MainCapableAgentRecord {
+    name: string;
+    description: string;
+    prompt: string;
+    model?: string;
+    readOnly?: boolean;
+    effort?: string;
+    source: string;
+    path?: string;
+}
+/** Maps a main-capable definition published by the subagents plugin to an active agent. */
+export declare function mainAgentFromRecord(record: MainCapableAgentRecord): ActiveAgent;
+/** Builds the selectable catalog from the subagents plugin's published state (best-effort). */
+export declare function agentCatalogFromState(untrusted: unknown): ActiveAgent[];
+/**
+ * The full selectable catalog: built-ins first, then contributed main-capable definitions.
+ * A contributed definition may never shadow a built-in id; later duplicates of a contributed id
+ * are dropped (the subagents plugin already resolved precedence by its own discovery order).
+ */
+export declare function activeAgentCatalog(contributions?: ActiveAgent[]): ActiveAgent[];
+/**
+ * The agents Shift+Tab (and the web selector) cycles through, in a STABLE order: `build`, then
+ * `plan`, then every other main-capable agent (`mode: primary|all`) by name. The catalog order of
+ * contributed agents follows plugin discovery and is not stable across reloads, so cycling never
+ * relies on it. Duplicated ids are dropped.
+ */
+export declare function cycleableAgents(agents: ActiveAgent[]): ActiveAgent[];
+/**
+ * The agent after (`step` 1) or before (`step` -1) `currentId` in the cycle, wrapping around. An
+ * unknown current id starts the cycle at its first agent (`build`). An empty list yields undefined.
+ */
+export declare function nextAgent(agents: ActiveAgent[], currentId: string | undefined, step?: 1 | -1): ActiveAgent | undefined;
+/** Resolves the persisted agent id; unknown ids fall back to the built-in default (`build`). */
+export declare function resolveActiveAgent(agents: ActiveAgent[], id: string | undefined): ActiveAgent;
+/** The run options an active agent implies. An undefined agent yields the current behavior. */
+export declare function agentRunOptions(agent: ActiveAgent | undefined): {
+    instructions?: string;
+    policy?: {
+        write: false;
+        process: false;
+        external: false;
+    };
+    approvals?: false;
+    reasoningEffort?: string;
+    optInTools?: string[];
+};
+/**
+ * Every loaded agent is also a slash command `/agent:<id>` that activates it. The `agent:`
+ * namespace keeps these commands from ever colliding with built-ins, plugin commands, prompt
+ * templates or `skill:<id>` entries; when a higher-precedence source already owns the exact name
+ * (e.g. a plugin with id `agent`), the agent command is skipped.
+ */
+export declare const AGENT_COMMAND_PREFIX = "agent:";
+export declare const agentCommandName: (id: string) => string;
+/** The agent id a `/agent:<id>` command names, or undefined for any other command. */
+export declare function agentIdFromCommand(name: string): string | undefined;
+/** `/agent:<id>` descriptors for `agents`, skipping names already in `taken`. */
+export declare function agentCommandDescriptors(agents: ActiveAgent[], taken?: ReadonlySet<string>): CommandDescriptor[];
+export interface AgentPickerItem {
+    value: string;
+    label: string;
+    description: string;
+}
+/** Picker rows for `/agents`: name with (current), built-in/default and read-only markers. */
+export declare function agentPickerItems(agents: ActiveAgent[], activeId: string): AgentPickerItem[];

package/dist/agents/active.js

@@ -0,0 +1,218 @@
+import { EXIT_PLAN_TOOL } from "../core/opt-in.js";
+export const DEFAULT_AGENT_ID = "build";
+export const PLAN_AGENT_ID = "plan";
+const PLAN_INSTRUCTIONS = `You are the "plan" agent: a read-only planning assistant for this main session.
+
+Your job is analysis and planning only. Investigate the repository with read-only tools
+(list_files, search_text, read_file, git_status, git_diff) and return a concrete, ordered plan:
+files to change, functions to touch, risks and verification steps. You may run context and
+inspection tools that do not modify anything.
+
+You never edit, write or delete files, and you never start processes that change the workspace
+or the network. If a task requires changes, hand back a precise plan (and the exact commands)
+instead of making them. You do not implement the plan yourself, even when the user approves it:
+approval hands the plan to the build agent.
+
+When the plan is complete, finish by calling \`exit_plan\` exactly once with the whole plan in
+Markdown (and a short \`title\`). Do not paste the plan in your reply first: exit_plan shows it to
+the user and asks for a decision. Write the plan with these sections, in this order:
+
+# <Title>
+## Goal
+What will be true when this is done, in one or two sentences.
+## Context
+What you found in the repository that the plan relies on (files, functions, conventions).
+## Steps
+A numbered, ordered list. Each step names the files and functions to change and what changes.
+## Risks
+What could go wrong, what is uncertain, and what you did not verify.
+## Verification
+The exact commands and checks that prove the work is done.
+
+Read the tool result: "approved" means the build agent will implement the plan, so reply with one
+short sentence and stop. "skipped" means stay in plan mode and do not call exit_plan again unless
+asked. "feedback" carries extra context from the user: revise the plan and call exit_plan again
+with the complete updated plan.`;
+/** Product built-ins. `build` keeps the CURRENT behavior exactly: no added persona, full power. */
+export const BUILTIN_AGENTS = [
+    {
+        id: DEFAULT_AGENT_ID,
+        name: "build",
+        description: "Default full-power agent: edits code and files, runs processes and verifies its work through the normal permission flow.",
+        source: "builtin",
+    },
+    {
+        id: PLAN_AGENT_ID,
+        name: "plan",
+        description: "Read-only planning agent: analyzes the codebase and returns an implementation plan without modifying anything.",
+        instructions: PLAN_INSTRUCTIONS,
+        readOnly: true,
+        source: "builtin",
+    },
+];
+/** Maps a main-capable definition published by the subagents plugin to an active agent. */
+export function mainAgentFromRecord(record) {
+    const source = String(record.source ?? "");
+    return {
+        id: record.name,
+        name: record.name,
+        description: record.description,
+        ...(record.prompt ? { instructions: record.prompt } : {}),
+        ...(record.model ? { model: record.model } : {}),
+        ...(record.readOnly ? { readOnly: true } : {}),
+        ...(typeof record.effort === "string" && record.effort ? { effort: record.effort } : {}),
+        ...(typeof record.path === "string" && record.path ? { path: record.path } : {}),
+        ...(source.startsWith("plugin:")
+            ? { source: "plugin" }
+            : { source: "user" }),
+    };
+}
+/** Builds the selectable catalog from the subagents plugin's published state (best-effort). */
+export function agentCatalogFromState(untrusted) {
+    if (!Array.isArray(untrusted))
+        return activeAgentCatalog([]);
+    const records = untrusted.filter((entry) => !!entry &&
+        typeof entry === "object" &&
+        typeof entry.name === "string" &&
+        typeof entry.description === "string" &&
+        entry.description.length > 0 &&
+        typeof entry.prompt === "string");
+    return activeAgentCatalog(records.map(mainAgentFromRecord));
+}
+/**
+ * The full selectable catalog: built-ins first, then contributed main-capable definitions.
+ * A contributed definition may never shadow a built-in id; later duplicates of a contributed id
+ * are dropped (the subagents plugin already resolved precedence by its own discovery order).
+ */
+export function activeAgentCatalog(contributions = []) {
+    const seen = new Set();
+    const out = [];
+    for (const agent of [...BUILTIN_AGENTS, ...contributions]) {
+        if (seen.has(agent.id))
+            continue;
+        seen.add(agent.id);
+        out.push(agent);
+    }
+    return out;
+}
+/**
+ * The agents Shift+Tab (and the web selector) cycles through, in a STABLE order: `build`, then
+ * `plan`, then every other main-capable agent (`mode: primary|all`) by name. The catalog order of
+ * contributed agents follows plugin discovery and is not stable across reloads, so cycling never
+ * relies on it. Duplicated ids are dropped.
+ */
+export function cycleableAgents(agents) {
+    const builtinRank = new Map(BUILTIN_AGENTS.map((agent, index) => [agent.id, index]));
+    const seen = new Set();
+    const unique = agents.filter((agent) => {
+        if (seen.has(agent.id))
+            return false;
+        seen.add(agent.id);
+        return true;
+    });
+    const byName = (a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()) || a.id.localeCompare(b.id);
+    return [
+        ...unique
+            .filter((agent) => builtinRank.has(agent.id))
+            .sort((a, b) => (builtinRank.get(a.id) ?? 0) - (builtinRank.get(b.id) ?? 0)),
+        ...unique.filter((agent) => !builtinRank.has(agent.id)).sort(byName),
+    ];
+}
+/**
+ * The agent after (`step` 1) or before (`step` -1) `currentId` in the cycle, wrapping around. An
+ * unknown current id starts the cycle at its first agent (`build`). An empty list yields undefined.
+ */
+export function nextAgent(agents, currentId, step = 1) {
+    const cycle = cycleableAgents(agents);
+    if (!cycle.length)
+        return undefined;
+    const index = cycle.findIndex((agent) => agent.id === currentId);
+    if (index < 0)
+        return cycle[0];
+    return cycle[(index + step + cycle.length) % cycle.length];
+}
+/** Resolves the persisted agent id; unknown ids fall back to the built-in default (`build`). */
+export function resolveActiveAgent(agents, id) {
+    const found = id ? agents.find((a) => a.id === id) : undefined;
+    if (found)
+        return found;
+    return agents.find((a) => a.id === DEFAULT_AGENT_ID) ?? agents[0] ?? BUILTIN_AGENTS[0];
+}
+/** The run options an active agent implies. An undefined agent yields the current behavior. */
+export function agentRunOptions(agent) {
+    if (!agent)
+        return {};
+    return {
+        ...(agent.instructions ? { instructions: agent.instructions } : {}),
+        // `exit_plan` exists for the built-in plan agent only (it is hidden from every other run).
+        ...(agent.id === PLAN_AGENT_ID && agent.source === "builtin"
+            ? { optInTools: [EXIT_PLAN_TOOL] }
+            : {}),
+        ...(agent.effort ? { reasoningEffort: agent.effort } : {}),
+        ...(agent.readOnly
+            ? {
+                policy: { write: false, process: false, external: false },
+                approvals: false,
+            }
+            : {}),
+    };
+}
+/**
+ * Every loaded agent is also a slash command `/agent:<id>` that activates it. The `agent:`
+ * namespace keeps these commands from ever colliding with built-ins, plugin commands, prompt
+ * templates or `skill:<id>` entries; when a higher-precedence source already owns the exact name
+ * (e.g. a plugin with id `agent`), the agent command is skipped.
+ */
+export const AGENT_COMMAND_PREFIX = "agent:";
+const COMMAND_SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+export const agentCommandName = (id) => `${AGENT_COMMAND_PREFIX}${id}`;
+/** The agent id a `/agent:<id>` command names, or undefined for any other command. */
+export function agentIdFromCommand(name) {
+    if (!name.startsWith(AGENT_COMMAND_PREFIX))
+        return undefined;
+    const id = name.slice(AGENT_COMMAND_PREFIX.length);
+    return COMMAND_SAFE_ID.test(id) ? id : undefined;
+}
+/** `/agent:<id>` descriptors for `agents`, skipping names already in `taken`. */
+export function agentCommandDescriptors(agents, taken = new Set()) {
+    const out = [];
+    const seen = new Set(taken);
+    for (const agent of agents) {
+        if (!COMMAND_SAFE_ID.test(agent.id))
+            continue;
+        const name = agentCommandName(agent.id);
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        out.push({
+            name,
+            description: `Activate the ${agent.name} agent${agent.id === DEFAULT_AGENT_ID ? " (default)" : ""}: ${agent.description}`,
+            source: "agent",
+            owner: agent.source,
+            surfaces: ["tui", "web", "api"],
+            execution: "surface",
+        });
+    }
+    return out;
+}
+/** Picker rows for `/agents`: name with (current), built-in/default and read-only markers. */
+export function agentPickerItems(agents, activeId) {
+    return agents.map((agent) => ({
+        value: agent.id,
+        label: [
+            agent.name,
+            agent.id === activeId ? "(current)" : undefined,
+            agent.id === DEFAULT_AGENT_ID ? "(default)" : undefined,
+            agent.readOnly ? "read-only" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" · "),
+        description: [
+            agent.description,
+            agent.model ? `default model: ${agent.model}` : undefined,
+            agent.instructions ? "injects its system prompt from the next prompt" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" · "),
+    }));
+}

package/dist/agents/capabilities.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Capability-driven agent settings: which reasoning, summary, verbosity and text-format options a
+ * model supports, derived only from its catalog metadata (`ModelInfo.effort`, `inputModalities`,
+ * `capabilities`). Providers that declare nothing (most OpenAI-compatible `GET /models` answers)
+ * get a permissive default: every option is offered and `known` is false, so surfaces can say the
+ * support is unverified. Explicit `false` metadata always hides an option.
+ */
+import type { AgentDefinitionInput, AgentModelCapabilities, AgentModelOption, AvailableProviderModel, ModelInfo } from "@alisio/sdk";
+/** Levels offered when a reasoning model does not list its own. */
+export declare const DEFAULT_EFFORT_LEVELS: string[];
+/** What `model` supports for the agent editor (permissive when the catalog says nothing). */
+export declare function agentModelCapabilities(model: ModelInfo | undefined): AgentModelCapabilities;
+/** Short labels such as "Reasoning · Tools · Vision", only for declared support. */
+export declare function agentModelLabels(capabilities: AgentModelCapabilities): string[];
+/** The editor's model options from the configured catalogs; `active` marks the running model. */
+export declare function agentModelOptions(available: AvailableProviderModel[], active?: {
+    profile?: string;
+    provider?: string;
+    model: string;
+}): AgentModelOption[];
+/**
+ * Drops or replaces settings `capabilities` does not support: unsupported reasoning settings are
+ * removed, an unknown effort level falls back to the model default (or is removed), an unsupported
+ * text format becomes `text`, unsupported verbosity is removed.
+ */
+export declare function fitAgentSettings<T extends Pick<AgentDefinitionInput, "reasoning" | "text">>(settings: T, capabilities: AgentModelCapabilities): T;

package/dist/agents/capabilities.js

@@ -0,0 +1,120 @@
+/** Levels offered when a reasoning model does not list its own. */
+export const DEFAULT_EFFORT_LEVELS = ["low", "medium", "high"];
+const flag = (capabilities, keys) => {
+    if (!capabilities)
+        return undefined;
+    for (const key of keys) {
+        const value = capabilities[key];
+        if (typeof value === "boolean")
+            return value;
+        if (value === "true" || value === "supported")
+            return true;
+        if (value === "false" || value === "unsupported")
+            return false;
+    }
+    return undefined;
+};
+/** What `model` supports for the agent editor (permissive when the catalog says nothing). */
+export function agentModelCapabilities(model) {
+    const caps = model?.capabilities;
+    const levels = model?.effort?.supportedLevels?.filter(Boolean) ?? [];
+    const declaredReasoning = flag(caps, ["reasoning", "reasoning_effort", "thinking"]);
+    const reasoning = levels.length > 0 || declaredReasoning !== false;
+    const summary = reasoning && flag(caps, ["reasoning_summary", "reasoningSummary"]) !== false;
+    const verbosity = flag(caps, ["verbosity", "text_verbosity"]) !== false;
+    const json = flag(caps, ["json_mode", "json_object", "response_format"]);
+    const schema = flag(caps, ["structured_outputs", "json_schema", "structuredOutputs"]);
+    const textFormats = ["text"];
+    if (json !== false)
+        textFormats.push("json_object");
+    if (schema !== false)
+        textFormats.push("json_schema");
+    const tools = flag(caps, ["tools", "tool_calling", "function_calling", "toolCalling"]);
+    const vision = model?.inputModalities?.includes("image") ||
+        model?.modalities?.includes("image") ||
+        flag(caps, ["vision", "image_input"]) === true
+        ? true
+        : flag(caps, ["vision", "image_input"]);
+    const known = !!levels.length ||
+        !!model?.inputModalities?.length ||
+        !!model?.modalities?.length ||
+        !!(caps && Object.keys(caps).length);
+    return {
+        known,
+        reasoning,
+        effortLevels: reasoning ? (levels.length ? levels : DEFAULT_EFFORT_LEVELS) : [],
+        ...(reasoning && model?.effort?.defaultLevel
+            ? { defaultEffort: model.effort.defaultLevel }
+            : {}),
+        summary,
+        verbosity,
+        textFormats,
+        ...(tools !== undefined ? { tools } : {}),
+        ...(vision !== undefined ? { vision } : {}),
+    };
+}
+/** Short labels such as "Reasoning · Tools · Vision", only for declared support. */
+export function agentModelLabels(capabilities) {
+    if (!capabilities.known)
+        return [];
+    return [
+        capabilities.reasoning ? "Reasoning" : undefined,
+        capabilities.tools ? "Tools" : undefined,
+        capabilities.vision ? "Vision" : undefined,
+        capabilities.textFormats.includes("json_schema") ? "Structured output" : undefined,
+    ].filter((label) => !!label);
+}
+/** The editor's model options from the configured catalogs; `active` marks the running model. */
+export function agentModelOptions(available, active) {
+    return available.map((entry) => {
+        const capabilities = agentModelCapabilities(entry.model);
+        return {
+            reference: entry.reference,
+            provider: entry.provider,
+            profile: entry.profile,
+            providerName: entry.providerName,
+            id: entry.model.id,
+            ...(entry.model.name ? { name: entry.model.name } : {}),
+            active: !!active &&
+                entry.model.id === active.model &&
+                (active.profile ? entry.profile === active.profile : entry.provider === active.provider),
+            capabilities,
+            labels: agentModelLabels(capabilities),
+        };
+    });
+}
+/**
+ * Drops or replaces settings `capabilities` does not support: unsupported reasoning settings are
+ * removed, an unknown effort level falls back to the model default (or is removed), an unsupported
+ * text format becomes `text`, unsupported verbosity is removed.
+ */
+export function fitAgentSettings(settings, capabilities) {
+    const reasoning = { ...(settings.reasoning ?? {}) };
+    if (!capabilities.reasoning) {
+        delete reasoning.effort;
+        delete reasoning.summary;
+    }
+    else if (reasoning.effort && !capabilities.effortLevels.includes(reasoning.effort)) {
+        if (capabilities.defaultEffort)
+            reasoning.effort = capabilities.defaultEffort;
+        else
+            delete reasoning.effort;
+    }
+    if (!capabilities.summary)
+        delete reasoning.summary;
+    const text = { ...(settings.text ?? {}) };
+    if (text.format && !capabilities.textFormats.includes(text.format.type))
+        text.format = { type: "text" };
+    if (!capabilities.verbosity)
+        delete text.verbosity;
+    const out = { ...settings };
+    if (Object.keys(reasoning).length)
+        out.reasoning = reasoning;
+    else
+        delete out.reasoning;
+    if (Object.keys(text).length)
+        out.text = text;
+    else
+        delete out.text;
+    return out;
+}

package/dist/agents/create-agent-skill.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The bundled `create-agent` skill: agent-authoring standards the ACTIVE model follows when it
+ * writes or refines an agent's instructions (assisted creation in the web Agents window and the
+ * TUI `/agents` manager). A user or project skill named `create-agent` (or `agent-creator`)
+ * replaces it, so teams can encode their own conventions.
+ */
+/** Skill names that override the bundled guidance, in order of preference. */
+export declare const AGENT_AUTHORING_SKILL_NAMES: readonly ["create-agent", "agent-creator"];
+export declare const CREATE_AGENT_SKILL = "---\nname: create-agent\ndescription: Standards for writing the system prompt (instructions) of an Alisio agent.\n---\n# Writing agent instructions\n\nAn agent's instructions are its system prompt. They are read on every turn, so every line must\nearn its place. Write them in Markdown, in the second person (\"You ...\"), in English unless the\nuser asks otherwise.\n\n## Required sections\n\n1. **Role** \u2014 one or two sentences: who the agent is and who it serves.\n2. **Goal** \u2014 the outcome a successful turn produces, stated so it can be checked.\n3. **Scope** \u2014 what the agent handles and, explicitly, what it must decline or hand back.\n4. **How to work** \u2014 an ordered method for the typical task (investigate, act, verify, report).\n5. **Tool usage** \u2014 when to read, search, edit or run processes; prefer reading before editing;\n   verify changes (tests, type checks) before claiming success; ask before destructive,\n   irreversible or external actions (deleting data, deploying, spending money, contacting people).\n6. **Constraints** \u2014 hard rules: safety, privacy, secrets never echoed, repository conventions,\n   performance or style limits. Phrase them as testable rules, not vague values.\n7. **Output format** \u2014 the exact shape of the final answer (headings, lists, tables, JSON keys,\n   length). Match the agent's text format setting.\n8. **Examples** (optional) \u2014 one short input \u2192 output pair when the format or tone is unusual.\n\n## Quality bar\n\n- Be specific to the described job; remove generic filler (\"be helpful\", \"be accurate\").\n- Prefer short imperative bullets over paragraphs. Target 150\u2013600 words.\n- Never invent tools, files, APIs or data the agent does not have; tell it to say when it lacks\n  information instead of guessing.\n- Keep the agent honest: report what was verified and what was not.\n- When refining an existing definition, keep what already works, apply the user's requested\n  changes, and fill any missing required section.\n\n## Settings to suggest\n\n- Reasoning effort: `high` for analysis, debugging, security or multi-step refactors; `medium`\n  for general engineering; `low` for formatting, summaries and support replies.\n- Reasoning summary: `auto` by default; `none` for short conversational agents; `detailed` when\n  the user audits the reasoning.\n- Verbosity: `low` for terse operational agents, `medium` by default, `high` for reports.\n- Text format: `text` unless the agent must return machine-readable output (`json_object`,\n  or `json_schema` when a strict schema is given).\n";
+/** The skill body without the loader preamble and frontmatter (what is sent as guidance). */
+export declare function skillBody(text: string): string;

package/dist/agents/create-agent-skill.js

@@ -0,0 +1,60 @@
+/**
+ * The bundled `create-agent` skill: agent-authoring standards the ACTIVE model follows when it
+ * writes or refines an agent's instructions (assisted creation in the web Agents window and the
+ * TUI `/agents` manager). A user or project skill named `create-agent` (or `agent-creator`)
+ * replaces it, so teams can encode their own conventions.
+ */
+/** Skill names that override the bundled guidance, in order of preference. */
+export const AGENT_AUTHORING_SKILL_NAMES = ["create-agent", "agent-creator"];
+export const CREATE_AGENT_SKILL = `---
+name: create-agent
+description: Standards for writing the system prompt (instructions) of an Alisio agent.
+---
+# Writing agent instructions
+
+An agent's instructions are its system prompt. They are read on every turn, so every line must
+earn its place. Write them in Markdown, in the second person ("You ..."), in English unless the
+user asks otherwise.
+
+## Required sections
+
+1. **Role** — one or two sentences: who the agent is and who it serves.
+2. **Goal** — the outcome a successful turn produces, stated so it can be checked.
+3. **Scope** — what the agent handles and, explicitly, what it must decline or hand back.
+4. **How to work** — an ordered method for the typical task (investigate, act, verify, report).
+5. **Tool usage** — when to read, search, edit or run processes; prefer reading before editing;
+   verify changes (tests, type checks) before claiming success; ask before destructive,
+   irreversible or external actions (deleting data, deploying, spending money, contacting people).
+6. **Constraints** — hard rules: safety, privacy, secrets never echoed, repository conventions,
+   performance or style limits. Phrase them as testable rules, not vague values.
+7. **Output format** — the exact shape of the final answer (headings, lists, tables, JSON keys,
+   length). Match the agent's text format setting.
+8. **Examples** (optional) — one short input → output pair when the format or tone is unusual.
+
+## Quality bar
+
+- Be specific to the described job; remove generic filler ("be helpful", "be accurate").
+- Prefer short imperative bullets over paragraphs. Target 150–600 words.
+- Never invent tools, files, APIs or data the agent does not have; tell it to say when it lacks
+  information instead of guessing.
+- Keep the agent honest: report what was verified and what was not.
+- When refining an existing definition, keep what already works, apply the user's requested
+  changes, and fill any missing required section.
+
+## Settings to suggest
+
+- Reasoning effort: \`high\` for analysis, debugging, security or multi-step refactors; \`medium\`
+  for general engineering; \`low\` for formatting, summaries and support replies.
+- Reasoning summary: \`auto\` by default; \`none\` for short conversational agents; \`detailed\` when
+  the user audits the reasoning.
+- Verbosity: \`low\` for terse operational agents, \`medium\` by default, \`high\` for reports.
+- Text format: \`text\` unless the agent must return machine-readable output (\`json_object\`,
+  or \`json_schema\` when a strict schema is given).
+`;
+/** The skill body without the loader preamble and frontmatter (what is sent as guidance). */
+export function skillBody(text) {
+    return text
+        .replace(/^Skill root:.*\r?\n(?:Use skill_resource.*\r?\n)?/, "")
+        .replace(/^---\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n?/, "")
+        .trim();
+}