@vascend/talos 0.1.0

package/dist/core/trust.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative, resolve } from "node:path";
+// Risorse che, se presenti, rendono il progetto "da fidare".
+const TRUST_RESOURCES = [
+    ".talos/settings.json",
+    ".talos/extensions",
+    ".talos/skills",
+    ".talos/prompts",
+    ".talos/themes",
+    ".talos/SYSTEM.md",
+    ".talos/APPEND_SYSTEM.md",
+    // Pi usa lo stesso modello di sicurezza per risorse project-local. Talos
+    // deve mostrare il prompt di fiducia anche quando il progetto contiene solo
+    // un package/configurazione Pi, altrimenti verrebbe ignorato in silenzio.
+    ".pi/settings.json",
+    ".pi/extensions",
+    ".pi/skills",
+    ".pi/prompts",
+    ".pi/themes",
+];
+export function resourcesRequiringTrust(cwd) {
+    return TRUST_RESOURCES.filter((rel) => existsSync(join(cwd, rel)));
+}
+function trustFile(env) {
+    const override = env["TALOS_CONFIG_DIR"];
+    const base = override ? override : join(homedir(), ".talos", "agent");
+    return join(base, "trust.json");
+}
+export function readTrustStore(env) {
+    const file = trustFile(env);
+    if (!existsSync(file))
+        return {};
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        if (typeof raw !== "object" || raw === null)
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(raw)) {
+            if (v === "trust" || v === "deny")
+                out[k] = v;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+export function writeTrustDecision(env, cwd, decision) {
+    const file = trustFile(env);
+    const store = readTrustStore(env);
+    const next = { ...store, [resolve(cwd)]: decision };
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(next, null, 2), "utf8");
+}
+function isAncestorOrSelf(ancestor, target) {
+    const rel = relative(ancestor, target);
+    return rel === "" || (!rel.startsWith("..") && !rel.includes(":"));
+}
+// Decisione salvata per cwd: vince il path piu' vicino (piu' lungo) tra gli
+// antenati registrati.
+export function savedDecision(store, cwd) {
+    const target = resolve(cwd);
+    let best;
+    for (const [path, decision] of Object.entries(store)) {
+        if (isAncestorOrSelf(path, target)) {
+            if (!best || path.length > best.path.length)
+                best = { path, decision };
+        }
+    }
+    return best?.decision;
+}
+export function parseDefaultTrust(value) {
+    return value === "trust" || value === "deny" ? value : "ask";
+}
+// Risolve la fiducia per il progetto in cwd. `prompt` viene usato solo in
+// modalita' "ask" interattiva quando ci sono risorse da fidare.
+export async function resolveProjectTrust(opts) {
+    const resources = resourcesRequiringTrust(opts.cwd);
+    if (resources.length === 0)
+        return { trusted: true, resources, persist: false, source: "default" };
+    const saved = savedDecision(readTrustStore(opts.env), opts.cwd);
+    if (saved)
+        return { trusted: saved === "trust", resources, persist: false, source: "stored" };
+    if (opts.defaultTrust === "trust")
+        return { trusted: true, resources, persist: false, source: "default" };
+    if (opts.defaultTrust === "deny")
+        return { trusted: false, resources, persist: false, source: "default" };
+    // "ask": interattivo se possibile, altrimenti default sicuro (deny).
+    if (opts.prompt) {
+        const granted = await opts.prompt(resources);
+        return { trusted: granted, resources, persist: true, source: "prompt" };
+    }
+    return { trusted: false, resources, persist: false, source: "default" };
+}

package/dist/core/types.d.ts

