@alisio/core 0.1.0-alpha.9 → 0.1.1

package/dist/goal/store.js

@@ -0,0 +1,184 @@
+import { isProcessAlive } from "../runtime/process.js";
+import { GOAL_STATUSES, systemRestart } from "./machine.js";
+const num = (value) => value === null || value === undefined ? undefined : Number(value);
+const str = (value) => value === null || value === undefined ? undefined : String(value);
+function parseEvidence(raw) {
+    if (typeof raw !== "string" || !raw)
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        return Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function goalFromRow(row) {
+    const status = String(row.status);
+    return {
+        sessionId: String(row.session),
+        goalId: str(row.goal_id) ?? String(row.session).slice(0, 8),
+        objective: String(row.objective),
+        status: GOAL_STATUSES.includes(status) ? status : "paused",
+        ...(str(row.reason) ? { reason: str(row.reason) } : {}),
+        ...(str(row.detail) ? { detail: str(row.detail) } : {}),
+        ...(str(row.summary) ? { summary: str(row.summary) } : {}),
+        ...(parseEvidence(row.evidence)
+            ? { evidence: parseEvidence(row.evidence) }
+            : {}),
+        epoch: Number(row.epoch ?? 1),
+        ...(num(row.token_budget) !== undefined
+            ? { tokenBudget: num(row.token_budget) }
+            : {}),
+        tokensUsed: Number(row.tokens_used ?? 0),
+        turnsUsed: Number(row.turns_used ?? 0),
+        maxTurns: Number(row.max_turns),
+        maxWallMs: Number(row.max_wall_ms),
+        activeMs: Number(row.active_ms ?? 0),
+        noToolStreak: Number(row.no_tool_streak ?? 0),
+        repeatStreak: Number(row.repeat_streak ?? 0),
+        ...(str(row.last_reply_hash) ? { lastReplyHash: str(row.last_reply_hash) } : {}),
+        blockedStreak: Number(row.blocked_streak ?? 0),
+        ...(str(row.blocked_run) ? { blockedRun: str(row.blocked_run) } : {}),
+        continuations: Number(row.continuations ?? 0),
+        ...(str(row.inflight) ? { inflight: str(row.inflight) } : {}),
+        ...(str(row.last_run_id) ? { lastRunId: str(row.last_run_id) } : {}),
+        kickoffSent: Number(row.kickoff_sent ?? 0) === 1,
+        ...(num(row.owner_pid) !== undefined ? { ownerPid: num(row.owner_pid) } : {}),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+        ...(num(row.completed_at) !== undefined
+            ? { completedAt: num(row.completed_at) }
+            : {}),
+    };
+}
+const COLUMNS = `session, goal_id, objective, status, reason, detail, summary, evidence, epoch,
+  token_budget, tokens_used, turns_used, max_turns, max_wall_ms, active_ms, no_tool_streak,
+  repeat_streak, last_reply_hash, blocked_streak, blocked_run, continuations, inflight,
+  last_run_id, kickoff_sent, owner_pid, created_at, updated_at, completed_at`;
+export class GoalStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get(sessionId) {
+        const row = this.db.prepare("SELECT * FROM session_goals WHERE session=?").get(sessionId);
+        return row ? goalFromRow(row) : undefined;
+    }
+    /** Every goal that is `active` (restart recovery). */
+    active() {
+        return this.db
+            .prepare("SELECT * FROM session_goals WHERE status='active'")
+            .all()
+            .map(goalFromRow);
+    }
+    write(goal) {
+        this.db
+            .prepare(`INSERT INTO session_goals(${COLUMNS}) VALUES(${COLUMNS.split(",")
+            .map(() => "?")
+            .join(",")})
+         ON CONFLICT(session) DO UPDATE SET
+           goal_id=excluded.goal_id, objective=excluded.objective, status=excluded.status,
+           reason=excluded.reason, detail=excluded.detail, summary=excluded.summary,
+           evidence=excluded.evidence, epoch=excluded.epoch, token_budget=excluded.token_budget,
+           tokens_used=excluded.tokens_used, turns_used=excluded.turns_used,
+           max_turns=excluded.max_turns, max_wall_ms=excluded.max_wall_ms,
+           active_ms=excluded.active_ms, no_tool_streak=excluded.no_tool_streak,
+           repeat_streak=excluded.repeat_streak, last_reply_hash=excluded.last_reply_hash,
+           blocked_streak=excluded.blocked_streak, blocked_run=excluded.blocked_run,
+           continuations=excluded.continuations, inflight=excluded.inflight,
+           last_run_id=excluded.last_run_id, kickoff_sent=excluded.kickoff_sent,
+           owner_pid=excluded.owner_pid, updated_at=excluded.updated_at,
+           completed_at=excluded.completed_at`)
+            .run(goal.sessionId, goal.goalId, goal.objective, goal.status, goal.reason ?? null, goal.detail ?? null, goal.summary ?? null, goal.evidence?.length ? JSON.stringify(goal.evidence) : null, goal.epoch, goal.tokenBudget ?? null, goal.tokensUsed, goal.turnsUsed, goal.maxTurns, goal.maxWallMs, goal.activeMs, goal.noToolStreak, goal.repeatStreak, goal.lastReplyHash ?? null, goal.blockedStreak, goal.blockedRun ?? null, goal.continuations, goal.inflight ?? null, goal.lastRunId ?? null, goal.kickoffSent ? 1 : 0, goal.ownerPid ?? null, goal.createdAt, goal.updatedAt, goal.completedAt ?? null);
+    }
+    /**
+     * Replaces (or creates) the goal of a session. `build` gets the previous goal, if any, so the
+     * new one can continue its epoch (a stale client then conflicts instead of acting on the new
+     * goal), or answer `"exists"` to refuse. With `expect`, a goal that moved on is not replaced.
+     */
+    replace(sessionId, build, expect) {
+        return this.db.transaction(() => {
+            const previous = this.get(sessionId);
+            const stale = staleness(previous, expect);
+            if (stale)
+                return stale;
+            const next = build(previous);
+            if (next === "exists")
+                return {
+                    ok: false,
+                    code: "exists",
+                    message: "This session already has a goal. Confirm to replace it.",
+                };
+            this.write(next);
+            return { ok: true, goal: next, value: previous };
+        });
+    }
+    /**
+     * Read-modify-write. `change` returns the new record (or undefined to leave it untouched) and
+     * a value for the caller; it must be pure (it may run inside a retried transaction).
+     */
+    update(sessionId, change, expect) {
+        return this.db.transaction(() => {
+            const current = this.get(sessionId);
+            if (!current)
+                return { ok: false, code: "not_found", message: "No goal." };
+            const stale = staleness(current, expect);
+            if (stale)
+                return stale;
+            const { goal, value } = change(current);
+            if (goal && goal !== current)
+                this.write(goal);
+            return { ok: true, goal: goal ?? current, value };
+        });
+    }
+    /** Removes the goal. With `expect`, only the goal the caller saw. */
+    delete(sessionId, expect) {
+        return this.db.transaction(() => {
+            const current = this.get(sessionId);
+            if (!current)
+                return { ok: false, code: "not_found", message: "No goal." };
+            const stale = staleness(current, expect);
+            if (stale)
+                return stale;
+            this.db.prepare("DELETE FROM session_goals WHERE session=?").run(sessionId);
+            return { ok: true, goal: current, value: undefined };
+        });
+    }
+    /**
+     * Startup recovery: an `active` goal whose driving process is gone (or unknown) pauses with
+     * reason `restart`. A goal driven by this very process (another application in it) or by a
+     * live one is left alone. Returns the goals that paused.
+     */
+    pauseOrphans(now, alive = isProcessAlive) {
+        return this.db.transaction(() => {
+            const paused = [];
+            for (const goal of this.active()) {
+                const owner = goal.ownerPid;
+                if (owner && (owner === process.pid || alive(owner)))
+                    continue;
+                const next = systemRestart(goal, now);
+                this.write(next);
+                paused.push(next);
+            }
+            return paused;
+        });
+    }
+    /** Sessions that have a goal in the given statuses (for lists). */
+    sessionsWith(status) {
+        return this.db.prepare("SELECT session FROM session_goals WHERE status=?").all(status).map((row) => row.session);
+    }
+}
+function staleness(current, expect) {
+    if (!expect || !current)
+        return undefined;
+    if (expect.goalId !== undefined && expect.goalId !== current.goalId)
+        return { ok: false, code: "conflict", message: "The goal was replaced by another one." };
+    if (expect.epoch !== undefined && expect.epoch !== current.epoch)
+        return {
+            ok: false,
+            code: "conflict",
+            message: "The goal changed since you last saw it (another window or the agent updated it).",
+        };
+    return undefined;
+}

