@harness-mix/cli 0.1.5 → 0.1.6

package/scripts/native-skill-roots-test.cjs

@@ -0,0 +1,90 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { ParityObserver } = require('./support/parity-observer.cjs');
+const { HostRuntime } = require('../src/main/host/runtime');
+
+// 用户可见契约：打开原生会话时，先为每个 Harness 创建缺失的原生技能根目录，
+// 这样刚安装、从未运行过的 Harness 也能立即被 Harness Mix 发现并安装技能。
+// 单个目录创建失败只提示、不阻断会话；项目作用域不可用时退化为全局根目录。
+
+const skills = { global: ['.test-harness/skills'], project: ['.agents/skills'] };
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function until(fn) { for (let i = 0; i < 200; i++) { if (fn()) return; await sleep(10); } throw new Error('timed out'); }
+
+function stubAdapter(id, onOpen) {
+  return {
+    manifest: { id, name: 'Test Harness', capabilities: {}, integrations: { mcp: false, skills: JSON.parse(JSON.stringify(skills)) } },
+    async open(input) { onOpen?.(input); return {}; },
+    async send() {}, async cancel() {}, async respond() {}, async close() {},
+  };
+}
+
+async function main() {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-skill-roots-'));
+  const workspace = path.join(directory, 'workspace');
+  const home = path.join(directory, 'home');
+  await fs.mkdir(workspace); await fs.mkdir(home);
+
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: directory });
+  await rt.store.load();
+  rt.integrations.home = home;
+  rt.integrations.environment = {};
+
+  // 1) 缺失的技能目录在会话打开时被创建（全局 + 项目）。
+  let opened = 0, emit = null;
+  const adapter = stubAdapter('test-harness', input => { opened++; emit = input.emit; });
+  rt.adapters.set(adapter.manifest.id, adapter);
+  rt.status[adapter.manifest.id] = { available: true };
+  const thread = await rt.createThread({ harnessId: adapter.manifest.id, cwd: workspace });
+  const toasts = [];
+  rt.subscribe(event => { if (event.type === 'toast') toasts.push(event); });
+  await rt.send(thread.id, 'hello');
+  assert.equal(opened, 1, 'native session opened');
+  for (const root of [path.join(home, '.test-harness', 'skills'), path.join(workspace, '.agents', 'skills')]) {
+    assert.equal((await fs.stat(root)).isDirectory(), true, `${root} created on launch`);
+  }
+  assert.deepEqual(toasts, [], 'a successful launch reports no skill-root failure');
+  emit({ kind: 'completed', finalAnswer: true });
+  await until(() => thread.status === 'ready' && !thread.reviewPending);
+
+  // 2) 已存在的根目录被复用，重复打开不会失败。
+  await fs.mkdir(path.join(home, '.test-harness', 'skills', 'existing'), { recursive: true });
+  await rt.send(thread.id, 'again');
+  assert.equal(opened, 1, 'same thread reuses the native session');
+  emit({ kind: 'completed', finalAnswer: true });
+  await until(() => thread.status === 'ready' && !thread.reviewPending);
+  assert.equal((await fs.stat(path.join(home, '.test-harness', 'skills', 'existing'))).isDirectory(), true, 'existing skill content untouched');
+
+  // 3) 无法创建的根目录只提示并跳过，会话照常打开。
+  const blockedHome = path.join(directory, 'blocked-home');
+  await fs.mkdir(path.join(blockedHome, '.test-harness'), { recursive: true });
+  await fs.writeFile(path.join(blockedHome, '.test-harness', 'skills'), 'not a directory');
+  const blockedWorkspace = path.join(directory, 'blocked-workspace');
+  await fs.mkdir(blockedWorkspace);
+  const blocked = new HostRuntime({ observer: new ParityObserver(), dataDirectory: path.join(directory, 'blocked-data') });
+  await blocked.store.load();
+  blocked.integrations.home = blockedHome;
+  blocked.integrations.environment = {};
+  let blockedOpened = 0;
+  const blockedAdapter = stubAdapter('test-harness', () => { blockedOpened++; });
+  blocked.adapters.set(blockedAdapter.manifest.id, blockedAdapter);
+  blocked.status[blockedAdapter.manifest.id] = { available: true };
+  const blockedThread = await blocked.createThread({ harnessId: blockedAdapter.manifest.id, cwd: blockedWorkspace });
+  const blockedToasts = [];
+  console.log('DBG blocked.integrations.home =', blocked.integrations.home);
+  console.log('DBG global root stat type =', (await fs.lstat(path.join(blockedHome, '.test-harness', 'skills'))).isFile() ? 'FILE' : 'other');
+  blocked.subscribe(event => { if (event.type === 'toast') blockedToasts.push(event); });
+  await blocked.send(blockedThread.id, 'hello');
+  assert.equal(blockedOpened, 1, 'session still opens when a skill root cannot be created');
+  assert.equal(blocked.sessions.has(blockedThread.id), true, 'native session attached despite the uncreatable root');
+  assert.equal(blockedThread.error, undefined, 'no session error from the uncreatable root');
+  assert.equal((await fs.stat(path.join(blockedWorkspace, '.agents', 'skills'))).isDirectory(), true, 'the remaining root is still created');
+  console.log('TOASTS:', JSON.stringify(blockedToasts.map(t => ({ type: t.type, level: t.level, text: String(t.text).slice(0, 140) }))));
+  assert.equal(blockedToasts.filter(event => /原生技能目录准备失败/.test(event.text)).length, 1, 'the skipped root is reported once');
+
+  console.log('native skill roots: created on session open, reused when present, and never fatal PASS');
+  await fs.rm(directory, { recursive: true, force: true });
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/test-live-mentions.cjs

