@zhanguym/chatroom 1.2.0 → 1.3.3

package/dist/app/application.d.ts

@@ -3,7 +3,9 @@ import { AppDatabase } from "#infrastructure/database/app-database";
 import { RuntimeEventBus } from "./event-bus.js";
 import { OperationLog } from "#operations/operation-log";
 import { PluginManager } from "#plugins/plugin-manager";
+import { McpToolControl } from "#mcp/server/tool-control";
 import { CustomMcpManager } from "#mcp/custom/manager";
+import { AgentMcpGateway } from "#plugins/agent/mcp-gateway";
 import { HttpServer } from "#infrastructure/http/http-server";
 import type { LogService } from "#core/logging/types";
 export interface ApplicationComponents {
@@ -12,6 +14,9 @@ export interface ApplicationComponents {
     operations: OperationLog;
     plugins: PluginManager;
     customMcp: CustomMcpManager;
+    agentCustomMcp: CustomMcpManager;
+    agentMcpGateway: AgentMcpGateway;
+    agentMcpTools: McpToolControl;
     processes: import("#plugins/process/process-supervisor").ProcessSupervisor;
     cloud: import("#plugins/cloud/controller").CloudController;
     computer: import("#plugins/computer/computer-service").ComputerService;

package/dist/app/application.js

@@ -1,6 +1,7 @@
 import { AppDatabase } from "#infrastructure/database/app-database";
 import { OperationRepository } from "#infrastructure/database/operation-repository";
 import { McpToolSettingsRepository } from "#infrastructure/database/mcp-tool-settings-repository";
+import { AgentMcpSettingsRepository } from "#infrastructure/database/agent-mcp-settings-repository";
 import { OAuthRepository } from "#infrastructure/database/oauth-repository";
 import { PasskeyRepository } from "#infrastructure/database/passkey-repository";
 import { WebSessionRepository } from "#infrastructure/database/web-session-repository";
@@ -22,25 +23,48 @@ import { createChatRoomMcpHandler } from "#mcp/server/create-mcp-server";
 import { McpToolControl } from "#mcp/server/tool-control";
 import { CustomMcpRepository } from "#infrastructure/database/custom-mcp-repository";
 import { CustomMcpManager } from "#mcp/custom/manager";
+import { AgentCustomMcpStore } from "#plugins/agent/custom-mcp-store";
+import { AgentMcpGateway, createAgentMcpServer, } from "#plugins/agent/mcp-gateway";
 import { HttpServer } from "#infrastructure/http/http-server";
 export async function createApplication(config, logs) {
     const database = new AppDatabase(config.databasePath);
+    let gatewayForCleanup = null;
+    let agentCustomMcpForCleanup = null;
+    let customMcpForCleanup = null;
+    let pluginsForCleanup = null;
     try {
         const eventBus = new RuntimeEventBus();
         const operations = new OperationLog(new OperationRepository(database), eventBus, config.operations.maxPayloadBytes);
         operations.reconcileInterrupted();
         const mcpTools = new McpToolControl(new McpToolSettingsRepository(database));
         const customMcp = new CustomMcpManager(new CustomMcpRepository(database), mcpTools, operations, config.dataDir);
+        customMcpForCleanup = customMcp;
+        const agentMcpSettings = new AgentMcpSettingsRepository(database);
+        const agentMcpTools = new McpToolControl(agentMcpSettings, false);
+        const agentCustomMcp = new CustomMcpManager(new AgentCustomMcpStore(new CustomMcpRepository(database), agentMcpSettings), agentMcpTools, operations, config.dataDir, "agent_mcp");
+        agentCustomMcpForCleanup = agentCustomMcp;
+        let plugins = null;
+        const agentMcpGateway = new AgentMcpGateway(() => createAgentMcpServer((server) => {
+            if (!plugins)
+                throw new Error("Agent MCP gateway is not initialized");
+            plugins.registerMcp(server, agentMcpTools, { agentMode: true });
+            agentCustomMcp.registerMcp(server);
+        }));
+        await agentMcpGateway.start();
+        gatewayForCleanup = agentMcpGateway;
         const externalAccess = new ExternalAccessRegistry(config.auth);
         const auth = new AuthService(new OAuthRepository(database), new WebSessionRepository(database), config.auth);
         const passkeys = new PasskeyService(new PasskeyRepository(database));
         const services = new ServiceRegistry();
-        const plugins = new PluginManager({
+        plugins = new PluginManager({
             config,
             database,
             operations,
             mcpTools,
             customMcp,
+            agentMcp: agentMcpGateway.connection(),
+            agentMcpTools,
+            agentCustomMcp,
             events: eventBus,
             externalAccess,
             services,
@@ -54,20 +78,27 @@ export async function createApplication(config, logs) {
             createAgentPlugin(),
             createWebPlugin(),
         ]);
+        pluginsForCleanup = plugins;
         await plugins.start();
+        plugins.defineMcp(agentMcpTools, { agentMode: true });
         customMcp.start();
+        agentCustomMcp.start();
+        const activePlugins = plugins;
         const web = services.require(WebServiceToken);
         const processes = services.require(ProcessServiceToken);
         const cloud = services.require(CloudServiceToken);
         const computer = services.require(ComputerServiceToken);
-        const mcp = createChatRoomMcpHandler(plugins, customMcp);
+        const mcp = createChatRoomMcpHandler(activePlugins, customMcp);
         const http = new HttpServer(config, web.application, eventBus, auth, passkeys, mcp, externalAccess, cloud, logs);
         return {
             database,
             eventBus,
             operations,
-            plugins,
+            plugins: activePlugins,
             customMcp,
+            agentCustomMcp,
+            agentMcpGateway,
+            agentMcpTools,
             processes,
             cloud,
             computer,
@@ -76,7 +107,27 @@ export async function createApplication(config, logs) {
         };
     }
     catch (error) {
-        database.close();
+        // Startup can fail after the loopback gateway has bound its ephemeral port.
+        // Tear down resources in reverse construction order before closing the DB.
+        for (const cleanup of [
+            () => pluginsForCleanup?.stop(),
+            () => gatewayForCleanup?.close(),
+            () => agentCustomMcpForCleanup?.close(),
+            () => customMcpForCleanup?.close(),
+        ]) {
+            try {
+                await cleanup();
+            }
+            catch {
+                /* preserve the startup error */
+            }
+        }
+        try {
+            database.close();
+        }
+        catch {
+            /* preserve the startup error */
+        }
         throw error;
     }
 }

package/dist/app/lifecycle.js

@@ -111,6 +111,18 @@ async function cleanupComponents(components) {
     catch (error) {
         errors.push(error);
     }
+    try {
+        await components.agentMcpGateway.close();
+    }
+    catch (error) {
+        errors.push(error);
+    }
+    try {
+        await components.agentCustomMcp.close();
+    }
+    catch (error) {
+        errors.push(error);
+    }
     try {
         await components.customMcp.close();
     }

package/dist/app/workspace-access.d.ts

@@ -1,7 +1,14 @@
+export type WorkspaceStatus = "available" | "missing" | "restore_pending" | "unregistered";
+export type WorkspaceSource = "configured" | "manual" | "both" | "history";
 export interface WorkspaceEntry {
-    root: string;
+    id: string;
+    path: string;
     name: string;
     summary: string | null;
+    status: WorkspaceStatus;
+    source: WorkspaceSource;
+    manuallyRegistered: boolean;
+    discovered: boolean;
 }
 export interface WorkspaceSkill {
     name: string;
@@ -16,9 +23,15 @@ export interface WorkspaceInfo extends WorkspaceEntry {
 export interface WorkspaceAccess {
     roots(): string[];
     list(): Promise<WorkspaceEntry[]>;
-    resolve(input: string): Promise<string>;
+    listAll(): Promise<WorkspaceEntry[]>;
+    resolve(workspaceId: string): Promise<string>;
     createProject(parentInput: string, nameInput: string): Promise<WorkspaceEntry>;
-    projectFiles(input: string, maxFiles?: number): Promise<string[]>;
-    info(input: string): Promise<WorkspaceInfo>;
+    registerProject(pathInput: string, nameInput?: string | null): Promise<WorkspaceEntry>;
+    renameProject(workspaceId: string, nameInput: string): Promise<WorkspaceEntry>;
+    removeProject(workspaceId: string): Promise<void>;
+    cleanupProject(workspaceId: string): Promise<void>;
+    restoreProject(workspaceId: string): Promise<WorkspaceEntry>;
+    projectFiles(workspaceId: string, maxFiles?: number): Promise<string[]>;
+    info(workspaceId: string): Promise<WorkspaceInfo>;
 }
 export declare const WorkspaceAccessToken: import("#app/service-registry").ServiceToken<WorkspaceAccess>;

package/dist/core/operations/types.d.ts

@@ -1,6 +1,6 @@
 declare const OPERATION_STATUSES: readonly ["running", "success", "error", "cancelled"];
 export type OperationStatus = (typeof OPERATION_STATUSES)[number];
-declare const OPERATION_SOURCES: readonly ["mcp", "gui", "system", "cli"];
+declare const OPERATION_SOURCES: readonly ["mcp", "agent_mcp", "gui", "system", "cli"];
 export type OperationSource = (typeof OPERATION_SOURCES)[number];
 export interface Operation {
     operationId: string;

package/dist/core/operations/types.js

@@ -4,5 +4,5 @@ const OPERATION_STATUSES = [
     "error",
     "cancelled",
 ];
-const OPERATION_SOURCES = ["mcp", "gui", "system", "cli"];
+const OPERATION_SOURCES = ["mcp", "agent_mcp", "gui", "system", "cli"];
 export {};

package/dist/infrastructure/database/agent-mcp-settings-repository.d.ts

@@ -0,0 +1,12 @@
+import type { AppDatabase } from "./app-database.js";
+import type { McpToolSettingStore } from "#mcp/server/tool-control";
+export declare class AgentMcpSettingsRepository implements McpToolSettingStore {
+    private readonly database;
+    constructor(database: AppDatabase);
+    disabledTools(): string[];
+    configuredTools(): string[];
+    setEnabled(name: string, enabled: boolean): void;
+    serverEnabled(serverId: string): boolean;
+    setServerEnabled(serverId: string, enabled: boolean): void;
+    deleteServerSetting(serverId: string): void;
+}

package/dist/infrastructure/database/agent-mcp-settings-repository.js

@@ -0,0 +1,55 @@
+export class AgentMcpSettingsRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    disabledTools() {
+        return this.database.raw
+            .prepare("SELECT tool_name FROM agent_mcp_tool_settings WHERE enabled=0")
+            .all().map((row) => row.tool_name);
+    }
+    configuredTools() {
+        return this.database.raw
+            .prepare("SELECT tool_name FROM agent_mcp_tool_settings")
+            .all().map((row) => row.tool_name);
+    }
+    setEnabled(name, enabled) {
+        this.database.raw
+            .prepare(`
+        INSERT INTO agent_mcp_tool_settings(tool_name, enabled, updated_at)
+        VALUES(?,?,?)
+        ON CONFLICT(tool_name) DO UPDATE SET
+          enabled=excluded.enabled,
+          updated_at=excluded.updated_at
+        `)
+            .run(name, enabled ? 1 : 0, new Date().toISOString());
+    }
+    serverEnabled(serverId) {
+        const row = this.database.raw
+            .prepare("SELECT enabled FROM agent_mcp_server_settings WHERE server_id=?")
+            .get(serverId);
+        return row ? Boolean(row.enabled) : false;
+    }
+    setServerEnabled(serverId, enabled) {
+        this.database.raw
+            .prepare(`
+        INSERT INTO agent_mcp_server_settings(server_id, enabled, updated_at)
+        VALUES(?,?,?)
+        ON CONFLICT(server_id) DO UPDATE SET
+          enabled=excluded.enabled,
+          updated_at=excluded.updated_at
+        `)
+            .run(serverId, enabled ? 1 : 0, new Date().toISOString());
+    }
+    deleteServerSetting(serverId) {
+        this.database.raw
+            .prepare("DELETE FROM agent_mcp_server_settings WHERE server_id=?")
+            .run(serverId);
+        if (serverId.startsWith("custom:")) {
+            const id = serverId.slice("custom:".length);
+            this.database.raw
+                .prepare("DELETE FROM agent_mcp_tool_settings WHERE tool_name GLOB ?")
+                .run("custom_" + id + "__*");
+        }
+    }
+}

package/dist/infrastructure/database/app-database.js

@@ -1,15 +1,15 @@
 import { mkdirSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { DATABASE_SCHEMA } from "./schema.js";
+import { initializeDatabase } from "./migrate.js";
 export class AppDatabase {
     raw;
     constructor(databasePath) {
         mkdirSync(path.dirname(databasePath), { recursive: true, mode: 0o700 });
         this.raw = new DatabaseSync(databasePath);
         try {
-            this.raw.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;");
-            this.raw.exec(DATABASE_SCHEMA);
+            this.raw.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+            initializeDatabase(this.raw);
         }
         catch (error) {
             this.raw.close();

package/dist/infrastructure/database/migrate.d.ts

@@ -0,0 +1,2 @@
+import type { DatabaseSync } from "node:sqlite";
+export declare function initializeDatabase(database: DatabaseSync): void;

package/dist/infrastructure/database/migrate.js

@@ -0,0 +1,83 @@
+import { randomUUID } from "node:crypto";
+import { agentSessionsSchema, DATABASE_SCHEMA, WORKSPACES_SCHEMA, } from "./schema.js";
+const SCHEMA_VERSION = 1;
+const LEGACY_SESSION_COLUMNS = [
+    "id",
+    "workspace_root",
+    "provider",
+    "status",
+    "created_at",
+    "updated_at",
+];
+export function initializeDatabase(database) {
+    const version = database.prepare("PRAGMA user_version").get().user_version;
+    const columns = database
+        .prepare("PRAGMA table_info(agent_sessions)")
+        .all();
+    const legacySessions = columns.some((column) => column.name === "workspace_root");
+    const recognizedLegacySessions = columns.length === LEGACY_SESSION_COLUMNS.length &&
+        columns.every((column, index) => column.name === LEGACY_SESSION_COLUMNS[index]);
+    // Older installations can have user_version=2 while still retaining the
+    // original 1.2.0 agent_sessions layout. Accept that specific layout only;
+    // never downgrade an unknown newer database.
+    if (version > SCHEMA_VERSION && !(version === 2 && recognizedLegacySessions))
+        throw new Error(`Unsupported newer ChatRoom database schema: ${version}`);
+    if (legacySessions && !recognizedLegacySessions)
+        throw new Error("Unrecognized ChatRoom agent_sessions schema");
+    if (columns.length > 0 &&
+        !legacySessions &&
+        !columns.some((column) => column.name === "workspace_id"))
+        throw new Error("Unrecognized ChatRoom agent_sessions schema");
+    // Rebuilding a referenced table requires foreign keys to be disabled before
+    // entering the transaction. The transaction keeps the old database intact
+    // if any migration or schema initialization step fails.
+    database.exec(`PRAGMA foreign_keys = ${legacySessions ? "OFF" : "ON"};`);
+    try {
+        database.exec("BEGIN IMMEDIATE");
+        try {
+            if (legacySessions)
+                migrateLegacySessions(database);
+            database.exec(DATABASE_SCHEMA);
+            if (legacySessions) {
+                const invalidReferences = database
+                    .prepare("PRAGMA foreign_key_check")
+                    .all();
+                if (invalidReferences.length)
+                    throw new Error("Database migration failed foreign-key validation");
+            }
+            database.exec(`PRAGMA user_version = ${SCHEMA_VERSION};`);
+            database.exec("COMMIT");
+        }
+        catch (error) {
+            database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    finally {
+        database.exec("PRAGMA foreign_keys = ON;");
+    }
+}
+function migrateLegacySessions(database) {
+    database.exec(WORKSPACES_SCHEMA);
+    const roots = database
+        .prepare("SELECT DISTINCT workspace_root FROM agent_sessions")
+        .all();
+    const insertWorkspace = database.prepare("INSERT INTO workspaces(id, path, manually_registered, state) VALUES(?, ?, 1, 'available') ON CONFLICT(path) DO NOTHING");
+    for (const { workspace_root } of roots)
+        insertWorkspace.run(`ws_${randomUUID()}`, workspace_root);
+    database.exec(agentSessionsSchema("agent_sessions_next"));
+    database.exec(`
+    INSERT INTO agent_sessions_next(id, workspace_id, provider, status, created_at, updated_at)
+    SELECT s.id, w.id, s.provider, s.status, s.created_at, s.updated_at
+    FROM agent_sessions s
+    JOIN workspaces w ON w.path = s.workspace_root;
+  `);
+    const oldCount = database.prepare("SELECT COUNT(*) AS count FROM agent_sessions").get().count;
+    const newCount = database
+        .prepare("SELECT COUNT(*) AS count FROM agent_sessions_next")
+        .get().count;
+    if (oldCount !== newCount)
+        throw new Error("Database migration would lose Agent sessions");
+    database.exec("DROP TABLE agent_sessions;");
+    database.exec("ALTER TABLE agent_sessions_next RENAME TO agent_sessions;");
+}

package/dist/infrastructure/database/schema.d.ts

@@ -1 +1,3 @@
-export declare const DATABASE_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS operations (\n    operation_id TEXT PRIMARY KEY,\n    plugin_id TEXT NOT NULL,\n    source TEXT NOT NULL,\n    action TEXT NOT NULL,\n    status TEXT NOT NULL,\n    process_id TEXT,\n    input_json TEXT NOT NULL,\n    output_json TEXT NOT NULL,\n    error_json TEXT NOT NULL,\n    input_truncated INTEGER NOT NULL DEFAULT 0,\n    output_truncated INTEGER NOT NULL DEFAULT 0,\n    started_at TEXT NOT NULL,\n    finished_at TEXT,\n    duration_ms INTEGER\n  );\n  CREATE INDEX IF NOT EXISTS operations_started_idx ON operations(started_at DESC);\n  CREATE INDEX IF NOT EXISTS operations_plugin_idx ON operations(plugin_id, started_at DESC);\n  CREATE INDEX IF NOT EXISTS operations_status_idx ON operations(status, started_at DESC);\n\n  CREATE TABLE IF NOT EXISTS oauth_clients (\n    client_id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    redirect_uris_json TEXT NOT NULL,\n    created_at TEXT NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS oauth_codes (\n    code_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    redirect_uri TEXT NOT NULL,\n    code_challenge TEXT NOT NULL,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    used_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS oauth_code_expiry_idx ON oauth_codes(expires_at);\n  CREATE TABLE IF NOT EXISTS oauth_tokens (\n    token_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    revoked_at TEXT,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS oauth_token_expiry_idx ON oauth_tokens(expires_at);\n  CREATE TABLE IF NOT EXISTS oauth_refresh_tokens (\n    token_hash TEXT PRIMARY KEY,\n    client_id TEXT NOT NULL REFERENCES oauth_clients(client_id) ON DELETE CASCADE,\n    scope TEXT NOT NULL,\n    expires_at TEXT NOT NULL,\n    revoked_at TEXT,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS oauth_refresh_expiry_idx ON oauth_refresh_tokens(expires_at);\n\n  CREATE TABLE IF NOT EXISTS web_sessions (\n    token_hash TEXT PRIMARY KEY,\n    expires_at TEXT NOT NULL,\n    created_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS web_session_expiry_idx ON web_sessions(expires_at);\n\n  CREATE TABLE IF NOT EXISTS passkeys (\n    credential_id TEXT PRIMARY KEY,\n    public_key BLOB NOT NULL,\n    counter INTEGER NOT NULL,\n    transports_json TEXT NOT NULL,\n    device_type TEXT NOT NULL CHECK(device_type IN ('singleDevice','multiDevice')),\n    backed_up INTEGER NOT NULL,\n    name TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    last_used_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS passkeys_last_used_idx ON passkeys(last_used_at DESC);\n\n  CREATE TABLE IF NOT EXISTS computer_settings (\n    id INTEGER PRIMARY KEY CHECK(id = 1),\n    enabled INTEGER NOT NULL DEFAULT 0,\n    remote_access INTEGER NOT NULL DEFAULT 1,\n    updated_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS mcp_tool_settings (\n    tool_name TEXT PRIMARY KEY,\n    enabled INTEGER NOT NULL CHECK(enabled IN (0, 1)),\n    updated_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS custom_mcp_servers (\n    id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    config_json TEXT NOT NULL,\n    enabled INTEGER NOT NULL CHECK(enabled IN (0, 1)),\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS agent_sessions (\n    id TEXT PRIMARY KEY,\n    workspace_root TEXT NOT NULL,\n    provider TEXT NOT NULL,\n    status TEXT NOT NULL CHECK(status IN ('idle','running','waiting_input','error')),\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS agent_sessions_updated_idx ON agent_sessions(updated_at DESC);\n\n  CREATE TABLE IF NOT EXISTS agent_turns (\n    id TEXT PRIMARY KEY,\n    session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,\n    provider_turn_id TEXT,\n    provider TEXT NOT NULL,\n    model TEXT,\n    reasoning_effort TEXT,\n    reasoning_summary TEXT CHECK(reasoning_summary IN ('auto','concise','detailed','none')),\n    service_tier TEXT,\n    approval_policy_json TEXT,\n    approvals_reviewer TEXT CHECK(approvals_reviewer IN ('user','auto_review','guardian_subagent')),\n    permission_mode TEXT CHECK(permission_mode IN ('default','acceptEdits','bypassPermissions','plan','dontAsk','auto','read-only','workspace-write','danger-full-access')),\n    usage_json TEXT,\n    origin INTEGER NOT NULL CHECK(origin IN (0,1)),\n    status TEXT NOT NULL CHECK(status IN ('running','completed','interrupted','failed')),\n    error_json TEXT NOT NULL,\n    started_at TEXT NOT NULL,\n    completed_at TEXT\n  );\n  CREATE INDEX IF NOT EXISTS agent_turns_session_idx ON agent_turns(session_id, started_at ASC);\n\n  CREATE TABLE IF NOT EXISTS agent_items (\n    id TEXT PRIMARY KEY,\n    turn_id TEXT NOT NULL REFERENCES agent_turns(id) ON DELETE CASCADE,\n    provider_item_id TEXT,\n    type TEXT NOT NULL,\n    sequence INTEGER NOT NULL,\n    status TEXT NOT NULL CHECK(status IN ('running','completed','waiting','interrupted','failed')),\n    payload_json TEXT NOT NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  );\n  CREATE INDEX IF NOT EXISTS agent_items_turn_idx ON agent_items(turn_id, sequence ASC);\n\n  CREATE TABLE IF NOT EXISTS agent_session_providers (\n    session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,\n    provider TEXT NOT NULL,\n    provider_session_id TEXT NOT NULL,\n    model TEXT,\n    reasoning_effort TEXT,\n    reasoning_summary TEXT CHECK(reasoning_summary IN ('auto','concise','detailed','none')),\n    service_tier TEXT,\n    approval_policy_json TEXT,\n    approvals_reviewer TEXT CHECK(approvals_reviewer IN ('user','auto_review','guardian_subagent')),\n    permission_mode TEXT CHECK(permission_mode IN ('default','acceptEdits','bypassPermissions','plan','dontAsk','auto','read-only','workspace-write','danger-full-access')),\n    token_usage_json TEXT,\n    continuity_context TEXT NOT NULL DEFAULT '',\n    synced_through_turn_id TEXT REFERENCES agent_turns(id) ON DELETE SET NULL,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    PRIMARY KEY(session_id, provider)\n  );\n";
+export declare const WORKSPACES_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS workspaces (\n    id TEXT PRIMARY KEY,\n    path TEXT NOT NULL UNIQUE,\n    name_override TEXT,\n    manually_registered INTEGER NOT NULL DEFAULT 0 CHECK(manually_registered IN (0, 1)),\n    discovered_from TEXT,\n    state TEXT NOT NULL DEFAULT 'available' CHECK(state IN ('available', 'missing', 'restore_pending'))\n  );\n";
+export declare function agentSessionsSchema(table: "agent_sessions" | "agent_sessions_next"): string;
+export declare const DATABASE_SCHEMA: string;

package/dist/infrastructure/database/schema.js

@@ -1,3 +1,25 @@
+export const WORKSPACES_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workspaces (
+    id TEXT PRIMARY KEY,
+    path TEXT NOT NULL UNIQUE,
+    name_override TEXT,
+    manually_registered INTEGER NOT NULL DEFAULT 0 CHECK(manually_registered IN (0, 1)),
+    discovered_from TEXT,
+    state TEXT NOT NULL DEFAULT 'available' CHECK(state IN ('available', 'missing', 'restore_pending'))
+  );
+`;
+export function agentSessionsSchema(table) {
+    return `
+  CREATE TABLE IF NOT EXISTS ${table} (
+    id TEXT PRIMARY KEY,
+    workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE RESTRICT,
+    provider TEXT NOT NULL,
+    status TEXT NOT NULL CHECK(status IN ('idle','running','waiting_input','error')),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+`;
+}
 export const DATABASE_SCHEMA = `
   CREATE TABLE IF NOT EXISTS operations (
     operation_id TEXT PRIMARY KEY,
@@ -96,15 +118,22 @@ export const DATABASE_SCHEMA = `
     updated_at TEXT NOT NULL
   );
 
-  CREATE TABLE IF NOT EXISTS agent_sessions (
-    id TEXT PRIMARY KEY,
-    workspace_root TEXT NOT NULL,
-    provider TEXT NOT NULL,
-    status TEXT NOT NULL CHECK(status IN ('idle','running','waiting_input','error')),
-    created_at TEXT NOT NULL,
+  CREATE TABLE IF NOT EXISTS agent_mcp_tool_settings (
+    tool_name TEXT PRIMARY KEY,
+    enabled INTEGER NOT NULL CHECK(enabled IN (0, 1)),
     updated_at TEXT NOT NULL
   );
+
+  CREATE TABLE IF NOT EXISTS agent_mcp_server_settings (
+    server_id TEXT PRIMARY KEY,
+    enabled INTEGER NOT NULL CHECK(enabled IN (0, 1)),
+    updated_at TEXT NOT NULL
+  );
+
+  ${WORKSPACES_SCHEMA}
+  ${agentSessionsSchema("agent_sessions")}
   CREATE INDEX IF NOT EXISTS agent_sessions_updated_idx ON agent_sessions(updated_at DESC);
+  CREATE INDEX IF NOT EXISTS agent_sessions_workspace_idx ON agent_sessions(workspace_id);
 
   CREATE TABLE IF NOT EXISTS agent_turns (
     id TEXT PRIMARY KEY,

package/dist/infrastructure/database/workspace-repository.d.ts

@@ -0,0 +1,28 @@
+import type { AppDatabase } from "./app-database.js";
+export type WorkspaceState = "available" | "missing" | "restore_pending";
+export interface WorkspaceRecord {
+    id: string;
+    path: string;
+    name_override: string | null;
+    manually_registered: number;
+    discovered_from: string | null;
+    state: WorkspaceState;
+}
+export declare class WorkspaceRepository {
+    private readonly database;
+    constructor(database: AppDatabase);
+    list(): WorkspaceRecord[];
+    get(id: string): WorkspaceRecord | null;
+    getByPath(workspacePath: string): WorkspaceRecord | null;
+    syncDiscoveredRoot(root: string, discoveredPaths: readonly string[]): void;
+    registerDiscoveredPath(workspacePath: string, root: string, requireRestoreConfirmation: boolean): WorkspaceRecord;
+    clearRemovedDiscoveryRoots(roots: readonly string[]): void;
+    registerManual(workspacePath: string, name: string | null): WorkspaceRecord;
+    rename(id: string, name: string): WorkspaceRecord | null;
+    removeManual(id: string): WorkspaceRecord | null;
+    hasActiveSessions(id: string): boolean;
+    cleanup(id: string): void;
+    markMissing(id: string): void;
+    markRestorePending(id: string): void;
+    confirmRestore(id: string): WorkspaceRecord | null;
+}

package/dist/infrastructure/database/workspace-repository.js

@@ -0,0 +1,126 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+export class WorkspaceRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    list() {
+        const rows = this.database.raw
+            .prepare("SELECT * FROM workspaces")
+            .all();
+        return rows.sort((a, b) => displayName(a).localeCompare(displayName(b), undefined, {
+            sensitivity: "base",
+        }) || a.path.localeCompare(b.path));
+    }
+    get(id) {
+        return (this.database.raw
+            .prepare("SELECT * FROM workspaces WHERE id=?")
+            .get(id) ?? null);
+    }
+    getByPath(workspacePath) {
+        return (this.database.raw
+            .prepare("SELECT * FROM workspaces WHERE path=?")
+            .get(workspacePath) ?? null);
+    }
+    syncDiscoveredRoot(root, discoveredPaths) {
+        const paths = new Set(discoveredPaths);
+        const updateMissing = this.database.raw.prepare("UPDATE workspaces SET discovered_from=CASE WHEN manually_registered=1 THEN NULL ELSE discovered_from END, state=CASE WHEN manually_registered=1 THEN state ELSE 'missing' END WHERE id=?");
+        for (const row of this.list()) {
+            if (row.discovered_from === root && !paths.has(row.path))
+                updateMissing.run(row.id);
+        }
+        for (const workspacePath of paths)
+            this.registerDiscoveredPath(workspacePath, root, true);
+    }
+    registerDiscoveredPath(workspacePath, root, requireRestoreConfirmation) {
+        const existing = this.getByPath(workspacePath);
+        if (!existing) {
+            const id = "ws_" + randomUUID();
+            this.database.raw
+                .prepare("INSERT INTO workspaces(id, path, manually_registered, discovered_from, state) VALUES(?,?,0,?,'available')")
+                .run(id, workspacePath, root);
+            return this.get(id);
+        }
+        const wasUnavailable = existing.state !== "available";
+        const state = requireRestoreConfirmation && wasUnavailable
+            ? "restore_pending"
+            : "available";
+        this.database.raw
+            .prepare("UPDATE workspaces SET discovered_from=?, state=? WHERE id=?")
+            .run(root, state, existing.id);
+        return this.get(existing.id);
+    }
+    clearRemovedDiscoveryRoots(roots) {
+        const configured = new Set(roots);
+        const update = this.database.raw.prepare("UPDATE workspaces SET discovered_from=NULL, state=CASE WHEN state='restore_pending' THEN 'missing' ELSE state END WHERE id=?");
+        for (const row of this.list()) {
+            if (row.discovered_from && !configured.has(row.discovered_from))
+                update.run(row.id);
+        }
+    }
+    registerManual(workspacePath, name) {
+        const existing = this.getByPath(workspacePath);
+        if (existing) {
+            this.database.raw
+                .prepare("UPDATE workspaces SET name_override=COALESCE(?, name_override), manually_registered=1, state='available' WHERE id=?")
+                .run(name, existing.id);
+            return this.get(existing.id);
+        }
+        const id = "ws_" + randomUUID();
+        this.database.raw
+            .prepare("INSERT INTO workspaces(id, path, name_override, manually_registered, state) VALUES(?,?,?,?, 'available')")
+            .run(id, workspacePath, name, 1);
+        return this.get(id);
+    }
+    rename(id, name) {
+        this.database.raw
+            .prepare("UPDATE workspaces SET name_override=? WHERE id=?")
+            .run(name, id);
+        return this.get(id);
+    }
+    removeManual(id) {
+        this.database.raw
+            .prepare("UPDATE workspaces SET manually_registered=0, state=CASE WHEN state='restore_pending' THEN 'missing' ELSE state END WHERE id=?")
+            .run(id);
+        return this.get(id);
+    }
+    hasActiveSessions(id) {
+        return Boolean(this.database.raw
+            .prepare("SELECT 1 FROM agent_sessions WHERE workspace_id=? AND status IN ('running','waiting_input') LIMIT 1")
+            .get(id));
+    }
+    cleanup(id) {
+        this.database.raw.exec("BEGIN IMMEDIATE");
+        try {
+            this.database.raw
+                .prepare("DELETE FROM agent_sessions WHERE workspace_id=?")
+                .run(id);
+            this.database.raw.prepare("DELETE FROM workspaces WHERE id=?").run(id);
+            this.database.raw.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.raw.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    markMissing(id) {
+        this.database.raw
+            .prepare("UPDATE workspaces SET state='missing' WHERE id=?")
+            .run(id);
+    }
+    markRestorePending(id) {
+        this.database.raw
+            .prepare("UPDATE workspaces SET state='restore_pending' WHERE id=? AND state='missing'")
+            .run(id);
+    }
+    confirmRestore(id) {
+        this.database.raw
+            .prepare("UPDATE workspaces SET state='available' WHERE id=? AND (manually_registered=1 OR discovered_from IS NOT NULL)")
+            .run(id);
+        return this.get(id);
+    }
+}
+function displayName(record) {
+    return record.name_override ?? (path.basename(record.path) || record.path);
+}

package/dist/mcp/custom/manager.d.ts

@@ -6,11 +6,12 @@ export declare class CustomMcpManager {
     private readonly repository;
     private readonly control;
     private readonly operations;
+    private readonly operationSource;
     private readonly oauth;
     private readonly authorizationFlows;
     private readonly entries;
     private closed;
-    constructor(repository: CustomMcpStore, control: McpToolControl, operations: OperationLog, dataDir?: string);
+    constructor(repository: CustomMcpStore, control: McpToolControl, operations: OperationLog, dataDir?: string, operationSource?: "mcp" | "agent_mcp");
     start(): void;
     list(): CustomMcpServerSummary[];
     create(input: Omit<CustomMcpConfig, "id">): Promise<CustomMcpServerSummary>;
@@ -48,6 +49,7 @@ export declare class CustomMcpManager {
     private forgetTools;
     private disconnect;
     private dispose;
+    private syncRepository;
     private require;
     private summary;
     close(): Promise<void>;