@geminixiang/mikan 1.0.0-beta.6 → 1.0.0-beta.60

package/dist/config.js

@@ -1,10 +1,10 @@
 import { Type } from "@sinclair/typebox";
-import { existsSync, readFileSync, renameSync, rmSync } from "fs";
-import { homedir } from "os";
-import { basename, dirname, join, resolve } from "path";
-import { readEnv } from "./utils/env.js";
-import { ensureDirExists, readJsonSchemaFileIfExists } from "./utils/file-guards.js";
-import { atomicWritePrivateFile } from "./utils/fs-atomic.js";
+import { existsSync, lstatSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { effectiveStateDir } from "./cli/arg-grammar.js";
+import { readEnv } from "./env-manifest.js";
+import { ensureDirExists, readJsonSchemaFileIfExists } from "./file-guards.js";
+import { atomicWritePrivateFile } from "./file-guards.js";
 import * as log from "./log.js";
 export class MissingGlobalSettingsError extends Error {
     constructor(settingsPath) {
@@ -18,10 +18,6 @@ const ONBOARD_SETTINGS = {
         provider: "anthropic",
         model: "claude-sonnet-4-6",
         thinkingLevel: "off",
-        autoReply: {
-            provider: "anthropic",
-            model: "claude-haiku-4-5",
-        },
     },
     slack: {
         replyMode: "top-level",
@@ -33,9 +29,11 @@ const ONBOARD_SETTINGS = {
             cpus: "2",
             memory: "4g",
         },
-        image: {
-            workspaceMount: "private",
-        },
+        // No pinned workspace door policy: with nothing set, the projection
+        // follows the platform's own channel vocabulary (public channels share
+        // workspace memory, private channels read it without writing, DMs stay
+        // isolated — see workspace-projection platformDerivedWorkspace).
+        // Deployments that predate this keep their explicit isolated setting.
         defaultSharedVault: "",
     },
 };
@@ -50,11 +48,8 @@ const SettingsFileSchema = Type.Object({
             Type.Literal("medium"),
             Type.Literal("high"),
             Type.Literal("xhigh"),
+            Type.Literal("max"),
         ])),
-        autoReply: Type.Optional(Type.Object({
-            provider: Type.Optional(Type.String()),
-            model: Type.Optional(Type.String()),
-        })),
     })),
     sentry: Type.Optional(Type.Object({
         dsn: Type.Optional(Type.String()),
@@ -72,47 +67,96 @@ const SettingsFileSchema = Type.Object({
         image: Type.Optional(Type.Object({
             workspaceMount: Type.Optional(Type.Union([Type.Literal("private"), Type.Literal("full")])),
         })),
+        workspace: Type.Optional(Type.Object({
+            doorPolicy: Type.Optional(Type.Union([Type.Literal("isolated"), Type.Literal("trusted")])),
+            layout: Type.Optional(Type.Union([
+                Type.Literal("conversation"),
+                Type.Literal("shared-support"),
+                Type.Literal("full"),
+            ])),
+            visibility: Type.Optional(Type.Union([Type.Literal("public"), Type.Literal("private")])),
+        })),
         defaultSharedVault: Type.Optional(Type.String()),
     })),
-    autoReply: Type.Optional(Type.Object({
-        enabled: Type.Optional(Type.Boolean()),
-        rules: Type.Optional(Type.Array(Type.String())),
-    })),
+    /**
+     * MCP servers, keyed by name. Merged per key across scopes: a conversation
+     * entry overrides (or, with `disabled: true`, turns off) the same-name
+     * global entry; other global entries stay available. The reserved
+     * `open-connector` name is ignored by runner construction.
+     */
+    mcpServers: Type.Optional(Type.Record(Type.String(), Type.Object({
+        command: Type.Optional(Type.String()),
+        args: Type.Optional(Type.Array(Type.String())),
+        env: Type.Optional(Type.Record(Type.String(), Type.String())),
+        url: Type.Optional(Type.String()),
+        headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+        disabled: Type.Optional(Type.Boolean()),
+    }))),
 });
 function loadSettingsFile(settingsPath) {
     return readJsonSchemaFileIfExists(settingsPath, SettingsFileSchema, (detail) => detail === "unexpected JSON shape"
         ? `Malformed settings file at ${settingsPath}: expected a JSON object at the top level`
         : `Malformed settings file at ${settingsPath}: ${detail}`);
 }