@@ -0,0 +1,152 @@
+const http = require('node:http');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+function getJson(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, res => {
+      let data = '';
+      res.on('data', c => (data += c));
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch (e) { reject(e); } });
+    }).on('error', reject);
+  });
+}
+
+async function main() {
+  const port = process.argv[2] || '57989';
+  const targets = await getJson(`http://127.0.0.1:${port}/json/list`);
+  const page = targets.find(t => t.type === 'page' && t.url === 'app://-/index.html');
+  if (!page) throw new Error('main page not found');
+  const ws = new WebSocket(page.webSocketDebuggerUrl);
+  await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+
+  let id = 0;
+  const pending = new Map();
+  ws.onmessage = ev => {
+    const msg = JSON.parse(ev.data);
+    if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); }
+  };
+  const send = (method, params) => new Promise(res => {
+    const i = ++id;
+    pending.set(i, res);
+    ws.send(JSON.stringify({ id: i, method, params }));
+  });
+
+  const evaluate = async expr => {
+    const result = await send('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true });
+    if (result.result?.exceptionDetails) {
+      throw new Error(JSON.stringify(result.result.exceptionDetails));
+    }
+    return result.result?.result?.value;
+  };
+
+  console.log('Waiting for probe to mount...');
+  await evaluate(`(async () => {
+    for (let i = 0; i < 50; i++) {
+      if (window.__codexhostRendererBindingProbeV1 && document.querySelector('.ProseMirror')) break;
+      await new Promise(r => setTimeout(r, 100));
+    }
+  })()`);
+
+  const directClientTest = await evaluate(`(async () => {
+    try {
+      const probe = window.__codexhostRendererBindingProbeV1;
+      return {
+        hasProbe: !!probe,
+        probeKeys: probe ? Object.keys(probe) : []
+      };
+    } catch (e) {
+      return { error: e.message, stack: e.stack };
+    }
+  })()`);
+  console.log('Direct client test:', JSON.stringify(directClientTest, null, 2));
+
+  console.log('Focusing editor and positioning caret at end...');
+  await evaluate(`(() => {
+    const editor = document.querySelector('.ProseMirror');
+    if (!editor) return;
+    editor.focus();
+    const p = editor.querySelector('p') || editor;
+    const sel = window.getSelection();
+    const range = document.createRange();
+    range.selectNodeContents(p);
+    range.collapse(false);
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+  })()`);
+
+  // Send input via CDP
+  console.log('Sending CDP input for #...');
+  await send('Input.insertText', { text: '#' });
+  await new Promise(r => setTimeout(r, 600));
+
+  const menuInfo = await evaluate(`(() => {
+    const menu = document.querySelector('[data-harness-mix-mentions]');
+    const tabs = [...document.querySelectorAll('[data-harness-mix-mentions] [role="tab"]')].map(t => t.textContent.trim());
+    const options = [...document.querySelectorAll('[data-harness-mix-mentions] [role="option"]')].map(opt => {
+      const name = opt.querySelector('span[style*="font-weight:600"]')?.textContent || opt.innerText;
+      const desc = opt.querySelector('span[style*="font-size:11px"]')?.textContent || '';
+      return { name, desc, disabled: opt.hasAttribute('disabled') };
+    });
+    return {
+      lastMentionDebug: window.__lastMentionDebug,
+      menuHidden: menu ? menu.hidden : true,
+      menuDisplay: menu ? menu.style.display : null,
+      menuRect: menu ? { left: menu.style.left, top: menu.style.top, bottom: menu.style.bottom } : null,
+      tabs,
+      optionCount: options.length,
+      sampleOptions: options.slice(0, 8)
+    };
+  })()`);
+  console.log('Menu state after typing #:', JSON.stringify(menuInfo, null, 2));
+
+  // Capture screenshot with popup open
+  const shot1 = await send('Page.captureScreenshot', { format: 'png' });
+  const data1 = shot1.result?.data || shot1.data;
+  if (data1) {
+    await fs.mkdir('output', { recursive: true });
+    await fs.writeFile(path.resolve('output/live-hash-mentions.png'), Buffer.from(data1, 'base64'));
+    console.log('Saved output/live-hash-mentions.png');
+  }
+
+  // 2. Select an agent (e.g. click first option) and verify badge styling
+  const state2 = await evaluate(`(async () => {
+    const firstOption = document.querySelector('[data-harness-mix-mentions] [role="option"]:not([disabled])');
+    if (firstOption) {
+      firstOption.click();
+      await new Promise(r => setTimeout(r, 200));
+    }
+    const badges = [...document.querySelectorAll('[data-harness-mix-selected-mentions] [data-harness-mix-mention-badge]')].map(b => ({
+      text: b.textContent.trim(),
+      title: b.title,
+      color: b.style.color
+    }));
+    const containerHasAttr = document.querySelector('[data-harness-mix-has-mentions="true"]') !== null;
+    return { badges, containerHasAttr };
+  })()`);
+  console.log('State after selecting agent:', JSON.stringify(state2, null, 2));
+
+  // Capture screenshot with badge in input box
+  const shot2 = await send('Page.captureScreenshot', { format: 'png' });
+  const data2 = shot2.result?.data || shot2.data;
+  if (data2) {
+    await fs.writeFile(path.resolve('output/live-hash-selected-badge.png'), Buffer.from(data2, 'base64'));
+    console.log('Saved output/live-hash-selected-badge.png');
+  }
+
+  // 3. Clear badge so we leave the UI clean
+  await evaluate(`(() => {
+    const badge = document.querySelector('[data-harness-mix-selected-mentions] [data-harness-mix-mention-badge]');
+    if (badge) badge.click();
+    const editor = document.querySelector('[contenteditable="true"], .ProseMirror, textarea');
+    if (editor && !editor.value) editor.textContent = '';
+  })()`);
+
+  ws.close();
+  console.log('Done!');
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/main/adapters/antigravity.js

@@ -639,21 +639,21 @@ class QuestionBridge {
       CODEXHOST_AGY_QUESTION_CLIENT: `"${clientPath.replaceAll('\\', '/')}"`,
     };
 
-    if (options.collaboration || options.managedMcp?.length) {
+    if (options.collaboration || options.managedMcp?.length) {
       const pluginDir = path.join(dir, '.agents', 'plugins', 'harness-mix');
       const plainPluginDir = path.join(dir, 'plugins', 'harness-mix');
       await fs.promises.mkdir(pluginDir, { recursive: true });
       await fs.promises.mkdir(plainPluginDir, { recursive: true });
       const pluginManifest = JSON.stringify({ name: 'harness-mix-collaboration', description: 'Harness Mix Multi-agent Collaboration' }, null, 2);
       const mcpConfig = JSON.stringify({
-        mcpServers: require('./managed-mcp').namedServers(options.managedMcp, options.collaboration),
+        mcpServers: require('./managed-mcp').namedServers(options.managedMcp, options.collaboration),
       }, null, 2);
       await fs.promises.writeFile(path.join(pluginDir, 'plugin.json'), pluginManifest, 'utf8');
       await fs.promises.writeFile(path.join(pluginDir, 'mcp_config.json'), mcpConfig, 'utf8');
       await fs.promises.writeFile(path.join(plainPluginDir, 'plugin.json'), pluginManifest, 'utf8');
       await fs.promises.writeFile(path.join(plainPluginDir, 'mcp_config.json'), mcpConfig, 'utf8');
       await fs.promises.writeFile(path.join(dir, '.agents', 'mcp_config.json'), mcpConfig, 'utf8');
-      Object.assign(bridge.environment, options.collaboration?.env || {});
+      Object.assign(bridge.environment, options.collaboration?.env || {});
     }
 
     return bridge;
@@ -817,7 +817,7 @@ function create(emit, options = {}) {
       });
     },
 
-    async open({ thread, emit: emitEvent, diagnostic, collaboration, managedMcp = [] }) {
+    async open({ thread, emit: emitEvent, diagnostic, collaboration, managedMcp = [] }) {
       // Do not start a second agy process while a real turn may be starting.
       // Quota is loaded only by the explicit account/usage refresh path below.
       await restoreLegacyClipboardAttachments(thread);
@@ -830,8 +830,8 @@ function create(emit, options = {}) {
         model,
         thinkingLevel,
         permissionMode,
-        collaboration: collaboration || null,
-        managedMcp,
+        collaboration: collaboration || null,
+        managedMcp,
         collaborationEnabled: !!collaboration,
         activeTurn: null,
         bridge: null,
@@ -853,15 +853,12 @@ function create(emit, options = {}) {
       const bridge = await QuestionBridge.create({
         approvals,
         emit: emitEvent,
-        collaboration: session.collaboration,
-        managedMcp: session.managedMcp,
+        collaboration: session.collaboration,
+        managedMcp: session.managedMcp,
       });
       session.bridge = bridge;
 
       let effectivePrompt = prompt ?? '';
-      if (session.collaborationEnabled) {
-        effectivePrompt = `[多 Agent 协作系统已就绪。你作为主协调者，可调用已注入的 MCP 工具：delegate_to_agent(agent_type, task) 向其他已注册的 Harness（如 @pi、@claude-code、@codex、@deepseek-harness 等）委派子任务，使用 get_delegation_status(task_ids) 等待结果，使用 update_agent_plan(steps) 设定与更新分步计划。]\n\n${effectivePrompt}`;
-      }
       const { imageEntries, extraDirs } = await prepareImageAttachments(attachments?.images, session.cwd);
       if (imageEntries.length) {
         const imageNotice = [
@@ -1211,15 +1208,18 @@ function create(emit, options = {}) {
     },
 
     async cancel(session) {
-      if (session.activeTurn?.child) {
-        void terminateTree(session.activeTurn.child.pid);
+      if (session.activeTurn) {
+        session.activeTurn.completed = true;
+        if (session.activeTurn.child) {
+          void terminateTree(session.activeTurn.child.pid);
+        }
+        session.activeTurn.resolve?.();
+        session.activeTurn = null;
       }
       if (session.bridge) {
         await session.bridge.dispose().catch(() => {});
         session.bridge = null;
       }
-      session.activeTurn?.resolve?.();
-      session.activeTurn = null;
     },
 
     async respond(session, requestId, response) {
@@ -1345,8 +1345,11 @@ function create(emit, options = {}) {
   };
 }
 
-manifest.integrations = { mcp: true };
-module.exports = {
+// https://antigravity.google/docs/skills/#where-skills-live
+// Single assignment: an earlier declaration used to be silently overwritten here,
+// which dropped Antigravity's native skill roots from the manifest.
+manifest.integrations = { mcp: true, skills: { global: ['.gemini/config/skills'], project: ['.agents/skills'] } };
+module.exports = {
   manifest,
   create,
   parseModelsOutput,

package/src/main/adapters/claude.js

@@ -20,7 +20,7 @@ const CLAUDE_PERMISSION_MODES = [
   { id: "acceptEdits", label: "接受编辑", description: "允许文件编辑；其他受保护操作前询问" },
   { id: "auto", label: "自动模式", description: "由 Claude 判断权限请求" },
   { id: "dontAsk", label: "免询问", description: "跳过权限询问（非绕过检查）" },
-  { id: "bypassPermissions", label: "绕过权限", description: "跳过全部权限检查，谨慎使用", dangerous: true },
+  { id: "bypassPermissions", label: "绕过权限 (YOLO)", description: "跳过全部权限检查（YOLO 模式），自动放行工具执行", dangerous: true },
 ];
 
 function summarizeInput(input) {
@@ -244,14 +244,25 @@ async function loadSdk() {
   return import("@anthropic-ai/claude-agent-sdk");
 }
 
+function normalizeClaudePermissionMode(mode) {
+  if (mode === 'yolo' || mode === 'skip' || mode === 'dangerously-skip-permissions') {
+    return 'bypassPermissions';
+  }
+  return mode;
+}
+
 /** 建立一个常驻 SDK 会话（open 与 fork 共用）：构造 query、启动事件泵 */
-function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelId, effort, emit, collaboration, managedMcp = [], onPlanLimit }) {
+function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelId, effort, emit, collaboration, managedMcp = [], onPlanLimit, isWorker = false }) {
   const input = new MessageQueue();
+  const normalizedPermissionMode = normalizeClaudePermissionMode(permissionMode) || (isWorker ? 'bypassPermissions' : undefined);
+  const isBypass = normalizedPermissionMode === 'bypassPermissions' || isWorker;
+
   const session = {
     nativeSessionId: resumeId || newSessionId,
     cwd,
     collaborationEnabled: !!collaboration,
-    permissionMode,
+    permissionMode: normalizedPermissionMode,
+    isWorker,
     model: undefined,
     input,
     query: undefined,
@@ -270,10 +281,17 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
       ...(resumeId ? { resume: resumeId } : {}),
       ...(!resumeId && newSessionId ? { sessionId: newSessionId } : {}),
       ...(effort ? { effort } : {}),
-      ...(permissionMode ? { permissionMode } : {}),
+      ...(normalizedPermissionMode ? { permissionMode: normalizedPermissionMode } : {}),
+      ...(isBypass ? { allowDangerouslySkipPermissions: true } : {}),
       ...(modelId ? { model: modelId } : {}),
       ...(process.env.HARNESS_MIX_CLAUDE_EXECUTABLE ? { pathToClaudeCodeExecutable: process.env.HARNESS_MIX_CLAUDE_EXECUTABLE } : {}),
       canUseTool: (toolName, toolInput, { signal, suggestions }) => {
+        if (toolName !== 'AskUserQuestion') {
+          const currentMode = normalizeClaudePermissionMode(session.permissionMode);
+          if (currentMode === 'bypassPermissions' || session.isWorker) {
+            return { behavior: 'allow', updatedInput: toolInput };
+          }
+        }
         const requestId = randomUUID();
         emit(projectApproval(requestId, toolName, toolInput, suggestions));
         return new Promise((resolve) => {
@@ -380,12 +398,16 @@ function create() {
     },
     async open({ thread, emit, collaboration, managedMcp }) {
       const sdk = await loadSdk();
+      const isWorker = Boolean(thread.parentThreadId);
+      const rawMode = thread.options?.permissionMode;
+      const permissionMode = normalizeClaudePermissionMode(rawMode) || (isWorker ? 'bypassPermissions' : undefined);
       return spawnSession(sdk, {
         cwd: thread.cwd,
         resumeId: thread.restore ? thread.nativeSessionId : undefined,
         newSessionId: thread.restore ? undefined : thread.nativeSessionId,
         effort: thread.options?.thinking,
-        permissionMode: thread.options?.permissionMode,
+        permissionMode,
+        isWorker,
         modelId: thread.options?.model?.id,
         emit,
         collaboration,
@@ -412,11 +434,19 @@ function create() {
     },
 
     async cancel(session) {
+      for (const pending of session.pendingApprovals?.values() ?? []) {
+        pending.resolve({ behavior: "deny", message: "用户取消了请求", interrupt: true });
+      }
+      session.pendingApprovals?.clear();
       // 原生优雅中断；超时后由 Host 走 close 兜底
       await Promise.race([
         session.query?.interrupt().catch(() => {}),
-        new Promise((r) => setTimeout(r, 5_000)),
+        new Promise((r) => setTimeout(r, 2_000)),
       ]);
+      if (session.state.turn) {
+        session.state.turn.resolve();
+        session.state.turn = null;
+      }
     },
 
     async listCommands(session) {
@@ -452,10 +482,12 @@ function create() {
       const copied = await getSessionMessages(result.sessionId, { dir: source.cwd });
       const checkpointMap = Object.fromEntries(copied.map((entry, index) => [history[index].uuid, entry.uuid]));
       // Fork 出的新原生会话立即拉起常驻进程（resume 到新 sessionId），与 open() 同路径
+      const isWorker = Boolean(source.parentThreadId);
       const session = spawnSession(sdk, {
         cwd: source.cwd,
         resumeId: result.sessionId,
         permissionMode: source.options?.permissionMode,
+        isWorker,
         emit,
         onPlanLimit,
       });
@@ -476,8 +508,9 @@ function create() {
       return session.model;
     },
     async setPermissionMode(session, mode) {
-      session.permissionMode = mode;
-      await session.query?.setPermissionMode(mode);
+      const normalized = normalizeClaudePermissionMode(mode);
+      session.permissionMode = normalized;
+      await session.query?.setPermissionMode(normalized);
     },
     async setThinkingLevel(session, level) {
       const models = await this.listModelsFor(session);

package/src/main/adapters/codebuddy.js

@@ -1,2 +1,3 @@
 const { nativeAcp } = require('./native-acp');
 module.exports = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', aliases: ['workbuddy', 'WorkBuddy'], args: ['--acp'] });
+module.exports.manifest.integrations.skills = { global: ['.codebuddy/skills'], project: ['.codebuddy/skills'] };

package/src/main/adapters/codex.js

@@ -401,8 +401,19 @@ function create() {
     },
 
     async cancel(session) {
+      for (const pending of session.pendingApprovals?.values() ?? []) {
+        pending.resolve({ action: 'decline' });
+      }
+      session.pendingApprovals?.clear();
       if (!session.state.nativeTurnId) return;
-      await session.host.request('turn/interrupt', { threadId: session.nativeSessionId, turnId: session.state.nativeTurnId });
+      await Promise.race([
+        session.host.request('turn/interrupt', { threadId: session.nativeSessionId, turnId: session.state.nativeTurnId }).catch(() => {}),
+        new Promise((r) => setTimeout(r, 2_000)),
+      ]);
+      if (session.state.turn) {
+        session.state.turn.resolve();
+        session.state.turn = null;
+      }
     },
 
     async respond(session, requestId, response) {
@@ -557,5 +568,12 @@ function create() {
   };
 }
 
-manifest.integrations = { mcp: true, skills: { global: ['.agents/skills'], project: ['.agents/skills'] } };
+// Global discovery: ~/.agents/skills is the recommended location; $CODEX_HOME/skills
+// (~/.codex/skills) is deprecated upstream but still loaded for backwards compatibility.
+// https://developers.openai.com/codex/skills
+manifest.integrations = { mcp: true, skills: {
+  global: ['.agents/skills', '.codex/skills'],
+  project: ['.agents/skills'],
+  overrides: { '.codex/skills': { env: 'CODEX_HOME', suffix: 'skills' } },
+} };
 module.exports = { manifest, create, projectNotification, queueRequest, usageView, modelView };

package/src/main/adapters/cursor.js

@@ -1,2 +1,6 @@
 const { nativeAcp } = require('./native-acp');
-module.exports = nativeAcp({ id: 'cursor-cli', name: 'Cursor', aliases: ['cursor', 'cursor-cli', 'cursorcli'], args: ['acp'] });
+module.exports = nativeAcp({ id: 'cursor-cli', name: 'Cursor', aliases: ['cursor', 'cursor-cli', 'cursorcli'], args: ['acp'] });
+module.exports.manifest.integrations.skills = {
+  global: ['.cursor/skills', '.agents/skills', '.claude/skills', '.codex/skills'],
+  project: ['.cursor/skills', '.agents/skills', '.claude/skills', '.codex/skills'],
+};

package/src/main/adapters/dsh.js

@@ -443,5 +443,12 @@ function create() {
   return web;
 }
 
-manifest.integrations = { mcp: true };
+manifest.integrations = { mcp: true, skills: {
+  global: ['.dsh/skills', '.agents/skills'],
+  project: ['.dsh/skills', '.agents/skills'],
+  overrides: {
+    '.dsh/skills': { env: 'DSH_HOME', suffix: 'skills' },
+    '.agents/skills': { env: 'DSH_AGENTS_HOME', suffix: 'skills' },
+  },
+} };
 module.exports = { manifest, create, projectWireEvent, flattenCatalog };

package/src/main/adapters/grok.js

@@ -275,4 +275,7 @@ async function doGrokCompact(session, userContext, hooks) {
   hooks?.emit?.({ kind: 'completed', finalAnswer: outcome !== 'cancelled' });
 }
 module.exports = { ...grokAdapter(), projectUsage, parseGrokCompactionUpdate, doGrokCompact };
-module.exports.manifest.integrations = { mcp: true };
+module.exports.manifest.integrations = { mcp: true, skills: {
+  global: ['.grok/skills', '.agents/skills', '.claude/skills'],
+  project: ['.grok/skills', '.claude/skills'],
+} };

package/src/main/adapters/hermes.js

@@ -22,3 +22,11 @@ module.exports = acpAdapter({
   usage: false,
   contextUsage: false,
 });
+// ~/.hermes/skills is Hermes' single source of truth (categories become subdirectories);
+// it has no documented project-scope skills directory. HERMES_HOME relocates the home.
+// https://hermes-agent.nousresearch.com/docs/user-guide/features/skills
+module.exports.manifest.integrations.skills = {
+  global: ['.hermes/skills'],
+  project: [],
+  overrides: { '.hermes/skills': { env: 'HERMES_HOME', suffix: 'skills' } },
+};

package/src/main/adapters/kiro.js

@@ -1,2 +1,3 @@
 const { nativeAcp } = require('./native-acp');
-module.exports = nativeAcp({ id: 'kiro-cli', name: 'Kiro', aliases: ['kiro', 'kiro-cli', 'kirocli'], args: ['acp', '--agent-engine', 'v3', '--auth-method', 'cli'] });
+module.exports = nativeAcp({ id: 'kiro-cli', name: 'Kiro', aliases: ['kiro', 'kiro-cli', 'kirocli'], args: ['acp', '--agent-engine', 'v3', '--auth-method', 'cli'] });
+module.exports.manifest.integrations.skills = { global: ['.kiro/skills'], project: ['.kiro/skills'] };

package/src/main/adapters/managed-mcp.js

@@ -3,8 +3,21 @@ function nativeServers(managed = [], collaboration) {
   return [...managed, ...(collaboration ? [{ name: 'harness-mix', ...collaboration }] : [])];
 }
 function acpServers(managed, collaboration) {
-  return nativeServers(managed, collaboration).map(s => ({ name: s.name, command: s.command, args: s.args,
-    env: Object.entries(s.env || {}).map(([name, value]) => ({ name, value })) }));
+  return nativeServers(managed, collaboration).map(s => {
+    if (s.url) {
+      return {
+        name: s.name,
+        url: s.url,
+        headers: Object.entries(s.http_headers || {}).map(([name, value]) => ({ name, value })),
+      };
+    }
+    return {
+      name: s.name,
+      command: s.command,
+      args: s.args || [],
+      env: Object.entries(s.env || {}).map(([name, value]) => ({ name, value })),
+    };
+  });
 }
 function namedServers(managed, collaboration) {
   return Object.fromEntries(nativeServers(managed, collaboration).map(({ name, ...server }) => [name, server]));

package/src/main/adapters/omp.js

@@ -10,3 +10,14 @@ module.exports = piFamily({
   packageHint: 'npm i -g @oh-my-pi/pi-coding-agent 或 https://omp.sh/install',
   aliases: ['omp', 'oh-my-pi'],
 });
+module.exports.manifest.integrations = {
+  mcp: false,
+  skills: {
+    global: ['.omp/agent/skills', '.agents/skills', '.pi/agent/skills'],
+    project: ['.omp/skills', '.agents/skills', '.pi/skills'],
+    overrides: {
+      '.omp/agent/skills': { env: 'OMP_CODING_AGENT_DIR', suffix: 'skills' },
+      '.pi/agent/skills': { env: 'PI_CODING_AGENT_DIR', suffix: 'skills' },
+    },
+  },
+};

package/src/main/adapters/openclaw.js

@@ -18,6 +18,12 @@ const manifest = {
   capabilities: { streaming: true, thinking: false, tools: true, approvals: true, questions: false, models: true, thinkingLevels: true, permissionModes: false, resume: true, fork: false, forkFromMessage: false, compaction: false, usage: true, contextUsage: true, attachments: true },
 };
 
+manifest.integrations = { mcp: false, skills: {
+  global: ['.openclaw/skills', '.agents/skills'],
+  project: ['skills', '.agents/skills'],
+  overrides: { '.openclaw/skills': { env: 'OPENCLAW_STATE_DIR', suffix: 'skills' } },
+} };
+
 const textOfContent = (result) => (result?.content ?? []).map((c) => (c?.type === "text" ? c.text : "")).filter(Boolean).join("\n");
 const stringifyArgs = (args) => {
   if (args == null) return undefined;

package/src/main/adapters/opencode.js

@@ -180,5 +180,9 @@ function create() {
   };
   return adapter;
 }
-manifest.integrations = { mcp: true, skills: { global: ['.config/opencode/skills'], project: ['.opencode/skills'], overrides: { '.config/opencode/skills': { env: 'XDG_CONFIG_HOME', suffix: 'opencode/skills' } } } };
+manifest.integrations = { mcp: true, skills: {
+  global: ['.config/opencode/skills', '.claude/skills', '.agents/skills'],
+  project: ['.opencode/skills', '.claude/skills', '.agents/skills'],
+  overrides: { '.config/opencode/skills': { env: 'XDG_CONFIG_HOME', suffix: 'opencode/skills' } },
+} };
 module.exports = { manifest, create, projectEvent, projectPart, describeSession };

package/src/main/adapters/pi.js

@@ -8,4 +8,8 @@ module.exports = piFamily({
   bin: 'pi',
   packageHint: 'npm i -g @earendil-works/pi-coding-agent',
 });
-module.exports.manifest.integrations = { mcp: false, skills: { global: ['.pi/agent/skills'], project: ['.pi/skills'], overrides: { '.pi/agent/skills': { env: 'PI_CODING_AGENT_DIR', suffix: 'skills' } } } };
+module.exports.manifest.integrations = { mcp: false, skills: {
+  global: ['.pi/agent/skills', '.agents/skills'],
+  project: ['.pi/skills', '.agents/skills'],
+  overrides: { '.pi/agent/skills': { env: 'PI_CODING_AGENT_DIR', suffix: 'skills' } },
+} };

package/src/main/adapters/qoder.js

@@ -5,3 +5,4 @@ module.exports = nativeAcp({
   id: 'qoder', name: 'Qoder', args: ['--acp'],
   capabilities: { questions: false, thinkingLevels: false, usage: true, contextUsage: true, attachments: true, fork: false, compaction: false },
 });
+module.exports.manifest.integrations.skills = { global: ['.qoder/skills'], project: ['.qoder/skills'] };

package/src/main/adapters/trae.js

@@ -5,3 +5,7 @@ module.exports = nativeAcp({
   id: 'trae', name: 'Trae', args: [],
   capabilities: { questions: false, thinkingLevels: false, usage: true, contextUsage: true, attachments: false, fork: false, compaction: false },
 });
+// Trae IDE uses .trae/skills; TraeCode CLI uses .traecli/skills. Both are registered so the
+// CLI-backed (ACP) session and the IDE share one managed root set.
+// https://docs.trae.cn/cli_skills
+module.exports.manifest.integrations.skills = { global: ['.trae/skills', '.traecli/skills'], project: ['.trae/skills', '.traecli/skills', '.agents/skills'] };