@@ -0,0 +1,402 @@
+import type { JsonSchema, McpCallToolResult, McpContentBlock, McpMeta, McpToolAnnotations, McpToolDefinition } from "../mcp/protocol.js";
+import type { ContextLedger } from "./context-ledger.js";
+import type { SessionUsageRecord } from "./session-usage.js";
+import type { FileActivityMode, FileActor, FileCoordinationContext, FilePresence } from "./file-coordination.js";
+export type Role = "system" | "user" | "assistant" | "tool";
+export interface TextPart {
+    readonly type: "text";
+    readonly text: string;
+}
+export interface ToolCallPart {
+    readonly type: "tool_call";
+    readonly id: string;
+    readonly name: string;
+    readonly input: Readonly<Record<string, unknown>>;
+    readonly inputTruncatedChars?: number;
+}
+export interface ToolResultPart {
+    readonly type: "tool_result";
+    readonly callId: string;
+    readonly output: string;
+    readonly isError: boolean;
+    readonly content?: readonly McpContentBlock[];
+    readonly structuredContent?: Readonly<Record<string, unknown>>;
+    readonly _meta?: McpMeta;
+    readonly media?: readonly ImagePart[];
+}
+export interface ImagePart {
+    readonly type: "image";
+    readonly data: string;
+    readonly mime: string;
+    readonly source?: string;
+}
+export type ContentPart = TextPart | ToolCallPart | ToolResultPart | ImagePart;
+export interface Message {
+    readonly role: Role;
+    readonly content: readonly ContentPart[];
+}
+export interface ToolDef extends McpToolDefinition {
+    readonly description: string;
+    readonly schema?: JsonSchema;
+}
+export interface LegacyToolDef {
+    readonly name: string;
+    readonly title?: string;
+    readonly description: string;
+    readonly schema: JsonSchema;
+    readonly inputSchema?: JsonSchema;
+    readonly outputSchema?: JsonSchema;
+    readonly annotations?: McpToolAnnotations;
+    readonly _meta?: McpMeta;
+}
+export type ToolRegistrationDef = ToolDef | LegacyToolDef;
+export type NestedToolEvent = {
+    readonly type: "tool_call";
+    readonly call: ToolCallPart;
+} | {
+    readonly type: "tool_result";
+    readonly call: ToolCallPart;
+    readonly result: ToolResultPart;
+};
+export interface ToolContext {
+    readonly cwd: string;
+    readonly workspaceSession?: import("./workspace-sessions.js").WorkspaceSession;
+    /** Ambiente che possiede davvero cwd, filesystem e processi del turno. */
+    readonly executionTarget?: import("./execution-target.js").ExecutionTarget;
+    /**
+     * Radici filesystem aggiuntive concesse dall'host per questo solo turno.
+     * La presenza del campo (anche come array vuoto) attiva il confinement su
+     * `cwd` + queste radici senza consultare la allowlist globale del processo.
+     */
+    readonly fsRoots?: readonly string[];
+    readonly signal: AbortSignal;
+    /** Coordinamento condiviso delle letture/scritture sul workspace. */
+    readonly fileCoordination?: FileCoordinationContext;
+    readonly confirm: (action: string, detail: string) => Promise<boolean>;
+    readonly ask?: (question: string, options?: readonly string[]) => Promise<string | null>;
+    readonly spawnKingdom?: (castles: readonly SpawnAgentSpec[], opts?: {
+        baseBranch?: string;
+        detach?: boolean;
+    }) => Promise<string>;
+    readonly kingdom?: {
+        readonly id: string;
+        readonly self: string;
+        readonly isolated?: boolean;
+        readonly peers?: readonly string[];
+    };
+    readonly sessionId?: string;
+    readonly sessionDir?: string;
+    readonly roomStoreId?: string;
+    readonly planStoreId?: string;
+    readonly planCastle?: string;
+    readonly planTasks?: readonly string[];
+    readonly emitToolEvent?: (event: NestedToolEvent) => void;
+    /** Shared dispatch including hooks, normalization, result storage and evidence. */
+    readonly visibleOutputPages?: ReadonlySet<string>;
+    readonly contextLearning?: {
+        readonly storeId: string;
+        readonly scope: string;
+    };
+    readonly guardToolCall?: (call: ToolCallPart) => void;
+    readonly invokeTool?: (call: ToolCallPart, signal?: AbortSignal, guard?: (call: ToolCallPart) => void) => Promise<ToolResultPart>;
+    readonly tools?: {
+        readonly revision?: string;
+        readonly compact?: boolean;
+        defs?(): readonly ToolDef[];
+        catalog(): readonly ToolDef[];
+        get(name: string): RegisteredTool | undefined;
+        isDeferred?(name: string): boolean;
+        promote?(name: string): boolean;
+    };
+}
+export interface ToolHandlerOutput {
+    readonly output?: string;
+    readonly media?: readonly ImagePart[];
+    readonly content?: McpCallToolResult["content"];
+    readonly structuredContent?: McpCallToolResult["structuredContent"];
+    readonly _meta?: McpCallToolResult["_meta"];
+    readonly isError?: boolean;
+}
+export type ToolHandler = (input: Record<string, unknown>, ctx: ToolContext) => Promise<string | ToolHandlerOutput | McpCallToolResult>;
+export type ToolExecution = "serial" | "parallel";
+export type Tool = ToolRegistrationDef & {
+    readonly handler: ToolHandler;
+    readonly execution?: ToolExecution;
+    readonly capabilities?: readonly string[];
+    readonly continuations?: readonly string[];
+    readonly requiresNativeCall?: boolean;
+};
+export interface RegisteredTool extends ToolDef {
+    readonly schema: JsonSchema;
+    readonly handler: ToolHandler;
+    readonly execution?: ToolExecution;
+    readonly capabilities?: readonly string[];
+    readonly continuations?: readonly string[];
+    readonly requiresNativeCall?: boolean;
+}
+export interface Usage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+    readonly costUsd?: number;
+}
+export interface PlanLimitWindow {
+    readonly id: string;
+    readonly label: string;
+    readonly utilization?: number;
+    readonly remaining?: number;
+    readonly limit?: number;
+    readonly resetAt?: number;
+    readonly status?: string;
+    readonly unit?: string;
+}
+export interface PlanLimits {
+    readonly providerId: string;
+    readonly windows: readonly PlanLimitWindow[];
+    readonly capturedAt: number;
+}
+export interface ModelTurn {
+    readonly text: string;
+    readonly toolCalls: readonly ToolCallPart[];
+    readonly stopReason: "end" | "tool_use" | "max_tokens" | "error";
+    readonly usage?: Usage;
+    readonly limits?: PlanLimits;
+}
+export interface CompletionRequest {
+    readonly system: string;
+    readonly turnContext?: string;
+    readonly messages: readonly Message[];
+    readonly tools: readonly ToolDef[];
+    readonly model: string;
+    readonly maxTokens: number;
+    readonly signal: AbortSignal;
+    readonly onDelta?: (chunk: string) => void;
+    readonly onToolDelta?: (event: {
+        readonly id: string;
+        readonly name: string;
+        readonly index: number;
+        readonly delta: string;
+    }) => void;
+    readonly onActivity?: (label: string) => void;
+    readonly onReasoning?: (chunk: string) => void;
+    readonly sessionId?: string;
+    readonly effort?: string;
+    readonly serviceTier?: "priority";
+}
+export interface Provider {
+    readonly id: string;
+    readonly label?: string;
+    readonly models: readonly string[];
+    readonly supportsFastMode?: boolean;
+    complete(req: CompletionRequest): Promise<ModelTurn>;
+}
+export interface SpawnAgentToolPolicy {
+    readonly allow?: readonly string[];
+    readonly deny?: readonly string[];
+}
+export interface SpawnAgentSpec {
+    readonly slug: string;
+    readonly goal: string;
+    readonly castle?: string;
+    readonly tasks?: readonly string[];
+    readonly after?: readonly string[];
+    readonly parent?: string;
+    readonly role?: string;
+    readonly model?: string;
+    readonly effort?: string;
+    readonly tools?: SpawnAgentToolPolicy;
+    readonly instructions?: string;
+    readonly area?: readonly string[];
+}
+export interface KingdomCastleInfo extends SpawnAgentSpec {
+    readonly after: readonly string[];
+}
+export type KingdomVassalState = "start" | "active" | "done" | "error";
+export interface KingdomVassalSummary {
+    readonly slug: string;
+    readonly ok: boolean;
+    readonly rooms: number;
+    readonly summary: string;
+    readonly model?: string;
+    readonly role?: string;
+    readonly parent?: string;
+    readonly workstreamId?: string;
+    readonly taskRefs?: readonly string[];
+    readonly parentTaskRef?: string;
+    readonly error?: string;
+    readonly branch?: string;
+    readonly merged?: boolean;
+}
+export type AgentEvent = {
+    readonly type: "turn_start";
+    readonly turn: number;
+} | {
+    readonly type: "workspace_message";
+    readonly message: import("./workspace-sessions.js").WorkspaceMessage;
+} | {
+    readonly type: "text";
+    readonly delta: string;
+} | {
+    readonly type: "tool_delta";
+    readonly id: string;
+    readonly name: string;
+    readonly index: number;
+    readonly delta: string;
+} | {
+    readonly type: "tool_call";
+    readonly call: ToolCallPart;
+    readonly parentId?: string;
+} | {
+    readonly type: "status";
+    readonly label: string;
+    readonly category?: "context";
+} | {
+    readonly type: "usage";
+    readonly record: SessionUsageRecord;
+    readonly persisted: boolean;
+} | {
+    readonly type: "file_coordination";
+    readonly phase: "observed" | "blocked" | "acquired" | "released" | "presence";
+    readonly path: string;
+    readonly actor: FileActor;
+    readonly mode: FileActivityMode;
+    readonly others: readonly FilePresence[];
+    readonly at: number;
+} | {
+    readonly type: "reasoning";
+    readonly delta: string;
+} | {
+    readonly type: "tool_result";
+    readonly result: ToolResultPart;
+    readonly parentId?: string;
+} | {
+    readonly type: "turn_end";
+    readonly stopReason: ModelTurn["stopReason"];
+    readonly usage?: Usage;
+    readonly limits?: PlanLimits;
+} | {
+    readonly type: "context_window";
+    readonly ledger: ContextLedger;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "start";
+    readonly kingdomId: string;
+    readonly concurrency: number;
+    readonly worktree: boolean;
+    readonly castles: readonly KingdomCastleInfo[];
+} | {
+    readonly type: "kingdom";
+    readonly phase: "notice";
+    readonly text: string;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "vassal";
+    readonly slug: string;
+    readonly state: KingdomVassalState;
+    readonly label?: string;
+    readonly parent?: string;
+    readonly role?: string;
+    readonly goal?: string;
+    readonly workstreamId?: string;
+    readonly taskRefs?: readonly string[];
+    readonly parentTaskRef?: string;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "message";
+    readonly from: string;
+    readonly to: string;
+    readonly text: string;
+    readonly kind?: "assignment" | "message" | "result";
+    readonly workstreamId?: string;
+    readonly taskRef?: string;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "task";
+    readonly slug: string;
+    readonly workstreamId: string;
+    readonly taskRef: string;
+    readonly status: "pending" | "running" | "completed" | "failed";
+    readonly at: number;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "note";
+    readonly slug: string;
+    readonly workstreamId: string;
+    readonly taskRef?: string;
+    readonly text: string;
+    readonly at: number;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "file";
+    readonly slug: string;
+    readonly path: string;
+    readonly operation: "write" | "edit";
+    readonly workstreamId?: string;
+    readonly taskRef?: string;
+    readonly edit?: {
+        readonly oldString?: string;
+        readonly newString?: string;
+        readonly content?: string;
+        readonly append?: boolean;
+    };
+} | {
+    readonly type: "kingdom";
+    readonly phase: "say";
+    readonly slug: string;
+    readonly text: string;
+    readonly at: number;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "tool";
+    readonly slug: string;
+    readonly callId: string;
+    readonly tool: string;
+    readonly args?: string;
+    readonly command?: string;
+    readonly state: "start" | "ok" | "error";
+    readonly output?: string;
+    readonly at: number;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "inbox";
+    readonly slug: string;
+    readonly messageId: string;
+    readonly text: string;
+    readonly state: "queued" | "read";
+    readonly at: number;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "usage";
+    readonly slug: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+    readonly costUsd?: number;
+    readonly turns: number;
+    readonly at: number;
+} | {
+    readonly type: "kingdom";
+    readonly phase: "end";
+    readonly reports: readonly KingdomVassalSummary[];
+} | {
+    readonly type: "compacted";
+    readonly tokensBefore: number;
+    readonly tokensAfter: number;
+    readonly reason?: "room-index" | "summary";
+    readonly anchors?: readonly string[];
+} | {
+    readonly type: "user_message";
+    readonly id: string;
+    readonly text: string;
+    readonly at: number;
+    readonly immediate?: boolean;
+} | {
+    readonly type: "error";
+    readonly message: string;
+    readonly providerId?: string;
+    readonly resetAt?: number;
+} | {
+    readonly type: "done";
+};
+export type EventSink = (event: AgentEvent) => void;

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/update-check.d.ts