-function getStateDir() {
-    const raw = readEnv("STATE_DIR");
-    return raw ? resolve(raw) : join(homedir(), ".mikan");
-}
 function normalizeSettingsConfig(config) {
     return {
         ...(config.llm?.provider !== undefined ? { provider: config.llm.provider } : {}),
         ...(config.llm?.model !== undefined ? { model: config.llm.model } : {}),
         ...(config.llm?.thinkingLevel !== undefined ? { thinkingLevel: config.llm.thinkingLevel } : {}),
         ...(config.sentry?.dsn !== undefined ? { sentryDsn: config.sentry.dsn } : {}),
-        ...(config.sandbox?.cpus !== undefined ? { sandboxCpus: config.sandbox.cpus } : {}),
-        ...(config.sandbox?.memory !== undefined ? { sandboxMemory: config.sandbox.memory } : {}),
-        ...(config.sandbox?.boost?.cpus !== undefined
-            ? { sandboxBoostCpus: config.sandbox.boost.cpus }
-            : {}),
-        ...(config.sandbox?.boost?.memory !== undefined
-            ? { sandboxBoostMemory: config.sandbox.boost.memory }
-            : {}),
-        ...(config.sandbox?.image?.workspaceMount !== undefined
-            ? { sandboxImageWorkspaceMount: config.sandbox.image.workspaceMount }
-            : {}),
-        ...(config.sandbox?.defaultSharedVault?.trim()
-            ? { defaultSharedVault: config.sandbox.defaultSharedVault.trim() }
-            : {}),
+        ...(config.sandbox !== undefined ? { sandbox: normalizeSandboxSettings(config.sandbox) } : {}),
         ...(config.slack !== undefined ? { slack: config.slack } : {}),
+        ...(config.mcpServers !== undefined ? { mcpServers: config.mcpServers } : {}),
+    };
+}
+/**
+ * File shape → in-memory shape for the sandbox group. An empty or
+ * whitespace-only `defaultSharedVault` means "no default" and is dropped;
+ * non-empty values are trimmed. Everything else passes through as-is.
+ */
+function normalizeSandboxSettings(sandbox) {
+    const defaultSharedVault = sandbox.defaultSharedVault?.trim();
+    const legacyWorkspace = sandbox.image?.workspaceMount === "private"
+        ? { doorPolicy: "trusted", layout: "shared-support" }
+        : sandbox.image?.workspaceMount === "full"
+            ? { doorPolicy: "trusted", layout: "full" }
+            : undefined;
+    const workspace = legacyWorkspace
+        ? { ...legacyWorkspace, ...sandbox.workspace }
+        : sandbox.workspace;
+    return {
+        ...(sandbox.cpus !== undefined ? { cpus: sandbox.cpus } : {}),
+        ...(sandbox.memory !== undefined ? { memory: sandbox.memory } : {}),
+        ...(sandbox.boost !== undefined ? { boost: sandbox.boost } : {}),
+        ...(sandbox.image !== undefined ? { image: sandbox.image } : {}),
+        ...(workspace !== undefined ? { workspace } : {}),
+        ...(defaultSharedVault ? { defaultSharedVault } : {}),
+    };
+}
+/**
+ * Merge two sandbox settings groups. The merge invariant is LEAF-LEVEL:
+ * an override that only sets `sandbox.memory` keeps the base `sandbox.cpus`,
+ * and an override that only sets `boost.memory` keeps the base `boost.cpus`
+ * (same for `image`). This mirrors how the fields merged when they were
+ * flat top-level keys; a group-level spread would silently drop base leaves.
+ */
+function mergeSandboxSettings(base, override) {
+    if (!base)
+        return override;
+    if (!override)
+        return base;
+    return {
+        ...base,
+        ...override,
+        ...(base.boost || override.boost ? { boost: { ...base.boost, ...override.boost } } : {}),
+        ...(base.image || override.image ? { image: { ...base.image, ...override.image } } : {}),
+        ...(base.workspace || override.workspace
+            ? { workspace: { ...base.workspace, ...override.workspace } }
+            : {}),
     };
 }
 function getSettingsPath() {
-    return join(getStateDir(), "settings.json");
+    return join(effectiveStateDir(), "settings.json");
 }
 function requireGlobalSettings() {
     const settingsPath = getSettingsPath();
@@ -128,33 +172,22 @@ function requireString(value, path) {
     }
     return value;
 }
