@alisio/core 0.1.0-alpha.3

package/dist/runtime/store.d.ts

@@ -0,0 +1,37 @@
+import { type Message, type SqlDatabase, type ToolCall, type ToolResult } from "@alisio/sdk";
+import type { Session, SessionStore } from "../core/contracts.ts";
+export declare class SQLiteStore implements SessionStore {
+    readonly db: SqlDatabase;
+    constructor(path: string);
+    /** Forward-only, idempotent migrations. Existing databases keep all rows. */
+    private migrate;
+    create(workspace: string, provider: string, model: string): Session;
+    private row;
+    get(id: string): Session;
+    /** Root sessions (children are listed through `children`). */
+    list(): Session[];
+    createChild(record: import("../core/contracts.ts").ChildSessionRecord): Session;
+    children(parentId: string): Session[];
+    updateSession(id: string, patch: {
+        status?: Session["status"];
+        usage?: {
+            input: number;
+            output: number;
+        };
+    }): void;
+    updateBinding(id: string, provider: string, model: string): void;
+    interruptStale(): number;
+    messages(id: string): Message[];
+    append(id: string, message: Message): void;
+    setModel(id: string, model: string): void;
+    compact(id: string, replaced: number, summary: Message): void;
+    acquire(id: string): void;
+    release(id: string): void;
+    beginCall(id: string, call: ToolCall): void;
+    endCall(id: string, call: ToolCall, result: ToolResult): void;
+    reconcile(id: string, acknowledge?: boolean): void;
+    event(id: string, runId: string, type: string, data: unknown): void;
+    getState(plugin: string, key: string): unknown;
+    setState(plugin: string, key: string, value: unknown): void;
+    close(): void;
+}

package/dist/runtime/store.js

