@alisio/alisio-code 0.1.0-alpha.25 → 0.1.0-alpha.27

package/dist/analysis.d.ts

@@ -0,0 +1,27 @@
+import type { AnalysisStatus } from "@alisio/sdk";
+type Common = {
+    db?: string;
+    python?: string;
+    cwd?: string;
+    config?: string;
+    trustProject?: boolean;
+};
+/** The unified runtime state and, when Python is missing, the install guidance for this system. */
+export declare function analysisState(o: Common): Promise<{
+    status: AnalysisStatus;
+    guidance?: string;
+    ignored: string[];
+}>;
+/** Prints `alisio analysis status`. */
+export declare function printAnalysisStatus(o: Common): Promise<void>;
+/** `alisio analysis setup --extras analysis|science`: needs network; offline it fails cleanly. */
+export declare function setupExtras(o: Common, extras: string | undefined): Promise<void>;
+/**
+ * `alisio analysis setup --oci [--image <name>]`: pulls the image once and verifies it. With a
+ * digest-pinned reference the pull verifies the digest; with a tag it prints the digest to put in
+ * `analysis.oci.image` (Alisio never writes it: only you choose what runs your code).
+ */
+export declare function setupOci(o: Common, image: string | undefined): Promise<void>;
+/** `alisio analysis sweep [--force]`: the retention sweep now (it also runs by itself, daily). */
+export declare function sweep(o: Common, force: boolean): Promise<void>;
+export {};

package/dist/analysis.js

