@alisio/server 0.1.0-alpha.1

package/dist/host/git.js

@@ -0,0 +1,99 @@
+/**
+ * Read-only git queries for the file routes (tree filtering, change marks, diffs). `spawn`
+ * without a shell, a 2 s timeout, bounded output, and options that keep git from running
+ * repository-configured programs (no fsmonitor, no external diff or textconv) or taking locks.
+ */
+import { spawn } from "node:child_process";
+import { relative, resolve, sep } from "node:path";
+const BASE = ["-c", "core.fsmonitor=false", "-c", "core.quotepath=off", "--no-optional-locks"];
+/** Runs git in `cwd`; resolves with code -1 when git is missing, times out or overflows. */
+export function runGit(cwd, args, 
+/** `literal`: pathspecs are plain paths (no globs or magic); unsupported by check-ignore. */
+options = {}) {
+    const maxBytes = options.maxBytes ?? 8 * 1024 * 1024;
+    return new Promise((done) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            done(result);
+        };
+        let child;
+        try {
+            child = spawn("git", [...BASE, ...(options.literal ? ["--literal-pathspecs"] : []), ...args], {
+                cwd,
+                stdio: ["pipe", "pipe", "ignore"],
+                env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0" },
+            });
+        }
+        catch {
+            finish({ code: -1, stdout: "" });
+            return;
+        }
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            finish({ code: -1, stdout: "" });
+        }, options.timeoutMs ?? 2_000);
+        const chunks = [];
+        let size = 0;
+        child.stdout?.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                child.kill("SIGKILL");
+                finish({ code: -1, stdout: "" });
+                return;
+            }
+            chunks.push(chunk);
+        });
+        child.on("error", () => finish({ code: -1, stdout: "" }));
+        child.on("close", (code) => finish({ code: code ?? -1, stdout: Buffer.concat(chunks).toString("utf8") }));
+        child.stdin?.on("error", () => { });
+        child.stdin?.end(options.input ?? "");
+    });
+}
+/** Top-level directory of the repository containing `cwd`, or undefined outside git. */
+export async function gitRoot(cwd) {
+    const r = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    return r.code === 0 && r.stdout.trim() ? r.stdout.trim() : undefined;
+}
+const toPosix = (path) => path.split(sep).join("/");
+/**
+ * `git status --porcelain=v1 -z` of the repository as `workspace-relative path → code` (`M`,
+ * `A`, `D`, `R`, `??`…). Paths outside `workspace` (sibling directories of a monorepo) are left out.
+ */
+export async function gitStatus(workspace, top) {
+    const marks = new Map();
+    const r = await runGit(workspace, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+    if (r.code !== 0)
+        return marks;
+    const fields = r.stdout.split("\0");
+    for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        if (field.length < 4)
+            continue;
+        const xy = field.slice(0, 2);
+        const path = field.slice(3);
+        if (xy[0] === "R" || xy[0] === "C")
+            i++; // the next field is the original path
+        const code = xy === "??" ? "??" : ((xy[0] !== " " ? xy[0] : xy[1]) ?? "M");
+        const rel = relative(workspace, resolve(top, path));
+        if (rel.startsWith(".."))
+            continue;
+        marks.set(toPosix(rel), code);
+    }
+    return marks;
+}
+/** The subset of workspace-relative `paths` (directories end in `/`) that git ignores. */
+export async function gitIgnored(workspace, paths) {
+    if (!paths.length)
+        return new Set();
+    const r = await runGit(workspace, ["check-ignore", "-z", "--stdin"], {
+        input: `${paths.join("\0")}\0`,
+    });
+    // 0: some ignored, 1: none, anything else: not a repository or an error (show everything).
+    if (r.code !== 0)
+        return new Set();
+    return new Set(r.stdout.split("\0").filter(Boolean));
+}

package/dist/host/presets.d.ts