@@ -0,0 +1,250 @@
+import { textResult, } from "@alisio/sdk";
+import { openDatabase } from "./sqlite.js";
+export class SQLiteStore {
+    db;
+    constructor(path) {
+        this.db = openDatabase(path);
+        this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;
+      CREATE TABLE IF NOT EXISTS schema_migrations(version INTEGER PRIMARY KEY);
+      INSERT OR IGNORE INTO schema_migrations VALUES(1);
+      CREATE TABLE IF NOT EXISTS sessions(id TEXT PRIMARY KEY,workspace TEXT,provider TEXT,model TEXT,locked_pid INTEGER);
+      CREATE TABLE IF NOT EXISTS messages(seq INTEGER PRIMARY KEY AUTOINCREMENT,session TEXT REFERENCES sessions(id),body TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS tool_calls(session TEXT,call_id TEXT,status TEXT,result TEXT,PRIMARY KEY(session,call_id));
+      CREATE TABLE IF NOT EXISTS events(seq INTEGER PRIMARY KEY AUTOINCREMENT,session TEXT,run_id TEXT,type TEXT,body TEXT);
+      CREATE TABLE IF NOT EXISTS plugin_state(plugin TEXT,key TEXT,value TEXT,PRIMARY KEY(plugin,key));`);
+        this.migrate();
+    }
+    /** Forward-only, idempotent migrations. Existing databases keep all rows. */
+    migrate() {
+        const has = (version) => !!this.db.prepare("SELECT 1 FROM schema_migrations WHERE version=?").get(version);
+        if (!has(2))
+            this.db.transaction(() => {
+                const columns = this.db.prepare("PRAGMA table_info(messages)").all();
+                // Compacted rows stay for audit but are excluded from the active conversation.
+                if (!columns.some((c) => c.name === "compacted"))
+                    this.db.exec("ALTER TABLE messages ADD COLUMN compacted INTEGER NOT NULL DEFAULT 0");
+                this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(2)");
+            });
+        if (!has(3))
+            this.db.transaction(() => {
+                // Child sessions: parent link, depth, agent label, lifecycle status, usage and spec.
+                const columns = new Set(this.db.prepare("PRAGMA table_info(sessions)").all().map((c) => c.name));
+                const add = (name, type) => {
+                    if (!columns.has(name))
+                        this.db.exec(`ALTER TABLE sessions ADD COLUMN ${name} ${type}`);
+                };
+                add("parent_id", "TEXT");
+                add("depth", "INTEGER NOT NULL DEFAULT 0");
+                add("agent", "TEXT");
+                add("status", "TEXT");
+                add("title", "TEXT");
+                add("usage", "TEXT");
+                add("options", "TEXT");
+                add("created_at", "INTEGER");
+                add("updated_at", "INTEGER");
+                this.db.exec("CREATE INDEX IF NOT EXISTS sessions_parent ON sessions(parent_id)");
+                this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(3)");
+            });
+    }
+    create(workspace, provider, model) {
+        const id = crypto.randomUUID();
+        this.db
+            .prepare("INSERT INTO sessions(id,workspace,provider,model) VALUES(?,?,?,?)")
+            .run(id, workspace, provider, model);
+        return { id, workspace, provider, model };
+    }
+    row(r) {
+        return {
+            id: String(r.id),
+            workspace: String(r.workspace),
+            provider: String(r.provider),
+            model: String(r.model),
+            ...(r.parent_id ? { parentId: String(r.parent_id) } : {}),
+            ...(r.parent_id ? { depth: Number(r.depth ?? 0) } : {}),
+            ...(r.agent ? { agent: String(r.agent) } : {}),
+            ...(r.status ? { status: r.status } : {}),
+            ...(r.title ? { title: String(r.title) } : {}),
+            ...(r.usage ? { usage: JSON.parse(String(r.usage)) } : {}),
+            ...(r.options ? { options: JSON.parse(String(r.options)) } : {}),
+            ...(r.created_at ? { createdAt: Number(r.created_at) } : {}),
+            ...(r.updated_at ? { updatedAt: Number(r.updated_at) } : {}),
+        };
+    }
+    get(id) {
+        const row = this.db.prepare("SELECT * FROM sessions WHERE id=?").get(id);
+        if (!row)
+            throw new Error(`Session not found: ${id}`);
+        return this.row(row);
+    }
+    /** Root sessions (children are listed through `children`). */
+    list() {
+        return this.db
+            .prepare("SELECT * FROM sessions WHERE parent_id IS NULL ORDER BY rowid DESC")
+            .all()
+            .map((r) => this.row(r));
+    }
+    createChild(record) {
+        const id = record.id ?? crypto.randomUUID();
+        const now = Date.now();
+        this.db
+            .prepare(`INSERT INTO sessions(id,workspace,provider,model,parent_id,depth,agent,status,title,usage,options,created_at,updated_at)
+         VALUES(?,?,?,?,?,?,?,'queued',?,?,?,?,?)`)
+            .run(id, record.workspace, record.provider, record.model, record.parentId, record.depth, record.agent, record.title, JSON.stringify({ input: 0, output: 0 }), JSON.stringify(record.options), now, now);
+        return this.get(id);
+    }
+    children(parentId) {
+        return this.db
+            .prepare("SELECT * FROM sessions WHERE parent_id=? ORDER BY created_at, rowid")
+            .all(parentId)
+            .map((r) => this.row(r));
+    }
+    updateSession(id, patch) {
+        if (patch.status)
+            this.db
+                .prepare("UPDATE sessions SET status=?, updated_at=? WHERE id=?")
+                .run(patch.status, Date.now(), id);
+        if (patch.usage)
+            this.db
+                .prepare("UPDATE sessions SET usage=?, updated_at=? WHERE id=?")
+                .run(JSON.stringify(patch.usage), Date.now(), id);
+    }
+    updateBinding(id, provider, model) {
+        if (!provider.trim() || !model.trim())
+            throw new Error("Provider and model must not be empty");
+        this.get(id);
+        this.db
+            .prepare("UPDATE sessions SET provider=?, model=?, updated_at=? WHERE id=?")
+            .run(provider, model, Date.now(), id);
+    }
+    interruptStale() {
+        let count = 0;
+        const rows = this.db
+            .prepare("SELECT id, locked_pid FROM sessions WHERE status IN ('queued','running')")
+            .all();
+        for (const row of rows) {
+            if (row.locked_pid && row.locked_pid !== process.pid) {
+                try {
+                    process.kill(row.locked_pid, 0);
+                    continue; // Another live process owns it.
+                }
+                catch {
+                    /* dead owner */
+                }
+            }
+            if (row.locked_pid === process.pid)
+                continue;
+            this.updateSession(row.id, { status: "interrupted" });
+            count++;
+        }
+        return count;
+    }
+    messages(id) {
+        return this.db
+            .prepare("SELECT body FROM messages WHERE session=? AND compacted=0 ORDER BY seq")
+            .all(id).map((x) => JSON.parse(x.body));
+    }
+    append(id, message) {
+        this.db
+            .prepare("INSERT INTO messages(session,body) VALUES(?,?)")
+            .run(id, JSON.stringify(message));
+    }
+    setModel(id, model) {
+        if (!model.trim())
+            throw new Error("Model ID must not be empty");
+        this.get(id);
+        this.db.prepare("UPDATE sessions SET model=? WHERE id=?").run(model, id);
+    }
+    compact(id, replaced, summary) {
+        this.db.transaction(() => {
+            const rows = this.db
+                .prepare("SELECT seq,body FROM messages WHERE session=? AND compacted=0 ORDER BY seq")
+                .all(id);
+            if (replaced < 1 || replaced > rows.length)
+                throw new Error("Compaction range does not match the active history");
+            // Keep ordering by seq: retire every active row, then write summary + kept copies.
+            this.db.prepare("UPDATE messages SET compacted=1 WHERE session=? AND compacted=0").run(id);
+            this.append(id, summary);
+            for (const row of rows.slice(replaced))
+                this.db.prepare("INSERT INTO messages(session,body) VALUES(?,?)").run(id, row.body);
+        });
+    }
+    acquire(id) {
+        this.db.transaction(() => {
+            this.get(id);
+            const row = this.db.prepare("SELECT locked_pid FROM sessions WHERE id=?").get(id);
+            if (row.locked_pid) {
+                let alive = true;
+                try {
+                    process.kill(row.locked_pid, 0);
+                }
+                catch (e) {
+                    if (e.code === "ESRCH")
+                        alive = false;
+                }
+                if (alive)
+                    throw new Error("Session is already in use");
+            }
+            this.db.prepare("UPDATE sessions SET locked_pid=? WHERE id=?").run(process.pid, id);
+        });
+    }
+    release(id) {
+        this.db
+            .prepare("UPDATE sessions SET locked_pid=NULL WHERE id=? AND locked_pid=?")
+            .run(id, process.pid);
+    }
+    beginCall(id, call) {
+        this.db
+            .prepare("INSERT INTO tool_calls(session,call_id,status) VALUES(?,?,'pending')")
+            .run(id, call.id);
+    }
+    endCall(id, call, result) {
+        this.db
+            .prepare("INSERT INTO tool_calls(session,call_id,status,result) VALUES(?,?,'completed',?) ON CONFLICT(session,call_id) DO UPDATE SET status='completed',result=excluded.result")
+            .run(id, call.id, JSON.stringify(result));
+    }
+    reconcile(id, acknowledge = false) {
+        this.db.transaction(() => {
+            const messages = this.messages(id);
+            const done = new Set(messages.filter((m) => m.role === "tool").map((m) => m.callId));
+            for (const m of messages) {
+                if (m.role !== "assistant")
+                    continue;
+                for (const call of m.calls) {
+                    if (done.has(call.id))
+                        continue;
+                    const row = this.db
+                        .prepare("SELECT status,result FROM tool_calls WHERE session=? AND call_id=?")
+                        .get(id, call.id);
+                    if (row?.status === "pending" && !acknowledge)
+                        throw new Error(`Uncertain tool outcome ${call.id}. Inspect effects, then use sessions recover ${id} --acknowledge`);
+                    const result = row?.status === "completed" && row.result
+                        ? JSON.parse(row.result)
+                        : textResult(row
+                            ? "Previous execution outcome is uncertain; user acknowledged it. Do not repeat automatically."
+                            : "Previous run stopped before this tool was executed.", true);
+                    this.endCall(id, call, result);
+                    this.append(id, { role: "tool", callId: call.id, result });
+                }
+            }
+        });
+    }
+    event(id, runId, type, data) {
+        this.db
+            .prepare("INSERT INTO events(session,run_id,type,body) VALUES(?,?,?,?)")
+            .run(id, runId, type, JSON.stringify(data));
+    }
+    getState(plugin, key) {
+        const row = this.db
+            .prepare("SELECT value FROM plugin_state WHERE plugin=? AND key=?")
+            .get(plugin, key);
+        return row ? JSON.parse(row.value) : undefined;
+    }
+    setState(plugin, key, value) {
+        this.db
+            .prepare("INSERT INTO plugin_state VALUES(?,?,?) ON CONFLICT(plugin,key) DO UPDATE SET value=excluded.value")
+            .run(plugin, key, JSON.stringify(value));
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/sessions/children.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Generic child sessions (the `api.sessions` extension point). A child is a separate,
+ * persisted conversation with a parent link that runs through the same runner with narrowed
+ * permissions: it can never gain a capability, tool or approval its parent lacks. Nothing here
+ * knows about "agents" or delegation policies; plugins build those on top.
+ */
+import type { ChildRunResult, ChildSessionInfo, ChildSessionSpec, PluginAPI, ResolvedProviderModel, SessionStatus } from "@alisio/sdk";
+import type { ContextSource, Policy, SessionStore } from "../core/contracts.ts";
+import type { AgentRunner } from "../core/runner.ts";
+type SessionsAPI = PluginAPI["sessions"];
+export interface ChildSessionsOptions {
+    store: SessionStore;
+    runner: AgentRunner;
+    providerId: () => string;
+    resolveModel?: (reference: string, signal?: AbortSignal) => Promise<ResolvedProviderModel>;
+    bindProvider?: (sessionId: string, target: ResolvedProviderModel) => Promise<string>;
+    /** The root policy (the runner's; it may widen after "allow for session" approvals). */
+    rootPolicy: () => Policy;
+    rootApprovals: boolean;
+    readOnly: boolean;
+    contextFor: (workspace: string) => ContextSource;
+}
+export declare class ChildSessions implements SessionsAPI {
+    private o;
+    private cancelled;
+    constructor(o: ChildSessionsOptions);
+    private spec;
+    private info;
+    capabilities(id: string): {
+        write: boolean;
+        process: boolean;
+        approvals: boolean;
+        readOnly: boolean;
+    };
+    /** Tool filter for a session: the parent's filter AND the child's own allow/deny/effects. */
+    private filter;
+    spawn(spec: ChildSessionSpec): ChildSessionInfo;
+    create(spec: ChildSessionSpec): Promise<ChildSessionInfo>;
+    /** Agent path from the top-level child down, e.g. "general › explore". */
+    private label;
+    run(id: string, prompt: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ChildRunResult>;
+    get(id: string): ChildSessionInfo | undefined;
+    children(parentId: string): ChildSessionInfo[];
+    ancestors(id: string): string[];
+    private descendants;
+    cancel(id: string): number;
+    enqueue(id: string, text: string): void;
+    isRunning(id: string): boolean;
+    model(id: string): string;
+    workspace(id: string): string;
+    setStatus(id: string, status: SessionStatus): void;
+}
+export {};

package/dist/sessions/children.js

@@ -0,0 +1,231 @@
+const STATE_CHANGING = new Set(["write", "process", "external"]);
+export class ChildSessions {
+    o;
+    cancelled = new Set();
+    constructor(o) {
+        this.o = o;
+        // Work left running by a previous process is never restarted automatically.
+        o.store.interruptStale();
+    }
+    spec(session) {
+        return (session.options ?? {});
+    }
+    info(session) {
+        if (!session.parentId)
+            throw new Error(`Not a child session: ${session.id}`);
+        return {
+            id: session.id,
+            parentId: session.parentId,
+            depth: session.depth ?? 1,
+            agent: session.agent ?? "agent",
+            title: session.title ?? "",
+            status: session.status ?? "queued",
+            model: session.model,
+            provider: session.provider,
+            workspace: session.workspace,
+            usage: session.usage ?? { input: 0, output: 0 },
+            capabilities: (({ readOnly: _r, ...caps }) => caps)(this.capabilities(session.id)),
+            createdAt: session.createdAt ?? 0,
+            updatedAt: session.updatedAt ?? 0,
+        };
+    }
+    capabilities(id) {
+        const session = this.o.store.get(id);
+        if (!session.parentId) {
+            const policy = this.o.rootPolicy();
+            return {
+                write: policy.write,
+                process: policy.process,
+                approvals: this.o.rootApprovals && !this.o.readOnly,
+                readOnly: this.o.readOnly,
+            };
+        }
+        const parent = this.capabilities(session.parentId);
+        const spec = this.spec(session);
+        const readOnly = parent.readOnly || !!spec.readOnly;
+        const level = (effect) => spec.permission?.[effect] ?? "allow";
+        return {
+            write: parent.write && !readOnly && level("write") === "allow",
+            process: parent.process && !readOnly && level("process") === "allow",
+            approvals: parent.approvals && !readOnly && (level("write") !== "deny" || level("process") !== "deny"),
+            readOnly,
+        };
+    }
+    /** Tool filter for a session: the parent's filter AND the child's own allow/deny/effects. */
+    filter(id) {
+        const session = this.o.store.get(id);
+        if (!session.parentId)
+            return () => true;
+        const parent = this.filter(session.parentId);
+        const spec = this.spec(session);
+        const caps = this.capabilities(id);
+        const allow = spec.tools?.allow;
+        const deny = new Set(spec.tools?.deny ?? []);
+        return (tool) => {
+            if (!parent(tool) || deny.has(tool.name))
+                return false;
+            if (allow && !allow.includes("*") && !allow.includes(tool.name))
+                return false;
+            const effect = tool.effect ?? "external";
+            if (caps.readOnly && STATE_CHANGING.has(effect))
+                return false;
+            for (const e of ["write", "process"])
+                if (effect === e && spec.permission?.[e] === "deny")
+                    return false;
+            return true;
+        };
+    }
+    spawn(spec) {
+        const parent = this.o.store.get(spec.parentId);
+        if (spec.id && !/^[0-9a-f-]{36}$/i.test(spec.id))
+            throw new Error("Child id must be a UUID");
+        const stored = {
+            ...(spec.instructions ? { instructions: spec.instructions } : {}),
+            ...(spec.tools ? { tools: spec.tools } : {}),
+            ...(spec.readOnly ? { readOnly: true } : {}),
+            ...(spec.permission ? { permission: spec.permission } : {}),
+            ...(spec.maxTurns ? { maxTurns: spec.maxTurns } : {}),
+            ...(spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {}),
+            ...(spec.maxTokens ? { maxTokens: spec.maxTokens } : {}),
+        };
+        const child = this.o.store.createChild({
+            ...(spec.id ? { id: spec.id } : {}),
+            parentId: parent.id,
+            workspace: spec.workspace ?? parent.workspace,
+            provider: parent.provider,
+            model: spec.model ?? parent.model,
+            agent: spec.agent,
+            title: spec.title,
+            depth: (parent.depth ?? 0) + 1,
+            options: stored,
+        });
+        return this.info(child);
+    }
+    async create(spec) {
+        if (!spec.model)
+            return this.spawn(spec);
+        if (!this.o.resolveModel || !this.o.bindProvider)
+            throw new Error("Cross-provider model resolution is not available");
+        const target = await this.o.resolveModel(spec.model);
+        const child = this.spawn({ ...spec, model: target.model.id });
+        try {
+            const provider = await this.o.bindProvider(child.id, target);
+            this.o.store.updateBinding(child.id, provider, target.model.id);
+            return this.info(this.o.store.get(child.id));
+        }
+        catch (error) {
+            this.o.store.updateSession(child.id, { status: "failed" });
+            throw error;
+        }
+    }
+    /** Agent path from the top-level child down, e.g. "general › explore". */
+    label(id) {
+        return [...this.ancestors(id).reverse(), id]
+            .map((x) => this.o.store.get(x))
+            .filter((s) => s.parentId)
+            .map((s) => s.agent ?? "agent")
+            .join(" › ");
+    }
+    async run(id, prompt, options = {}) {
+        const session = this.o.store.get(id);
+        if (!session.parentId)
+            throw new Error(`Not a child session: ${id}`);
+        if (this.o.runner.isRunning(id))
+            throw new Error(`Session ${id} is already running`);
+        const spec = this.spec(session);
+        const caps = this.capabilities(id);
+        const root = this.o.rootPolicy();
+        const signals = [options.signal, this.o.runner.signal(session.parentId)].filter((s) => !!s);
+        this.cancelled.delete(id);
+        this.o.store.updateSession(id, { status: "running" });
+        const usage = { ...(session.usage ?? { input: 0, output: 0 }) };
+        try {
+            const result = await this.o.runner.run(id, prompt, signals.length ? AbortSignal.any(signals) : undefined, {
+                ...(spec.instructions ? { instructions: spec.instructions } : {}),
+                toolFilter: this.filter(id),
+                policy: {
+                    write: caps.write,
+                    process: caps.process,
+                    external: root.external && !caps.readOnly,
+                },
+                approvals: caps.approvals,
+                label: this.label(id),
+                workspace: session.workspace,
+                context: this.o.contextFor(session.workspace),
+                ...(spec.maxTurns ? { maxTurns: spec.maxTurns } : {}),
+                ...(spec.maxTokens ? { maxTokens: spec.maxTokens } : {}),
+                ...(spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {}),
+            });
+            usage.input += result.usage.input;
+            usage.output += result.usage.output;
+            this.o.store.updateSession(id, { status: "completed", usage });
+            return { id, status: "completed", text: result.text, usage };
+        }
+        catch (error) {
+            const aborted = this.cancelled.has(id) || signals.some((s) => s.aborted);
+            const status = aborted ? "cancelled" : "failed";
+            this.o.store.updateSession(id, { status });
+            return {
+                id,
+                status,
+                text: "",
+                usage,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    get(id) {
+        try {
+            const session = this.o.store.get(id);
+            return session.parentId ? this.info(session) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    children(parentId) {
+        return this.o.store.children(parentId).map((s) => this.info(s));
+    }
+    ancestors(id) {
+        const out = [];
+        let current = this.o.store.get(id);
+        while (current.parentId) {
+            out.push(current.parentId);
+            current = this.o.store.get(current.parentId);
+        }
+        return out;
+    }
+    descendants(id) {
+        return this.o.store.children(id).flatMap((c) => [c.id, ...this.descendants(c.id)]);
+    }
+    cancel(id) {
+        let running = 0;
+        for (const target of [id, ...this.descendants(id)]) {
+            const session = this.o.store.get(target);
+            if (this.o.runner.isRunning(target)) {
+                this.cancelled.add(target);
+                this.o.runner.abort(target, new Error("Cancelled by the user"));
+                running++;
+            }
+            else if (session.parentId && session.status === "queued")
+                this.o.store.updateSession(target, { status: "cancelled" });
+        }
+        return running;
+    }
+    enqueue(id, text) {
+        this.o.runner.enqueue(id, text);
+    }
+    isRunning(id) {
+        return this.o.runner.isRunning(id);
+    }
+    model(id) {
+        return this.o.store.get(id).model;
+    }
+    workspace(id) {
+        return this.o.store.get(id).workspace;
+    }
+    setStatus(id, status) {
+        if (this.o.store.get(id).parentId)
+            this.o.store.updateSession(id, { status });
+    }
+}

package/dist/startup/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Startup pipeline: resolve the startup-screen and mascot providers from the extension
+ * registry, validate their output, and fall back to the defaults (with a diagnostic) when a
+ * provider throws, returns garbage or is too slow. Never throws.
+ */
+import type { PluginMetadata, StartupFact, TerminalCapabilities } from "@alisio/sdk";
+import type { ExtensionConflict, ExtensionRegistry } from "../extensions/registry.ts";
+export { DefaultAlisioMascot } from "./mascot.ts";
+export { composeSideBySide, DefaultStartupScreen, infoSection, mascotSection, pluginsSection, shortenPath, startupTips, tipsSection, titleSection, welcomeSection, } from "./screen.ts";
+export { padEnd, sanitizeLine, stripAnsi, truncate, visibleWidth } from "./text.ts";
+export type StartupDiagnostic = ({
+    type: "extension_conflict";
+} & ExtensionConflict) | {
+    type: "plugin_hook_failed";
+    source: string;
+    hook: string;
+    error: string;
+};
+export interface StartupInput {
+    version: string;
+    cwd: string;
+    /** Home directory used to shorten the working directory as `~/…`. */
+    home?: string;
+    model?: string;
+    provider?: string;
+    userName?: string;
+    terminal?: TerminalCapabilities;
+    facts?: StartupFact[];
+    tipSeed?: number;
+}
+export interface StartupResult {
+    lines: string[];
+    screen: string;
+    mascot: string;
+    diagnostics: StartupDiagnostic[];
+}
+interface Source {
+    extensions: ExtensionRegistry;
+    metadata(): PluginMetadata[];
+}
+export declare function renderStartup(source: Source, input: StartupInput): StartupResult;