@@ -0,0 +1,26 @@
+import type { CliArgs } from "./cli-args.js";
+import { type UpdateRunner } from "./update-process.js";
+export declare const TALOS_REPOSITORY = "VascendTechnologies/vascend-talos";
+export declare const TALOS_RELEASES_URL = "https://github.com/VascendTechnologies/vascend-talos/releases";
+export interface TalosUpdate {
+    readonly currentVersion: string;
+    readonly version: string;
+    readonly tag: string;
+}
+export type UpdateSource = "github" | "npm";
+export declare function parseUpdateVersion(value: unknown): {
+    version: string;
+    core: readonly bigint[];
+    prerelease: boolean;
+} | null;
+export declare function updateFromRelease(currentVersion: string, data: unknown): TalosUpdate | null;
+export declare function shouldCheckForUpdate(args: Pick<CliArgs, "mode" | "help" | "version">, env: NodeJS.ProcessEnv, inputIsTTY: boolean, outputIsTTY: boolean): boolean;
+export declare function checkForTalosUpdate(options: {
+    readonly currentVersion: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly cwd: string;
+    readonly timeoutMs?: number;
+    readonly fetch?: typeof fetch;
+    readonly run?: UpdateRunner;
+    readonly source?: UpdateSource;
+}): Promise<TalosUpdate | null>;