@@ -0,0 +1,145 @@
+/**
+ * `alisio analysis …` and the analysis line of `alisio doctor`: the state of the Python runtime,
+ * the optional extras (`setup --extras`, hash-locked, needs network), the optional container
+ * runtime (`setup --oci`) and the retention sweep (`sweep`). None of these is needed to run
+ * `python_run`: the base runtime is the discovered Python with only the standard library.
+ */
+import { dirname, join } from "node:path";
+async function context(o) {
+    const core = await import("@alisio/core");
+    const workspace = await core.findWorkspace(o.cwd ?? process.cwd());
+    const { config, provenance } = await core.loadConfigWithProvenance(workspace, {
+        file: o.config,
+        trustProject: o.trustProject,
+    });
+    const stateDir = o.db && o.db !== ":memory:" ? dirname(o.db) : core.stateHome();
+    const manager = new core.AnalysisRuntimeManager({
+        stateDir,
+        ...(o.python ? { python: o.python } : {}),
+    });
+    const oci = () => new core.OciRuntime({ ...config.analysis.oci });
+    return { core, config, provenance, stateDir, manager, oci };
+}
+/** The unified runtime state and, when Python is missing, the install guidance for this system. */
+export async function analysisState(o) {
+    const { core, config, provenance, stateDir, manager, oci } = await context(o);
+    const janitor = {
+        lastSweep: () => import("node:fs/promises")
+            .then((fs) => fs.readFile(join(stateDir, "analysis", ".last-sweep"), "utf8"))
+            .then((text) => {
+            const value = Number(text.trim());
+            return Number.isFinite(value) ? value : undefined;
+        })
+            .catch(() => undefined),
+    };
+    const status = await core.analysisStatus({
+        config: config.analysis,
+        runtime: manager,
+        oci,
+        janitor,
+        enabled: config.analysis.enabled,
+        readOnly: false,
+    });
+    const guidance = status.python.found
+        ? undefined
+        : (async () => {
+            const resolved = await manager.interpreter();
+            return resolved.ok
+                ? undefined
+                : core.installHintsText(core.pythonInstallHints(await core.detectHintHost(resolved.found)));
+        })();
+    return {
+        status,
+        ...(guidance ? { guidance: await guidance } : {}),
+        ignored: provenance.ignored ?? [],
+    };
+}
+/** Prints `alisio analysis status`. */
+export async function printAnalysisStatus(o) {
+    const { status, guidance, ignored } = await analysisState(o);
+    console.log(JSON.stringify(status, null, 2));
+    if (guidance)
+        process.stderr.write(`\n${guidance}\n`);
+    if (status.mode === "oci" && status.oci.available === false)
+        process.stderr.write(`\nThe container runtime is configured but not usable: ${status.oci.reason ?? "unknown reason"}\n`);
+    for (const key of ignored)
+        process.stderr.write(`\nIgnored ${key} from the project configuration: only your user configuration decides it.\n`);
+}
+/** `alisio analysis setup --extras analysis|science`: needs network; offline it fails cleanly. */
+export async function setupExtras(o, extras) {
+    if (extras !== "analysis" && extras !== "science")
+        throw new Error("Choose the extras to install: --extras analysis or --extras science");
+    const { core, manager } = await context(o);
+    const preview = core.installPreview(extras);
+    const controller = new AbortController();
+    process.on("SIGINT", () => controller.abort(new Error("Interrupted")));
+    process.stderr.write(`Installing the ${extras} extras: ${preview.packages.join(", ")} (+ dependencies, ${preview.packageCount} packages, about ${Math.round(preview.estimatedBytes / (1024 * 1024))} MB). ` +
+        "Wheels only, hashes required, needs network.\n");
+    try {
+        const state = await manager.installExtras(extras, {
+            signal: controller.signal,
+            onOutput: (text) => process.stderr.write(text),
+        });
+        console.log(JSON.stringify(state, null, 2));
+    }
+    catch (error) {
+        // A clean message and a failing exit code; the base runtime is untouched.
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    }
+}
+/**
+ * `alisio analysis setup --oci [--image <name>]`: pulls the image once and verifies it. With a
+ * digest-pinned reference the pull verifies the digest; with a tag it prints the digest to put in
+ * `analysis.oci.image` (Alisio never writes it: only you choose what runs your code).
+ */
+export async function setupOci(o, image) {
+    const { core, config } = await context(o);
+    const reference = image ?? config.analysis.oci.image;
+    if (!reference)
+        throw new Error("Pass --image <name[:tag]> (or set analysis.oci.image in your user configuration) to pull.");
+    const runtime = new core.OciRuntime({ ...config.analysis.oci, image: undefined });
+    const status = await runtime.status();
+    if (!status.ok)
+        throw new Error(`${status.reason}${status.alternative ? `; ${status.alternative} is installed (set analysis.oci.engine to "${status.alternative}")` : ""}. The container runtime is optional; python_run works without it.`);
+    process.stderr.write(`Pulling ${reference} with ${status.engine} ${status.version}…\n`);
+    const controller = new AbortController();
+    process.on("SIGINT", () => controller.abort(new Error("Interrupted")));
+    const { digest } = await runtime.pull(reference, controller.signal);
+    const pinned = core.OCI_IMAGE_PATTERN.test(reference);
+    if (pinned) {
+        const wanted = reference.slice(reference.indexOf("@") + 1);
+        if (digest && !digest.endsWith(wanted))
+            throw new Error(`The pulled image reports ${digest}, not the pinned ${wanted}`);
+        console.log(`Verified ${reference}. Set analysis.runtime to "oci" to use it.`);
+    }
+    else if (digest)
+        console.log(`Pulled ${reference}. To use it, put this in your user configuration (${core.configHome()}):\n` +
+            `  "analysis": { "runtime": "oci", "oci": { "engine": "${status.engine}", "image": "${digest}" } }`);
+    else
+        throw new Error(`${reference} has no repository digest (a locally built image?). Push it to a registry or pull a published image.`);
+}
+/** `alisio analysis sweep [--force]`: the retention sweep now (it also runs by itself, daily). */
+export async function sweep(o, force) {
+    const { core, config, stateDir } = await context(o);
+    const store = new core.SQLiteStore(o.db ?? join(stateDir, "sessions.sqlite"));
+    try {
+        const artifacts = new core.ArtifactStore({ root: stateDir, db: store.db });
+        const datasets = new core.DatasetService({ root: stateDir, db: store.db });
+        const blobs = new core.BlobStore({ root: join(stateDir, "blobs"), db: store.db });
+        const janitor = new core.AnalysisJanitor({
+            root: stateDir,
+            db: store.db,
+            artifacts,
+            datasets,
+            blobs,
+            retention: () => config.analysis.retention,
+        });
+        const report = await janitor.sweep({ force });
+        console.log(JSON.stringify(report, null, 2));
+        datasets.close();
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/banner.js

@@ -21,7 +21,8 @@ export function terminalCapabilities(input) {
     const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "";
     return {
         color: input.tty && !dumb && env.NO_COLOR === undefined,
-        unicode: !dumb && !/^(C|POSIX)(\.|$)/i.test(locale),
+        // `C.UTF-8` is a UTF-8 locale (the default on CI runners); only bare C/POSIX is ASCII.
+        unicode: !dumb && (/utf-?8/i.test(locale) || !/^(C|POSIX)(\.|$)/i.test(locale)),
         columns: input.columns > 0 ? input.columns : 80,
         interactive: input.tty,
     };

package/dist/main.js

@@ -35,6 +35,8 @@ program
     .option("--api-mode <mode>", "chat or responses")
     .option("--allow-write", "Allow file writes")
     .option("--allow-process", "Allow arbitrary subprocesses; not sandboxed")
+    .option("--allow-analysis", "Allow Python analysis (python_run) without asking; not sandboxed, never allows shell")
+    .option("--python <path>", "Python 3.10+ interpreter for python_run (default: discovered)")
     .option("--allow-external", "Allow network tools: webfetch, websearch and provider-native search")
     .option("--allow-mcp", "Allow configured MCP servers and remote tool calls")
     .option("--allow-agents", "Allow messaging neighboring agents through Herdr")
@@ -116,7 +118,7 @@ async function run(cmd, prompt, sessionId) {
         const trusted = await withProjectTrust(opts);
         return runTui({ ...trusted, ...(sessionId ? { session: sessionId } : {}) });
     }
-    const { createApplication } = await import("@alisio/core");
+    const { createApplication, formatBytes, KIND_LABELS } = await import("@alisio/core");
     const app = await createApplication({
         ...(await cliDefaults()),
         ...opts,
@@ -125,10 +127,21 @@ async function run(cmd, prompt, sessionId) {
                 process.stdout.write(`${JSON.stringify(event)}\n`);
             else if (event.type === "text_delta")
                 process.stdout.write(String(event.data.delta));
+            else if (event.type === "request_retry") {
+                const retry = event.data;
+                process.stderr.write(`\nThe model did not respond; retrying (${retry.attempt}/${retry.of})…\n`);
+            }
             else if (event.type === "tool_started")
                 process.stderr.write(`\n→ ${event.data.name}\n`);
+            else if (event.type === "artifact_published")
+                process.stderr.write(artifactLine(event));
         },
     });
+    /** `artifact: Dashboard site.zip (48 KB) → /abs/path` (nothing is opened automatically). */
+    function artifactLine(event) {
+        const data = event.data;
+        return `artifact: ${KIND_LABELS[data.artifact.kind] ?? "File"} ${data.artifact.fileName} (${formatBytes(data.artifact.bytes)}) → ${data.path}\n`;
+    }
     for (const failure of app.mcpStartupFailures())
         process.stderr.write(`[startup] ${failure}\n`);
     // The ACTIVE agent (built-in `build`/`plan` or a main-capable definition) drives the main
@@ -349,13 +362,61 @@ program.command("doctor").action(async (_opts, cmd) => {
                 : config.provider.auth === "none" || !!process.env[config.provider.apiKeyEnv],
         },
     };
-    console.log(JSON.stringify(status, null, 2));
+    const { analysisState } = await import("./analysis.js");
+    const analysisInfo = await analysisState(o);
+    const { hints: _hints, ...pythonInfo } = analysisInfo.status.python;
+    console.log(JSON.stringify({
+        ...status,
+        python: { mode: analysisInfo.status.mode, ...pythonInfo },
+        analysis: {
+            mode: analysisInfo.status.mode,
+            oci: analysisInfo.status.oci,
+            limits: analysisInfo.status.limits,
+            retention: analysisInfo.status.retention,
+            ...(analysisInfo.ignored.length ? { ignored: analysisInfo.ignored } : {}),
+        },
+    }, null, 2));
+    if (analysisInfo.guidance)
+        process.stderr.write(`\n${analysisInfo.guidance}\n`);
+    for (const key of provenance.ignored ?? [])
+        process.stderr.write(`\nIgnored ${key} from the project configuration: only your user configuration decides it.\n`);
     if (!status.ripgrep)
         process.stderr.write(`\nWarning: ripgrep (rg) is not installed; search_text and list_files will not work. ${RIPGREP_INSTALL_HINT}\n`);
     if (!model || model === "YOUR_MODEL_ID")
         console.error("\nNo model configured yet: set provider.model in your config, --model, or ALISIO_MODEL " +
             "before starting a real conversation (it will otherwise fail on the first turn).");
 });
+const analysis = program
+    .command("analysis")
+    .description("Python analysis runtime (python_run): status, optional extras and containers");
+analysis
+    .command("status")
+    .description("Show the runtime: Python, extras, container engine, limits and retention")
+    .action(async (_opts, cmd) => {
+    const { printAnalysisStatus } = await import("./analysis.js");
+    await printAnalysisStatus(options(cmd));
+});
+analysis
+    .command("setup")
+    .description("Optional: install hash-locked Python extras (--extras) or pull the container image (--oci). " +
+    "python_run never needs this for the standard library.")
+    .option("--extras <set>", "analysis (pandas, numpy, matplotlib…) or science (adds scipy…)")
+    .option("--oci", "Pull the container image once and verify its digest (Docker or Podman)")
+    .option("--image <name>", "With --oci: the image to pull (default: analysis.oci.image)")
+    .action(async (flags, cmd) => {
+    const { setupExtras, setupOci } = await import("./analysis.js");
+    if (flags.oci)
+        return setupOci(options(cmd), flags.image);
+    return setupExtras(options(cmd), flags.extras);
+});
+analysis
+    .command("sweep")
+    .description("Run the retention sweep now (it also runs by itself at most once a day)")
+    .option("--force", "Ignore the once-a-day mark")
+    .action(async (flags, cmd) => {
+    const { sweep } = await import("./analysis.js");
+    await sweep(options(cmd), !!flags.force);
+});
 const trust = program.command("trust").description("Inspect or revoke per-directory project trust");
 trust.command("list").action(async () => {
     const { listTrust } = await import("@alisio/core");

package/dist/tui/app.js

@@ -1,16 +1,20 @@
 import { homedir } from "node:os";
-import { AGENT_TEMPLATES, agentAuthoringGuidance, agentCommandDescriptors, agentIdFromCommand, agentModelCapabilities, agentModelLabels, agentModelOptions, generateAgentDraft, } from "@alisio/core";
+import { join } from "node:path";
+import { AGENT_TEMPLATES, agentAuthoringGuidance, agentCommandDescriptors, agentIdFromCommand, agentModelCapabilities, agentModelLabels, agentModelOptions, generateAgentDraft, NOT_SANDBOXED, toGrantWire, toRef, } from "@alisio/core";
 import { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, getNativeClipboard, Key, MouseRegion, matchesKey, ProcessTerminal, ScrollView, SelectList, TuiAltScreen, truncateToWidth, VStack, } from "@earendil-works/pi-tui";
 import { loadVersion } from "../version.js";
 import { AGENT_PICKER_ACTIONS, agentEditorRows, agentFieldChoices, agentFieldSupported, agentPickerRows, applyDraft, decodeMultiline, emptyAgentForm, encodeMultiline, filterAgentRows, formErrors, formFromDefinition, formFromTemplate, formToInput, parseAgentsArgs, } from "./agent-manager.js";
 import { activeAgentCatalog, agentRunOptions, mainAgentFromRecord, resolveActiveAgent, } from "./agents.js";
+import { ArtifactPreview, loadPreview } from "./artifact-preview.js";
+import { ARTIFACTS_HINT, artifactActions, artifactRow, capabilityApprovalTitle, detailRows, installApprovalDetail, installApprovalTitle, matchArtifact, permissionRow, } from "./artifacts.js";
 import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_IMAGE_BYTES, pasteImageFromClipboard, removeLastAttachment, toApiAttachment, } from "./attachments.js";
 import { BTW_DESCRIPTION, BTW_USAGE, btwBrowser, btwPending } from "./btw.js";
 import { copyText, nodeSpawn } from "./clipboard.js";
-import { AttachmentsBar, BannerBlock, BtwPanel, ContentInset, clock, contentInnerWidth, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
+import { AttachmentsBar, BannerBlock, BtwPanel, ContentInset, clock, contentInnerWidth, Footer, Header, QuestionPanel, Switch, setArtifactPathResolver, 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 { cannotOpenMessage, openPath, revealPath } from "./open-path.js";
 import { initialPanelState, reducePanel, visibleRows } from "./panel.js";
 import { summarizeAnswers } from "./questions.js";
 import { InteractiveQueue } from "./queue.js";
@@ -479,6 +483,12 @@ export async function runTui(options) {
     const error = (e) => push({ kind: "error", text: e instanceof Error ? e.message : String(e) });
     const info = (text) => push({ kind: "info", text });
     let terminalEvent = false;
+    let artifactsThisRun = 0;
+    // Artifact announcements show the real local file (resolved from the store, never the model).
+    setArtifactPathResolver((id) => {
+        const record = app.artifacts.get(id);
+        return record?.status === "ready" ? app.artifacts.localPath(record) : undefined;
+    });
     dispatch = (event) => {
         // The event stream stays text-only (headless/JSONL consumers see the projection); the TUI
         // pulls the persisted rich parts (ui/image) itself so native rendering survives resume.
@@ -497,15 +507,22 @@ export async function runTui(options) {
             tui.requestRender();
             return;
         }
-        if ([
+        if (event.type === "artifact_published")
+            artifactsThisRun++;
+        const ended = [
             "run_completed",
             "run_failed",
             "run_cancelled",
             "run_turns_exceeded",
             "compaction_failed",
-        ].includes(event.type))
+        ].includes(event.type);
+        if (ended)
             terminalEvent = true;
         view = reduceEvent(view, event);
+        if (ended && event.type !== "compaction_failed" && artifactsThisRun > 0) {
+            artifactsThisRun = 0;
+            view = addItem(view, { kind: "notice", text: ARTIFACTS_HINT });
+        }
         sync();
     };
     const refreshEstimate = () => {
@@ -562,6 +579,31 @@ export async function runTui(options) {
             };
             const onAbort = () => finish("deny");
             request.signal.addEventListener("abort", onAbort, { once: true });
+            if (request.capability === "analysis.install" && request.install) {
+                // Installing the optional packages: only once or deny (never stored), with what is
+                // installed, the download estimate and that it needs the network.
+                showPicker(new Picker(`${request.label ? `[${request.label}] ` : ""}${installApprovalTitle(request.install)}`, [
+                    { value: "once", label: "Allow once" },
+                    { value: "deny", label: "Deny" },
+                ], (item) => finish(item.value), () => finish("deny"), false, installApprovalDetail(request.install)));
+                return;
+            }
+            if (request.capability) {
+                // A capability (Python analysis): its own title, the script preview and the
+                // not-a-sandbox warning; "for this session" is persisted for the root session.
+                showPicker(new Picker(`${request.label ? `[${request.label}] ` : ""}${capabilityApprovalTitle(request.runtime)}`, [
+                    { value: "once", label: "Allow once" },
+                    { value: "session", label: "Allow for this session" },
+                    { value: "deny", label: "Deny" },
+                ], (item) => finish(item.value), () => finish("deny"), false, [
+                    request.preview ?? "",
+                    "",
+                    request.runtime === "oci"
+                        ? "Runs in a container without network access. Repository files are not modified by this step."
+                        : `${NOT_SANDBOXED} It could change repository files; Alisio itself does not modify them in this step.`,
+                ].join("\n")));
+                return;
+            }
             showPicker(new Picker(`${request.label ? `[${request.label}] ` : ""}Allow ${request.call.name} (${request.effect}): ${summarizeToolArgs(request.call.name, request.call.arguments)}?`, [
                 { value: "once", label: "Allow once" },
                 { value: "session", label: `Always allow ${request.effect} in this session` },
@@ -684,6 +726,156 @@ export async function runTui(options) {
             tui.requestRender();
         }
     };
+    /** `/artifacts [filter]`: the root session's artifacts, newest first, then their actions. */
+    const browseArtifacts = (filter) => {
+        const all = app.artifacts
+            .list(app.store.rootOf(session), { limit: 500, includeExpired: true })
+            .map(toRef);
+        const shown = filter ? all.filter((artifact) => matchArtifact(artifact, filter)) : all;
+        if (!shown.length)
+            return notice(all.length ? `No artifacts match "${filter}"` : "No artifacts in this session yet.");
+        const byId = new Map(all.map((artifact) => [artifact.id, artifact]));
+        const now = Date.now();
+        showPicker(new Picker(`Artifacts · ${shown.length}`, shown.map((artifact) => ({ value: artifact.id, label: artifactRow(artifact, now) })), (item) => artifactMenu(item.value, filter), () => closePicker(), true, undefined, (items, text) => items.filter((item) => {
+            const artifact = byId.get(item.value);
+            return !!artifact && matchArtifact(artifact, text);
+        })));
+    };
+    const artifactMenu = (id, filter) => {
+        const record = app.artifacts.get(id);
+        if (!record || (record.status !== "ready" && record.status !== "expired")) {
+            closePicker();
+            return notice("This artifact is no longer available.");
+        }
+        const artifact = toRef(record);
+        const path = app.artifacts.localPath(record);
+        const back = () => artifactMenu(id, filter);
+        const copyPath = async () => {
+            const result = await copy(path);
+            closePicker();
+            if (result.ok)
+                tui.flash("Path copied");
+            else
+                notice(`${copyMessage(result)}. Path: ${path}`);
+        };
+        /** Opens (or reveals) a store path; without a desktop, offers to copy it instead. */
+        const launch = async (target, reveal) => {
+            const outcome = await (reveal ? revealPath(target) : openPath(target));
+            if (outcome.ok)
+                return closePicker();
+            // No desktop (SSH, no display) or no opener: nothing was launched; offer the path.
+            return showPicker(new Picker(cannotOpenMessage(target, outcome), [
+                { value: "copy", label: "Copy path" },
+                { value: "close", label: "Close" },
+            ], (choice) => choice.value === "copy"
+                ? void copy(target).then((result) => {
+                    closePicker();
+                    if (result.ok)
+                        tui.flash("Path copied");
+                    else
+                        notice(`${copyMessage(result)}. Path: ${target}`);
+                })
+                : closePicker(), () => closePicker()));
+        };
+        // `Copy to workspace…` needs artifact_export (absent under --read-only or with analysis off).
+        const canExport = !options.readOnly && app.registry.list().some((tool) => tool.name === "artifact_export");
+        const job = record.executionId ? app.analysis.jobs.get(record.executionId) : undefined;
+        // `Rerun` runs python_run { rerunOf } (absent under --read-only or with analysis disabled).
+        const canRerun = !options.readOnly && app.registry.list().some((tool) => tool.name === "python_run");
+        showPicker(new Picker(artifact.fileName, artifactActions(artifact, {
+            readOnly: !canExport,
+            sources: !!job,
+            rerun: !!job && canRerun,
+        }), (item) => void (async () => {
+            if (item.value === "copy")
+                return copyPath();
+            if (item.value === "open" || item.value === "reveal")
+                return launch(path, item.value === "reveal");
+            if (item.value === "preview") {
+                const preview = await loadPreview(artifact, path);
+                return showPicker(new ArtifactPreview(artifact, preview, {
+                    height: () => Math.max(5, (process.stdout.rows ?? 24) - 12),
+                    open: () => void launch(path, false).catch(error),
+                    copy: () => void copyPath().catch(error),
+                    close: back,
+                }));
+            }
+            if (item.value === "sources" && job)
+                // An explicit user action: the job folder (script, logs, work) of this execution.
+                return launch(join(app.artifacts.root, ...job.relDir.split(/[\\/]/)), false);
+            if (item.value === "details") {
+                const provenance = record.provenance;
+                return showPicker(new Picker(`Details · ${artifact.fileName}`, [{ value: "back", label: "Back" }], back, back, false, detailRows(artifact, provenance)
+                    .map(([label, value]) => `${label}: ${value}`)
+                    .join("\n")));
+            }
+            if (item.value === "rerun") {
+                if (busy) {
+                    closePicker();
+                    return notice("Wait until the current run finishes, then run the analysis again.");
+                }
+                closePicker();
+                info(`Run the analysis of ${artifact.fileName} again`);
+                // A tool call without the model: the same capability gate as the first run.
+                void task((signal) => app.runner.runToolCall(session, "python_run", { rerunOf: id }, { signal, display: `Run the analysis of ${artifact.fileName} again` }));
+                return;
+            }
+            if (item.value === "export") {
+                if (busy) {
+                    closePicker();
+                    return notice("Wait until the current run finishes, then copy the artifact.");
+                }
+                return showPicker(new ConnectInputPrompt({
+                    provider: "",
+                    title: `Copy ${artifact.fileName} to the workspace`,
+                    label: "Folder in the workspace",
+                    initial: ".",
+                    secret: false,
+                    placeholder: ".",
+                    hint: "Relative to the workspace. Writing asks first unless --allow-write.",
+                    step: 1,
+                    steps: 1,
+                    onSubmit: (target) => {
+                        closePicker();
+                        info(`Copy ${artifact.fileName} to the workspace (${target.trim() || "."})`);
+                        // A tool call without the model: the write gate (approval) applies as usual.
+                        void task((signal) => app.runner.runToolCall(session, "artifact_export", { id, target: target.trim() || "." }, {
+                            signal,
+                            display: `Copy ${artifact.fileName} to the workspace (${target.trim() || "."})`,
+                        }));
+                    },
+                    onCancel: back,
+                }));
+            }
+            if (item.value === "delete")
+                return showPicker(new Picker(`Delete ${artifact.fileName}? This can't be undone.`, [
+                    { value: "delete", label: "Delete" },
+                    { value: "cancel", label: "Cancel" },
+                ], (choice) => void (async () => {
+                    if (choice.value !== "delete")
+                        return back();
+                    await app.artifacts.delete(id);
+                    closePicker();
+                    notice(`Deleted ${artifact.fileName}`);
+                })(), back));
+        })().catch(error), () => browseArtifacts(filter)));
+    };
+    /** `/permissions`: persisted grants of the root session; choosing one offers to revoke it. */
+    const managePermissions = () => {
+        const grants = app.capabilityGrants.live(session).map(toGrantWire);
+        if (!grants.length)
+            return notice("No saved permissions in this session.");
+        showPicker(new Picker("Session permissions", grants.map((grant) => ({ value: grant.id, label: permissionRow(grant) })), (item) => showPicker(new Picker(`Revoke "${item.label}"?`, [
+            { value: "revoke", label: "Revoke" },
+            { value: "cancel", label: "Cancel" },
+        ], (choice) => {
+            if (choice.value !== "revoke")
+                return managePermissions();
+            app.capabilityGrants.revoke(session, item.value, "tui");
+            closePicker();
+            notice("Permission revoked: the next Python analysis asks again.");
+        }, () => managePermissions())), () => closePicker()));
+    };
     const runPrompt = (display, prompt, persistDisplay) => {
         // Any pending clipboard-pasted images ride along with the very next turn, then are cleared.
         const attachments = pendingAttachments.map(toApiAttachment);
@@ -1740,7 +1932,9 @@ export async function runTui(options) {
                     .finally(settle);
                 return;
             }
-            const stored = row.id === "limits.timeoutMs" ? Number(value) * 1000 : value;
+            const stored = row.id === "limits.timeoutMs" || row.id === "analysis.limits.timeoutMs"
+                ? Number(value) * 1000
+                : value;
             void app
                 // Setting ids are the exact SettableSettingKey paths SETTINGS_DEFINITIONS is built from.
                 .updateSetting(row.id, stored)
@@ -2026,6 +2220,10 @@ export async function runTui(options) {
                 }
                 case "btw":
                     return await sideQuestion(parsed.args);
+                case "artifacts":
+                    return browseArtifacts(parsed.args);
+                case "permissions":
+                    return managePermissions();
                 case "ask": {
                     if (!parsed.args)
                         return notice("Usage: /ask <question>");

package/dist/tui/artifact-preview.d.ts

@@ -0,0 +1,52 @@
+import type { ArtifactRef, UiBlock } from "@alisio/sdk";
+import { type Component } from "@earendil-works/pi-tui";
+export declare const PREVIEW_MAX_BYTES: number;
+export declare const PREVIEW_MAX_LINES = 2000;
+export declare const PREVIEW_MAX_ROWS = 200;
+export declare const PREVIEW_MAX_COLUMNS = 20;
+export type PreviewKind = "markdown" | "table" | "json" | "text";
+/** How an artifact previews in the terminal, or undefined when it only opens externally. */
+export declare function previewKind(artifact: ArtifactRef): PreviewKind | undefined;
+export interface Preview {
+    block: UiBlock;
+    truncated: boolean;
+    /** Table legend: `showing 200 of 12,480 rows · 20 of 31 columns`. */
+    legend?: string;
+}
+/**
+ * RFC 4180 rows (quotes, doubled quotes, newlines inside quotes, CRLF/LF/CR), up to `limit`, with
+ * the same parser the dataset ingestion uses (so the preview and `data_inspect` agree).
+ */
+export declare function parseDelimited(text: string, delimiter: string, limit?: number): {
+    rows: string[][];
+    total: number;
+    complete: boolean;
+};
+/** The preview of an artifact from its leading bytes (the caller reads them, bounded). */
+export declare function buildPreview(artifact: ArtifactRef, bytes: Uint8Array, fileBytes?: number): Preview;
+/** Reads the bytes a preview needs (never the whole of a large file). */
+export declare function loadPreview(artifact: ArtifactRef, path: string): Promise<Preview>;
+/**
+ * A bounded, scrollable preview panel: ↑/↓, PgUp/PgDn, Home/End scroll; `o` opens with the
+ * system app, `c` copies the path, `Esc` or `q` closes. The footer says `truncated` when cut.
+ */
+export declare class ArtifactPreview implements Component {
+    private readonly artifact;
+    private readonly preview;
+    private readonly options;
+    private offset;
+    private lines;
+    private renderedWidth;
+    constructor(artifact: ArtifactRef, preview: Preview, options: {
+        /** Rows available for the body (the panel adds a title and a footer). */
+        height: () => number;
+        open: () => void;
+        copy: () => void;
+        close: () => void;
+    });
+    invalidate(): void;
+    private page;
+    private clamp;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}