package/dist/index.d.ts

@@ -1,29 +1,74 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
+export { type ActiveAgent, AGENT_COMMAND_PREFIX, type AgentPickerItem, activeAgentCatalog, agentCatalogFromState, agentCommandDescriptors, agentCommandName, agentIdFromCommand, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, cycleableAgents, DEFAULT_AGENT_ID, type MainCapableAgentRecord, mainAgentFromRecord, nextAgent, PLAN_AGENT_ID, resolveActiveAgent, } from "./agents/active.ts";
+export { agentModelCapabilities, agentModelLabels, agentModelOptions, DEFAULT_EFFORT_LEVELS, fitAgentSettings, } from "./agents/capabilities.ts";
+export { AGENT_AUTHORING_SKILL_NAMES, CREATE_AGENT_SKILL, } from "./agents/create-agent-skill.ts";
+export { AGENT_ID_PATTERN, AGENT_LIMITS, AGENT_REASONING_SUMMARIES, AGENT_TEXT_FORMATS, AGENT_VERBOSITIES, type AgentFieldError, AgentNotFoundError, AgentScopeStore, agentIdFromName, agentScopeDir, parseAgentFile, RESERVED_AGENT_IDS, slugify, validateAgentDefinitionInput, } from "./agents/definitions.ts";
+export { AGENT_DRAFT_INSTRUCTIONS, AGENT_DRAFT_MAX_DESCRIPTION, type AgentAuthoringGuidance, agentAuthoringGuidance, agentDraftRequest, generateAgentDraft, parseAgentDraft, } from "./agents/draft.ts";
+export { type AgentChange, AgentDefinitionService, type AgentDefinitionServiceOptions, type AgentRegistry, mergeAgentScopes, } from "./agents/service.ts";
+export { AGENT_TEMPLATES, agentTemplate } from "./agents/templates.ts";
+export { CapabilityGrants, type GrantRecord, type GrantSource, toGrantWire, } from "./analysis/capabilities.ts";
+export { CsvParser, decodeTextBytes, detectDelimiter } from "./analysis/data/csv.ts";
+export { type DatasetLimits, type DatasetRecord, DatasetService, DEFAULT_DATASET_LIMITS, datasetFormat, PageParamError, toDatasetRef, XLSX_REMEDY, } from "./analysis/data/datasets.ts";
+export { DataEngine, DataError, type DataErrorCode, } from "./analysis/data/engine-client.ts";
+export { guardSql } from "./analysis/data/sql-guard.ts";
+export { detectHintHost, type HintHost, type InstallHints, installHintsMarkdown, installHintsText, parseOsRelease, pythonInstallHints, } from "./analysis/install-hints.ts";
+export { AnalysisJanitor, type RetentionPolicy, SWEEP_INTERVAL_MS, type SweepReport, } from "./analysis/janitor.ts";
+export { AnalysisJobs, type ExecutionDetails, type ExecutionStatus, type JobPaths, } from "./analysis/jobs.ts";
+export { containerName, type OciDeps, type OciEngine, OciRuntime, type OciSettings, type OciStatus, ociRunArgs, parseDigests, } from "./analysis/oci.ts";
+export { AnalysisRerun, type RerunPlan, type RerunPreparation, } from "./analysis/rerun.ts";
+export { AnalysisRuntimeManager, type DiscoveryDeps, type Extras, ExtrasInstallError, type InstallStep, installPreview, type PythonCandidate, type PythonResolution, type RuntimeState, setupCommand, venvInterpreter, } from "./analysis/runtime-manager.ts";
+export { analysisStatus } from "./analysis/status.ts";
 export { type AppOptions, type BuiltinContext, type BuiltinPlugin, createApplication, enabledBuiltins, type PluginCatalogEntry, type PluginCatalogStatus, } from "./application.ts";