package/dist/core/update-check.js

@@ -0,0 +1,89 @@
+import { runUpdateCommand } from "./update-process.js";
+export const TALOS_REPOSITORY = "VascendTechnologies/vascend-talos";
+export const TALOS_RELEASES_URL = `https://github.com/${TALOS_REPOSITORY}/releases`;
+const RELEASE_ENDPOINT = `https://api.github.com/repos/${TALOS_REPOSITORY}/releases/latest`;
+// Accept SemVer only; reject shell syntax, control characters and oversized input.
+export function parseUpdateVersion(value) {
+    if (typeof value !== "string" || value.length > 128)
+        return null;
+    const match = /^v?((0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)$/.exec(value);
+    if (!match || match[0] !== value)
+        return null;
+    if (match[5]?.split(".").some(part => /^0\d+$/.test(part)))
+        return null;
+    return { version: match[1], core: [BigInt(match[2]), BigInt(match[3]), BigInt(match[4])], prerelease: Boolean(match[5]) };
+}
+export function updateFromRelease(currentVersion, data) {
+    if (!data || typeof data !== "object")
+        return null;
+    const release = data;
+    if (release.draft !== false || release.prerelease !== false)
+        return null;
+    const current = parseUpdateVersion(currentVersion);
+    const latest = parseUpdateVersion(release.tag_name);
+    if (!current || !latest || latest.prerelease)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        if (latest.core[i] < current.core[i])
+            return null;
+        if (latest.core[i] > current.core[i]) {
+            return { currentVersion: current.version, version: latest.version, tag: release.tag_name };
+        }
+    }
+    return current.prerelease
+        ? { currentVersion: current.version, version: latest.version, tag: release.tag_name }
+        : null;
+}
+export function shouldCheckForUpdate(args, env, inputIsTTY, outputIsTTY) {
+    return args.mode === "tui" && !args.help && !args.version && inputIsTTY && outputIsTTY
+        && env.TALOS_NO_UPDATE_CHECK !== "1"
+        && (!env.CI || /^(0|false)$/i.test(env.CI))
+        && env.TALOS_HOST_PROFILE?.toLowerCase() !== "horizon";
+}
+export async function checkForTalosUpdate(options) {
+    if (!parseUpdateVersion(options.currentVersion))
+        return null;
+    const budget = options.timeoutMs ?? 2_500;
+    const deadline = Date.now() + budget;
+    const fromNpm = options.source === "npm";
+    const token = fromNpm ? undefined : options.env.GH_TOKEN || options.env.GITHUB_TOKEN;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(1, Math.floor(budget / (fromNpm ? 1 : 2))));
+    try {
+        const response = await (options.fetch ?? fetch)(fromNpm ? "https://registry.npmjs.org/@vascend%2ftalos/latest" : RELEASE_ENDPOINT, {
+            headers: { Accept: fromNpm ? "application/json" : "application/vnd.github+json", "User-Agent": "vascend-talos-update",
+                ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+            redirect: "error",
+            signal: controller.signal,
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (!fromNpm)
+                return updateFromRelease(options.currentVersion, data);
+            const pkg = data;
+            return pkg?.name === "@vascend/talos"
+                ? updateFromRelease(options.currentVersion, { tag_name: pkg.version, draft: false, prerelease: false })
+                : null;
+        }
+        await response.body?.cancel();
+    }
+    catch { /* Offline, authentication or rate limit: try the user's GitHub CLI. */ }
+    finally {
+        clearTimeout(timer);
+    }
+    if (fromNpm)
+        return null;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+        return null;
+    try {
+        // Also supports private repositories when the user has signed into gh.
+        const json = await (options.run ?? runUpdateCommand)({ command: "gh", args: [
+                "api", "--hostname", "github.com", `repos/${TALOS_REPOSITORY}/releases/latest`,
+            ], cwd: options.cwd, env: { ...options.env, GH_PROMPT_DISABLED: "1" }, timeoutMs: remaining });
+        return updateFromRelease(options.currentVersion, JSON.parse(json));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/update-process.d.ts

@@ -0,0 +1,10 @@
+export interface UpdateCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly timeoutMs?: number;
+    readonly inherit?: boolean;
+}
+export type UpdateRunner = (command: UpdateCommand) => Promise<string>;
+export declare const runUpdateCommand: UpdateRunner;

package/dist/core/update-process.js

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+// No shell: paths with spaces and release tags remain individual arguments.
+export const runUpdateCommand = (command) => new Promise((resolve, reject) => {
+    const child = spawn(command.command, [...command.args], {
+        cwd: command.cwd, env: command.env, shell: false, windowsHide: true,
+        stdio: command.inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+        timeout: command.timeoutMs,
+    });
+    let output = "";
+    let failed = false;
+    const collect = (data) => {
+        output += data.toString();
+        if (output.length > 2_000_000) {
+            failed = true;
+            child.kill();
+            reject(new Error("Command output exceeded limit"));
+        }
+    };
+    child.stdout?.on("data", collect);
+    // Do not surface authentication diagnostics or credentials in the update UI.
+    child.stderr?.resume();
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+        if (failed)
+            return;
+        if (code === 0 && !signal)
+            resolve(output.trim());
+        else
+            reject(new Error(`${command.command} exited with ${signal ?? code}`));
+    });
+});

