@alisio/server 0.1.0-alpha.8 → 0.1.1

package/dist/bridges/interaction-bridge.js

@@ -1,5 +1,7 @@
 import { randomUUID } from "node:crypto";
 const RECENT = 500;
+/** Longest free-text answer accepted ("Add context"). */
+const TEXT_MAX = 20_000;
 /**
  * Plugin UI requests (`ui.select`, `ui.askQuestions`, `ui.open`) for web clients (RF-18). A
  * request that names a session goes to its root session's streams; otherwise (every `select`)
@@ -29,6 +31,10 @@ export class InteractionBridge {
             askQuestions: (request) => {
                 const empty = () => Object.fromEntries(request.questions.map((q) => [q.id, undefined]));
                 const ids = new Set(request.questions.map((q) => q.id));
+                // `"<questionId>:text"` carries the free text of an option with `textInput` ("Add context").
+                const textKeys = new Set(request.questions
+                    .filter((q) => q.options.some((o) => o.textInput))
+                    .map((q) => `${q.id}:text`));
                 return this.ask({
                     interactionId: randomUUID(),
                     ...(request.session ? { sessionId: request.session } : {}),
@@ -37,15 +43,18 @@ export class InteractionBridge {
                         kind: "questions",
                         questions: request.questions,
                         ...(request.label ? { label: request.label } : {}),
+                        ...(request.plan ? { plan: request.plan } : {}),
                     },
                 }, request.signal, empty(), (answer) => answer === null ||
                     (!!answer &&
                         typeof answer === "object" &&
                         !Array.isArray(answer) &&
-                        Object.entries(answer).every(([id, value]) => ids.has(id) &&
-                            (value === null ||
-                                typeof value === "string" ||
-                                (Array.isArray(value) && value.every((v) => typeof v === "string"))))), (answer) => ({
+                        Object.entries(answer).every(([id, value]) => textKeys.has(id)
+                            ? value === null || (typeof value === "string" && value.length <= TEXT_MAX)
+                            : ids.has(id) &&
+                                (value === null ||
+                                    typeof value === "string" ||
+                                    (Array.isArray(value) && value.every((v) => typeof v === "string"))))), (answer) => ({
                     ...empty(),
                     ...Object.fromEntries(Object.entries((answer ?? {})).map(([id, value]) => [
                         id,

package/dist/host/goal.d.ts

@@ -0,0 +1,36 @@
+import { type GoalHostView, type SQLiteStore } from "@alisio/core";
+import type { GoalInfo, ServerFrame } from "@alisio/sdk";
+import type { RunJob, RunOutcome, RunScheduler } from "./run-scheduler.ts";
+import type { SessionService } from "./sessions.ts";
+import { type WorkspaceHost } from "./workspace-host.ts";
+export interface GoalDriverOptions {
+    catalog: SQLiteStore;
+    sessions: () => SessionService;
+    scheduler: () => RunScheduler;
+    workspaces: () => WorkspaceHost;
+    awaiting: (root: string) => "approval" | "question" | undefined;
+    toSession: (sessionId: string, frame: ServerFrame) => void;
+    closing: () => boolean;
+    log: (event: string, data: Record<string, unknown>) => void;
+}
+export declare class GoalDriver {
+    private readonly options;
+    private readonly store;
+    /** The last frame sent per session, so an unchanged goal is not sent again. */
+    private sent;
+    constructor(options: GoalDriverOptions);
+    private opened;
+    /** What the host knows about a session, for the core's blocker list. */
+    view(sessionId: string): GoalHostView;
+    /** The goal of a root session as UIs see it (with what it waits for), or undefined. */
+    info(sessionId: string): GoalInfo | undefined;
+    /** Sends `goal_changed` when what a UI shows changed (dedupe by content). */
+    refresh(sessionId: string): void;
+    /** Folds a finished run into the session's goal. Child sessions and tool-only jobs have none. */
+    settle(job: RunJob, outcome: RunOutcome): void;
+    /**
+     * Continues the goal if it may continue now. Safe to call from anywhere, any number of times:
+     * the core claims at most one continuation, and a busy session is simply left alone.
+     */
+    pump(sessionId: string): "started" | "waiting" | "idle";
+}