-function requireThinkingLevel(value) {
-    return requireString(value, "llm.thinkingLevel");
-}
 function toAgentConfig(fromFile) {
     const provider = requireString(fromFile.provider, "llm.provider");
     const model = requireString(fromFile.model, "llm.model");
-    const thinkingLevel = requireThinkingLevel(fromFile.thinkingLevel);
-    const sentryDsn = fromFile.sentryDsn ?? process.env.SENTRY_DSN;
-    const sandboxCpus = fromFile.sandboxCpus;
-    const sandboxMemory = fromFile.sandboxMemory;
-    const sandboxBoostCpus = fromFile.sandboxBoostCpus;
-    const sandboxBoostMemory = fromFile.sandboxBoostMemory;
-    const sandboxImageWorkspaceMount = fromFile.sandboxImageWorkspaceMount;
-    const defaultSharedVault = fromFile.defaultSharedVault;
+    const thinkingLevel = requireString(fromFile.thinkingLevel, "llm.thinkingLevel");
+    const sentryDsn = sentryDsnFrom(fromFile.sentryDsn);
+    const sandbox = fromFile.sandbox;
     const slack = fromFile.slack;
+    const mcpServers = fromFile.mcpServers;
     return {
         provider,
         model,
         thinkingLevel,
         sentryDsn,
-        sandboxCpus,
-        sandboxMemory,
-        sandboxBoostCpus,
-        sandboxBoostMemory,
-        sandboxImageWorkspaceMount,
-        defaultSharedVault,
+        sandbox,
         slack,
+        mcpServers,
     };
 }
 function loadRawGlobalSettings() {
@@ -165,7 +198,9 @@ export function loadGlobalSettings() {
 }
 /**
  * Host-authoritative location of a conversation's settings file:
- * `<stateDir>/conversations/<conversationId>/settings.json`.
+ * `<office state dir>/settings.json`. The Office value names both the
+ * state-dir key and the legacy pre-host-migration location (its workspace
+ * dir) — the key is never inferred from a directory basename.
  *
  * Conversation settings used to live at `<conversationDir>/settings.json`,
  * but conversation dirs are bind-mounted read-write into sandbox containers
@@ -180,23 +215,23 @@ export function loadGlobalSettings() {
  * migration marker — a legacy file (re)appearing later, e.g. planted from
  * inside the sandbox, is never read again.
  */
-export function conversationSettingsPath(conversationDir) {
-    const conversationId = basename(resolve(conversationDir));
-    const hostPath = join(getStateDir(), "conversations", conversationId, "settings.json");
-    if (existsSync(hostPath))
+export function conversationSettingsPath(office) {
+    const hostPath = join(office.stateDir, "settings.json");
+    if (existsSync(hostPath)) {
+        assertSettingsFile(hostPath, "Host conversation settings");
         return hostPath;
+    }
     ensureDirExists(dirname(hostPath));
-    const legacyPath = join(conversationDir, "settings.json");
+    const legacyPath = join(office.dir, "settings.json");
     let content = "{}\n";
     let migrated = false;
     if (existsSync(legacyPath)) {
-        try {
-            content = readFileSync(legacyPath, "utf-8");
-            migrated = true;
-        }
-        catch (err) {
-            log.logWarning(`Could not read legacy conversation settings: ${legacyPath}`, String(err));
-        }
+        assertSettingsFile(legacyPath, "Legacy conversation settings");
+        content = readFileSync(legacyPath, "utf-8");
+        // Validate before moving the file. A malformed legacy file must fail
+        // closed and remain available for an operator to repair.
+        loadSettingsFile(legacyPath);
+        migrated = true;
     }
     atomicWritePrivateFile(hostPath, content);
     if (migrated) {
@@ -210,103 +245,53 @@ export function conversationSettingsPath(conversationDir) {
     }
     return hostPath;
 }
-export function resolveConversationSettings(conversationDir) {
-    const globalConfig = loadRawGlobalSettings();
-    const conversationConfig = normalizeSettingsConfig(loadSettingsFile(conversationSettingsPath(conversationDir)) ?? {});
-    return toAgentConfig({ ...globalConfig, ...conversationConfig });
-}
-/**
- * Resolve the model used to judge auto-reply rules. Falls back to the main
- * llm.{provider,model} when llm.autoReply is not set, so a missing override
- * keeps current behavior.
- *
- * @deprecated Auto-reply is kept for compatibility while its future is undecided.
- */
-export function loadAutoReplyJudgeModel(conversationDir) {
-    const global = requireGlobalSettings();
-    const local = conversationDir
-        ? (loadSettingsFile(conversationSettingsPath(conversationDir)) ?? {})
-        : {};
-    const merged = { ...global.llm, ...local.llm };
-    const judge = { ...global.llm?.autoReply, ...local.llm?.autoReply };
-    const provider = requireString(judge.provider ?? merged?.provider, "llm.autoReply.provider");
-    const model = requireString(judge.model ?? merged?.model, "llm.autoReply.model");
-    return { provider, model };
+function assertSettingsFile(path, label) {
+    let stats;
+    try {
+        stats = lstatSync(path);
+    }
+    catch (err) {
+        throw new Error(`${label} cannot be inspected: ${path}`, { cause: err });
+    }
+    if (stats.isSymbolicLink() || !stats.isFile()) {
+        throw new Error(`${label} must be a regular non-symlink file: ${path}`);
+    }
 }
 const AUTO_REPLY_FILE = "auto-reply";
 const AUTO_REPLY_DISABLED_FILE = "auto-reply.disabled";
-function readAutoReplyRulesFile(path) {
-    const text = readFileSync(path, "utf-8").trim();
-    return text ? [text] : [];
-}
-/**
- * Load the mom-compatible auto-reply marker file state for a conversation.
- *
- * - `auto-reply` exists: enabled; empty file means reply to any top-level message.
- * - `auto-reply.disabled` exists: disabled, preserving any rules text for re-enable.
- * - neither exists: disabled.
- *
- * @deprecated Auto-reply is kept for compatibility while its future is undecided.
- */
-export function loadConversationAutoReplyConfig(conversationDir) {
-    const enabledPath = join(conversationDir, AUTO_REPLY_FILE);
-    if (existsSync(enabledPath)) {
-        return { enabled: true, rules: readAutoReplyRulesFile(enabledPath) };
-    }
-    const disabledPath = join(conversationDir, AUTO_REPLY_DISABLED_FILE);
-    if (existsSync(disabledPath)) {
-        return { enabled: false, rules: readAutoReplyRulesFile(disabledPath) };
-    }
-    return { enabled: false, rules: [] };
+export function slackConversationAutoReplyEnabled(office) {
+    return existsSync(join(office.dir, AUTO_REPLY_FILE));
 }
-/**
- * Save auto-reply state using mom-compatible marker files.
- *
- * @deprecated Auto-reply is kept for compatibility while its future is undecided.
- */
-export function saveConversationAutoReplyConfig(conversationDir, config) {
-    ensureDirExists(conversationDir);
-    const enabledPath = join(conversationDir, AUTO_REPLY_FILE);
-    const disabledPath = join(conversationDir, AUTO_REPLY_DISABLED_FILE);
-    const targetPath = config.enabled ? enabledPath : disabledPath;
-    const otherPath = config.enabled ? disabledPath : enabledPath;
+export function setSlackConversationAutoReply(office, enabled) {
+    ensureDirExists(office.dir);
+    const enabledPath = join(office.dir, AUTO_REPLY_FILE);
+    const disabledPath = join(office.dir, AUTO_REPLY_DISABLED_FILE);
+    const targetPath = enabled ? enabledPath : disabledPath;
+    const otherPath = enabled ? disabledPath : enabledPath;
     if (existsSync(otherPath)) {
         renameSync(otherPath, targetPath);
+        return;
     }
-    atomicWritePrivateFile(targetPath, config.rules.join("\n"));
-}
-export function resolveWorkspaceDirFromArgv(args = process.argv.slice(2)) {
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "--sandbox" || arg === "--download" || arg === "--state-dir") {
-            i += 1;
-            continue;
-        }
-        if (arg === "--version" || arg === "-v" || arg === "-V" || arg === "--onboard") {
-            continue;
-        }
-        if (arg.startsWith("--sandbox=") ||
-            arg.startsWith("--download=") ||
-            arg.startsWith("--state-dir=")) {
-            continue;
-        }
-        if (!arg.startsWith("-")) {
-            return arg;
-        }
+    if (enabled && !existsSync(targetPath)) {
+        atomicWritePrivateFile(targetPath, "");
     }
-    return undefined;
 }
-export function resolveStateDirFromArgv(args = process.argv.slice(2)) {
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg.startsWith("--state-dir=")) {
-            return resolve(arg.slice("--state-dir=".length));
-        }
-        if (arg === "--state-dir") {
-            return resolve(args[++i] || "");
-        }
-    }
-    return join(homedir(), ".mikan");
+export function resolveConversationSettings(office) {
+    const globalConfig = loadRawGlobalSettings();
+    const conversationConfig = normalizeSettingsConfig(loadSettingsFile(conversationSettingsPath(office)) ?? {});
+    // MCP servers merge per key: a conversation redefines or disables individual
+    // servers without losing the rest of the global set. Runner construction
+    // removes the reserved open-connector entry before loading servers.
+    const mcpServers = { ...globalConfig.mcpServers, ...conversationConfig.mcpServers };
+    // The sandbox group merges at the leaf level (see mergeSandboxSettings):
+    // a conversation that only sets sandbox.memory keeps the global sandbox.cpus.
+    const sandbox = mergeSandboxSettings(globalConfig.sandbox, conversationConfig.sandbox);
+    return toAgentConfig({
+        ...globalConfig,
+        ...conversationConfig,
+        ...(sandbox ? { sandbox } : {}),
+        ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
+    });
 }
 /**
  * True when `child` is `parent` or a path inside it. Purely lexical (no
@@ -319,39 +304,49 @@ export function isPathInside(child, parent) {
     return childPath === parentPath || childPath.startsWith(parentPath + "/");
 }
 /**
- * The state dir (extensions code, extension data, vaults, auth.json) must
- * never live inside the working dir: conversation opt-in "full" mode mounts
- * the entire working dir read-write into sandbox containers, and a mounted
- * state dir would let sandboxed code plant extension modules that the host
- * process later imports — a sandbox escape. Fatal under sandboxed modes;
- * host mode has no mounts, so only warn about the bad hygiene.
+ * The state dir (settings, office records, vaults) must never live inside
+ * the working dir: conversation opt-in "full" mode mounts the entire working
+ * dir read-write into sandbox containers, which would expose host-authoritative
+ * state and credentials. Fatal under sandboxed modes; host mode has no mounts,
+ * so only warn about the bad hygiene.
  */
 export function assertStateDirOutsideWorkspace(stateDir, workingDir, sandboxType) {
     if (!isPathInside(stateDir, workingDir))
         return;
     const message = `--state-dir (${stateDir}) must not be inside the working directory (${workingDir}): ` +
         `sandbox containers mount the working directory, and a mounted state dir ` +
-        `would expose extensions, vaults, and credentials to sandboxed code.`;
+        `would expose settings, office records, vaults, and credentials to sandboxed code.`;
     if (sandboxType === "host") {
         log.logWarning("Insecure state dir location", message);
         return;
     }
     throw new Error(message);
 }
+/** Settings-file DSN wins over SENTRY_DSN env — the rule lives only here. */
+function sentryDsnFrom(fromFile) {
+    return fromFile || readEnv("SENTRY_DSN");
+}
 export function resolveSentryDsn() {
     const fromFile = normalizeSettingsConfig(loadSettingsFile(getSettingsPath()) ?? {});
-    if (fromFile.sentryDsn) {
-        return fromFile.sentryDsn;
-    }
-    return process.env.SENTRY_DSN;
+    return sentryDsnFrom(fromFile.sentryDsn);
 }
-export function createGlobalSettingsFile(stateDir) {
+export function createGlobalSettingsFile(stateDir, llm) {
     const settingsPath = join(stateDir, "settings.json");
     if (existsSync(settingsPath)) {
         throw new Error(`Global settings already exists at ${settingsPath}`);
     }
     ensureDirExists(stateDir);
-    atomicWritePrivateFile(settingsPath, JSON.stringify(ONBOARD_SETTINGS, null, 2));
+    const settings = llm
+        ? {
+            ...ONBOARD_SETTINGS,
+            llm: {
+                ...ONBOARD_SETTINGS.llm,
+                provider: llm.provider,
+                model: llm.model,
+            },
+        }
+        : ONBOARD_SETTINGS;
+    atomicWritePrivateFile(settingsPath, JSON.stringify(settings, null, 2));
     return settingsPath;
 }
 /**
@@ -373,8 +368,9 @@ function compactSettingsConfig(config) {
         ...(hasDefinedValue(config.llm) ? { llm: config.llm } : {}),
         ...(hasDefinedValue(config.sentry) ? { sentry: config.sentry } : {}),
         ...(hasDefinedValue(config.sandbox) ? { sandbox: config.sandbox } : {}),
-        ...(hasDefinedValue(config.autoReply) ? { autoReply: config.autoReply } : {}),
         ...(hasDefinedValue(config.slack) ? { slack: config.slack } : {}),
+        // An empty map means "all servers removed".
+        ...(config.mcpServers !== undefined ? { mcpServers: config.mcpServers } : {}),
     };
 }
 function patchSettingsConfig(existing, config) {
@@ -390,61 +386,106 @@ function patchSettingsConfig(existing, config) {
             ...existing.sentry,
             ...(config.sentryDsn !== undefined ? { dsn: config.sentryDsn } : {}),
         },
-        sandbox: {
-            ...existing.sandbox,
-            ...(config.sandboxCpus !== undefined ? { cpus: config.sandboxCpus } : {}),
-            ...(config.sandboxMemory !== undefined ? { memory: config.sandboxMemory } : {}),
-            ...(config.sandboxBoostCpus !== undefined || config.sandboxBoostMemory !== undefined
-                ? {
-                    boost: {
-                        ...existing.sandbox?.boost,
-                        ...(config.sandboxBoostCpus !== undefined ? { cpus: config.sandboxBoostCpus } : {}),
-                        ...(config.sandboxBoostMemory !== undefined
-                            ? { memory: config.sandboxBoostMemory }
-                            : {}),
-                    },
-                }
-                : {}),
-            ...(config.sandboxImageWorkspaceMount !== undefined
-                ? {
-                    image: {
-                        ...existing.sandbox?.image,
-                        workspaceMount: config.sandboxImageWorkspaceMount,
-                    },
-                }
-                : {}),
-            ...(config.defaultSharedVault !== undefined
-                ? { defaultSharedVault: config.defaultSharedVault }
-                : {}),
-        },
+        // Leaf-level merge: a patch that only sets sandbox.boost.memory keeps the
+        // existing boost.cpus (and every other existing leaf). compactSettingsConfig
+        // drops the group entirely when it ends up with no defined values.
+        sandbox: mergeSandboxSettings(existing.sandbox, config.sandbox) ?? {},
         slack: {
             ...existing.slack,
             ...config.slack,
         },
+        // The portal edits the full MCP map, and
+        // a merge would make removing a server impossible.
+        ...(config.mcpServers !== undefined ? { mcpServers: config.mcpServers } : {}),
     };
     return compactSettingsConfig(patched);
 }
-function updateSettingsFile(settingsPath, patch, defaultSettings) {
-    let existing = defaultSettings;
-    if (existsSync(settingsPath)) {
-        try {
-            existing = loadSettingsFile(settingsPath) ?? {};
-        }
-        catch (err) {
-            const detail = err instanceof Error ? err.message : String(err);
-            const message = detail.startsWith("Malformed settings file")
-                ? detail.replace("Malformed settings file", "Refusing to overwrite malformed settings file")
-                : detail;
-            throw new Error(message, { cause: err });
-        }
+function loadSettingsFileForUpdate(settingsPath, defaultSettings) {
+    if (!existsSync(settingsPath))
+        return defaultSettings;
+    try {
+        return loadSettingsFile(settingsPath) ?? {};
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        const message = detail.startsWith("Malformed settings file")
+            ? detail.replace("Malformed settings file", "Refusing to overwrite malformed settings file")
+            : detail;
+        throw new Error(message, { cause: err });
     }
+}
+function updateSettingsFile(settingsPath, patch, defaultSettings) {
+    const existing = loadSettingsFileForUpdate(settingsPath, defaultSettings);
     ensureDirExists(dirname(settingsPath));
     atomicWritePrivateFile(settingsPath, JSON.stringify(patchSettingsConfig(existing, patch), null, 2));
 }
 export function updateGlobalSettings(patch) {
-    updateSettingsFile(join(getStateDir(), "settings.json"), patch, ONBOARD_SETTINGS);
+    updateSettingsFile(getSettingsPath(), patch, ONBOARD_SETTINGS);
+}
+export function updateConversationSettings(office, patch) {
+    updateSettingsFile(conversationSettingsPath(office), patch, {});
 }
-export function updateConversationSettings(conversationDir, patch) {
-    updateSettingsFile(conversationSettingsPath(conversationDir), patch, {});
+/**
+ * The two scope-level MCP server maps, unmerged: the portal edits each scope's
+ * own file, so it needs the raw per-scope values, not the effective merge
+ * (`resolveConversationSettings` owns that).
+ */
+export function loadScopeMcpServers(office) {
+    return {
+        global: loadRawGlobalSettings().mcpServers ?? {},
+        conversation: loadSettingsFile(conversationSettingsPath(office))?.mcpServers ?? {},
+    };
+}
+/**
+ * The conversation's own door-policy override (legacy `image.workspaceMount`
+ * included), or null when the office follows the global default. Missing
+ * `visibility` on a shared-support choice defaults to "public" downstream
+ * (see resolveEffectiveWorkspace), preserving today's read-write behavior for
+ * every office that predates this setting.
+ */
+export function loadConversationWorkspaceOverride(office) {
+    const file = loadSettingsFile(conversationSettingsPath(office));
+    const sandbox = file?.sandbox;
+    if (sandbox?.workspace?.doorPolicy === "isolated")
+        return { doorPolicy: "isolated" };
+    if (sandbox?.workspace?.doorPolicy === "trusted") {
+        if (sandbox.workspace.layout === "full")
+            return { doorPolicy: "trusted", layout: "full" };
+        return {
+            doorPolicy: "trusted",
+            layout: "shared-support",
+            ...(sandbox.workspace.visibility ? { visibility: sandbox.workspace.visibility } : {}),
+        };
+    }
+    if (sandbox?.image?.workspaceMount === "full")
+        return { doorPolicy: "trusted", layout: "full" };
+    if (sandbox?.image?.workspaceMount === "private") {
+        return { doorPolicy: "trusted", layout: "shared-support" };
+    }
+    return null;
+}
+export function setConversationWorkspacePolicy(office, choice) {
+    writeWorkspacePolicy(conversationSettingsPath(office), choice, {});
+}
+export function setGlobalWorkspacePolicy(choice) {
+    writeWorkspacePolicy(getSettingsPath(), choice, ONBOARD_SETTINGS);
+}
+/**
+ * The generic settings patch merges leaves and cannot remove keys, so the
+ * door-policy writer edits the file shape directly: it always drops the
+ * legacy `image.workspaceMount` (the explicit choice replaces it) and either
+ * sets or removes the `workspace` group.
+ */
+function writeWorkspacePolicy(settingsPath, choice, defaultSettings) {
+    const existing = loadSettingsFileForUpdate(settingsPath, defaultSettings);
+    const { workspaceMount: _legacy, ...image } = existing.sandbox?.image ?? {};
+    const { workspace: _previous, image: _image, ...sandboxRest } = existing.sandbox ?? {};
+    const sandbox = {
+        ...sandboxRest,
+        ...(hasDefinedValue(image) ? { image } : {}),
+        ...(choice ? { workspace: choice } : {}),
+    };
+    ensureDirExists(dirname(settingsPath));
+    atomicWritePrivateFile(settingsPath, JSON.stringify(compactSettingsConfig({ ...existing, sandbox }), null, 2));
 }
 //# sourceMappingURL=config.js.map