@suveren/gateway 0.10.1 → 0.11.0

package/README.md

@@ -185,6 +185,42 @@ See `suveren-gateway config help` for the full command reference.
 
 ---
 
+## Simulation mode — block every real system
+
+A mandate is bound to a *profile* (e.g. "sales"), not to a specific connector. If a real
+connector (e.g. a live ERP account) and a simulated one (the built-in ERP/CRM/email
+simulators) share a profile on one gateway, a mandate meant only for testing also
+authorizes the real connector — nothing about the mandate says which one it's for.
+
+Simulation mode closes that gap gateway-wide: turn it on and **every connector without a
+manifest `simulation` marker is refused to even start** (the built-in ERP, CRM, and email
+simulators all declare one; a connected Gmail or live ERP account does not), and every
+connector that does declare one has its mode forced to `simulation`, overriding whatever
+credential value is on file. Mandates and profiles are completely unaffected, and the
+Authority Server never learns this is on — it's a purely local, gateway-side switch.
+
+```bash
+# Start fresh with real systems blocked:
+suveren-gateway start --simulation
+
+# Or flip it on an existing install (takes effect on the next start/restart):
+suveren-gateway simulation on
+suveren-gateway restart
+
+# Check the mode (the SAVED setting and, if the gateway is running, the LIVE one):
+suveren-gateway simulation status
+
+# Turning it off makes real systems reachable again, so it requires typed
+# confirmation (or --confirm live for scripts) — turning it ON does not:
+suveren-gateway simulation off
+suveren-gateway restart
+```
+
+`suveren-gateway status` also shows the current mode. See `suveren-gateway simulation help`
+for the full command reference.
+
+---
+
 ## Technical Documentation
 
 | Document | Contents |

package/bin/suveren-gateway.js

@@ -17,7 +17,8 @@ import { homedir, platform, userInfo } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { buildLaunchAgentPlist, buildMacLauncher, buildSystemdUnit, buildWindowsTaskXml } from '../lib/autostart-templates.mjs';
-import { DEFAULT_AS_URL, readConfig, writeConfig, validateAsUrl, validateCaFile, validatePinTls, resolveAsUrl, resolvePinTls, resolvePinTlsExpectedFingerprint } from '../lib/config.mjs';
+import { DEFAULT_AS_URL, readConfig, writeConfig, validateAsUrl, validateCaFile, validatePinTls, resolveAsUrl, resolvePinTls, resolvePinTlsExpectedFingerprint, resolveSimulation } from '../lib/config.mjs';
+import { createInterface } from 'node:readline/promises';
 import { readPairing as readAsPairing, recordTlsPin, formatFingerprint, normalizeFingerprint } from '../lib/as-pairing.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -210,6 +211,13 @@ async function start(args) {
     pinTlsToSave = true;
   }
 
+  // --simulation: the safe direction (turning OFF real systems), so — unlike
+  // `simulation off` — this needs no confirmation. Only ever turns it ON;
+  // there is no `start --no-simulation` (use `simulation off` for that, which
+  // DOES require confirmation, since that direction makes real systems
+  // reachable again).
+  const simulationFlag = args.includes('--simulation');
+
   if (await isAlreadyRunning()) {
     console.error(`suveren-gateway is already running (pid ${readPid()}). Use \`suveren-gateway stop\` first or \`suveren-gateway restart\`.`);
     process.exit(1);
@@ -269,6 +277,10 @@ async function start(args) {
         : `  Staged — the first sign-in's challenge must match it (refused otherwise); it then becomes the permanent pin.`,
     );
   }