-export { type Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, isSettableSettingKey, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, overridesSavedProviderProfile, type SettableSettingKey, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.ts";
+export { classifyArtifact, extensionOf, fileType as artifactFileType, isPreviewable, KIND_LABELS, viewerContentType, } from "./artifacts/kinds.ts";
+export { createArtifactPublisher } from "./artifacts/publisher.ts";
+export { type ArtifactFile, type ArtifactLimits, type ArtifactOwner, type ArtifactRecord, ArtifactRejected, ArtifactStore, type PublishedArtifact, readHead as readArtifactHead, slugify as artifactSlug, toRef, } from "./artifacts/store.ts";
+export { TaskJanitor } from "./background/janitor.ts";
+export { subagentTasks } from "./background/mirror.ts";
+export { buildTaskNotification, DEFAULT_NOTIFIER_TIMING, type NotifierTiming, TaskNotifier, type TaskWake, type TaskWakeRequest, type WakeOutcome, } from "./background/notify.ts";
+export { DEFAULT_READ_BYTES, MAX_READ_BYTES } from "./background/output.ts";
+export { BackgroundTasks, type BackgroundTasksOptions, type TaskAdmissionCode, TaskAdmissionError, TaskForeignError, TaskNotFoundError, } from "./background/service.ts";
+export { BackgroundTaskStore, isLive as isTaskLive, isTerminal as isTaskTerminal, } from "./background/store.ts";
+export { changelogNews, compareVersions, formatChangelogMarkdown, isVersion, loadChangelog, type NewsDecision, parseChangelog, type SelectedEntries, selectEntries, UNRELEASED, } from "./changelog/index.ts";
+export { BUILTIN_COMMANDS, type BuiltinCommand, CommandCatalog, type CommandExecutionContext, type CommandHost, type CommandResult, type CommandSurface, } from "./commands/catalog.ts";
+export { type Config, type ConfigLoadResult, type ConfigProvenance, configFile, configHome, configSchema, isSettableSettingKey, type LoadedConfig, loadConfig, loadConfigWithProvenance, type McpServerSource, OCI_IMAGE_PATTERN, overridesSavedProviderProfile, type SettableSettingInfo, type SettableSettingKey, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, settableSettings, stateHome, } from "./config.ts";
 export { type ContextBudget, checkpointInstructions, completeText, effectiveContextBudget, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, shouldCompactContext, summarize, } from "./core/compaction.ts";
-export type { ApprovalDecision, ApprovalHandler, ApprovalRequest, ContextSource, HookFailure, Policy, RunnerExtensions, Session, SessionStore, } from "./core/contracts.ts";
+export type { ApprovalDecision, ApprovalHandler, ApprovalRequest, ArtifactPublisherFactory, BeginRunInput, CapabilityGate, ContextSource, CoreArtifactPublisher, EndRunInput, EventPage, HookFailure, MessagePage, PageOptions, Policy, PublishedArtifactInfo, RunnerExtensions, RunRecord, RunStatus, Session, SessionStore, StoredEvent, TerminalRunStatus, ToolCallMeta, } from "./core/contracts.ts";
+export { EXIT_PLAN_TOOL, GOAL_TOOLS, OPT_IN_TOOLS } from "./core/opt-in.ts";
+export { DEFAULT_MAX_OUTPUT_TOKENS, describeOutputLimitSource, MAX_AUTO_OUTPUT_TOKENS, type OutputLimit, type OutputLimitSource, resolveMaxOutputTokens, } from "./core/output-limit.ts";
 export { ToolRegistry } from "./core/registry.ts";
 export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunnerSettingsPatch, type RunOptions, } from "./core/runner.ts";
 export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
