@alisio/alisio-code 0.1.0-alpha.11 → 0.1.0-alpha.13

package/README.md

@@ -1,23 +1,102 @@
-# alisio
+# @alisio/alisio-code
 
-**Alisio is an extensible, provider-agnostic coding-agent harness for your terminal.** It pairs a
-fast TUI with any OpenAI-compatible model, runs local tools behind explicit permissions, compacts
-long conversations into structured checkpoints, remembers decisions across sessions with an
-Engram-style memory plugin, and exposes a typed plugin SDK.
+**Alisio is an extensible, provider-agnostic coding-agent harness for your terminal.** It pairs a fast
+TUI with any OpenAI-compatible model, runs local tools behind explicit permissions, compacts long
+conversations into structured checkpoints, remembers decisions across sessions with an Engram-style
+memory plugin, and exposes a typed plugin SDK.
+
+## What it is
+
+`alisio` is the CLI of the Alisio project. It connects to any OpenAI-compatible endpoint (Chat
+Completions or Responses), drives its own agent tool loop, and runs interactively as a TUI or
+headless for scripts and CI. Provider SDKs stay out of the harness: the CLI ships built-in DeepSeek,
+OpenAI-compatible, OpenCode Console (Zen) and OpenCode Go providers, plus memory and subagents
+plugins.
+
+## Installation
+
+```sh
+npm i -g @alisio/alisio-code        # or: pnpm add -g @alisio/alisio-code · bun add -g @alisio/alisio-code
+alisio                              # the binary is installed as `alisio`
+```
+
+Standalone binaries (Bun embedded, no Node required) are attached to GitHub releases.
+
+## Quick start
+
+The fastest path is the TUI's `/connect` form: pick a provider, enter its settings and key, choose a
+model, and Alisio persists the selection globally (`/model` re-opens the same selector). A plain
+config start looks like:
+
+```sh
+alisio setup                        # writes a secret-free .alisio/config.json in .alisio/
+export DEEPSEEK_API_KEY=...         # keys come from environment variables or /connect, never config files
+alisio --config .alisio/config.json
+```
+
+Run one prompt headless, emitting versioned JSONL events:
 
 ```sh
-npm install -g @alisio/alisio-code        # or: pnpm add -g @alisio/alisio-code · bun add -g @alisio/alisio-code
-alisio                                      # the CLI binary is installed as `alisio`
-export DEEPSEEK_API_KEY=...  # keys are read from environment variables only
-alisio --config ./alisio.json
+alisio run "Summarize this repository" --json
+alisio run "/init" --allow-write    # generate AGENTS.md from the built-in /init template
 ```
 