@@ -0,0 +1,21 @@
+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;
+/**
+ * The capability ceiling of a workspace: the policy its app was launched with (the `alisio serve`
+ * flags) and whether approvals exist at all (not under `--read-only`).
+ */
+export interface Ceiling {
+    policy: Readonly<Policy>;
+    approvals: boolean;
+    readOnly: boolean;
+}
+/**
+ * A preset narrowed by the ceiling: an effect the launch flags do not allow degrades to asking
+ * (the runner only ever narrows its own policy). Under `--read-only` only `read-only` exists.
+ */
+export declare function presetInfo(id: PermissionPresetId, ceiling: Ceiling): PermissionPresetInfo;
+export declare const presetInfos: (ceiling: Ceiling) => PermissionPresetInfo[];
+/** The stored preset of a session, falling back to the default (or `read-only` when forced). */
+export declare function sessionPreset(options: Record<string, unknown> | undefined, ceiling: Ceiling): PermissionPresetId;

package/dist/host/presets.js

@@ -0,0 +1,60 @@
+export const PRESET_IDS = [
+    "read-only",
+    "ask",
+    "workspace-write",
+    "full-access",
+];
+export const DEFAULT_PRESET = "workspace-write";
+/** 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 },
+};
+const FLAG = {
+    write: "--allow-write",
+    process: "--allow-process",
+    external: "--allow-external",
+};
+/**
+ * A preset narrowed by the ceiling: an effect the launch flags do not allow degrades to asking
+ * (the runner only ever narrows its own policy). Under `--read-only` only `read-only` exists.
+ */
+export function presetInfo(id, ceiling) {
+    const wanted = WANTED[id];
+    const policy = {
+        write: wanted.policy.write && ceiling.policy.write,
+        process: wanted.policy.process && ceiling.policy.process,
+        external: wanted.policy.external && ceiling.policy.external,
+    };
+    if (ceiling.readOnly && id !== "read-only")
+        return {
+            id,
+            available: false,
+            reason: "The server was started with --read-only",
+            policy: { write: false, process: false, external: false },
+            approvals: false,
+        };
+    const degraded = Object.keys(FLAG).filter((effect) => wanted.policy[effect] && !ceiling.policy[effect]);
+    return {
+        id,
+        available: true,
+        ...(degraded.length
+            ? {
+                reason: `${degraded.join(", ")} still ask: the server was started without ${degraded.map((e) => FLAG[e]).join(", ")}`,
+            }
+            : {}),
+        policy,
+        approvals: wanted.approvals && ceiling.approvals,
+    };
+}
+export const presetInfos = (ceiling) => PRESET_IDS.map((id) => presetInfo(id, ceiling));
+/** The stored preset of a session, falling back to the default (or `read-only` when forced). */
+export function sessionPreset(options, ceiling) {
+    const stored = options?.preset;
+    const id = PRESET_IDS.includes(stored)
+        ? stored
+        : DEFAULT_PRESET;
+    return presetInfo(id, ceiling).available ? id : "read-only";
+}

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

@@ -0,0 +1,67 @@
+import type { Attachment } from "@alisio/sdk";
+import type { Application } from "./workspace-host.ts";
+type RunOptions = NonNullable<Parameters<Application["runner"]["run"]>[3]>;
+/** One prompt accepted by the server: a `runs` row in `queued` until a slot is free. */
+export interface RunJob {
+    runId: string;
+    sessionId: string;
+    workspaceId: string;
+    app: Application;
+    text: string;
+    correlationId: string;
+    /** Built when the run starts, so preset and effort changes while queued apply. */
+    options: () => Omit<RunOptions, "runId" | "correlationId" | "attachments">;
+    attachments?: Attachment[];
+    display?: string;
+}
+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;
+}
+/**
+ * FIFO scheduler with a global concurrency limit. A session has at most one job (queued or
+ * running); the runner itself enforces one active run per session.
+ */
+export declare class RunScheduler {
+    private options;
+    private jobs;
+    private queue;
+    private running;
+    private readonly max;
+    /** Compactions (or other exclusive work) per session, tracked for status and shutdown. */
+    private exclusive;
+    constructor(options?: RunSchedulerOptions);
+    /** Accepts a job; it starts now when a slot is free, otherwise it waits in FIFO order. */
+    submit(job: RunJob): "queued" | "running";
+    private pump;
+    private start;
+    /** The queued or running job of a session. */
+    job(sessionId: string): {
+        runId: string;
+        status: "queued" | "running";
+    } | undefined;
+    /** Whether a session has a job or exclusive work (compaction) in flight. */
+    busy(sessionId: string): boolean;
+    compacting(sessionId: string): boolean;
+    /** Whether any job or exclusive work of a workspace is in flight (blocks eviction). */
+    busyWorkspace(workspaceId: string): boolean;
+    /** Tracks exclusive per-session work (e.g. a manual compaction) until it settles. */
+    track(sessionId: string, workspaceId: string, work: Promise<unknown>, hooks?: {
+        abort?: () => void;
+        onDone?: () => void;
+    }): void;
+    /**
+     * Cancels the session's job: a queued one is removed and journaled `cancelled`; a running one
+     * is aborted (the runner journals it). `runId`, when given, must match.
+     */
+    cancel(sessionId: string, runId?: string): boolean;
+    counts(): {
+        active: number;
+        queued: number;
+    };
+    /** Cancels everything and waits (bounded by `ms`) for running work to settle. */
+    shutdown(ms?: number): Promise<void>;
+}
+export {};

package/dist/host/run-scheduler.js

@@ -0,0 +1,143 @@
+/**
+ * FIFO scheduler with a global concurrency limit. A session has at most one job (queued or
+ * running); the runner itself enforces one active run per session.
+ */
+export class RunScheduler {
+    options;
+    jobs = new Map();
+    queue = [];
+    running = 0;
+    max;
+    /** Compactions (or other exclusive work) per session, tracked for status and shutdown. */
+    exclusive = new Map();
+    constructor(options = {}) {
+        this.options = options;
+        this.max = Math.max(1, options.maxConcurrent ?? 4);
+    }
+    /** Accepts a job; it starts now when a slot is free, otherwise it waits in FIFO order. */
+    submit(job) {
+        const tracked = { ...job, status: "queued", controller: new AbortController() };
+        this.jobs.set(job.sessionId, tracked);
+        this.queue.push(tracked);
+        this.options.onChange?.(job, "queued");
+        this.pump();
+        return tracked.status;
+    }
+    pump() {
+        while (this.running < this.max && this.queue.length) {
+            const job = this.queue.shift();
+            this.start(job);
+        }
+    }
+    start(job) {
+        job.status = "running";
+        this.running++;
+        this.options.onChange?.(job, "running");
+        const { runner, store } = job.app;
+        let run;
+        try {
+            run = runner.run(job.sessionId, job.text, job.controller.signal, {
+                ...job.options(),
+                runId: job.runId,
+                correlationId: job.correlationId,
+                ...(job.attachments?.length ? { attachments: job.attachments } : {}),
+                ...(job.display ? { display: job.display } : {}),
+            });
+        }
+        catch (error) {
+            run = Promise.reject(error);
+        }
+        job.done = run.then(() => undefined, (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, {
+                status: job.controller.signal.aborted ? "cancelled" : "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+        void job.done.finally(() => {
+            this.running--;
+            if (this.jobs.get(job.sessionId) === job)
+                this.jobs.delete(job.sessionId);
+            this.options.onChange?.(job, "finished");
+            this.pump();
+        });
+    }
+    /** The queued or running job of a session. */
+    job(sessionId) {
+        const job = this.jobs.get(sessionId);
+        return job ? { runId: job.runId, status: job.status } : undefined;
+    }
+    /** Whether a session has a job or exclusive work (compaction) in flight. */
+    busy(sessionId) {
+        return this.jobs.has(sessionId) || this.exclusive.has(sessionId);
+    }
+    compacting(sessionId) {
+        return this.exclusive.has(sessionId);
+    }
+    /** Whether any job or exclusive work of a workspace is in flight (blocks eviction). */
+    busyWorkspace(workspaceId) {
+        for (const job of this.jobs.values())
+            if (job.workspaceId === workspaceId)
+                return true;
+        for (const work of this.exclusive.values())
+            if (work.workspaceId === workspaceId)
+                return true;
+        return false;
+    }
+    /** Tracks exclusive per-session work (e.g. a manual compaction) until it settles. */
+    track(sessionId, workspaceId, work, hooks = {}) {
+        const done = work.catch(() => undefined);
+        const onDone = hooks.onDone;
+        this.exclusive.set(sessionId, {
+            workspaceId,
+            done,
+            ...(hooks.abort ? { abort: hooks.abort } : {}),
+        });
+        void done.finally(() => {
+            if (this.exclusive.get(sessionId)?.done === done)
+                this.exclusive.delete(sessionId);
+            onDone?.();
+        });
+    }
+    /**
+     * Cancels the session's job: a queued one is removed and journaled `cancelled`; a running one
+     * is aborted (the runner journals it). `runId`, when given, must match.
+     */
+    cancel(sessionId, runId) {
+        const job = this.jobs.get(sessionId);
+        if (!job || (runId && job.runId !== runId))
+            return false;
+        job.controller.abort(new Error("Cancelled"));
+        if (job.status === "queued") {
+            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");
+        }
+        return true;
+    }
+    counts() {
+        return { active: this.running + this.exclusive.size, queued: this.queue.length };
+    }
+    /** Cancels everything and waits (bounded by `ms`) for running work to settle. */
+    async shutdown(ms = 3_000) {
+        for (const sessionId of [...this.jobs.keys()])
+            this.cancel(sessionId);
+        for (const work of this.exclusive.values())
+            work.abort?.();
+        const pending = [
+            ...[...this.jobs.values()].flatMap((job) => (job.done ? [job.done] : [])),
+            ...[...this.exclusive.values()].map((work) => work.done),
+        ];
+        let timer;
+        await Promise.race([
+            Promise.allSettled(pending),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, ms);
+            }),
+        ]);
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/host/sessions.d.ts

@@ -0,0 +1,81 @@
+import { type Policy, type Session, type SQLiteStore } from "@alisio/core";
+import type { ServerFrame, SessionDetail, SessionDetailWire, SessionSummary, SessionUiStatus } from "@alisio/sdk";
+import { type Ceiling } from "./presets.ts";
+import type { RunScheduler } from "./run-scheduler.ts";
+import { type OpenWorkspace, type ServerAppOptions, type WorkspaceHost } from "./workspace-host.ts";
+export interface SessionServiceOptions {
+    catalog: SQLiteStore;
+    workspaces: WorkspaceHost;
+    scheduler: RunScheduler;
+    base: ServerAppOptions;
+    /** Whether an approval or interaction waits for input in a root session's tree. */
+    awaitingInput?: (rootSessionId: string) => boolean;
+    /** Sends a frame to every connected stream (session status for sidebars). */
+    broadcast?: (frame: ServerFrame) => void;
+}
+/**
+ * Session views (derived UI status §6.2, wire/summary/detail shapes) and per-session run
+ * policy. Reads go to the server's own store connection, so listing sessions never opens a
+ * workspace application.
+ */
+export declare class SessionService {
+    private options;
+    /** Per-session policy objects: "allow for session" widens only its own session. */
+    private policies;
+    readonly ceiling: Ceiling;
+    constructor(options: SessionServiceOptions);
+    /** A session by id, or 404. */
+    get(id: string): Session;
+    /** The root of a session (itself for roots). */
+    rootOf(id: string): string;
+    /** Derived UI status (§6.2); never persisted. */
+    status(session: Session): SessionUiStatus;
+    /**
+     * The stored title, else the first user prompt collapsed to one line and cut at 60
+     * characters (RF-10). Derived on read, never persisted, so a rename always wins.
+     */
+    title(session: Session): string | undefined;
+    wire(session: Session): SessionDetailWire;
+    summary(session: Session): SessionSummary;
+    detail(session: Session): SessionDetail;
+    /**
+     * The policy object passed as `RunOptions.policy` for a session: the preset narrowed by the
+     * ceiling. The runner widens this object on "allow for session", so each session keeps its
+     * own object (the app-wide policy is never mutated by web approvals).
+     */
+    policy(session: Session): {
+        policy: Policy;
+        approvals: boolean;
+    };
+    /** Drops session-scoped grants (after a preset change). */
+    resetPolicy(sessionId: string): void;
+    /**
+     * Run options for the session's next run: its own policy object, approvals, effort and the
+     * session's agent (stored id, else the app's active agent, as in the TUI). A read-only agent
+     * narrows the run to reads without approvals; its instructions are appended per run.
+     */
+    runOptions(sessionId: string): {
+        policy: Policy;
+        approvals: boolean;
+        reasoningEffort?: string;
+        instructions?: string;
+    };
+    private agentOptions;
+    /** Merges keys into the session's stored options (undefined removes a key). */
+    setOptions(sessionId: string, options: Record<string, unknown>): void;
+    runByRequest(sessionId: string, requestId: string): import("@alisio/core").RunRecord | undefined;
+    beginRun(input: Parameters<SQLiteStore["beginRun"]>[0]): {
+        run: import("@alisio/core").RunRecord;
+        created: boolean;
+    };
+    /** Pid of another live process holding the session (for example the TUI). */
+    lockedBy(sessionId: string): number | undefined;
+    /** The already open workspace application of a session, without opening one. */
+    openApp(session: Session): OpenWorkspace | undefined;
+    /** The workspace application of a session, opened on demand. */
+    app(session: Session): Promise<OpenWorkspace>;
+    /** 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;
+}

package/dist/host/sessions.js

@@ -0,0 +1,211 @@
+import { agentCatalogFromState, agentRunOptions, resolveActiveAgent, } from "@alisio/core";
+import { HttpError } from "../http/errors.js";
+import { presetInfos, sessionPreset } from "./presets.js";
+import { workspaceId, } from "./workspace-host.js";
+/**
+ * Session views (derived UI status §6.2, wire/summary/detail shapes) and per-session run
+ * policy. Reads go to the server's own store connection, so listing sessions never opens a
+ * workspace application.
+ */
+export class SessionService {
+    options;
+    /** Per-session policy objects: "allow for session" widens only its own session. */
+    policies = new Map();
+    ceiling;
+    constructor(options) {
+        this.options = options;
+        const base = options.base;
+        const readOnly = !!base.readOnly;
+        this.ceiling = {
+            policy: {
+                write: !readOnly && !!base.allowWrite,
+                process: !readOnly && !!base.allowProcess,
+                external: !readOnly && (!!base.allowExternal || !!base.allowMcp || !!base.allowAgents),
+            },
+            approvals: !readOnly,
+            readOnly,
+        };
+    }
+    /** A session by id, or 404. */
+    get(id) {
+        try {
+            return this.options.catalog.get(id);
+        }
+        catch {
+            throw new HttpError("not_found", "Session not found");
+        }
+    }
+    /** The root of a session (itself for roots). */
+    rootOf(id) {
+        let current = id;
+        for (let depth = 0; depth < 32; depth++) {
+            let session;
+            try {
+                session = this.options.catalog.get(current);
+            }
+            catch {
+                return current;
+            }
+            if (!session.parentId)
+                return current;
+            current = session.parentId;
+        }
+        return current;
+    }
+    /** Derived UI status (§6.2); never persisted. */
+    status(session) {
+        const { catalog, scheduler } = this.options;
+        if (catalog.lockedBy(session.id))
+            return "locked";
+        const job = scheduler.job(session.id);
+        if (job?.status === "queued")
+            return "queued";
+        if (job || scheduler.compacting(session.id))
+            return this.options.awaitingInput?.(session.id) ? "awaiting_input" : "running";
+        const last = catalog.runs?.(session.id, { limit: 1 })[0];
+        return last && (last.status === "failed" || last.status === "interrupted") ? "error" : "idle";
+    }
+    /**
+     * The stored title, else the first user prompt collapsed to one line and cut at 60
+     * characters (RF-10). Derived on read, never persisted, so a rename always wins.
+     */
+    title(session) {
+        if (session.title)
+            return session.title;
+        const first = this.options.catalog
+            .messagesPage(session.id, { after: -1, limit: 4, compacted: true })
+            .items.find((i) => i.message.role === "user" && !i.message.summary)?.message;
+        if (first?.role !== "user")
+            return undefined;
+        const text = (first.display ?? first.text).replace(/\s+/g, " ").trim();
+        return text ? text.slice(0, 60) : undefined;
+    }
+    wire(session) {
+        const title = this.title(session);
+        return {
+            id: session.id,
+            workspaceId: workspaceId(session.workspace),
+            workspace: session.workspace,
+            provider: session.provider,
+            model: session.model,
+            status: session.parentId ? "idle" : this.status(session),
+            ...(title ? { title } : {}),
+            ...(session.parentId ? { parentId: session.parentId } : {}),
+            ...(session.parentId && session.status ? { childStatus: session.status } : {}),
+            ...(session.createdAt ? { createdAt: session.createdAt } : {}),
+            ...(session.updatedAt ? { updatedAt: session.updatedAt } : {}),
+        };
+    }
+    summary(session) {
+        return { ...this.wire(session), pinned: !!session.pinned, archived: !!session.archivedAt };
+    }
+    detail(session) {
+        const options = session.options ?? {};
+        return {
+            ...this.summary(session),
+            preset: sessionPreset(options, this.ceiling),
+            ...(typeof options.effort === "string" ? { effort: options.effort } : {}),
+            ...(typeof options.agent === "string" ? { agent: options.agent } : {}),
+            presets: presetInfos(this.ceiling),
+            children: this.options.catalog.children(session.id).map((child) => this.wire(child)),
+        };
+    }
+    /**
+     * The policy object passed as `RunOptions.policy` for a session: the preset narrowed by the
+     * ceiling. The runner widens this object on "allow for session", so each session keeps its
+     * own object (the app-wide policy is never mutated by web approvals).
+     */
+    policy(session) {
+        const info = presetInfos(this.ceiling).find((p) => p.id === sessionPreset(session.options, this.ceiling));
+        let policy = this.policies.get(session.id);
+        if (!policy) {
+            policy = { ...(info?.policy ?? { write: false, process: false, external: false }) };
+            this.policies.set(session.id, policy);
+        }
+        return { policy, approvals: info?.approvals ?? false };
+    }
+    /** Drops session-scoped grants (after a preset change). */
+    resetPolicy(sessionId) {
+        this.policies.delete(sessionId);
+    }
+    /**
+     * Run options for the session's next run: its own policy object, approvals, effort and the
+     * session's agent (stored id, else the app's active agent, as in the TUI). A read-only agent
+     * narrows the run to reads without approvals; its instructions are appended per run.
+     */
+    runOptions(sessionId) {
+        const session = this.get(sessionId);
+        const { policy, approvals } = this.policy(session);
+        const effort = session.options?.effort;
+        const agent = this.agentOptions(session);
+        return {
+            policy: agent.policy ? { ...agent.policy } : policy,
+            approvals: agent.approvals ?? approvals,
+            ...(typeof effort === "string" ? { reasoningEffort: effort } : {}),
+            ...(agent.instructions ? { instructions: agent.instructions } : {}),
+        };
+    }
+    agentOptions(session) {
+        const app = this.openApp(session)?.app;
+        if (!app)
+            return {};
+        let state;
+        try {
+            state = app.plugins.pluginState("subagents", "mainAgents");
+        }
+        catch {
+            /* 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);
+    }
+    /** Merges keys into the session's stored options (undefined removes a key). */
+    setOptions(sessionId, options) {
+        this.options.catalog.updateSessionMeta(sessionId, { options });
+    }
+    runByRequest(sessionId, requestId) {
+        return this.options.catalog.runByRequest(sessionId, requestId);
+    }
+    beginRun(input) {
+        return this.options.catalog.beginRun(input);
+    }
+    /** Pid of another live process holding the session (for example the TUI). */
+    lockedBy(sessionId) {
+        return this.options.catalog.lockedBy(sessionId);
+    }
+    /** The already open workspace application of a session, without opening one. */
+    openApp(session) {
+        return this.options.workspaces.get(workspaceId(session.workspace));
+    }
+    /** The workspace application of a session, opened on demand. */
+    async app(session) {
+        const opened = await this.options.workspaces.openPath(session.workspace);
+        opened.lastUsed = Date.now();
+        return opened;
+    }
+    /** Broadcasts the current status of a session to every stream (sidebars). */
+    notify(sessionId) {
+        if (!this.options.broadcast)
+            return;
+        let session;
+        try {
+            session = this.options.catalog.get(sessionId);
+        }
+        catch {
+            return;
+        }
+        this.options.broadcast({
+            t: "session_status",
+            sessionId,
+            workspaceId: workspaceId(session.workspace),
+            status: this.status(session),
+            ...(this.title(session) ? { title: this.title(session) } : {}),
+            ...(session.updatedAt ? { updatedAt: session.updatedAt } : {}),
+        });
+    }
+    /** Late binding for components created after this service. */
+    bind(hooks) {
+        Object.assign(this.options, hooks);
+    }
+}