package/dist/host/goal.js

@@ -0,0 +1,172 @@
+/**
+ * The server side of `/goal`: the glue between the core goal service (state machine, caps,
+ * breakers, the claim of ONE continuation) and what only the server knows (the run scheduler, the
+ * pending approvals and questions, the open workspace applications, the SSE hub).
+ *
+ * Everything funnels through `pump(sessionId)`: it asks the core whether the goal continues now
+ * and, when it does, starts the continuation as a normal run (`goal-<goalId>-<n>` is the run's
+ * request id, so a double trigger starts one run). It is called after each user action, after each
+ * run, when the last background task ends, and when anything that blocks a goal may have changed.
+ * A goal never starts a run by any other path.
+ */
+import { randomUUID } from "node:crypto";
+import { GoalStore, goalOutcome, goalWaiting, toGoalInfo, } from "@alisio/core";
+import { workspaceId } from "./workspace-host.js";
+export class GoalDriver {
+    options;
+    store;
+    /** The last frame sent per session, so an unchanged goal is not sent again. */
+    sent = new Map();
+    constructor(options) {
+        this.options = options;
+        this.store = new GoalStore(options.catalog.db);
+    }
+    opened(sessionId) {
+        try {
+            return this.options
+                .workspaces()
+                .get(workspaceId(this.options.catalog.get(sessionId).workspace));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** What the host knows about a session, for the core's blocker list. */
+    view(sessionId) {
+        const { catalog } = this.options;
+        const session = catalog.get(sessionId);
+        const opened = this.opened(sessionId);
+        const awaiting = this.options.awaiting(sessionId);
+        return {
+            running: this.options.scheduler().busy(sessionId) ||
+                !!opened?.app.runner.isRunning(sessionId) ||
+                !!catalog.lockedBy(sessionId),
+            queuedInput: false,
+            ...(awaiting ? { awaiting } : {}),
+            planMode: this.options.sessions().activeAgentId(session) === "plan",
+            liveTasks: opened?.app.tasks.liveCount(sessionId) ?? 0,
+        };
+    }
+    /** The goal of a root session as UIs see it (with what it waits for), or undefined. */
+    info(sessionId) {
+        const goal = this.store.get(sessionId);
+        if (!goal)
+            return undefined;
+        const enabled = this.opened(sessionId)?.app.goals.enabled ?? true;
+        const waiting = goalWaiting({
+            ...this.view(sessionId),
+            status: goal.status,
+            enabled,
+            inflight: !!goal.inflight,
+        });
+        return { ...toGoalInfo(goal), ...(waiting ? { waiting } : {}) };
+    }
+    /** Sends `goal_changed` when what a UI shows changed (dedupe by content). */
+    refresh(sessionId) {
+        let info;
+        try {
+            info = this.info(sessionId);
+        }
+        catch {
+            return;
+        }
+        const key = JSON.stringify(info ?? null);
+        if (this.sent.get(sessionId) === key)
+            return;
+        this.sent.set(sessionId, key);
+        this.options.toSession(sessionId, { t: "goal_changed", sessionId, goal: info ?? null });
+    }
+    /** Folds a finished run into the session's goal. Child sessions and tool-only jobs have none. */
+    settle(job, outcome) {
+        if (job.tool)
+            return;
+        const opened = this.opened(job.sessionId);
+        if (!opened || !opened.app.goals.get(job.sessionId))
+            return;
+        opened.app.goals.settle(job.sessionId, goalOutcome({
+            runId: job.runId,
+            startedAt: outcome.startedAt,
+            endedAt: outcome.endedAt,
+            cancelled: outcome.cancelled,
+            ...(outcome.result ? { result: outcome.result } : {}),
+            ...(outcome.error !== undefined ? { error: outcome.error } : {}),
+        }));
+    }
+    /**
+     * Continues the goal if it may continue now. Safe to call from anywhere, any number of times:
+     * the core claims at most one continuation, and a busy session is simply left alone.
+     */
+    pump(sessionId) {
+        const { catalog } = this.options;
+        try {
+            const session = catalog.get(sessionId);
+            const opened = this.opened(sessionId);
+            if (this.options.closing() || session.parentId || session.archivedAt || !opened) {
+                this.refresh(sessionId);
+                return "idle";
+            }
+            const goals = opened.app.goals;
+            if (!goals.get(sessionId))
+                return "idle";
+            const decision = goals.next(sessionId, this.view(sessionId));
+            this.refresh(sessionId);
+            if (decision.kind === "wait")
+                return "waiting";
+            if (decision.kind !== "continue")
+                return "idle";
+            const { requestId, prompt, run } = decision;
+            const sessions = this.options.sessions();
+            const correlationId = randomUUID();
+            const { run: record, created } = sessions.beginRun({
+                id: randomUUID(),
+                session: sessionId,
+                status: "queued",
+                requestId,
+                correlationId,
+                model: session.model,
+            });
+            if (!created) {
+                // The same continuation was already started (a double trigger): nothing more to do, and
+                // the claim stays with that run.
+                if (["completed", "failed", "cancelled", "interrupted", "turns_exceeded"].includes(record.status))
+                    goals.abandon(sessionId, requestId, prompt.kind);
+                return "started";
+            }
+            const job = {
+                runId: record.id,
+                sessionId,
+                workspaceId: opened.id,
+                app: opened.app,
+                text: prompt.text,
+                display: prompt.display,
+                correlationId,
+                // The goal's own caps (the runner resets its own per run): what is left of the budget and
+                // of the time cap, applied on top of the session's usual run options.
+                options: () => {
+                    const base = sessions.runOptions(sessionId);
+                    const timeout = opened.app.config.limits.timeoutMs;
+                    return {
+                        ...base,
+                        ...(run.maxTokens !== undefined ? { maxTokens: run.maxTokens } : {}),
+                        timeoutMs: Math.max(1000, Math.min(run.remainingMs, timeout ?? run.remainingMs)),
+                    };
+                },
+            };
+            try {
+                this.options.scheduler().submit(job);
+            }
+            catch (error) {
+                goals.abandon(sessionId, requestId, prompt.kind);
+                throw error;
+            }
+            return "started";
+        }
+        catch (error) {
+            this.options.log("goal_pump_failed", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return "idle";
+        }
+    }
+}

package/dist/host/plan.d.ts

@@ -0,0 +1,10 @@
+import { type SQLiteStore } from "@alisio/core";
+import type { RunJob, RunScheduler } from "./run-scheduler.ts";
+import type { SessionService } from "./sessions.ts";
+export declare function followUpPlanRun(input: {
+    job: RunJob;
+    cancelled: boolean;
+    catalog: SQLiteStore;
+    sessions: SessionService;
+    scheduler: RunScheduler;
+}): "started" | "dropped" | "none";

package/dist/host/plan.js

@@ -0,0 +1,45 @@
+/**
+ * What happens after a plan run (spec: Plan Review). `exit_plan` only RECORDS the user's decision
+ * while its run is still going; changing agents in the middle of a run would break the persisted
+ * session. Once the run has ended this follow-up looks at the session's plan state:
+ *
+ * - cancelled run: an approved plan is dropped and a still-pending one is withdrawn;
+ * - approved plan: claimed exactly once (compare-and-set), the session switches to `build` in the
+ *   same transaction and ONE implementation run starts through the normal scheduler, carrying the
+ *   approved plan as a persisted user message. The run's request id is the plan id, so even a
+ *   second claim path could not create a second run.
+ */
+import { randomUUID } from "node:crypto";
+import { IMPLEMENTATION_AGENT_ID, settlePlanRun } from "@alisio/core";
+export function followUpPlanRun(input) {
+    const { job, catalog, sessions, scheduler } = input;
+    const sessionId = job.sessionId;
+    const next = settlePlanRun(catalog, sessionId, {
+        aborted: input.cancelled,
+        alsoSet: { agent: IMPLEMENTATION_AGENT_ID },
+    });
+    if (next.kind !== "implement")
+        return next.kind;
+    const correlationId = randomUUID();
+    const { run, created } = sessions.beginRun({
+        id: randomUUID(),
+        session: sessionId,
+        status: "queued",
+        requestId: `plan-${next.plan.planId}`,
+        correlationId,
+        model: sessions.get(sessionId).model,
+    });
+    if (!created)
+        return "none";
+    scheduler.submit({
+        runId: run.id,
+        sessionId,
+        workspaceId: job.workspaceId,
+        app: job.app,
+        text: next.text,
+        display: next.display,
+        correlationId,
+        options: () => sessions.runOptions(sessionId),
+    });
+    return "started";
+}

package/dist/host/presets.d.ts

@@ -1,4 +1,4 @@
-import type { Policy } from "@alisio/core";
+import { type Policy } from "@alisio/core";
 import type { PermissionPresetId, PermissionPresetInfo } from "@alisio/sdk";
 export declare const PRESET_IDS: readonly PermissionPresetId[];
 export declare const DEFAULT_PRESET: PermissionPresetId;

package/dist/host/presets.js

@@ -1,3 +1,4 @@
+import { PERMISSION_MODE_TABLE, presetToMode, READ_ONLY_POLICY, } from "@alisio/core";
 export const PRESET_IDS = [
     "read-only",
     "ask",
@@ -5,12 +6,17 @@ export const PRESET_IDS = [
     "full-access",
 ];
 export const DEFAULT_PRESET = "workspace-write";
+/** The policy of a permission mode (the table lives in core, shared with the TUI). */
+const ofMode = (mode) => ({
+    policy: { ...PERMISSION_MODE_TABLE[mode].policy },
+    approvals: PERMISSION_MODE_TABLE[mode].approvals,
+});
 /** What each preset asks for before the server ceiling is applied (RF-08). */
 const WANTED = {
-    "read-only": { policy: { write: false, process: false, external: false }, approvals: false },
-    ask: { policy: { write: false, process: false, external: false }, approvals: true },
-    "workspace-write": { policy: { write: true, process: false, external: false }, approvals: true },
-    "full-access": { policy: { write: true, process: true, external: true }, approvals: true },
+    "read-only": { policy: { ...READ_ONLY_POLICY }, approvals: false },
+    ask: ofMode("ask"),
+    "workspace-write": ofMode("auto"),
+    "full-access": ofMode("full"),
 };
 const FLAG = {
     write: "--allow-write",
@@ -32,9 +38,11 @@ export function presetInfo(id, ceiling) {
         // processes (full-access); elsewhere python_run asks.
         ...(wanted.policy.process && ceiling.policy.analysis ? { analysis: true } : {}),
     };
+    const mode = presetToMode(id);
     if (ceiling.readOnly && id !== "read-only")
         return {
             id,
+            ...(mode ? { mode } : {}),
             available: false,
             reason: "The server was started with --read-only",
             policy: { write: false, process: false, external: false },
@@ -43,6 +51,7 @@ export function presetInfo(id, ceiling) {
     const degraded = Object.keys(FLAG).filter((effect) => wanted.policy[effect] && !ceiling.policy[effect]);
     return {
         id,
+        ...(mode ? { mode } : {}),
         available: true,
         ...(degraded.length
             ? {

package/dist/host/run-scheduler.d.ts

@@ -24,11 +24,34 @@ export interface RunJob {
         input: Record<string, unknown>;
     };
 }
+/** What a finished job reports (the goal controller folds it into the session's goal). */
+export interface RunOutcome {
+    /** The job's abort signal fired (a cancel, or the server shutting down). */
+    cancelled: boolean;
+    /** What `runner.run` resolved with, when it did. */
+    result?: {
+        text: string;
+        status: string;
+        usage: {
+            input: number;
+            output: number;
+        };
+        toolCalls?: number;
+    };
+    /** Why it failed, when it did (never set for a cancelled job). */
+    error?: unknown;
+    /** When the job started running (ms), and when it ended. */
+    startedAt: number;
+    endedAt: number;
+}
 export interface RunSchedulerOptions {
     /** Global semaphore across sessions and workspaces (RF-02, default 4). */
     maxConcurrent?: number;
-    /** Called on every job state change (queued, running, finished). */
-    onChange?: (job: RunJob, status: "queued" | "running" | "finished") => void;
+    /**
+     * Called on every job state change (queued, running, finished). `finished` also says whether
+     * the job was cancelled (its abort signal fired), so a follow-up never outlives a cancel.
+     */
+    onChange?: (job: RunJob, status: "queued" | "running" | "finished", outcome?: RunOutcome) => void;
 }
 /**
  * FIFO scheduler with a global concurrency limit. A session has at most one job (queued or

package/dist/host/run-scheduler.js

@@ -31,6 +31,7 @@ export class RunScheduler {
     }
     start(job) {
         job.status = "running";
+        job.startedAt = Date.now();
         this.running++;
         this.options.onChange?.(job, "running");
         const { runner, store } = job.app;
@@ -56,7 +57,11 @@ export class RunScheduler {
         catch (error) {
             run = Promise.reject(error);
         }
-        job.done = run.then(() => undefined, (error) => {
+        job.done = run.then((result) => {
+            if (result && typeof result === "object")
+                job.result = result;
+        }, (error) => {
+            job.error = error;
             // A run that never reached the runner's journal (e.g. the session was claimed) must not
             // stay `queued`; terminal rows are never overwritten.
             store.endRun?.(job.runId, {
@@ -68,7 +73,13 @@ export class RunScheduler {
             this.running--;
             if (this.jobs.get(job.sessionId) === job)
                 this.jobs.delete(job.sessionId);
-            this.options.onChange?.(job, "finished");
+            this.options.onChange?.(job, "finished", {
+                cancelled: job.controller.signal.aborted,
+                ...(job.result ? { result: job.result } : {}),
+                ...(job.error !== undefined && !job.controller.signal.aborted ? { error: job.error } : {}),
+                startedAt: job.startedAt ?? Date.now(),
+                endedAt: Date.now(),
+            });
             this.pump();
         });
     }
@@ -122,7 +133,11 @@ export class RunScheduler {
             this.queue = this.queue.filter((queued) => queued !== job);
             this.jobs.delete(sessionId);
             job.app.store.endRun?.(job.runId, { status: "cancelled", error: "Cancelled" });
-            this.options.onChange?.(job, "finished");
+            this.options.onChange?.(job, "finished", {
+                cancelled: true,
+                startedAt: Date.now(),
+                endedAt: Date.now(),
+            });
         }
         return true;
     }

package/dist/host/sessions.d.ts

@@ -12,6 +12,8 @@ export interface SessionServiceOptions {
     awaitingInput?: (rootSessionId: string) => boolean;
     /** Sends a frame to every connected stream (session status for sidebars). */
     broadcast?: (frame: ServerFrame) => void;
+    /** A session's stored options changed (agent, preset, effort): a goal may now continue. */
+    onOptions?: (sessionId: string) => void;
 }
 /**
  * Session views (derived UI status §6.2, wire/summary/detail shapes) and per-session run
@@ -23,6 +25,7 @@ export declare class SessionService {
     /** Per-session policy objects: "allow for session" widens only its own session. */
     private policies;
     readonly ceiling: Ceiling;
+    private readonly goals;
     constructor(options: SessionServiceOptions);
     /** A session by id, or 404. */
     get(id: string): Session;
@@ -59,10 +62,16 @@ export declare class SessionService {
         approvals: boolean;
         reasoningEffort?: string;
         instructions?: string;
+        optInTools?: string[];
     };
+    /** The agent id the session's next run uses (stored id, else the app's active agent). */
+    activeAgentId(session: Session): string | undefined;
+    private resolveAgent;
     private agentOptions;
     /** Merges keys into the session's stored options (undefined removes a key). */
     setOptions(sessionId: string, options: Record<string, unknown>): void;
+    /** A session option (agent, preset, effort) changed: a goal that waited on it may continue. */
+    optionsChanged(sessionId: string): void;
     runByRequest(sessionId: string, requestId: string): import("@alisio/core").RunRecord | undefined;
     beginRun(input: Parameters<SQLiteStore["beginRun"]>[0]): {
         run: import("@alisio/core").RunRecord;
@@ -77,5 +86,5 @@ export declare class SessionService {
     /** Broadcasts the current status of a session to every stream (sidebars). */
     notify(sessionId: string): void;
     /** Late binding for components created after this service. */
-    bind(hooks: Pick<SessionServiceOptions, "awaitingInput" | "broadcast">): void;
+    bind(hooks: Pick<SessionServiceOptions, "awaitingInput" | "broadcast" | "onOptions">): void;
 }

package/dist/host/sessions.js

@@ -1,4 +1,4 @@
-import { agentCatalogFromState, agentRunOptions, resolveActiveAgent, } from "@alisio/core";
+import { agentCatalogFromState, agentRunOptions, GoalStore, goalOptInTools, PLAN_AGENT_ID, resolveActiveAgent, } from "@alisio/core";
 import { HttpError } from "../http/errors.js";
 import { presetInfos, sessionPreset } from "./presets.js";
 import { workspaceId, } from "./workspace-host.js";
@@ -12,8 +12,10 @@ export class SessionService {
     /** Per-session policy objects: "allow for session" widens only its own session. */
     policies = new Map();
     ceiling;
+    goals;
     constructor(options) {
         this.options = options;
+        this.goals = new GoalStore(options.catalog.db);
         const base = options.base;
         const readOnly = !!base.readOnly;
         this.ceiling = {
@@ -139,6 +141,9 @@ export class SessionService {
         const { policy, approvals } = this.policy(session);
         const effort = session.options?.effort;
         const agent = this.agentOptions(session);
+        // The goal tools exist for the runs of a session with an ACTIVE goal (never in plan mode).
+        const goalTools = goalOptInTools(this.goals.get(session.id), this.activeAgentId(session) === PLAN_AGENT_ID);
+        const optInTools = [...(agent.optInTools ?? []), ...goalTools];
         return {
             policy: agent.policy ? { ...agent.policy } : policy,
             approvals: agent.approvals ?? approvals,
@@ -149,12 +154,18 @@ export class SessionService {
                     ? { reasoningEffort: agent.reasoningEffort }
                     : {}),
             ...(agent.instructions ? { instructions: agent.instructions } : {}),
+            ...(optInTools.length ? { optInTools } : {}),
         };
     }
-    agentOptions(session) {
+    /** The agent id the session's next run uses (stored id, else the app's active agent). */
+    activeAgentId(session) {
         const app = this.openApp(session)?.app;
+        const stored = session.options?.agent;
         if (!app)
-            return {};
+            return typeof stored === "string" ? stored : undefined;
+        return this.resolveAgent(session, app)?.id;
+    }
+    resolveAgent(session, app) {
         let state;
         try {
             state = app.plugins.pluginState("subagents", "mainAgents");
@@ -163,12 +174,22 @@ export class SessionService {
             /* agent contributions are best-effort */
         }
         const stored = session.options?.agent;
-        const agent = resolveActiveAgent(agentCatalogFromState(state), typeof stored === "string" ? stored : app.config.agents.active);
-        return agentRunOptions(agent);
+        return resolveActiveAgent(agentCatalogFromState(state), typeof stored === "string" ? stored : app.config.agents.active);
+    }
+    agentOptions(session) {
+        const app = this.openApp(session)?.app;
+        if (!app)
+            return {};
+        return agentRunOptions(this.resolveAgent(session, app));
     }
     /** Merges keys into the session's stored options (undefined removes a key). */
     setOptions(sessionId, options) {
         this.options.catalog.updateSessionMeta(sessionId, { options });
+        this.optionsChanged(sessionId);
+    }
+    /** A session option (agent, preset, effort) changed: a goal that waited on it may continue. */
+    optionsChanged(sessionId) {
+        this.options.onOptions?.(sessionId);
     }
     runByRequest(sessionId, requestId) {
         return this.options.catalog.runByRequest(sessionId, requestId);

package/dist/host/workspace-host.d.ts

@@ -1,8 +1,8 @@
 import { type AppOptions, createApplication, type SQLiteStore } from "@alisio/core";
-import type { WorkspaceInfo } from "@alisio/sdk";
+import type { ReloadReport, WorkspaceInfo } from "@alisio/sdk";
 export type Application = Awaited<ReturnType<typeof createApplication>>;
 /** `AppOptions` minus what the server owns per workspace (cwd, events, approvals). */
-export type ServerAppOptions = Omit<AppOptions, "cwd" | "onEvent" | "approve" | "approveExternalDirectory">;
+export type ServerAppOptions = Omit<AppOptions, "cwd" | "onEvent" | "approve" | "approveExternalDirectory" | "tasks" | "goals">;
 /** An open workspace: one `Application` bound to one canonical path. */
 export interface OpenWorkspace {
     id: string;
@@ -22,11 +22,11 @@ export interface WorkspaceHostOptions {
     /** Listed even before it has sessions (e.g. the directory `alisio serve` ran in). */
     defaultWorkspace?: string;
     /** Per-workspace wiring the server owns: events and approval handlers. */
-    wire?: (id: string, path: string) => Pick<AppOptions, "onEvent" | "approve" | "approveExternalDirectory">;
+    wire?: (id: string, path: string) => Pick<AppOptions, "onEvent" | "approve" | "approveExternalDirectory" | "tasks" | "goals">;
     /** Called once an app is created (e.g. to bind interactive UI) and before it is closed. */
     onOpen?: (workspace: OpenWorkspace) => void;
     onClose?: (workspace: OpenWorkspace) => void;
-    /** A workspace with runs, subscribers or pending approvals is never evicted. */
+    /** A workspace with runs, subscribers, pending approvals or live background tasks is never evicted. */
     busy?: (id: string) => boolean;
     /** Injectable for tests. */
     create?: typeof createApplication;
@@ -58,6 +58,12 @@ export declare class WorkspaceHost {
     get(id: string): OpenWorkspace | undefined;
     /** Opens (or reuses) the app of a canonical workspace path, evicting an idle one if needed. */
     openPath(path: string): Promise<OpenWorkspace>;
+    /**
+     * Builds the `Application` of a workspace: launch flags are explicit, one-run trust like in the
+     * terminal; otherwise the trust store decides and a workspace that would need a prompt opens
+     * untrusted.
+     */
+    private build;
     private create;
     /** Closes the least recently used idle app, or fails with 503 `workspace_limit`. */
     private evictOne;
@@ -72,6 +78,15 @@ export declare class WorkspaceHost {
      * shared store) and the next request uses the new app.
      */
     recycle(id: string): Promise<OpenWorkspace | undefined>;
+    /**
+     * `/reload` for one open workspace: validate, build the new app NEXT TO the current one and
+     * only then swap, so a broken configuration leaves the workspace and its sessions untouched
+     * (unlike `recycle`, which closes first). The caller refuses while runs are active (`busy`).
+     * SSE subscribers are unaffected: they read the shared store.
+     */
+    reload(id: string, guard?: {
+        busy?: () => string | undefined;
+    }): Promise<ReloadReport>;
     /** Closes every app in parallel (each close is capped by the core's teardown timeouts). */
     closeAll(): Promise<void>;
     /**