+export * from "./goal/index.ts";
 export { HerdrBridge } from "./integrations/herdr.ts";
 export { McpConnector, type McpServerInfo, type McpStatus, type McpToolInfo, } from "./mcp/connector.ts";
-export { discoverPlugins, PluginHost, type PluginHostOptions, pluginPrefix, } from "./plugins/host.ts";
+export { describePermissionStatus, type EffectState, effectState, FULL_ACCESS_WARNING, type ModeFlags, type ModePolicy, modeFromFlags, modeToPreset, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, PERMISSION_USAGE, type PermissionCommand, type PermissionModeLabel, type PermissionModeSpec, parsePermissionCommand, parsePermissionMode, presetToMode, READ_ONLY_POLICY, } from "./permissions/modes.ts";
+export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, type PlanFollowUp, type PlanState, type PlanStatus, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.ts";
+export { discoverPlugins, PluginHost, type PluginHostOptions, pluginPrefix, type ViewInfo, ViewRunError, } from "./plugins/host.ts";
 export { type CliInstallOptions, cliInstall, INSTALL_TIMEOUT_MS, type InstallPluginInput, type InstallPluginResult, type InstallRunner, installedNpmPlugins, installPlugin, npmInstallTarget, type PluginSpec, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, } from "./plugins/install.ts";
 export { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.ts";
 export { availableProviderModels, type ProviderModelCatalog, resolveProviderModel, } from "./providers/routing.ts";
-export { type ProviderProfile, type ProviderSettings, ProviderSettingsStore, } from "./providers/settings.ts";
+export { maskSecret, type ProviderProfile, type ProviderSettings, ProviderSettingsStore, } from "./providers/settings.ts";
+export { buildReloadReport, formatReloadReport, type ReloadableApp, ReloadFailedError, type ReloadInput, ReloadRefusedError, type ReloadSnapshot, reloadApplication, snapshotApplication, validateReloadConfig, } from "./reload.ts";
 export { type InstructionFile, ProjectContext, type ProjectContextOptions, } from "./resources/context.ts";
 export { expandSlashPrompt, loadPromptTemplates, type PromptDiagnostic, type PromptRequirement, type PromptSource, type PromptSourceKind, type PromptTemplate, parsePromptTemplate, promptSources, renderPromptTemplate, splitArguments, } from "./resources/prompts.ts";
 export { type Skill, type SkillCatalogEntry, type SkillRoot, type SkillScope, Skills, skillRoots, } from "./resources/skills.ts";
+export { type ExternalDirectoryDecision, type ExternalDirectoryHandler, type ExternalDirectoryRequest, PathAccess, type PathAccessOptions, type ResolvePathOptions, } from "./runtime/access.ts";
+export { BlobStore, type BlobStoreOptions, BlobTooLarge } from "./runtime/blobs.ts";
+export { clipLines, unifiedPatch } from "./runtime/diff.ts";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.ts";
+export { newId, ulid } from "./runtime/ids.ts";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.ts";
-export { findWorkspace, safePath } from "./runtime/paths.ts";
+export { findWorkspace, inside, outsideRootsMessage, safePath, workspaceKey, } from "./runtime/paths.ts";
 export { isMissingCommand, type ProcessResult, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.ts";
 export { isSqliteExperimentalWarning, openDatabase } from "./runtime/sqlite.ts";
 export { SQLiteStore } from "./runtime/store.ts";
+export { crc32, writeZip, type ZipEntry, type ZipSink } from "./runtime/zip.ts";
 export { ChildSessions, type ChildSessionsOptions } from "./sessions/children.ts";
+export { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_HISTORY_LIMIT, SIDE_QUESTION_INSTRUCTIONS, SIDE_QUESTION_MAX_CHARS, SIDE_QUESTION_USAGE, SIDE_QUESTIONS_NAMESPACE, type SideQuestionEntry, SideQuestions, type SideQuestionsOptions, sideTranscript, } from "./sessions/side-questions.ts";
 export { composeSideBySide, DefaultAlisioMascot, DefaultStartupScreen, infoSection, mascotSection, padEnd, pluginsSection, renderStartup, type StartupDiagnostic, type StartupInput, type StartupResult, sanitizeLine, shortenPath, startupTips, stripAnsi, tipsSection, titleSection, truncate, visibleWidth, welcomeSection, } from "./startup/index.ts";
+export { formatBytes, NOT_SANDBOXED } from "./tools/analysis.ts";
+export { ARTIFACT_READ_MAX, exportedPaths } from "./tools/artifacts.ts";
+export { GET_GOAL_TOOL, parseEvidence, UPDATE_GOAL_TOOL } from "./tools/goal.ts";
 export { hash, objectSchema, registerStandard } from "./tools/standard.ts";
 export { getTrust, hashProjectConfig, hasProjectResources, listTrust, resolveTrust, revokeTrust, setTrust, type TrustEntry, type TrustListing, type TrustResolution, trustStorePath, } from "./trust.ts";

package/dist/index.js

@@ -1,28 +1,73 @@
 /** @alisio/core public API: embed the Alisio agent programmatically. */
 export * from "@alisio/sdk";
+export { AGENT_COMMAND_PREFIX, activeAgentCatalog, agentCatalogFromState, agentCommandDescriptors, agentCommandName, agentIdFromCommand, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, cycleableAgents, DEFAULT_AGENT_ID, mainAgentFromRecord, nextAgent, PLAN_AGENT_ID, resolveActiveAgent, } from "./agents/active.js";
+export { agentModelCapabilities, agentModelLabels, agentModelOptions, DEFAULT_EFFORT_LEVELS, fitAgentSettings, } from "./agents/capabilities.js";
+export { AGENT_AUTHORING_SKILL_NAMES, CREATE_AGENT_SKILL, } from "./agents/create-agent-skill.js";
+export { AGENT_ID_PATTERN, AGENT_LIMITS, AGENT_REASONING_SUMMARIES, AGENT_TEXT_FORMATS, AGENT_VERBOSITIES, AgentNotFoundError, AgentScopeStore, agentIdFromName, agentScopeDir, parseAgentFile, RESERVED_AGENT_IDS, slugify, validateAgentDefinitionInput, } from "./agents/definitions.js";
+export { AGENT_DRAFT_INSTRUCTIONS, AGENT_DRAFT_MAX_DESCRIPTION, agentAuthoringGuidance, agentDraftRequest, generateAgentDraft, parseAgentDraft, } from "./agents/draft.js";
+export { AgentDefinitionService, mergeAgentScopes, } from "./agents/service.js";
+export { AGENT_TEMPLATES, agentTemplate } from "./agents/templates.js";
+export { CapabilityGrants, toGrantWire, } from "./analysis/capabilities.js";
+export { CsvParser, decodeTextBytes, detectDelimiter } from "./analysis/data/csv.js";
+export { DatasetService, DEFAULT_DATASET_LIMITS, datasetFormat, PageParamError, toDatasetRef, XLSX_REMEDY, } from "./analysis/data/datasets.js";
+export { DataEngine, DataError, } from "./analysis/data/engine-client.js";
+export { guardSql } from "./analysis/data/sql-guard.js";
+export { detectHintHost, installHintsMarkdown, installHintsText, parseOsRelease, pythonInstallHints, } from "./analysis/install-hints.js";
+export { AnalysisJanitor, SWEEP_INTERVAL_MS, } from "./analysis/janitor.js";
+export { AnalysisJobs, } from "./analysis/jobs.js";
+export { containerName, OciRuntime, ociRunArgs, parseDigests, } from "./analysis/oci.js";
+export { AnalysisRerun, } from "./analysis/rerun.js";
+export { AnalysisRuntimeManager, ExtrasInstallError, installPreview, setupCommand, venvInterpreter, } from "./analysis/runtime-manager.js";
+export { analysisStatus } from "./analysis/status.js";
 export { createApplication, enabledBuiltins, } from "./application.js";
-export { configFile, configHome, configSchema, isSettableSettingKey, loadConfig, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
+export { classifyArtifact, extensionOf, fileType as artifactFileType, isPreviewable, KIND_LABELS, viewerContentType, } from "./artifacts/kinds.js";
+export { createArtifactPublisher } from "./artifacts/publisher.js";
+export { ArtifactRejected, ArtifactStore, readHead as readArtifactHead, slugify as artifactSlug, toRef, } from "./artifacts/store.js";
+export { TaskJanitor } from "./background/janitor.js";
+export { subagentTasks } from "./background/mirror.js";
+export { buildTaskNotification, DEFAULT_NOTIFIER_TIMING, TaskNotifier, } from "./background/notify.js";
+export { DEFAULT_READ_BYTES, MAX_READ_BYTES } from "./background/output.js";
+export { BackgroundTasks, TaskAdmissionError, TaskForeignError, TaskNotFoundError, } from "./background/service.js";
+export { BackgroundTaskStore, isLive as isTaskLive, isTerminal as isTaskTerminal, } from "./background/store.js";
+export { changelogNews, compareVersions, formatChangelogMarkdown, isVersion, loadChangelog, parseChangelog, selectEntries, UNRELEASED, } from "./changelog/index.js";
+export { BUILTIN_COMMANDS, CommandCatalog, } from "./commands/catalog.js";
+export { configFile, configHome, configSchema, isSettableSettingKey, loadConfig, loadConfigWithProvenance, OCI_IMAGE_PATTERN, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, settableSettings, stateHome, } from "./config.js";
 export { checkpointInstructions, completeText, effectiveContextBudget, estimateTokens, MAX_TRUSTED_WINDOW, parseCheckpointOutput, planCompaction, renderCheckpoint, serializeForSummary, shouldCompact, shouldCompactContext, summarize, } from "./core/compaction.js";
+export { EXIT_PLAN_TOOL, GOAL_TOOLS, OPT_IN_TOOLS } from "./core/opt-in.js";
+export { DEFAULT_MAX_OUTPUT_TOKENS, describeOutputLimitSource, MAX_AUTO_OUTPUT_TOKENS, resolveMaxOutputTokens, } from "./core/output-limit.js";
 export { ToolRegistry } from "./core/registry.js";
 export { AgentRunner, defaultTokenBudget, } from "./core/runner.js";
 export { ExtensionRegistry } from "./extensions/registry.js";
+export * from "./goal/index.js";
 export { HerdrBridge } from "./integrations/herdr.js";
 export { McpConnector, } from "./mcp/connector.js";
-export { discoverPlugins, PluginHost, pluginPrefix, } from "./plugins/host.js";
+export { describePermissionStatus, effectState, FULL_ACCESS_WARNING, modeFromFlags, modeToPreset, PERMISSION_MODE_TABLE, PERMISSION_MODES, PERMISSION_MODES_LOCKED, PERMISSION_USAGE, parsePermissionCommand, parsePermissionMode, presetToMode, READ_ONLY_POLICY, } from "./permissions/modes.js";
+export { claimApprovedPlan, currentPlan, discardApprovedPlan, IMPLEMENTATION_AGENT_ID, implementationPrompt, PLAN_CONTEXT_MAX_CHARS, PLAN_OPTIONS, PLAN_QUESTION_ID, PLAN_REVIEW_TITLE, PLAN_TEXT_KEY, planHash, readPlanState, settlePlanRun, withdrawPendingPlan, } from "./plan/state.js";
+export { discoverPlugins, PluginHost, pluginPrefix, ViewRunError, } from "./plugins/host.js";
 export { cliInstall, INSTALL_TIMEOUT_MS, installedNpmPlugins, installPlugin, npmInstallTarget, parsePluginSpec, pluginTrustRemark, printInstallResult, registerPluginInstallTool, sanitizeNpmError, } from "./plugins/install.js";
 export { ActiveProvider, ProviderRegistry, UnconfiguredProvider } from "./providers/registry.js";
 export { availableProviderModels, resolveProviderModel, } from "./providers/routing.js";
-export { ProviderSettingsStore, } from "./providers/settings.js";
+export { maskSecret, ProviderSettingsStore, } from "./providers/settings.js";
+export { buildReloadReport, formatReloadReport, ReloadFailedError, ReloadRefusedError, reloadApplication, snapshotApplication, validateReloadConfig, } from "./reload.js";
 export { ProjectContext, } from "./resources/context.js";
 export { expandSlashPrompt, loadPromptTemplates, parsePromptTemplate, promptSources, renderPromptTemplate, splitArguments, } from "./resources/prompts.js";
 export { Skills, skillRoots, } from "./resources/skills.js";
+export { PathAccess, } from "./runtime/access.js";
+export { BlobStore, BlobTooLarge } from "./runtime/blobs.js";
+export { clipLines, unifiedPatch } from "./runtime/diff.js";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.js";
+export { newId, ulid } from "./runtime/ids.js";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.js";
-export { findWorkspace, safePath } from "./runtime/paths.js";
+export { findWorkspace, inside, outsideRootsMessage, safePath, workspaceKey, } from "./runtime/paths.js";
 export { isMissingCommand, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.js";
 export { isSqliteExperimentalWarning, openDatabase } from "./runtime/sqlite.js";
 export { SQLiteStore } from "./runtime/store.js";
+export { crc32, writeZip } from "./runtime/zip.js";
 export { ChildSessions } from "./sessions/children.js";
+export { formatSideQuestion, SIDE_QUESTION_DESCRIPTION, SIDE_QUESTION_HISTORY_LIMIT, SIDE_QUESTION_INSTRUCTIONS, SIDE_QUESTION_MAX_CHARS, SIDE_QUESTION_USAGE, SIDE_QUESTIONS_NAMESPACE, SideQuestions, sideTranscript, } from "./sessions/side-questions.js";
 export { composeSideBySide, DefaultAlisioMascot, DefaultStartupScreen, infoSection, mascotSection, padEnd, pluginsSection, renderStartup, sanitizeLine, shortenPath, startupTips, stripAnsi, tipsSection, titleSection, truncate, visibleWidth, welcomeSection, } from "./startup/index.js";
+export { formatBytes, NOT_SANDBOXED } from "./tools/analysis.js";
+export { ARTIFACT_READ_MAX, exportedPaths } from "./tools/artifacts.js";
+export { GET_GOAL_TOOL, parseEvidence, UPDATE_GOAL_TOOL } from "./tools/goal.js";
 export { hash, objectSchema, registerStandard } from "./tools/standard.js";
 export { getTrust, hashProjectConfig, hasProjectResources, listTrust, resolveTrust, revokeTrust, setTrust, trustStorePath, } from "./trust.js";

package/dist/mcp/connector.js

@@ -4,7 +4,18 @@ import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/cli
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { objectSchema } from "../tools/standard.js";
 import { loadVersion } from "../version.js";
+import { mapMcpCallResult, mapMcpResourceResult } from "./rich.js";
 const TOOL_NAME_LIMIT = 64;
+/**
+ * Per-server client close cap used ONLY by the terminal `close()`: the MCP SDK's stdio close can
+ * take ~4s worst case (stdin end → 2s → SIGTERM → 2s → SIGKILL) when a server ignores
+ * termination, and exit must never wait for that ladder. Runtime `disconnect()` keeps its
+ * unbounded semantics so interactive reconnect flows stay unchanged.
+ */
+const CLOSE_SERVER_TIMEOUT_MS = 800;
+/** Overall cap for `close()` (every connected server in parallel plus bridge unregistration). */
+const CLOSE_TOTAL_TIMEOUT_MS = 1_500;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const semanticSegment = (value, fallback) => value
     .normalize("NFKD")
     .replace(/[\u0300-\u036f]/g, "")
@@ -101,7 +112,7 @@ export class McpConnector {
                     const result = i.uri
                         ? await client.readResource({ uri: String(i.uri) }, { signal: c.signal, timeout: 15000 })
                         : await client.listResources(undefined, { signal: c.signal, timeout: 15000 });
-                    return textResult(JSON.stringify(result));
+                    return mapMcpResourceResult(result);
                 },
             }));
             undo.push(this.registry.register({
@@ -208,7 +219,7 @@ export class McpConnector {
         if (!config)
             throw new Error(`Unknown MCP server: ${name}`);
         if (!config.enabled)
-            throw new Error(`MCP server "${name}" is disabled; enable it in /mcp`);
+            throw new Error(`MCP server "${name}" is disabled; enable it in /mcps`);
         if (this.clients.has(name))
             return this.registeredNames(name);
         if (config.transport === "http" &&
@@ -319,7 +330,7 @@ export class McpConnector {
                             JSON.stringify(current.inputSchema) !== JSON.stringify(tool.inputSchema))
                             throw new Error("MCP schema changed; reconnect the server to refresh tools");
                         const result = await client.callTool({ name: tool.name, arguments: input }, { signal: ctx.signal, timeout: 30000 });
-                        return textResult(JSON.stringify(result), "isError" in result && result.isError === true);
+                        return mapMcpCallResult(result);
                     },
                 }));
             }
@@ -385,8 +396,29 @@ export class McpConnector {
         return [...(this.clients.get(name)?.registeredNames ?? [])];
     }
     async close() {
-        await Promise.all([...this.clients.keys()].map((name) => this.disconnect(name)));
-        for (const undo of this.bridgeUndo.splice(0).reverse())
-            undo();
+        const servers = [...this.clients.keys()];
+        // Exit latency is user-facing: every server is disconnected in parallel, each client close
+        // raced against a short cap, and the whole phase against an overall cap. An abandoned close
+        // keeps running in the background and the SDK still SIGKILLs an unresponsive server; the
+        // registry cleanup runs synchronously inside `disconnect`, so tools are always unregistered.
+        await Promise.race([
+            (async () => {
+                await Promise.all(servers.map((name) => Promise.race([this.disconnect(name), delay(CLOSE_SERVER_TIMEOUT_MS)])));
+                for (const undo of this.bridgeUndo.splice(0).reverse())
+                    undo();
+            })(),
+            delay(CLOSE_TOTAL_TIMEOUT_MS),
+        ]);
+        // A raced `disconnect` may have been abandoned before its final status cleanup (it flips
+        // the status only after `client.close()` resolves): the client entry is already gone, so
+        // settle the status here for exit without touching runtime disconnect semantics.
+        for (const name of servers) {
+            if (this.clients.has(name) || this.statuses.get(name) !== "connected")
+                continue;
+            const server = this.servers[name];
+            if (!server)
+                continue;
+            this.statuses.set(name, server.enabled ? "disconnected" : "disabled");
+        }
     }
 }

package/dist/mcp/rich.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MCP → Alisio result mapping ("Nivel 0" rich tool results).
+ *
+ * MCP protocol types never leak into the SDK: this adapter is the single place that folds an
+ * MCP `CallToolResult` / `ReadResourceResult` into the Alisio-owned `ToolResult` content union
+ * (text, image, ui blocks). Mapping is heuristic and conservative:
+ *
+ * - `text` parts stay text parts; an image part becomes `{type:"image"}` (base64 data + mime).
+ * - `structuredContent` (or a JSON-parseable text part) is folded into a `ui` block when it
+ *   matches a verified shape — `{columns,rows}` / `{headers,rows}` tables, all-scalar
+ *   key-value objects, or `{nodes:[{label,children,meta}]}` trees. Anything else stays text
+ *   (the previous flattening).
+ * - A canonical text projection of every ui block / image is ALWAYS appended as a text part so
+ *   providers, compaction and headless output only see text.
+ * - Unknown call results (no contents, nothing recognized) keep the previous
+ *   `JSON.stringify(result)` behavior verbatim.
+ */
+import { type ToolResult, type UiBlock } from "@alisio/sdk";
+/**
+ * Folds a candidate value into a UiBlock when it matches one of the verified shapes:
+ * `{columns,rows}` / `{headers,rows}` tables, `{nodes:[...]}` trees, or flat scalar objects.
+ */
+export declare function blockFromUnknown(value: unknown): UiBlock | undefined;
+/** Tries a JSON-parseable text part: recognized shapes become ui blocks, everything else stays text. */
+export declare function blockFromJsonText(text: string): UiBlock | undefined;
+/** Compact plain-text rendering of a ui block, used as the canonical model-visible projection. */
+export declare function renderUiBlockText(block: UiBlock): string;
+/**
+ * Maps an MCP `CallToolResult` into an Alisio `ToolResult`. Text/image parts map directly;
+ * verified table/key-value/tree shapes (from `structuredContent` or JSON text parts) become
+ * `ui` blocks; a canonical text projection is always appended when non-text parts exist, and
+ * unrecognized results keep the previous `JSON.stringify` flattening verbatim.
+ */
+export declare function mapMcpCallResult(result: unknown): ToolResult;
+/**
+ * Maps an MCP `ReadResourceResult` / `ListResourcesResult` into an Alisio `ToolResult`.
+ * Text contents map to text parts; image blobs become `{type:"image"}` parts; non-image blobs
+ * become a text marker (never raw base64 in the model prompt). Results without contents (a
+ * resource listing, for example) keep the previous `JSON.stringify` flattening.
+ */
+export declare function mapMcpResourceResult(result: unknown): ToolResult;