machine-bridge-mcp 0.12.1 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machine-bridge-mcp",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Cross-client MCP bridge for local agent context, structured browser and application automation, files, Git, processes, resources, and durable jobs over stdio or OAuth relay.",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "worker:types": "wrangler types src/worker/worker-configuration.d.ts",
     "typecheck": "npm run worker:types && tsc -p tsconfig.json --noEmit",
     "syntax": "node scripts/syntax-check.mjs",
-    "check": "npm run privacy:check && npm run privacy:test && npm run release-impact:check && npm run release-impact:test && npm run release-state:test && npm run network-retry:test && npm run relay:test && npm run secure-file:test && npm run architecture:test && npm run typecheck && npm run syntax && npm run process-lock:test && npm run service-lifecycle:test && npm run catalog:test && npm run agent-context:test && npm run browser-bridge:test && npm run app-automation:test && npm run self-test && npm run atomic-fs:test && npm run package:test && npm run ssh-key:test && npm run full-access:test && npm run managed-jobs:test && npm run stdio:integration-test && npm run worker:integration-test",
+    "check": "npm run privacy:check && npm run privacy:test && npm run release-impact:check && npm run release-impact:test && npm run release-state:test && npm run release-ci:test && npm run network-retry:test && npm run relay:test && npm run secure-file:test && npm run architecture:test && npm run typecheck && npm run syntax && npm run process-lock:test && npm run service-lifecycle:test && npm run catalog:test && npm run agent-context:test && npm run browser-bridge:test && npm run app-automation:test && npm run self-test && npm run atomic-fs:test && npm run package:test && npm run ssh-key:test && npm run full-access:test && npm run managed-jobs:test && npm run stdio:integration-test && npm run worker:integration-test",
     "worker:dry-run": "wrangler deploy --dry-run",
     "worker:integration-test": "node tests/worker-integration-test.mjs",
     "release:check": "node scripts/github-release.mjs --check",
@@ -55,6 +55,7 @@
     "full-access:test": "node tests/full-access-test.mjs",
     "atomic-fs:test": "node tests/atomic-fs-test.mjs",
     "privacy:check": "node scripts/privacy-check.mjs",
+    "privacy:history": "node scripts/privacy-check.mjs --history",
     "package:test": "node tests/package-test.mjs",
     "release-impact:check": "node scripts/release-impact-check.mjs",
     "release-impact:test": "node tests/release-impact-test.mjs",
@@ -65,6 +66,7 @@
     "secure-file:test": "node tests/secure-file-test.mjs",
     "architecture:test": "node tests/architecture-test.mjs",
     "release-state:test": "node tests/release-state-test.mjs",
+    "release-ci:test": "node tests/release-ci-test.mjs",
     "agent-context:test": "node tests/agent-context-test.mjs",
     "browser-bridge:test": "node tests/browser-bridge-test.mjs",
     "app-automation:test": "node tests/app-automation-test.mjs",
@@ -73,6 +75,8 @@
     "app-automation:live-test": "node tests/app-automation-test.mjs --live-macos"
   },
   "dependencies": {
+    "https-proxy-agent": "9.1.0",
+    "proxy-from-env": "2.1.0",
     "wrangler": "4.110.0",
     "ws": "8.21.0"
   },

package/scripts/github-release.mjs

@@ -10,6 +10,7 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { runNetworkCommand } from "./network-retry.mjs";
+import { requireSuccessfulCiRun } from "./release-ci.mjs";
 import { tagSyncError } from "./release-state.mjs";
 import { fileURLToPath } from "node:url";
 
@@ -124,6 +125,31 @@ function remoteTagCommit(tag) {
   return (peeled ?? direct)?.[0] ?? null;
 }
 