-- Terminal UI: streaming Markdown, tool blocks with diffs, context/token bar, slash commands, copy-on-select.
-- Headless: `alisio run "prompt" --json` emits versioned JSONL events.
-- Permissions: reads by default; `--allow-write`, `--allow-process` or interactive approval; `--read-only`.
-- Built-in memory plugin (disable with `--disable-plugin memory`); npm plugins via `--plugin <package>`.
-- Runs on Node.js >= 22.16 or Bun; standalone binaries are attached to GitHub releases.
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `alisio` | Interactive TUI (readline with `--no-tui`) |
+| `alisio run <prompt>` | Headless run; `/name args` runs a prompt template |
+| `alisio resume <session> [prompt]` | Resume a session |
+| `alisio setup` | Write a secret-free example `.alisio/config.json` |
+| `alisio doctor` | Environment and provider diagnostics |
+| `alisio trust list` / `trust revoke <path>` | Inspect or revoke per-directory project trust |
+| `alisio sessions list` / `sessions recover <id> --acknowledge` | List sessions; recover after a crash |
+| `alisio skills list` / `skills validate` | Discover and validate Agent Skills |
+| `alisio plugins list` / `plugins doctor` | List/load plugins and show their tools and commands |
+| `alisio mcp list` / `mcp doctor <server>` | List configured MCP servers; connect to one (`--allow-mcp`) |
+| `alisio context explain <path>` | Show which `AGENTS.md` files apply to a path |
+| `alisio install npm:<package>` | Install an npm plugin into the global plugins directory |
+
+## Permissions and key flags
+
+Reads run by default; anything else needs a flag or interactive approval:
+
+| Flag | Effect |
+| --- | --- |
+| `--allow-write` | Allow file writes |
+| `--allow-process` | Allow arbitrary subprocesses (not sandboxed) |
+| `--allow-external` | Allow network tools: `webfetch`, `websearch`, provider-native search |
+| `--allow-mcp` | Allow configured MCP servers and remote tool calls |
+| `--allow-agents` | Allow messaging neighboring agents through Herdr |
+| `--read-only` | Disable writes, subprocesses, network tools, executable plugins and MCP |
+| `--plugin <path…>` / `--trust-project` | Load explicitly trusted plugins / trust project config |
+| `--disable-plugin <ids…>` | Disable built-in plugins (e.g. `memory`) |
+| `--json` | Emit versioned JSONL events (headless) |
+
+Other global flags: `--cwd`, `--config`, `--model`, `--base-url`, `--api-mode`, `--db`,
+`--no-tui`, `--no-banner`, `--no-herdr`, `--agents <json>`, `--quiet`, `-V`, `-h`.
+
+## In the TUI
+
+`/connect` adds a provider; `/model` picks a saved provider/model; `/compact`, `/stats`, `/clear`,
+`/sessions`, `/resume` manage conversations; `/plugins`, `/skills`, `/mcp`, `/settings` manage
+extensions and preferences; `/memory` and `/agents` drive the built-in plugins; `/init` writes
+`AGENTS.md`.
+
+## Requirements
+
+Node.js **>= 22.16** (`node:sqlite` with FTS5) or Bun **>= 1.4.2**. Git and ripgrep on `PATH` for the
+Git and search tools; `alisio doctor` reports what it detects.
+
+## Docs
+
+Documentation (EN/ES): <https://gustavogutierrez.github.io/alisio/> — [quick start](https://gustavogutierrez.github.io/alisio/quick-start),
+[configuration](https://gustavogutierrez.github.io/alisio/configuration), [plugins](https://gustavogutierrez.github.io/alisio/plugins),
+[subagents](https://gustavogutierrez.github.io/alisio/subagents), [memory](https://gustavogutierrez.github.io/alisio/memory),
+[TUI](https://gustavogutierrez.github.io/alisio/tui).
 
-Documentation: [English](https://gustavogutierrez.github.io/alisio/) · [Español](https://gustavogutierrez.github.io/alisio/es/)
+## 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/tui/app.js

@@ -5,6 +5,8 @@ import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_IMAGE_BYTES, pasteImageFromClipboard,
 import { copyText, nodeSpawn } from "./clipboard.js";
 import { AttachmentsBar, BannerBlock, clock, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
 import { ConnectInputPrompt } from "./connect-input.js";
+import { bounded, EXIT_PENDING_CAP_MS, EXIT_SESSION_END_CAP_MS } from "./exit.js";
+import { BRANCH_REFRESH_MS, createBranchCache } from "./git-branch.js";
 import { initialPanelState, reducePanel, visibleRows } from "./panel.js";
 import { summarizeAnswers } from "./questions.js";
 import { InteractiveQueue } from "./queue.js";
@@ -153,6 +155,21 @@ export async function runTui(options) {
         }, ms);
         tui.requestRender();
     };
+    // Git branch of the workspace for the header. Reading refs is a read operation, so it stays on
+    // under --read-only; the TTL cache means git is spawned at most once per ~10s, never per frame,
+    // and a missing repo/git or a slow spawn simply yields no branch segment.
+    const branchCache = createBranchCache();
+    let branchName;
+    const refreshBranch = () => {
+        void branchCache.read(app.workspace).then((branch) => {
+            if (branch !== branchName) {
+                branchName = branch;
+                tui.requestRender();
+            }
+        });
+    };
+    refreshBranch();
+    const branchTimer = setInterval(refreshBranch, BRANCH_REFRESH_MS);
     const headerInfo = () => {
         const policy = app.runner.policy, ask = app.runner.approvals;
         return {
@@ -162,6 +179,7 @@ export async function runTui(options) {
             provider: app.providers.get(activeProvider?.id ?? "")?.name,
             cwd: shortenPath(app.workspace, homedir()),
             session: shortId(session),
+            branch: branchName,
             write: policy.write ? "on" : ask ? "ask" : "off",
             process: policy.process ? "on" : ask ? "ask" : "off",
             mcp: app.mcpRuntimePermission() === "granted",
@@ -308,7 +326,13 @@ export async function runTui(options) {
             tui.requestRender();
             return;
         }
-        if (["run_completed", "run_failed", "run_cancelled", "compaction_failed"].includes(event.type))
+        if ([
+            "run_completed",
+            "run_failed",
+            "run_cancelled",
+            "run_turns_exceeded",
+            "compaction_failed",
+        ].includes(event.type))
             terminalEvent = true;
         view = reduceEvent(view, event);
         sync();
@@ -479,7 +503,7 @@ export async function runTui(options) {
     const endSession = async (reason) => {
         if (!view.stats.runs || !app.plugins.hasSessionEndHooks)
             return;
-        flashHint("Running session-end plugin hooks (bounded by pluginHooks.sessionEndTimeoutMs)…", 60_000);
+        flashHint("Running session-end plugin hooks…", 60_000);
         tui.renderNow?.();
         try {
             const { failures } = await app.endSession(session, reason);
@@ -499,8 +523,12 @@ export async function runTui(options) {
             return;
         stopping = true;
         controller?.abort(new Error("Exiting"));
-        await Promise.race([pending?.catch(() => { }), new Promise((r) => setTimeout(r, 3000))]);
-        await endSession("exit");
+        // Exit must feel instant: an in-flight turn gets up to 3s (the abort above settles it
+        // immediately in practice), then session-end hooks get a short cap — /clear still honors
+        // the full pluginHooks.sessionEndTimeoutMs. app.close() later in the main path is itself
+        // parallel and capped, so the whole exit path is bounded end to end.
+        await bounded(pending?.catch(() => { }), EXIT_PENDING_CAP_MS);
+        await bounded(endSession("exit"), EXIT_SESSION_END_CAP_MS);
         resolveExit();
     };
     const askInput = (input) => new Promise((resolve) => {
@@ -1540,6 +1568,7 @@ export async function runTui(options) {
     }
     finally {
         clearInterval(ticker);
+        clearInterval(branchTimer);
         clearTimeout(hintTimer);
         process.off("SIGTERM", onSignal);
         process.off("SIGHUP", onSignal);

package/dist/tui/components.d.ts

@@ -17,6 +17,8 @@ export interface HeaderInfo {
     provider?: string;
     cwd: string;
     session: string;
+    /** Git branch (or short SHA on a detached HEAD) of the session workspace; undefined when unavailable. */
+    branch?: string;
     write: PermissionState;
     process: PermissionState;
     mcp: boolean;

package/dist/tui/components.js

@@ -1,5 +1,7 @@
 import { Container, getCapabilities, Image, Key, Markdown, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { terminalCapabilities } from "../banner.js";
 import { attachmentCaption, MAX_ATTACHMENTS_PER_MESSAGE, } from "./attachments.js";
+import { branchDisplay } from "./git-branch.js";
 import { initialQuestionState, reduceQuestions, } from "./questions.js";
 import { contextLevel, contextPercent, editSummary, fitSegments, formatContext, formatDuration, formatTokens, } from "./state.js";
 import { imageTheme, levelColor, markdownTheme, style } from "./theme.js";
@@ -28,7 +30,7 @@ export class Header {
     render(width) {
         const i = this.info(), v = this.view();
         const line1 = line([
-            { text: "◆ alisio", priority: 8, paint: (t) => style.bold(style.brightCyan(t)) },
+            { text: "◆ Alisio Code", priority: 8, paint: (t) => style.bold(style.brightCyan(t)) },
             { text: `v${i.version}`, priority: 1, paint: style.gray },
             {
                 text: v.model || "not connected",
@@ -53,6 +55,19 @@ export class Header {
         const line2 = line([
             { text: i.cwd, priority: 6, paint: style.cyan },
             { text: `session ${i.session}`, priority: 4, paint: style.gray },
+            // Priority 3 (below session's 4): the branch is ambient context, so on narrow terminals it
+            // drops first — before the session ID and permissions. At equal priority fitSegments drops
+            // the FIRST lowest-priority segment, which would mis-drop the session when branch sits
+            // after it, so the branch keeps a strictly lower priority instead.
+            ...(i.branch
+                ? [
+                    {
+                        text: branchDisplay(i.branch, terminalCapabilities({ env: process.env, columns: width, tty: true }).unicode),
+                        priority: 3,
+                        paint: style.cyan,
+                    },
+                ]
+                : []),
             ...perms,
         ], width);
         return fit([line1, line2, style.gray("─".repeat(Math.max(0, width)))], width);

package/dist/tui/exit.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interactive-exit bounds: `/exit`, double Ctrl+C on an empty input, Ctrl+D and SIGINT/SIGTERM
+ * must feel instant, so each shutdown step is raced against a cap instead of awaiting teardown
+ * without limits. The plugin host's own hook timeout (`pluginHooks.sessionEndTimeoutMs`) still
+ * applies to `/clear`; exit deliberately uses shorter user-facing caps on the same hooks.
+ */
+export declare const EXIT_PENDING_CAP_MS = 3000;
+export declare const EXIT_SESSION_END_CAP_MS = 1500;
+/** Resolves when `work` settles or after `capMs`, whichever comes first; never rejects. */
+export declare function bounded(work: Promise<unknown> | undefined, capMs: number): Promise<void>;

package/dist/tui/exit.js

@@ -0,0 +1,15 @@
+/**
+ * Interactive-exit bounds: `/exit`, double Ctrl+C on an empty input, Ctrl+D and SIGINT/SIGTERM
+ * must feel instant, so each shutdown step is raced against a cap instead of awaiting teardown
+ * without limits. The plugin host's own hook timeout (`pluginHooks.sessionEndTimeoutMs`) still
+ * applies to `/clear`; exit deliberately uses shorter user-facing caps on the same hooks.
+ */
+export const EXIT_PENDING_CAP_MS = 3_000;
+export const EXIT_SESSION_END_CAP_MS = 1_500;
+/** Resolves when `work` settles or after `capMs`, whichever comes first; never rejects. */
+export function bounded(work, capMs) {
+    return Promise.race([
+        Promise.resolve(work).catch(() => { }),
+        new Promise((resolve) => setTimeout(resolve, capMs)),
+    ]).then(() => undefined);
+}

package/dist/tui/git-branch.d.ts

@@ -0,0 +1,48 @@
+import { execFile } from "node:child_process";
+/** Hard cap for branch names shown in the header, so a hostile/long ref never breaks layout. */
+export declare const BRANCH_MAX_LENGTH = 24;
+/** How long a resolved branch is reused before git is asked again (avoids spawning per frame). */
+export declare const BRANCH_TTL_MS = 10000;
+/** Re-check cadence; matches the cache TTL so the header follows branch switches within ~10s. */
+export declare const BRANCH_REFRESH_MS = 10000;
+/** Bounded spawn: a slow or hung git must never stall the TUI. */
+export declare const BRANCH_TIMEOUT_MS = 800;
+type Spawn = typeof execFile;
+/**
+ * Strips ANSI escapes and control characters, then truncates to `BRANCH_MAX_LENGTH` chars with an
+ * ellipsis. Branch names come from the workspace repository, not from user input, but a hostile or
+ * corrupted ref must never inject escape sequences or overflow the header line.
+ */
+export declare function sanitizeBranchName(name: string): string;
+/** Header segment text: `⎇ main` on unicode terminals, `branch main` otherwise. */
+export declare function branchDisplay(branch: string, unicode: boolean): string;
+export interface ReadBranchOptions {
+    timeoutMs?: number;
+    /** Injectable for tests; defaults to node:child_process execFile. */
+    spawn?: Spawn;
+}
+/**
+ * Reads the branch of the git repository at `workspace` (read-only ref query, safe under
+ * `--read-only`). Returns the branch name, the short commit SHA on a detached HEAD, or `undefined`
+ * when the directory is missing, is not a git repository, git itself is unavailable, or the call
+ * times out. All failures are silent: stderr is captured and never printed.
+ */
+export declare function readGitBranch(workspace: string, options?: ReadBranchOptions): Promise<string | undefined>;
+export interface BranchCache {
+    /** Cached branch for `workspace`, or a fresh read when the entry expired; dedupes in-flight reads. */
+    read(workspace: string): Promise<string | undefined>;
+    clear(workspace: string): void;
+}
+export interface BranchCacheOptions {
+    ttlMs?: number;
+    timeoutMs?: number;
+    spawn?: Spawn;
+    /** Injectable clock for expiry tests. */
+    now?: () => number;
+}
+/**
+ * TTL cache keyed by workspace so the TUI never spawns git on every frame: one read per workspace
+ * per `ttlMs` (hits and misses are both cached), with a single in-flight promise per key.
+ */
+export declare function createBranchCache(options?: BranchCacheOptions): BranchCache;
+export {};

package/dist/tui/git-branch.js

@@ -0,0 +1,99 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+/** Hard cap for branch names shown in the header, so a hostile/long ref never breaks layout. */
+export const BRANCH_MAX_LENGTH = 24;
+/** How long a resolved branch is reused before git is asked again (avoids spawning per frame). */
+export const BRANCH_TTL_MS = 10_000;
+/** Re-check cadence; matches the cache TTL so the header follows branch switches within ~10s. */
+export const BRANCH_REFRESH_MS = BRANCH_TTL_MS;
+/** Bounded spawn: a slow or hung git must never stall the TUI. */
+export const BRANCH_TIMEOUT_MS = 800;
+/**
+ * Strips ANSI escapes and control characters, then truncates to `BRANCH_MAX_LENGTH` chars with an
+ * ellipsis. Branch names come from the workspace repository, not from user input, but a hostile or
+ * corrupted ref must never inject escape sequences or overflow the header line.
+ */
+export function sanitizeBranchName(name) {
+    const clean = name
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, "")
+        .trim();
+    const chars = [...clean];
+    return chars.length > BRANCH_MAX_LENGTH
+        ? `${chars.slice(0, BRANCH_MAX_LENGTH - 1).join("")}…`
+        : clean;
+}
+/** Header segment text: `⎇ main` on unicode terminals, `branch main` otherwise. */
+export function branchDisplay(branch, unicode) {
+    return `${unicode ? "⎇" : "branch"} ${branch}`;
+}
+function runGit(spawn, args, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        spawn("git", args, { cwd, timeout: timeoutMs, windowsHide: true }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
+/**
+ * Reads the branch of the git repository at `workspace` (read-only ref query, safe under
+ * `--read-only`). Returns the branch name, the short commit SHA on a detached HEAD, or `undefined`
+ * when the directory is missing, is not a git repository, git itself is unavailable, or the call
+ * times out. All failures are silent: stderr is captured and never printed.
+ */
+export async function readGitBranch(workspace, options = {}) {
+    const timeoutMs = options.timeoutMs ?? BRANCH_TIMEOUT_MS;
+    if (!existsSync(workspace))
+        return undefined;
+    const spawn = options.spawn ?? execFile;
+    try {
+        const ref = (await runGit(spawn, ["rev-parse", "--abbrev-ref", "HEAD"], workspace, timeoutMs)).trim();
+        if (ref && ref !== "HEAD")
+            return sanitizeBranchName(ref);
+        if (ref === "HEAD") {
+            const sha = (await runGit(spawn, ["rev-parse", "--short", "HEAD"], workspace, timeoutMs)).trim();
+            return sha ? sanitizeBranchName(sha) : undefined;
+        }
+        return undefined;
+    }
+    catch {
+        // Not a repository, git missing, or timed out: the header simply shows no branch segment.
+        return undefined;
+    }
+}
+/**
+ * TTL cache keyed by workspace so the TUI never spawns git on every frame: one read per workspace
+ * per `ttlMs` (hits and misses are both cached), with a single in-flight promise per key.
+ */
+export function createBranchCache(options = {}) {
+    const ttlMs = options.ttlMs ?? BRANCH_TTL_MS;
+    const now = options.now ?? Date.now;
+    const entries = new Map();
+    const inflight = new Map();
+    const read = (workspace) => {
+        const hit = entries.get(workspace);
+        if (hit && hit.expires > now())
+            return Promise.resolve(hit.branch);
+        const pending = inflight.get(workspace);
+        if (pending)
+            return pending;
+        const promise = readGitBranch(workspace, {
+            timeoutMs: options.timeoutMs,
+            spawn: options.spawn,
+        })
+            .then((branch) => {
+            entries.set(workspace, { branch, expires: now() + ttlMs });
+            inflight.delete(workspace);
+            return branch;
+        })
+            .catch(() => {
+            inflight.delete(workspace);
+            return undefined;
+        });
+        inflight.set(workspace, promise);
+        return promise;
+    };
+    return { read, clear: (workspace) => void entries.delete(workspace) };
+}

package/dist/tui/settings.js

@@ -11,7 +11,7 @@ export const WEBSEARCH_PROVIDERS = [
 export const defaultConfig = {
     compaction: { auto: true, threshold: 0.85, keepTurns: 2, maxOutputTokens: 16_000 },
     context: { claudeMdFallback: false, maxBytes: 32 * 1024 },
-    limits: { maxTurns: 20, maxOutputTokens: 4_096, maxContextChars: 160_000, timeoutMs: 300_000 },
+    limits: { maxTurns: 100, maxOutputTokens: 16_384, maxContextChars: 800_000, timeoutMs: 300_000 },
     tui: { paddingX: 1, skillSlashCommands: true },
     mcp: { allow: false },
     websearch: { provider: undefined },
@@ -112,7 +112,7 @@ export const SETTINGS_DEFINITIONS = [
         valueType: "number",
         values: [5, 10, 15, 20, 30, 50, 100],
         read: (config) => config.limits.maxTurns,
-        description: "Maximum agent-loop turns per run before the run ends. Applied from the next run; longer tasks may need a higher budget.",
+        description: "Maximum agent-loop turns per run. Reaching the limit ends the run softly: everything so far is kept and the session stays usable, so you can just say continue. Raise it for long read-heavy audits. Applied from the next run.",
     },
     {
         id: "limits.maxOutputTokens",
@@ -128,7 +128,7 @@ export const SETTINGS_DEFINITIONS = [
         label: "Context char budget",
         category: "Limits",
         valueType: "number",
-        values: [80_000, 120_000, 160_000, 240_000, 320_000],
+        values: [80_000, 120_000, 160_000, 240_000, 320_000, 800_000],
         read: (config) => config.limits.maxContextChars,
         description: "Hard context limit in characters (instruction files + transcript + tool list) per run; the budget fallback that auto-compaction measures when the model window is unknown. Applied from the next run.",
     },

package/dist/tui/state.js

@@ -529,7 +529,8 @@ export function reduceEvent(state, event) {
         }
         case "run_completed":
         case "run_failed":
-        case "run_cancelled": {
+        case "run_cancelled":
+        case "run_turns_exceeded": {
             const ended = {
                 ...state,
                 streaming: false,
@@ -541,6 +542,11 @@ export function reduceEvent(state, event) {
             };
             if (event.type === "run_failed")
                 return addItem(ended, { kind: "error", text: String(d.error ?? "Run failed") });
+            if (event.type === "run_turns_exceeded")
+                return addItem(ended, {
+                    kind: "notice",
+                    text: "Turn limit reached — the answer may be incomplete. Continue with another prompt or raise limits.maxTurns (/settings → Max turns).",
+                });
             if (event.type === "run_cancelled") {
                 const reason = String(d.error ?? "cancelled");
                 return addItem(ended, {
@@ -591,7 +597,7 @@ export function reduceEvent(state, event) {
         case "response_truncated":
             return addItem(state, {
                 kind: "notice",
-                text: "Response cut by max output tokens — the answer may be incomplete. Raise limits.maxOutputTokens to allow longer answers.",
+                text: "Response cut by max output tokens — the answer may be incomplete. Raise limits.maxOutputTokens (/settings → Agent max output tokens) to allow longer answers.",
             });
         case "model_changed":
             return {

package/dist/version.d.ts

@@ -1,8 +1,10 @@
 /**
- * Reads the package version at runtime so --version, doctor, plugin metadata and MCP client
- * metadata stay in sync with the published package without a build-time constant to update.
- * The manifest is resolved relative to the module (`src/version.ts` → `../package.json` in the
- * source tree; `dist/version.js` → `../package.json` of the installed package). Standalone
- * binaries inject the version at build time via ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
+ * Reads the package version at runtime so --version, the TUI header, doctor, plugin metadata and
+ * MCP client metadata stay in sync with the published package without a build-time constant to
+ * update. The manifest is resolved by walking UP from the module directory until a package.json
+ * with a string `version` is found (bounded, any depth: module, then up to 8 parents), so deeply
+ * nested call sites like `src/tui/app.ts` and compiled `dist/*` resolve the same manifest as
+ * `src/main.ts`. Standalone binaries inject the version at build time via
+ * ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
  */
 export declare function loadVersion(fromHere: string): string;

package/dist/version.js

@@ -8,19 +8,55 @@ import { fileURLToPath } from "node:url";
  */
 const FALLBACK = "dev";
 /**
- * Reads the package version at runtime so --version, doctor, plugin metadata and MCP client
- * metadata stay in sync with the published package without a build-time constant to update.
- * The manifest is resolved relative to the module (`src/version.ts` → `../package.json` in the
- * source tree; `dist/version.js` → `../package.json` of the installed package). Standalone
- * binaries inject the version at build time via ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
+ * How many parent directories the loader walks up before giving up. Bounded so a missing
+ * manifest can never make the lookup climb an unbounded path.
+ */
+const MAX_PARENT_HOPS = 8;
+/** Manifests whose `name` identifies the CLI package; preferred when several are hit. */
+const CLI_MANIFEST_NAMES = new Set(["@alisio/alisio-code", "alisio"]);
+/**
+ * Walks up from `dir` looking for a package manifest. Returns the version of the nearest
+ * manifest that declares a string `version`, preferring a manifest whose `name` identifies the
+ * CLI package (`@alisio/alisio-code`/`alisio`) when several are hit — e.g. running from source
+ * inside the monorepo, where the repo-root manifest is also a candidate. `undefined` when no
+ * manifest with a version is reached within the bound.
+ */
+function findManifestVersion(dir) {
+    let nearest;
+    let current = dir;
+    for (let hop = 0; hop <= MAX_PARENT_HOPS; hop++) {
+        try {
+            const parsed = JSON.parse(readFileSync(join(current, "package.json"), "utf8"));
+            if (typeof parsed.version === "string" && parsed.version) {
+                if (typeof parsed.name === "string" && CLI_MANIFEST_NAMES.has(parsed.name))
+                    return parsed.version;
+                nearest ??= parsed.version;
+            }
+        }
+        catch {
+            // No manifest here; keep walking up.
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break; // Filesystem root.
+        current = parent;
+    }
+    return nearest;
+}
+/**
+ * Reads the package version at runtime so --version, the TUI header, doctor, plugin metadata and
+ * MCP client metadata stay in sync with the published package without a build-time constant to
+ * update. The manifest is resolved by walking UP from the module directory until a package.json
+ * with a string `version` is found (bounded, any depth: module, then up to 8 parents), so deeply
+ * nested call sites like `src/tui/app.ts` and compiled `dist/*` resolve the same manifest as
+ * `src/main.ts`. Standalone binaries inject the version at build time via
+ * ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
  */
 export function loadVersion(fromHere) {
     if (process.env.ALISIO_PACKAGE_VERSION)
         return process.env.ALISIO_PACKAGE_VERSION;
     try {
-        const manifest = join(dirname(fileURLToPath(fromHere)), "..", "package.json");
-        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
-        return typeof parsed.version === "string" && parsed.version ? parsed.version : FALLBACK;
+        return findManifestVersion(dirname(fileURLToPath(fromHere))) ?? FALLBACK;
     }
     catch {
         return FALLBACK;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.11",
+  "version": "0.1.0-alpha.13",
   "description": "Alisio: an extensible, provider-agnostic coding-agent harness for your terminal. TUI, OpenAI-compatible providers, permissioned local tools, context compaction, persistent memory and a typed plugin SDK.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,14 +45,14 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.9",
-    "@alisio/plugin-deepseek": "0.1.0-alpha.7",
-    "@alisio/plugin-memory": "0.1.0-alpha.6",
-    "@alisio/plugin-openai-compatible": "0.1.0-alpha.7",
-    "@alisio/plugin-opencode": "0.1.0-alpha.6",
-    "@alisio/plugin-opencode-go": "0.1.0-alpha.6",
-    "@alisio/plugin-subagents": "0.1.0-alpha.6",
-    "@alisio/sdk": "0.1.0-alpha.5",
+    "@alisio/core": "0.1.0-alpha.11",
+    "@alisio/plugin-deepseek": "0.1.0-alpha.9",
+    "@alisio/plugin-memory": "0.1.0-alpha.7",
+    "@alisio/plugin-openai-compatible": "0.1.0-alpha.9",
+    "@alisio/plugin-opencode": "0.1.0-alpha.8",
+    "@alisio/plugin-opencode-go": "0.1.0-alpha.8",
+    "@alisio/plugin-subagents": "0.1.0-alpha.8",
+    "@alisio/sdk": "0.1.0-alpha.7",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },