@orion-agents/orion-code 0.3.4 → 0.3.9

package/dist/web/host-daemon.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_POLL_MS = exports.DAEMON_READY_TIMEOUT_MS = exports.HOST_DAEMON_CHILD_ENV = exports.HOST_PIDFILE_BASE = void 0;
+exports.hostLogsDirectory = hostLogsDirectory;
+exports.hostPidfilePath = hostPidfilePath;
+exports.parseHostPidfile = parseHostPidfile;
+exports.readHostPidfile = readHostPidfile;
+exports.writeHostPidfile = writeHostPidfile;
+exports.clearHostPidfile = clearHostPidfile;
+exports.isProcessAlive = isProcessAlive;
+exports.hostDaemonStatus = hostDaemonStatus;
+exports.spawnBackgroundHost = spawnBackgroundHost;
+exports.stopBackgroundHost = stopBackgroundHost;
+/**
+ * Native background/daemon lifecycle for `orion web` (issue #247, S1+S2).
+ *
+ * A foreground `orion web --background` parent spawns the real host detached,
+ * waits for it to publish a pidfile under the config home, then returns. The
+ * detached child redirects its stdio to per-host log files and keeps the
+ * fail-closed approval / context / sandbox semantics untouched — this is a
+ * process-lifecycle concern only, still bound to 127.0.0.1.
+ *
+ * The pidfile shape is intentionally tiny and human-readable:
+ *
+ *   { "pid": 12345, "port": 3080, "url": "http://127.0.0.1:3080",
+ *     "startedAt": 1725000000000, "workspace": "/abs/path" }
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const paths_1 = require("../product/paths");
+exports.HOST_PIDFILE_BASE = 'web-host';
+exports.HOST_DAEMON_CHILD_ENV = 'ORION_WEB_DAEMON_CHILD';
+exports.DAEMON_READY_TIMEOUT_MS = 8000;
+exports.DAEMON_POLL_MS = 120;
+function hostLogsDirectory() {
+    return (0, path_1.join)((0, paths_1.getConfigHome)(), 'logs');
+}
+function hostPidfilePath(port) {
+    return (0, path_1.join)((0, paths_1.getConfigHome)(), `${exports.HOST_PIDFILE_BASE}.${port}.pid`);
+}
+function parseHostPidfile(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== 'object')
+            return null;
+        const record = value;
+        if (typeof record.pid !== 'number' ||
+            typeof record.port !== 'number' ||
+            typeof record.url !== 'string' ||
+            typeof record.workspace !== 'string' ||
+            typeof record.startedAt !== 'number') {
+            return null;
+        }
+        return Object.freeze({
+            pid: record.pid,
+            port: record.port,
+            url: record.url,
+            workspace: record.workspace,
+            startedAt: record.startedAt,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function readHostPidfile(port) {
+    const path = hostPidfilePath(port);
+    if (!(0, fs_1.existsSync)(path))
+        return null;
+    try {
+        return parseHostPidfile((0, fs_1.readFileSync)(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeHostPidfile(pidfile) {
+    (0, fs_1.mkdirSync)((0, paths_1.getConfigHome)(), { recursive: true });
+    (0, fs_1.writeFileSync)(hostPidfilePath(pidfile.port), JSON.stringify(pidfile, null, 2), 'utf8');
+}
+function clearHostPidfile(port) {
+    try {
+        (0, fs_1.rmSync)(hostPidfilePath(port), { force: true });
+    }
+    catch {
+        // Pidfile removal is best-effort: a locked/restricted filesystem must not
+        // turn `orion web stop` into a failure after the process is already gone.
+    }
+}
+/** Cross-platform process-liveness probe used by `status`. */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function hostDaemonStatus(port) {
+    const pidfile = readHostPidfile(port);
+    if (!pidfile)
+        return { state: 'stopped' };
+    if (isProcessAlive(pidfile.pid)) {
+        return { state: 'running', pidfile };
+    }
+    return { state: 'stale', pid: pidfile.pid, port };
+}
+/** Build the argument vector used to re-launch the current CLI detached. */
+function childArgs(webArgs) {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error('Unable to determine the CLI entry to relaunch.');
+    return [entry, 'web', ...webArgs];
+}
+/**
+ * Parent-side entry for `--background`: spawn the host detached, redirect its
+ * stdio to `~/.orion-code/logs/web-<port>.log`, and wait for the pidfile so the
+ * foreground command can print the URL and exit cleanly.
+ */
+function spawnBackgroundHost(options) {
+    const logsDirectory = hostLogsDirectory();
+    (0, fs_1.mkdirSync)(logsDirectory, { recursive: true });
+    const logPath = (0, path_1.join)(logsDirectory, `web-${options.port}.log`);
+    const output = (0, fs_1.openSync)(logPath, 'a');
+    const child = (0, child_process_1.spawn)(process.execPath, childArgs(options.webArgs), {
+        cwd: options.cwd,
+        detached: true,
+        stdio: ['ignore', output, output],
+        env: { ...process.env, [exports.HOST_DAEMON_CHILD_ENV]: '1' },
+    });
+    child.unref();
+    return new Promise((resolve, reject) => {
+        const deadline = Date.now() + exports.DAEMON_READY_TIMEOUT_MS;
+        const poll = () => {
+            const pidfile = readHostPidfile(options.port);
+            if (pidfile && pidfile.pid === child.pid) {
+                resolve({ child, pidfile });
+                return;
+            }
+            if (child.exitCode !== null || child.signalCode !== null) {
+                reject(new Error(`Background host exited before readiness (code ${child.exitCode ?? 'signal'}); see ${logPath}`));
+                return;
+            }
+            if (Date.now() > deadline) {
+                reject(new Error(`Background host did not become ready within ${exports.DAEMON_READY_TIMEOUT_MS}ms; see ${logPath}`));
+                return;
+            }
+            setTimeout(poll, exports.DAEMON_POLL_MS);
+        };
+        poll();
+    });
+}
+/** Terminate a background host by pidfile (SIGTERM, then escalate to SIGKILL). */
+function stopBackgroundHost(port) {
+    const status = hostDaemonStatus(port);
+    if (status.state !== 'running')
+        return Promise.resolve('not_running');
+    const { pidfile } = status;
+    return new Promise(resolve => {
+        try {
+            process.kill(pidfile.pid, 'SIGTERM');
+        }
+        catch {
+            clearHostPidfile(port);
+            resolve('stopped');
+            return;
+        }
+        const deadline = Date.now() + 4000;
+        const poll = () => {
+            if (!isProcessAlive(pidfile.pid)) {
+                clearHostPidfile(port);
+                resolve('stopped');
+                return;
+            }
+            if (Date.now() > deadline) {
+                try {
+                    process.kill(pidfile.pid, 'SIGKILL');
+                }
+                catch {
+                    // Already gone.
+                }
+                clearHostPidfile(port);
+                resolve('stopped');
+                return;
+            }
+            setTimeout(poll, 100);
+        };
+        poll();
+    });
+}
+//# sourceMappingURL=host-daemon.js.map

package/dist/web/launch.d.ts

@@ -2,6 +2,9 @@ export interface RunOrionWebOptions {
     readonly cwd: string;
     readonly port?: number;
     readonly open?: boolean;
+    readonly background?: boolean;
+    /** Full `orion web` arguments of the relaunched child (excludes --background). */
+    readonly backgroundArgs?: readonly string[];
     readonly stdout?: Pick<NodeJS.WriteStream, 'write'>;
     readonly stderr?: Pick<NodeJS.WriteStream, 'write'>;
 }

package/dist/web/launch.js

@@ -3,10 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runOrionWeb = runOrionWeb;
 const child_process_1 = require("child_process");
 const server_1 = require("./server");
+const host_daemon_1 = require("./host-daemon");
 async function runOrionWeb(options) {
     const stdout = options.stdout ?? process.stdout;
     const stderr = options.stderr ?? process.stderr;
+    const isDaemonChild = process.env[host_daemon_1.HOST_DAEMON_CHILD_ENV] === '1';
+    const port = options.port ?? 3080;
+    if (options.background && !isDaemonChild) {
+        // Parent side: launch detached and wait for its pidfile, then print the URL.
+        const { pidfile } = await (0, host_daemon_1.spawnBackgroundHost)({
+            cwd: options.cwd,
+            port,
+            webArgs: options.backgroundArgs ?? [],
+        });
+        stdout.write(`Orion Code Web Workbench running in the background: ${pidfile.url}\n`);
+        stdout.write(`pid ${pidfile.pid} · logs ~/.orion-code/logs/web-${port}.log\n`);
+        stdout.write(`Manage it with: orion web status|stop [--port ${port}]\n`);
+        return;
+    }
     const handle = await (0, server_1.startOrionWebServer)({ cwd: options.cwd, port: options.port });
+    if (isDaemonChild) {
+        (0, host_daemon_1.writeHostPidfile)({
+            pid: process.pid,
+            port: handle.port,
+            url: handle.url,
+            workspace: handle.workbench.workspace,
+            startedAt: Date.now(),
+        });
+    }
     stdout.write(`Orion Code Web Workbench: ${handle.url}\n`);
     stdout.write(`Workspace: ${handle.workbench.workspace}\n`);
     if (options.open !== false) {

package/dist/web/protocol.d.ts

@@ -412,6 +412,8 @@ export interface WebSessionSummaryV1 {
     readonly id: string;
     readonly projectPath: string;
     readonly name?: string;
+    /** v0.3.7 — User-assigned tags (optional, sorted as stored). */
+    readonly tags?: readonly string[];
     readonly model: string;
     readonly createdAt: string;
     readonly updatedAt: string;

package/dist/web/protocol.js

@@ -464,6 +464,7 @@ function projectSessionSummary(session) {
                 messageCount: session.messageCount ?? 0,
             }),
         ...(session.taskSummary ? { taskSummary: session.taskSummary } : {}),
+        ...(session.tags && session.tags.length > 0 ? { tags: Object.freeze([...session.tags]) } : {}),
         ...(session.activeGoalId ? { activeGoalId: session.activeGoalId } : {}),
         ...(session.activeGoalObjective ? { activeGoalObjective: session.activeGoalObjective } : {}),
     });

package/dist/web/review-service.js

@@ -9,16 +9,26 @@ class ReviewServiceV1 {
         this.listReceiptRefs = listReceiptRefs;
     }
     async snapshot() {
-        const [status, receiptRefs] = await Promise.all([
-            this.git.status({ pageSize: 2000 }),
+        // v0.3.9 #237/#228 — collect every Git status page. A repository with more
+        // than the single pageSize of changed files was silently truncated before;
+        // the review overview must aggregate all pages (bounded by a guard that
+        // keeps runaway repositories from looping forever).
+        const [receiptRefs, statusPages] = await Promise.all([
             this.listReceiptRefs(),
+            collectStatusPages((cursor) => this.git.status({ pageSize: 2000, ...(cursor ? { cursor } : {}) })),
         ]);
-        const changedFiles = uniqueFiles([
-            ...status.conflicted,
-            ...status.staged,
-            ...status.unstaged,
-            ...status.untracked,
-        ]);
+        const status = statusPages.at(-1) ?? (await this.git.status({ pageSize: 2000 }));
+        const conflicted = [];
+        const staged = [];
+        const unstaged = [];
+        const untracked = [];
+        for (const page of statusPages) {
+            conflicted.push(...page.conflicted);
+            staged.push(...page.staged);
+            unstaged.push(...page.unstaged);
+            untracked.push(...page.untracked);
+        }
+        const changedFiles = uniqueFiles([...conflicted, ...staged, ...unstaged, ...untracked]);
         const verification = receiptRefs.slice(0, 100).map(receipt => Object.freeze({
             callId: receipt.callId,
             sessionId: receipt.sessionId,
@@ -46,11 +56,11 @@ class ReviewServiceV1 {
             clean: status.clean,
             changedFiles: Object.freeze(changedFiles),
             totalChangedFiles: status.totalFiles,
-            stagedCount: status.staged.length,
-            unstagedCount: status.unstaged.length,
-            untrackedCount: status.untracked.length,
-            conflictCount: status.conflicted.length,
-            truncated: status.truncated,
+            stagedCount: staged.length,
+            unstagedCount: unstaged.length,
+            untrackedCount: untracked.length,
+            conflictCount: conflicted.length,
+            truncated: statusPages.at(-1)?.truncated ?? false,
             verification: Object.freeze(verification),
         });
     }
@@ -72,4 +82,22 @@ function uniqueFiles(files) {
         byId.set(file.fileId, file);
     return [...byId.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
+/**
+ * v0.3.9 #237/#228 — page through Git status until the snapshot is fully
+ * collected. The bounded guard (64 pages x 2_000 = 128k files) exists to stop
+ * runaway repositories from looping; a repository exceeding it stays marked
+ * truncated so the UI can still communicate the limit.
+ */
+async function collectStatusPages(fetchPage) {
+    const pages = [];
+    let page = await fetchPage(undefined);
+    pages.push(page);
+    let guard = 0;
+    while (page.truncated && page.nextCursor && guard < 64) {
+        page = await fetchPage(page.nextCursor);
+        pages.push(page);
+        guard += 1;
+    }
+    return pages;
+}
 //# sourceMappingURL=review-service.js.map

package/dist/web/server.js

@@ -112,6 +112,13 @@ async function handleRequest(context) {
         sendJson(response, 200, collectionPage(url, `workspace-sessions-${workspaceId}`, context.workbench.listWorkspaceSessions(workspaceId, contextGuard), session => session.id));
         return;
     }
+    const archivedSessionsMatch = path.match(/^\/workspaces\/([^/]+)\/sessions\/archived$/);
+    if (method === 'GET' && archivedSessionsMatch) {
+        const workspaceId = safeDecodePathSegment(archivedSessionsMatch[1]);
+        const contextGuard = requireContextGuardQuery(url);
+        sendJson(response, 200, collectionPage(url, `workspace-sessions-archived-${workspaceId}`, context.workbench.listArchivedWorkspaceSessions(workspaceId, contextGuard), session => session.id));
+        return;
+    }
     const workspaceSummaryMatch = path.match(/^\/workspaces\/([^/]+)\/summary$/);
     if (method === 'GET' && workspaceSummaryMatch) {
         const workspaceId = requireUuid(safeDecodePathSegment(workspaceSummaryMatch[1]), 'workspaceId');
@@ -279,6 +286,68 @@ async function handleRequest(context) {
         sendJson(response, 200, result);
         return;
     }
+    // v0.3.7 — Session tags / archive / restore / delete. One mutation family:
+    // every body carries a requestId so the idempotency ledger dedupes retries.
+    const sessionTagsMatch = path.match(/^\/sessions\/([^/]+)\/tags$/);
+    if (method === 'POST' && sessionTagsMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session tags request');
+        assertOnlyKeys(body, ['requestId', 'tags', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionTagsMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.tags', { sessionId, tags: body.tags, ...contextGuard }, () => ({
+            requestId,
+            session: context.workbench.setSessionTags(sessionId, body.tags, contextGuard),
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
+    const sessionArchiveMatch = path.match(/^\/sessions\/([^/]+)\/archive$/);
+    if (method === 'POST' && sessionArchiveMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session archive request');
+        assertOnlyKeys(body, ['requestId', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionArchiveMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.archive', { sessionId, ...contextGuard }, () => ({
+            requestId,
+            session: context.workbench.archiveSession(sessionId, contextGuard),
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
+    const sessionRestoreMatch = path.match(/^\/sessions\/([^/]+)\/restore$/);
+    if (method === 'POST' && sessionRestoreMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session restore request');
+        assertOnlyKeys(body, ['requestId', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionRestoreMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.restore', { sessionId, ...contextGuard }, () => ({
+            requestId,
+            session: context.workbench.restoreSession(sessionId, contextGuard),
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
+    const sessionDeleteMatch = path.match(/^\/sessions\/([^/]+)$/);
+    if (method === 'DELETE' && sessionDeleteMatch) {
+        assertMutation(request, context.nonce, context.origin);
+        const body = requireRecord(await readJson(request), 'Session delete request');
+        assertOnlyKeys(body, ['requestId', 'expectedContextRevision', 'workspaceId']);
+        const requestId = requireUuid(body.requestId, 'requestId');
+        const contextGuard = requireContextGuardRecord(body);
+        const sessionId = safeDecodePathSegment(sessionDeleteMatch[1]);
+        const result = await context.workbench.executeMutation(requestId, 'session.delete', { sessionId, ...contextGuard }, () => ({
+            requestId,
+            deleted: context.workbench.deleteSession(sessionId, contextGuard).deleted,
+        }));
+        sendJson(response, 200, result);
+        return;
+    }
     if (method === 'POST' && path === '/commands') {
         assertMutation(request, context.nonce, context.origin);
         sendJson(response, 202, await context.workbench.dispatch(await readJson(request)));

package/dist/web/session-runtime-registry.d.ts

@@ -65,9 +65,23 @@ export declare class WebSessionRuntimeRegistryV1<TActor extends object> {
     private ordinal;
     private runningCountValue;
     private closed;
+    private actorsCreatedCount;
+    private actorsClosedCount;
+    private actorsEvictedCount;
     constructor(options: WebSessionRuntimeRegistryOptionsV1<TActor>);
     get runningCount(): number;
     get residentCount(): number;
+    /**
+     * Cumulative actor pool counters since the registry was created. E2E and
+     * diagnostics compare two reads to prove a pure Session selection allocated
+     * no Session actor (actorsCreated delta 0) and performed no capacity
+     * eviction (actorsEvicted delta 0) while the pool keeps actors alive.
+     */
+    stats(): {
+        readonly actorsCreated: number;
+        readonly actorsClosed: number;
+        readonly actorsEvicted: number;
+    };
     summary(key: WebSessionActorKeyV1): WebSessionRuntimeSummaryV1;
     summaries(): readonly WebSessionRuntimeSummaryV1[];
     /**

package/dist/web/session-runtime-registry.js

@@ -21,6 +21,12 @@ class WebSessionRuntimeRegistryV1 {
         this.ordinal = 0;
         this.runningCountValue = 0;
         this.closed = false;
+        // Host-level actor pool counters. Allocations are the authoritative signal
+        // for "pure selection must not start a Session Runtime" diagnostics: an E2E
+        // reads these before/after a switch and asserts a zero delta.
+        this.actorsCreatedCount = 0;
+        this.actorsClosedCount = 0;
+        this.actorsEvictedCount = 0;
         this.maxRunningSessions = boundedInteger(options.maxRunningSessions, DEFAULT_MAX_RUNNING_SESSIONS, 1, 8, 'maxRunningSessions');
         this.maxResidentSessionActors = boundedInteger(options.maxResidentSessionActors, DEFAULT_MAX_RESIDENT_SESSION_ACTORS, 1, 8, 'maxResidentSessionActors');
         if (this.maxResidentSessionActors < this.maxRunningSessions) {
@@ -39,6 +45,19 @@ class WebSessionRuntimeRegistryV1 {
                 count += 1;
         return count;
     }
+    /**
+     * Cumulative actor pool counters since the registry was created. E2E and
+     * diagnostics compare two reads to prove a pure Session selection allocated
+     * no Session actor (actorsCreated delta 0) and performed no capacity
+     * eviction (actorsEvicted delta 0) while the pool keeps actors alive.
+     */
+    stats() {
+        return {
+            actorsCreated: this.actorsCreatedCount,
+            actorsClosed: this.actorsClosedCount,
+            actorsEvicted: this.actorsEvictedCount,
+        };
+    }
     summary(key) {
         return this.snapshot(this.record(key));
     }
@@ -190,6 +209,7 @@ class WebSessionRuntimeRegistryV1 {
                     await this.options.closeActor(actor, reason);
                     record.actor = undefined;
                     record.estimatedBytes = 0;
+                    this.actorsClosedCount += 1;
                     this.transition(record, wasActive ? 'interrupted' : 'cold');
                 }
                 catch (error) {
@@ -247,6 +267,7 @@ class WebSessionRuntimeRegistryV1 {
             record.actorReady = true;
             actor = undefined;
             record.failure = undefined;
+            this.actorsCreatedCount += 1;
             this.transition(record, 'idle');
             return record.actor;
         }
@@ -286,6 +307,7 @@ class WebSessionRuntimeRegistryV1 {
             throw new WebSessionRuntimeRegistryError(503, 'session_concurrency_limit', 'All resident Session actors are busy; the requested Session remains available read-only.');
         }
         await this.closeResidentLocked(candidate, 'idle Session actor evicted by LRU', 'cold');
+        this.actorsEvictedCount += 1;
     }
     isEvictable(record) {
         return (Boolean(record.actor) &&
@@ -304,6 +326,7 @@ class WebSessionRuntimeRegistryV1 {
             await this.options.closeActor(actor, reason);
             record.actor = undefined;
             record.estimatedBytes = 0;
+            this.actorsClosedCount += 1;
             this.transition(record, terminalPhase);
         }
         catch (error) {

package/dist/web/workbench-controller.d.ts

@@ -26,6 +26,13 @@ export declare class WebWorkbenchController {
     private readonly createRuntime;
     private readonly createSessionRuntime;
     private sessionRegistry;
+    /**
+     * Workspace-scoped shared kernels owned by this Host. Control planes and
+     * Session actors both borrow from this pool, so a Workspace Context switch
+     * never tears down kernels that resident actors still reference. The pool is
+     * released only during Host shutdown.
+     */
+    private readonly workspaceKernels;
     private readonly workspaceRegistry;
     readonly terminalManager: TerminalManagerV1;
     private readonly mutationResults;
@@ -52,6 +59,13 @@ export declare class WebWorkbenchController {
     private contextTransitionReserved;
     private closed;
     private shutdownResult?;
+    /**
+     * Host-observed Web activity counters. Exposed through diagnostics() so E2E
+     * and the diagnostics panel can prove that a pure Session selection issues
+     * no control-plane reinstall (controlPlaneInstalls delta 0) and that
+     * snapshots stay bounded and fast (snapshotTotalMs / snapshotLastMs).
+     */
+    private readonly sessionActivity;
     private workspaceWatchers;
     private resourceInvalidationTimer?;
     private constructor();
@@ -64,11 +78,15 @@ export declare class WebWorkbenchController {
     settings(): WebSettingsSnapshotV1;
     listWorkspaces(context?: WebContextGuardV1): readonly WebWorkspaceSummaryV1[];
     listWorkspaceSessions(workspaceId: string, context?: WebContextGuardV1): readonly WebSessionSummaryV1[];
+    /** Archived sessions of a Workspace (v0.3.7), newest archive first. */
+    listArchivedWorkspaceSessions(workspaceId: string, context?: WebContextGuardV1): readonly WebSessionSummaryV1[];
     workspaceProjectSummary(workspaceId: string, context?: WebContextGuardV1): Promise<WebWorkspaceProjectSummaryV1>;
     setWorkspacePinned(workspaceId: string, pinned: boolean, context: WebContextGuardV1): WebWorkspaceSummaryV1;
     removeWorkspace(workspaceId: string, context: WebContextGuardV1): void;
     listSessions(context?: WebContextGuardV1): readonly WebSessionSummaryV1[];
     sessionSnapshot(sessionId: string, cursor?: string, pageSize?: number, tail?: boolean, context?: WebContextGuardV1): WebSessionSnapshotV1;
+    private snapshotSessionV1;
+    private recordSessionSnapshotActivity;
     composerState(sessionId: string, context?: WebContextGuardV1): WebComposerControlStateV1;
     sessionRuntimeSummary(sessionId: string): WebSessionRuntimeSummaryV1;
     waitForSessionIdle(sessionId: string): Promise<void>;
@@ -90,6 +108,22 @@ export declare class WebWorkbenchController {
     createSession(name?: string, context?: WebContextGuardV1): Promise<WebSessionSummaryV1>;
     activateSession(sessionId: string, context?: WebContextGuardV1): Promise<WebCommandResultV1>;
     renameSession(sessionId: string, name: string, context?: WebContextGuardV1): WebSessionSummaryV1;
+    setSessionTags(sessionId: string, tags: unknown, context?: WebContextGuardV1): WebSessionSummaryV1;
+    archiveSession(sessionId: string, context?: WebContextGuardV1): WebSessionSummaryV1;
+    restoreSession(sessionId: string, context?: WebContextGuardV1): WebSessionSummaryV1;
+    deleteSession(sessionId: string, context?: WebContextGuardV1): {
+        readonly deleted: boolean;
+    };
+    /**
+     * A busy Session (starting / queued / running / waiting approval / stopping)
+     * must not be archived or deleted while its actor is doing work.
+     */
+    private assertSessionNotBusy;
+    /**
+     * Deletion removes files under the Session while a resident actor may still
+     * hold them open — require that no actor exists at all (phase 'cold').
+     */
+    private assertSessionHasNoActor;
     switchWorkspace(path: string, context: WebContextGuardV1): Promise<void>;
     activateContext(input: Omit<WebContextActivateRequestV1, 'requestId'>): Promise<void>;
     dispatch(raw: unknown): Promise<WebCommandResultV1>;
@@ -102,6 +136,27 @@ export declare class WebWorkbenchController {
     diagnostics(context?: WebContextGuardV1): Promise<Record<string, unknown>>;
     shutdown(): Promise<void>;
     private shutdownOwnedResources;
+    /**
+     * Return the workspace kernel for `cwd`, creating and pooling one on first
+     * use. Control planes and Session actors borrow the same kernel instance per
+     * canonical Workspace; the pool is released only when the Host shuts down.
+     */
+    private workspaceKernelFor;
+    /**
+     * Settings invalidations from pooled kernels are only forwarded while their
+     * Workspace is the active Context. A background Workspace's coordinator
+     * keeps watching its own durable file; its next activation publishes a fresh
+     * Settings document through `emitSettingsWorkspaceChange()`.
+     */
+    private onWorkspaceKernelSettingsInvalidated;
+    /**
+     * Release the Host owner seat on every pooled kernel. Runtime shutdowns have
+     * already disposed their Settings participants (actors first, then the
+     * active control plane), so an unowned kernel with zero participants closes
+     * its Settings coordinator here. A kernel that still has a running actor
+     * participant survives until that actor actually terminates.
+     */
+    private releaseWorkspaceKernels;
     private createSessionRegistry;
     private createSessionActor;
     private closeSessionActor;