package/dist/core/user-inbox.d.ts

@@ -0,0 +1,23 @@
+import type { ContentPart } from "./types.js";
+export interface PendingUserMessage {
+    readonly id: string;
+    readonly parts: readonly ContentPart[];
+    /** Quando l'host l'ha ricevuto dall'utente. */
+    readonly queuedAt: number;
+    readonly immediate?: boolean;
+}
+export interface UserInbox {
+    /** Accoda un messaggio arrivato durante il turno. Ritorna l'id assegnato. */
+    push(input: string | readonly ContentPart[], id?: string): string;
+    /** Porta un messaggio gia' accodato in testa, senza duplicarlo. */
+    promote(id: string): boolean;
+    /** Vero se c'e' almeno un messaggio in attesa. */
+    readonly pending: number;
+    /** Preleva e SVUOTA la coda. La chiama solo il loop, a confine sicuro. */
+    drain(): readonly PendingUserMessage[];
+    /** Richiesta esplicita di interrompere la generazione per leggere subito l'input.
+     * Notifica anche un invio immediato gia' pendente quando ci si iscrive. */
+    onImmediate?(listener: () => void): () => void;
+}
+export declare function createUserInbox(now?: () => number): UserInbox;
+export declare function pendingText(message: PendingUserMessage): string;