+  if (simulationFlag) {
+    writeConfig(DATA_DIR, { simulation: true });
+    console.log(`Simulation mode: ON (saved) — every connector without a manifest "simulation" marker will be blocked.`);
+  }
 
   if (detach) {
     const out = openSync(LOG_FILE, 'a');
@@ -414,6 +426,7 @@ async function status() {
         console.log('suveren-gateway: running (managed by the login service)');
         console.log(`  UI:           http://localhost:${SUVEREN_PORT}`);
         console.log(`  Vault:        ${body.vaultUnlocked ? 'unlocked' : 'locked'}`);
+        console.log(`  Simulation:   ${body.simulation ? 'on — real systems are blocked' : 'off'}`);
         console.log(`  Version:      ${body.version ?? 'unknown'} (running)`);
         console.log(`  Service:      suveren-gateway service status`);
         return;
@@ -438,6 +451,7 @@ async function status() {
     console.log(`suveren-gateway: running (pid ${pid})`);
     console.log(`  UI:           http://localhost:${SUVEREN_PORT}`);
     console.log(`  Vault:        ${body.vaultUnlocked ? 'unlocked' : 'locked'}`);
+    console.log(`  Simulation:   ${body.simulation ? 'on — real systems are blocked' : 'off'}`);
     console.log(`  Version:      ${body.version ?? 'unknown'} (running)`);
     if (CLI_VERSION) console.log(`                ${CLI_VERSION} (installed CLI)`);
     if (CLI_VERSION && body.version && body.version !== CLI_VERSION && body.version !== 'dev') {
@@ -634,6 +648,102 @@ async function config(args) {
   if (sub !== undefined && sub !== 'help' && sub !== '--help' && sub !== '-h') process.exit(2);
 }
 
+// ─── simulation: gateway-wide switch that blocks every real system ──────
+//
+// A mandate is bound to a PROFILE, not a connector — see suveren-gateway's
+// tool-proxy.ts (`profileMatches`). Put a real connector and a simulated one
+// on the same profile, and one mandate authorizes both. Simulation mode
+// closes that generically: ON blocks every connector whose manifest carries
+// no `simulation` marker, and forces every connector that DOES have one into
+// its simulated mode, regardless of what credential value is on file.
+// Mandates and profiles are unaffected; the Authority Server never learns
+// about this — it is a purely local, gateway-side switch. See
+// apps/mcp-server/src/lib/simulation-mode.ts for enforcement.
+
+function printSimulationHelp() {
+  console.log(`suveren-gateway simulation — gateway-wide switch that blocks every real system
+
+Usage:
+  suveren-gateway simulation on               Block every real connector (no confirmation — the safe direction)
+  suveren-gateway simulation off              Make real systems reachable again (requires confirmation)
+    [--confirm live]                          Non-interactive confirmation
+  suveren-gateway simulation status           Show the saved setting and (if running) the live one
+
+Changes take effect on the next \`suveren-gateway start\` / \`restart\`.
+`);
+}
+
+async function printSimulationStatus() {
+  const saved = resolveSimulation(DATA_DIR);
+  console.log(`Saved:   ${saved ? 'on' : 'off'}`);
+  try {
+    const res = await fetch(`http://localhost:${SUVEREN_PORT}/health`, { signal: AbortSignal.timeout(3000) });
+    if (res.ok) {
+      const body = await res.json();
+      const running = body.simulation === true;
+      console.log(`Running: ${running ? 'on' : 'off'}${running !== saved ? '  (restart to apply the saved value)' : ''}`);
+    }
+  } catch {
+    // Not reachable — the saved value is all there is to report.
+  }
+}
+
+/** Read one line from stdin, or undefined if there is no TTY to prompt on
+ *  (so a non-interactive caller gets a clean abort instead of a hang). */
+async function promptLine(question) {
+  if (!process.stdin.isTTY) return undefined;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+async function simulation(args) {
+  const sub = args[0] ?? 'status';
+
+  if (sub === 'help' || sub === '--help' || sub === '-h') { printSimulationHelp(); return; }
+
+  if (sub === 'status') {
+    await printSimulationStatus();
+    return;
+  }
+
+  if (sub === 'on') {
+    // The safe direction — blocking real systems needs no confirmation.
+    writeConfig(DATA_DIR, { simulation: true });
+    console.log('Simulation mode: ON (saved) — every connector without a manifest "simulation" marker will be blocked.');
+    console.log('Restart to pick it up: suveren-gateway restart');
+    return;
+  }
+
+  if (sub === 'off') {
+    console.error('Turning simulation mode OFF makes every real system reachable again: any connector');
+    console.error('without a manifest "simulation" marker (e.g. a live Gmail or ERP account) will spawn');
+    console.error('and execute for real the next time this gateway starts.');
+    console.error('');
+    let typed = flagValue(args, '--confirm');
+    if (typed === undefined) {
+      typed = await promptLine('Type "live" to confirm, or anything else to abort: ');
+    }
+    if (typed !== 'live') {
+      console.error(typed === undefined
+        ? 'No TTY to confirm on and no --confirm given — aborted. Simulation mode unchanged.'
+        : 'Aborted — simulation mode unchanged.');
+      process.exit(1);
+    }
+    writeConfig(DATA_DIR, { simulation: false });
+    console.log('Simulation mode: OFF (saved) — real systems become reachable on next restart.');
+    console.log('Restart to pick it up: suveren-gateway restart');
+    return;
+  }
+
+  console.error(`Unknown: simulation ${sub}\n`);
+  printSimulationHelp();
+  process.exit(2);
+}
+
 // ─── service: install autostart-on-login (survives reboot) ──────────────
 //
 // Keeps the gateway PROCESS always running (starts on login, restarts on
@@ -1139,9 +1249,10 @@ Usage:
     [--as-url <url>]                         Authority Server URL (saved for next time)
     [--ca-file <path>]                       Internal CA bundle (saved for next time)
     [--pin-tls --expect-fingerprint <hex>]   Pin the AS TLS certificate (saved; https:// only — see below)
+    [--simulation]                           Block every real system (saved — see \`simulation help\`)
   suveren-gateway stop                       Stop a detached gateway
   suveren-gateway restart                    Stop, then start --detach
-  suveren-gateway status                     Show running state + health
+  suveren-gateway status                     Show running state + health (incl. simulation mode)
   suveren-gateway logs [--tail]               Print or tail ~/.suveren/gateway.log
   suveren-gateway service <cmd>               Run as a login service that survives reboot
                                               (install | uninstall | status)
@@ -1152,6 +1263,8 @@ Usage:
                                               Pin the Authority Server's TLS certificate
                                               (see \`suveren-gateway config help\` for the fingerprint check)
   suveren-gateway config set pin-tls off      Stop enforcing the TLS certificate pin
+  suveren-gateway simulation on|off|status    Block (or unblock) every real system
+                                              (see \`suveren-gateway simulation help\`)
   suveren-gateway help                        Print this help
 
 Environment:
@@ -1159,6 +1272,7 @@ Environment:
   SUVEREN_MCP_PORT    MCP server port (default 3430)
   SUVEREN_DATA_DIR    Data directory (default ~/.suveren)
   SUVEREN_AS_URL      Authority Server URL — overrides the saved as-url
+  SUVEREN_SIMULATION  1 to force simulation mode for this run — overrides the saved setting
 
 Authority Server resolution order: --as-url flag > SUVEREN_AS_URL env >
 saved as-url (\`config set as-url\`) > default (${DEFAULT_AS_URL}).
@@ -1181,6 +1295,7 @@ async function main() {
     case 'logs':    await logs(argv.slice(1)); break;
     case 'service': await service(argv.slice(1)); break;
     case 'config':  await config(argv.slice(1)); break;
+    case 'simulation': await simulation(argv.slice(1)); break;
     case 'help':
     case '--help':
     case '-h':

package/content/integrations/crm.json

@@ -137,7 +137,8 @@
           "contact_type": "customer",
           "action_type": "setup"
         },
-        "actionLabel": "Test data loaded"
+        "actionLabel": "Test data loaded",
+        "hideUnlessAuthorized": true
       }
     }
   },

package/content/integrations/erp.json

@@ -133,7 +133,8 @@
         "staticExecution": {
           "action_type": "setup"
         },
-        "actionLabel": "Test data loaded"
+        "actionLabel": "Test data loaded",
+        "hideUnlessAuthorized": true
       }
     }
   },

package/content/integrations/mail.json

@@ -81,7 +81,8 @@
         "staticExecution": {
           "action_type": "setup"
         },
-        "actionLabel": "Test data loaded"
+        "actionLabel": "Test data loaded",
+        "hideUnlessAuthorized": true
       }
     }
   },

package/dist/control-plane/index.mjs

@@ -3545,6 +3545,11 @@ function selectDenials(records, opts = {}) {
   return { count, records: out };
 }
 
+// src/lib/simulation-mode.ts
+function isSimulationMode() {
+  return process.env.SUVEREN_SIMULATION === "1";
+}
+
 // src/index.ts
 (function migrateDataDir() {
   if (process.env.SUVEREN_DATA_DIR) return;
@@ -4159,6 +4164,9 @@ app.get("/health", async (req, res) => {
     updateAvailable: update.updateAvailable,
     installMethod: INSTALL_METHOD,
     spUrl: SP_URL,
+    // Purely local — the Authority Server never learns this. UI reads it to
+    // show a gateway-wide banner ("real systems are blocked").
+    simulation: isSimulationMode(),
     session: buildSessionHealth(vault),
     security: {
       note: "Gateway secures tool execution. Agent host isolation is the user's responsibility."

package/dist/mcp-server/http.mjs

@@ -2599,10 +2599,62 @@ function clampAgeFloor(requested, maxAgeDays, nowMs, format = "iso") {
 }
 
 // src/lib/tool-proxy.ts
-import { getProfile as getProfile3, ContentBindingError } from "@hap/core";
+import { getProfile as getProfile3, ContentBindingError, boundActionTypes as boundActionTypes2 } from "@hap/core";
 import { readFile } from "fs/promises";
 import { extname } from "path";
 import { randomUUID } from "crypto";
+
+// src/lib/manifest-loader.ts
+import { readFileSync as readFileSync12, existsSync as existsSync11 } from "fs";
+import { join as join11, resolve } from "path";
+var manifests = /* @__PURE__ */ new Map();
+function loadManifests(integrationsDir) {
+  const dir = resolve(
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join11(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+  );
+  const indexPath = join11(dir, "index.json");
+  if (!existsSync11(indexPath)) {
+    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
+    return 0;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync12(indexPath, "utf-8"));
+  } catch (err) {
+    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
+    return 0;
+  }
+  let loaded = 0;
+  for (const [id, relativePath] of Object.entries(index.integrations)) {
+    const manifestPath = join11(dir, relativePath);
+    try {
+      const manifest = JSON.parse(readFileSync12(manifestPath, "utf-8"));
+      manifests.set(id, manifest);
+      loaded++;
+    } catch (err) {
+      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
+    }
+  }
+  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
+  return loaded;
+}
+function getManifest(id) {
+  return manifests.get(id);
+}
+function getAllManifests() {
+  return Array.from(manifests.values());
+}
+
+// src/lib/simulation-mode.ts
+function isSimulationMode() {
+  return process.env.SUVEREN_SIMULATION === "1";
+}
+function manifestIsSimulated(manifest) {
+  return Boolean(manifest?.simulation);
+}
+var SIMULATION_BLOCK_REASON = "blocked: simulation mode \u2014 real systems are off";
+
+// src/lib/tool-proxy.ts
 var IMAGE_MIME = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -2662,6 +2714,38 @@ function applyMapping(m, value, execution) {
 function profileMatches(profileId, shortName) {
   return profileId === shortName || profileId.includes("/" + shortName + "@") || profileId.endsWith("/" + shortName);
 }
+function countBoundsFor(profileId, actionType) {
+  const fields = getProfile3(profileId)?.boundsSchema?.fields;
+  if (!fields) return null;
+  return Object.entries(fields).filter(([, def]) => def.boundType?.kind === "cumulative_count").filter(([name, def]) => {
+    const applies = boundActionTypes2(name, def);
+    return applies === void 0 || applies.includes(actionType);
+  }).map(([name]) => name);
+}
+function zeroCappedBound(profileId, bounds, actionType) {
+  if (typeof actionType !== "string") return null;
+  const names = countBoundsFor(profileId, actionType);
+  if (!names) return null;
+  for (const n of names) {
+    const v = bounds?.[n];
+    if (v !== void 0 && v !== "" && Number(v) <= 0) return n;
+  }
+  return null;
+}
+function toolIsAuthorizedForDisplay(tool, matchingAuths) {
+  if (!tool.gating?.hideUnlessAuthorized) return true;
+  if (matchingAuths.length === 0) return false;
+  const profileId = tool.gating.profile;
+  const actionType = tool.gating.staticExecution?.action_type;
+  if (!profileId || typeof actionType !== "string") return false;
+  const requiredFields = countBoundsFor(profileId, actionType);
+  if (!requiredFields) return false;
+  if (requiredFields.length === 0) return true;
+  return matchingAuths.some((a) => {
+    const bounds = a.bounds ?? a.frame;
+    return requiredFields.every((f) => Number(bounds?.[f] ?? 0) > 0);
+  });
+}
 function parseFirstJson(result) {
   const text = result.content?.find((c) => c.type === "text")?.text;
   if (typeof text !== "string") return void 0;
@@ -2687,6 +2771,15 @@ function denyRead(state2, tool, reason, detail, target) {
   return { content: [{ type: "text", text: `Read blocked by Gatekeeper: ${detail}` }], isError: true };
 }
 function createGatedToolHandler(tool, integrationManager2, state2) {
+  if (isSimulationMode() && !manifestIsSimulated(getManifest(tool.integrationId))) {
+    return async () => ({
+      content: [{
+        type: "text",
+        text: `Refused: "${tool.namespacedName}" talks to a real system, but this gateway is running in simulation mode (real systems are off). No ticket was requested.`
+      }],
+      isError: true
+    });
+  }
   const gated = createGatedToolHandlerInner(tool, integrationManager2, state2);
   const inner = async (args) => gated(normalizeIncomingArgs(tool, args));
   const blocked = tool.gating?.blockedArgs ?? [];
@@ -2962,7 +3055,10 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
         bounds: candidate.bounds,
         context: candidate.context
       });
-      if (result.approved) {
+      const capped = result.approved ? zeroCappedBound(candidate.profileId, candidate.bounds ?? candidate.frame, typeof execution.action_type === "string" ? execution.action_type : void 0) : null;
+      if (result.approved && capped) {
+        errors.push(`${candidate.path}: ${capped} is 0 \u2014 this mandate does not allow "${execution.action_type}"`);
+      } else if (result.approved) {
         passers.push(candidate);
       } else {
         const reasons = result.errors.map((e) => {
@@ -3998,9 +4094,10 @@ function createMcpServer(state2, integrationManager2) {
       const description = buildProxiedToolDescription(tool, state2);
       registered.update({ description });
       if (tool.gating?.profile) {
-        const hasAuth = auths.some(
+        const matchingAuths = auths.filter(
           (a) => a.complete && profileMatches(a.profileId, tool.gating.profile)
         );
+        const hasAuth = matchingAuths.length > 0 && toolIsAuthorizedForDisplay(tool, matchingAuths);
         if (hasAuth) registered.enable();
         else registered.disable();
       } else {
@@ -4041,16 +4138,16 @@ function verifyGateContentHashes(content, auth) {
 }
 
 // src/lib/integration-registry.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync11 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync12 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname9, join as join11 } from "path";
-var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join11(homedir8(), ".suveren");
+import { dirname as dirname9, join as join12 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join12(homedir8(), ".suveren");
 var IntegrationRegistry = class {
   integrations = /* @__PURE__ */ new Map();
   filePath;
   constructor(dataDir2) {
     const dir = dataDir2 ?? DEFAULT_DATA_DIR;
-    this.filePath = join11(dir, "integrations.json");
+    this.filePath = join12(dir, "integrations.json");
     this.load();
   }
   // ─── CRUD ───────────────────────────────────────────────────────────────
@@ -4081,12 +4178,12 @@ var IntegrationRegistry = class {
   }
   // ─── Load / Save ────────────────────────────────────────────────────────
   load() {
-    if (!existsSync11(this.filePath)) {
+    if (!existsSync12(this.filePath)) {
       mkdirSync9(dirname9(this.filePath), { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync12(this.filePath, "utf-8");
+      const raw = readFileSync13(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       const migrated = data.integrations.map((i) => {
         if ("toolGating" in i && !("profile" in i)) {
@@ -4129,47 +4226,6 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { getProfile as getProfile5 } from "@hap/core";
 
-// src/lib/manifest-loader.ts
-import { readFileSync as readFileSync13, existsSync as existsSync12 } from "fs";
-import { join as join12, resolve } from "path";
-var manifests = /* @__PURE__ */ new Map();
-function loadManifests(integrationsDir) {
-  const dir = resolve(
-    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join12(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
-  );
-  const indexPath = join12(dir, "index.json");
-  if (!existsSync12(indexPath)) {
-    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
-    return 0;
-  }
-  let index;
-  try {
-    index = JSON.parse(readFileSync13(indexPath, "utf-8"));
-  } catch (err) {
-    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
-    return 0;
-  }
-  let loaded = 0;
-  for (const [id, relativePath] of Object.entries(index.integrations)) {
-    const manifestPath = join12(dir, relativePath);
-    try {
-      const manifest = JSON.parse(readFileSync13(manifestPath, "utf-8"));
-      manifests.set(id, manifest);
-      loaded++;
-    } catch (err) {
-      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
-    }
-  }
-  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
-  return loaded;
-}
-function getManifest(id) {
-  return manifests.get(id);
-}
-function getAllManifests() {
-  return Array.from(manifests.values());
-}
-
 // src/lib/remote-auth-preflight.ts
 var AUTH_HEADER_RE = /^authorization:\s*(.+)$/i;
 function remotePreflightTarget(command, args) {
@@ -4477,10 +4533,21 @@ var IntegrationManager = class {
       if (opts.skipIfRunning) return existing.tools;
       await this.stopIntegrationLocked(config.id);
     }
+    if (isSimulationMode() && !manifestIsSimulated(getManifest(config.id))) {
+      throw new Error(`${config.id}: ${SIMULATION_BLOCK_REASON}`);
+    }
     if (config.npmPackage) {
       await this.ensureInstalled(config.npmPackage);
     }
     const env = this.resolveEnvKeys(config);
+    if (isSimulationMode()) {
+      const manifest = getManifest(config.id);
+      const simDecl = manifest?.simulation;
+      if (simDecl) {
+        const envVar = Object.entries(manifest.credentials.envMapping).find(([, credKey]) => credKey === simDecl.field)?.[0];
+        if (envVar) env[envVar] = "simulation";
+      }
+    }
     const interpolate = (s) => s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => env[name] ?? process.env[name] ?? "");
     const args = config.args.map(interpolate);
     const remote = remotePreflightTarget(config.command, args);
@@ -4655,7 +4722,15 @@ var IntegrationManager = class {
             name: config.name,
             running: false,
             toolCount: 0,
-            readAgeDays: readAgeOf(config)
+            readAgeDays: readAgeOf(config),
+            // Computed fresh, not cached: true whenever simulation mode is on
+            // AND this connector has no manifest `simulation` marker, which is
+            // exactly the condition startIntegrationLocked refuses under — so
+            // the UI always reflects why a real connector never started,
+            // without needing a separate error-tracking path for this one
+            // reason. Unrelated start failures still surface via the
+            // `warning` string returned by /internal/add-integration.
+            error: isSimulationMode() && !manifestIsSimulated(getManifest(config.id)) ? SIMULATION_BLOCK_REASON : void 0
           });
         }
       }
@@ -4749,7 +4824,8 @@ var IntegrationManager = class {
           read: ext.read,
           readGovernance: ext.readGovernance,
           readGovernanceReason: ext.readGovernanceReason,
-          blockedArgs: ext.blockedArgs
+          blockedArgs: ext.blockedArgs,
+          hideUnlessAuthorized: ext.hideUnlessAuthorized
         };
       }
       return {
@@ -4763,7 +4839,8 @@ var IntegrationManager = class {
         contentField: ext.contentField,
         blockedArgs: ext.blockedArgs,
         argEncoding: ext.argEncoding,
-        argNormalization: ext.argNormalization
+        argNormalization: ext.argNormalization,
+        hideUnlessAuthorized: ext.hideUnlessAuthorized
       };
     }
     return {