@alisio/alisio-code 0.1.0-alpha.9 → 0.1.0

package/dist/tui/connect-input.d.ts

@@ -26,6 +26,8 @@ export declare class ConnectInputPrompt implements Component {
         hint?: string;
         step: number;
         steps: number;
+        /** Dialog title (default `Connect · <provider>`). */
+        title?: string;
         onSubmit: (value: string) => void;
         onCancel: () => void;
     });

package/dist/tui/connect-input.js

@@ -92,7 +92,7 @@ export class ConnectInputPrompt {
         const rule = "─".repeat(Math.max(1, Math.min(56, width - 2)));
         return [
             truncateToWidth(style.cyan(`┌${rule}┐`), width),
-            truncateToWidth(`│ ${style.bold(`Connect · ${this.options.provider}`)} ${style.dim(`(${this.options.step}/${this.options.steps})`)}`, width),
+            truncateToWidth(`│ ${style.bold(this.options.title ?? `Connect · ${this.options.provider}`)}${this.options.title && this.options.steps <= 1 ? "" : ` ${style.dim(`(${this.options.step}/${this.options.steps})`)}`}`, width),
             truncateToWidth(`│ ${style.brightCyan("❯")} ${style.bold(this.options.label)}`, width),
             truncateToWidth(`│   ${field}`, width),
             ...(this.options.hint ? [truncateToWidth(`│   ${style.dim(this.options.hint)}`, 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/goal.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `/goal` in the terminal. Pure logic first (what a typed command does, the picker, the bar), then
+ * the `GoalBar` component. The goal itself (state machine, caps, breakers, the one-continuation
+ * claim) lives in `@alisio/core`; this module only decides what to SHOW and which action a command
+ * means, so it can be tested without a terminal.
+ */
+import { formatGoalStatus, type GoalCommand } from "@alisio/core";
+import type { GoalInfo } from "@alisio/sdk";
+import { type Component } from "@earendil-works/pi-tui";
+/** What a typed `/goal …` means, given the session's current goal. */
+export type GoalPlan = {
+    kind: "say";
+    text: string;
+    tone: "info" | "notice";
+}
+/** `/goal` with a goal: the action picker. */
+ | {
+    kind: "picker";
+}
+/** `/goal <objective>` over an existing goal: ask before replacing it. */
+ | {
+    kind: "confirm-replace";
+    objective: string;
+    tokenBudget?: number;
+} | {
+    kind: "create";
+    objective: string;
+    tokenBudget?: number;
+} | {
+    kind: "act";
+    action: "pause" | "resume" | "clear";
+} | {
+    kind: "edit";
+    objective: string;
+}
+/** `/goal edit` without text: put the current objective in the editor to change it. */
+ | {
+    kind: "edit-prefill";
+    text: string;
+} | {
+    kind: "budget";
+    tokens: number | null;
+};
+export declare const NO_GOAL_TEXT = "This session has no goal. Start one with /goal <objective>.";
+export declare const GOALS_OFF_TEXT = "Goals are turned off (goal.enabled).";
+export declare function planGoalCommand(command: GoalCommand, context: {
+    goal: GoalInfo | undefined;
+    enabled: boolean;
+}): GoalPlan;
+export interface GoalPickerItem {
+    value: "status" | "pause" | "resume" | "edit" | "budget" | "clear" | "help";
+    label: string;
+    description: string;
+}
+/** The rows of `/goal` ("Start or manage the current Session Goal") for a goal in this state. */
+export declare function goalPickerItems(goal: GoalInfo): GoalPickerItem[];
+/** The editor text a picker row leaves for the user to finish (`undefined` = act at once). */
+export declare function goalPickerPrefill(value: GoalPickerItem["value"], goal: GoalInfo): string | undefined;
+export type GoalTone = "ok" | "warn" | "danger" | "done";
+export declare function goalTone(goal: GoalInfo): GoalTone;
+/** The one or two lines of the bar, unstyled; `width` only decides how the objective is cut. */
+export declare function goalBarText(goal: GoalInfo): {
+    head: string;
+    detail: string;
+};
+/** The goal bar above the editor: nothing without a goal, two lines with one. */
+export declare class GoalBar implements Component {
+    private readonly goal;
+    constructor(goal: () => GoalInfo | undefined);
+    invalidate(): void;
+    render(width: number): string[];
+}
+/** One transcript line when a goal stops by itself (the bar shows the same, but scrolls away). */
+export declare function goalStopNotice(goal: GoalInfo): string | undefined;
+export { formatGoalStatus };

package/dist/tui/goal.js

@@ -0,0 +1,171 @@
+/**
+ * `/goal` in the terminal. Pure logic first (what a typed command does, the picker, the bar), then
+ * the `GoalBar` component. The goal itself (state machine, caps, breakers, the one-continuation
+ * claim) lives in `@alisio/core`; this module only decides what to SHOW and which action a command
+ * means, so it can be tested without a terminal.
+ */
+import { formatGoalElapsed, formatGoalStatus, GOAL_HELP, GOAL_STATUS_LABEL, GOAL_USAGE, GOAL_WAITING_LABEL, goalActionHints, goalReasonText, goalTokensText, } from "@alisio/core";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { style } from "./theme.js";
+export const NO_GOAL_TEXT = "This session has no goal. Start one with /goal <objective>.";
+export const GOALS_OFF_TEXT = "Goals are turned off (goal.enabled).";
+export function planGoalCommand(command, context) {
+    const { goal } = context;
+    const say = (text, tone = "notice") => ({
+        kind: "say",
+        text,
+        tone,
+    });
+    switch (command.type) {
+        case "error":
+            return say(`${command.message}\n${GOAL_USAGE}`);
+        case "help":
+            return say(GOAL_HELP, "info");
+        case "show":
+            if (!goal)
+                return say(`${NO_GOAL_TEXT}\n${GOAL_USAGE}`);
+            return { kind: "picker" };
+        case "create":
+            if (!context.enabled)
+                return say(GOALS_OFF_TEXT);
+            return goal
+                ? {
+                    kind: "confirm-replace",
+                    objective: command.objective,
+                    ...(command.tokenBudget ? { tokenBudget: command.tokenBudget } : {}),
+                }
+                : {
+                    kind: "create",
+                    objective: command.objective,
+                    ...(command.tokenBudget ? { tokenBudget: command.tokenBudget } : {}),
+                };
+        case "pause":
+        case "resume":
+        case "clear":
+            return goal ? { kind: "act", action: command.type } : say(NO_GOAL_TEXT);
+        case "edit":
+            if (!goal)
+                return say(NO_GOAL_TEXT);
+            return command.objective === undefined
+                ? { kind: "edit-prefill", text: `/goal edit ${goal.objective}` }
+                : { kind: "edit", objective: command.objective };
+        case "budget":
+            return goal ? { kind: "budget", tokens: command.tokens } : say(NO_GOAL_TEXT);
+    }
+}
+/** The rows of `/goal` ("Start or manage the current Session Goal") for a goal in this state. */
+export function goalPickerItems(goal) {
+    const items = [
+        {
+            value: "status",
+            label: "Show status",
+            description: "Objective, usage and the agent's report",
+        },
+    ];
+    if (goal.actions.includes("pause"))
+        items.push({
+            value: "pause",
+            label: "Pause",
+            description: "Stop continuing automatically (the current turn finishes)",
+        });
+    if (goal.actions.includes("resume"))
+        items.push({
+            value: "resume",
+            label: "Resume",
+            description: goal.reason === "max_turns" || goal.reason === "max_wall"
+                ? "Continue with one more allowance of the limit that stopped it"
+                : "Continue working on the goal",
+        });
+    items.push({ value: "edit", label: "Edit objective…", description: "Change the objective text" });
+    items.push({
+        value: "budget",
+        label: goal.status === "budget_limited" ? "Raise budget…" : "Set token budget…",
+        description: "e.g. 50k or 1.5M; budget=clear removes it",
+    });
+    items.push({
+        value: "clear",
+        label: "Clear goal",
+        description: "Remove the goal from this session",
+    });
+    items.push({ value: "help", label: "Help", description: "Syntax and budget examples" });
+    return items;
+}
+/** The editor text a picker row leaves for the user to finish (`undefined` = act at once). */
+export function goalPickerPrefill(value, goal) {
+    if (value === "edit")
+        return `/goal edit ${goal.objective}`;
+    if (value === "budget")
+        return `/goal budget=${goal.tokenBudget !== undefined ? goal.tokenBudget : ""}`;
+    return undefined;
+}
+export function goalTone(goal) {
+    switch (goal.status) {
+        case "active":
+            return "ok";
+        case "complete":
+            return "done";
+        case "blocked":
+            return "danger";
+        default:
+            return "warn";
+    }
+}
+/** The one or two lines of the bar, unstyled; `width` only decides how the objective is cut. */
+export function goalBarText(goal) {
+    const label = GOAL_STATUS_LABEL[goal.status];
+    const why = goal.waiting
+        ? GOAL_WAITING_LABEL[goal.waiting]
+        : goal.status === "active"
+            ? ""
+            : goalReasonText(goal);
+    const parts = [
+        goalTokensText(goal),
+        `turn ${goal.turnsUsed}/${goal.maxTurns}`,
+        formatGoalElapsed(goal.activeMs),
+        ...(why ? [why] : []),
+        goalActionHints(goal.actions),
+    ].filter(Boolean);
+    return {
+        head: `◎ Goal · ${label} · ${goal.objective.replace(/\s+/g, " ").trim()}`,
+        detail: `  ${parts.join(" · ")}`,
+    };
+}
+const TONE_STYLE = {
+    ok: style.cyan,
+    warn: style.yellow,
+    danger: style.red,
+    done: style.green,
+};
+/** The goal bar above the editor: nothing without a goal, two lines with one. */
+export class GoalBar {
+    goal;
+    constructor(goal) {
+        this.goal = goal;
+    }
+    invalidate() { }
+    render(width) {
+        const goal = this.goal();
+        if (!goal)
+            return [];
+        const { head, detail } = goalBarText(goal);
+        const paint = TONE_STYLE[goalTone(goal)];
+        return [
+            truncateToWidth(style.bold(paint(head)), width),
+            truncateToWidth(style.dim(detail), width),
+        ];
+    }
+}
+/** One transcript line when a goal stops by itself (the bar shows the same, but scrolls away). */
+export function goalStopNotice(goal) {
+    if (goal.status === "active")
+        return undefined;
+    const base = `Goal ${GOAL_STATUS_LABEL[goal.status].toLowerCase()}`;
+    const why = goalReasonText(goal);
+    const next = goal.status === "paused" || goal.status === "blocked"
+        ? " · /goal resume to continue"
+        : goal.status === "budget_limited"
+            ? " · /goal budget=<n> to raise it"
+            : "";
+    return `${base}${why ? `: ${why}` : ""}${next}`;
+}
+export { formatGoalStatus };

package/dist/tui/modes.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pure logic of the TUI modes (spec: modes, goal and background, Phase 1): the Shift+Tab agent
+ * cycle, the `/permission` menu and transitions, and the `/reload` guard. No terminal output and
+ * no I/O, so it is unit-testable without a TTY; `app.ts` wires it to the editor and the pickers.
+ */
+import { type ActiveAgent, type PermissionMode, type PermissionModeLabel } from "@alisio/core";
+export declare const CYCLE_BLOCKED_HINT = "A turn is running: wait for it to finish before switching agents";
+/** What the input listener must do with a keypress. */
+export type ShiftTabDecision = {
+    type: "ignore";
+}
+/** A turn is running: say so and consume the key. */
+ | {
+    type: "blocked";
+    hint: string;
+} | {
+    type: "cycle";
+};
+export interface ShiftTabState {
+    /** A turn (or compaction) is running. */
+    busy: boolean;
+    /** A picker, menu or panel owns the keyboard. */
+    picker: boolean;
+    /** The slash/file autocomplete list is visible in the editor. */
+    autocomplete: boolean;
+    /** The subagent tree panel has the focus instead of the editor. */
+    panelFocused: boolean;
+}
+/**
+ * Shift+Tab cycles the main agents only when the editor owns the keyboard: with a picker, the
+ * autocomplete list or the agents panel open the key is left alone (not consumed), and during a
+ * turn it is consumed with a hint, because an agent switch applies from the next prompt.
+ */
+export declare function shiftTabDecision(data: string, state: ShiftTabState): ShiftTabDecision;
+/** The one-line hint after cycling to `agent`; it names the model the agent declares, if any. */
+export declare function agentCycleHint(agent: ActiveAgent, currentModel: string): string;
+/** The mode name shown in the header and the status row (`locked` is shown as `read-only`). */
+export declare const modeDisplay: (mode: PermissionModeLabel) => string;
+export interface PermissionMenuRow {
+    value: PermissionMode | "status" | "manage";
+    label: string;
+    description: string;
+}
+/** The five rows of the `/permission` menu, in order (decision P2). */
+export declare function permissionMenuRows(current: PermissionModeLabel): PermissionMenuRow[];
+export type ModeTransition = {
+    ok: true;
+    mode: PermissionMode;
+    message: string;
+    warning?: string;
+    changed: boolean;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Moves to `target`. Refused under `--read-only` (there is no approval handler to widen); setting
+ * the mode that is already active still succeeds, because it also resets "allow for this session"
+ * widenings. Full access always carries the not-a-sandbox warning.
+ */
+export declare function permissionTransition(current: PermissionModeLabel, target: PermissionMode): ModeTransition;
+export declare const isPermissionMode: (value: string) => value is PermissionMode;
+export declare const RELOAD_BUSY = "Reload is only available between turns: wait for the current turn to finish.";
+/** A reason to refuse `/reload` right now, or undefined when it is safe. */
+export declare function reloadGuard(state: {
+    busy: boolean;
+    runningChildren: number;
+    queuedPrompts: boolean;
+    /** Live background tasks (`bg_run`): closing the old application would kill them. */
+    backgroundTasks?: number;
+}): string | undefined;

package/dist/tui/modes.js

@@ -0,0 +1,90 @@
+/**
+ * Pure logic of the TUI modes (spec: modes, goal and background, Phase 1): the Shift+Tab agent
+ * cycle, the `/permission` menu and transitions, and the `/reload` guard. No terminal output and
+ * no I/O, so it is unit-testable without a TTY; `app.ts` wires it to the editor and the pickers.
+ */
+import { FULL_ACCESS_WARNING, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, } from "@alisio/core";
+import { Key, matchesKey } from "@earendil-works/pi-tui";
+export const CYCLE_BLOCKED_HINT = "A turn is running: wait for it to finish before switching agents";
+/**
+ * Shift+Tab cycles the main agents only when the editor owns the keyboard: with a picker, the
+ * autocomplete list or the agents panel open the key is left alone (not consumed), and during a
+ * turn it is consumed with a hint, because an agent switch applies from the next prompt.
+ */
+export function shiftTabDecision(data, state) {
+    if (!matchesKey(data, Key.shift("tab")))
+        return { type: "ignore" };
+    if (state.picker || state.autocomplete || state.panelFocused)
+        return { type: "ignore" };
+    if (state.busy)
+        return { type: "blocked", hint: CYCLE_BLOCKED_HINT };
+    return { type: "cycle" };
+}
+/** The one-line hint after cycling to `agent`; it names the model the agent declares, if any. */
+export function agentCycleHint(agent, currentModel) {
+    const base = `Agent: ${agent.name}${agent.readOnly ? " (read-only)" : ""} · Shift+Tab cycles agents`;
+    return agent.model && agent.model !== currentModel
+        ? `${base} · it declares model ${agent.model}: run /agents to apply it`
+        : base;
+}
+/** The mode name shown in the header and the status row (`locked` is shown as `read-only`). */
+export const modeDisplay = (mode) => mode === "locked" ? "read-only" : mode;
+/** The five rows of the `/permission` menu, in order (decision P2). */
+export function permissionMenuRows(current) {
+    const locked = current === "locked";
+    const mode = (id, label) => ({
+        value: id,
+        label: `${label}${current === id ? " (current)" : ""}`,
+        description: locked
+            ? "Locked: Alisio was started with --read-only"
+            : id === "full"
+                ? `${PERMISSION_MODE_TABLE[id].summary} Not a sandbox.`
+                : PERMISSION_MODE_TABLE[id].summary,
+    });
+    return [
+        mode("ask", "Use ask mode"),
+        mode("auto", "Use auto mode"),
+        mode("full", "Use full access mode"),
+        {
+            value: "status",
+            label: "Status",
+            description: "Show the current mode and what runs without asking",
+        },
+        {
+            value: "manage",
+            label: "Manage saved permissions…",
+            description: "Review and revoke the permissions saved for this session",
+        },
+    ];
+}
+/**
+ * Moves to `target`. Refused under `--read-only` (there is no approval handler to widen); setting
+ * the mode that is already active still succeeds, because it also resets "allow for this session"
+ * widenings. Full access always carries the not-a-sandbox warning.
+ */
+export function permissionTransition(current, target) {
+    if (current === "locked")
+        return { ok: false, message: PERMISSION_MODES_LOCKED };
+    const spec = PERMISSION_MODE_TABLE[target];
+    return {
+        ok: true,
+        mode: target,
+        changed: current !== target,
+        message: `Permission mode: ${target}. ${spec.summary}`,
+        ...(target === "full" ? { warning: FULL_ACCESS_WARNING } : {}),
+    };
+}
+export const isPermissionMode = (value) => PERMISSION_MODES.includes(value);
+export const RELOAD_BUSY = "Reload is only available between turns: wait for the current turn to finish.";
+/** A reason to refuse `/reload` right now, or undefined when it is safe. */
+export function reloadGuard(state) {
+    if (state.busy)
+        return RELOAD_BUSY;
+    if (state.backgroundTasks)
+        return `Reload would stop ${state.backgroundTasks} running background task${state.backgroundTasks === 1 ? "" : "s"}: stop ${state.backgroundTasks === 1 ? "it" : "them"} with /tasks or wait for ${state.backgroundTasks === 1 ? "it" : "them"} to finish, then reload.`;
+    if (state.runningChildren > 0)
+        return `Reload is unavailable while ${state.runningChildren} subagent${state.runningChildren === 1 ? " is" : "s are"} running: wait for ${state.runningChildren === 1 ? "it" : "them"} to finish or cancel with Ctrl+K in the agents panel.`;
+    if (state.queuedPrompts)
+        return "Reload is unavailable while an approval or question is waiting.";
+    return undefined;
+}

package/dist/tui/open-path.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Opening and revealing local files with the desktop's default application, portably and without
+ * a shell: arguments are an array (no `cmd /c start`, no `sh -c`), so a file name can never inject
+ * a command. Only paths returned by the artifact store are opened, never a path the model wrote.
+ */
+import { type ChildProcess, spawn } from "node:child_process";
+export interface Launch {
+    command: string;
+    args: string[];
+}
+export type OpenOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "no-desktop" | "unavailable";
+};
+export interface OpenDeps {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    spawn?: (command: string, args: string[], options: Parameters<typeof spawn>[2]) => ChildProcess;
+}
+/** Commands that open `path` with the default app, in fallback order. */
+export declare function openCommands(path: string, platform: NodeJS.Platform): Launch[];
+/** Commands that show `path` selected in the file manager (its folder on Linux/BSD). */
+export declare function revealCommands(path: string, platform: NodeJS.Platform): Launch[];
+/**
+ * Whether a desktop session can show a window: never over SSH; on Linux/BSD only with a display
+ * (`DISPLAY` or `WAYLAND_DISPLAY`). macOS and Windows always have one locally.
+ */
+export declare function desktopAvailable(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): boolean;
+/** Opens a file with the default application. */
+export declare const openPath: (path: string, deps?: OpenDeps) => Promise<OpenOutcome>;
+/** Shows a file in the system file manager. */
+export declare const revealPath: (path: string, deps?: OpenDeps) => Promise<OpenOutcome>;
+/** The notice shown when nothing could be opened (the caller offers "Copy path"). */
+export declare const cannotOpenMessage: (path: string, outcome: Exclude<OpenOutcome, {
+    ok: true;
+}>) => string;