orkestrator 2.34.4-beta → 2.35.0-beta

package/resources/claude-bridge/dist/index.js

@@ -2666,14 +2666,30 @@ import { join as join2 } from "node:path";
 
 // ../../bridges/claude-bridge/src/services/claude-home.ts
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 var overrideHome = null;
+var overrideAccountHome;
+var CLAUDE_ACCOUNT_HOME_ENV = "ORKESTRATOR_CLAUDE_ACCOUNT_HOME";
 function claudeHome() {
   return overrideHome ?? homedir();
 }
 function claudeJsonPath() {
   return join(claudeHome(), ".claude.json");
 }
+function claudeAccountJsonPath() {
+  let home = overrideAccountHome;
+  if (home === undefined) {
+    if (overrideHome !== null)
+      return null;
+    const marked = process.env[CLAUDE_ACCOUNT_HOME_ENV]?.trim();
+    const configDir = process.env.CLAUDE_CONFIG_DIR?.trim();
+    home = marked && configDir && resolve(marked) === resolve(configDir) ? configDir : null;
+  }
+  if (!home)
+    return null;
+  const file = join(home, ".claude.json");
+  return resolve(file) === resolve(claudeJsonPath()) ? null : file;
+}
 function claudeUserSettingsPath() {
   const configDir = overrideHome === null ? process.env.CLAUDE_CONFIG_DIR?.trim() : undefined;
   return join(configDir || join(claudeHome(), ".claude"), "settings.json");
@@ -4117,6 +4133,43 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
 
+// ../protocol/src/native-agent-goal.ts
+var NATIVE_AGENT_GOAL_LIMITS = Object.freeze({
+  objectiveMaxChars: 4000,
+  checkMaxBytes: 4 * 1024,
+  reportMessageMaxBytes: 2 * 1024,
+  checkOutputMaxBytes: 8 * 1024,
+  statusDetailMaxBytes: 1024,
+  maxIterationsDefault: 20,
+  maxIterationsLimit: 100,
+  noProgressLimit: 3,
+  checkTimeoutDefaultMs: 10 * 60000,
+  checkTimeoutMaxMs: 30 * 60000,
+  verifierModelMaxChars: 200,
+  verifierTimeoutDefaultMs: 30 * 60000,
+  verdictSummaryMaxBytes: 2 * 1024,
+  verdictReasonsMax: 16,
+  verdictReasonMaxBytes: 512,
+  historyLimit: 5
+});
+var AGENT_GOAL_TOOL_NAMES = Object.freeze(["report_goal"]);
+var GOAL_QUALIFIED_PLATFORMS = Object.freeze([
+  "claude",
+  "codex",
+  "opencode",
+  "cursor",
+  "grok",
+  "pi"
+]);
+var GOAL_TOKEN_BUDGET_PLATFORMS = Object.freeze([
+  "claude",
+  "codex",
+  "opencode",
+  "cursor",
+  "grok",
+  "pi"
+]);
+
 // ../protocol/src/native-agent-transcript-patch.ts
 var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 
@@ -4517,6 +4570,7 @@ var PROJECTION_FIELD_SET = new Set([
   "queue",
   "asyncQuestionResponses",
   "contextUsage",
+  "goal",
   "rateLimits",
   "runtime",
   "runtimeHealthAuthoritative",
@@ -4541,6 +4595,7 @@ var OPTIONAL_PROJECTION_FIELD_SET = new Set([
   "queue",
   "asyncQuestionResponses",
   "contextUsage",
+  "goal",
   "rateLimits",
   "runtime",
   "runtimeHealthAuthoritative",
@@ -4642,6 +4697,15 @@ async function runtimeEnvironmentForSessionQuery(policy, env = process.env, opti
   const ghConfigDir = await (options.ghConfigDir ?? emptyGhConfigDir)();
   return withheldGitHubCredentialEnvironment(env, { ghConfigDir });
 }
+var UNATTENDED_OVERLOAD_RETRY_ENV = {
+  CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS: "4000",
+  CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS: "64000"
+};
+function withUnattendedOverloadRetry(sessionPolicy, environment) {
+  if (sessionPolicy?.id !== "pipeline")
+    return environment;
+  return { ...UNATTENDED_OVERLOAD_RETRY_ENV, ...environment };
+}
 
 // ../../bridges/claude-bridge/src/services/coordinator-skills.ts
 import { createHash as createHash4, randomBytes } from "node:crypto";
@@ -4669,16 +4733,19 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "add_ticket_comment",
   "address_multi_review",
   "adopt_workflow",
+  "answer_worker_question",
   "cancel_build_pipeline",
   "cancel_graph_run",
   "cancel_multi_review",
   "cancel_schedule",
+  "clear_worker_goal",
   "compare_project_files",
   "create_pr",
   "create_schedule",
   "create_ticket",
   "custom_fix_multi_review",
   "edit_worker_tab",
+  "fork_worker",
   "get_build_pipeline",
   "get_environment",
   "get_feature_plan",
@@ -4691,6 +4758,9 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "get_tab_state",
   "get_tab_transcript",
   "get_ticket",
+  "get_usage_limits",
+  "get_worker_changes",
+  "get_worker_goal",
   "launch_environment",
   "launch_feature_plan",
   "launch_graph",
@@ -4705,14 +4775,18 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "list_node_environments",
   "list_nodes",
   "list_projects",
+  "list_provider_accounts",
   "list_schedules",
   "list_tabs",
   "list_tickets",
+  "list_worker_commands",
   "list_workflows",
   "open_multi_review",
   "open_multi_review_fix",
   "open_worker_browser",
   "pause_build_pipeline",
+  "pause_schedule",
+  "pause_worker_goal",
   "propose_agents_md_update",
   "read_messages",
   "read_node_environment",
@@ -4721,18 +4795,26 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "request_project_file_update",
   "request_project_on_node",
   "request_root_changes",
+  "resolve_conflicts",
   "resume_build_pipeline",
+  "resume_schedule",
+  "run_worker_command",
   "send_message",
   "send_node_message",
   "send_prompt_to_node_tab",
   "send_prompt_to_tab",
+  "set_worker_goal",
   "start_build_pipeline",
   "start_environment",
   "start_multi_review",
   "start_node_environment",
   "stop_environment",
   "stop_node_environment",
+  "stop_worker_turn",
+  "switch_provider_account",
+  "set_account_auto_switch",
   "transfer_files",
+  "update_schedule",
   "update_ticket"
 ]);
 
@@ -8783,6 +8865,8 @@ function claudeLaunchConflict(runtime, request) {
     return "adaptive thinking";
   if (request.bypassCapable && !runtime.bypassCapable)
     return "bypass permission capability";
+  if (request.repositoryInstructions !== undefined && runtime.repositoryInstructions !== request.repositoryInstructions)
+    return "repository instructions";
   if (request.plugins !== undefined && runtime.plugins !== request.plugins)
     return "plugins";
   if (request.credentials !== undefined && runtime.credentials !== request.credentials)
@@ -8931,7 +9015,7 @@ function noMessages() {
 // ../../bridges/claude-bridge/src/services/session-manager-persistence.ts
 import { constants as constants2 } from "node:fs";
 import { lstat as lstat2, open as open2, realpath as realpath2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join10, relative, resolve as resolve2, sep } from "node:path";
+import { isAbsolute as isAbsolute3, join as join10, relative, resolve as resolve3, sep } from "node:path";
 
 // ../protocol/src/node/command-change-journal.ts
 import { appendFile, mkdir as mkdir3, readFile as readFile5, rename as rename3, rm as rm3, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
@@ -9088,7 +9172,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import { rmSync } from "node:fs";
 import { copyFile, lstat, mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { delimiter as delimiter2, isAbsolute as isAbsolute2, join as join6, resolve } from "node:path";
+import { delimiter as delimiter2, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
 var DEFAULT_MAX_UNTRACKED_FILE_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_UNTRACKED_FILES = 5000;
 var DEFAULT_SLOW_SNAPSHOT_MS = 500;
@@ -9370,8 +9454,8 @@ class WorkspaceChangeProbe {
           return;
         return {
           root,
-          indexPath: isAbsolute2(index) ? index : resolve(cwd, index),
-          objectsPath: isAbsolute2(objects) ? objects : resolve(cwd, objects)
+          indexPath: isAbsolute2(index) ? index : resolve2(cwd, index),
+          objectsPath: isAbsolute2(objects) ? objects : resolve2(cwd, objects)
         };
       }).catch(() => {
         return;
@@ -11777,13 +11861,13 @@ class ClaudeAttachmentError extends Error {
 var BRIDGE_ATTACHMENT_ROOT_ENV = "ORKESTRATOR_BRIDGE_ATTACHMENT_ROOT";
 function configuredAttachmentRoot(env = process.env) {
   const value = env[BRIDGE_ATTACHMENT_ROOT_ENV]?.trim();
-  return value && isAbsolute3(value) ? resolve2(value) : undefined;
+  return value && isAbsolute3(value) ? resolve3(value) : undefined;
 }
 function attachmentContainmentRoot(filePath, cwd, extraRoot = configuredAttachmentRoot()) {
-  if (extraRoot && isAbsolute3(filePath) && isPathWithin2(extraRoot, resolve2(filePath))) {
+  if (extraRoot && isAbsolute3(filePath) && isPathWithin2(extraRoot, resolve3(filePath))) {
     return extraRoot;
   }
-  return resolve2(cwd);
+  return resolve3(cwd);
 }
 function isPathWithin2(rootPath, targetPath) {
   const childPath = relative(rootPath, targetPath);
@@ -11831,7 +11915,7 @@ async function assertOpenedWorkspaceFile(targetPath, canonicalRoot, openedStats)
 }
 async function readWorkspaceImageAttachment(filePath, cwd, afterSymlinkValidation, afterCanonicalValidation, afterInitialValidation) {
   const lexicalRoot = attachmentContainmentRoot(filePath, cwd);
-  const targetPath = isAbsolute3(filePath) ? resolve2(filePath) : resolve2(lexicalRoot, filePath);
+  const targetPath = isAbsolute3(filePath) ? resolve3(filePath) : resolve3(lexicalRoot, filePath);
   if (!isPathWithin2(lexicalRoot, targetPath)) {
     throw new ClaudeAttachmentError("attachment_outside_workspace", "Image attachment must be contained in the current workspace.");
   }
@@ -13605,7 +13689,11 @@ function claudeUserMcpQueryOptions(policy) {
 async function loadScopedMcpServers(cwd, scope) {
   if (scope === "none") {
     const sources = { user: "excluded", project: "excluded" };
-    return { configs: {}, revision: { fingerprint: revisionFingerprint(sources), sources, scope } };
+    return {
+      configs: {},
+      layers: new Map,
+      revision: { fingerprint: revisionFingerprint(sources), sources, scope }
+    };
   }
   const path = claudeJsonPath();
   const [global2, projectGlobal, projectLocal] = await Promise.all([
@@ -13618,11 +13706,33 @@ async function loadScopedMcpServers(cwd, scope) {
     ...projectGlobal?.value,
     ...projectLocal?.value
   };
+  const layers = new Map;
+  for (const name of Object.keys(global2.value ?? {}))
+    layers.set(name, "user");
+  for (const name of Object.keys(projectGlobal?.value ?? {}))
+    layers.set(name, "local");
+  for (const name of Object.keys(projectLocal?.value ?? {}))
+    layers.set(name, "project");
   const sources = {
     user: sourceDigest(global2.digest),
     project: projectLocal ? sourceDigest(projectLocal.digest) : "excluded"
   };
-  return { configs, revision: { fingerprint: revisionFingerprint(sources), sources, scope } };
+  return {
+    configs,
+    layers,
+    revision: { fingerprint: revisionFingerprint(sources), sources, scope }
+  };
+}
+async function claudeAccountOnlyMcpServerNames(cwd, settingSources, declared, strictMcpConfig = false) {
+  const path = claudeAccountJsonPath();
+  if (!path || strictMcpConfig)
+    return [];
+  const [user, local] = await Promise.all([
+    settingSources.includes("user") ? readJsonSliceCached(path, "mcpServers", (config) => config?.mcpServers) : undefined,
+    settingSources.includes("local") ? readJsonSliceCached(path, `projects:${cwd}:mcpServers`, (config) => config?.projects?.[cwd]?.mcpServers) : undefined
+  ]);
+  const names = new Set([...Object.keys(user ?? {}), ...Object.keys(local ?? {})]);
+  return Array.from(names).filter((name) => !declared.has(name)).sort();
 }
 function revisionFingerprint(sources) {
   return createHash9("sha256").update(`user=${sources.user}\x00project=${sources.project}`).digest("base64url");
@@ -13631,21 +13741,28 @@ async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources =
   const scoped = await loadScopedMcpServers(cwd, normalizeScope(sources));
   const { revision } = scoped;
   const configs = allowConfigured ? Object.fromEntries(Object.entries(scoped.configs).filter(([name]) => allowConfigured(name))) : scoped.configs;
-  const agentServer = getOrkestratorAgentMcpServerFromConnection(connection) ?? getOrkestratorAgentMcpServer(env);
   const servers = toSdkServers(configs);
+  const layers = new Map(Array.from(scoped.layers).filter(([name]) => Object.hasOwn(servers, name)));
+  const agentServer = getOrkestratorAgentMcpServerFromConnection(connection) ?? getOrkestratorAgentMcpServer(env);
   if (agentServer) {
     servers[AGENT_MCP_SERVER_NAME] = agentServer;
-    if (connection?.design)
+    layers.set(AGENT_MCP_SERVER_NAME, "orkestrator");
+    if (connection?.design) {
       servers["orkestrator-design"] = {
         ...agentServer,
         url: new URL("/design-mcp", agentServer.url).toString()
       };
+      layers.set("orkestrator-design", "orkestrator");
+    }
   }
   const artifactServer = getOrkestratorArtifactMcpServer(connection);
-  if (artifactServer)
+  if (artifactServer) {
     servers[ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME] = artifactServer;
-  else
+    layers.set(ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME, "orkestrator");
+  } else {
     delete servers[ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME];
+    layers.delete(ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME);
+  }
   const research = normalizeScope(sources) === "none" ? coordinatorResearchMcpServersFromEnv(env) : [];
   for (const server of research)
     servers[server.name] = { type: "http", url: server.url };
@@ -13657,6 +13774,7 @@ async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources =
       ...artifactServer ? [ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME] : [],
       ...research.map((server) => server.name)
     ]),
+    layers,
     revision
   };
 }
@@ -13664,130 +13782,508 @@ async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources =
 // ../../bridges/claude-bridge/src/services/session-manager-commands.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 
-// ../protocol/src/agent-command-catalogue.ts
-var NATIVE_AGENT_COMMAND_CATALOGUE_VERSION = 1;
-var COMMAND_CATALOGUE_LIMITS = Object.freeze({
-  maxCommands: 512,
-  maxNameBytes: 256,
-  maxIdBytes: 256,
-  maxAliasesPerCommand: 16,
-  maxAliasesTotal: 2048,
-  maxDescriptionBytes: 1000,
-  maxArgumentHintBytes: 512,
-  maxAvailabilityMessageBytes: 512,
-  maxBindingRevisionBytes: 128,
-  maxWireBytes: 512 * 1024,
-  maxArgumentBytes: 256 * 1024
-});
-var SOURCES = new Set([
-  "builtin",
-  "project",
-  "user",
-  "plugin",
-  "skill",
-  "template",
-  "extension",
-  "orkestrator",
-  "unknown"
-]);
-var EXECUTION_KINDS = new Set(NATIVE_AGENT_COMMAND_EXECUTION_KINDS);
-var ORIGINS2 = new Set(NATIVE_AGENT_COMMAND_ORIGINS);
-var UNAVAILABLE_REASONS = new Set(NATIVE_AGENT_COMMAND_UNAVAILABLE_REASONS);
-var ERROR_CODES = new Set(NATIVE_AGENT_COMMAND_CATALOGUE_ERROR_CODES);
-var encoder = new TextEncoder;
-function utf8ByteLength(value) {
-  if (/^[\x00-\x7f]*$/.test(value))
-    return value.length;
-  return encoder.encode(value).byteLength;
+// ../../bridges/claude-bridge/src/services/claude-model-catalog.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join12 } from "node:path";
+import { stat as stat5 } from "node:fs/promises";
+
+// ../../bridges/claude-bridge/src/services/live-claude-control.ts
+var LIVE_CLAUDE_READ_TIMEOUT_MS = 5000;
+function readsProbeSettings(settingSources) {
+  if (settingSources === undefined)
+    return false;
+  try {
+    const sources = JSON.parse(settingSources);
+    return Array.isArray(sources) && ["user", "project", "local"].every((source) => sources.includes(source));
+  } catch {
+    return false;
+  }
 }
-function truncateUtf8(value, maxBytes) {
-  if (utf8ByteLength(value) <= maxBytes)
-    return value;
-  const marker = "…";
-  const budget = Math.max(0, maxBytes - utf8ByteLength(marker));
-  let bytes = 0;
-  let out = "";
-  for (const char of value) {
-    const size = utf8ByteLength(char);
-    if (bytes + size > budget)
-      break;
-    bytes += size;
-    out += char;
+function liveClaudeControls() {
+  const runtimes = [];
+  for (const session of sessions.values()) {
+    const runtime = session.claudeRuntime;
+    if (runtime?.state !== "open" || runtime.abortController.signal.aborted)
+      continue;
+    if (session.queryControlDraining === runtime.control || session.deleting)
+      continue;
+    if (!readsProbeSettings(runtime.launch.settingSources))
+      continue;
+    runtimes.push(runtime);
   }
-  return `${out}${marker}`;
+  return runtimes.sort((left, right) => right.lastFrameAt - left.lastFrameAt).map((runtime) => runtime.control);
 }
-function commandBindingRevision(parts) {
-  let hash = 0xcbf29ce484222325n;
-  const prime = 0x100000001b3n;
-  const mask = 0xffffffffffffffffn;
-  for (const part of parts) {
-    for (const byte of encoder.encode(part)) {
-      hash ^= BigInt(byte);
-      hash = hash * prime & mask;
+async function readFromLiveClaude(read, timeoutMs = LIVE_CLAUDE_READ_TIMEOUT_MS) {
+  for (const control of liveClaudeControls()) {
+    let timer;
+    try {
+      const answer = read(control);
+      if (answer === undefined)
+        continue;
+      answer.catch(() => {
+        return;
+      });
+      const value = await Promise.race([
+        answer,
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(undefined), timeoutMs);
+        })
+      ]);
+      if (value !== undefined)
+        return value;
+    } catch (error) {
+      debugLog("[live-claude-control] A running CLI could not answer:", error);
+    } finally {
+      clearTimeout(timer);
     }
-    hash ^= 0xffn;
-    hash = hash * prime & mask;
   }
-  return hash.toString(16).padStart(16, "0");
-}
-function isRecord2(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  return;
 }
-function boundedIdentity(value, maxBytes) {
-  if (typeof value !== "string")
-    return;
-  if (value.length === 0 || value.trim() !== value || /\s/.test(value))
+function liveInitializationResult(control) {
+  if (typeof control.initializationResult !== "function")
     return;
-  return utf8ByteLength(value) <= maxBytes ? value : undefined;
+  return control.initializationResult().then((result) => result && typeof result === "object" ? result : undefined);
 }
-function boundedText(value, maxBytes) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  return trimmed ? truncateUtf8(trimmed, maxBytes) : undefined;
+
+// ../../bridges/claude-bridge/src/services/claude-sign-in.ts
+var AUTH_CACHE_TTL_MS = 30000;
+var FAILED_AUTH_CACHE_TTL_MS = 5000;
+var CLAUDE_SIGN_IN = {
+  kind: "terminal",
+  hint: "Sign in to Claude from the sign-in card in this tab or from Settings → Claude."
+};
+var CLAUDE_SIGN_IN_REQUIRED_MESSAGE = "Claude isn't signed in. Sign in to Claude to keep working.";
+var authCache;
+var authRead;
+var authReadGeneration;
+var authRefreshPending = false;
+var authGeneration = 0;
+var turnAuthenticationFailedUntil = 0;
+var reuseLiveAccounts = true;
+function withTurnFailure(value) {
+  return Date.now() < turnAuthenticationFailedUntil && value.state === "signed-in" ? { ...value, state: "expired" } : value;
 }
-function displayCommandName(name) {
-  return name.startsWith("/") || name.startsWith("$") ? name : `/${name}`;
+function presentSource(value) {
+  return value && value !== "none" ? value : undefined;
 }
-function normalizeAvailability(value) {
-  if (!isRecord2(value))
-    return;
-  if (typeof value.state !== "string")
-    return;
-  const reason = typeof value.reason === "string" && UNAVAILABLE_REASONS.has(value.reason) ? value.reason : undefined;
-  const message = boundedText(value.message, COMMAND_CATALOGUE_LIMITS.maxAvailabilityMessageBytes);
-  if (value.state === "available")
-    return { state: "available" };
+function normalizeClaudeAccount(account) {
+  const source = presentSource(account.apiKeySource) ?? presentSource(account.tokenSource);
+  const externalProvider = account.apiProvider && account.apiProvider !== "firstParty" ? account.apiProvider : undefined;
+  const signedIn = Boolean(source || account.subscriptionType || account.organization || externalProvider);
+  const label = account.organization || account.subscriptionType || externalProvider;
   return {
-    state: "unavailable",
-    reason: reason ?? "unsupported",
-    ...message ? { message } : {}
+    state: signedIn ? "signed-in" : "needs-auth",
+    ...label ? {
+      account: {
+        label,
+        ...account.subscriptionType ? { plan: account.subscriptionType } : {}
+      }
+    } : {},
+    signIn: CLAUDE_SIGN_IN,
+    signOut: false
   };
 }
-function normalizeInputPolicy(value) {
-  if (!isRecord2(value))
-    return;
-  const policy = {};
-  if (value.arguments === "none" || value.arguments === "optional" || value.arguments === "required") {
-    policy.arguments = value.arguments;
-  }
-  if (value.attachments === "none" || value.attachments === "images" || value.attachments === "any") {
-    policy.attachments = value.attachments;
+function claudeAccountKey(status) {
+  return JSON.stringify([status.state, status.account?.label, status.account?.plan]);
+}
+function claudeObservedAccountKey() {
+  const value = authCache?.value;
+  return value && value.state !== "unknown" ? claudeAccountKey(value) : undefined;
+}
+function liveSignedInAccount() {
+  return readFromLiveClaude((control) => liveInitializationResult(control)?.then((result) => {
+    const account = result?.account;
+    if (!account || typeof account !== "object")
+      return;
+    const status = normalizeClaudeAccount(account);
+    return status.state === "signed-in" ? status : undefined;
+  }));
+}
+async function probeAccount() {
+  if (reuseLiveAccounts) {
+    const live = await liveSignedInAccount();
+    if (live && reuseLiveAccounts)
+      return live;
   }
-  if (value.busy === "queue" || value.busy === "idle" || value.busy === "running") {
-    policy.busy = value.busy;
+  let probe;
+  try {
+    probe = controlOnlyQuery({
+      cwd: process.env.CWD || process.cwd(),
+      env: { ...process.env },
+      ...claudeExecutableOptions()
+    });
+    return normalizeClaudeAccount(await probe.accountInfo());
+  } finally {
+    await Promise.resolve(probe?.close()).catch(() => {
+      return;
+    });
   }
-  return Object.keys(policy).length > 0 ? policy : undefined;
 }
-function normalizeCommandCataloguePayload(payload, options = {}) {
-  const record = isRecord2(payload) ? payload : {};
-  const enhanced = record.catalogueVersion === NATIVE_AGENT_COMMAND_CATALOGUE_VERSION;
-  const rows = Array.isArray(record.commands) ? record.commands : [];
-  const byId = new Map;
-  let truncated = record.truncated === true || rows.length > COMMAND_CATALOGUE_LIMITS.maxCommands;
-  let rejected = 0;
-  let aliasBudget = COMMAND_CATALOGUE_LIMITS.maxAliasesTotal;
-  for (const candidate of rows.slice(0, COMMAND_CATALOGUE_LIMITS.maxCommands)) {
+function readClaudeAuthStatus() {
+  if (authCache && authCache.expiresAt > Date.now()) {
+    return Promise.resolve(withTurnFailure(authCache.value));
+  }
+  if (authRead)
+    return authRead;
+  const generation = authGeneration;
+  const read = probeAccount().then((value) => ({ value, ttl: AUTH_CACHE_TTL_MS }), () => ({
+    value: {
+      state: "unknown",
+      signIn: CLAUDE_SIGN_IN,
+      signOut: false
+    },
+    ttl: FAILED_AUTH_CACHE_TTL_MS
+  })).then(({ value, ttl }) => {
+    if (generation === authGeneration) {
+      authCache = { expiresAt: Date.now() + ttl, value };
+    }
+    return withTurnFailure(value);
+  }).finally(() => {
+    if (authRead !== read)
+      return;
+    authRead = undefined;
+    authReadGeneration = undefined;
+    if (authRefreshPending) {
+      authRefreshPending = false;
+      readClaudeAuthStatus();
+    }
+  });
+  authReadGeneration = generation;
+  authRead = read;
+  return read;
+}
+function noteClaudeAuthenticationFailure() {
+  reuseLiveAccounts = false;
+  turnAuthenticationFailedUntil = Date.now() + AUTH_CACHE_TTL_MS;
+  authCache = undefined;
+  if (authRead && authReadGeneration !== authGeneration)
+    authRefreshPending = true;
+  readClaudeAuthStatus();
+}
+function noteClaudeAuthenticationWorked() {
+  reuseLiveAccounts = true;
+  authGeneration += 1;
+  authRefreshPending = false;
+  turnAuthenticationFailedUntil = 0;
+  if (authCache?.value.state === "needs-auth")
+    authCache = undefined;
+}
+function claudeReadiness() {
+  const cached = authCache;
+  if (cached?.value.state !== "needs-auth")
+    return;
+  if (cached.expiresAt <= Date.now())
+    readClaudeAuthStatus();
+  return {
+    state: "authentication-required",
+    message: CLAUDE_SIGN_IN_REQUIRED_MESSAGE,
+    signIn: CLAUDE_SIGN_IN
+  };
+}
+
+// ../../bridges/claude-bridge/src/services/claude-model-catalog.ts
+var CLAUDE_MODEL_CACHE_TTL_MS = 60 * 60000;
+var CLAUDE_MODEL_PROBE_TIMEOUT_MS = 25000;
+var remembered;
+var liveAnswers = new WeakMap;
+var invalidLiveAnswers = new WeakSet;
+var generation = 0;
+var probe;
+function invalidateClaudeModelCatalog() {
+  for (const control of liveClaudeControls())
+    invalidLiveAnswers.add(control);
+  remembered = undefined;
+  generation += 1;
+}
+function catalogModels(models) {
+  return models.map((model) => ({
+    id: model.value,
+    resolvedModel: model.resolvedModel,
+    name: model.displayName,
+    description: model.description,
+    supportsFastMode: model.supportsFastMode,
+    supportsEffort: model.supportsEffort,
+    supportedEffortLevels: model.supportedEffortLevels,
+    supportsAdaptiveThinking: model.supportsAdaptiveThinking,
+    supportsAutoMode: model.supportsAutoMode
+  }));
+}
+async function claudeCliIdentity() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join12(homedir2(), ".claude");
+  const executable = process.env.CLAUDE_CLI_PATH?.trim();
+  const resolved = executable ? Bun.which(executable, { PATH: process.env.PATH }) || executable : undefined;
+  const cwd = process.env.CWD || process.cwd();
+  const paths = [
+    resolved,
+    join12(configDir, "settings.json"),
+    join12(cwd, ".claude/settings.json"),
+    join12(cwd, ".claude/settings.local.json")
+  ];
+  const files = await Promise.all(paths.map(async (path) => {
+    const file = path ? await stat5(path).catch(() => {
+      return;
+    }) : undefined;
+    return [path, file?.size, file?.mtimeMs, file?.ctimeMs];
+  }));
+  return JSON.stringify([configDir, cwd, files]);
+}
+function accountKeyOf(account) {
+  if (!account || typeof account !== "object")
+    return;
+  return claudeAccountKey(normalizeClaudeAccount(account));
+}
+async function rememberModels(models, account, at = generation, cli, expiresAt) {
+  if (!account || typeof account !== "object" || models.length === 0)
+    return;
+  const status = normalizeClaudeAccount(account);
+  if (status.state !== "signed-in")
+    return;
+  const identity = cli ?? await claudeCliIdentity();
+  if (at !== generation)
+    return;
+  remembered = {
+    cli: identity,
+    account: claudeAccountKey(status),
+    models,
+    expiresAt: expiresAt ?? Date.now() + CLAUDE_MODEL_CACHE_TTL_MS
+  };
+}
+async function rememberedModels() {
+  const entry = remembered;
+  if (!entry || entry.expiresAt <= Date.now())
+    return;
+  const observed = claudeObservedAccountKey();
+  if (observed !== undefined && observed !== entry.account)
+    return;
+  return entry.cli === await claudeCliIdentity() ? entry.models : undefined;
+}
+async function liveModels() {
+  const observed = claudeObservedAccountKey();
+  const at = generation;
+  const cli = await claudeCliIdentity();
+  return readFromLiveClaude(async (control) => {
+    if (invalidLiveAnswers.has(control))
+      return;
+    let identity = liveAnswers.get(control);
+    if (!identity) {
+      identity = { cli, expiresAt: Date.now() + CLAUDE_MODEL_CACHE_TTL_MS };
+      liveAnswers.set(control, identity);
+    }
+    if (identity.cli !== cli || identity.expiresAt <= Date.now())
+      return;
+    const result = await liveInitializationResult(control);
+    if (at !== generation || invalidLiveAnswers.has(control))
+      return;
+    if (!Array.isArray(result?.models) || result.models.length === 0)
+      return;
+    const account = accountKeyOf(result.account);
+    if (observed !== undefined && account !== undefined && account !== observed)
+      return;
+    return { models: result.models, account: result.account, at, ...identity };
+  });
+}
+function fallbackCatalog() {
+  return {
+    source: "fallback",
+    models: CLAUDE_FALLBACK_MODEL_CATALOG.map((model) => ({
+      ...model,
+      ...model.supportedEffortLevels ? { supportedEffortLevels: [...model.supportedEffortLevels] } : {}
+    }))
+  };
+}
+async function probeModels(at) {
+  let q;
+  let timer;
+  try {
+    const cwd = process.env.CWD || process.cwd();
+    debugLog("[session-manager] Fetching supported models", { cwd });
+    q = controlOnlyQuery({
+      cwd,
+      env: { ...process.env },
+      ...claudeExecutableOptions()
+    });
+    const control = q;
+    const answer = Promise.all([
+      control.supportedModels(),
+      typeof control.accountInfo === "function" ? control.accountInfo().catch(() => {
+        return;
+      }) : undefined
+    ]);
+    answer.catch(() => {
+      return;
+    });
+    const [models, account] = await Promise.race([
+      answer,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("The model probe did not answer in time")), CLAUDE_MODEL_PROBE_TIMEOUT_MS);
+      })
+    ]);
+    debugLog("[session-manager] Supported models fetched", { count: models.length });
+    await rememberModels(models, account, at);
+    return { source: "sdk", models: catalogModels(models) };
+  } catch (error) {
+    console.error("[session-manager] Error fetching supported models:", error);
+    return fallbackCatalog();
+  } finally {
+    clearTimeout(timer);
+    if (q?.return) {
+      try {
+        await q.return();
+      } catch (error) {
+        debugLog("[session-manager] Failed to clean up model query:", error);
+      }
+    }
+  }
+}
+function sharedProbe() {
+  if (probe?.generation === generation)
+    return probe.read;
+  const read = probeModels(generation).finally(() => {
+    if (probe?.read === read)
+      probe = undefined;
+  });
+  probe = { generation, read };
+  return read;
+}
+async function getAvailableModelCatalog() {
+  const live = liveClaudeControls().length ? await liveModels() : undefined;
+  if (live) {
+    debugLog("[session-manager] Supported models read from a running CLI", {
+      count: live.models.length
+    });
+    await rememberModels(live.models, live.account, live.at, live.cli, live.expiresAt);
+    return { source: "sdk", models: catalogModels(live.models) };
+  }
+  const known = await rememberedModels();
+  if (known)
+    return { source: "sdk", models: catalogModels(known) };
+  return sharedProbe();
+}
+
+// ../protocol/src/agent-command-catalogue.ts
+var NATIVE_AGENT_COMMAND_CATALOGUE_VERSION = 1;
+var COMMAND_CATALOGUE_LIMITS = Object.freeze({
+  maxCommands: 512,
+  maxNameBytes: 256,
+  maxIdBytes: 256,
+  maxAliasesPerCommand: 16,
+  maxAliasesTotal: 2048,
+  maxDescriptionBytes: 1000,
+  maxArgumentHintBytes: 512,
+  maxAvailabilityMessageBytes: 512,
+  maxBindingRevisionBytes: 128,
+  maxWireBytes: 512 * 1024,
+  maxArgumentBytes: 256 * 1024
+});
+var SOURCES = new Set([
+  "builtin",
+  "project",
+  "user",
+  "plugin",
+  "skill",
+  "template",
+  "extension",
+  "orkestrator",
+  "unknown"
+]);
+var EXECUTION_KINDS = new Set(NATIVE_AGENT_COMMAND_EXECUTION_KINDS);
+var ORIGINS2 = new Set(NATIVE_AGENT_COMMAND_ORIGINS);
+var UNAVAILABLE_REASONS = new Set(NATIVE_AGENT_COMMAND_UNAVAILABLE_REASONS);
+var ERROR_CODES = new Set(NATIVE_AGENT_COMMAND_CATALOGUE_ERROR_CODES);
+var encoder = new TextEncoder;
+function utf8ByteLength(value) {
+  if (/^[\x00-\x7f]*$/.test(value))
+    return value.length;
+  return encoder.encode(value).byteLength;
+}
+function truncateUtf8(value, maxBytes) {
+  if (utf8ByteLength(value) <= maxBytes)
+    return value;
+  const marker = "…";
+  const budget = Math.max(0, maxBytes - utf8ByteLength(marker));
+  let bytes = 0;
+  let out = "";
+  for (const char of value) {
+    const size = utf8ByteLength(char);
+    if (bytes + size > budget)
+      break;
+    bytes += size;
+    out += char;
+  }
+  return `${out}${marker}`;
+}
+function commandBindingRevision(parts) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (const part of parts) {
+    for (const byte of encoder.encode(part)) {
+      hash ^= BigInt(byte);
+      hash = hash * prime & mask;
+    }
+    hash ^= 0xffn;
+    hash = hash * prime & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function boundedIdentity(value, maxBytes) {
+  if (typeof value !== "string")
+    return;
+  if (value.length === 0 || value.trim() !== value || /\s/.test(value))
+    return;
+  return utf8ByteLength(value) <= maxBytes ? value : undefined;
+}
+function boundedText(value, maxBytes) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed ? truncateUtf8(trimmed, maxBytes) : undefined;
+}
+function displayCommandName(name) {
+  return name.startsWith("/") || name.startsWith("$") ? name : `/${name}`;
+}
+function normalizeAvailability(value) {
+  if (!isRecord2(value))
+    return;
+  if (typeof value.state !== "string")
+    return;
+  const reason = typeof value.reason === "string" && UNAVAILABLE_REASONS.has(value.reason) ? value.reason : undefined;
+  const message = boundedText(value.message, COMMAND_CATALOGUE_LIMITS.maxAvailabilityMessageBytes);
+  if (value.state === "available")
+    return { state: "available" };
+  return {
+    state: "unavailable",
+    reason: reason ?? "unsupported",
+    ...message ? { message } : {}
+  };
+}
+function normalizeInputPolicy(value) {
+  if (!isRecord2(value))
+    return;
+  const policy = {};
+  if (value.arguments === "none" || value.arguments === "optional" || value.arguments === "required") {
+    policy.arguments = value.arguments;
+  }
+  if (value.attachments === "none" || value.attachments === "images" || value.attachments === "any") {
+    policy.attachments = value.attachments;
+  }
+  if (value.busy === "queue" || value.busy === "idle" || value.busy === "running") {
+    policy.busy = value.busy;
+  }
+  return Object.keys(policy).length > 0 ? policy : undefined;
+}
+function normalizeCommandCataloguePayload(payload, options = {}) {
+  const record = isRecord2(payload) ? payload : {};
+  const enhanced = record.catalogueVersion === NATIVE_AGENT_COMMAND_CATALOGUE_VERSION;
+  const rows = Array.isArray(record.commands) ? record.commands : [];
+  const byId = new Map;
+  let truncated = record.truncated === true || rows.length > COMMAND_CATALOGUE_LIMITS.maxCommands;
+  let rejected = 0;
+  let aliasBudget = COMMAND_CATALOGUE_LIMITS.maxAliasesTotal;
+  for (const candidate of rows.slice(0, COMMAND_CATALOGUE_LIMITS.maxCommands)) {
     const row = typeof candidate === "string" ? { name: candidate } : candidate;
     if (!isRecord2(row)) {
       rejected += 1;
@@ -13968,7 +14464,7 @@ function idleSteerPromptReply(prompt, agentLabel) {
 
 // ../../bridges/claude-bridge/src/services/claude-terminal-commands.ts
 import { mkdir as mkdir5, readFile as readFile6, rename as rename5, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 var FILE_NAME = "terminal-slash-commands.json";
 var MAX_VERSIONS = 4;
 var MAX_NAMES = 512;
@@ -13979,7 +14475,7 @@ var dirty = false;
 var entries = [];
 var writes = Promise.resolve();
 function filePath() {
-  return join12(claudeOrkestratorDir(), FILE_NAME);
+  return join13(claudeOrkestratorDir(), FILE_NAME);
 }
 function validVersion(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_VERSION_LENGTH;
@@ -14031,84 +14527,26 @@ function recordTerminalSlashCommands(version, commands) {
     { version, commands: names },
     ...entries.filter((entry) => entry.version !== version)
   ].slice(0, MAX_VERSIONS);
-  writes = writes.then(async () => {
-    await load();
-    const directory = claudeOrkestratorDir();
-    await mkdir5(directory, { recursive: true });
-    const target = filePath();
-    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
-    const snapshot = entries;
-    await writeFile5(temporary, `${JSON.stringify({ versions: snapshot })}
-`, {
-      mode: 384
-    });
-    await rename5(temporary, target);
-    if (entries === snapshot)
-      dirty = false;
-  }).catch(() => {});
-}
-
-// ../../bridges/claude-bridge/src/services/session-manager-catalog.ts
-import { createHash as createHash10 } from "node:crypto";
-
-// ../../bridges/claude-bridge/src/services/live-claude-control.ts
-var LIVE_CLAUDE_READ_TIMEOUT_MS = 5000;
-function readsProbeSettings(settingSources) {
-  if (settingSources === undefined)
-    return false;
-  try {
-    const sources = JSON.parse(settingSources);
-    return Array.isArray(sources) && ["user", "project", "local"].every((source) => sources.includes(source));
-  } catch {
-    return false;
-  }
-}
-function liveClaudeControls() {
-  const runtimes = [];
-  for (const session of sessions.values()) {
-    const runtime = session.claudeRuntime;
-    if (runtime?.state !== "open" || runtime.abortController.signal.aborted)
-      continue;
-    if (session.queryControlDraining === runtime.control || session.deleting)
-      continue;
-    if (!readsProbeSettings(runtime.launch.settingSources))
-      continue;
-    runtimes.push(runtime);
-  }
-  return runtimes.sort((left, right) => right.lastFrameAt - left.lastFrameAt).map((runtime) => runtime.control);
-}
-async function readFromLiveClaude(read, timeoutMs = LIVE_CLAUDE_READ_TIMEOUT_MS) {
-  for (const control of liveClaudeControls()) {
-    let timer;
-    try {
-      const answer = read(control);
-      if (answer === undefined)
-        continue;
-      answer.catch(() => {
-        return;
-      });
-      const value = await Promise.race([
-        answer,
-        new Promise((resolve) => {
-          timer = setTimeout(() => resolve(undefined), timeoutMs);
-        })
-      ]);
-      if (value !== undefined)
-        return value;
-    } catch (error) {
-      debugLog("[live-claude-control] A running CLI could not answer:", error);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  return;
-}
-function liveInitializationResult(control) {
-  if (typeof control.initializationResult !== "function")
-    return;
-  return control.initializationResult().then((result) => result && typeof result === "object" ? result : undefined);
+  writes = writes.then(async () => {
+    await load();
+    const directory = claudeOrkestratorDir();
+    await mkdir5(directory, { recursive: true });
+    const target = filePath();
+    const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+    const snapshot = entries;
+    await writeFile5(temporary, `${JSON.stringify({ versions: snapshot })}
+`, {
+      mode: 384
+    });
+    await rename5(temporary, target);
+    if (entries === snapshot)
+      dirty = false;
+  }).catch(() => {});
 }
 
+// ../../bridges/claude-bridge/src/services/session-manager-catalog.ts
+import { createHash as createHash10 } from "node:crypto";
+
 // ../protocol/src/secret-redaction.ts
 var TEXT_RULES = [
   {
@@ -14145,7 +14583,11 @@ function redactSecrets(value) {
 }
 
 // ../../bridges/claude-bridge/src/services/mcp-runtime-status.ts
-function mcpScope(scope, name, source) {
+var FOREIGN_MCP_SOURCES = new Set(["plugin", "sdk", "claudeai"]);
+function mcpScope(scope, name, source, layers) {
+  const layer = FOREIGN_MCP_SOURCES.has(source ?? "") ? undefined : layers?.get(name);
+  if (layer)
+    return layer;
   if (name === "orkestrator")
     return "orkestrator";
   if (source?.includes("plugin") || scope?.includes("plugin"))
@@ -14167,145 +14609,16 @@ function mcpRuntimeState(status) {
       return "unknown";
   }
 }
-function initMcpServerStatus(raw) {
+function initMcpServerStatus(raw, layers) {
   const source = typeof raw.source === "string" ? raw.source : undefined;
   return {
     name: raw.name,
     status: mcpRuntimeState(raw.status),
-    ...source ? { scope: mcpScope(source, raw.name) } : {},
+    ...source || layers?.has(raw.name) ? { scope: mcpScope(source, raw.name, source, layers) } : {},
     ...typeof raw.error === "string" && raw.error ? { error: raw.error } : {},
     ...Array.isArray(raw.tools) ? { tools: raw.tools.filter((tool) => typeof tool === "string") } : {}
   };
 }
-
-// ../../bridges/claude-bridge/src/services/claude-sign-in.ts
-var AUTH_CACHE_TTL_MS = 30000;
-var FAILED_AUTH_CACHE_TTL_MS = 5000;
-var CLAUDE_SIGN_IN = {
-  kind: "terminal",
-  hint: "Sign in to Claude from the sign-in card in this tab or from Settings → Claude."
-};
-var CLAUDE_SIGN_IN_REQUIRED_MESSAGE = "Claude isn't signed in. Sign in to Claude to keep working.";
-var authCache;
-var authRead;
-var authReadGeneration;
-var authRefreshPending = false;
-var authGeneration = 0;
-var turnAuthenticationFailedUntil = 0;
-var reuseLiveAccounts = true;
-function withTurnFailure(value) {
-  return Date.now() < turnAuthenticationFailedUntil && value.state === "signed-in" ? { ...value, state: "expired" } : value;
-}
-function presentSource(value) {
-  return value && value !== "none" ? value : undefined;
-}
-function normalizeClaudeAccount(account) {
-  const source = presentSource(account.apiKeySource) ?? presentSource(account.tokenSource);
-  const externalProvider = account.apiProvider && account.apiProvider !== "firstParty" ? account.apiProvider : undefined;
-  const signedIn = Boolean(source || account.subscriptionType || account.organization || externalProvider);
-  const label = account.organization || account.subscriptionType || externalProvider;
-  return {
-    state: signedIn ? "signed-in" : "needs-auth",
-    ...label ? {
-      account: {
-        label,
-        ...account.subscriptionType ? { plan: account.subscriptionType } : {}
-      }
-    } : {},
-    signIn: CLAUDE_SIGN_IN,
-    signOut: false
-  };
-}
-function liveSignedInAccount() {
-  return readFromLiveClaude((control) => liveInitializationResult(control)?.then((result) => {
-    const account = result?.account;
-    if (!account || typeof account !== "object")
-      return;
-    const status = normalizeClaudeAccount(account);
-    return status.state === "signed-in" ? status : undefined;
-  }));
-}
-async function probeAccount() {
-  if (reuseLiveAccounts) {
-    const live = await liveSignedInAccount();
-    if (live && reuseLiveAccounts)
-      return live;
-  }
-  let probe;
-  try {
-    probe = controlOnlyQuery({
-      cwd: process.env.CWD || process.cwd(),
-      env: { ...process.env },
-      ...claudeExecutableOptions()
-    });
-    return normalizeClaudeAccount(await probe.accountInfo());
-  } finally {
-    await Promise.resolve(probe?.close()).catch(() => {
-      return;
-    });
-  }
-}
-function readClaudeAuthStatus() {
-  if (authCache && authCache.expiresAt > Date.now()) {
-    return Promise.resolve(withTurnFailure(authCache.value));
-  }
-  if (authRead)
-    return authRead;
-  const generation = authGeneration;
-  const read = probeAccount().then((value) => ({ value, ttl: AUTH_CACHE_TTL_MS }), () => ({
-    value: {
-      state: "unknown",
-      signIn: CLAUDE_SIGN_IN,
-      signOut: false
-    },
-    ttl: FAILED_AUTH_CACHE_TTL_MS
-  })).then(({ value, ttl }) => {
-    if (generation === authGeneration) {
-      authCache = { expiresAt: Date.now() + ttl, value };
-    }
-    return withTurnFailure(value);
-  }).finally(() => {
-    if (authRead !== read)
-      return;
-    authRead = undefined;
-    authReadGeneration = undefined;
-    if (authRefreshPending) {
-      authRefreshPending = false;
-      readClaudeAuthStatus();
-    }
-  });
-  authReadGeneration = generation;
-  authRead = read;
-  return read;
-}
-function noteClaudeAuthenticationFailure() {
-  reuseLiveAccounts = false;
-  turnAuthenticationFailedUntil = Date.now() + AUTH_CACHE_TTL_MS;
-  authCache = undefined;
-  if (authRead && authReadGeneration !== authGeneration)
-    authRefreshPending = true;
-  readClaudeAuthStatus();
-}
-function noteClaudeAuthenticationWorked() {
-  reuseLiveAccounts = true;
-  authGeneration += 1;
-  authRefreshPending = false;
-  turnAuthenticationFailedUntil = 0;
-  if (authCache?.value.state === "needs-auth")
-    authCache = undefined;
-}
-function claudeReadiness() {
-  const cached = authCache;
-  if (cached?.value.state !== "needs-auth")
-    return;
-  if (cached.expiresAt <= Date.now())
-    readClaudeAuthStatus();
-  return {
-    state: "authentication-required",
-    message: CLAUDE_SIGN_IN_REQUIRED_MESSAGE,
-    signIn: CLAUDE_SIGN_IN
-  };
-}
 // ../../bridges/claude-bridge/src/services/session-manager-catalog.ts
 function readableControl(session) {
   if (!session)
@@ -14456,7 +14769,7 @@ function mcpTransport(status) {
 function mcpError(error) {
   return redactSecrets(error).slice(0, 2000);
 }
-function normalizeMcp(status) {
+function normalizeMcp(status, layers) {
   const mappedStatus = status.status === "pending" ? "connecting" : status.status;
   const tools = (status.tools ?? []).map((tool) => tool.name).filter(Boolean).slice(0, 256);
   const actions = status.status === "disabled" ? ["enable"] : status.status === "needs-auth" ? ["sign-in", "reconnect", "disable"] : ["reconnect", "disable"];
@@ -14465,7 +14778,7 @@ function normalizeMcp(status) {
     id: status.name,
     name: status.serverInfo?.name || status.name,
     status: mappedStatus,
-    scope: mcpScope(status.scope, status.name, status.source),
+    scope: mcpScope(status.scope, status.name, status.source, layers),
     ...transport ? { transport } : {},
     toolCount: tools.length,
     ...tools.length ? { tools } : {},
@@ -14473,18 +14786,11 @@ function normalizeMcp(status) {
     actions
   };
 }
-async function readSessionMcpServers(sessionId) {
-  const session = sessions.get(sessionId);
-  if (!session)
-    return [];
-  const control = readableControl(session);
-  if (control?.mcpServerStatus) {
-    try {
-      session.mcpInventory = (await control.mcpServerStatus()).slice(0, 128).map(normalizeMcp);
-    } catch (error) {
-      rethrowUnlessClosedTransport(error);
-    }
-  } else if (!session.mcpInventory && session.initData?.mcpServers) {
+function liveMcpInventory(session, statuses) {
+  return statuses.slice(0, 128).map((status) => normalizeMcp(status, session.mcpServerLayers));
+}
+function retainedMcpInventory(session) {
+  if (!session.mcpInventory && session.initData?.mcpServers) {
     session.mcpInventory = session.initData.mcpServers.slice(0, 128).map((server) => ({
       id: server.name,
       name: server.name,
@@ -14496,7 +14802,34 @@ async function readSessionMcpServers(sessionId) {
       ...server.error ? { error: mcpError(server.error) } : {}
     }));
   }
-  return session.mcpInventory ?? [];
+  return session.mcpInventory;
+}
+function applyProbeMcpStatus(session, serverId, statuses) {
+  const status = statuses.find((candidate) => candidate.name === serverId);
+  if (!status)
+    return;
+  const inventory = retainedMcpInventory(session);
+  session.mcpInventory = inventory?.map((row) => {
+    if (row.id !== serverId)
+      return row;
+    const updated = normalizeMcp(status, session.mcpServerLayers);
+    return { ...updated, scope: row.scope ?? updated.scope };
+  });
+}
+async function readSessionMcpServers(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return [];
+  const control = readableControl(session);
+  if (control?.mcpServerStatus) {
+    try {
+      session.mcpInventory = liveMcpInventory(session, await control.mcpServerStatus());
+    } catch (error) {
+      rethrowUnlessClosedTransport(error);
+    }
+    return session.mcpInventory ?? [];
+  }
+  return retainedMcpInventory(session) ?? [];
 }
 async function performSessionMcpAction(sessionId, serverId, action) {
   const session = sessions.get(sessionId);
@@ -14519,7 +14852,11 @@ async function performSessionMcpAction(sessionId, serverId, action) {
       await control.reconnectMcpServer?.(serverId);
     }
     if (control.mcpServerStatus) {
-      session.mcpInventory = (await control.mcpServerStatus()).slice(0, 128).map(normalizeMcp);
+      const statuses = await control.mcpServerStatus();
+      if (probe)
+        applyProbeMcpStatus(session, serverId, statuses);
+      else
+        session.mcpInventory = liveMcpInventory(session, statuses);
     }
     return {};
   } finally {
@@ -15140,6 +15477,7 @@ async function refreshClaudeCommandCatalogue(sessionId) {
   }
 }
 async function refreshClaudeCatalogs() {
+  invalidateClaudeModelCatalog();
   const sessionIds = Array.from(sessions.keys()).slice(0, 128);
   let next = 0;
   await Promise.allSettled(Array.from({ length: Math.min(8, sessionIds.length) }, async () => {
@@ -15229,10 +15567,17 @@ function appendLocalCommandResult(session, content, key) {
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-prompt-mcp-sync.ts
-function createClaudeRuntimeMcp(servers, declared) {
-  return { servers, claimed: false, declared: new Set(declared), stale: new Set };
+function createClaudeRuntimeMcp(servers, declared, accountOnly = []) {
+  const declaredNames = new Set(declared);
+  const loadedOnlyByAccount = new Set(Array.from(accountOnly).filter((name) => !declaredNames.has(name)));
+  return {
+    servers,
+    claimed: false,
+    declared: declaredNames,
+    stale: new Set(loadedOnlyByAccount),
+    accountOnly: loadedOnlyByAccount
+  };
 }
-var FOREIGN_SOURCES = new Set(["plugin", "sdk", "claudeai"]);
 var MAX_REPORTED_STALE_SERVERS = 256;
 function conflict(message) {
   return sessionOperationError("conflict", message);
@@ -15287,10 +15632,12 @@ async function syncClaudeRuntimeMcp(runtime, next) {
     runtime.mcpServers = "";
     throw conflict("Claude required MCP server is not connected; retry the prompt");
   }
-  const stillRuns = (name) => statuses ? statuses.some((server) => server.name === name && server.status !== "disabled" && !FOREIGN_SOURCES.has(server.source ?? "")) : !removed?.has(name);
+  const stillRuns = (name) => statuses ? statuses.some((server) => server.name === name && server.status !== "disabled" && !FOREIGN_MCP_SOURCES.has(server.source ?? "")) : !removed?.has(name);
   for (const name of Array.from(mcp.stale)) {
-    if (next.names.has(name) || !stillRuns(name))
+    if (next.names.has(name) || !stillRuns(name)) {
       mcp.stale.delete(name);
+      mcp.accountOnly.delete(name);
+    }
   }
   for (const name of undeclared)
     if (stillRuns(name))
@@ -15332,7 +15679,7 @@ function createStaleMcpServerHook(mcp) {
       hookSpecificOutput: {
         hookEventName: "PreToolUse",
         permissionDecision: "deny",
-        permissionDecisionReason: `The MCP server "${server}" was removed from this session's configuration, so ${input.tool_name} is not available. This Claude process loaded it at launch and cannot unload it; it is gone once the process closes after an idle period, or when the session is stopped.`
+        permissionDecisionReason: mcp.accountOnly.has(server) ? `The MCP server "${server}" is only in this Claude account's own configuration, not in the user's Claude configuration, so ${input.tool_name} is not available. Orkestrator replaces an account's MCP servers with the user's when the account's Claude starts; add the server to the user's Claude configuration to use it.` : `The MCP server "${server}" was removed from this session's configuration, so ${input.tool_name} is not available. This Claude process loaded it at launch and cannot unload it; it is gone once the process closes after an idle period, or when the session is stopped.`
       }
     };
   };
@@ -15584,6 +15931,60 @@ function claudeArtifactServerTools(servers) {
   return ARTIFACT_TOOL_NAMES.map((name) => `mcp__${ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME}__${name}`);
 }
 
+// ../protocol/src/node/repository-instructions.ts
+import { open as open3, realpath as realpath3 } from "node:fs/promises";
+import { join as join14, relative as relative2, isAbsolute as isAbsolute4 } from "node:path";
+
+// ../protocol/src/agent-system-instructions.ts
+var AGENT_IMAGE_PREVIEW_INSTRUCTION = "Orkestrator renders Markdown images inline in the transcript. When you show the user an image in your reply (a screenshot, rendered preview, or chart) using Markdown image syntax, reference it by its absolute path. In a managed worktree or container environment, save the file inside the working directory, preferably in a git-ignored folder so preview files stay out of the change set. Local image previews are limited to Orkestrator-managed workspace storage or the container's /workspace. Project-home checkouts are excluded from host preview reads, even when they are the working directory, so images saved there cannot be previewed from a local Markdown path. Paths outside previewable storage, such as /tmp, also show a placeholder.";
+var AGENT_DOCUMENT_INSTRUCTION = "When the user asks for a document (a report, design doc, plan, analysis, guide, or other writing to keep), prefer writing it as a Markdown file in a `docs/` folder at the root of the working directory, and tell the user the file's path. Project instructions (such as AGENTS.md or CLAUDE.md), local skills, and the user's own request take priority over this default when they say where or how to write documents.";
+var GENERAL_AGENT_INSTRUCTIONS = [
+  AGENT_IMAGE_PREVIEW_INSTRUCTION,
+  AGENT_DOCUMENT_INSTRUCTION
+];
+function agentSystemInstructions(providerSpecific = []) {
+  return [...GENERAL_AGENT_INSTRUCTIONS, ...providerSpecific].filter((line) => line.trim().length > 0).join(`
+
+`);
+}
+var REPOSITORY_INSTRUCTIONS_FILE = "AGENTS.md";
+function repositoryInstructionsBlock(path, content, truncated) {
+  return [
+    `# Repository instructions (${REPOSITORY_INSTRUCTIONS_FILE})`,
+    `This session does not load the repository's ${REPOSITORY_INSTRUCTIONS_FILE} on its own, so Orkestrator includes it here. Follow it as project instructions. Contents of ${path}:`,
+    content.trimEnd(),
+    ...truncated ? [
+      `[${REPOSITORY_INSTRUCTIONS_FILE} is longer than this session can hold, so it is cut here. Read the rest from ${path} before relying on anything it may say.]`
+    ] : []
+  ].join(`
+
+`);
+}
+
+// ../protocol/src/node/repository-instructions.ts
+var MAX_REPOSITORY_INSTRUCTIONS_BYTES = 256 * 1024;
+async function readRepositoryInstructions(cwd, maxBytes = MAX_REPOSITORY_INSTRUCTIONS_BYTES) {
+  const path = join14(cwd, REPOSITORY_INSTRUCTIONS_FILE);
+  try {
+    const [root, target] = await Promise.all([realpath3(cwd), realpath3(path)]);
+    const inside = relative2(root, target);
+    if (!inside || inside.startsWith("..") || isAbsolute4(inside))
+      return;
+    const handle = await open3(target, "r");
+    try {
+      const buffer = Buffer.alloc(maxBytes + 1);
+      const { bytesRead } = await handle.read(buffer, 0, maxBytes + 1, 0);
+      const truncated = bytesRead > maxBytes;
+      const text = new TextDecoder().decode(buffer.subarray(0, Math.min(bytesRead, maxBytes))).replace(/�$/, "");
+      return text.trim() ? repositoryInstructionsBlock(path, text, truncated) : undefined;
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return;
+  }
+}
+
 // ../protocol/src/claude-background-commands.ts
 var CLAUDE_BASH_MAX_TIMEOUT_ENV = "BASH_MAX_TIMEOUT_MS";
 var CLAUDE_BASH_DEFAULT_TIMEOUT_ENV = "BASH_DEFAULT_TIMEOUT_MS";
@@ -15632,6 +16033,17 @@ function backgroundCommandInstruction(env) {
   return `Background shell commands in this session are stopped when they reach their timeout (${defaultText} by default, ${maxText} at most). Pass a longer \`timeout\` when a background command needs more than ${defaultText}. For a dev server or watcher that must keep running longer than ${maxText}, tell the user to start it in an Orkestrator terminal tab instead of running it yourself.`;
 }
 
+// ../../bridges/claude-bridge/src/services/system-prompt-append.ts
+var READ_BEFORE_EDIT_INSTRUCTION = "IMPORTANT: You MUST read a file before editing or writing to it. The Edit and Write tools will fail if you have not first used the Read tool to read the file in this conversation. Always read files before attempting to modify them.";
+var CLAUDE_DOCS_INSTRUCTION = "Write a requested document as that Markdown file rather than as a Claude Doc or claude.ai artifact: Orkestrator cannot open those, so the user would never see it.";
+function claudeSystemPromptAppend(env) {
+  return agentSystemInstructions([
+    CLAUDE_DOCS_INSTRUCTION,
+    READ_BEFORE_EDIT_INSTRUCTION,
+    backgroundCommandInstruction(env)
+  ]);
+}
+
 // ../protocol/src/agent-interaction-deadline.ts
 var SYSTEM_CLOCK = {
   now: () => Date.now(),
@@ -15777,7 +16189,7 @@ function canAdmitInteraction(candidate, family) {
 // ../../bridges/claude-bridge/src/services/session-manager-interactions.ts
 import { readFile as readFile7 } from "node:fs/promises";
 
-// ../../bridges/claude-bridge/src/services/claude-elicitation-schema.ts
+// ../protocol/src/mcp-elicitation-form.ts
 function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -15802,7 +16214,7 @@ var FIELD_KEYS = new Set([
   "minimum",
   "maximum"
 ]);
-function isSupportedClaudeForm(schema) {
+function isSupportedMcpForm(schema) {
   if (!record2(schema) || schema.type !== "object" || Object.keys(schema).some((key) => !ROOT_KEYS.has(key)))
     return false;
   if (schema.additionalProperties !== undefined && schema.additionalProperties !== false)
@@ -15832,8 +16244,8 @@ function isSupportedClaudeForm(schema) {
     return true;
   });
 }
-function isValidClaudeFormContent(schema, content) {
-  if (!isSupportedClaudeForm(schema) || !record2(content))
+function isValidMcpFormContent(schema, content) {
+  if (!isSupportedMcpForm(schema) || !record2(content))
     return false;
   const properties = schema.properties ?? {};
   if (schema.required?.some((key) => !Object.hasOwn(content, key)))
@@ -15954,7 +16366,7 @@ function respondToInteraction(requestId, response, sessionId) {
   const resolve = interactionResolvers.get(key);
   if (!resolve)
     return false;
-  if (response.action === "accept" && request.kind === "mcp-form" && !isValidClaudeFormContent(request.schema, response.content))
+  if (response.action === "accept" && request.kind === "mcp-form" && !isValidMcpFormContent(request.schema, response.content))
     return false;
   pendingInteractions.delete(key);
   interactionResolvers.delete(key);
@@ -15974,61 +16386,6 @@ function getSessionInitData(sessionId) {
   const session = sessions.get(sessionId);
   return session?.initData;
 }
-function catalogModels(models) {
-  return models.map((model) => ({
-    id: model.value,
-    resolvedModel: model.resolvedModel,
-    name: model.displayName,
-    description: model.description,
-    supportsFastMode: model.supportsFastMode,
-    supportsEffort: model.supportsEffort,
-    supportedEffortLevels: model.supportedEffortLevels,
-    supportsAdaptiveThinking: model.supportsAdaptiveThinking,
-    supportsAutoMode: model.supportsAutoMode
-  }));
-}
-function liveModels() {
-  return readFromLiveClaude((control) => liveInitializationResult(control)?.then((result) => Array.isArray(result?.models) && result.models.length > 0 ? result.models : undefined));
-}
-async function getAvailableModelCatalog() {
-  const live = await liveModels();
-  if (live) {
-    debugLog("[session-manager] Supported models read from a running CLI", {
-      count: live.length
-    });
-    return { source: "sdk", models: catalogModels(live) };
-  }
-  let q;
-  try {
-    const cwd = process.env.CWD || process.cwd();
-    debugLog("[session-manager] Fetching supported models", { cwd });
-    q = controlOnlyQuery({
-      cwd,
-      env: { ...process.env },
-      ...claudeExecutableOptions()
-    });
-    const models = await q.supportedModels();
-    debugLog("[session-manager] Supported models fetched", { count: models.length });
-    return { source: "sdk", models: catalogModels(models) };
-  } catch (error) {
-    console.error("[session-manager] Error fetching supported models:", error);
-    return {
-      source: "fallback",
-      models: CLAUDE_FALLBACK_MODEL_CATALOG.map((model) => ({
-        ...model,
-        ...model.supportedEffortLevels ? { supportedEffortLevels: [...model.supportedEffortLevels] } : {}
-      }))
-    };
-  } finally {
-    if (q?.return) {
-      try {
-        await q.return();
-      } catch (error) {
-        debugLog("[session-manager] Failed to clean up model query:", error);
-      }
-    }
-  }
-}
 async function getClaudeRuntimeVersions() {
   let sdkVersion;
   let bundledCliVersion;
@@ -16182,7 +16539,7 @@ async function answerClaudeElicitation(session, sessionId, request, options) {
   const url = request.mode === "url" ? bounded2(request.url) : undefined;
   const schema = request.mode === "url" ? undefined : request.requestedSchema ?? { type: "object" };
   const schemaText = schema === undefined ? "" : JSON.stringify(schema);
-  if (request.mode === "url" && (!url || url !== request.url) || new TextEncoder().encode(schemaText).byteLength > AGENT_INTERACTION_LIMITS.maxTextLength || schema !== undefined && !isSupportedClaudeForm(schema)) {
+  if (request.mode === "url" && (!url || url !== request.url) || new TextEncoder().encode(schemaText).byteLength > AGENT_INTERACTION_LIMITS.maxTextLength || schema !== undefined && !isSupportedMcpForm(schema)) {
     appendTranscriptNotice(session, sessionId, (event) => eventEmitter.emit(event), {
       type: "status",
       severity: "warning",
@@ -16230,9 +16587,9 @@ function proposedBashPrefix(suggestions) {
       const { toolName, ruleContent } = rule;
       if (toolName !== "Bash" || typeof ruleContent !== "string")
         continue;
-      const prefix = ruleContent.endsWith(":*") ? ruleContent.slice(0, -2) : ruleContent;
+      const prefix = ruleContent.replace(/(?::| )\*$/, "");
       const words = prefix.trim().split(/\s+/);
-      if (words.length === 0 || words.length > MAX_PROPOSED_PREFIX_TOKENS || words.some((word) => word.length === 0 || word.length > MAX_PROPOSED_PREFIX_TOKEN_LENGTH)) {
+      if (words.length === 0 || words.length > MAX_PROPOSED_PREFIX_TOKENS || words.some((word) => word.length === 0 || word.length > MAX_PROPOSED_PREFIX_TOKEN_LENGTH || word.includes("*"))) {
         continue;
       }
       return words;
@@ -16443,6 +16800,9 @@ function turnHook(turn, hook) {
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-prompt-query.ts
+function withNativeGoalClosed(disallowed) {
+  return [...disallowed ?? [], "ProposeGoal"];
+}
 var PLAN_MODE_INSTRUCTIONS = `The user has enabled planning mode. Use this phase to:
 1. Thoroughly explore the codebase and its existing patterns.
 2. Consider viable approaches and their trade-offs.
@@ -16463,15 +16823,22 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   };
   const settingSources = claudeTurnSettingSources(session, options);
   session.commandDiscoveryInputs.includeLocalSettings = settingSources.includes("local");
+  const repositoryInstructions = options?.readOnly || policy?.id === "coordinator-read-only" || settingSources.includes("project") ? undefined : await readRepositoryInstructions(cwd);
   const readOnlyCommandSandbox = isCoordinatorReadOnlyPolicy(policy) ? claudeReadOnlyCommandSandbox() : undefined;
   const [
-    { servers: mcpServers, names: mcpServerNames, revision: mcpConfigRevision },
+    {
+      servers: mcpServers,
+      names: mcpServerNames,
+      layers: mcpServerLayers,
+      revision: mcpConfigRevision
+    },
     { plugins, coordinatorSkills }
   ] = await Promise.all([
     getMcpRuntimeConfig(cwd, process.env, options?.agentMcp, mcpSourceScopeForPolicy(policy), userMcpServerFilter(policy)),
     resolveClaudeTurnPlugins(cwd, policy, settingSources)
   ]);
   turn.mcpServerNames = mcpServerNames;
+  const accountOnlyMcpServers = await claudeAccountOnlyMcpServerNames(cwd, settingSources, mcpServerNames, claudeUserMcpQueryOptions(policy).strictMcpConfig === true);
   const mcpServerCount = Object.keys(mcpServers).length;
   const pluginCount = plugins.length;
   const policyPermissionMode = claudePolicyPermissionMode(policy);
@@ -16492,7 +16859,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   ];
   const coordinatorReadOnly = isCoordinatorReadOnlyPolicy(policy);
   const grantedMcpServerNames = claudeAsksForApproval(policy, options) ? [] : claudeGrantedMcpServerNames(policy, mcpServerNames);
-  const agentMailTools = mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? [...AGENT_MAIL_TOOL_NAMES, ...ARTIFACT_TOOL_NAMES].map((name) => `mcp__${AGENT_MCP_SERVER_NAME}__${name}`) : [];
+  const agentMailTools = mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? [...AGENT_MAIL_TOOL_NAMES, ...ARTIFACT_TOOL_NAMES, ...AGENT_GOAL_TOOL_NAMES].map((name) => `mcp__${AGENT_MCP_SERVER_NAME}__${name}`) : [];
   const allowedTools = coordinatorReadOnly ? claudeReadOnlyAllowedTools({
     agentMcpServerNames: mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? [AGENT_MCP_SERVER_NAME] : [],
     policy,
@@ -16506,7 +16873,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
     ...claudeArtifactServerTools(mcpServerNames),
     ...grantedMcpServerNames.map((name) => `${claudeMcpToolPrefix(name)}*`)
   ];
-  const disallowedTools = coordinatorReadOnly ? claudeDeniedTools(policy) : claudeDisallowedTools(policy);
+  const disallowedTools = withNativeGoalClosed(coordinatorReadOnly ? claudeDeniedTools(policy) : claudeDisallowedTools(policy));
   const fastMode = options?.fastMode === true;
   const ultracode = requestsUltracode(options?.parameterValues);
   session.ultracode = ultracode;
@@ -16528,7 +16895,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   const envPath = process.env.PATH;
   debugLog("[session-manager] SDK env PATH", { path: envPath });
   const sdkPrompt = await buildSdkPrompt(sdkTextPrompt, options?.attachments, cwd, testHooks?.afterAttachmentSymlinkValidation, testHooks?.afterAttachmentCanonicalValidation, testHooks?.afterAttachmentInitialValidation);
-  const queryEnvironment = await runtimeEnvironmentForSessionQuery(policy);
+  const queryEnvironment = withUnattendedOverloadRetry(session.executionPolicy, await runtimeEnvironmentForSessionQuery(policy));
   const liveSettings = claudeLiveSettings({
     model: options?.model,
     permissionMode,
@@ -16539,11 +16906,14 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   const mcpServersKey = createHash11("sha256").update(JSON.stringify(mcpServers)).digest("hex");
   return {
     settingSources,
+    repositoryInstructions,
     cwd,
     policy,
     effortLevel,
     mcpServers,
     mcpServerNames,
+    mcpServerLayers,
+    accountOnlyMcpServers,
     mcpConfigRevision,
     plugins,
     mcpServerCount,
@@ -16564,6 +16934,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
 }
 function recordMcpConfigRevision(session, plan, mcp) {
   const { mcpConfigRevision } = plan;
+  session.mcpServerLayers = plan.mcpServerLayers;
   if (!mcpConfigRevision)
     return;
   const staleServers = reportedStaleServers(mcp);
@@ -16646,11 +17017,9 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
     systemPrompt: {
       type: "preset",
       preset: "claude_code",
-      append: coordinatorReadOnly ? "You are a read-only coordinator. Inspect the checkout with reading tools and use the trusted research tools available for this turn. Delegate all mutations and artifact creation to worker environments through Orkestrator tools. Present findings directly in your response." : [
-        "IMPORTANT: You MUST read a file before editing or writing to it. The Edit and Write tools will fail if you have not first used the Read tool to read the file in this conversation. Always read files before attempting to modify them.",
-        backgroundCommandInstruction(queryEnvironment),
-        "When the user asks for a document (a report, design doc, plan, analysis, guide, or other writing to keep), prefer writing it as a Markdown file in a `docs/` folder at the root of the working directory over creating a Claude Doc or claude.ai artifact, and tell the user the file's path. Project instructions (such as CLAUDE.md or AGENTS.md), local skills, and the user's own request take priority over this default when they say where or how to write documents.",
-        "When you show the user an image in your reply (a screenshot, rendered preview, or chart) using Markdown image syntax, reference it by its absolute path. In a managed worktree or container environment, save the file inside the working directory, preferably in a git-ignored folder so preview files stay out of the change set. Local image previews are limited to Orkestrator-managed workspace storage or the container's /workspace. Project-home checkouts are excluded from host preview reads, even when they are the working directory, so images saved there cannot be previewed from a local Markdown path. Paths outside previewable storage, such as /tmp, also show a placeholder."
+      append: [
+        coordinatorReadOnly ? "You are a read-only coordinator. Inspect the checkout with reading tools and use the trusted research tools available for this turn. Delegate all mutations and artifact creation to worker environments through Orkestrator tools. Present findings directly in your response." : claudeSystemPromptAppend(queryEnvironment),
+        ...plan.repositoryInstructions ? [plan.repositoryInstructions] : []
       ].join(`
 
 `)
@@ -16985,7 +17354,7 @@ async function handleInitMessage(turn, message) {
   }
   const allMcpServers = initMsg.mcp_servers || [];
   const regularMcpServers = allMcpServers.filter((s) => !s.name?.startsWith("plugin:"));
-  const mcpServerStatuses = regularMcpServers.map(initMcpServerStatus);
+  const mcpServerStatuses = regularMcpServers.map((server) => initMcpServerStatus(server, session.mcpServerLayers));
   const { statuses: pluginStatuses, errors: pluginErrors } = pluginStatusesFromInit(initMsg);
   const previousPluginErrors = new Set(session.pluginErrorSignatures);
   session.pluginErrorSignatures = pluginErrors.map(({ plugin, type, message, path, loaded }) => JSON.stringify([plugin, type, message, path, loaded]));
@@ -17172,6 +17541,28 @@ var LEAF_MESSAGE_HANDLERS = {
   conversation_reset: handleConversationReset
 };
 
+// ../protocol/src/agent-usage-limits.ts
+var USAGE_LIMIT_PATTERNS = [
+  /usage[\s_-]?limit/i,
+  /hit your (?:usage |session |weekly )?limit/i,
+  /\b(?:5|five)[\s-]?hour limit\b/i,
+  /\bweekly limit\b/i,
+  /\b(?:usage|quota|credits?|allowance) (?:is |has been )?(?:exhausted|exceeded|used up)\b/i,
+  /\bquota exceeded\b|\binsufficient_quota\b|\bout of (?:credits|usage)\b/i,
+  /\bUSAGE_EXHAUSTED\b|\bPAYMENT_REQUIRED\b/,
+  /\b(?:usage|plan|session|daily|weekly|monthly|go) limit reached\b/i
+];
+function classifyUsageLimitError(text) {
+  if (typeof text !== "string" || !text.trim())
+    return null;
+  const bounded = text.slice(0, 2000);
+  if (!USAGE_LIMIT_PATTERNS.some((pattern) => pattern.test(bounded)))
+    return null;
+  const reset = bounded.match(/\b(?:resets?|try again)(?:\s+(?:at|in|after))?\s+([^.\n·]{1,60})/i);
+  const hint = reset?.[1]?.trim();
+  return hint ? { resetHint: hint } : {};
+}
+
 // ../../bridges/claude-bridge/src/services/session-manager-prompt-handlers/result.ts
 function claudeStartupFailureMessage(reason) {
   switch (reason) {
@@ -17213,8 +17604,11 @@ function claudeStartupFailureMessage(reason) {
       return "Claude could not load the policy limits and managed settings your organization requires. Check connectivity and any proxy, then retry.";
     case "org_config_refused":
       return "Anthropic refused your organization's required Claude settings for this sign-in. Sign in to Claude again; if that does not help, ask an administrator to allow Claude Code for this account.";
+    case "sandbox_required_unavailable":
+      return "Claude requires a working command sandbox, and it cannot run here (for example, bubblewrap is missing or the platform is unsupported). Make the sandbox available or have the requirement changed, then retry.";
   }
 }
+var MAX_USAGE_LIMIT_ERROR_CHARS = 500;
 var STOPPED_TERMINAL_REASONS = new Set([
   "aborted_streaming",
   "aborted_tools"
@@ -17347,8 +17741,9 @@ async function handleResultMessage(turn, message) {
       isError: resultIsError
     });
     const startupFailure = resultMsg.startup_failure_reason ? claudeStartupFailureMessage(resultMsg.startup_failure_reason) : undefined;
+    const usageLimit = resultMsg.subtype === "success" && classifyUsageLimitError(resultMsg.result) ? resultMsg.result.trim().slice(0, MAX_USAGE_LIMIT_ERROR_CHARS) : undefined;
     const resultError = startupFailure || resultMsg.errors?.filter(Boolean).join(`
-`) || (resultMsg.subtype === "success" ? "Claude ended the turn on an API error." : `Claude query failed: ${resultMsg.subtype}`);
+`) || usageLimit || (resultMsg.subtype === "success" ? "Claude ended the turn on an API error." : `Claude query failed: ${resultMsg.subtype}`);
     if (startupFailure) {
       appendTranscriptNotice(session, sessionId, (event) => eventEmitter.emit(event), {
         type: "status",
@@ -18280,7 +18675,8 @@ async function prepareJoin(turn, plan, running) {
   const required = mcpServers[AGENT_MCP_SERVER_NAME] ? [AGENT_MCP_SERVER_NAME, ...options?.agentMcp?.design ? ["orkestrator-design"] : []] : [];
   await assertClaudeRuntimeAccepts(session, options, {
     ...claudeLaunchResourceProfile(plugins, queryEnvironment),
-    settingSources: JSON.stringify(plan.settingSources)
+    settingSources: JSON.stringify(plan.settingSources),
+    repositoryInstructions: plan.repositoryInstructions ?? ""
   }, plan.readOnlyCommandSandbox);
   session.queryControl = running.control;
   turn.queryIteratorControl = running.control;
@@ -18321,7 +18717,7 @@ function launchClaudeRuntime(turn, plan) {
   const { session, options, abortController, stream } = turn;
   const { plugins, sdkPrompt, queryEnvironment, mcpServers, mcpServerNames, mcpServersKey } = plan;
   const heldSdkPrompt = holdSdkPromptOpen(sdkPrompt, abortController.signal, turn.promptUuid);
-  const mcp = createClaudeRuntimeMcp(mcpServers, mcpServerNames);
+  const mcp = createClaudeRuntimeMcp(mcpServers, mcpServerNames, plan.accountOnlyMcpServers);
   const turnFor = (toolUseId) => (toolUseId ? turn.runtime?.toolOwners.get(toolUseId) : undefined) ?? turn.runtime?.latestTurn ?? turn.thisTurn;
   const queryIterator = query2({
     prompt: heldSdkPrompt.prompt,
@@ -18340,6 +18736,7 @@ function launchClaudeRuntime(turn, plan) {
     launch: {
       ...claudeLaunchedProfile(session, options, plan.readOnlyCommandSandbox),
       settingSources: JSON.stringify(plan.settingSources),
+      repositoryInstructions: plan.repositoryInstructions ?? "",
       ...claudeLaunchResourceProfile(plugins, queryEnvironment)
     },
     mcpServers: mcpServersKey,
@@ -18396,6 +18793,7 @@ function joinableRuntime(turn, plan) {
   const requested = {
     ...claudeLaunchProfile(turn.session, turn.options, plan.readOnlyCommandSandbox),
     settingSources: JSON.stringify(plan.settingSources),
+    repositoryInstructions: plan.repositoryInstructions ?? "",
     ...claudeLaunchResourceProfile(plan.plugins, plan.queryEnvironment)
   };
   return claudeLaunchConflict(running.launch, requested) ? undefined : running;
@@ -18790,6 +19188,8 @@ async function settlesBy(work, deadline) {
 // ../../bridges/claude-bridge/src/routes/config.ts
 var config = new Hono2;
 config.get("/models", async (c) => {
+  if (c.req.query("forceRefresh") === "true")
+    invalidateClaudeModelCatalog();
   const startedAt = Date.now();
   console.log("[config] /models requested");
   const [{ models, source }, versions] = await Promise.all([
@@ -19093,7 +19493,7 @@ function parseSessionActivityObservation(value) {
   if (!isRecord4(value))
     return;
   const { activity, readyForInput, completionPending, asyncQuestionItemIds, closing } = value;
-  const { contentRevision } = value;
+  const { contentRevision, turnFailed } = value;
   if (typeof activity !== "string" || !SESSION_ACTIVITY_STATES.has(activity))
     return;
   if (readyForInput !== undefined && typeof readyForInput !== "boolean")
@@ -19102,6 +19502,8 @@ function parseSessionActivityObservation(value) {
     return;
   if (closing !== undefined && typeof closing !== "boolean")
     return;
+  if (turnFailed !== undefined && typeof turnFailed !== "boolean")
+    return;
   if (contentRevision !== undefined && !isContentRevision(contentRevision))
     return;
   let itemIds;
@@ -19117,6 +19519,7 @@ function parseSessionActivityObservation(value) {
     ...completionPending !== undefined ? { completionPending } : {},
     ...itemIds !== undefined ? { asyncQuestionItemIds: itemIds } : {},
     ...closing !== undefined ? { closing } : {},
+    ...turnFailed === true ? { turnFailed } : {},
     ...contentRevision !== undefined ? { contentRevision } : {}
   };
 }
@@ -19248,6 +19651,7 @@ async function readSessionActivityObservation(sessionId) {
   return {
     activity: activity === "idle" && completionPending ? "working" : activity,
     ...resident?.status === "idle" ? { readyForInput: true, completionPending } : {},
+    ...resident?.status === "error" ? { turnFailed: true } : {},
     ...activity === "missing" ? {} : contentRevisionField(resident)
   };
 }
@@ -20725,7 +21129,7 @@ session.post("/:id/interactions/:interactionId", interactionBodyLimit, async (c)
   } else if (action === "accept" && pending.kind === "mcp-form") {
     return c.json({ error: "An MCP form answer requires 'content'" }, 400);
   }
-  if (action === "accept" && pending.kind === "mcp-form" && !isValidClaudeFormContent(pending.schema, content)) {
+  if (action === "accept" && pending.kind === "mcp-form" && !isValidMcpFormContent(pending.schema, content)) {
     return c.json({ error: "The answer does not match the MCP form schema" }, 400);
   }
   const response = action === "accept" ? content ? { action, content } : { action } : { action };