orkestrator 2.32.0-beta → 2.33.0-beta

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

@@ -1669,7 +1669,7 @@ var shouldTransform = (res) => {
 };
 
 // ../../bridges/claude-bridge/src/index.ts
-import { randomBytes, timingSafeEqual } from "node:crypto";
+import { randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
 
 // ../../bridges/claude-bridge/src/routes/health.ts
 var health = new Hono2;
@@ -2548,6 +2548,10 @@ function claudeCommandChangesDir() {
 function claudeChangeEvidenceDir() {
   return join(claudeHome(), ".claude", "orkestrator", "change-evidence");
 }
+function claudeCoordinatorSkillPluginsDir() {
+  const configDir = overrideHome === null ? process.env.CLAUDE_CONFIG_DIR?.trim() : undefined;
+  return join(configDir || join(claudeHome(), ".claude"), "orkestrator", "coordinator-skills");
+}
 
 // ../../bridges/claude-bridge/src/services/session-preferences.ts
 function parseTurnInFlightMark(value) {
@@ -3771,672 +3775,978 @@ function nextTurnGeneration() {
   turnGenerationCounter += 1;
   return turnGenerationCounter;
 }
-// ../../bridges/claude-bridge/src/services/session-manager-runtime.ts
-import { createHash as createHash5 } from "node:crypto";
-
-// ../../bridges/claude-bridge/src/services/plugin-config.ts
-import { readdir, access } from "node:fs/promises";
-import { join as join3 } from "node:path";
-
-// ../protocol/src/node/claude-plugin-set.ts
-import path from "node:path";
-var CLAUDE_PLUGINS_MARKER = "/.claude/plugins/";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function claudePluginConfigList(value) {
-  if (!Array.isArray(value))
-    return [];
-  const plugins = [];
-  for (const item of value) {
-    if (isRecord(item) && typeof item.path === "string" && item.path) {
-      plugins.push({ type: "local", path: item.path });
-    }
-  }
-  return plugins;
-}
-function isPathWithin(parentDir, candidatePath) {
-  const relativePath = path.relative(parentDir, candidatePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
-}
-function remapInstalledPlugins(pluginsDir, installedPlugins, onUnsafe) {
-  const plugins = [];
-  const pluginsRoot = path.resolve(pluginsDir);
-  if (!isRecord(installedPlugins.plugins))
-    return plugins;
-  for (const [installedId, entries] of Object.entries(installedPlugins.plugins)) {
-    if (!Array.isArray(entries))
-      continue;
-    for (const entry of entries) {
-      if (!isRecord(entry) || typeof entry.installPath !== "string")
-        continue;
-      const installPath = entry.installPath;
-      const markerIdx = installPath.indexOf(CLAUDE_PLUGINS_MARKER);
-      let resolvedPath;
-      if (markerIdx !== -1) {
-        const relativePath = installPath.substring(markerIdx + CLAUDE_PLUGINS_MARKER.length);
-        const remappedPath = path.resolve(pluginsDir, relativePath);
-        if (!isPathWithin(pluginsRoot, remappedPath)) {
-          onUnsafe?.(installPath);
-          continue;
-        }
-        resolvedPath = remappedPath;
-      } else {
-        resolvedPath = installPath;
-      }
-      plugins.push({ type: "local", path: resolvedPath, installedId });
-    }
-  }
-  return plugins;
-}
-function resolveClaudePluginPath(pluginPath, cwd, home) {
-  if (pluginPath.startsWith("~"))
-    return path.join(home, pluginPath.slice(1));
-  if (pluginPath.startsWith("/"))
-    return pluginPath;
-  return path.join(cwd, pluginPath);
+// ../../bridges/claude-bridge/src/services/image-attachment-data.ts
+var SUPPORTED_IMAGE_MEDIA_TYPES = new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+var MAX_IMAGE_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+function decodedBase64ByteLength(value) {
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  return value.length / 4 * 3 - padding;
 }
-function mergeClaudePluginLayers(layers, options) {
-  const ordered = [
-    claudePluginConfigList(layers.global),
-    layers.cliInstalled,
-    ...options.includeProjectSources ? [claudePluginConfigList(layers.projectGlobal), claudePluginConfigList(layers.projectLocal)] : []
-  ];
-  const seen = new Set;
-  const paths = [];
-  for (const layer of ordered) {
-    for (const plugin of layer) {
-      const resolved = resolveClaudePluginPath(plugin.path, options.cwd, options.home);
-      if (seen.has(resolved))
-        continue;
-      seen.add(resolved);
-      paths.push(resolved);
+function parseBase64ImageData(value) {
+  let data = value;
+  let mediaType;
+  if (value.startsWith("data:")) {
+    const match = /^data:([^;,]+);base64,([\s\S]+)$/.exec(value);
+    if (!match || !SUPPORTED_IMAGE_MEDIA_TYPES.has(match[1])) {
+      return null;
     }
+    mediaType = match[1];
+    data = match[2];
   }
-  return paths;
-}
-var INVALID_PLUGIN_NAME = new RegExp("[@:\\s/\\\\\\u0000-\\u001f\\u007f\\u200b-\\u200f\\u2028-\\u202e\\u2060-\\u2064\\ufeff]");
-var CLAUDE_PLUGIN_SETTING_SOURCES = ["local", "project", "user"];
-function claudeInstalledPluginIdEnablement(id, settings, loadedSources) {
-  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-  for (const source of ["local", "project", "user"]) {
-    if (!loadedSources.includes(source))
-      continue;
-    const document = settings[source];
-    const enabledPlugins = isRecord(document) ? document.enabledPlugins : undefined;
-    if (!isRecord(enabledPlugins) || !Object.hasOwn(enabledPlugins, id))
-      continue;
-    return { enabled: enabledPlugins[id] === true, decidedBy: { source, key: id } };
+  const normalized = data.replace(/\s+/g, "");
+  if (normalized.length === 0 || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized) || decodedBase64ByteLength(normalized) > MAX_IMAGE_ATTACHMENT_BYTES) {
+    return null;
   }
-  return { enabled: false };
-}
-function enabledInstalledPlugins(plugins, settings, loadedSources) {
-  return plugins.filter((plugin) => plugin.installedId === undefined || claudeInstalledPluginIdEnablement(plugin.installedId, settings, loadedSources).enabled);
-}
-function claudePluginSettingSources(settingSources) {
-  return CLAUDE_PLUGIN_SETTING_SOURCES.filter((source) => settingSources.includes(source));
+  return { data: normalized, mediaType };
 }
+// ../../bridges/claude-bridge/src/services/session-manager-runtime.ts
+import { createHash as createHash6 } from "node:crypto";
 
-// ../../bridges/claude-bridge/src/services/json-file-cache.ts
-import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-var SEPARATOR = "\x00";
-var slices = new Map;
-var readCohorts = new Map;
-var parseCounts = new Map;
-var beforeStatForTesting = null;
-function fingerprintOf(stats) {
-  return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
-}
-function forgetFile(filePath) {
-  const prefix = `${filePath}${SEPARATOR}`;
-  for (const key of slices.keys()) {
-    if (key.startsWith(prefix))
-      slices.delete(key);
+// ../../bridges/claude-bridge/src/services/runtime-env.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile2 } from "node:fs/promises";
+import { promisify } from "node:util";
+var GITHUB_CREDENTIAL_FILE_ENV = "ORKESTRATOR_GITHUB_CREDENTIAL_FILE";
+var GITHUB_MCP_TOKEN_ENV = "GITHUB_PERSONAL_ACCESS_TOKEN";
+var execFileAsync = promisify(execFile2);
+var GH_TOKEN_TIMEOUT_MS = 2000;
+var GH_TOKEN_CACHE_MS = 5 * 60000;
+var GH_TOKEN_FAILURE_CACHE_MS = 15000;
+var ghTokenCache = new WeakMap;
+async function readGitHubCliToken(env) {
+  try {
+    const { stdout } = await execFileAsync("gh", ["auth", "token", "--hostname", "github.com"], {
+      env,
+      timeout: GH_TOKEN_TIMEOUT_MS
+    });
+    return stdout.trim() || undefined;
+  } catch {
+    return;
   }
 }
-function joinReadCohort(filePath) {
-  const existing = readCohorts.get(filePath);
-  if (existing) {
-    existing.readers += 1;
-    return existing;
+function cachedGitHubCliToken(env, reader) {
+  const key = JSON.stringify([env.PATH, env.HOME, env.XDG_CONFIG_HOME, env.GH_CONFIG_DIR]);
+  let entries = ghTokenCache.get(reader);
+  if (!entries) {
+    entries = new Map;
+    ghTokenCache.set(reader, entries);
   }
-  const cohort = { readers: 1, parses: new Map };
-  readCohorts.set(filePath, cohort);
-  return cohort;
+  const now = Date.now();
+  const cached = entries.get(key);
+  if (cached && cached.expiresAt > now)
+    return cached.value;
+  if (!cached && entries.size >= 8)
+    entries.clear();
+  const value = Promise.resolve().then(() => reader(env)).catch(() => {
+    return;
+  }).then((token) => {
+    if (entries.get(key)?.value === value) {
+      entries.set(key, {
+        value: Promise.resolve(token),
+        expiresAt: Date.now() + (token ? GH_TOKEN_CACHE_MS : GH_TOKEN_FAILURE_CACHE_MS)
+      });
+    }
+    return token;
+  });
+  entries.set(key, { value, expiresAt: now + GH_TOKEN_TIMEOUT_MS });
+  return value;
 }
-function leaveReadCohort(filePath, cohort) {
-  cohort.readers -= 1;
-  if (cohort.readers === 0 && readCohorts.get(filePath) === cohort) {
-    readCohorts.delete(filePath);
+async function runtimeEnvironmentForAgentQuery(env = process.env, readTextFile = readFile2, readGhToken = readGitHubCliToken) {
+  const snapshot = { ...env };
+  const credentialFile = env[GITHUB_CREDENTIAL_FILE_ENV]?.trim();
+  if (!credentialFile) {
+    if (!snapshot[GITHUB_MCP_TOKEN_ENV]?.trim()) {
+      const token = snapshot.GH_TOKEN?.trim() || snapshot.GITHUB_TOKEN?.trim() || await cachedGitHubCliToken(snapshot, readGhToken);
+      if (token)
+        snapshot[GITHUB_MCP_TOKEN_ENV] = token;
+    }
+    return snapshot;
+  }
+  let token = "";
+  try {
+    token = (await readTextFile(credentialFile, "utf8")).trim();
+  } catch {}
+  if (token) {
+    snapshot.GITHUB_TOKEN = token;
+    snapshot.GH_TOKEN = token;
+    snapshot[GITHUB_MCP_TOKEN_ENV] = token;
+  } else {
+    delete snapshot.GITHUB_TOKEN;
+    delete snapshot.GH_TOKEN;
+    delete snapshot[GITHUB_MCP_TOKEN_ENV];
   }
+  return snapshot;
 }
-function parseOnce(filePath, fingerprint, cohort) {
-  const existing = cohort.parses.get(fingerprint);
-  if (existing)
-    return existing;
-  const parse = (async () => {
-    parseCounts.set(filePath, (parseCounts.get(filePath) ?? 0) + 1);
-    let bytes;
-    try {
-      bytes = await readFile2(filePath);
-    } catch {
-      return { parsed: null, digest: null };
-    }
-    const digest = createHash4("sha256").update(bytes).digest("base64url");
-    try {
-      return { parsed: JSON.parse(bytes.toString("utf-8")), digest };
-    } catch {
-      return { parsed: null, digest };
-    }
-  })();
-  cohort.parses.set(fingerprint, parse);
-  return parse;
+
+// ../protocol/src/native-agent-transcript-patch.ts
+var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+// ../protocol/src/native-agent-policy-effects.ts
+function appendNativeAgentPolicyNote(policy, note) {
+  return { ...policy, note: policy.note ? `${policy.note} ${note}` : note };
 }
-async function readJsonSliceCached(filePath, sliceKey, select) {
-  return (await readJsonSliceCachedWithDigest(filePath, sliceKey, select)).value;
+var READ_ONLY_TURN_POLICY_NOTE = "The current turn is read-only, so it runs under the read-only policy rather than this session's own.";
+function readOnlyTurnReportedPolicy(turnPolicy) {
+  return appendNativeAgentPolicyNote(turnPolicy, READ_ONLY_TURN_POLICY_NOTE);
 }
-async function readJsonSliceCachedWithDigest(filePath, sliceKey, select) {
-  const cohort = joinReadCohort(filePath);
-  try {
-    await beforeStatForTesting?.(filePath);
-    let fingerprint;
-    try {
-      fingerprint = fingerprintOf(await stat2(filePath));
-    } catch {
-      forgetFile(filePath);
-      return { value: null, digest: null };
-    }
-    const key = `${filePath}${SEPARATOR}${sliceKey}`;
-    const cached = slices.get(key);
-    if (cached && cached.fingerprint === fingerprint) {
-      return { value: cached.value, digest: cached.digest };
+
+// ../protocol/src/native-agent-steer-rejection.ts
+var NATIVE_AGENT_STEER_REJECTION_HTTP_STATUS = 429;
+var MAX_STEER_JOURNAL_BYTES = 1024 * 1024 * 1024;
+// ../protocol/src/native-agent.ts
+var DEFAULT_OPENCODE_MODEL_PROVIDERS = Object.freeze([
+  "opencode",
+  "opencode-go"
+]);
+var NATIVE_AGENT_APPROVAL_MODES = Object.freeze({
+  claude: [
+    {
+      id: "default",
+      label: "Ask",
+      description: "Ask before editing files or running commands",
+      kind: "ask"
+    },
+    {
+      id: "acceptEdits",
+      label: "Accept edits",
+      description: "Apply file edits without asking; ask before running commands",
+      kind: "auto-edits"
+    },
+    {
+      id: "auto",
+      label: "Auto",
+      description: "A model reviews each action, approving safe ones and blocking risky ones",
+      kind: "auto-review"
+    },
+    {
+      id: "bypassPermissions",
+      label: "Bypass",
+      description: "Approve everything without asking",
+      kind: "auto-approve"
     }
-    const { parsed, digest } = await parseOnce(filePath, fingerprint, cohort);
-    let value = null;
-    if (parsed !== null && parsed !== undefined) {
-      try {
-        value = select(parsed) ?? null;
-      } catch {
-        value = null;
-      }
+  ],
+  codex: [
+    {
+      id: "untrusted",
+      label: "Untrusted",
+      description: "Ask before running any command Codex does not trust",
+      kind: "ask"
+    },
+    {
+      id: "on-request",
+      label: "On request",
+      description: "Work in a sandbox; Codex asks before stepping outside it",
+      kind: "ask"
+    },
+    {
+      id: "auto-review",
+      label: "Auto review",
+      description: "Work in a sandbox; a reviewer agent decides when Codex may step outside it",
+      kind: "auto-review"
+    },
+    {
+      id: "never",
+      label: "Full access",
+      description: "Never ask; run everything",
+      kind: "auto-approve"
     }
-    slices.set(key, { fingerprint, value, digest });
-    return { value, digest };
-  } finally {
-    leaveReadCohort(filePath, cohort);
+  ]
+});
+var CODEX_CONTAINER_APPROVAL_DESCRIPTIONS = Object.freeze({
+  ask: {
+    "on-request": "Codex has no sandbox of its own in a container, so this asks before any command Codex does not trust, like Untrusted"
+  },
+  "auto-approve": {
+    "on-request": "Codex has no sandbox of its own in a container, so this never asks; choose Untrusted to approve commands",
+    "auto-review": "Codex has no sandbox of its own in a container, so the reviewer is never consulted and everything runs"
   }
+});
+var DISPATCH_OUTCOME_LOST_KIND = "dispatch-outcome-lost";
+var NATIVE_AGENT_RETIRED_DISPATCH_TTL_MS = 24 * 60 * 60 * 1000;
+var SUPPRESSED_COMPOSER_PARAMETERS = Object.freeze({
+  claude: Object.freeze(["parameter:thinking", "parameter:context1m"]),
+  codex: Object.freeze(["parameter:summary"]),
+  cursor: Object.freeze(["parameter:variant"])
+});
+var NATIVE_AGENT_CAPABILITIES = [
+  "file.write",
+  "file.patch",
+  "shell",
+  "shell.mutate",
+  "network",
+  "web.search"
+];
+function isNativeAgentCapability(value) {
+  return typeof value === "string" && NATIVE_AGENT_CAPABILITIES.includes(value);
 }
-
-// ../../bridges/claude-bridge/src/services/plugin-config.ts
-async function pathExists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
+function isNativeAgentExecutionPolicy(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
-  }
-}
-async function scanCliPluginsDirectory(pluginsDir) {
-  if (!await pathExists(pluginsDir)) {
-    return [];
-  }
-  try {
-    const entries = await readdir(pluginsDir, { withFileTypes: true });
-    const plugins = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      const pluginPath = join3(pluginsDir, entry.name);
-      const manifestPath = join3(pluginPath, ".claude-plugin", "plugin.json");
-      if (await pathExists(manifestPath)) {
-        plugins.push({
-          type: "local",
-          path: pluginPath
-        });
-      }
-    }
-    return plugins;
-  } catch {
-    return [];
-  }
-}
-async function loadGlobalPlugins() {
-  const plugins = await readJsonSliceCached(claudeJsonPath(), "plugins", (config) => claudePluginConfigList(config?.plugins));
-  return plugins ?? [];
-}
-async function loadProjectPlugins(cwd) {
-  const plugins = await readJsonSliceCached(join3(cwd, ".claude", "plugins.json"), "plugins", (config) => claudePluginConfigList(config?.plugins));
-  return plugins ?? [];
-}
-async function loadCliInstalledPlugins() {
-  const pluginsDir = claudePluginsDir();
-  const installedPluginsPath = join3(pluginsDir, "installed_plugins.json");
-  const plugins = await readJsonSliceCached(installedPluginsPath, "plugins", (config) => config?.plugins);
-  if (!plugins) {
-    return scanCliPluginsDirectory(pluginsDir);
-  }
-  return remapInstalledPlugins2(pluginsDir, { plugins });
-}
-function pluginSettingsPath(source, cwd) {
-  switch (source) {
-    case "user":
-      return claudeUserSettingsPath();
-    case "project":
-      return join3(cwd, ".claude", "settings.json");
-    case "local":
-      return join3(cwd, ".claude", "settings.local.json");
-  }
-}
-async function loadPluginSettings(cwd, sources) {
-  const entries = await Promise.all(sources.map(async (source) => {
-    const enabledPlugins = await readJsonSliceCached(pluginSettingsPath(source, cwd), "enabledPlugins", (config) => config?.enabledPlugins ?? null);
-    return [source, enabledPlugins === null ? undefined : { enabledPlugins }];
-  }));
-  return Object.fromEntries(entries);
-}
-function remapInstalledPlugins2(pluginsDir, installedPlugins) {
-  return remapInstalledPlugins(pluginsDir, installedPlugins, (installPath) => console.warn(`[plugin-config] Skipping plugin with unsafe install path: "${installPath}"`));
-}
-async function loadProjectOverridesFromGlobal(cwd) {
-  const plugins = await readJsonSliceCached(claudeJsonPath(), `projects:${cwd}:plugins`, (config) => claudePluginConfigList(config?.projects?.[cwd]?.plugins));
-  return plugins ?? [];
-}
-async function readPluginManifest(pluginPath) {
-  const manifestPath = join3(pluginPath, ".claude-plugin", "plugin.json");
-  const manifest = await readJsonSliceCached(manifestPath, "manifest", (config) => config ? { name: config.name, description: config.description } : null);
-  if (!manifest) {
-    return null;
-  }
-  const name = manifest.name || pluginPath.split("/").pop() || "unknown";
-  return {
-    name,
-    description: manifest.description
-  };
+  const policy = value;
+  const isPlainObject = (candidate) => typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+  if (policy.toolPolicy !== undefined && !isPlainObject(policy.toolPolicy))
+    return false;
+  if (policy.capabilityPolicy !== undefined && !isPlainObject(policy.capabilityPolicy))
+    return false;
+  const toolPolicy = policy.toolPolicy;
+  const capabilityPolicy = policy.capabilityPolicy;
+  return (policy.id === "interactive-host" || policy.id === "interactive-container" || policy.id === "coordinator-read-only" || policy.id === "pipeline") && (policy.sandbox === "provider" || policy.sandbox === "container" || policy.sandbox === "none") && (policy.approvals === "ask" || policy.approvals === "auto-approve" || policy.approvals === "deny") && typeof policy.projectResources === "boolean" && (policy.networkAccess === "restricted" || policy.networkAccess === "full") && (policy.containerNetworkAccess === undefined || policy.containerNetworkAccess === "restricted" || policy.containerNetworkAccess === "full") && (policy.note === undefined || typeof policy.note === "string") && (toolPolicy === undefined || (toolPolicy.allow === undefined || Array.isArray(toolPolicy.allow) && toolPolicy.allow.every((item) => typeof item === "string")) && (toolPolicy.deny === undefined || Array.isArray(toolPolicy.deny) && toolPolicy.deny.every((item) => typeof item === "string"))) && (capabilityPolicy === undefined || Array.isArray(capabilityPolicy.deny) && capabilityPolicy.deny.every(isNativeAgentCapability) && (capabilityPolicy.allow === undefined || Array.isArray(capabilityPolicy.allow) && capabilityPolicy.allow.every(isNativeAgentCapability)));
 }
-function resolvePath(pluginPath, cwd) {
-  return resolveClaudePluginPath(pluginPath, cwd, claudeHome());
+function nativeAgentPolicyDeniesWebSearch(policy) {
+  const capabilities = policy?.capabilityPolicy;
+  if (!capabilities)
+    return false;
+  if (capabilities.deny.includes("web.search"))
+    return true;
+  return capabilities.deny.includes("network") && !capabilities.allow?.includes("web.search");
 }
-function defaultSettingSources(includeProjectSources) {
-  return includeProjectSources ? ["user", "project"] : ["user"];
+var MAX_NATIVE_AGENT_DRIFT_KINDS = 16;
+var MAX_NATIVE_AGENT_DRIFT_KIND_LENGTH = 128;
+var NATIVE_AGENT_PENDING_SIGN_IN_TTL_MS = 15 * 60000;
+var BACKGROUND_CAPABLE_SHELL_TOOL_NAMES = new Set([
+  "bash",
+  "shell",
+  "terminal",
+  "run_command",
+  "runcommand",
+  "run_terminal_cmd",
+  "execute_command"
+]);
+var NATIVE_AGENT_COMMAND_EXECUTION_KINDS = [
+  "provider-prompt",
+  "provider-command",
+  "structured-skill",
+  "bridge-template",
+  "bridge-local",
+  "session-action"
+];
+var NATIVE_AGENT_COMMAND_ORIGINS = [
+  "project",
+  "user",
+  "system",
+  "admin",
+  "plugin",
+  "orkestrator",
+  "unknown"
+];
+var NATIVE_AGENT_COMMAND_UNAVAILABLE_REASONS = [
+  "disabled",
+  "shadowed",
+  "reserved-name",
+  "ambiguous",
+  "requires-interactive-ui",
+  "requires-shell-execution",
+  "session-changing",
+  "unqualified",
+  "unsupported",
+  "update-required"
+];
+var NATIVE_AGENT_COMMAND_CATALOGUE_ERROR_CODES = [
+  "timeout",
+  "unreachable",
+  "rejected",
+  "malformed",
+  "too-large",
+  "provider-error",
+  "outdated-bridge"
+];
+var DEFAULT_NATIVE_AGENT_LIVE_WINDOW = {
+  messages: 100,
+  targetBytes: 512 * 1024
+};
+var NATIVE_AGENT_SYNC_MAX_SNAPSHOT_BYTES = 20 * 1024 * 1024;
+var NATIVE_AGENT_SYNC_MAX_PAGE_BYTES = 16 * 1024 * 1024 + 64 * 1024;
+var PROJECTION_FIELD_SET = new Set([
+  "platform",
+  "environmentId",
+  "sessionId",
+  "title",
+  "shareUrl",
+  "cursor",
+  "connection",
+  "turn",
+  "messageWindow",
+  "interactions",
+  "composerControls",
+  "composer",
+  "readiness",
+  "capabilities",
+  "queue",
+  "asyncQuestionResponses",
+  "contextUsage",
+  "rateLimits",
+  "runtime",
+  "runtimeHealthAuthoritative",
+  "notices",
+  "recoverableDispatch",
+  "retiredDispatch",
+  "backgroundTasks",
+  "suggestedPrompt",
+  "completionBlockedByBackgroundTasks",
+  "turnBoundaries",
+  "slashCommands",
+  "slashCommandCatalogue"
+]);
+var OPTIONAL_PROJECTION_FIELD_SET = new Set([
+  "sessionId",
+  "title",
+  "shareUrl",
+  "cursor",
+  "messageWindow",
+  "composer",
+  "readiness",
+  "queue",
+  "asyncQuestionResponses",
+  "contextUsage",
+  "rateLimits",
+  "runtime",
+  "runtimeHealthAuthoritative",
+  "notices",
+  "recoverableDispatch",
+  "retiredDispatch",
+  "backgroundTasks",
+  "suggestedPrompt",
+  "completionBlockedByBackgroundTasks",
+  "turnBoundaries",
+  "slashCommands",
+  "slashCommandCatalogue"
+]);
+
+// ../../bridges/claude-bridge/src/services/coordinator-skills.ts
+import { createHash as createHash4, randomBytes } from "node:crypto";
+import {
+  mkdir as mkdir2,
+  readdir,
+  readFile as readFile3,
+  realpath,
+  rename as rename2,
+  rm as rm2,
+  stat as stat2,
+  symlink,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import { isAbsolute, join as join3 } from "node:path";
+
+// ../protocol/src/coordinator.ts
+var COORDINATOR_COMMAND_SANDBOX_ENV = "ORKESTRATOR_COORDINATOR_COMMAND_SANDBOX";
+function coordinatorCommandSandboxFromEnv(env) {
+  return env[COORDINATOR_COMMAND_SANDBOX_ENV] === "unavailable" ? "unavailable" : "required";
 }
-async function getMergedPlugins(cwd, includeProjectSources = true, settingSources = defaultSettingSources(includeProjectSources)) {
-  const sources = claudePluginSettingSources(settingSources);
-  const [global2, cliInstalled, projectGlobal, projectLocal, settings] = await Promise.all([
-    loadGlobalPlugins(),
-    loadCliInstalledPlugins(),
-    includeProjectSources ? loadProjectOverridesFromGlobal(cwd) : [],
-    includeProjectSources ? loadProjectPlugins(cwd) : [],
-    loadPluginSettings(cwd, sources)
-  ]);
-  return mergeClaudePluginLayers({
-    global: global2,
-    cliInstalled: enabledInstalledPlugins(cliInstalled, settings, sources),
-    projectGlobal,
-    projectLocal
-  }, { cwd, home: claudeHome(), includeProjectSources }).map((path) => ({ type: "local", path }));
+var COORDINATOR_CLAUDE_USER_SKILLS_DIR_ENV = "ORKESTRATOR_COORDINATOR_CLAUDE_USER_SKILLS_DIR";
+var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
+  "ack_message",
+  "add_ticket_comment",
+  "address_multi_review",
+  "adopt_workflow",
+  "cancel_build_pipeline",
+  "cancel_multi_review",
+  "cancel_schedule",
+  "compare_project_files",
+  "create_schedule",
+  "create_ticket",
+  "get_build_pipeline",
+  "get_environment",
+  "get_launch_options",
+  "get_message",
+  "get_message_status",
+  "get_multi_review",
+  "get_repository_context",
+  "get_tab_state",
+  "get_tab_transcript",
+  "get_ticket",
+  "launch_environment",
+  "launch_job",
+  "launch_multi_review",
+  "launch_node_environment",
+  "list_agents",
+  "list_environments",
+  "list_mailboxes",
+  "list_node_environments",
+  "list_nodes",
+  "list_projects",
+  "list_schedules",
+  "list_tabs",
+  "list_tickets",
+  "list_workflows",
+  "open_multi_review",
+  "open_multi_review_fix",
+  "pause_build_pipeline",
+  "read_messages",
+  "read_node_environment",
+  "request_env_value_reveal",
+  "request_environment_deletion",
+  "request_project_file_update",
+  "request_project_on_node",
+  "resume_build_pipeline",
+  "send_message",
+  "send_node_message",
+  "send_prompt_to_node_tab",
+  "send_prompt_to_tab",
+  "start_build_pipeline",
+  "start_environment",
+  "start_multi_review",
+  "start_node_environment",
+  "stop_environment",
+  "stop_node_environment",
+  "transfer_files",
+  "update_ticket"
+]);
+
+// ../../bridges/claude-bridge/src/services/coordinator-skills.ts
+var KEPT_FRONTMATTER_KEYS = Object.freeze([
+  "name",
+  "description",
+  "when_to_use",
+  "argument-hint",
+  "arguments",
+  "disable-model-invocation",
+  "user-invocable",
+  "version"
+]);
+var MIRROR_FORMAT = 1;
+var MAX_SKILLS_PER_SOURCE = 256;
+var MAX_SKILL_FILE_BYTES = 1024 * 1024;
+var MAX_ENTRIES_PER_SKILL = 256;
+var KEPT_OLD_MIRRORS = 4;
+var SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var FRONTMATTER = /^?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+function coordinatorSkillSources(cwd, env = process.env) {
+  const userDir = env[COORDINATOR_CLAUDE_USER_SKILLS_DIR_ENV]?.trim();
+  return [
+    ...userDir && isAbsolute(userDir) ? [{ plugin: "user-skills", dir: userDir }] : [],
+    { plugin: "project-skills", dir: join3(cwd, ".claude", "skills") }
+  ];
 }
-async function getPluginsForSdk(cwd, includeProjectSources = true, settingSources = defaultSettingSources(includeProjectSources)) {
-  const configs = await getMergedPlugins(cwd, includeProjectSources, settingSources);
-  const validPlugins = [];
-  for (const config of configs) {
-    if (await pathExists(config.path)) {
-      validPlugins.push({
-        type: "local",
-        path: config.path
+async function coordinatorSkillPlugins(sources, root = claudeCoordinatorSkillPluginsDir()) {
+  const plugins = [];
+  const skills = [];
+  for (const source of sources) {
+    try {
+      const mirror = await mirrorSkillSource(source, root);
+      if (!mirror)
+        continue;
+      plugins.push({ type: "local", path: mirror.path });
+      skills.push(...mirror.names.map((name) => `${source.plugin}:${name}`));
+    } catch (error) {
+      debugLog("[coordinator-skills] Skipping skills source", {
+        plugin: source.plugin,
+        error: error instanceof Error ? error.message : String(error)
       });
-    } else {
-      const pluginName = config.path.split("/").pop() || "unknown";
-      console.warn(`[plugin-config] Skipping plugin "${pluginName}" - path does not exist: "${config.path}"`);
     }
   }
-  return validPlugins;
+  return { plugins, skills };
 }
-async function getPluginInfo(cwd) {
-  const [global2, cliInstalled, projectGlobal, projectLocal] = await Promise.all([
-    loadGlobalPlugins(),
-    loadCliInstalledPlugins(),
-    loadProjectOverridesFromGlobal(cwd),
-    loadProjectPlugins(cwd)
-  ]);
-  const globalPaths = new Set(global2.map((p) => resolvePath(p.path, cwd)));
-  const cliPaths = new Set(cliInstalled.map((p) => resolvePath(p.path, cwd)));
-  const projectGlobalPaths = new Set(projectGlobal.map((p) => resolvePath(p.path, cwd)));
-  const projectLocalPaths = new Set(projectLocal.map((p) => resolvePath(p.path, cwd)));
-  const merged = await getMergedPlugins(cwd);
-  const result = [];
-  for (const config of merged) {
-    const manifest = await readPluginManifest(config.path);
-    const exists = await pathExists(config.path);
-    let source = "global";
-    if (projectLocalPaths.has(config.path) || projectGlobalPaths.has(config.path)) {
-      source = "project";
-    } else if (cliPaths.has(config.path)) {
-      source = "cli";
-    } else if (globalPaths.has(config.path)) {
-      source = "global";
-    }
-    result.push({
-      name: manifest?.name || config.path.split("/").pop() || "unknown",
-      path: config.path,
-      description: manifest?.description,
-      source,
-      enabled: exists
+async function mirrorSkillSource(source, root) {
+  const dir = await realpath(source.dir).catch(() => {
+    return;
+  });
+  if (!dir)
+    return;
+  const skills = await readSkills(dir);
+  if (skills.length === 0)
+    return;
+  const digest = createHash4("sha256").update(JSON.stringify([MIRROR_FORMAT, source.plugin, dir, skills])).digest("hex").slice(0, 24);
+  const path = join3(root, `${source.plugin}-${digest}`);
+  if (!await isMirror(path))
+    await writeMirror(root, path, source.plugin, skills);
+  await pruneOldMirrors(root, source.plugin, path);
+  return { path, names: skills.map((skill) => skill.name) };
+}
+async function readSkills(dir) {
+  const entries = (await readdir(dir)).filter((name) => !name.startsWith(".")).sort();
+  const skills = [];
+  const names = new Set;
+  for (const entry of entries) {
+    if (skills.length >= MAX_SKILLS_PER_SOURCE)
+      break;
+    const skillDir = await realpath(join3(dir, entry)).catch(() => {
+      return;
     });
+    if (!skillDir || !(await stat2(skillDir).catch(() => {
+      return;
+    }))?.isDirectory())
+      continue;
+    const skill = await readSkill(skillDir, entry);
+    if (!skill || names.has(skill.name))
+      continue;
+    names.add(skill.name);
+    skills.push(skill);
   }
-  return result;
+  return skills;
 }
-
-// ../../bridges/claude-bridge/src/services/runtime-env.ts
-import { execFile as execFile2 } from "node:child_process";
-import { readFile as readFile3 } from "node:fs/promises";
-import { promisify } from "node:util";
-var GITHUB_CREDENTIAL_FILE_ENV = "ORKESTRATOR_GITHUB_CREDENTIAL_FILE";
-var GITHUB_MCP_TOKEN_ENV = "GITHUB_PERSONAL_ACCESS_TOKEN";
-var execFileAsync = promisify(execFile2);
-var GH_TOKEN_TIMEOUT_MS = 2000;
-var GH_TOKEN_CACHE_MS = 5 * 60000;
-var GH_TOKEN_FAILURE_CACHE_MS = 15000;
-var ghTokenCache = new WeakMap;
-async function readGitHubCliToken(env) {
-  try {
-    const { stdout } = await execFileAsync("gh", ["auth", "token", "--hostname", "github.com"], {
-      env,
-      timeout: GH_TOKEN_TIMEOUT_MS
-    });
-    return stdout.trim() || undefined;
-  } catch {
+async function readSkill(skillDir, dirName) {
+  const entries = await readdir(skillDir);
+  const skillFile = entries.find((entry) => entry === "SKILL.md");
+  if (!skillFile)
+    return;
+  const file = join3(skillDir, skillFile);
+  const info = await stat2(file).catch(() => {
+    return;
+  });
+  if (!info?.isFile() || info.size > MAX_SKILL_FILE_BYTES)
+    return;
+  const sanitized = sanitizeSkillFile(await readFile3(file, "utf8"), dirName);
+  if (!sanitized) {
+    debugLog("[coordinator-skills] Skipping skill with unreadable frontmatter", { dirName });
+    return;
+  }
+  const links = entries.filter((entry) => entry.toLowerCase() !== "skill.md").sort().slice(0, MAX_ENTRIES_PER_SKILL).map((entry) => [entry, join3(skillDir, entry)]);
+  return { name: sanitized.name, text: sanitized.text, links };
+}
+function yamlParser() {
+  const parse = globalThis.Bun?.YAML?.parse;
+  return typeof parse === "function" ? parse : null;
+}
+function sanitizeSkillFile(text, dirName, parse = yamlParser()) {
+  const match = FRONTMATTER.exec(text);
+  let fields = {};
+  if (match) {
+    if (!parse)
+      return;
+    let parsed;
+    try {
+      parsed = parse(match[1]);
+    } catch {
+      return;
+    }
+    if (parsed !== null && parsed !== undefined) {
+      if (typeof parsed !== "object" || Array.isArray(parsed))
+        return;
+      fields = parsed;
+    }
+  }
+  const declared = typeof fields.name === "string" ? fields.name.trim() : "";
+  const name = SKILL_NAME.test(declared) ? declared : dirName;
+  if (!SKILL_NAME.test(name))
     return;
+  const lines = [`name: ${JSON.stringify(name)}`];
+  for (const key of KEPT_FRONTMATTER_KEYS) {
+    if (key === "name" || !Object.hasOwn(fields, key))
+      continue;
+    const value = frontmatterValue(fields[key]);
+    if (value !== undefined)
+      lines.push(`${key}: ${value}`);
   }
+  const body = match ? text.slice(match[0].length) : text.replace(/^/, "");
+  return { name, text: `---
+${lines.join(`
+`)}
+---
+${body}` };
 }
-function cachedGitHubCliToken(env, reader) {
-  const key = JSON.stringify([env.PATH, env.HOME, env.XDG_CONFIG_HOME, env.GH_CONFIG_DIR]);
-  let entries = ghTokenCache.get(reader);
-  if (!entries) {
-    entries = new Map;
-    ghTokenCache.set(reader, entries);
-  }
-  const now = Date.now();
-  const cached = entries.get(key);
-  if (cached && cached.expiresAt > now)
-    return cached.value;
-  if (!cached && entries.size >= 8)
-    entries.clear();
-  const value = Promise.resolve().then(() => reader(env)).catch(() => {
+function frontmatterValue(value) {
+  if (typeof value === "string" || typeof value === "boolean")
+    return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value))
+    return JSON.stringify(String(value));
+  if (Array.isArray(value) && value.every((item) => typeof item === "string"))
+    return JSON.stringify(value);
+  return;
+}
+async function isMirror(path) {
+  return (await stat2(join3(path, ".claude-plugin", "plugin.json")).catch(() => {
     return;
-  }).then((token) => {
-    if (entries.get(key)?.value === value) {
-      entries.set(key, {
-        value: Promise.resolve(token),
-        expiresAt: Date.now() + (token ? GH_TOKEN_CACHE_MS : GH_TOKEN_FAILURE_CACHE_MS)
-      });
-    }
-    return token;
-  });
-  entries.set(key, { value, expiresAt: now + GH_TOKEN_TIMEOUT_MS });
-  return value;
+  }))?.isFile() ? true : false;
 }
-async function runtimeEnvironmentForAgentQuery(env = process.env, readTextFile = readFile3, readGhToken = readGitHubCliToken) {
-  const snapshot = { ...env };
-  const credentialFile = env[GITHUB_CREDENTIAL_FILE_ENV]?.trim();
-  if (!credentialFile) {
-    if (!snapshot[GITHUB_MCP_TOKEN_ENV]?.trim()) {
-      const token = snapshot.GH_TOKEN?.trim() || snapshot.GITHUB_TOKEN?.trim() || await cachedGitHubCliToken(snapshot, readGhToken);
-      if (token)
-        snapshot[GITHUB_MCP_TOKEN_ENV] = token;
+async function writeMirror(root, path, plugin, skills) {
+  await mkdir2(root, { recursive: true, mode: 448 });
+  const staging = join3(root, `.staging-${randomBytes(8).toString("hex")}`);
+  try {
+    await mkdir2(join3(staging, ".claude-plugin"), { recursive: true });
+    await writeFile2(join3(staging, ".claude-plugin", "plugin.json"), JSON.stringify({
+      name: plugin,
+      description: plugin === "user-skills" ? "The user's own Claude skills, mirrored by Orkestrator without hooks or tool grants." : "This project's .claude/skills, mirrored by Orkestrator without hooks or tool grants."
+    }));
+    for (const skill of skills) {
+      const skillDir = join3(staging, "skills", skill.name);
+      await mkdir2(skillDir, { recursive: true });
+      await writeFile2(join3(skillDir, "SKILL.md"), skill.text);
+      for (const [name, target] of skill.links)
+        await symlink(target, join3(skillDir, name));
     }
-    return snapshot;
+    try {
+      await rename2(staging, path);
+    } catch (error) {
+      if (!await isMirror(path))
+        throw error;
+    }
+  } finally {
+    await rm2(staging, { recursive: true, force: true });
   }
-  let token = "";
+}
+async function pruneOldMirrors(root, plugin, current) {
   try {
-    token = (await readTextFile(credentialFile, "utf8")).trim();
+    const old = await Promise.all((await readdir(root)).filter((name) => name.startsWith(`${plugin}-`) && join3(root, name) !== current).map(async (name) => ({
+      path: join3(root, name),
+      mtimeMs: (await stat2(join3(root, name)).catch(() => {
+        return;
+      }))?.mtimeMs ?? 0
+    })));
+    old.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const { path } of old.slice(KEPT_OLD_MIRRORS)) {
+      await rm2(path, { recursive: true, force: true });
+    }
   } catch {}
-  if (token) {
-    snapshot.GITHUB_TOKEN = token;
-    snapshot.GH_TOKEN = token;
-    snapshot[GITHUB_MCP_TOKEN_ENV] = token;
-  } else {
-    delete snapshot.GITHUB_TOKEN;
-    delete snapshot.GH_TOKEN;
-    delete snapshot[GITHUB_MCP_TOKEN_ENV];
-  }
-  return snapshot;
 }
 
-// ../protocol/src/native-agent-transcript-patch.ts
-var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+// ../../bridges/claude-bridge/src/services/plugin-config.ts
+import { readdir as readdir2, access } from "node:fs/promises";
+import { join as join4 } from "node:path";
 
-// ../protocol/src/native-agent-policy-effects.ts
-function appendNativeAgentPolicyNote(policy, note) {
-  return { ...policy, note: policy.note ? `${policy.note} ${note}` : note };
+// ../protocol/src/node/claude-plugin-set.ts
+import path from "node:path";
+var CLAUDE_PLUGINS_MARKER = "/.claude/plugins/";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var READ_ONLY_TURN_POLICY_NOTE = "The current turn is read-only, so it runs under the read-only policy rather than this session's own.";
-function readOnlyTurnReportedPolicy(turnPolicy) {
-  return appendNativeAgentPolicyNote(turnPolicy, READ_ONLY_TURN_POLICY_NOTE);
+function claudePluginConfigList(value) {
+  if (!Array.isArray(value))
+    return [];
+  const plugins = [];
+  for (const item of value) {
+    if (isRecord(item) && typeof item.path === "string" && item.path) {
+      plugins.push({ type: "local", path: item.path });
+    }
+  }
+  return plugins;
+}
+function isPathWithin(parentDir, candidatePath) {
+  const relativePath = path.relative(parentDir, candidatePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+function remapInstalledPlugins(pluginsDir, installedPlugins, onUnsafe) {
+  const plugins = [];
+  const pluginsRoot = path.resolve(pluginsDir);
+  if (!isRecord(installedPlugins.plugins))
+    return plugins;
+  for (const [installedId, entries] of Object.entries(installedPlugins.plugins)) {
+    if (!Array.isArray(entries))
+      continue;
+    for (const entry of entries) {
+      if (!isRecord(entry) || typeof entry.installPath !== "string")
+        continue;
+      const installPath = entry.installPath;
+      const markerIdx = installPath.indexOf(CLAUDE_PLUGINS_MARKER);
+      let resolvedPath;
+      if (markerIdx !== -1) {
+        const relativePath = installPath.substring(markerIdx + CLAUDE_PLUGINS_MARKER.length);
+        const remappedPath = path.resolve(pluginsDir, relativePath);
+        if (!isPathWithin(pluginsRoot, remappedPath)) {
+          onUnsafe?.(installPath);
+          continue;
+        }
+        resolvedPath = remappedPath;
+      } else {
+        resolvedPath = installPath;
+      }
+      plugins.push({ type: "local", path: resolvedPath, installedId });
+    }
+  }
+  return plugins;
+}
+function resolveClaudePluginPath(pluginPath, cwd, home) {
+  if (pluginPath.startsWith("~"))
+    return path.join(home, pluginPath.slice(1));
+  if (pluginPath.startsWith("/"))
+    return pluginPath;
+  return path.join(cwd, pluginPath);
+}
+function mergeClaudePluginLayers(layers, options) {
+  const ordered = [
+    claudePluginConfigList(layers.global),
+    layers.cliInstalled,
+    ...options.includeProjectSources ? [claudePluginConfigList(layers.projectGlobal), claudePluginConfigList(layers.projectLocal)] : []
+  ];
+  const seen = new Set;
+  const paths = [];
+  for (const layer of ordered) {
+    for (const plugin of layer) {
+      const resolved = resolveClaudePluginPath(plugin.path, options.cwd, options.home);
+      if (seen.has(resolved))
+        continue;
+      seen.add(resolved);
+      paths.push(resolved);
+    }
+  }
+  return paths;
+}
+var INVALID_PLUGIN_NAME = new RegExp("[@:\\s/\\\\\\u0000-\\u001f\\u007f\\u200b-\\u200f\\u2028-\\u202e\\u2060-\\u2064\\ufeff]");
+var CLAUDE_PLUGIN_SETTING_SOURCES = ["local", "project", "user"];
+function claudeInstalledPluginIdEnablement(id, settings, loadedSources) {
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  for (const source of ["local", "project", "user"]) {
+    if (!loadedSources.includes(source))
+      continue;
+    const document = settings[source];
+    const enabledPlugins = isRecord(document) ? document.enabledPlugins : undefined;
+    if (!isRecord(enabledPlugins) || !Object.hasOwn(enabledPlugins, id))
+      continue;
+    return { enabled: enabledPlugins[id] === true, decidedBy: { source, key: id } };
+  }
+  return { enabled: false };
+}
+function enabledInstalledPlugins(plugins, settings, loadedSources) {
+  return plugins.filter((plugin) => plugin.installedId === undefined || claudeInstalledPluginIdEnablement(plugin.installedId, settings, loadedSources).enabled);
+}
+function claudePluginSettingSources(settingSources) {
+  return CLAUDE_PLUGIN_SETTING_SOURCES.filter((source) => settingSources.includes(source));
 }
 
-// ../protocol/src/native-agent-steer-rejection.ts
-var NATIVE_AGENT_STEER_REJECTION_HTTP_STATUS = 429;
-var MAX_STEER_JOURNAL_BYTES = 1024 * 1024 * 1024;
-// ../protocol/src/native-agent.ts
-var DEFAULT_OPENCODE_MODEL_PROVIDERS = Object.freeze([
-  "opencode",
-  "opencode-go"
-]);
-var NATIVE_AGENT_APPROVAL_MODES = Object.freeze({
-  claude: [
-    {
-      id: "default",
-      label: "Ask",
-      description: "Ask before editing files or running commands",
-      kind: "ask"
-    },
-    {
-      id: "acceptEdits",
-      label: "Accept edits",
-      description: "Apply file edits without asking; ask before running commands",
-      kind: "auto-edits"
-    },
-    {
-      id: "auto",
-      label: "Auto",
-      description: "A model reviews each action, approving safe ones and blocking risky ones",
-      kind: "auto-review"
-    },
-    {
-      id: "bypassPermissions",
-      label: "Bypass",
-      description: "Approve everything without asking",
-      kind: "auto-approve"
+// ../../bridges/claude-bridge/src/services/json-file-cache.ts
+import { createHash as createHash5 } from "node:crypto";
+import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+var SEPARATOR = "\x00";
+var slices = new Map;
+var readCohorts = new Map;
+var parseCounts = new Map;
+var beforeStatForTesting = null;
+function fingerprintOf(stats) {
+  return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}`;
+}
+function forgetFile(filePath) {
+  const prefix = `${filePath}${SEPARATOR}`;
+  for (const key of slices.keys()) {
+    if (key.startsWith(prefix))
+      slices.delete(key);
+  }
+}
+function joinReadCohort(filePath) {
+  const existing = readCohorts.get(filePath);
+  if (existing) {
+    existing.readers += 1;
+    return existing;
+  }
+  const cohort = { readers: 1, parses: new Map };
+  readCohorts.set(filePath, cohort);
+  return cohort;
+}
+function leaveReadCohort(filePath, cohort) {
+  cohort.readers -= 1;
+  if (cohort.readers === 0 && readCohorts.get(filePath) === cohort) {
+    readCohorts.delete(filePath);
+  }
+}
+function parseOnce(filePath, fingerprint, cohort) {
+  const existing = cohort.parses.get(fingerprint);
+  if (existing)
+    return existing;
+  const parse = (async () => {
+    parseCounts.set(filePath, (parseCounts.get(filePath) ?? 0) + 1);
+    let bytes;
+    try {
+      bytes = await readFile4(filePath);
+    } catch {
+      return { parsed: null, digest: null };
+    }
+    const digest = createHash5("sha256").update(bytes).digest("base64url");
+    try {
+      return { parsed: JSON.parse(bytes.toString("utf-8")), digest };
+    } catch {
+      return { parsed: null, digest };
     }
-  ],
-  codex: [
-    {
-      id: "untrusted",
-      label: "Untrusted",
-      description: "Ask before running any command Codex does not trust",
-      kind: "ask"
-    },
-    {
-      id: "on-request",
-      label: "On request",
-      description: "Work in a sandbox; Codex asks before stepping outside it",
-      kind: "ask"
-    },
-    {
-      id: "auto-review",
-      label: "Auto review",
-      description: "Work in a sandbox; a reviewer agent decides when Codex may step outside it",
-      kind: "auto-review"
-    },
-    {
-      id: "never",
-      label: "Full access",
-      description: "Never ask; run everything",
-      kind: "auto-approve"
+  })();
+  cohort.parses.set(fingerprint, parse);
+  return parse;
+}
+async function readJsonSliceCached(filePath, sliceKey, select) {
+  return (await readJsonSliceCachedWithDigest(filePath, sliceKey, select)).value;
+}
+async function readJsonSliceCachedWithDigest(filePath, sliceKey, select) {
+  const cohort = joinReadCohort(filePath);
+  try {
+    await beforeStatForTesting?.(filePath);
+    let fingerprint;
+    try {
+      fingerprint = fingerprintOf(await stat3(filePath));
+    } catch {
+      forgetFile(filePath);
+      return { value: null, digest: null };
     }
-  ]
-});
-var CODEX_CONTAINER_APPROVAL_DESCRIPTIONS = Object.freeze({
-  ask: {
-    "on-request": "Codex has no sandbox of its own in a container, so this asks before any command Codex does not trust, like Untrusted"
-  },
-  "auto-approve": {
-    "on-request": "Codex has no sandbox of its own in a container, so this never asks; choose Untrusted to approve commands",
-    "auto-review": "Codex has no sandbox of its own in a container, so the reviewer is never consulted and everything runs"
+    const key = `${filePath}${SEPARATOR}${sliceKey}`;
+    const cached = slices.get(key);
+    if (cached && cached.fingerprint === fingerprint) {
+      return { value: cached.value, digest: cached.digest };
+    }
+    const { parsed, digest } = await parseOnce(filePath, fingerprint, cohort);
+    let value = null;
+    if (parsed !== null && parsed !== undefined) {
+      try {
+        value = select(parsed) ?? null;
+      } catch {
+        value = null;
+      }
+    }
+    slices.set(key, { fingerprint, value, digest });
+    return { value, digest };
+  } finally {
+    leaveReadCohort(filePath, cohort);
   }
-});
-var DISPATCH_OUTCOME_LOST_KIND = "dispatch-outcome-lost";
-var NATIVE_AGENT_RETIRED_DISPATCH_TTL_MS = 24 * 60 * 60 * 1000;
-var SUPPRESSED_COMPOSER_PARAMETERS = Object.freeze({
-  claude: Object.freeze(["parameter:thinking", "parameter:context1m"]),
-  codex: Object.freeze(["parameter:summary"]),
-  cursor: Object.freeze(["parameter:variant"])
-});
-var NATIVE_AGENT_CAPABILITIES = [
-  "file.write",
-  "file.patch",
-  "shell",
-  "shell.mutate",
-  "network",
-  "web.search"
-];
-function isNativeAgentCapability(value) {
-  return typeof value === "string" && NATIVE_AGENT_CAPABILITIES.includes(value);
 }
-function isNativeAgentExecutionPolicy(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const policy = value;
-  const isPlainObject = (candidate) => typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
-  if (policy.toolPolicy !== undefined && !isPlainObject(policy.toolPolicy))
-    return false;
-  if (policy.capabilityPolicy !== undefined && !isPlainObject(policy.capabilityPolicy))
+
+// ../../bridges/claude-bridge/src/services/plugin-config.ts
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
     return false;
-  const toolPolicy = policy.toolPolicy;
-  const capabilityPolicy = policy.capabilityPolicy;
-  return (policy.id === "interactive-host" || policy.id === "interactive-container" || policy.id === "coordinator-read-only" || policy.id === "pipeline") && (policy.sandbox === "provider" || policy.sandbox === "container" || policy.sandbox === "none") && (policy.approvals === "ask" || policy.approvals === "auto-approve" || policy.approvals === "deny") && typeof policy.projectResources === "boolean" && (policy.networkAccess === "restricted" || policy.networkAccess === "full") && (policy.containerNetworkAccess === undefined || policy.containerNetworkAccess === "restricted" || policy.containerNetworkAccess === "full") && (policy.note === undefined || typeof policy.note === "string") && (toolPolicy === undefined || (toolPolicy.allow === undefined || Array.isArray(toolPolicy.allow) && toolPolicy.allow.every((item) => typeof item === "string")) && (toolPolicy.deny === undefined || Array.isArray(toolPolicy.deny) && toolPolicy.deny.every((item) => typeof item === "string"))) && (capabilityPolicy === undefined || Array.isArray(capabilityPolicy.deny) && capabilityPolicy.deny.every(isNativeAgentCapability) && (capabilityPolicy.allow === undefined || Array.isArray(capabilityPolicy.allow) && capabilityPolicy.allow.every(isNativeAgentCapability)));
+  }
 }
-function nativeAgentPolicyDeniesWebSearch(policy) {
-  const capabilities = policy?.capabilityPolicy;
-  if (!capabilities)
-    return false;
-  if (capabilities.deny.includes("web.search"))
-    return true;
-  return capabilities.deny.includes("network") && !capabilities.allow?.includes("web.search");
+async function scanCliPluginsDirectory(pluginsDir) {
+  if (!await pathExists(pluginsDir)) {
+    return [];
+  }
+  try {
+    const entries = await readdir2(pluginsDir, { withFileTypes: true });
+    const plugins = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const pluginPath = join4(pluginsDir, entry.name);
+      const manifestPath = join4(pluginPath, ".claude-plugin", "plugin.json");
+      if (await pathExists(manifestPath)) {
+        plugins.push({
+          type: "local",
+          path: pluginPath
+        });
+      }
+    }
+    return plugins;
+  } catch {
+    return [];
+  }
+}
+async function loadGlobalPlugins() {
+  const plugins = await readJsonSliceCached(claudeJsonPath(), "plugins", (config) => claudePluginConfigList(config?.plugins));
+  return plugins ?? [];
+}
+async function loadProjectPlugins(cwd) {
+  const plugins = await readJsonSliceCached(join4(cwd, ".claude", "plugins.json"), "plugins", (config) => claudePluginConfigList(config?.plugins));
+  return plugins ?? [];
+}
+async function loadCliInstalledPlugins() {
+  const pluginsDir = claudePluginsDir();
+  const installedPluginsPath = join4(pluginsDir, "installed_plugins.json");
+  const plugins = await readJsonSliceCached(installedPluginsPath, "plugins", (config) => config?.plugins);
+  if (!plugins) {
+    return scanCliPluginsDirectory(pluginsDir);
+  }
+  return remapInstalledPlugins2(pluginsDir, { plugins });
+}
+function pluginSettingsPath(source, cwd) {
+  switch (source) {
+    case "user":
+      return claudeUserSettingsPath();
+    case "project":
+      return join4(cwd, ".claude", "settings.json");
+    case "local":
+      return join4(cwd, ".claude", "settings.local.json");
+  }
+}
+async function loadPluginSettings(cwd, sources) {
+  const entries = await Promise.all(sources.map(async (source) => {
+    const enabledPlugins = await readJsonSliceCached(pluginSettingsPath(source, cwd), "enabledPlugins", (config) => config?.enabledPlugins ?? null);
+    return [source, enabledPlugins === null ? undefined : { enabledPlugins }];
+  }));
+  return Object.fromEntries(entries);
+}
+function remapInstalledPlugins2(pluginsDir, installedPlugins) {
+  return remapInstalledPlugins(pluginsDir, installedPlugins, (installPath) => console.warn(`[plugin-config] Skipping plugin with unsafe install path: "${installPath}"`));
+}
+async function loadProjectOverridesFromGlobal(cwd) {
+  const plugins = await readJsonSliceCached(claudeJsonPath(), `projects:${cwd}:plugins`, (config) => claudePluginConfigList(config?.projects?.[cwd]?.plugins));
+  return plugins ?? [];
+}
+async function readPluginManifest(pluginPath) {
+  const manifestPath = join4(pluginPath, ".claude-plugin", "plugin.json");
+  const manifest = await readJsonSliceCached(manifestPath, "manifest", (config) => config ? { name: config.name, description: config.description } : null);
+  if (!manifest) {
+    return null;
+  }
+  const name = manifest.name || pluginPath.split("/").pop() || "unknown";
+  return {
+    name,
+    description: manifest.description
+  };
+}
+function resolvePath(pluginPath, cwd) {
+  return resolveClaudePluginPath(pluginPath, cwd, claudeHome());
+}
+function defaultSettingSources(includeProjectSources) {
+  return includeProjectSources ? ["user", "project"] : ["user"];
+}
+async function getMergedPlugins(cwd, includeProjectSources = true, settingSources = defaultSettingSources(includeProjectSources)) {
+  const sources = claudePluginSettingSources(settingSources);
+  const [global2, cliInstalled, projectGlobal, projectLocal, settings] = await Promise.all([
+    loadGlobalPlugins(),
+    loadCliInstalledPlugins(),
+    includeProjectSources ? loadProjectOverridesFromGlobal(cwd) : [],
+    includeProjectSources ? loadProjectPlugins(cwd) : [],
+    loadPluginSettings(cwd, sources)
+  ]);
+  return mergeClaudePluginLayers({
+    global: global2,
+    cliInstalled: enabledInstalledPlugins(cliInstalled, settings, sources),
+    projectGlobal,
+    projectLocal
+  }, { cwd, home: claudeHome(), includeProjectSources }).map((path) => ({ type: "local", path }));
+}
+async function getPluginsForSdk(cwd, includeProjectSources = true, settingSources = defaultSettingSources(includeProjectSources)) {
+  const configs = await getMergedPlugins(cwd, includeProjectSources, settingSources);
+  const validPlugins = [];
+  for (const config of configs) {
+    if (await pathExists(config.path)) {
+      validPlugins.push({
+        type: "local",
+        path: config.path
+      });
+    } else {
+      const pluginName = config.path.split("/").pop() || "unknown";
+      console.warn(`[plugin-config] Skipping plugin "${pluginName}" - path does not exist: "${config.path}"`);
+    }
+  }
+  return validPlugins;
+}
+async function getPluginInfo(cwd) {
+  const [global2, cliInstalled, projectGlobal, projectLocal] = await Promise.all([
+    loadGlobalPlugins(),
+    loadCliInstalledPlugins(),
+    loadProjectOverridesFromGlobal(cwd),
+    loadProjectPlugins(cwd)
+  ]);
+  const globalPaths = new Set(global2.map((p) => resolvePath(p.path, cwd)));
+  const cliPaths = new Set(cliInstalled.map((p) => resolvePath(p.path, cwd)));
+  const projectGlobalPaths = new Set(projectGlobal.map((p) => resolvePath(p.path, cwd)));
+  const projectLocalPaths = new Set(projectLocal.map((p) => resolvePath(p.path, cwd)));
+  const merged = await getMergedPlugins(cwd);
+  const result = [];
+  for (const config of merged) {
+    const manifest = await readPluginManifest(config.path);
+    const exists = await pathExists(config.path);
+    let source = "global";
+    if (projectLocalPaths.has(config.path) || projectGlobalPaths.has(config.path)) {
+      source = "project";
+    } else if (cliPaths.has(config.path)) {
+      source = "cli";
+    } else if (globalPaths.has(config.path)) {
+      source = "global";
+    }
+    result.push({
+      name: manifest?.name || config.path.split("/").pop() || "unknown",
+      path: config.path,
+      description: manifest?.description,
+      source,
+      enabled: exists
+    });
+  }
+  return result;
 }
-var MAX_NATIVE_AGENT_DRIFT_KINDS = 16;
-var MAX_NATIVE_AGENT_DRIFT_KIND_LENGTH = 128;
-var NATIVE_AGENT_PENDING_SIGN_IN_TTL_MS = 15 * 60000;
-var BACKGROUND_CAPABLE_SHELL_TOOL_NAMES = new Set([
-  "bash",
-  "shell",
-  "terminal",
-  "run_command",
-  "runcommand",
-  "run_terminal_cmd",
-  "execute_command"
-]);
-var NATIVE_AGENT_COMMAND_EXECUTION_KINDS = [
-  "provider-prompt",
-  "provider-command",
-  "structured-skill",
-  "bridge-template",
-  "bridge-local",
-  "session-action"
-];
-var NATIVE_AGENT_COMMAND_ORIGINS = [
-  "project",
-  "user",
-  "system",
-  "admin",
-  "plugin",
-  "orkestrator",
-  "unknown"
-];
-var NATIVE_AGENT_COMMAND_UNAVAILABLE_REASONS = [
-  "disabled",
-  "shadowed",
-  "reserved-name",
-  "ambiguous",
-  "requires-interactive-ui",
-  "requires-shell-execution",
-  "session-changing",
-  "unqualified",
-  "unsupported",
-  "update-required"
-];
-var NATIVE_AGENT_COMMAND_CATALOGUE_ERROR_CODES = [
-  "timeout",
-  "unreachable",
-  "rejected",
-  "malformed",
-  "too-large",
-  "provider-error",
-  "outdated-bridge"
-];
-var DEFAULT_NATIVE_AGENT_LIVE_WINDOW = {
-  messages: 100,
-  targetBytes: 512 * 1024
-};
-var NATIVE_AGENT_SYNC_MAX_SNAPSHOT_BYTES = 20 * 1024 * 1024;
-var NATIVE_AGENT_SYNC_MAX_PAGE_BYTES = 16 * 1024 * 1024 + 64 * 1024;
-var PROJECTION_FIELD_SET = new Set([
-  "platform",
-  "environmentId",
-  "sessionId",
-  "title",
-  "shareUrl",
-  "cursor",
-  "connection",
-  "turn",
-  "messageWindow",
-  "interactions",
-  "composerControls",
-  "composer",
-  "readiness",
-  "capabilities",
-  "queue",
-  "asyncQuestionResponses",
-  "contextUsage",
-  "rateLimits",
-  "runtime",
-  "runtimeHealthAuthoritative",
-  "notices",
-  "recoverableDispatch",
-  "retiredDispatch",
-  "backgroundTasks",
-  "suggestedPrompt",
-  "completionBlockedByBackgroundTasks",
-  "turnBoundaries",
-  "slashCommands",
-  "slashCommandCatalogue"
-]);
-var OPTIONAL_PROJECTION_FIELD_SET = new Set([
-  "sessionId",
-  "title",
-  "shareUrl",
-  "cursor",
-  "messageWindow",
-  "composer",
-  "readiness",
-  "queue",
-  "asyncQuestionResponses",
-  "contextUsage",
-  "rateLimits",
-  "runtime",
-  "runtimeHealthAuthoritative",
-  "notices",
-  "recoverableDispatch",
-  "retiredDispatch",
-  "backgroundTasks",
-  "suggestedPrompt",
-  "completionBlockedByBackgroundTasks",
-  "turnBoundaries",
-  "slashCommands",
-  "slashCommandCatalogue"
-]);
 
 // ../protocol/src/coordinator-web-research.ts
 var COORDINATOR_WEB_RESEARCH_MODES = ["off", "search", "search-and-mcp"];
@@ -4530,11 +4840,11 @@ function claudeMcpToolPrefix(name) {
 
 // ../../bridges/claude-bridge/src/services/read-only-policy.ts
 var CAPABILITY_TOOLS = new Map([
-  ["file.write", ["Write", "NotebookEdit"]],
+  ["file.write", ["Write", "NotebookEdit", "EnterWorktree", "ExitWorktree"]],
   ["file.patch", ["Edit", "MultiEdit", "ApplyPatch"]],
-  ["shell", ["Bash", "BashOutput", "KillShell"]],
-  ["shell.mutate", []],
-  ["network", ["WebFetch", "WebSearch"]],
+  ["shell", ["Bash", "BashOutput", "KillShell", "PowerShell"]],
+  ["shell.mutate", ["PowerShell"]],
+  ["network", ["WebFetch", "WebSearch", "RemoteTrigger"]],
   ["web.search", ["WebSearch"]]
 ]);
 var READ_ONLY_TOOLS = Object.freeze([
@@ -4782,6 +5092,7 @@ function claudeDisallowedTools(policy) {
 function claudeReadOnlyAllowedTools(options) {
   return [
     ...READ_ONLY_TOOLS,
+    ...(options.skillNames ?? []).map((name) => `Skill(${name})`),
     ...options.policy && !nativeAgentPolicyDeniesWebSearch(options.policy) ? ["WebSearch"] : [],
     ...(options.agentMcpServerNames ?? []).map((name) => `${claudeMcpToolPrefix(name)}*`),
     ...(options.researchMcpServerNames ?? []).map((name) => `${claudeMcpToolPrefix(name)}*`)
@@ -5033,16 +5344,36 @@ function claudeSettingSources(policy, includeLocalSettings) {
     return ["user"];
   return includeLocalSettings ? ["user", "project", "local"] : ["user", "project"];
 }
+function claudeManagedSettings(policy) {
+  return isCoordinatorReadOnlyPolicy(policy) ? { allowManagedHooksOnly: true, disableSkillShellExecution: true } : undefined;
+}
+function loadsCoordinatorSkills(policy, env = process.env) {
+  return isCoordinatorReadOnlyPolicy(policy) && processExecutionPolicyIsCoordinator(env);
+}
+async function resolveClaudeTurnPlugins(cwd, policy, settingSources) {
+  const [plugins, skills] = await Promise.all([
+    getPluginsForSdk(cwd, policy?.projectResources !== false, settingSources),
+    loadsCoordinatorSkills(policy) ? coordinatorSkillPlugins(coordinatorSkillSources(cwd)) : { plugins: [], skills: [] }
+  ]);
+  return { plugins: [...plugins, ...skills.plugins], coordinatorSkills: skills.skills };
+}
 async function resolveClaudeDiscoveryConfig(sessionPolicy, inputs) {
   const policy = claudeTurnPolicy(sessionPolicy, inputs.readOnly);
   const cwd = claudeWorkspaceCwd();
   const settingSources = claudeSettingSources(policy, inputs.includeLocalSettings);
-  const plugins = await getPluginsForSdk(cwd, policy?.projectResources !== false, settingSources);
+  const { plugins } = await resolveClaudeTurnPlugins(cwd, policy, settingSources);
+  const managedSettings = claudeManagedSettings(policy);
   return {
     cwd,
     settingSources,
     plugins,
-    fingerprint: JSON.stringify([cwd, settingSources, plugins.map((plugin) => plugin.path)])
+    managedSettings,
+    fingerprint: JSON.stringify([
+      cwd,
+      settingSources,
+      plugins.map((plugin) => plugin.path),
+      managedSettings ?? null
+    ])
   };
 }
 function effectiveClaudeChrome(policy, options) {
@@ -5060,6 +5391,15 @@ var LIVE_BACKGROUND_TASK_STATUSES = new Set([
   "running",
   "paused"
 ]);
+var CLAUDE_RESUME_ORPHAN_SUMMARY = "Orphaned by a previous Claude Code process exit and reported in an aggregate summary.";
+function resumeOrphanScanOutcome(message, previous) {
+  if (message.subtype !== "task_notification" || message.status !== "stopped" || message.summary !== CLAUDE_RESUME_ORPHAN_SUMMARY) {
+    return;
+  }
+  if (!previous)
+    return "cleanup";
+  return LIVE_BACKGROUND_TASK_STATUSES.has(previous.status) ? undefined : "already-settled";
+}
 function registerBackgroundTaskCandidate(session, toolUseId, control) {
   const candidates = session.backgroundTaskCandidates ??= new Map;
   if (!candidates.has(toolUseId) && candidates.size >= MAX_BACKGROUND_TASK_CANDIDATES) {
@@ -6380,6 +6720,36 @@ var RECOGNIZED_UNRENDERED_BLOCK_TYPES = new Set([
   "document",
   "redacted_thinking"
 ]);
+function persistedUserImageParts(record) {
+  if (record.type !== "user" || !isRootAssistantRecord(record.parent_tool_use_id, record.isSidechain))
+    return [];
+  const content = record.message?.content;
+  if (!Array.isArray(content))
+    return [];
+  if (content.some((block) => block?.type === "tool_result"))
+    return [];
+  const parts = [];
+  for (const block of content) {
+    if (block?.type !== "image")
+      continue;
+    const source = block.source;
+    if (source?.type !== "base64" || typeof source.media_type !== "string" || typeof source.data !== "string") {
+      continue;
+    }
+    const parsed = parseBase64ImageData(`data:${source.media_type};base64,${source.data}`);
+    if (!parsed?.mediaType)
+      continue;
+    const mediaType = parsed.mediaType;
+    const extension = mediaType === "image/jpeg" ? "jpg" : mediaType.slice("image/".length);
+    parts.push({
+      type: "image",
+      content: `image-${parts.length + 1}.${extension}`,
+      fileUrl: `data:${mediaType};base64,${parsed.data}`,
+      imageSource: "attachment"
+    });
+  }
+  return parts;
+}
 function buildMessageParts(orderedParts, toolTracker) {
   const result = [];
   for (const entry of orderedParts) {
@@ -6723,6 +7093,9 @@ function reducePersistedBackgroundTaskMessage(tasks, message, timestamp) {
   if (message.subtype === "task_notification") {
     if (!message.status)
       return tasks ?? {};
+    const orphanScan = resumeOrphanScanOutcome(message, previous);
+    if (orphanScan === "already-settled")
+      return tasks ?? {};
     const startedAt = previous?.startedAt ?? timestamp;
     const endedAt = timestamp >= startedAt ? timestamp : previous?.endedAt;
     const terminalStatus = message.status === "failed" ? "failed" : message.status === "stopped" ? "killed" : message.status === "completed" ? "completed" : "killed";
@@ -6742,7 +7115,8 @@ function reducePersistedBackgroundTaskMessage(tasks, message, timestamp) {
         usage: message.usage ?? previous?.usage,
         subagentType: previous?.subagentType,
         ...carriedTaskMetadata(previous),
-        ...taskMessageMetadata(message)
+        ...taskMessageMetadata(message),
+        ...orphanScan === "cleanup" ? { endReason: "resume_cleanup" } : {}
       }
     });
   }
@@ -6872,8 +7246,9 @@ function normalizePersistedSessionMessages(persisted) {
     });
     if (entry.raw.type === "system")
       continue;
-    const parts = buildMessageParts(entry.orderedParts, toolTracker);
-    if (entry.raw.type === "user" && !entry.content.trim())
+    const images = persistedUserImageParts(entry.raw);
+    const parts = [...buildMessageParts(entry.orderedParts, toolTracker), ...images];
+    if (entry.raw.type === "user" && !entry.content.trim() && images.length === 0)
       continue;
     if (entry.raw.type === "assistant" && parts.length === 0 && !entry.content.trim()) {
       continue;
@@ -7527,7 +7902,7 @@ function effectiveClaudeContext1m(options) {
   return options?.parameterValues?.context1m === true && (!model || model === "default" || /opus|sonnet/i.test(model));
 }
 function claudeLaunchResourceProfile(plugins, environment) {
-  const digest = (value) => createHash5("sha256").update(JSON.stringify(value)).digest("hex");
+  const digest = (value) => createHash6("sha256").update(JSON.stringify(value)).digest("hex");
   return {
     plugins: digest(plugins.map((plugin) => plugin.path)),
     credentials: digest([
@@ -7571,8 +7946,8 @@ async function assertClaudeRuntimeAccepts(session, options, resources) {
   refuse(claudeLaunchConflict(runtime.launch, request));
   if (!resources) {
     const policy = claudeTurnPolicy(session.executionPolicy, options?.readOnly);
-    const [plugins, environment] = await Promise.all([
-      getPluginsForSdk(request.cwd, policy?.projectResources !== false, claudeTurnSettingSources(session, options)),
+    const [{ plugins }, environment] = await Promise.all([
+      resolveClaudeTurnPlugins(request.cwd, policy, claudeTurnSettingSources(session, options)),
       runtimeEnvironmentForAgentQuery()
     ]);
     resources = claudeLaunchResourceProfile(plugins, environment);
@@ -7772,11 +8147,11 @@ function noMessages() {
 
 // ../../bridges/claude-bridge/src/services/session-manager-persistence.ts
 import { constants } from "node:fs";
-import { lstat as lstat2, open as open2, realpath } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join8, relative, resolve as resolve2, sep } from "node:path";
+import { lstat as lstat2, open as open2, realpath as realpath2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join9, relative, resolve as resolve2, sep } from "node:path";
 
 // ../protocol/src/node/command-change-journal.ts
-import { appendFile, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir3, readFile as readFile5, rename as rename3, rm as rm3, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname } from "node:path";
 var MAX_JOURNAL_ENTRIES = 1000;
 var MAX_JOURNAL_FILES_PER_ENTRY = 20;
@@ -7850,10 +8225,10 @@ class CommandChangeJournal {
     const line = `${JSON.stringify({ id, change: bounded })}
 `;
     this.writes = this.writes.then(async () => {
-      await mkdir2(dirname(this.path), { recursive: true, mode: 448 });
+      await mkdir3(dirname(this.path), { recursive: true, mode: 448 });
       if (!this.sizeChecked) {
         this.sizeChecked = true;
-        const existing = await stat3(this.path).catch(() => {
+        const existing = await stat4(this.path).catch(() => {
           return;
         });
         if (existing && existing.size > MAX_JOURNAL_BYTES / 2)
@@ -7873,7 +8248,7 @@ class CommandChangeJournal {
   async remove() {
     this.removed = true;
     await this.writes;
-    await rm2(this.path, { force: true }).catch(() => {});
+    await rm3(this.path, { force: true }).catch(() => {});
   }
   async compact() {
     this.appendsSinceCompaction = 0;
@@ -7881,16 +8256,16 @@ class CommandChangeJournal {
     const body = Array.from(records, ([id, change]) => JSON.stringify({ id, change })).join(`
 `);
     const temp = `${this.path}.${process.pid}.tmp`;
-    await writeFile2(temp, body ? `${body}
+    await writeFile3(temp, body ? `${body}
 ` : "", { mode: 384 });
-    await rename2(temp, this.path);
+    await rename3(temp, this.path);
   }
 }
 async function readJournal(path, maxEntries) {
   const records = new Map;
   let text;
   try {
-    const buffer = await readFile4(path);
+    const buffer = await readFile5(path);
     text = buffer.subarray(Math.max(0, buffer.length - MAX_JOURNAL_BYTES)).toString("utf8");
   } catch {
     return records;
@@ -7928,9 +8303,9 @@ async function readJournal(path, maxEntries) {
 import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { rmSync } from "node:fs";
-import { copyFile, lstat, mkdtemp, rm as rm3 } from "node:fs/promises";
+import { copyFile, lstat, mkdtemp, rm as rm4 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { delimiter, isAbsolute, join as join4, resolve } from "node:path";
+import { delimiter, isAbsolute as isAbsolute2, join as join5, resolve } from "node:path";
 var DEFAULT_MAX_UNTRACKED_FILE_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_UNTRACKED_FILES = 5000;
 var DEFAULT_SLOW_SNAPSHOT_MS = 500;
@@ -8019,7 +8394,7 @@ class WorkspaceChangeProbe {
       repo.latest = undefined;
   }
   async removeObjectDirectory(directory) {
-    await rm3(directory, { recursive: true, force: true }).catch(() => {});
+    await rm4(directory, { recursive: true, force: true }).catch(() => {});
     temporaryObjectDirectories.delete(directory);
   }
   objectEnv(repo, directory, beforeDirectory) {
@@ -8212,8 +8587,8 @@ class WorkspaceChangeProbe {
           return;
         return {
           root,
-          indexPath: isAbsolute(index) ? index : resolve(cwd, index),
-          objectsPath: isAbsolute(objects) ? objects : resolve(cwd, objects)
+          indexPath: isAbsolute2(index) ? index : resolve(cwd, index),
+          objectsPath: isAbsolute2(objects) ? objects : resolve(cwd, objects)
         };
       }).catch(() => {
         return;
@@ -8256,8 +8631,8 @@ class WorkspaceChangeProbe {
       return;
     const { root, indexPath } = repo.location;
     const started = this.now();
-    const tempIndex = join4(this.tempDir, `orkestrator-probe-${randomUUID2()}.index`);
-    const objectDirectory = await mkdtemp(join4(this.tempDir, "orkestrator-probe-objects-"));
+    const tempIndex = join5(this.tempDir, `orkestrator-probe-${randomUUID2()}.index`);
+    const objectDirectory = await mkdtemp(join5(this.tempDir, "orkestrator-probe-objects-"));
     temporaryObjectDirectories.add(objectDirectory);
     let retained = false;
     try {
@@ -8274,7 +8649,7 @@ class WorkspaceChangeProbe {
       const included = [];
       const skipped = new Map;
       for (const path of untracked) {
-        const stats = await lstat(join4(root, path)).catch(() => {
+        const stats = await lstat(join5(root, path)).catch(() => {
           return;
         });
         if (!stats)
@@ -8301,8 +8676,8 @@ class WorkspaceChangeProbe {
       retained = true;
       return snapshot;
     } finally {
-      await rm3(tempIndex, { force: true }).catch(() => {});
-      await rm3(`${tempIndex}.lock`, { force: true }).catch(() => {});
+      await rm4(tempIndex, { force: true }).catch(() => {});
+      await rm4(`${tempIndex}.lock`, { force: true }).catch(() => {});
       if (!retained)
         await this.removeObjectDirectory(objectDirectory);
       this.recordDuration(repo, this.now() - started);
@@ -8420,10 +8795,10 @@ function parseNumstatZ(output) {
 }
 
 // ../../bridges/claude-bridge/src/services/command-changes.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // ../../bridges/claude-bridge/src/services/change-evidence.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import {
   closeSync,
   existsSync,
@@ -8433,7 +8808,7 @@ import {
   rmSync as rmSync2,
   writeSync
 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // ../protocol/src/field-validation.ts
 function isPlainRecord(value) {
@@ -8836,10 +9211,10 @@ function workspaceObservationReportIssues(value) {
 }
 
 // ../protocol/src/node/change-tracking/evidence-spool.ts
-import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 import { readdirSync, readFileSync } from "node:fs";
-import { appendFile as appendFile2, mkdir as mkdir3, rename as rename3, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { appendFile as appendFile2, mkdir as mkdir4, rename as rename4, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var DEFAULT_EVIDENCE_SPOOL_LIMITS = {
   maxEntries: 2048,
   maxEntryBytes: 256 * 1024,
@@ -8852,10 +9227,10 @@ var DEFAULT_EVIDENCE_SPOOL_LIMITS = {
 var ENTRIES_FILE = "entries.jsonl";
 var BODY_DIRECTORY = "bodies";
 function evidenceBodyId(bytes) {
-  return `sha256:${createHash6("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${createHash7("sha256").update(bytes).digest("hex")}`;
 }
 function stableEvidenceId(...parts) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   for (const part of parts)
     hash.update(`${part ?? ""}\x00`);
   return hash.digest("hex").slice(0, 40);
@@ -9101,8 +9476,8 @@ class ChangeEvidenceSpool {
       return;
     const lines = this.pendingLines.splice(0).join("");
     this.enqueueIo(async () => {
-      await mkdir3(directory, { recursive: true, mode: 448 });
-      await appendFile2(join5(directory, ENTRIES_FILE), lines, { mode: 384 });
+      await mkdir4(directory, { recursive: true, mode: 448 });
+      await appendFile2(join6(directory, ENTRIES_FILE), lines, { mode: 384 });
     });
   }
   persistBody(id, bytes) {
@@ -9110,9 +9485,9 @@ class ChangeEvidenceSpool {
     if (!directory || this.restoring)
       return;
     this.enqueueIo(async () => {
-      const bodies = join5(directory, BODY_DIRECTORY);
-      await mkdir3(bodies, { recursive: true, mode: 448 });
-      await writeFile3(join5(bodies, bodyFileName(id)), bytes, { mode: 384, flag: "wx" }).catch((error) => {
+      const bodies = join6(directory, BODY_DIRECTORY);
+      await mkdir4(bodies, { recursive: true, mode: 448 });
+      await writeFile4(join6(bodies, bodyFileName(id)), bytes, { mode: 384, flag: "wx" }).catch((error) => {
         if (error.code !== "EEXIST")
           throw error;
       });
@@ -9122,7 +9497,7 @@ class ChangeEvidenceSpool {
     const directory = this.directory;
     if (!directory)
       return;
-    this.enqueueIo(() => rm4(join5(directory, BODY_DIRECTORY, bodyFileName(id)), { force: true }));
+    this.enqueueIo(() => rm5(join6(directory, BODY_DIRECTORY, bodyFileName(id)), { force: true }));
   }
   compactPersisted() {
     const directory = this.directory;
@@ -9132,12 +9507,12 @@ class ChangeEvidenceSpool {
     const body = this.entries.map((stored) => JSON.stringify({ epoch: this.runtimeEpoch, entry: stored.entry })).join(`
 `);
     this.enqueueIo(async () => {
-      await mkdir3(directory, { recursive: true, mode: 448 });
-      const file = join5(directory, ENTRIES_FILE);
+      await mkdir4(directory, { recursive: true, mode: 448 });
+      const file = join6(directory, ENTRIES_FILE);
       const temp = `${file}.${process.pid}.tmp`;
-      await writeFile3(temp, body ? `${body}
+      await writeFile4(temp, body ? `${body}
 ` : "", { mode: 384 });
-      await rename3(temp, file);
+      await rename4(temp, file);
     });
   }
   async flush() {
@@ -9145,10 +9520,10 @@ class ChangeEvidenceSpool {
     await this.io;
   }
   restore(directory) {
-    const bodyDirectory = join5(directory, BODY_DIRECTORY);
+    const bodyDirectory = join6(directory, BODY_DIRECTORY);
     try {
       for (const name of readdirSync(bodyDirectory)) {
-        const bytes = new Uint8Array(readFileSync(join5(bodyDirectory, name)));
+        const bytes = new Uint8Array(readFileSync(join6(bodyDirectory, name)));
         const id = evidenceBodyId(bytes);
         if (bodyFileName(id) !== name)
           continue;
@@ -9160,7 +9535,7 @@ class ChangeEvidenceSpool {
     } catch {}
     let text = "";
     try {
-      text = readFileSync(join5(directory, ENTRIES_FILE), "utf8");
+      text = readFileSync(join6(directory, ENTRIES_FILE), "utf8");
     } catch {
       return;
     }
@@ -9673,8 +10048,8 @@ function createChangeEvidence(options) {
 }
 function claimSpoolDirectory() {
   const scope = process.env.CWD || process.cwd();
-  const directory = join6(claudeChangeEvidenceDir(), createHash7("sha256").update(scope).digest("hex").slice(0, 32));
-  const owner = join6(directory, "owner.pid");
+  const directory = join7(claudeChangeEvidenceDir(), createHash8("sha256").update(scope).digest("hex").slice(0, 32));
+  const owner = join7(directory, "owner.pid");
   try {
     mkdirSync(directory, { recursive: true, mode: 448 });
     for (let attempt = 0;attempt < 2; attempt++) {
@@ -9850,7 +10225,7 @@ function commandChangeJournal(sdkSessionId) {
   if (journal) {
     journals.delete(sdkSessionId);
   } else {
-    journal = new CommandChangeJournal(join7(claudeCommandChangesDir(), `${sdkSessionId}.jsonl`));
+    journal = new CommandChangeJournal(join8(claudeCommandChangesDir(), `${sdkSessionId}.jsonl`));
   }
   journals.set(sdkSessionId, journal);
   while (journals.size > MAX_CACHED_JOURNALS) {
@@ -10534,13 +10909,6 @@ function getImageMediaType(filePath) {
       return "image/png";
   }
 }
-var SUPPORTED_IMAGE_MEDIA_TYPES = new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp"
-]);
-var MAX_IMAGE_ATTACHMENT_BYTES = 8 * 1024 * 1024;
 
 class ClaudeAttachmentError extends Error {
   code;
@@ -10550,41 +10918,20 @@ class ClaudeAttachmentError extends Error {
     this.code = code;
   }
 }
-function decodedBase64ByteLength(value) {
-  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
-  return value.length / 4 * 3 - padding;
-}
-function parseBase64ImageData(value) {
-  let data = value;
-  let mediaType;
-  if (value.startsWith("data:")) {
-    const match = /^data:([^;,]+);base64,([\s\S]+)$/.exec(value);
-    if (!match || !SUPPORTED_IMAGE_MEDIA_TYPES.has(match[1])) {
-      return null;
-    }
-    mediaType = match[1];
-    data = match[2];
-  }
-  const normalized = data.replace(/\s+/g, "");
-  if (normalized.length === 0 || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized) || decodedBase64ByteLength(normalized) > MAX_IMAGE_ATTACHMENT_BYTES) {
-    return null;
-  }
-  return { data: normalized, mediaType };
-}
 var BRIDGE_ATTACHMENT_ROOT_ENV = "ORKESTRATOR_BRIDGE_ATTACHMENT_ROOT";
 function configuredAttachmentRoot(env = process.env) {
   const value = env[BRIDGE_ATTACHMENT_ROOT_ENV]?.trim();
-  return value && isAbsolute2(value) ? resolve2(value) : undefined;
+  return value && isAbsolute3(value) ? resolve2(value) : undefined;
 }
 function attachmentContainmentRoot(filePath, cwd, extraRoot = configuredAttachmentRoot()) {
-  if (extraRoot && isAbsolute2(filePath) && isPathWithin2(extraRoot, resolve2(filePath))) {
+  if (extraRoot && isAbsolute3(filePath) && isPathWithin2(extraRoot, resolve2(filePath))) {
     return extraRoot;
   }
   return resolve2(cwd);
 }
 function isPathWithin2(rootPath, targetPath) {
   const childPath = relative(rootPath, targetPath);
-  return childPath === "" || childPath !== ".." && !childPath.startsWith(`..${sep}`) && !isAbsolute2(childPath);
+  return childPath === "" || childPath !== ".." && !childPath.startsWith(`..${sep}`) && !isAbsolute3(childPath);
 }
 function attachmentErrorForFsFailure(error) {
   const code = error?.code;
@@ -10600,7 +10947,7 @@ async function assertNoSymlinkComponents(lexicalRoot, targetPath) {
   const childPath = relative(lexicalRoot, targetPath);
   let currentPath = lexicalRoot;
   for (const segment of childPath.split(sep).filter(Boolean)) {
-    currentPath = join8(currentPath, segment);
+    currentPath = join9(currentPath, segment);
     const stats = await lstat2(currentPath).catch((error) => {
       throw attachmentErrorForFsFailure(error);
     });
@@ -10612,7 +10959,7 @@ async function assertNoSymlinkComponents(lexicalRoot, targetPath) {
 async function assertOpenedWorkspaceFile(targetPath, canonicalRoot, openedStats) {
   const [pathStats, canonicalTarget] = await Promise.all([
     lstat2(targetPath),
-    realpath(targetPath)
+    realpath2(targetPath)
   ]).catch((error) => {
     throw attachmentErrorForFsFailure(error);
   });
@@ -10628,16 +10975,16 @@ async function assertOpenedWorkspaceFile(targetPath, canonicalRoot, openedStats)
 }
 async function readWorkspaceImageAttachment(filePath, cwd, afterSymlinkValidation, afterCanonicalValidation, afterInitialValidation) {
   const lexicalRoot = attachmentContainmentRoot(filePath, cwd);
-  const targetPath = isAbsolute2(filePath) ? resolve2(filePath) : resolve2(lexicalRoot, filePath);
+  const targetPath = isAbsolute3(filePath) ? resolve2(filePath) : resolve2(lexicalRoot, filePath);
   if (!isPathWithin2(lexicalRoot, targetPath)) {
     throw new ClaudeAttachmentError("attachment_outside_workspace", "Image attachment must be contained in the current workspace.");
   }
-  const canonicalRoot = await realpath(lexicalRoot).catch((error) => {
+  const canonicalRoot = await realpath2(lexicalRoot).catch((error) => {
     throw attachmentErrorForFsFailure(error);
   });
   await assertNoSymlinkComponents(lexicalRoot, targetPath);
   await afterSymlinkValidation?.(targetPath);
-  const canonicalTarget = await realpath(targetPath).catch((error) => {
+  const canonicalTarget = await realpath2(targetPath).catch((error) => {
     throw attachmentErrorForFsFailure(error);
   });
   if (!isPathWithin2(canonicalRoot, canonicalTarget)) {
@@ -12157,8 +12504,8 @@ function createClaudeTurn(admission, input) {
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
 // ../../bridges/claude-bridge/src/services/mcp-config.ts
-import { createHash as createHash8 } from "node:crypto";
-import { join as join9 } from "node:path";
+import { createHash as createHash9 } from "node:crypto";
+import { join as join10 } from "node:path";
 
 // ../protocol/src/agent-mail.ts
 var AGENT_MAIL_MAX_BODY_BYTES = 32 * 1024;
@@ -12267,7 +12614,7 @@ async function loadGlobalMcpServers() {
   return servers ?? {};
 }
 async function loadProjectMcpServers(cwd) {
-  const servers = await readJsonSliceCached(join9(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers);
+  const servers = await readJsonSliceCached(join10(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers);
   return servers ?? {};
 }
 async function loadProjectOverridesFromGlobal2(cwd) {
@@ -12371,7 +12718,7 @@ async function loadScopedMcpServers(cwd, scope) {
   const [global2, projectGlobal, projectLocal] = await Promise.all([
     readJsonSliceCachedWithDigest(path, "mcpServers", (config) => config?.mcpServers),
     scope === "all" ? readJsonSliceCachedWithDigest(path, `projects:${cwd}:mcpServers`, (config) => config?.projects?.[cwd]?.mcpServers) : null,
-    scope === "all" ? readJsonSliceCachedWithDigest(join9(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers) : null
+    scope === "all" ? readJsonSliceCachedWithDigest(join10(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers) : null
   ]);
   const configs = {
     ...global2.value,
@@ -12385,7 +12732,7 @@ async function loadScopedMcpServers(cwd, scope) {
   return { configs, revision: { fingerprint: revisionFingerprint(sources), sources, scope } };
 }
 function revisionFingerprint(sources) {
-  return createHash8("sha256").update(`user=${sources.user}\x00project=${sources.project}`).digest("base64url");
+  return createHash9("sha256").update(`user=${sources.user}\x00project=${sources.project}`).digest("base64url");
 }
 async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources = "all") {
   const { configs, revision } = await loadScopedMcpServers(cwd, normalizeScope(sources));
@@ -12725,8 +13072,8 @@ function idleSteerPromptReply(prompt, agentLabel) {
 }
 
 // ../../bridges/claude-bridge/src/services/claude-terminal-commands.ts
-import { mkdir as mkdir4, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile6, rename as rename5, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 var FILE_NAME = "terminal-slash-commands.json";
 var MAX_VERSIONS = 4;
 var MAX_NAMES = 512;
@@ -12737,7 +13084,7 @@ var dirty = false;
 var entries = [];
 var writes = Promise.resolve();
 function filePath() {
-  return join10(claudeOrkestratorDir(), FILE_NAME);
+  return join11(claudeOrkestratorDir(), FILE_NAME);
 }
 function validVersion(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_VERSION_LENGTH;
@@ -12765,7 +13112,7 @@ function parseEntries(raw) {
   return result;
 }
 function load() {
-  loaded ??= readFile5(filePath(), "utf8").then(parseEntries, () => []).catch(() => []).then((stored) => {
+  loaded ??= readFile6(filePath(), "utf8").then(parseEntries, () => []).catch(() => []).then((stored) => {
     const recorded = new Set(entries.map((entry) => entry.version));
     entries = [...entries, ...stored.filter((entry) => !recorded.has(entry.version))].slice(0, MAX_VERSIONS);
   });
@@ -12792,22 +13139,22 @@ function recordTerminalSlashCommands(version, commands) {
   writes = writes.then(async () => {
     await load();
     const directory = claudeOrkestratorDir();
-    await mkdir4(directory, { recursive: true });
+    await mkdir5(directory, { recursive: true });
     const target = filePath();
     const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
     const snapshot = entries;
-    await writeFile4(temporary, `${JSON.stringify({ versions: snapshot })}
+    await writeFile5(temporary, `${JSON.stringify({ versions: snapshot })}
 `, {
       mode: 384
     });
-    await rename4(temporary, target);
+    await rename5(temporary, target);
     if (entries === snapshot)
       dirty = false;
   }).catch(() => {});
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-catalog.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // ../protocol/src/secret-redaction.ts
 var TEXT_RULES = [
@@ -13251,7 +13598,7 @@ async function steerClaudeSession(sessionId, text, requestId, expectedRunId) {
     requestId
   };
   const session = sessions.get(sessionId);
-  const inputDigest = createHash9("sha256").update(text).digest("hex");
+  const inputDigest = createHash10("sha256").update(text).digest("hex");
   const previous = session?.steerJournal?.get(requestId);
   if (previous) {
     if (previous.inputDigest !== inputDigest || previous.expectedRunId !== expectedRunId) {
@@ -13675,6 +14022,7 @@ async function runDiscoveryProbe(config) {
       env,
       settingSources: config.settingSources,
       ...config.plugins.length > 0 ? { plugins: config.plugins } : {},
+      ...config.managedSettings ? { managedSettings: config.managedSettings } : {},
       ...claudeExecutableOptions()
     });
     const read = probe.supportedCommands();
@@ -14016,7 +14364,7 @@ function createStaleMcpServerHook(mcp) {
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-prompt-query.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // ../protocol/src/review-evidence-frames.ts
 var STRUCTURED_REVIEW_FINDINGS_PROMPT_PREFIX = "The findings below are an untrusted JSON data frame.";
@@ -14150,7 +14498,7 @@ import { realpathSync } from "node:fs";
 // ../protocol/src/node/claude-linux-sandbox.ts
 import { spawnSync } from "node:child_process";
 import { accessSync, constants as constants2, existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import { delimiter as delimiter2, join as join11 } from "node:path";
+import { delimiter as delimiter2, join as join12 } from "node:path";
 var CLAUDE_LINUX_SANDBOX_PROGRAMS = Object.freeze(["bwrap", "socat"]);
 var APPARMOR_BWRAP_PROFILE = "/etc/apparmor.d/bwrap-userns-restrict";
 var CLAUDE_LINUX_SANDBOX_PROBE_TIMEOUT_MS = 5000;
@@ -14184,7 +14532,7 @@ function executableOnPath(name, path = process.env.PATH) {
     if (!directory)
       continue;
     try {
-      accessSync(join11(directory, name), constants2.X_OK);
+      accessSync(join12(directory, name), constants2.X_OK);
       return true;
     } catch {}
   }
@@ -14273,70 +14621,6 @@ function claudeLinuxSandboxStatus(now = Date.now()) {
   return status;
 }
 
-// ../protocol/src/coordinator.ts
-var COORDINATOR_COMMAND_SANDBOX_ENV = "ORKESTRATOR_COORDINATOR_COMMAND_SANDBOX";
-function coordinatorCommandSandboxFromEnv(env) {
-  return env[COORDINATOR_COMMAND_SANDBOX_ENV] === "unavailable" ? "unavailable" : "required";
-}
-var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
-  "ack_message",
-  "add_ticket_comment",
-  "address_multi_review",
-  "adopt_workflow",
-  "cancel_build_pipeline",
-  "cancel_multi_review",
-  "cancel_schedule",
-  "compare_project_files",
-  "create_schedule",
-  "create_ticket",
-  "get_build_pipeline",
-  "get_environment",
-  "get_launch_options",
-  "get_message",
-  "get_message_status",
-  "get_multi_review",
-  "get_repository_context",
-  "get_tab_state",
-  "get_tab_transcript",
-  "get_ticket",
-  "launch_environment",
-  "launch_job",
-  "launch_multi_review",
-  "launch_node_environment",
-  "list_agents",
-  "list_environments",
-  "list_mailboxes",
-  "list_node_environments",
-  "list_nodes",
-  "list_projects",
-  "list_schedules",
-  "list_tabs",
-  "list_tickets",
-  "list_workflows",
-  "open_multi_review",
-  "open_multi_review_fix",
-  "pause_build_pipeline",
-  "read_messages",
-  "read_node_environment",
-  "request_env_value_reveal",
-  "request_environment_deletion",
-  "request_project_file_update",
-  "request_project_on_node",
-  "resume_build_pipeline",
-  "send_message",
-  "send_node_message",
-  "send_prompt_to_node_tab",
-  "send_prompt_to_tab",
-  "start_build_pipeline",
-  "start_environment",
-  "start_multi_review",
-  "start_node_environment",
-  "stop_environment",
-  "stop_node_environment",
-  "transfer_files",
-  "update_ticket"
-]);
-
 // ../../bridges/claude-bridge/src/services/claude-execution-sandbox.ts
 function claudeReadOnlyWorkspaces(cwd) {
   let resolved;
@@ -14521,7 +14805,7 @@ function canAdmitInteraction(candidate, family) {
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-interactions.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 
 // ../../bridges/claude-bridge/src/services/claude-elicitation-schema.ts
 function record2(value) {
@@ -14770,7 +15054,7 @@ async function getClaudeRuntimeVersions() {
   let bundledCliVersion;
   try {
     const sdkEntryUrl = import.meta.resolve("@anthropic-ai/claude-agent-sdk");
-    const manifest = JSON.parse(await readFile6(new URL("./package.json", sdkEntryUrl), "utf8"));
+    const manifest = JSON.parse(await readFile7(new URL("./package.json", sdkEntryUrl), "utf8"));
     sdkVersion = manifest.version;
     bundledCliVersion = manifest.claudeCodeVersion;
   } catch (error) {
@@ -15145,12 +15429,14 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
     readOnly: options?.readOnly === true,
     includeLocalSettings: options?.includeLocalSettings === true
   };
-  const includeProjectResources = policy?.projectResources !== false;
   const settingSources = claudeTurnSettingSources(session, options);
   session.commandDiscoveryInputs.includeLocalSettings = settingSources.includes("local");
-  const [{ servers: mcpServers, names: mcpServerNames, revision: mcpConfigRevision }, plugins] = await Promise.all([
+  const [
+    { servers: mcpServers, names: mcpServerNames, revision: mcpConfigRevision },
+    { plugins, coordinatorSkills }
+  ] = await Promise.all([
     getMcpRuntimeConfig(cwd, process.env, options?.agentMcp, mcpSourceScopeForPolicy(policy)),
-    getPluginsForSdk(cwd, includeProjectResources, settingSources)
+    resolveClaudeTurnPlugins(cwd, policy, settingSources)
   ]);
   turn.mcpServerNames = mcpServerNames;
   const mcpServerCount = Object.keys(mcpServers).length;
@@ -15176,7 +15462,8 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   const allowedTools = coordinatorReadOnly ? claudeReadOnlyAllowedTools({
     agentMcpServerNames: mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? [AGENT_MCP_SERVER_NAME] : [],
     policy,
-    researchMcpServerNames: coordinatorResearchMcpServersFromEnv(process.env).map((server) => server.name).filter((name) => mcpServerNames.has(name))
+    researchMcpServerNames: coordinatorResearchMcpServersFromEnv(process.env).map((server) => server.name).filter((name) => mcpServerNames.has(name)),
+    skillNames: coordinatorSkills
   }) : [
     ...policy?.toolPolicy?.allow ?? defaultAllowedTools,
     ...agentMailTools,
@@ -15213,7 +15500,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
     parameterValues: options?.parameterValues,
     fastMode
   });
-  const mcpServersKey = createHash10("sha256").update(JSON.stringify(mcpServers)).digest("hex");
+  const mcpServersKey = createHash11("sha256").update(JSON.stringify(mcpServers)).digest("hex");
   return {
     settingSources,
     cwd,
@@ -15269,6 +15556,7 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
     ultracode,
     queryEnvironment
   } = plan;
+  const managedSettings = claudeManagedSettings(policy);
   const latestTurnHook = (pick) => (...args) => pick(turnFor())(...args);
   const backgroundTaskHook = latestTurnHook((target) => target.recordBackgroundTaskHook);
   const commandChangeHook = commandChangeHookFor(turnFor, session.id);
@@ -15327,6 +15615,7 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
 `)
     },
     settingSources: plan.settingSources,
+    ...managedSettings ? { managedSettings } : {},
     ...(fastMode || ultracode) && {
       settings: {
         ...fastMode && { fastMode: true },
@@ -16112,6 +16401,15 @@ function handleTaskNotification(turn, message) {
   const correlated = takeProvisionalBackgroundTask(session, notification.tool_use_id);
   const parked = takeSettlingBackgroundTask(session, notification.task_id);
   const previous = session.backgroundTasks?.[notification.task_id] ?? parked?.task ?? correlated.task;
+  const orphanScan = resumeOrphanScanOutcome(notification, previous);
+  if (orphanScan === "already-settled" && previous) {
+    session.backgroundTasks = boundBackgroundTaskHistory({
+      ...session.backgroundTasks,
+      [previous.id]: previous
+    });
+    emitBackgroundTasks(turn);
+    return;
+  }
   const terminalStatus = notification.status === "failed" ? "failed" : notification.status === "stopped" ? "killed" : "completed";
   const task = {
     id: notification.task_id,
@@ -16127,7 +16425,8 @@ function handleTaskNotification(turn, message) {
     usage: notification.usage ?? previous?.usage,
     subagentType: previous?.subagentType,
     ...carriedTaskMetadata(previous),
-    ...taskMessageMetadata(notification)
+    ...taskMessageMetadata(notification),
+    ...orphanScan === "cleanup" ? { endReason: "resume_cleanup" } : {}
   };
   Object.assign(task, takeShellTaskFields(session, task.toolUseId), task.error ? { error: task.error } : {});
   session.backgroundTasks = boundBackgroundTaskHistory({
@@ -17440,6 +17739,58 @@ config.get("/models", async (c) => {
 });
 var config_default = config;
 
+// ../protocol/src/human-prompts.ts
+var HUMAN_PROMPT_SCAN_BYTES = 16 * 1024;
+function humanPromptObservation(messages, tasks) {
+  const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+  const parts = [];
+  let remaining = 64 * 1024;
+  let visited = 0;
+  const walk = (value, depth = 0) => {
+    if (!Array.isArray(value) || depth > 8)
+      return;
+    for (const part of value) {
+      if (++visited > 2048 || remaining <= 0 || parts.length >= 32)
+        return;
+      if (!object(part))
+        continue;
+      if (typeof part.toolOutput === "string" && (part.toolState === "pending" || part.toolOutput.includes("Output is being written to:"))) {
+        const output = part.toolOutput.slice(-Math.min(HUMAN_PROMPT_SCAN_BYTES, remaining));
+        remaining -= output.length;
+        const args = object(part.toolArgs) ? part.toolArgs : {};
+        const command = args.command ?? args.cmd;
+        parts.push({
+          toolUseId: String(part.toolUseId ?? part.id ?? "").slice(0, 200),
+          toolName: String(part.toolName ?? "").slice(0, 100),
+          toolState: part.toolState,
+          toolOutput: output,
+          ...typeof command === "string" ? { toolArgs: { command: command.slice(0, 500) } } : {}
+        });
+      }
+      walk(part.parts, depth + 1);
+      walk(part.childTools, depth + 1);
+      if (object(part.task))
+        walk([part.task], depth + 1);
+    }
+  };
+  if (Array.isArray(messages)) {
+    for (let i = messages.length - 1;i >= Math.max(0, messages.length - 64); i--) {
+      const message = messages[i];
+      if (object(message))
+        walk(message.parts);
+    }
+  }
+  const taskList = Array.isArray(tasks) ? tasks : object(tasks) ? Object.values(tasks) : [];
+  const backgroundTasks = taskList.filter(object).filter((task) => task.status === "running" || task.status === "pending").slice(-64).map((task) => ({
+    id: String(task.id ?? "").slice(0, 200),
+    status: task.status,
+    kind: task.kind,
+    ...typeof task.outputFile === "string" ? { outputFile: task.outputFile.slice(0, 2048) } : {},
+    ...typeof task.toolUseId === "string" ? { toolUseId: task.toolUseId.slice(0, 200) } : {}
+  }));
+  return { messages: [{ parts }], backgroundTasks };
+}
+
 // ../../bridges/claude-bridge/src/routes/session.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 
@@ -17852,7 +18203,7 @@ sessionActivityBatch.post(SESSION_ACTIVITY_BATCH_PATH, async (c) => {
 
 // ../protocol/src/node/bridge-transcript-summary.ts
 import { Buffer as Buffer3 } from "node:buffer";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // ../protocol/src/node/progressive-transcript.ts
 var BRIDGE_TRANSCRIPT_MAX_MESSAGES = 100;
@@ -18018,7 +18369,7 @@ function digestPayload(payload) {
   const serialized = JSON.stringify(payload);
   return {
     bytes: Buffer3.byteLength(serialized),
-    digest: createHash11("sha256").update(serialized).digest("base64url").slice(0, 32)
+    digest: createHash12("sha256").update(serialized).digest("base64url").slice(0, 32)
   };
 }
 function topLevelKey(part, index) {
@@ -18417,7 +18768,6 @@ function registerSessionTranscriptRoutes(app, generation, materialize) {
 // ../../bridges/claude-bridge/src/routes/session.ts
 var session = new Hono2;
 var TRANSCRIPT_GENERATION = randomUUID5();
-var MAX_IMAGE_ATTACHMENT_BYTES2 = 8 * 1024 * 1024;
 var MAX_QUESTION_ANSWER_REQUEST_BYTES = AGENT_INTERACTION_LIMITS.maxSerializedPayloadBytes + 1024;
 var MAX_CLAUDE_TRANSCRIPT_RESPONSE_BYTES = 16 * 1024 * 1024;
 function boundClaudeTranscriptResponse(messages, tailMessages) {
@@ -18470,13 +18820,7 @@ function errorMessage(error, fallback) {
   return error instanceof Error && error.message ? error.message : fallback;
 }
 function isValidImageDataUrl(value) {
-  const match = /^data:image\/(?:jpeg|png|gif|webp);base64,([\s\S]+)$/.exec(value);
-  if (!match)
-    return false;
-  const data = match[1].replace(/\s+/g, "");
-  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
-  const decodedBytes = data.length % 4 === 0 ? data.length / 4 * 3 - padding : Number.POSITIVE_INFINITY;
-  return data.length > 0 && data.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(data) && decodedBytes <= MAX_IMAGE_ATTACHMENT_BYTES2;
+  return parseBase64ImageData(value)?.mediaType !== undefined;
 }
 function isBoundedClaudeQuestionAnswers(value, questionCount) {
   if (!Array.isArray(value) || value.length !== questionCount)
@@ -19119,6 +19463,10 @@ session.post("/:id/tasks/:taskId/stop", async (c) => {
     return c.json({ error: errorMessage(error, "Failed to stop background task") }, sessionErrorStatus(error));
   }
 });
+session.get("/:id/human-prompts", (c) => {
+  const state = peekSession(c.req.param("id"));
+  return c.json(humanPromptObservation(state?.messages, state?.backgroundTasks));
+});
 session.get("/:id/activity", async (c) => {
   return c.json(await readSessionActivityObservation(c.req.param("id")));
 });
@@ -21465,7 +21813,7 @@ app.onError((error, c) => {
 var BRIDGE_TOKEN_ENV = "CLAUDE_BRIDGE_TOKEN";
 var BRIDGE_ALLOWED_ORIGINS_ENV = "CLAUDE_BRIDGE_ALLOWED_ORIGINS";
 var configuredBridgeAuthToken = process.env[BRIDGE_TOKEN_ENV]?.trim();
-var bridgeAuthToken = configuredBridgeAuthToken || randomBytes(32).toString("base64url");
+var bridgeAuthToken = configuredBridgeAuthToken || randomBytes2(32).toString("base64url");
 delete process.env[BRIDGE_TOKEN_ENV];
 process.env.ORKESTRATOR_NATIVE_AGENT_BRIDGE = "claude";
 var bridgeAuthEnabledOverrideForTesting = null;