@drisp/cli 0.5.24 → 0.5.26

package/dist/{chunk-QBMYQJFX.js → chunk-YZ7RCBKO.js}

@@ -12,30 +12,33 @@ import {
   isToolEvent,
   isValidHookEventEnvelope,
   resolveHookSocketPath
-} from "./chunk-BTKQ67RE.js";
+} from "./chunk-QYB6N2OT.js";
 import {
   TransportUnreachableError,
   createUdsClientTransport,
+  createWsClientTransport,
   generateChannelRequestId,
   openVersionedDb,
   readDashboardClientConfig,
   refreshDashboardAccessToken,
   resolveGatewayPaths,
-  traceGatewayFrame,
   trackGatewayTransportReconnect,
-  writeGatewayTrace
-} from "./chunk-YU2WMPRC.js";
+  writeGatewayTrace,
+  wsClientOptionsForEndpoint
+} from "./chunk-3U37HT4T.js";
 import {
   compileWorkflowPlan,
   createWorkflowRunner,
   installWorkflowFromSource,
+  isMarketplaceRef,
   readConfig,
   readGlobalConfig,
   resolveActiveWorkflow,
+  resolveMarketplacePlugin,
   resolveWorkflow,
   resolveWorkflowInstall,
   resolveWorkflowPlugins
-} from "./chunk-7UUPLAP4.js";
+} from "./chunk-73V7GXV6.js";
 
 // src/infra/daemon/stateDir.ts
 import fs from "fs";
@@ -238,6 +241,16 @@ var RULES = {
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
     canBlock: false
   },
+  // Observation-only: the batch fires after every call in it has already
+  // resolved, so nothing downstream produces a decision or block for it. The
+  // claim is not cosmetic — hook dispatch keeps every decision-capable event
+  // on Claude's critical path, so a false `canBlock` would make every
+  // parallel tool batch wait on the forwarder for a reply never sent.
+  "tool.batch": {
+    expectsDecision: false,
+    defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+    canBlock: false
+  },
   "tool.delta": {
     expectsDecision: false,
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
@@ -288,6 +301,16 @@ var RULES = {
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
     canBlock: true
   },
+  // Observation-only: nothing in the pipeline produces a decision or a block
+  // for an expansion, so it must not claim `canBlock`. The claim is not
+  // cosmetic — hook dispatch keeps every decision-capable event on Claude's
+  // critical path, so a false `canBlock` would make every slash command wait
+  // on the forwarder for a reply that is never sent.
+  "prompt.expansion": {
+    expectsDecision: false,
+    defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+    canBlock: false
+  },
   "turn.start": {
     expectsDecision: false,
     defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
@@ -420,6 +443,15 @@ function asRecord(value) {
   }
   return {};
 }
+function readToolBatchCalls(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => asRecord(entry)).map((call) => ({
+    tool_name: call["tool_name"],
+    tool_input: call["tool_input"],
+    tool_use_id: call["tool_use_id"],
+    tool_response: call["tool_response"]
+  }));
+}
 function translateClaudeEnvelope(envelope) {
   const payload = asRecord(envelope.payload);
   let toolName;
@@ -444,7 +476,9 @@ function translateClaudeEnvelope(envelope) {
         kind: "session.start",
         data: {
           source: payload["source"],
-          agent_type: payload["agent_type"]
+          model: payload["model"],
+          agent_type: payload["agent_type"],
+          session_title: payload["session_title"]
         }
       };
     case "SessionEnd":
@@ -458,6 +492,22 @@ function translateClaudeEnvelope(envelope) {
       return {
         kind: "user.prompt",
         data: {
+          prompt: payload["prompt"],
+          cwd: payload["cwd"],
+          permission_mode: payload["permission_mode"]
+        }
+      };
+    // Fires immediately before UserPromptSubmit, sharing its prompt_id,
+    // when a typed command expands into a prompt. Field names are pinned
+    // to the payload captured in the #116 spike.
+    case "UserPromptExpansion":
+      return {
+        kind: "prompt.expansion",
+        data: {
+          expansion_type: payload["expansion_type"],
+          command_name: payload["command_name"],
+          command_args: payload["command_args"],
+          command_source: payload["command_source"],
           prompt: payload["prompt"],
           permission_mode: payload["permission_mode"]
         }
@@ -485,6 +535,18 @@ function translateClaudeEnvelope(envelope) {
           tool_response: payload["tool_response"]
         }
       };
+    // Fires once per assistant tool batch, after every PostToolUse in it.
+    // Field names are pinned to the payload captured in the #116 spike;
+    // note that `tool_calls[].tool_response` is a STRING there, unlike
+    // PostToolUse's structured `tool_response`.
+    case "PostToolBatch":
+      return {
+        kind: "tool.batch",
+        data: {
+          tool_calls: readToolBatchCalls(payload["tool_calls"]),
+          permission_mode: payload["permission_mode"]
+        }
+      };
     case "PostToolUseFailure":
       return {
         kind: "tool.failure",
@@ -495,7 +557,10 @@ function translateClaudeEnvelope(envelope) {
           tool_input: payload["tool_input"] ?? {},
           tool_use_id: toolUseId,
           error: payload["error"],
-          is_interrupt: payload["is_interrupt"]
+          is_interrupt: payload["is_interrupt"],
+          exit_code: payload["exit_code"],
+          output: payload["output"],
+          error_code: payload["error_code"]
         }
       };
     case "PermissionRequest":
@@ -721,6 +786,12 @@ function buildClaudeDisplay(kind, data) {
 }
 
 // src/harnesses/claude/runtime/mapper.ts
+function readEffortLevel(payload) {
+  const effort = payload["effort"];
+  if (typeof effort !== "object" || effort === null) return void 0;
+  const level = effort["level"];
+  return typeof level === "string" ? level : void 0;
+}
 function mapEnvelopeToRuntimeEvent(envelope) {
   const payload = envelope.payload;
   const safePayload = typeof payload === "object" && payload !== null ? payload : { value: payload };
@@ -738,6 +809,13 @@ function mapEnvelopeToRuntimeEvent(envelope) {
     data: translated.data,
     hookName: envelope.hook_event_name,
     sessionId: envelope.session_id,
+    // prompt_id is a Claude common input field (v2.1.196+) on every hook
+    // payload; carried harness-neutrally as the Prompt identity (ADR 0009).
+    promptId: safePayloadRecord["prompt_id"],
+    // `effort` is likewise a common input field ({level}), observed on
+    // PostToolUse-class payloads and never on SessionStart, so it is read here
+    // rather than in any one hook's translation.
+    effortLevel: readEffortLevel(safePayloadRecord),
     toolName: translated.toolName,
     toolUseId: translated.toolUseId,
     agentId: translated.agentId,
@@ -855,9 +933,23 @@ function extractResultText(content) {
   }
   return parts.join("\n");
 }
-function createStreamJsonToolParser(onToolResult, onToolUse) {
+function extractAssistantText(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "object" && block !== null) {
+      const rec = block;
+      if (rec["type"] === "text" && typeof rec["text"] === "string") {
+        parts.push(rec["text"]);
+      }
+    }
+  }
+  return parts.join("");
+}
+function createStreamJsonToolParser(onToolResult, onToolUse, onMessageDelta, onMessageComplete) {
   let buffer = "";
   const toolNameById = /* @__PURE__ */ new Map();
+  let currentMessageId;
   function processLine(line) {
     const trimmed = line.trim();
     if (!trimmed) return;
@@ -868,6 +960,19 @@ function createStreamJsonToolParser(onToolResult, onToolUse) {
       return;
     }
     const record = parsed.type === "stream_event" && parsed.event ? parsed.event : parsed;
+    if (record.type === "message_start") {
+      const id = record.message?.["id"];
+      if (typeof id === "string") currentMessageId = id;
+    }
+    if (record.type === "content_block_delta") {
+      const delta = record["delta"];
+      if (typeof delta === "object" && delta !== null) {
+        const d = delta;
+        if (d["type"] === "text_delta" && typeof d["text"] === "string") {
+          onMessageDelta?.({ item_id: currentMessageId, delta: d["text"] });
+        }
+      }
+    }
     const contentBlocks = (record.type === "assistant" ? record.message?.content : record.type === "message" && record.role === "assistant" ? record.content : void 0) ?? [];
     for (const block of contentBlocks) {
       if (typeof block !== "object" || block === null) continue;
@@ -877,6 +982,14 @@ function createStreamJsonToolParser(onToolResult, onToolUse) {
         onToolUse?.({ tool_use_id: rec["id"], tool_name: rec["name"] });
       }
     }
+    if (record.type === "assistant" || record.type === "message" && record.role === "assistant") {
+      const messageText = extractAssistantText(contentBlocks);
+      if (messageText) {
+        const idValue = record.type === "assistant" ? record.message?.["id"] : record["id"];
+        const itemId = typeof idValue === "string" ? idValue : currentMessageId;
+        onMessageComplete?.({ item_id: itemId, message: messageText });
+      }
+    }
     if (record.type === "tool_result") {
       const toolUseId = typeof record.tool_use_id === "string" ? record.tool_use_id : void 0;
       const text = extractResultText(record.content);
@@ -975,6 +1088,38 @@ function createServer2(opts) {
     },
     () => {
       transportStats.streamToolUses++;
+    },
+    (messageDelta) => {
+      emit({
+        id: `stream-msg-delta-${messageDelta.item_id ?? "unknown"}-${Date.now()}`,
+        timestamp: Date.now(),
+        kind: "message.delta",
+        data: {
+          item_id: messageDelta.item_id,
+          delta: messageDelta.delta
+        },
+        hookName: "stream-json",
+        sessionId,
+        context: { cwd: projectDir, transcriptPath: "" },
+        interaction: getInteractionHints("message.delta"),
+        payload: null
+      });
+    },
+    (messageComplete) => {
+      emit({
+        id: `stream-msg-complete-${messageComplete.item_id ?? "unknown"}-${Date.now()}`,
+        timestamp: Date.now(),
+        kind: "message.complete",
+        data: {
+          item_id: messageComplete.item_id,
+          message: messageComplete.message
+        },
+        hookName: "stream-json",
+        sessionId,
+        context: { cwd: projectDir, transcriptPath: "" },
+        interaction: getInteractionHints("message.complete"),
+        payload: null
+      });
     }
   );
   function emit(event) {
@@ -1375,6 +1520,10 @@ var TOOL_HOOK_EVENTS = [
   "PreToolUse",
   "PostToolUse",
   "PostToolUseFailure",
+  // Batch-level, not per-tool, but Claude accepts (and requires) a matcher
+  // here: the #116 capture registered it with `matcher: '*'` and it fired in
+  // every run. Matcher-less registration is unverified.
+  "PostToolBatch",
   "PermissionRequest",
   "PermissionDenied",
   "Elicitation",
@@ -1389,6 +1538,7 @@ var NON_TOOL_HOOK_EVENTS = [
   "SubagentStart",
   "SubagentStop",
   "UserPromptSubmit",
+  "UserPromptExpansion",
   "PreCompact",
   "PostCompact",
   "Setup",
@@ -1401,6 +1551,27 @@ var NON_TOOL_HOOK_EVENTS = [
   "WorktreeCreate",
   "WorktreeRemove"
 ];
+var SYNC_HOOK_EVENTS = [
+  // Decision/blocking — kept in step with `runtime/interactionRules.ts`.
+  "PreToolUse",
+  "PermissionRequest",
+  "UserPromptSubmit",
+  "Stop",
+  "StopFailure",
+  "SubagentStop",
+  "Elicitation",
+  "ElicitationResult",
+  "TeammateIdle",
+  "TaskCreated",
+  "TaskCompleted",
+  "ConfigChange",
+  // Teardown — see (2) above.
+  "SessionEnd"
+];
+var SYNC_HOOK_EVENT_SET = new Set(SYNC_HOOK_EVENTS);
+function isAsyncHookEvent(event) {
+  return !SYNC_HOOK_EVENT_SET.has(event);
+}
 function quoteShellArg(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
@@ -1448,23 +1619,20 @@ function generateHookSettings(tempDir, authOverlay) {
   if (process.env["ATHENA_DEBUG"]) {
     console.error("[athena-debug] Hook forwarder path:", hookForwarder.command);
   }
-  const hookCommand = {
-    type: "command",
-    command: hookForwarder.command
-  };
+  const hookCommandFor = (event) => isAsyncHookEvent(event) ? { type: "command", command: hookForwarder.command, async: true } : { type: "command", command: hookForwarder.command };
   const hooks = {};
   for (const event of TOOL_HOOK_EVENTS) {
     hooks[event] = [
       {
         matcher: "*",
-        hooks: [hookCommand]
+        hooks: [hookCommandFor(event)]
       }
     ];
   }
   for (const event of NON_TOOL_HOOK_EVENTS) {
     hooks[event] = [
       {
-        hooks: [hookCommand]
+        hooks: [hookCommandFor(event)]
       }
     ];
   }
@@ -2824,6 +2992,17 @@ import os8 from "os";
 import path10 from "path";
 
 // src/harnesses/claude/config/isolation.ts
+var CLAUDE_EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function normalizeEffort(value) {
+  if (value === void 0) return void 0;
+  return CLAUDE_EFFORT_LEVELS.includes(value) ? value : void 0;
+}
 var DISALLOWED_FIRST_PARTY_MCPS = [
   "mcp__claude_ai_Gmail__*",
   "mcp__claude_ai_Google_Calendar__*",
@@ -2934,6 +3113,7 @@ var FLAG_REGISTRY = [
   { field: "additionalDirectories", flag: "--add-dir", kind: "array" },
   // === Model & Agent ===
   { field: "model", flag: "--model", kind: "value" },
+  { field: "effort", flag: "--effort", kind: "value" },
   { field: "fallbackModel", flag: "--fallback-model", kind: "value" },
   { field: "agent", flag: "--agent", kind: "value" },
   { field: "agents", flag: "--agents", kind: "json" },
@@ -3831,20 +4011,49 @@ function buildClaudeCompatibleIsolationConfig({
   additionalDirectories,
   pluginDirs,
   verbose,
-  configuredModel
+  configuredModel,
+  configuredEffort
 }) {
   return {
     preset: isolationPreset,
     additionalDirectories,
     pluginDirs: pluginDirs.length > 0 ? pluginDirs : void 0,
     debug: verbose,
-    model: configuredModel
+    model: configuredModel,
+    effort: normalizeEffort(configuredEffort)
   };
 }
+var CLAUDE_MODEL_OPTIONS = [
+  {
+    value: "sonnet",
+    label: "Sonnet",
+    description: "Balanced default for day-to-day coding work."
+  },
+  {
+    value: "opus",
+    label: "Opus",
+    description: "Stronger reasoning for complex architecture and debugging."
+  },
+  {
+    value: "haiku",
+    label: "Haiku",
+    description: "Fastest option for lighter tasks."
+  },
+  {
+    value: "opusplan",
+    label: "OpusPlan",
+    description: "Uses Opus for planning and Sonnet for execution."
+  }
+];
 var CLAUDE_CONFIG_PROFILE = {
   harness: "claude-code",
   buildIsolationConfig: buildClaudeCompatibleIsolationConfig,
-  resolveModelName: ({ projectDir, configuredModel }) => resolveClaudeModel({ projectDir, configuredModel })
+  resolveModelName: ({ projectDir, configuredModel }) => resolveClaudeModel({ projectDir, configuredModel }),
+  pluginDelivery: {
+    mergeWorkflowPluginDirs: true,
+    registrationBuildsMcpConfig: true,
+    workflowPluginsVia: "registration"
+  }
 };
 var claudeHarnessAdapter = {
   id: "claude-code",
@@ -3854,7 +4063,9 @@ var claudeHarnessAdapter = {
     conversationModel: "fresh_per_turn",
     killWaitsForTurnSettlement: true,
     supportsEphemeralSessions: false,
-    supportsConfigurableIsolation: true
+    supportsConfigurableIsolation: true,
+    emitsStartupDiagnostics: true,
+    extraAllowedTools: []
   },
   verify: () => verifyClaudeHarness(),
   createRuntime: (input) => createClaudeHookRuntime({
@@ -3890,7 +4101,8 @@ var claudeHarnessAdapter = {
     };
     return controller;
   },
-  resolveConfigProfile: () => CLAUDE_CONFIG_PROFILE
+  resolveConfigProfile: () => CLAUDE_CONFIG_PROFILE,
+  listModels: async () => CLAUDE_MODEL_OPTIONS
 };
 
 // src/harnesses/codex/runtime/appServerManager.ts
@@ -7029,7 +7241,12 @@ var CODEX_CONFIG_PROFILE = {
     preset: isolationPreset,
     model: configuredModel
   }),
-  resolveModelName: ({ configuredModel }) => configuredModel ?? null
+  resolveModelName: ({ configuredModel }) => configuredModel ?? null,
+  pluginDelivery: {
+    mergeWorkflowPluginDirs: false,
+    registrationBuildsMcpConfig: false,
+    workflowPluginsVia: "generated-mcp"
+  }
 };
 var codexHarnessAdapter = {
   id: "openai-codex",
@@ -7039,7 +7256,12 @@ var codexHarnessAdapter = {
     conversationModel: "persistent_thread",
     killWaitsForTurnSettlement: true,
     supportsEphemeralSessions: true,
-    supportsConfigurableIsolation: true
+    supportsConfigurableIsolation: true,
+    emitsStartupDiagnostics: false,
+    // Codex auto-approves Bash/Edit (outside-sandbox commandExecution /
+    // fileChange) and the scoped 'Permissions' capability, on top of the
+    // shared 'mcp__*' baseline seeded via allowedTools (see buildInitialRules).
+    extraAllowedTools: ["Permissions", "Bash", "Edit"]
   },
   verify: () => verifyCodexHarness(),
   createRuntime: (input) => createCodexRuntime({
@@ -7066,8 +7288,23 @@ var codexHarnessAdapter = {
     };
     return controller;
   },
-  resolveConfigProfile: () => CODEX_CONFIG_PROFILE
+  resolveConfigProfile: () => CODEX_CONFIG_PROFILE,
+  listModels: async (runtime) => {
+    if (!isCodexRuntimeWithModels(runtime)) {
+      throw new Error("Codex runtime is not available");
+    }
+    const models = await runtime.listModels();
+    return models.map((model) => ({
+      value: model.model,
+      label: model.displayName,
+      description: model.description,
+      isDefault: model.isDefault
+    }));
+  }
 };
+function isCodexRuntimeWithModels(runtime) {
+  return Boolean(runtime && "listModels" in runtime);
+}
 
 // src/harnesses/registry.ts
 function buildClaudeCompatibleIsolationConfig2({
@@ -7093,7 +7330,9 @@ var opencodeHarnessAdapter = {
     conversationModel: "fresh_per_turn",
     killWaitsForTurnSettlement: true,
     supportsEphemeralSessions: false,
-    supportsConfigurableIsolation: false
+    supportsConfigurableIsolation: false,
+    emitsStartupDiagnostics: false,
+    extraAllowedTools: []
   },
   createRuntime: (input) => claudeHarnessAdapter.createRuntime(input),
   createSessionController: (input) => claudeHarnessAdapter.createSessionController(input),
@@ -7101,8 +7340,14 @@ var opencodeHarnessAdapter = {
   resolveConfigProfile: () => ({
     harness: "opencode",
     buildIsolationConfig: (input) => buildClaudeCompatibleIsolationConfig2(input),
-    resolveModelName: ({ configuredModel }) => configuredModel ?? null
-  })
+    resolveModelName: ({ configuredModel }) => configuredModel ?? null,
+    pluginDelivery: {
+      mergeWorkflowPluginDirs: true,
+      registrationBuildsMcpConfig: true,
+      workflowPluginsVia: "registration"
+    }
+  }),
+  listModels: async () => []
 };
 var HARNESS_ADAPTERS = [
   claudeHarnessAdapter,
@@ -7218,6 +7463,28 @@ function loadPlugin(pluginDir) {
   }
   return commands2;
 }
+function loadPersonalSkills(skills) {
+  const commands2 = [];
+  for (const skill of skills) {
+    const skillPath = path12.join(skill.path, "SKILL.md");
+    if (!fs14.existsSync(skillPath)) {
+      console.warn(
+        `Skipping personal skill '${skill.name}' [${skill.sourceLayer}]: SKILL.md not found at ${skill.path}`
+      );
+      continue;
+    }
+    try {
+      const parsed = parseFrontmatter(fs14.readFileSync(skillPath, "utf-8"));
+      commands2.push(skillToCommand(parsed.frontmatter, parsed.body));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `Skipping personal skill '${skill.name}' [${skill.sourceLayer}]: ${message}`
+      );
+    }
+  }
+  return commands2;
+}
 function skillToCommand(frontmatter, body, mcpConfigPath) {
   const args = frontmatter["argument-hint"] ? [
     {
@@ -7241,8 +7508,9 @@ function skillToCommand(frontmatter, body, mcpConfigPath) {
 }
 
 // src/infra/plugins/register.ts
-function buildPluginMcpConfig(pluginDirs, mcpServerOptions) {
+function buildPluginMcpConfig(pluginDirs, mcpServerOptions, personalMcpServers = []) {
   const mergedServers = {};
+  const conflicts = [];
   for (const dir of pluginDirs) {
     const mcpPath = path13.join(dir, ".mcp.json");
     if (!fs15.existsSync(mcpPath)) {
@@ -7268,22 +7536,99 @@ function buildPluginMcpConfig(pluginDirs, mcpServerOptions) {
       mergedServers[serverName] = rest;
     }
   }
+  for (const personal of personalMcpServers) {
+    const { name, sourceLayer: _sourceLayer, ...server } = personal;
+    if (name in mergedServers) {
+      conflicts.push(personal);
+      continue;
+    }
+    mergedServers[name] = server;
+  }
   if (Object.keys(mergedServers).length === 0) {
-    return void 0;
+    return { mcpConfig: void 0, conflicts };
   }
   const mcpConfig = path13.join(os10.tmpdir(), `athena-mcp-${process.pid}.json`);
   fs15.writeFileSync(mcpConfig, JSON.stringify({ mcpServers: mergedServers }));
-  return mcpConfig;
+  return { mcpConfig, conflicts };
 }
-function registerPlugins(pluginDirs, mcpServerOptions, includeMcpConfig = true) {
+function registerPlugins(pluginDirs, mcpServerOptions, includeMcpConfig = true, personalMcpServers = [], personalSkills = []) {
   for (const dir of pluginDirs) {
     const commands2 = loadPlugin(dir);
     for (const command of commands2) {
       register(command);
     }
   }
-  const mcpConfig = includeMcpConfig ? buildPluginMcpConfig(pluginDirs, mcpServerOptions) : void 0;
-  return { mcpConfig };
+  const skillByName = new Map(personalSkills.map((skill) => [skill.name, skill]));
+  const skillConflicts = [];
+  for (const command of loadPersonalSkills(personalSkills)) {
+    if (get(command.name)) {
+      const shadowed = skillByName.get(command.name);
+      if (shadowed) {
+        skillConflicts.push(shadowed);
+      }
+      continue;
+    }
+    register(command);
+  }
+  const mcpResult = includeMcpConfig ? buildPluginMcpConfig(pluginDirs, mcpServerOptions, personalMcpServers) : { mcpConfig: void 0, conflicts: [] };
+  return {
+    mcpConfig: mcpResult.mcpConfig,
+    conflicts: { mcpServers: mcpResult.conflicts, skills: skillConflicts }
+  };
+}
+
+// src/infra/plugins/pluginRefResolution.ts
+function resolvePluginDirs(entries) {
+  const dirs = [];
+  const warnings = [];
+  for (const entry of entries) {
+    if (!isMarketplaceRef(entry)) {
+      dirs.push(entry);
+      continue;
+    }
+    try {
+      dirs.push(resolveMarketplacePlugin(entry));
+    } catch (error) {
+      warnings.push(`Skipping plugin "${entry}": ${error.message}`);
+    }
+  }
+  return { dirs, warnings };
+}
+
+// src/infra/capabilities/effective.ts
+function resolveEffectiveCapabilities(input) {
+  const { globalConfig, projectConfig } = input;
+  return {
+    mcpServers: mergeMcpServers(
+      globalConfig.mcpServers,
+      projectConfig.mcpServers
+    ),
+    skills: mergeSkills(globalConfig.skills, projectConfig.skills)
+  };
+}
+function mergeMcpServers(global, project) {
+  const projectNames = new Set(Object.keys(project ?? {}));
+  const result = [];
+  for (const [name, server] of Object.entries(global ?? {})) {
+    if (projectNames.has(name)) continue;
+    result.push({ name, ...server, sourceLayer: "global" });
+  }
+  for (const [name, server] of Object.entries(project ?? {})) {
+    result.push({ name, ...server, sourceLayer: "project" });
+  }
+  return result;
+}
+function mergeSkills(global, project) {
+  const projectNames = new Set((project ?? []).map((s) => s.name));
+  const result = [];
+  for (const skill of global ?? []) {
+    if (projectNames.has(skill.name)) continue;
+    result.push({ ...skill, sourceLayer: "global" });
+  }
+  for (const skill of project ?? []) {
+    result.push({ ...skill, sourceLayer: "project" });
+  }
+  return result;
 }
 
 // src/setup/shouldResolveWorkflow.ts
@@ -7339,6 +7684,9 @@ function bootstrapRuntimeConfig({
   const projectConfig = providedProjectConfig ?? readConfig(projectDir);
   const warnings = [];
   const harness = harnessOverride ?? projectConfig.harness ?? globalConfig.harness ?? DEFAULT_HARNESS;
+  const harnessConfigProfile = resolveHarnessConfigProfile(harness);
+  const pluginDelivery = harnessConfigProfile.pluginDelivery;
+  const workflowPluginsAsGeneratedMcp = pluginDelivery.workflowPluginsVia === "generated-mcp";
   const activeWorkflowSelection = resolveActiveWorkflow({
     globalConfig,
     projectConfig,
@@ -7361,34 +7709,45 @@ function bootstrapRuntimeConfig({
       (plugin) => plugin.claudeArtifactDir
     );
   }
+  const globalPluginResolution = resolvePluginDirs(globalConfig.plugins);
+  const projectPluginResolution = resolvePluginDirs(projectConfig.plugins);
+  warnings.push(
+    ...globalPluginResolution.warnings,
+    ...projectPluginResolution.warnings
+  );
   const pluginDirs = mergePluginDirs({
-    workflowPluginDirs: harness === "openai-codex" ? [] : workflowPluginDirs,
-    globalPlugins: globalConfig.plugins,
-    projectPlugins: projectConfig.plugins,
+    workflowPluginDirs: pluginDelivery.mergeWorkflowPluginDirs ? workflowPluginDirs : [],
+    globalPlugins: globalPluginResolution.dirs,
+    projectPlugins: projectPluginResolution.dirs,
     pluginFlags
   });
-  const pluginResult = pluginDirs.length > 0 ? registerPlugins(
+  const effectiveCapabilities = harness === "openai-codex" ? { mcpServers: [], skills: [] } : resolveEffectiveCapabilities({ globalConfig, projectConfig });
+  const personalMcpServers = effectiveCapabilities.mcpServers;
+  const personalSkills = effectiveCapabilities.skills;
+  const pluginResult = pluginDirs.length > 0 || personalMcpServers.length > 0 || personalSkills.length > 0 ? registerPlugins(
     pluginDirs,
     workflowToResolve ? activeWorkflowConfig.workflowSelections?.[workflowToResolve]?.mcpServerOptions : void 0,
-    harness !== "openai-codex"
-  ) : { mcpConfig: void 0 };
-  const workflowPluginMcpConfig = harness === "openai-codex" ? buildPluginMcpConfig(
+    pluginDelivery.registrationBuildsMcpConfig,
+    personalMcpServers,
+    personalSkills
+  ) : { mcpConfig: void 0, conflicts: { mcpServers: [], skills: [] } };
+  const workflowPluginMcpConfig = workflowPluginsAsGeneratedMcp ? buildPluginMcpConfig(
     workflowPluginDirs,
     workflowToResolve ? activeWorkflowConfig.workflowSelections?.[workflowToResolve]?.mcpServerOptions : void 0
-  ) : void 0;
-  const pluginMcpConfig = harness === "openai-codex" ? void 0 : pluginResult.mcpConfig;
+  ).mcpConfig : void 0;
+  const pluginMcpConfig = workflowPluginsAsGeneratedMcp ? void 0 : pluginResult.mcpConfig;
   const activeWorkflow = resolvedWorkflow;
   const additionalDirectories = [
     ...globalConfig.additionalDirectories,
     ...projectConfig.additionalDirectories
   ];
-  const harnessConfigProfile = resolveHarnessConfigProfile(harness);
   const workflowPlan = compileWorkflowPlan({
     workflow: activeWorkflow,
     resolvedPlugins: activeWorkflow && resolvedWorkflow?.name === activeWorkflow.name ? workflowResolvedPlugins : void 0,
-    pluginMcpConfig: harness === "openai-codex" && activeWorkflow && resolvedWorkflow?.name === activeWorkflow.name ? workflowPluginMcpConfig : pluginResult.mcpConfig
+    pluginMcpConfig: workflowPluginsAsGeneratedMcp && activeWorkflow && resolvedWorkflow?.name === activeWorkflow.name ? workflowPluginMcpConfig : pluginResult.mcpConfig
   });
   const configModel = projectConfig.model || globalConfig.model || activeWorkflow?.model;
+  const configEffort = activeWorkflow?.effort;
   let isolationPreset = initialIsolationPreset;
   if (activeWorkflow?.isolation) {
     const presetOrder = ["strict", "minimal", "permissive"];
@@ -7407,7 +7766,8 @@ function bootstrapRuntimeConfig({
     additionalDirectories,
     pluginDirs,
     verbose,
-    configuredModel: configModel
+    configuredModel: configModel,
+    configuredEffort: configEffort
   });
   const modelName = harnessConfigProfile.resolveModelName({
     projectDir,
@@ -7423,6 +7783,9 @@ function bootstrapRuntimeConfig({
     workflow: activeWorkflow,
     workflowPlan,
     modelName,
+    personalMcpServers,
+    personalSkills,
+    capabilityConflicts: pluginResult.conflicts,
     warnings
   };
 }
@@ -7635,8 +7998,10 @@ function generateTitle(event, ascii = false) {
 }
 function generateNeutralTitle(event, g) {
   switch (event.kind) {
-    case "session.start":
-      return `Session started (${event.data.source})`;
+    case "session.start": {
+      const sessionTitle = event.data.session_title?.trim();
+      return sessionTitle ? truncate(sessionTitle) : `Session started (${event.data.source})`;
+    }
     case "session.end":
       return `Session ended (${event.data.reason})`;
     case "run.start":
@@ -7645,6 +8010,8 @@ function generateNeutralTitle(event, g) {
       return `Run ${event.data.status}`;
     case "user.prompt":
       return truncate(event.data.prompt);
+    case "prompt.expansion":
+      return event.data.command_name ? truncate(`Expanded /${event.data.command_name}`) : "Prompt expanded";
     case "plan.update":
       return truncate(
         event.data.explanation || event.data.delta || "Plan updated"
@@ -7659,6 +8026,10 @@ function generateNeutralTitle(event, g) {
       return `${g["tool.bullet"]} ${event.data.tool_name}`;
     case "tool.post":
       return `${g["tool.gutter"]} ${event.data.tool_name} result`;
+    case "tool.batch": {
+      const n = event.data.tool_calls.length;
+      return `Batch of ${n} tool call${n === 1 ? "" : "s"}`;
+    }
     case "tool.failure":
       return truncate(
         `${g["status.blocked"]} ${event.data.tool_name} failed: ${event.data.error}`
@@ -7889,6 +8260,7 @@ function createRunLifecycle(boundary) {
   let currentRun = null;
   let seq = 0;
   let runSeq = 0;
+  let currentPromptId;
   function getRunId() {
     const sessId = currentSession?.session_id ?? "unknown";
     return `${sessId}:R${runSeq}`;
@@ -7937,7 +8309,13 @@ function createRunLifecycle(boundary) {
     );
   }
   function beginRun(runtimeEvent, triggerType = "other", promptPreview) {
-    if (currentRun && triggerType === "other") return [];
+    const promptId = runtimeEvent.promptId;
+    const isExplicitContextTrigger = triggerType === "resume" || triggerType === "clear" || triggerType === "compact";
+    if (promptId !== void 0 && !isExplicitContextTrigger) {
+      if (currentRun && promptId === currentPromptId) return [];
+    } else if (promptId === void 0 && currentRun && triggerType === "other") {
+      return [];
+    }
     const results = [];
     const closeEvt = closeRunIntoEvent(runtimeEvent, "completed");
     if (closeEvt) results.push(closeEvt);
@@ -7948,6 +8326,7 @@ function createRunLifecycle(boundary) {
       triggerType,
       promptPreview
     );
+    currentPromptId = promptId;
     results.push(
       makeEvent(
         "run.start",
@@ -8027,6 +8406,7 @@ function createRunLifecycle(boundary) {
           if (e.kind === "tool.failure") currentRun.counters.tool_failures++;
           if (e.kind === "permission.request")
             currentRun.counters.permission_requests++;
+          if (e.prompt_id !== void 0) currentPromptId = e.prompt_id;
         }
       }
     }
@@ -8538,6 +8918,15 @@ function toolUseCause(toolUseId, parentId) {
     ...parentId ? { parent_event_id: parentId } : {}
   };
 }
+function readToolBatchCalls2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "object" && entry !== null).map((entry) => readObject(entry)).map((call) => ({
+    tool_name: readString(call["tool_name"]),
+    tool_input: readObject(call["tool_input"]),
+    tool_use_id: readString(call["tool_use_id"]),
+    tool_response: readString(call["tool_response"])
+  }));
+}
 function createToolProjection(args) {
   const {
     ensureRunArray,
@@ -8594,6 +8983,21 @@ function createToolProjection(args) {
   return {
     mapToolEvent(event, data) {
       const results = ensureRunArray(event);
+      if (event.kind === "tool.batch") {
+        results.push(
+          makeEvent(
+            "tool.batch",
+            "info",
+            resolveToolActor(),
+            {
+              tool_calls: readToolBatchCalls2(data["tool_calls"]),
+              permission_mode: readString(data["permission_mode"])
+            },
+            event
+          )
+        );
+        return results;
+      }
       const toolUseId = resolveToolUseId(event, data);
       const toolName = event.toolName ?? readString(data["tool_name"]) ?? "Unknown";
       const toolInput = readObject(data["tool_input"]);
@@ -9372,7 +9776,8 @@ function createRunSessionProjection(args) {
             {
               source,
               agent_type: readString(data["agent_type"]),
-              model: readString(data["model"])
+              model: readString(data["model"]),
+              session_title: readString(data["session_title"])
             },
             event
           )
@@ -9417,6 +9822,34 @@ function createRunSessionProjection(args) {
         );
         return results;
       }
+      if (event.kind === "prompt.expansion") {
+        if (event.promptId !== void 0) {
+          results.push(
+            ...ensureRunArray(
+              event,
+              "user_prompt_submit",
+              readString(data["prompt"])?.slice(0, 80)
+            )
+          );
+        }
+        results.push(
+          makeEvent(
+            "prompt.expansion",
+            "info",
+            "user",
+            {
+              expansion_type: readString(data["expansion_type"]),
+              command_name: readString(data["command_name"]),
+              command_args: readString(data["command_args"]),
+              command_source: readString(data["command_source"]),
+              prompt: readString(data["prompt"]),
+              permission_mode: event.context.permissionMode ?? readString(data["permission_mode"])
+            },
+            event
+          )
+        );
+        return results;
+      }
       if (event.kind === "turn.start") {
         agentMessageStream.clearPending();
         const prompt = readString(data["prompt"]);
@@ -9649,6 +10082,7 @@ var RUN_SESSION_EVENT_KINDS = /* @__PURE__ */ new Set([
   "session.start",
   "session.end",
   "user.prompt",
+  "prompt.expansion",
   "turn.start",
   "message.delta",
   "message.complete",
@@ -9661,6 +10095,7 @@ var TOOL_EVENT_KINDS = /* @__PURE__ */ new Set([
   "tool.delta",
   "tool.pre",
   "tool.post",
+  "tool.batch",
   "tool.failure"
 ]);
 var DECISION_EVENT_KINDS = /* @__PURE__ */ new Set([
@@ -9722,6 +10157,8 @@ function createFeedMapper(bootstrap) {
       ts: runtimeEvent.timestamp,
       session_id: runtimeEvent.sessionId,
       run_id: runId,
+      prompt_id: runtimeEvent.promptId,
+      effort_level: runtimeEvent.effortLevel,
       kind,
       level,
       actor_id: actorId,
@@ -9877,7 +10314,7 @@ function createFeedMapper(bootstrap) {
 }
 
 // src/infra/sessions/schema.ts
-var SCHEMA_VERSION = 6;
+var SCHEMA_VERSION = 7;
 var applySessionSchema = (db, fromVersion) => {
   db.exec(`
 		CREATE TABLE IF NOT EXISTS session (
@@ -9907,6 +10344,10 @@ var applySessionSchema = (db, fromVersion) => {
 			actor_id TEXT NOT NULL,
 			timestamp INTEGER NOT NULL,
 			data JSON NOT NULL,
+			-- Harness-native Prompt identity (Claude prompt_id): a nullable
+			-- correlation key, NOT the Run identity (that stays run_id). Unset for
+			-- pre-prompt bootstrap + harnesses/versions without it (ADR 0009).
+			prompt_id TEXT,
 			FOREIGN KEY (runtime_event_id) REFERENCES runtime_events(id)
 		);
 
@@ -9960,6 +10401,11 @@ var applySessionSchema = (db, fromVersion) => {
 		CREATE INDEX IF NOT EXISTS idx_workflow_runs_session ON workflow_runs(session_id);
 		CREATE INDEX IF NOT EXISTS idx_outbox_due ON channel_outbox(next_attempt_at);
 	`);
+  if (fromVersion === void 0 || fromVersion >= 7) {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_feed_prompt ON feed_events(prompt_id);"
+    );
+  }
   if (fromVersion === void 0) return;
   if (fromVersion >= SCHEMA_VERSION) return;
   if (fromVersion < 2) {
@@ -10022,6 +10468,14 @@ var applySessionSchema = (db, fromVersion) => {
 			UPDATE schema_version SET version = 6;
 		`);
   }
+  const versionAfterV6 = db.prepare("SELECT version FROM schema_version").get().version;
+  if (versionAfterV6 === 6) {
+    db.exec(`
+			ALTER TABLE feed_events ADD COLUMN prompt_id TEXT;
+			CREATE INDEX IF NOT EXISTS idx_feed_prompt ON feed_events(prompt_id);
+			UPDATE schema_version SET version = 7;
+		`);
+  }
 };
 var SESSION_SCHEMA = {
   version: SCHEMA_VERSION,
@@ -10078,8 +10532,8 @@ function createSessionStore(opts) {
 		 VALUES (?, ?, ?, ?, ?, ?)`
   );
   const insertFeedEvent = db.prepare(
-    `INSERT OR IGNORE INTO feed_events (event_id, runtime_event_id, seq, kind, run_id, actor_id, timestamp, data)
-		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    `INSERT OR IGNORE INTO feed_events (event_id, runtime_event_id, seq, kind, run_id, actor_id, timestamp, data, prompt_id)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
   const insertAdapterSession = db.prepare(
     `INSERT OR IGNORE INTO adapter_sessions (session_id, started_at)
@@ -10134,7 +10588,8 @@ function createSessionStore(opts) {
           fe.run_id,
           fe.actor_id,
           fe.ts,
-          JSON.stringify(fe)
+          JSON.stringify(fe),
+          fe.prompt_id ?? null
         );
       }
       updateEventCount.run(feedEvents.length, opts.sessionId);
@@ -10150,7 +10605,8 @@ function createSessionStore(opts) {
         fe.run_id,
         fe.actor_id,
         fe.ts,
-        JSON.stringify(fe)
+        JSON.stringify(fe),
+        fe.prompt_id ?? null
       );
     }
     updateEventCount.run(feedEvents.length, opts.sessionId);
@@ -11984,6 +12440,13 @@ var stopFailure = defaultRenderer(
 var permissionDenied = defaultRenderer(
   (event) => `${event.data.tool_name}${event.data.reason ? `: ${event.data.reason}` : ""}`
 );
+var promptExpansion = defaultRenderer(
+  (event) => event.data.command_name ? `/${event.data.command_name}${event.data.command_args ? ` ${event.data.command_args}` : ""}` : event.data.expansion_type ?? ""
+);
+var toolBatch = defaultRenderer((event) => {
+  const names = event.data.tool_calls.map((call) => call.tool_name).filter((name) => Boolean(name));
+  return names.length > 0 ? names.join(", ") : "";
+});
 var elicitationRequest = defaultRenderer((event) => `elicitation from ${event.data.mcp_server}`);
 var elicitationResult = defaultRenderer(
   (event) => `${event.data.mcp_server} \u2192 ${event.data.action}`
@@ -12032,6 +12495,7 @@ var RENDERERS = {
   "tool.delta": toolDelta,
   "tool.pre": toolPre,
   "tool.post": toolPost,
+  "tool.batch": toolBatch,
   "tool.failure": toolFailure,
   "permission.request": permissionRequest,
   "permission.decision": permissionDecision,
@@ -12071,6 +12535,7 @@ var RENDERERS = {
   "worktree.remove": worktreeRemove,
   "stop.failure": stopFailure,
   "permission.denied": permissionDenied,
+  "prompt.expansion": promptExpansion,
   "elicitation.request": elicitationRequest,
   "elicitation.result": elicitationResult,
   "channel.permission.relayed": channelPermissionRelayed,
@@ -12912,6 +13377,7 @@ function resolveEventToolColumn(event) {
     case "tool.delta":
     case "tool.pre":
     case "tool.post":
+    case "tool.batch":
     case "tool.failure":
     case "permission.decision":
     case "permission.denied":
@@ -12939,6 +13405,7 @@ function resolveEventToolColumn(event) {
     case "todo.done":
     case "agent.message":
     case "teammate.idle":
+    case "prompt.expansion":
     case "task.created":
     case "task.completed":
     case "config.change":
@@ -13642,7 +14109,7 @@ function extractRelayQuestions(event) {
 }
 
 // src/app/channels/gatewayControlClient.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/gateway/control/client.ts
 import crypto from "crypto";
@@ -13750,6 +14217,7 @@ async function connect(opts) {
     preHelloResolve = (frame) => {
       clearTimeout(timer);
       preHelloAbort = null;
+      helloAcked = true;
       resolve(frame);
     };
     preHelloAbort = (err) => {
@@ -13772,7 +14240,6 @@ async function connect(opts) {
     }
     throw new GatewayProtocolError(String(msg));
   }
-  helloAcked = true;
   const request = async (kind, payload, reqOpts) => {
     const requestId = crypto.randomUUID();
     const envelope = {
@@ -13793,9 +14260,6 @@ async function connect(opts) {
     );
     connection.send(envelope);
     const res = await responsePromise;
-    if (res.request_id !== requestId) {
-      throw new GatewayProtocolError("response request_id mismatch");
-    }
     if (!res.ok) {
       throw new GatewayProtocolError(
         `${res.error.code}: ${res.error.message}`,
@@ -13832,93 +14296,6 @@ function isStringRecord(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
-// src/gateway/transport/wsClient.ts
-import { WebSocket } from "ws";
-import { readFileSync as readFileSync2 } from "fs";
-function createWsClientTransport(opts) {
-  return {
-    kind: "ws",
-    connect: () => connectWs(opts)
-  };
-}
-function wsClientOptionsForEndpoint(input) {
-  return {
-    url: input.url,
-    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
-    ...input.tlsCaPath !== void 0 ? { tlsCaPath: input.tlsCaPath } : {}
-  };
-}
-async function connectWs(opts) {
-  const timeoutMs = opts.timeoutMs ?? 5e3;
-  const wsOpts = opts.tlsCaPath ? { ca: readFileSync2(opts.tlsCaPath) } : {};
-  const ws = new WebSocket(opts.url, wsOpts);
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      ws.close();
-      reject(
-        new TransportUnreachableError(`connect timed out after ${timeoutMs}ms`)
-      );
-    }, timeoutMs);
-    ws.once("open", () => {
-      clearTimeout(timer);
-      resolve();
-    });
-    ws.once("error", (err) => {
-      clearTimeout(timer);
-      reject(
-        new TransportUnreachableError(
-          `gateway not reachable at ${opts.url}: ${err.message}`
-        )
-      );
-    });
-  });
-  return createWsConnection(ws, opts.url);
-}
-function createWsConnection(ws, peer) {
-  const frameHandlers = /* @__PURE__ */ new Set();
-  const closeHandlers = /* @__PURE__ */ new Set();
-  const errorHandlers = /* @__PURE__ */ new Set();
-  ws.on("message", (data) => {
-    let parsed;
-    try {
-      parsed = JSON.parse(data.toString());
-    } catch {
-      ws.close();
-      return;
-    }
-    traceGatewayFrame("ws-client", peer, "in", parsed);
-    for (const handler of frameHandlers) handler(parsed);
-  });
-  ws.on("error", (err) => {
-    for (const handler of errorHandlers) handler(err);
-  });
-  ws.on("close", () => {
-    for (const handler of closeHandlers) handler();
-  });
-  return {
-    kind: "ws",
-    peer,
-    send: (frame) => {
-      if (ws.readyState !== ws.OPEN) return;
-      traceGatewayFrame("ws-client", peer, "out", frame);
-      ws.send(JSON.stringify(frame));
-    },
-    close: () => ws.close(),
-    onFrame: (cb) => {
-      frameHandlers.add(cb);
-      return () => frameHandlers.delete(cb);
-    },
-    onClose: (cb) => {
-      closeHandlers.add(cb);
-      return () => closeHandlers.delete(cb);
-    },
-    onError: (cb) => {
-      errorHandlers.add(cb);
-      return () => errorHandlers.delete(cb);
-    }
-  };
-}
-
 // src/app/channels/gatewayControlClient.ts
 async function connectGatewayControlClient(opts) {
   const loadToken = opts.loadToken ?? defaultLoadToken;
@@ -13940,7 +14317,7 @@ async function connectGatewayControlClient(opts) {
   });
 }
 function defaultLoadToken(tokenPath) {
-  return readFileSync3(tokenPath, "utf8").trim();
+  return readFileSync2(tokenPath, "utf8").trim();
 }
 
 // src/infra/config/gatewayClient.ts
@@ -15034,6 +15411,10 @@ function createExecOutputWriter(options) {
       if (!options.verbose) return;
       writeLine(options.stderr, `[athena exec] ${message}`);
     },
+    notice(message) {
+      if (options.json) return;
+      writeLine(options.stderr, `[athena exec] ${message}`);
+    },
     warn(message) {
       writeLine(options.stderr, `[athena exec] warning: ${message}`);
     },
@@ -15062,6 +15443,34 @@ var NULL_TOKENS3 = {
   contextSize: null,
   contextWindowSize: null
 };
+function formatPersonalCapabilityNotice(summary) {
+  const parts = [];
+  if (summary.mcpServers.length > 0) {
+    const list = summary.mcpServers.map((server) => `${server.name} [${server.sourceLayer}]`).join(", ");
+    parts.push(`mcp servers: ${list}`);
+  }
+  if (summary.skills.length > 0) {
+    const list = summary.skills.map((skill) => `${skill.name} [${skill.sourceLayer}]`).join(", ");
+    parts.push(`skills: ${list}`);
+  }
+  if (parts.length === 0) return null;
+  return `personal capabilities active \u2014 ${parts.join("; ")}`;
+}
+function formatCapabilityConflictNotice(summary) {
+  const parts = [];
+  if (summary.mcpServers.length > 0) {
+    const list = summary.mcpServers.map((server) => `${server.name} [${server.sourceLayer}]`).join(", ");
+    parts.push(`mcp servers: ${list}`);
+  }
+  if (summary.skills.length > 0) {
+    const list = summary.skills.map((skill) => `${skill.name} [${skill.sourceLayer}]`).join(", ");
+    parts.push(`skills: ${list}`);
+  }
+  if (parts.length === 0) return null;
+  return `personal capability conflicts \u2014 workflow plugin wins; shadowed: ${parts.join(
+    "; "
+  )}`;
+}
 function workflowFailure(state, message) {
   return {
     kind: "workflow",
@@ -15336,11 +15745,29 @@ async function runExec(options) {
       });
     }, options.timeoutMs);
   }
+  const personalCapabilities = options.personalCapabilities ?? {
+    mcpServers: [],
+    skills: []
+  };
+  const capabilityConflicts = options.capabilityConflicts ?? {
+    mcpServers: [],
+    skills: []
+  };
   output.emitJsonEvent("exec.started", {
     projectDir: options.projectDir,
     harness: options.harness,
-    athenaSessionId: options.ephemeral ? null : athenaSessionId
+    athenaSessionId: options.ephemeral ? null : athenaSessionId,
+    personalCapabilities,
+    capabilityConflicts
   });
+  const personalCapabilityNotice = formatPersonalCapabilityNotice(personalCapabilities);
+  if (personalCapabilityNotice) {
+    output.notice(personalCapabilityNotice);
+  }
+  const capabilityConflictNotice = formatCapabilityConflictNotice(capabilityConflicts);
+  if (capabilityConflictNotice) {
+    output.notice(capabilityConflictNotice);
+  }
   try {
     await runtime.start();
     runtimeStarted = true;
@@ -15497,7 +15924,7 @@ async function runExec(options) {
 }
 
 // src/app/dashboard/instanceSocketClient.ts
-import { WebSocket as WebSocket2 } from "ws";
+import { WebSocket } from "ws";
 var DEFAULT_HEARTBEAT_MS = 3e4;
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 function instanceSocketUrl(dashboardUrl, instanceId) {
@@ -15514,7 +15941,7 @@ function createInstanceSocketClient(opts) {
   const log = opts.log ?? (() => {
   });
   const now = opts.now ?? (() => Date.now());
-  const makeWebSocket = opts.makeWebSocket ?? ((url, accessToken) => new WebSocket2(url, [accessToken]));
+  const makeWebSocket = opts.makeWebSocket ?? ((url, accessToken) => new WebSocket(url, [accessToken]));
   const frameHandlers = /* @__PURE__ */ new Set();
   const closeHandlers = /* @__PURE__ */ new Set();
   let ws = null;
@@ -15714,7 +16141,7 @@ function normalizeHarnessOverride(value) {
 }
 
 // src/app/dashboard/runStreamClient.ts
-import { WebSocket as WebSocket3 } from "ws";
+import { WebSocket as WebSocket2 } from "ws";
 var DEFAULT_RECONNECT_DELAYS_MS = [250, 1e3, 2e3, 5e3, 15e3];
 var DEFAULT_HEARTBEAT_MS2 = 3e4;
 var DEFAULT_WATCHDOG_MS = 9e4;
@@ -15727,7 +16154,7 @@ function createRunStreamClient(opts) {
   const heartbeatMs = opts.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS2;
   const watchdogMs = opts.watchdogTimeoutMs ?? DEFAULT_WATCHDOG_MS;
   const maxQueueSize = opts.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
-  const makeWebSocket = opts.makeWebSocket ?? ((url) => new WebSocket3(url));
+  const makeWebSocket = opts.makeWebSocket ?? ((url) => new WebSocket2(url));
   const setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
   const clearTimer = opts.clearTimer ?? ((t) => clearTimeout(t));
   let nextSeq = 1;
@@ -18092,8 +18519,6 @@ export {
   GatewayUnreachableError,
   GatewayUnauthorizedError,
   connect,
-  createWsClientTransport,
-  wsClientOptionsForEndpoint,
   isSupportedGatewayUrl,
   readGatewayClientConfig,
   writeGatewayClientConfig,
@@ -18121,6 +18546,8 @@ export {
   isBashToolResponse,
   resolveToolColumn,
   IndexedTimeline,
+  parseFrontmatter,
+  resolveEffectiveCapabilities,
   bootstrapRuntimeConfig,
   EXEC_EXIT_CODE,
   runExec,
@@ -18133,4 +18560,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-QBMYQJFX.js.map
+//# sourceMappingURL=chunk-YZ7RCBKO.js.map