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

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",
@@ -479,7 +497,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 +517,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 +1562,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";
@@ -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: 20, maxOutputTokens: 16_384, maxContextChars: 800_000, timeoutMs: 300_000 },
     tui: { paddingX: 1, skillSlashCommands: true },
     mcp: { allow: false },
     websearch: { provider: undefined },
@@ -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

@@ -591,7 +591,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.11",
+  "version": "0.1.0-alpha.12",
   "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/core": "0.1.0-alpha.10",
+    "@alisio/plugin-deepseek": "0.1.0-alpha.8",
     "@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/plugin-openai-compatible": "0.1.0-alpha.8",
+    "@alisio/plugin-opencode": "0.1.0-alpha.7",
+    "@alisio/plugin-opencode-go": "0.1.0-alpha.7",
+    "@alisio/plugin-subagents": "0.1.0-alpha.7",
+    "@alisio/sdk": "0.1.0-alpha.6",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },