@pasko70/pibo 1.1.0 → 1.2.0

package/dist/reliability/store.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
+import { piboHomePath } from "../core/pibo-home.js";
+import { sqliteTableColumns } from "../data/sqlite-schema.js";
 import { DatabaseSync } from "node:sqlite";
 function now() {
     return new Date().toISOString();
@@ -17,9 +19,24 @@ function parseJson(value) {
 function asDate(value) {
     return value ?? new Date();
 }
+function migratePiboRunControllerColumn(db) {
+    const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'pibo_runs'").get();
+    if (!table)
+        return;
+    const legacyColumn = ["o", "wner_pibo_session_id"].join("");
+    const columns = sqliteTableColumns(db, "pibo_runs");
+    if (!columns.has(legacyColumn) || columns.has("controller_pibo_session_id"))
+        return;
+    db.exec("DROP INDEX IF EXISTS idx_pibo_runs_" + ["o", "wner_updated"].join(""));
+    db.exec(`ALTER TABLE pibo_runs RENAME COLUMN ${legacyColumn} TO controller_pibo_session_id`);
+}
 export class PiboReliabilityStore {
     db;
-    constructor(path = resolve(process.cwd(), ".pibo/pibo-events.sqlite")) {
+    appendEventStatement;
+    getEventByStreamIdStatement;
+    getEventByTopicEventIdStatement;
+    getEventByTopicIdempotencyKeyStatement;
+    constructor(path = piboHomePath("pibo-events.sqlite")) {
         const resolvedPath = path === ":memory:" ? path : resolve(path);
         if (resolvedPath !== ":memory:")
             mkdirSync(dirname(resolvedPath), { recursive: true });
@@ -28,6 +45,7 @@ export class PiboReliabilityStore {
         this.db.exec("PRAGMA foreign_keys = ON");
         if (resolvedPath !== ":memory:")
             this.db.exec("PRAGMA journal_mode = WAL");
+        migratePiboRunControllerColumn(this.db);
         this.db.exec(`
 			CREATE TABLE IF NOT EXISTS pibo_event_stream (
 				stream_id INTEGER PRIMARY KEY,
@@ -102,7 +120,7 @@ export class PiboReliabilityStore {
 			CREATE TABLE IF NOT EXISTS pibo_runs (
 				run_id TEXT PRIMARY KEY,
 				kind TEXT NOT NULL,
-				owner_pibo_session_id TEXT NOT NULL,
+				controller_pibo_session_id TEXT NOT NULL,
 				status TEXT NOT NULL,
 				completion_policy TEXT NOT NULL,
 				consumed INTEGER NOT NULL DEFAULT 0,
@@ -119,21 +137,23 @@ export class PiboReliabilityStore {
 				retryable INTEGER NOT NULL DEFAULT 0,
 				max_attempts INTEGER NOT NULL DEFAULT 1
 			);
-			CREATE INDEX IF NOT EXISTS idx_pibo_runs_owner_updated
-				ON pibo_runs(owner_pibo_session_id, updated_at);
+			CREATE INDEX IF NOT EXISTS idx_pibo_runs_controller_updated
+				ON pibo_runs(controller_pibo_session_id, updated_at);
 			CREATE INDEX IF NOT EXISTS idx_pibo_runs_status
 				ON pibo_runs(status);
 		`);
+        this.appendEventStatement = this.db.prepare(`
+			INSERT INTO pibo_event_stream (topic, key, event_id, idempotency_key, created_at, retention_class, payload_json)
+			VALUES (?, ?, ?, ?, ?, ?, ?)
+		`);
+        this.getEventByStreamIdStatement = this.db.prepare("SELECT * FROM pibo_event_stream WHERE stream_id = ?");
+        this.getEventByTopicEventIdStatement = this.db.prepare("SELECT * FROM pibo_event_stream WHERE topic = ? AND event_id = ?");
+        this.getEventByTopicIdempotencyKeyStatement = this.db.prepare("SELECT * FROM pibo_event_stream WHERE topic = ? AND idempotency_key = ?");
     }
     append(input) {
         const eventId = input.eventId ?? `evt_${randomUUID()}`;
         const createdAt = input.createdAt ?? now();
-        const result = this.db
-            .prepare(`
-				INSERT INTO pibo_event_stream (topic, key, event_id, idempotency_key, created_at, retention_class, payload_json)
-				VALUES (?, ?, ?, ?, ?, ?, ?)
-			`)
-            .run(input.topic, input.key ?? null, eventId, input.idempotencyKey ?? null, createdAt, input.retentionClass ?? "audit_event", json(input.payload));
+        const result = this.appendEventStatement.run(input.topic, input.key ?? null, eventId, input.idempotencyKey ?? null, createdAt, input.retentionClass ?? "audit_event", json(input.payload));
         return this.getEventByStreamId(Number(result.lastInsertRowid));
     }
     appendOnce(input) {
@@ -450,7 +470,7 @@ export class PiboReliabilityStore {
             queue: "runs",
             payload: {
                 runId,
-                ownerPiboSessionId: input.ownerPiboSessionId,
+                controllerPiboSessionId: input.controllerPiboSessionId,
                 toolName: input.toolName,
                 params: input.params,
             },
@@ -459,12 +479,12 @@ export class PiboReliabilityStore {
         this.db
             .prepare(`
 				INSERT INTO pibo_runs (
-					run_id, kind, owner_pibo_session_id, status, completion_policy, consumed, tool_name,
+					run_id, kind, controller_pibo_session_id, status, completion_policy, consumed, tool_name,
 					summary, result_json, error, notified_status, acknowledged_status, created_at, updated_at,
 					completed_at, job_id, retryable, max_attempts
 				) VALUES (?, 'tool', ?, 'running', ?, 0, ?, ?, NULL, NULL, NULL, NULL, ?, ?, NULL, ?, ?, ?)
 			`)
-            .run(runId, input.ownerPiboSessionId, input.completionPolicy, input.toolName, `${input.toolName} run is running.`, timestamp, timestamp, job.jobId, input.retryable ? 1 : 0, maxAttempts);
+            .run(runId, input.controllerPiboSessionId, input.completionPolicy, input.toolName, `${input.toolName} run is running.`, timestamp, timestamp, job.jobId, input.retryable ? 1 : 0, maxAttempts);
         this.claimJob(job.jobId, `run-registry:${process.pid}`, 24 * 60 * 60 * 1000);
         return this.requireRun(runId);
     }
@@ -501,9 +521,9 @@ export class PiboReliabilityStore {
     listRuns(input = {}) {
         const clauses = [];
         const values = [];
-        if (input.ownerPiboSessionId) {
-            clauses.push("owner_pibo_session_id = ?");
-            values.push(input.ownerPiboSessionId);
+        if (input.controllerPiboSessionId) {
+            clauses.push("controller_pibo_session_id = ?");
+            values.push(input.controllerPiboSessionId);
         }
         if (!input.includeConsumed)
             clauses.push("consumed = 0");
@@ -566,21 +586,17 @@ export class PiboReliabilityStore {
         this.db.close();
     }
     getEventByStreamId(streamId) {
-        const row = this.db.prepare("SELECT * FROM pibo_event_stream WHERE stream_id = ?").get(streamId);
+        const row = this.getEventByStreamIdStatement.get(streamId);
         if (!row)
             throw new Error(`Unknown pibo event stream id "${streamId}"`);
         return eventFromRow(row);
     }
     getEventByTopicEventId(topic, eventId) {
-        const row = this.db
-            .prepare("SELECT * FROM pibo_event_stream WHERE topic = ? AND event_id = ?")
-            .get(topic, eventId);
+        const row = this.getEventByTopicEventIdStatement.get(topic, eventId);
         return row ? eventFromRow(row) : undefined;
     }
     getEventByTopicIdempotencyKey(topic, idempotencyKey) {
-        const row = this.db
-            .prepare("SELECT * FROM pibo_event_stream WHERE topic = ? AND idempotency_key = ?")
-            .get(topic, idempotencyKey);
+        const row = this.getEventByTopicIdempotencyKeyStatement.get(topic, idempotencyKey);
         return row ? eventFromRow(row) : undefined;
     }
     getConsumerOffset(topic, consumer) {
@@ -666,8 +682,8 @@ export class PiboReliabilityStore {
         return run;
     }
 }
-export function createDefaultPiboReliabilityStore(cwd = process.cwd()) {
-    return new PiboReliabilityStore(resolve(cwd, ".pibo/pibo-events.sqlite"));
+export function createDefaultPiboReliabilityStore(_cwd) {
+    return new PiboReliabilityStore(piboHomePath("pibo-events.sqlite"));
 }
 function eventFromRow(row) {
     return {
@@ -720,7 +736,7 @@ function runFromRow(row) {
     const output = {
         runId: row.run_id,
         kind: row.kind,
-        ownerPiboSessionId: row.owner_pibo_session_id,
+        controllerPiboSessionId: row.controller_pibo_session_id,
         status: row.status,
         completionPolicy: row.completion_policy,
         consumed: row.consumed === 1,

package/dist/runs/registry.js

@@ -8,7 +8,7 @@ function snapshot(record) {
     const output = {
         runId: record.runId,
         kind: record.kind,
-        ownerPiboSessionId: record.ownerPiboSessionId,
+        controllerPiboSessionId: record.controllerPiboSessionId,
         status: record.status,
         completionPolicy: record.completionPolicy,
         consumed: record.consumed,
@@ -29,6 +29,11 @@ export class PiboRunRegistry {
     options;
     runs = new Map();
     waiters = new Map();
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
     constructor(options = {}) {
         this.options = options;
         if (this.options.store) {
@@ -42,7 +47,7 @@ export class PiboRunRegistry {
         this.prune();
         if (this.options.store) {
             const stored = this.options.store.createRun({
-                ownerPiboSessionId: input.ownerPiboSessionId,
+                controllerPiboSessionId: input.controllerPiboSessionId,
                 toolName: input.toolName,
                 completionPolicy: input.completionPolicy ?? "tracked",
                 params: input.params,
@@ -51,14 +56,16 @@ export class PiboRunRegistry {
             });
             const record = recordFromStored(stored);
             this.runs.set(record.runId, record);
-            return snapshot(record);
+            const output = snapshot(record);
+            this.notify({ type: "run_started", run: output });
+            return output;
         }
         const timestamp = now();
         const runId = `run_${randomUUID()}`;
         const record = {
             runId,
             kind: "tool",
-            ownerPiboSessionId: input.ownerPiboSessionId,
+            controllerPiboSessionId: input.controllerPiboSessionId,
             status: "running",
             completionPolicy: input.completionPolicy ?? "tracked",
             consumed: false,
@@ -70,12 +77,15 @@ export class PiboRunRegistry {
             maxAttempts: Math.max(1, input.maxAttempts ?? 1),
         };
         this.runs.set(runId, record);
-        return snapshot(record);
+        const output = snapshot(record);
+        this.notify({ type: "run_started", run: output });
+        return output;
     }
     complete(runId, result) {
         const record = this.runs.get(runId);
         if (!record || terminal(record.status))
             return undefined;
+        const previousStatus = record.status;
         record.status = "completed";
         record.result = result;
         record.summary = `${record.toolName} run completed.`;
@@ -83,12 +93,15 @@ export class PiboRunRegistry {
         this.options.store?.updateRun(runId, record);
         if (record.jobId)
             this.options.store?.ack(record.jobId, `run-registry:${process.pid}`);
-        return snapshot(record);
+        const output = snapshot(record);
+        this.notify({ type: "run_changed", run: output, previousStatus });
+        return output;
     }
     fail(runId, error) {
         const record = this.runs.get(runId);
         if (!record || terminal(record.status))
             return undefined;
+        const previousStatus = record.status;
         record.status = "failed";
         record.error = error;
         record.summary = `${record.toolName} run failed.`;
@@ -96,21 +109,30 @@ export class PiboRunRegistry {
         this.options.store?.updateRun(runId, record);
         if (record.jobId)
             this.options.store?.fail(record.jobId, `run-registry:${process.pid}`, error);
-        return snapshot(record);
+        const output = snapshot(record);
+        this.notify({ type: "run_changed", run: output, previousStatus, reason: error });
+        return output;
     }
-    list(ownerPiboSessionId, options = {}) {
+    list(controllerPiboSessionId, options = {}) {
         this.prune();
         return [...this.runs.values()]
-            .filter((record) => record.ownerPiboSessionId === ownerPiboSessionId)
+            .filter((record) => record.controllerPiboSessionId === controllerPiboSessionId)
             .filter((record) => options.includeConsumed || !record.consumed)
             .filter((record) => options.includeDetached || record.completionPolicy !== "detached")
             .map(snapshot);
     }
-    status(ownerPiboSessionId, runId) {
-        return snapshot(this.requireOwned(ownerPiboSessionId, runId));
+    listAll(options = {}) {
+        this.prune();
+        return [...this.runs.values()]
+            .filter((record) => options.includeConsumed || !record.consumed)
+            .filter((record) => options.includeDetached || record.completionPolicy !== "detached")
+            .map(snapshot);
+    }
+    status(controllerPiboSessionId, runId) {
+        return snapshot(this.requireRunForController(controllerPiboSessionId, runId));
     }
-    async wait(ownerPiboSessionId, runId, timeoutMs) {
-        const record = this.requireOwned(ownerPiboSessionId, runId);
+    async wait(controllerPiboSessionId, runId, timeoutMs) {
+        const record = this.requireRunForController(controllerPiboSessionId, runId);
         if (terminal(record.status))
             return { ...snapshot(record), timedOut: false };
         const boundedTimeoutMs = Math.max(0, Math.min(timeoutMs, 300000));
@@ -143,12 +165,13 @@ export class PiboRunRegistry {
             return { ...snapshot(record), timedOut: true };
         return { ...snapshot(completed), timedOut: false };
     }
-    read(ownerPiboSessionId, runId) {
-        const record = this.requireOwned(ownerPiboSessionId, runId);
+    read(controllerPiboSessionId, runId) {
+        const record = this.requireRunForController(controllerPiboSessionId, runId);
         if (terminal(record.status)) {
             record.consumed = true;
             record.updatedAt = now();
             this.options.store?.updateRun(runId, record);
+            this.notify({ type: "run_consumed", run: snapshot(record) });
         }
         const output = { ...snapshot(record) };
         if (record.result)
@@ -157,8 +180,9 @@ export class PiboRunRegistry {
             output.error = record.error;
         return output;
     }
-    cancel(ownerPiboSessionId, runId) {
-        const record = this.requireOwned(ownerPiboSessionId, runId);
+    cancel(controllerPiboSessionId, runId) {
+        const record = this.requireRunForController(controllerPiboSessionId, runId);
+        const previousStatus = record.status;
         if (!terminal(record.status)) {
             record.status = "cancelled";
             record.summary = `${record.toolName} run cancelled.`;
@@ -169,19 +193,23 @@ export class PiboRunRegistry {
         record.consumed = true;
         record.updatedAt = now();
         this.options.store?.updateRun(runId, record);
-        return snapshot(record);
+        const output = snapshot(record);
+        this.notify({ type: "run_changed", run: output, previousStatus, reason: "Run was cancelled." });
+        return output;
     }
-    ack(ownerPiboSessionId, runId) {
-        const record = this.requireOwned(ownerPiboSessionId, runId);
+    ack(controllerPiboSessionId, runId) {
+        const record = this.requireRunForController(controllerPiboSessionId, runId);
         record.acknowledgedStatus = record.status;
         if (terminal(record.status))
             record.consumed = true;
         record.updatedAt = now();
         this.options.store?.updateRun(runId, record);
-        return snapshot(record);
+        const output = snapshot(record);
+        this.notify({ type: "run_acknowledged", run: output });
+        return output;
     }
-    createNotification(ownerPiboSessionId, options = {}) {
-        const records = [...this.runs.values()].filter((record) => this.needsNotification(record, ownerPiboSessionId, options));
+    createNotification(controllerPiboSessionId, options = {}) {
+        const records = [...this.runs.values()].filter((record) => this.needsNotification(record, controllerPiboSessionId, options));
         if (records.length === 0)
             return undefined;
         for (const record of records) {
@@ -207,13 +235,13 @@ export class PiboRunRegistry {
         }
         return notification;
     }
-    hasPendingNotification(ownerPiboSessionId, options = {}) {
-        return [...this.runs.values()].some((record) => this.needsNotification(record, ownerPiboSessionId, options));
+    hasPendingNotification(controllerPiboSessionId, options = {}) {
+        return [...this.runs.values()].some((record) => this.needsNotification(record, controllerPiboSessionId, options));
     }
-    cancelOwnerRuns(ownerPiboSessionId, reason = "Owner Pibo session was disposed.") {
+    cancelControllerRuns(controllerPiboSessionId, reason = "Controller Pibo session was disposed.") {
         const cancelled = [];
         for (const record of this.runs.values()) {
-            if (record.ownerPiboSessionId !== ownerPiboSessionId || terminal(record.status))
+            if (record.controllerPiboSessionId !== controllerPiboSessionId || terminal(record.status))
                 continue;
             record.status = "cancelled";
             record.error = reason;
@@ -223,7 +251,9 @@ export class PiboRunRegistry {
             this.options.store?.updateRun(record.runId, record);
             if (record.jobId)
                 this.options.store?.fail(record.jobId, `run-registry:${process.pid}`, reason);
-            cancelled.push(snapshot(record));
+            const output = snapshot(record);
+            this.notify({ type: "run_changed", run: output, previousStatus: "running", reason });
+            cancelled.push(output);
         }
         return cancelled;
     }
@@ -240,7 +270,9 @@ export class PiboRunRegistry {
             this.options.store?.updateRun(record.runId, record);
             if (record.jobId)
                 this.options.store?.fail(record.jobId, `run-registry:${process.pid}`, reason);
-            cancelled.push(snapshot(record));
+            const output = snapshot(record);
+            this.notify({ type: "run_changed", run: output, previousStatus: "running", reason });
+            cancelled.push(output);
         }
         return cancelled;
     }
@@ -262,6 +294,7 @@ export class PiboRunRegistry {
             if (!shouldPrune)
                 continue;
             this.runs.delete(runId);
+            this.notify({ type: "run_removed", runId, controllerPiboSessionId: record.controllerPiboSessionId });
             pruned += 1;
         }
         if (this.options.store) {
@@ -269,15 +302,15 @@ export class PiboRunRegistry {
         }
         return pruned;
     }
-    requireOwned(ownerPiboSessionId, runId) {
+    requireRunForController(controllerPiboSessionId, runId) {
         const record = this.runs.get(runId);
-        if (!record || record.ownerPiboSessionId !== ownerPiboSessionId) {
-            throw new Error(`Unknown run "${runId}" for session "${ownerPiboSessionId}"`);
+        if (!record || record.controllerPiboSessionId !== controllerPiboSessionId) {
+            throw new Error(`Unknown run "${runId}" for session "${controllerPiboSessionId}"`);
         }
         return record;
     }
-    needsNotification(record, ownerPiboSessionId, options = {}) {
-        return (record.ownerPiboSessionId === ownerPiboSessionId &&
+    needsNotification(record, controllerPiboSessionId, options = {}) {
+        return (record.controllerPiboSessionId === controllerPiboSessionId &&
             record.completionPolicy === "tracked" &&
             !record.consumed &&
             record.acknowledgedStatus !== record.status &&
@@ -298,12 +331,16 @@ export class PiboRunRegistry {
             waiter.resolve(record);
         }
     }
+    notify(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
 }
 function recordFromStored(record) {
     return {
         runId: record.runId,
         kind: record.kind,
-        ownerPiboSessionId: record.ownerPiboSessionId,
+        controllerPiboSessionId: record.controllerPiboSessionId,
         status: record.status,
         completionPolicy: record.completionPolicy,
         consumed: record.consumed,

package/dist/session-ui/commandCatalog.js

@@ -0,0 +1,193 @@
+import { redactTerminalSecret } from "./statusViewModel.js";
+export const CLI_ONLY_SLASH_COMMANDS = [
+    { id: "help", slash: "/help", description: "Show command help and keyboard controls.", group: "cli", support: "supported" },
+    { id: "new", slash: "/new", description: "Create a new session in the active or selected room.", group: "navigation", support: "supported" },
+    { id: "room", slash: "/room", description: "Select the active room in the app context.", group: "navigation", support: "supported" },
+    { id: "session", slash: "/session", description: "Select a room, then open or create a session.", group: "navigation", support: "supported" },
+    { id: "agent", slash: "/agent", description: "Select an existing agent/profile for the session.", group: "navigation", support: "supported" },
+    { id: "profile", slash: "/profile", description: "Select an existing agent/profile for the session.", group: "navigation", support: "supported" },
+    { id: "repair-user-unknown", slash: "/repair-user-unknown", description: "Repair legacy CLI sessions stored under user:unknown.", group: "cli", support: "supported" },
+    { id: "exit", slash: "/exit", description: "Exit the terminal UI.", group: "cli", support: "supported", aliases: ["/quit"] },
+    { id: "quit", slash: "/quit", description: "Exit the terminal UI.", group: "cli", support: "supported" },
+];
+export const WEB_PARITY_SLASH_COMMANDS = [
+    { id: "status", slash: "/status", actionName: "status", description: "Show session, runtime, model, queue, and usage status.", group: "session", support: "supported" },
+    { id: "compact", slash: "/compact", actionName: "compact", description: "Run session compaction when the runtime supports it.", group: "runtime", support: "terminal-adapted" },
+    { id: "clear", slash: "/clear", actionName: "clear_queue", description: "Clear queued messages that have not started yet; terminal currently also clears local display.", group: "runtime", support: "terminal-adapted" },
+    { id: "abort", slash: "/abort", actionName: "abort", description: "Abort the active response.", group: "runtime", support: "terminal-adapted" },
+    { id: "kill", slash: "/kill", actionName: "kill", description: "Dispose the active session runtime.", group: "runtime", support: "terminal-adapted" },
+    { id: "kill-all", slash: "/kill-all", actionName: "kill-all", description: "Dispose all routed runtimes for the selected app context when supported.", group: "runtime", support: "terminal-adapted" },
+    { id: "fast", slash: "/fast", actionName: "fast_mode", description: "Toggle fast mode for the active session.", argumentHint: "[on|off]", group: "runtime", support: "terminal-adapted" },
+    { id: "thinking", slash: "/thinking", actionName: "thinking", description: "Show or set model thinking level.", argumentHint: "[off|minimal|low|medium|high|xhigh]", group: "runtime", support: "terminal-adapted", terminalAdaptation: "Without an argument, open a keyboard picker." },
+    { id: "model", slash: "/model", actionName: "model", description: "Choose an authenticated provider model.", group: "runtime", support: "terminal-adapted", terminalAdaptation: "Open provider and model pickers." },
+    { id: "login", slash: "/login", actionName: "login", description: "Authenticate a model provider.", group: "runtime", support: "terminal-adapted", terminalAdaptation: "Show provider/auth-method instructions in terminal." },
+    { id: "session-current", slash: "/session-current", actionName: "session-current", description: "Show metadata for the active session.", group: "session", support: "terminal-adapted" },
+    { id: "sessions", slash: "/sessions", actionName: "sessions", description: "List sessions for the selected shared room.", group: "session", support: "terminal-adapted" },
+    { id: "clone", slash: "/clone", actionName: "clone", description: "Clone or derive the active session when supported.", group: "session", support: "terminal-adapted" },
+    { id: "fork-candidates", slash: "/fork-candidates", actionName: "session.fork_candidates", description: "Inspect terminal-selectable fork candidates.", argumentHint: "[entry-id]", group: "session", support: "terminal-adapted", terminalAdaptation: "Without an argument, list candidates; selecting one attempts a routed fork." },
+    { id: "download", slash: "/download", actionName: "download", description: "Show terminal-safe download instructions for a server path.", argumentHint: "<path>", group: "session", support: "terminal-adapted", terminalAdaptation: "Use shell/server paths instead of browser download APIs." },
+    { id: "upload", slash: "/upload", actionName: "upload", description: "Show terminal-safe upload instructions for a local path.", argumentHint: "<path>", group: "session", support: "terminal-adapted", terminalAdaptation: "Use path-based terminal instructions instead of browser file picker APIs." },
+    { id: "thinking-show", slash: "/thinking-show", actionName: "thinking", description: "Show thinking controls in Web.", group: "unsupported", support: "deferred", unsupportedReason: "Use /thinking in terminal." },
+];
+export function buildSlashCommandCatalog(capabilities = []) {
+    const bySlash = new Map();
+    for (const command of [...WEB_PARITY_SLASH_COMMANDS, ...CLI_ONLY_SLASH_COMMANDS])
+        bySlash.set(command.slash, command);
+    for (const capability of expandGatewayCommandCapabilities(capabilities)) {
+        if (capability.hidden)
+            continue;
+        const slash = normalizeSlash(capability.slash ?? capability.name);
+        if (!slash)
+            continue;
+        const existing = bySlash.get(slash);
+        if (existing && isCliOwnedCommand(existing) && capability.name !== undefined)
+            continue;
+        bySlash.set(slash, {
+            id: slash.slice(1),
+            slash,
+            actionName: capability.actionName ?? existing?.actionName ?? capability.name,
+            description: redactTerminalSecret(capability.description ?? existing?.description ?? `Run ${slash}.`),
+            argumentHint: capability.argumentHint ?? existing?.argumentHint,
+            group: capability.browserOnly || capability.productArea ? "unsupported" : existing?.group ?? "session",
+            support: supportForCapability(capability, existing),
+            unsupportedReason: redactTerminalSecret(capability.unsupportedReason ?? existing?.unsupportedReason ?? "") || undefined,
+            terminalAdaptation: existing?.terminalAdaptation,
+            aliases: existing?.aliases,
+        });
+    }
+    return [...bySlash.values()].sort((left, right) => left.slash.localeCompare(right.slash));
+}
+export function filterSlashCommands(catalog, input) {
+    const normalized = input.trim().split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+    const prefix = normalized.startsWith("/") ? normalized : `/${normalized}`;
+    return catalog.filter((command) => command.slash.toLowerCase().startsWith(prefix) || command.aliases?.some((alias) => alias.toLowerCase().startsWith(prefix)));
+}
+export function formatSlashCommand(command) {
+    return `${command.slash}${command.argumentHint ? ` ${command.argumentHint}` : ""}`;
+}
+export function commandSupportLabel(command) {
+    if (command.support === "supported")
+        return "available";
+    if (command.support === "terminal-adapted")
+        return "terminal";
+    if (command.support === "browser-only")
+        return "browser-only";
+    if (command.support === "product-area")
+        return "product-area";
+    return "deferred";
+}
+export function groupSlashCommandsForHelp(catalog) {
+    return {
+        available: catalog.filter((command) => (command.group === "session" || command.group === "runtime") && (command.support === "supported" || command.support === "terminal-adapted")),
+        navigation: catalog.filter((command) => command.group === "navigation" || command.group === "cli"),
+        unsupported: catalog.filter((command) => command.group === "unsupported" || command.support === "browser-only" || command.support === "product-area" || command.support === "deferred"),
+    };
+}
+export function buildSlashCommandBehaviorMatrix(catalog = buildSlashCommandCatalog()) {
+    return catalog.map((command) => ({
+        id: command.id,
+        slash: command.slash,
+        aliases: command.aliases ?? [],
+        group: command.group,
+        support: command.support,
+        supportLabel: commandSupportLabel(command),
+        palette: "shown",
+        argumentBehavior: slashArgumentBehavior(command),
+        enterBehavior: slashEnterBehavior(command),
+        resultPlacement: slashResultPlacement(command),
+        contextRequirement: slashContextRequirement(command),
+        errorBehavior: slashErrorBehavior(command),
+        terminalAdaptation: command.terminalAdaptation,
+    }));
+}
+function slashArgumentBehavior(command) {
+    if (command.argumentHint)
+        return command.argumentHint;
+    if (command.slash === "/model")
+        return "no argument opens provider/model picker; provider/model applies selection";
+    if (command.slash === "/login")
+        return "no argument opens provider/auth picker; provider/method applies selection";
+    if (command.slash === "/thinking")
+        return "no argument opens thinking picker; level applies selection";
+    return "none";
+}
+function slashEnterBehavior(command) {
+    if (command.slash === "/help")
+        return "append help text above transcript guidance";
+    if (command.slash === "/new")
+        return "create session in active or selected room";
+    if (["/room", "/session", "/profile", "/agent"].includes(command.slash))
+        return "open keyboard picker overlay";
+    if (["/exit", "/quit"].includes(command.slash))
+        return "exit terminal UI";
+    if (command.slash === "/repair-user-unknown")
+        return "append compact repair result";
+    if (["/model", "/login", "/thinking"].includes(command.slash))
+        return "open picker without arguments or append result with arguments";
+    if (command.slash === "/fork-candidates")
+        return "open candidate picker without entry id or dispatch fork with entry id";
+    if (command.support === "browser-only" || command.support === "product-area" || command.support === "deferred")
+        return "append unsupported/deferred transcript result";
+    return "append command and result rows to transcript";
+}
+function slashResultPlacement(command) {
+    if (["/exit", "/quit"].includes(command.slash))
+        return "exit";
+    if (["/room", "/session", "/profile", "/agent"].includes(command.slash))
+        return "overlay";
+    if (command.slash === "/new")
+        return "navigation";
+    if (["/model", "/login", "/thinking", "/fork-candidates"].includes(command.slash))
+        return "transcript-or-overlay";
+    return "transcript";
+}
+function slashContextRequirement(command) {
+    if (["/room", "/session", "/new", "/profile", "/repair-user-unknown"].includes(command.slash))
+        return "app room/session navigation";
+    if (["/status", "/sessions", "/session-current", "/clone", "/fork-candidates"].includes(command.slash))
+        return "active session when available; named room context preferred";
+    if (["/compact", "/clear", "/abort", "/kill", "/kill-all", "/fast", "/thinking", "/model", "/login"].includes(command.slash))
+        return "active routed session/runtime";
+    if (["/download", "/upload"].includes(command.slash))
+        return "terminal path argument";
+    return "none";
+}
+function slashErrorBehavior(command) {
+    if (command.support === "browser-only" || command.support === "product-area" || command.support === "deferred")
+        return "render compact unsupported result";
+    if (["/room", "/session", "/profile", "/agent", "/model", "/login", "/thinking", "/fork-candidates"].includes(command.slash))
+        return "keep overlay compact or append redacted error row after confirmed action";
+    return "append redacted command error row";
+}
+function expandGatewayCommandCapabilities(capabilities) {
+    const expanded = [];
+    for (const capability of capabilities) {
+        if (capability.slashCommands && capability.slashCommands.length > 0) {
+            for (const slash of capability.slashCommands)
+                expanded.push({ ...capability, slash, actionName: capability.actionName ?? capability.name });
+            continue;
+        }
+        expanded.push(capability);
+    }
+    return expanded;
+}
+function isCliOwnedCommand(command) {
+    return command.group === "cli" || command.slash === "/new" || command.slash === "/room" || command.slash === "/session" || command.slash === "/agent" || command.slash === "/profile";
+}
+function normalizeSlash(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return undefined;
+    return (trimmed.startsWith("/") ? trimmed : `/${trimmed}`);
+}
+function supportForCapability(capability, existing) {
+    if (capability.browserOnly)
+        return "browser-only";
+    if (capability.productArea)
+        return "product-area";
+    if (capability.supported === false)
+        return "deferred";
+    return existing?.support ?? "terminal-adapted";
+}