+function assertSuccessfulCi(head) {
+  const text = outputNetwork("gh", [
+    "run",
+    "list",
+    "--workflow",
+    ".github/workflows/ci.yml",
+    "--commit",
+    head,
+    "--event",
+    "push",
+    "--limit",
+    "20",
+    "--json",
+    "databaseId,status,conclusion,headSha,event,createdAt,url",
+  ]);
+  let runs;
+  try { runs = JSON.parse(text); }
+  catch { fail("GitHub Actions did not return valid JSON"); }
+  let run;
+  try { run = requireSuccessfulCiRun(runs, head); }
+  catch (error) { fail(String(error?.message || error)); }
+  console.log(`GitHub Actions CI succeeded for ${head} (run ${run.databaseId}).`);
+  return run;
+}
+
 function releaseInfo(tag) {
   const result = runNetwork(
     "gh",
@@ -148,6 +174,7 @@ function assertCoreSync({ requireReleaseAsset }) {
   if (head !== originMain) {
     fail(`HEAD ${head} does not match origin/main ${originMain}`);
   }
+  assertSuccessfulCi(head);
 
   const localCommit = localTagCommit(tag);
   const localTagError = tagSyncError({ scope: "local", tag, head, commit: localCommit });
@@ -275,6 +302,7 @@ function publishCurrent() {
     }
     runNetwork("git", ["push", "origin", "HEAD:main"]);
   }
+  assertSuccessfulCi(head);
 
   const existingLocal = localTagCommit(tag);
   if (existingLocal && existingLocal !== head) {

package/scripts/privacy-check.mjs

@@ -5,6 +5,11 @@ import { fileURLToPath } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const selfPath = "scripts/privacy-check.mjs";
+const requestedOptions = new Set(process.argv.slice(2));
+for (const option of requestedOptions) {
+  if (option !== "--history") throw new Error(`unknown privacy-check option: ${option}`);
+}
+const scanHistory = requestedOptions.has("--history");
 const candidates = collectCandidateFiles(root);
 const denylist = loadDenylist(path.join(root, ".privacy-denylist"));
 const findings = [];
@@ -47,6 +52,8 @@ for (const relativePath of candidates) {
   scanDenylist(relativePath, text, denylist, findings);
 }
 
+const historySummaryCounts = scanHistory ? scanReachableHistory(root, denylist, findings) : { blobs: 0, commits: 0 };
+
 if (findings.length) {
   for (const finding of findings.slice(0, 100)) {
     process.stderr.write(`${redactReportPath(finding.path, denylist)}:${finding.line}: ${finding.rule}\n`);
@@ -56,7 +63,8 @@ if (findings.length) {
   process.exit(1);
 }
 
-process.stderr.write(`privacy check ok (${candidates.length} tracked/unignored files; ${denylist.length} local denylist entries)\n`);
+const historySummary = scanHistory ? `; ${historySummaryCounts.blobs} reachable history blobs; ${historySummaryCounts.commits} commit messages` : "";
+process.stderr.write(`privacy check ok (${candidates.length} tracked/unignored files; ${denylist.length} local denylist entries${historySummary})\n`);
 
 function collectCandidateFiles(directory) {
   try {
@@ -87,6 +95,136 @@ function collectCandidateFiles(directory) {
   }
 }
 
+function scanReachableHistory(directory, entries, out) {
+  let listing;
+  try {
+    listing = execFileSync("git", ["-C", directory, "rev-list", "--objects", "--all", "-z"], {
+      encoding: "buffer",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch {
+    throw new Error("privacy history scan could not enumerate reachable Git objects");
+  }
+  let records;
+  try { records = new TextDecoder("utf-8", { fatal: true }).decode(listing).split("\0").filter(Boolean); }
+  catch { throw new Error("privacy history scan encountered a non-UTF-8 Git object path"); }
+  const objectPaths = new Map();
+  let objectHash = "";
+  for (const record of records) {
+    if (/^[0-9a-f]{40,64}$/.test(record)) {
+      objectHash = record;
+      continue;
+    }
+    if (!record.startsWith("path=") || !objectHash) {
+      objectHash = "";
+      continue;
+    }
+    const relativePath = record.slice(5);
+    if (relativePath && !relativePath.includes("\0")) {
+      if (!objectPaths.has(objectHash)) objectPaths.set(objectHash, new Set());
+      objectPaths.get(objectHash).add(relativePath);
+    }
+    objectHash = "";
+  }
+  const hashes = [...objectPaths.keys()];
+  let metadata;
+  try {
+    metadata = execFileSync("git", ["-C", directory, "cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], {
+      input: `${hashes.join("\n")}\n`,
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim().split(/\r?\n/);
+  } catch {
+    throw new Error("privacy history scan could not classify reachable Git objects");
+  }
+  const blobSizes = new Map();
+  for (const line of metadata) {
+    const match = /^([0-9a-f]{40,64}) blob ([0-9]+)$/.exec(line);
+    if (match) blobSizes.set(match[1], Number(match[2]));
+  }
+  let scanned = 0;
+  for (const [hash, paths] of objectPaths) {
+    if (!blobSizes.has(hash)) continue;
+    const relativePaths = [...paths].sort();
+    const reportPath = relativePaths[0] || "unknown";
+    const contentPath = relativePaths.find((relativePath) => relativePath !== selfPath) || reportPath;
+    for (const relativePath of relativePaths) {
+      if (relativePath === ".privacy-denylist") continue;
+      const historicalPath = `history/${hash.slice(0, 12)}/${relativePath}`;
+      scanDenylistPath(historicalPath, entries, out);
+      scanSensitivePath(historicalPath, out);
+    }
+    if (blobSizes.get(hash) > 5 * 1024 * 1024) {
+      out.push({ path: `history/${hash.slice(0, 12)}/${reportPath}`, line: 1, rule: "historical file exceeds privacy scanner size limit and requires manual review" });
+      continue;
+    }
+    let buffer;
+    try {
+      buffer = execFileSync("git", ["-C", directory, "cat-file", "blob", hash], {
+        encoding: "buffer",
+        maxBuffer: 6 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch {
+      out.push({ path: `history/${hash.slice(0, 12)}/${reportPath}`, line: 1, rule: "historical file content could not be read" });
+      continue;
+    }
+    scanned += 1;
+    const historicalPath = `history/${hash.slice(0, 12)}/${contentPath}`;
+    if (buffer.includes(0)) {
+      out.push({ path: historicalPath, line: 1, rule: "binary file in reachable Git history requires manual review" });
+      continue;
+    }
+    let historicalText;
+    try { historicalText = new TextDecoder("utf-8", { fatal: true }).decode(buffer); }
+    catch {
+      out.push({ path: historicalPath, line: 1, rule: "non-UTF-8 file in reachable Git history requires manual review" });
+      continue;
+    }
+    if (contentPath !== selfPath) scanBuiltIn(historicalPath, historicalText, out);
+    if (relativePaths.some((relativePath) => path.basename(relativePath).toLowerCase() === ".npmrc")) scanNpmrc(historicalPath, historicalText, out);
+    scanDenylist(historicalPath, historicalText, entries, out);
+  }
+  const commitCount = scanReachableCommitMessages(directory, entries, out);
+  return { blobs: scanned, commits: commitCount };
+}
+
+function scanReachableCommitMessages(directory, entries, out) {
+  let output;
+  try {
+    output = execFileSync("git", ["-C", directory, "log", "--all", "--format=%H%x00%B%x00"], {
+      encoding: "buffer",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch {
+    throw new Error("privacy history scan could not read reachable commit messages");
+  }
+  let records;
+  try { records = new TextDecoder("utf-8", { fatal: true }).decode(output).split("\0"); }
+  catch { throw new Error("privacy history scan encountered a non-UTF-8 commit message"); }
+  let count = 0;
+  for (let index = 0; index + 1 < records.length; index += 2) {
+    const hash = records[index].trim();
+    const message = records[index + 1];
+    if (!/^[0-9a-f]{40,64}$/.test(hash)) continue;
+    const reportPath = `history/commit/${hash.slice(0, 12)}/message`;
+    const scannedMessage = removeKnownPublicAutomationTrailers(message);
+    scanBuiltIn(reportPath, scannedMessage, out);
+    scanDenylist(reportPath, scannedMessage, entries, out);
+    count += 1;
+  }
+  return count;
+}
+
+function removeKnownPublicAutomationTrailers(message) {
+  return String(message).split(/\r?\n/).filter((line) => {
+    return !/^(?:Signed-off-by|Co-authored-by):\s+dependabot\[bot\]\s+<[^>\s]+@github\.com>\s*$/i.test(line);
+  }).join("\n");
+}
+
 function redactReportPath(relativePath, entries) {
   let shown = String(relativePath);
   for (const entry of entries) {
@@ -112,7 +250,6 @@ function scanBuiltIn(relativePath, text, out) {
     ["live payment API key", /\b(?:sk|rk|pk)_live_[A-Za-z0-9]{16,}\b/g],
     ["API secret token", /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g],
     ["JWT-like bearer token", /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g],
-    ["URL with embedded credentials", /https?:\/\/[^\s/@:"'<>]+:[^\s/@"'<>]+@[^\s/"'<>]+/gi],
     ["absolute macOS/Linux home path", /(?:^|[\s"'=(:,])\/(?:Users|home)\/([^/\s"'<>]+)\//gm],
     ["absolute Windows home path", /(?:^|[\s"'=(:,])\b[A-Za-z]:\\Users\\([^\\\s"'<>]+)\\/gm],
   ];
@@ -122,6 +259,11 @@ function scanBuiltIn(relativePath, text, out) {
       out.push({ path: relativePath, line: lineNumber(text, match.index || 0), rule });
     }
   }
+  const credentialUrl = /https?:\/\/[^\s/@:"'<>]+:[^\s/@"'<>]+@([^\s/"'<>]+)/gi;
+  for (const match of text.matchAll(credentialUrl)) {
+    if (isReservedExampleHost(stripHostPort(match[1]))) continue;
+    out.push({ path: relativePath, line: lineNumber(text, match.index || 0), rule: "URL with embedded credentials" });
+  }
   const emailLike = /\b[A-Z0-9._%+-]+@([A-Z0-9.-]+\.[A-Z]{2,})\b/gi;
   for (const match of text.matchAll(emailLike)) {
     if (isReservedExampleHost(match[1]) || String(match[1]).toLowerCase().endsWith(".noreply.github.com")) continue;
@@ -215,6 +357,12 @@ function hasNearbySshContext(text, offset) {
   return /\b(?:ssh|scp|sftp)\b/i.test(text.slice(start, end));
 }
 
+function stripHostPort(host) {
+  const value = String(host || "");
+  if (value.startsWith("[")) return value.slice(1, value.indexOf("]") > 0 ? value.indexOf("]") : undefined);
+  return value.replace(/:[0-9]+$/, "");
+}
+
 function isReservedExampleHost(host) {
   const value = String(host || "").toLowerCase().replace(/\.$/, "");
   return value === "localhost"

package/scripts/release-ci.mjs

@@ -0,0 +1,18 @@
+export function requireSuccessfulCiRun(runs, head) {
+  if (!Array.isArray(runs)) throw new Error("GitHub Actions response is not an array");
+  if (!/^[0-9a-f]{40,64}$/i.test(String(head || ""))) throw new Error("release commit SHA is invalid");
+  const matching = runs
+    .filter((run) => run && run.headSha === head && run.event === "push")
+    .sort((left, right) => String(right.createdAt || "").localeCompare(String(left.createdAt || "")));
+  const run = matching[0];
+  if (!run) {
+    throw new Error(`no push-triggered CI run exists for release commit ${head}; wait for GitHub Actions to register the run and retry`);
+  }
+  if (run.status !== "completed") {
+    throw new Error(`CI run ${run.databaseId || "unknown"} for release commit ${head} is ${run.status || "unknown"}; wait for completion and retry`);
+  }
+  if (run.conclusion !== "success") {
+    throw new Error(`CI run ${run.databaseId || "unknown"} for release commit ${head} concluded ${run.conclusion || "unknown"}; fix or rerun CI before release`);
+  }
+  return run;
+}

package/src/local/agent-context.mjs

@@ -3,6 +3,7 @@ import { constants as fsConstants } from "node:fs";
 import { lstat, open, opendir, realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createBuiltinInstruction, discoverAutomaticProjectInstruction } from "./default-instructions.mjs";
+import { automaticPackageCommands, readProjectPackageMetadata } from "./project-package.mjs";
 
 const CONFIG_RELATIVE_PATH = join(".machine-bridge", "agent.json");
 const GLOBAL_CONFIG_RELATIVE_PATH = join(".config", "machine-bridge-mcp", "agent.json");
@@ -24,6 +25,35 @@ const MAX_COMMAND_ARGV = 128;
 const MAX_COMMAND_ARGUMENT_BYTES = 256 * 1024;
 const COMMAND_NAME_PATTERN = /^[a-z][a-z0-9._-]{0,63}$/;
 const TOKEN_STOP_WORDS = new Set(["the", "and", "for", "with", "from", "this", "that", "use", "using", "into", "of", "to", "a", "an", "in", "on", "is", "are", "or", "及", "和", "的", "了", "在", "用", "使用", "进行", "根据"]);
+const ENGLISH_TOKEN_CANONICAL = new Map([
+  ["created", "create"], ["creating", "create"], ["creation", "create"], ["creator", "create"],
+  ["improved", "improve"], ["improving", "improve"], ["improvement", "improve"],
+  ["installed", "install"], ["installing", "install"], ["installation", "install"], ["installer", "install"],
+  ["searched", "search"], ["searching", "search"], ["finder", "find"],
+  ["documentation", "docs"], ["document", "docs"], ["documents", "docs"],
+  ["validated", "verify"], ["validate", "verify"], ["validation", "verify"], ["verification", "verify"],
+  ["factcheck", "verify"], ["fact-check", "verify"], ["testing", "test"], ["tests", "test"],
+  ["building", "build"], ["built", "build"], ["deployment", "deploy"], ["deployed", "deploy"],
+]);
+const HAN_TOKEN_ALIASES = Object.freeze([
+  [/创建|新建|编写/u, ["create", "creator"]],
+  [/改进|优化|更新|维护/u, ["improve", "update"]],
+  [/技能/u, ["skill"]],
+  [/安装/u, ["install", "installer"]],
+  [/部署/u, ["deploy", "deployment"]],
+  [/查找|搜索|检索/u, ["search", "find"]],
+  [/最新|当前/u, ["latest", "current"]],
+  [/官方/u, ["official"]],
+  [/文档|资料/u, ["docs", "documentation"]],
+  [/事实核查|核查|验证|校验/u, ["verify", "factcheck"]],
+  [/测试/u, ["test"]],
+  [/前端/u, ["frontend"]],
+  [/设计/u, ["design"]],
+  [/邮件|邮箱/u, ["email"]],
+  [/浏览器|网页|网站/u, ["browser", "web"]],
+  [/性能/u, ["performance"]],
+  [/安全|漏洞/u, ["security", "audit"]],
+]);
 const CONFIG_KEYS = new Set(["version", "builtin_instructions", "automatic_project_context", "model_instructions_file", "instruction_files", "instruction_max_bytes", "skill_roots", "commands"]);
 const COMMAND_KEYS = new Set(["description", "argv", "cwd", "timeout_seconds", "allow_extra_args"]);
 
@@ -117,7 +147,7 @@ export class AgentContextManager {
       .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name))
       .slice(0, maxSkills);
     const commandMatches = [...state.commands.values()]
-      .map((command) => ({ command, score: relevanceScore(task, `${command.name} ${command.description} ${command.argv.join(" ")}`, command.name) }))
+      .map((command) => ({ command, score: relevanceScore(task, commandMatchText(command), command.name) }))
       .filter((item) => item.score > 0)
       .sort((a, b) => b.score - a.score || a.command.name.localeCompare(b.command.name))
       .slice(0, 20);
@@ -127,7 +157,11 @@ export class AgentContextManager {
       const content = await readRegularUtf8(selected.entrypoint, MAX_SKILL_ENTRY_BYTES, "skill entrypoint");
       selectedSkill = { ...publicSkill(selected, this.displayPath), instructions: content.text };
     }
-    const recommendedTools = recommendTools(task, commandMatches.length > 0, skillMatches.length > 0);
+    const recommendedTools = recommendTools(task, {
+      commandsAvailable: state.commands.size > 0,
+      commandRelevant: (commandMatches[0]?.score || 0) >= 3,
+      skillRelevant: Boolean(selected),
+    });
     const refresh = capabilityFingerprint(state, discovered.skills);
     return {
       task,
@@ -239,7 +273,7 @@ export class AgentContextManager {
       scopeRoot,
       instructionFiles: [...DEFAULT_INSTRUCTION_FILES],
       instructionMaxBytes: DEFAULT_INSTRUCTION_MAX_BYTES,
-      skillRoots: defaultSkillRoots(directories, this.home, this.policy.unrestrictedPaths === true),
+      skillRoots: defaultSkillRoots(directories, this.home, this.codexHome, this.policy.unrestrictedPaths === true),
       commands: new Map(),
       builtinInstructionsEnabled: true,
       automaticProjectContextEnabled: true,
@@ -253,6 +287,9 @@ export class AgentContextManager {
       instructionsTruncated: false,
     };
 
+    const packageMetadata = await readProjectPackageMetadata(scopeRoot, () => this.throwIfCancelled(context));
+    state.commands = automaticPackageCommands(packageMetadata, scopeRoot);
+
     if (this.home) {
       const globalConfig = join(this.home, GLOBAL_CONFIG_RELATIVE_PATH);
       const config = await readOptionalConfig(globalConfig, this.home, false);
@@ -488,9 +525,14 @@ function directoriesBetween(root, leaf) {
   return result.reverse();
 }
 
-function defaultSkillRoots(directories, home, unrestricted) {
-  const roots = [...directories].reverse().map((directory) => resolve(directory, ".agents", "skills"));
+function defaultSkillRoots(directories, home, codexHome, unrestricted) {
+  const roots = [];
+  for (const directory of [...directories].reverse()) {
+    roots.push(resolve(directory, ".agents", "skills"));
+    roots.push(resolve(directory, ".codex", "skills"));
+  }
   if (unrestricted && home) roots.push(resolve(home, ".agents", "skills"));
+  if (unrestricted && codexHome) roots.push(resolve(codexHome, "skills"));
   if (unrestricted && process.platform !== "win32") roots.push(resolve("/etc/codex/skills"));
   return [...new Set(roots)];
 }
@@ -718,13 +760,19 @@ function capabilityFingerprint(state, skills) {
   }));
 }
 
+function commandMatchText(command) {
+  return `${command.name} ${command.description} ${command.argv.join(" ")} ${command.searchTerms || ""}`;
+}
+
 function relevanceScore(task, candidate, identity = "") {
   const taskTokens = tokenize(task);
   const candidateTokens = tokenize(candidate);
   if (!taskTokens.size || !candidateTokens.size) return 0;
+  const identityTokens = tokenize(identity);
   let score = 0;
   for (const token of taskTokens) {
     if (candidateTokens.has(token)) score += token.length >= 6 ? 2 : 1;
+    if (identityTokens.has(token)) score += token.length >= 6 ? 4 : 3;
   }
   const taskComparable = comparableText(task);
   const candidateComparable = comparableText(candidate);
@@ -747,33 +795,40 @@ function tokenize(value) {
   const tokens = new Set();
   for (const raw of text.match(/[a-z0-9_][a-z0-9_.-]{1,}/g) || []) {
     const token = raw.replace(/^[.-]+|[.-]+$/g, "");
-    if (token.length >= 2 && !TOKEN_STOP_WORDS.has(token)) tokens.add(token);
-    for (const part of token.split(/[._-]+/)) {
-      if (part.length >= 2 && !TOKEN_STOP_WORDS.has(part)) tokens.add(part);
-    }
+    addToken(tokens, token);
+    for (const part of token.split(/[._-]+/)) addToken(tokens, part);
   }
   for (const sequence of text.match(/[\p{Script=Han}]{1,}/gu) || []) {
-    if (!TOKEN_STOP_WORDS.has(sequence)) tokens.add(sequence);
+    addToken(tokens, sequence);
     const minimumSize = sequence.length === 1 ? 1 : 2;
     for (let size = minimumSize; size <= Math.min(3, sequence.length); size += 1) {
-      for (let index = 0; index + size <= sequence.length; index += 1) {
-        const token = sequence.slice(index, index + size);
-        if (!TOKEN_STOP_WORDS.has(token)) tokens.add(token);
-      }
+      for (let index = 0; index + size <= sequence.length; index += 1) addToken(tokens, sequence.slice(index, index + size));
     }
   }
+  for (const [pattern, aliases] of HAN_TOKEN_ALIASES) {
+    if (!pattern.test(text)) continue;
+    for (const alias of aliases) addToken(tokens, alias);
+  }
   return tokens;
 }
 
-function recommendTools(task, hasCommands, hasSkills) {
+function addToken(tokens, raw) {
+  const token = String(raw || "").replace(/^[.-]+|[.-]+$/g, "");
+  if (token.length < 2 || TOKEN_STOP_WORDS.has(token)) return;
+  tokens.add(token);
+  const canonical = ENGLISH_TOKEN_CANONICAL.get(token);
+  if (canonical) tokens.add(canonical);
+}
+
+function recommendTools(task, { commandsAvailable, commandRelevant, skillRelevant }) {
   const lower = task.toLowerCase();
   const tools = ["agent_context"];
-  if (hasSkills) tools.push("load_local_skill");
-  if (hasCommands) tools.push("run_local_command");
+  if (skillRelevant) tools.push("load_local_skill");
+  if (commandRelevant) tools.push("run_local_command");
   if (/browser|chrome|edge|brave|网页|浏览器|表单|网站/.test(lower)) tools.push("browser_status", "browser_list_tabs", "browser_inspect_page", "browser_action", "browser_fill_form");
   if (/app|application|gui|window|应用|软件|窗口|界面/.test(lower)) tools.push("list_local_applications", "inspect_local_application", "operate_local_application");
   if (/git|commit|branch|diff|仓库|提交|分支/.test(lower)) tools.push("git_status", "git_diff");
-  if (/test|build|lint|command|terminal|测试|构建|命令|终端/.test(lower)) tools.push(hasCommands ? "run_local_command" : "run_process");
+  if (/test|build|lint|command|terminal|测试|构建|命令|终端/.test(lower)) tools.push(commandsAvailable ? "run_local_command" : "run_process");
   if (/file|code|source|edit|write|文件|代码|源码|修改|写入/.test(lower)) tools.push("read_file", "search_text", "edit_file", "apply_patch");
   return [...new Set(tools)];
 }
@@ -828,6 +883,8 @@ function publicCommands(commands, displayPath) {
       timeout_seconds: command.timeoutSeconds,
       allow_extra_args: command.allowExtraArgs,
       source: displayPath(command.source),
+      source_type: command.sourceType || "agent-config",
+      ...(command.script ? { package_script: command.script } : {}),
     }));
 }
 

package/src/local/app-automation.mjs

@@ -9,9 +9,10 @@ const MAX_UI_ELEMENTS = 500;
 const MAX_UI_DEPTH = 12;
 const MAX_TEXT_CHARS = 4000;
 const APP_NAME_PATTERN = /^[^\0\r\n]{1,300}$/;
+const DEFAULT_APPLICATION_CACHE_MS = 30_000;
 
 export class AppAutomationManager {
-  constructor({ policy, displayPath, runProcess, readResourceText, throwIfCancelled = () => {}, platform = process.platform, home = homedir(), applicationRoots = null }) {
+  constructor({ policy, displayPath, runProcess, readResourceText, throwIfCancelled = () => {}, platform = process.platform, home = homedir(), applicationRoots = null, applicationCacheMs = DEFAULT_APPLICATION_CACHE_MS, now = () => Date.now() }) {
     this.policy = policy || {};
     this.displayPath = displayPath;
     this.runProcess = runProcess;
@@ -20,6 +21,9 @@ export class AppAutomationManager {
     this.platform = platform;
     this.home = home;
     this.applicationRoots = applicationRoots;
+    this.applicationCacheMs = Math.max(0, Number(applicationCacheMs) || 0);
+    this.now = now;
+    this.applicationCache = null;
   }
 
   capabilities() {
@@ -57,6 +61,16 @@ export class AppAutomationManager {
   }
 
   async discoverApplications(context = {}) {
+    const now = this.now();
+    if (this.applicationCache && now - this.applicationCache.createdAt < this.applicationCacheMs) {
+      return this.applicationCache.result;
+    }
+    const result = await this.scanApplications(context);
+    this.applicationCache = { createdAt: this.now(), result };
+    return result;
+  }
+
+  async scanApplications(context = {}) {
     if (this.platform === "darwin") {
       return listMacApplications(this.applicationRoots || ["/Applications", "/System/Applications", join(this.home, "Applications")], context, this.throwIfCancelled);
     }

package/src/local/atomic-fs.mjs

@@ -5,8 +5,11 @@ const WAIT_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 
 export function replaceFileSync(source, target, options = {}) {
   const rename = typeof options.rename === "function" ? options.rename : renameSync;
-  const attempts = clampInteger(options.attempts, 8, 1, 32);
+  const sleep = typeof options.sleep === "function" ? options.sleep : sleepSync;
+  const random = typeof options.random === "function" ? options.random : Math.random;
+  const attempts = clampInteger(options.attempts, 16, 1, 64);
   const baseDelayMs = clampInteger(options.baseDelayMs, 15, 0, 1000);
+  const maxDelayMs = Math.max(baseDelayMs, clampInteger(options.maxDelayMs, 250, 0, 2000));
   let lastError;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
@@ -15,7 +18,7 @@ export function replaceFileSync(source, target, options = {}) {
     } catch (error) {
       lastError = error;
       if (!isTransientReplaceError(error) || attempt === attempts) throw error;
-      sleepSync(Math.min(baseDelayMs * attempt, 250));
+      sleep(retryDelayMs(attempt, baseDelayMs, maxDelayMs, random));
     }
   }
   throw lastError || new Error("atomic file replacement failed");
@@ -25,6 +28,15 @@ export function isTransientReplaceError(error) {
   return TRANSIENT_REPLACE_ERRORS.has(String(error?.code || ""));
 }
 
+function retryDelayMs(attempt, baseDelayMs, maxDelayMs, random) {
+  if (baseDelayMs <= 0 || maxDelayMs <= 0) return 0;
+  const exponential = Math.min(baseDelayMs * (2 ** Math.min(attempt - 1, 5)), maxDelayMs);
+  const randomValue = Number(random());
+  const normalizedRandom = Number.isFinite(randomValue) ? Math.min(Math.max(randomValue, 0), 1) : 0;
+  const jitter = Math.floor(exponential * 0.5 * normalizedRandom);
+  return Math.min(exponential + jitter, maxDelayMs);
+}
+
 function sleepSync(milliseconds) {
   if (milliseconds <= 0) return;
   Atomics.wait(WAIT_BUFFER, 0, 0, milliseconds);

package/src/local/browser-bridge.mjs

@@ -355,7 +355,9 @@ export class BrowserBridgeManager {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
-        if (!ok) try { ws.close(); } catch {}
+        if (!ok) {
+          try { ws.terminate(); } catch { try { ws.close(); } catch {} }
+        }
         resolvePromise(ok);
       };
       ws.on("message", (data) => {

package/src/local/capability-observer.mjs

@@ -0,0 +1,56 @@
+import { createHmac, randomBytes } from "node:crypto";
+
+export class CapabilityObserver {
+  constructor(now = () => Date.now(), taskFingerprintKey = randomBytes(32)) {
+    this.now = now;
+    this.taskFingerprintKey = Buffer.from(taskFingerprintKey);
+    this.bootstrapCount = 0;
+    this.resolutionCount = 0;
+    this.lastBootstrap = null;
+    this.lastResolution = null;
+  }
+
+  recordBootstrap(result) {
+    this.bootstrapCount += 1;
+    this.lastBootstrap = {
+      observed_at: timestamp(this.now()),
+      target: result?.target || ".",
+      instruction_bytes: Buffer.byteLength(String(result?.instructions || "")),
+      builtin_loaded: Boolean(result?.builtin_instructions),
+      automatic_project_context_loaded: Boolean(result?.automatic_project_context),
+      global_model_instructions_loaded: Boolean(result?.model_instructions_file),
+      refresh_fingerprint: String(result?.capability_refresh?.instruction_and_command_fingerprint || ""),
+    };
+  }
+
+  recordResolution(task, result) {
+    this.resolutionCount += 1;
+    this.lastResolution = {
+      observed_at: timestamp(this.now()),
+      task_fingerprint: createHmac("sha256", this.taskFingerprintKey).update(String(task || "")).digest("hex"),
+      target: result?.target || ".",
+      selected_skill: result?.selected_skill?.name || null,
+      matched_skills: Array.isArray(result?.skill_matches) ? result.skill_matches.length : 0,
+      matched_commands: Array.isArray(result?.command_matches) ? result.command_matches.length : 0,
+      matched_applications: Array.isArray(result?.application_matches) ? result.application_matches.length : 0,
+      recommended_tools: Array.isArray(result?.recommended_tools) ? [...result.recommended_tools] : [],
+      refresh_fingerprint: String(result?.refresh?.fingerprint || ""),
+    };
+  }
+
+  snapshot() {
+    return {
+      bootstrap_observed: this.bootstrapCount > 0,
+      bootstrap_count: this.bootstrapCount,
+      task_resolution_observed: this.resolutionCount > 0,
+      task_resolution_count: this.resolutionCount,
+      last_bootstrap: this.lastBootstrap ? structuredClone(this.lastBootstrap) : null,
+      last_task_resolution: this.lastResolution ? structuredClone(this.lastResolution) : null,
+      enforcement_boundary: "The server can discover, rank, load, and report capabilities; the MCP host decides whether to call the resolver or recommended tools.",
+    };
+  }
+}
+
+function timestamp(milliseconds) {
+  return new Date(Number(milliseconds)).toISOString();
+}