@x1aoye/conflux-oc 0.1.0

package/dist/index.js

@@ -0,0 +1,1394 @@
+// src/config.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { parse } from "jsonc-parser";
+var BUILTIN_DEFAULTS = {
+  layers: [
+    { name: "platform", priority: 0, storage: "transform-only", inject: "always" },
+    { name: "machine", priority: 1, storage: { type: "local", path: "machines/{id}.json" }, inject: "summary-only" },
+    { name: "user", priority: 2, storage: { type: "local", path: "users/{name}.json" }, inject: "always" },
+    { name: "project", priority: 3, storage: { type: "local", path: ".opencode/skills/" }, inject: "on-demand" }
+  ],
+  behavior_rules: [
+    {
+      id: "precheck-runtime",
+      trigger: "before:build_run_test",
+      rule: "Before build/run/test: read Project Runtime Requirements first, then check Machine toolchain paths, auto-prepend version switching commands",
+      enabled: true
+    },
+    {
+      id: "knowledge-routing-cross-branch",
+      trigger: "on:note_discovery",
+      rule: "Core architecture/interface contracts/design decisions \u2192 _shared/; current branch progress/implementation details \u2192 SKILL.md",
+      condition: "is_git_project",
+      enabled: true
+    },
+    {
+      id: "knowledge-source-routing",
+      trigger: "on:note_discovery",
+      rule: "Only tool output results go to Machine/Platform layers; user assumptions never enter any layer",
+      enabled: true
+    }
+  ]
+};
+var CONFIG_FILE_NAME = "conflux-oc.jsonc";
+function configSearchPaths(projectRoot) {
+  const paths = [];
+  paths.push(join(projectRoot, ".opencode", CONFIG_FILE_NAME));
+  const customDir = process.env.OPENCODE_CONFIG_DIR;
+  if (customDir) {
+    paths.push(join(customDir, CONFIG_FILE_NAME));
+  }
+  paths.push(join(homedir(), ".config", "opencode", CONFIG_FILE_NAME));
+  return paths;
+}
+function resolvePluginDataDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR;
+  if (configDir) {
+    return join(configDir, "plugins", "conflux-oc");
+  }
+  return join(homedir(), ".config", "opencode", "plugins", "conflux-oc");
+}
+function loadPluginConfig(projectRoot) {
+  const base = projectRoot || process.cwd();
+  for (const p of configSearchPaths(base)) {
+    try {
+      const raw = readFileSync(p, "utf-8");
+      const parsed = parse(raw);
+      if (parsed?.layers && parsed?.behavior_rules) {
+        return parsed;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { ...BUILTIN_DEFAULTS, layers: BUILTIN_DEFAULTS.layers.map((l) => ({ ...l })) };
+}
+function resolveLayerStorage(layer, pluginDataDir, projectRoot) {
+  if (typeof layer.storage === "string") {
+    return { type: "none", basePath: "", template: "" };
+  }
+  if (layer.storage.type === "local") {
+    const isProjectScope = layer.storage.path.startsWith(".opencode");
+    const basePath = isProjectScope ? projectRoot : pluginDataDir;
+    return {
+      type: "local",
+      basePath,
+      template: layer.storage.path
+    };
+  }
+  return { type: "none", basePath: "", template: "" };
+}
+function resolvePluginConfig(projectRoot) {
+  const base = projectRoot || process.cwd();
+  const config = loadPluginConfig(base);
+  const pluginDataDir = resolvePluginDataDir();
+  const resolvedStorages = {};
+  for (const layer of config.layers) {
+    resolvedStorages[layer.name] = resolveLayerStorage(layer, pluginDataDir, base);
+  }
+  return {
+    layers: config.layers,
+    behavior_rules: config.behavior_rules,
+    pluginDataDir,
+    projectRoot: base,
+    resolvedStorages
+  };
+}
+
+// src/layers/registry.ts
+var LayerRegistry = class {
+  layers;
+  constructor(layers) {
+    this.layers = [...layers].sort((a, b) => a.priority - b.priority);
+  }
+  getByPriority() {
+    return this.layers;
+  }
+  getByName(name) {
+    return this.layers.find((l) => l.name === name);
+  }
+  add(layer) {
+    this.layers.push(layer);
+    this.layers.sort((a, b) => a.priority - b.priority);
+  }
+};
+
+// src/detection/platform.ts
+import { platform, release, arch, type } from "os";
+import { env } from "process";
+function detectOS() {
+  const name = type();
+  const releaseStr = release();
+  switch (platform()) {
+    case "darwin":
+      return `macOS (${osxReleaseName(releaseStr)})`;
+    case "linux":
+      return `Linux${releaseStr ? ` (${releaseStr})` : ""}`;
+    case "win32":
+      return `Windows${releaseStr ? ` (${releaseStr})` : ""}`;
+    default:
+      return `${name} ${releaseStr}`;
+  }
+}
+function osxReleaseName(release2) {
+  const major = Number.parseInt(release2.split(".")[0]);
+  const names = {
+    20: "Big Sur",
+    21: "Monterey",
+    22: "Ventura",
+    23: "Sonoma",
+    24: "Sequoia",
+    25: "Sequoia"
+  };
+  return names[major] ? `${names[major]} ${release2}` : release2;
+}
+function detectShell() {
+  const shellPath = env.SHELL || env.ComSpec || "unknown";
+  const name = shellPath.split("/").pop()?.split("\\").pop() || shellPath;
+  return `${name} (${shellPath})`;
+}
+function detectArch() {
+  const archMap = {
+    x64: "x86_64",
+    arm64: "aarch64",
+    ia32: "x86"
+  };
+  return archMap[arch()] || arch();
+}
+function detectPlatform() {
+  return {
+    os: detectOS(),
+    shell: detectShell(),
+    arch: detectArch()
+  };
+}
+
+// src/layers/platform-layer.ts
+function getPlatformContext(_config) {
+  return detectPlatform();
+}
+function formatPlatformContext(platform4) {
+  return `OS: ${platform4.os}
+Shell: ${platform4.shell}
+Arch: ${platform4.arch}`;
+}
+
+// src/layers/machine-layer.ts
+import { existsSync, readFileSync as readFileSync3, writeFileSync, mkdirSync } from "fs";
+import { join as join2, dirname } from "path";
+import { hostname as hostname2 } from "os";
+
+// src/detection/machine-id.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { execSync } from "child_process";
+import { hostname, platform as platform2 } from "os";
+function tryDMISerial() {
+  try {
+    const paths = [
+      "/sys/devices/virtual/dmi/id/product_name",
+      "/sys/devices/virtual/dmi/id/product_serial"
+    ];
+    for (const p of paths) {
+      try {
+        const content = readFileSync2(p, "utf-8").trim();
+        if (content && content !== "Not Specified" && content !== "System Product Name") {
+          return content;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function tryMachineID() {
+  try {
+    return readFileSync2("/etc/machine-id", "utf-8").trim().slice(0, 8) || null;
+  } catch {
+    return null;
+  }
+}
+function tryHostnameMAC() {
+  const hn = hostname();
+  try {
+    const isWin = platform2() === "win32";
+    const cmd = isWin ? 'powershell -Command "Get-NetAdapter | Select-Object -ExpandProperty MacAddress"' : "ifconfig 2>/dev/null || ip link 2>/dev/null";
+    const output = execSync(cmd, { encoding: "utf-8", timeout: 5e3 });
+    const macs = output.match(/([0-9A-Fa-f]{2}([:-][0-9A-Fa-f]{2}){5})/g);
+    if (macs && macs.length > 0) {
+      return `${hn}-${macs[0].replace(/[:-]/g, "").slice(0, 6)}`;
+    }
+    return hn;
+  } catch {
+    return hn;
+  }
+}
+function tryWindowsMachineId() {
+  try {
+    const output = execSync(
+      'powershell -Command "Get-CimInstance -Class Win32_ComputerSystemProduct | Select-Object -ExpandProperty UUID"',
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    const trimmed = output.trim();
+    return trimmed && trimmed !== "00000000-0000-0000-0000-000000000000" ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+function identifyMachine() {
+  const isWin = platform2() === "win32";
+  if (!isWin) {
+    const dmi = tryDMISerial();
+    if (dmi) return { id: dmi, method: "dmi" };
+    const machineId = tryMachineID();
+    if (machineId) return { id: machineId, method: "machine-id" };
+  }
+  if (isWin) {
+    const winId = tryWindowsMachineId();
+    if (winId) return { id: winId, method: "hostname-mac" };
+  }
+  return { id: tryHostnameMAC(), method: "hostname-mac" };
+}
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").slice(0, 64);
+}
+
+// src/layers/machine-layer.ts
+function resolveMachineId() {
+  try {
+    const identity = identifyMachine();
+    const id = sanitizeId(identity.id);
+    return { id, method: identity.method };
+  } catch {
+    return {
+      id: sanitizeId(`fallback-${hostname2()}`),
+      method: "hostname-mac"
+    };
+  }
+}
+var _cachedId = null;
+function getMachineId() {
+  if (!_cachedId) {
+    _cachedId = resolveMachineId();
+  }
+  return _cachedId;
+}
+function machineProfilePath(config) {
+  const storage = config.resolvedStorages.machine;
+  if (storage.type !== "local") return "";
+  const { id } = getMachineId();
+  return join2(storage.basePath, storage.template.replace("{id}", id));
+}
+function loadMachineProfile(config) {
+  const path = machineProfilePath(config);
+  if (!path) return null;
+  try {
+    if (!existsSync(path)) return null;
+    const raw = readFileSync3(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveMachineProfile(config, profile) {
+  const path = machineProfilePath(config);
+  if (!path) return;
+  mkdirSync(dirname(path), { recursive: true });
+  profile.last_updated = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  writeFileSync(path, JSON.stringify(profile, null, 2), "utf-8");
+}
+function createMachineProfile(config, domains) {
+  const { id, method } = getMachineId();
+  return {
+    machine_id: id,
+    id_method: method,
+    hostname: hostname2(),
+    last_updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    domains
+  };
+}
+
+// src/detection/project.ts
+import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+import { parse as parseYaml } from "yaml";
+var DETECTORS = {
+  java_maven: {
+    file: "pom.xml",
+    parse: (content) => {
+      const javaMatch = content.match(/<java\.version>([^<]+)<\/java\.version>/) || content.match(/<maven\.compiler\.source>([^<]+)<\/maven\.compiler\.source>/);
+      if (!javaMatch) return null;
+      return {
+        languages: ["java"],
+        versions: { java: javaMatch[1] },
+        build: "mvn clean compile",
+        test: "mvn test"
+      };
+    }
+  },
+  java_gradle: {
+    file: "build.gradle",
+    parse: (content) => {
+      const match = content.match(/sourceCompatibility\s*=\s*['"]?(\d+\.?\d*)['"]?/);
+      if (!match) return null;
+      return {
+        languages: ["java"],
+        versions: { java: match[1] },
+        build: "gradle build",
+        test: "gradle test"
+      };
+    }
+  },
+  java_gradle_kts: {
+    file: "build.gradle.kts",
+    parse: (content) => {
+      const match = content.match(/JavaVersion\.VERSION_(\d+\.?\d*)/) || content.match(/java\.toolchain\.languageVersion\.set\(JavaLanguageVersion\.of\((\d+\.?\d*)\)\)/);
+      if (!match) return null;
+      return {
+        languages: ["java"],
+        versions: { java: match[1] },
+        build: "gradle build",
+        test: "gradle test"
+      };
+    }
+  },
+  node: {
+    file: "package.json",
+    parse: (content) => {
+      const pkg = JSON.parse(content);
+      const scripts = pkg.scripts || {};
+      return {
+        languages: ["javascript", "typescript"],
+        versions: { node: "unknown" },
+        build: scripts.build || "npm run build",
+        test: scripts.test || "npm test"
+      };
+    }
+  },
+  go: {
+    file: "go.mod",
+    parse: (content) => {
+      const match = content.match(/^go (\d+\.\d+\.?\d*)/m);
+      return {
+        languages: ["go"],
+        versions: { go: match?.[1] || "unknown" },
+        build: "go build ./...",
+        test: "go test ./..."
+      };
+    }
+  },
+  rust: {
+    file: "Cargo.toml",
+    parse: () => ({
+      languages: ["rust"],
+      versions: { rust: "unknown" },
+      build: "cargo build",
+      test: "cargo test"
+    })
+  }
+};
+function runtimeRequirementsPath(projectRoot) {
+  return join3(projectRoot, ".opencode", "skills", "_shared", "runtime-requirements.yaml");
+}
+function readRuntimeRequirements(projectRoot) {
+  const path = runtimeRequirementsPath(projectRoot);
+  try {
+    if (!existsSync2(path)) return null;
+    const raw = readFileSync4(path, "utf-8");
+    return parseYaml(raw);
+  } catch {
+    return null;
+  }
+}
+function detectProjectRuntime(projectRoot) {
+  const result = {
+    languages: [],
+    versions: {},
+    build: "",
+    test: ""
+  };
+  for (const [, detector] of Object.entries(DETECTORS)) {
+    const filePath = join3(projectRoot, detector.file);
+    if (!existsSync2(filePath)) continue;
+    try {
+      const content = readFileSync4(filePath, "utf-8");
+      const parsed = detector.parse(content);
+      if (parsed) {
+        result.languages.push(...parsed.languages);
+        Object.assign(result.versions, parsed.versions);
+        result.build = parsed.build || result.build;
+        result.test = parsed.test || result.test;
+      }
+    } catch {
+      continue;
+    }
+  }
+  result.languages = [...new Set(result.languages)];
+  return result;
+}
+
+// src/layers/project-layer.ts
+function getProjectRuntime(config) {
+  return detectProjectRuntime(config.projectRoot);
+}
+function getRecordedRequirements(config) {
+  return readRuntimeRequirements(config.projectRoot);
+}
+function diffRuntimeVersions(current, recorded) {
+  const warnings = [];
+  if (!recorded) return warnings;
+  for (const [lang, currentVersion] of Object.entries(current.versions)) {
+    const recordedVersion = recorded[lang]?.version;
+    if (recordedVersion && !currentVersion.includes(recordedVersion)) {
+      warnings.push(
+        `Project ${lang} version is ${currentVersion}, but recorded Runtime Requirements require ${recordedVersion}.`
+      );
+    }
+  }
+  return warnings;
+}
+
+// src/layers/user-layer.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+
+// src/detection/language.ts
+var LANGUAGE_MAP = {
+  zh: "\u6280\u672F\u89E3\u91CA\u7528\u4E2D\u6587\uFF0C\u547D\u4EE4\u8F93\u51FA\u4FDD\u7559\u539F\u6587",
+  ja: "\u6280\u8853\u8AAC\u660E\u306F\u65E5\u672C\u8A9E\u3001\u30B3\u30DE\u30F3\u30C9\u51FA\u529B\u306F\u539F\u6587\u306E\u307E\u307E",
+  ko: "\uAE30\uC220 \uC124\uBA85\uC740 \uD55C\uAD6D\uC5B4, \uBA85\uB839\uC5B4 \uCD9C\uB825\uC740 \uC6D0\uBB38 \uC720\uC9C0",
+  de: "Technische Erkl\xE4rungen auf Deutsch, Befehlsausgabe im Original",
+  fr: "Explications techniques en fran\xE7ais, sortie des commandes en original",
+  es: "Explicaciones t\xE9cnicas en espa\xF1ol, salida de comandos en original"
+};
+var FALLBACK = "Technical explanations in English, keep command output as-is";
+function detectSystemLanguage() {
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    return locale.split("-")[0].toLowerCase();
+  } catch {
+    return "en";
+  }
+}
+function languageInstruction(lang) {
+  const code = lang || detectSystemLanguage();
+  return LANGUAGE_MAP[code] ?? FALLBACK;
+}
+
+// src/i18n/en.ts
+var en = {
+  // User preferences defaults
+  "prefs.comment_style": "follow existing code comment style",
+  "prefs.sudo": "list commands for user to run manually",
+  // Decision log
+  "decision.title": "# Decision Log \u2014 {date}",
+  "decision.affected_file": "**Affected file**: {path}",
+  "decision.name_change": "**Name change**: `{old}` \u2192 `{new}`",
+  "decision.stats_title": "## Change Statistics",
+  "decision.lines_added": "- Lines added: {count}",
+  "decision.lines_removed": "- Lines removed: {count}",
+  "decision.structure_title": "## Structure Changes",
+  "decision.section_removed": "**Removed sections**: {sections}",
+  "decision.section_added": "**Added sections**: {sections}",
+  "decision.reason_title": "## Reason for Change",
+  "decision.reason_placeholder": "_(Please document the reason for this change here)_",
+  // Migration map
+  "migration.entry": "- `{old}/` is replaced by `{new}`"
+};
+var en_default = en;
+
+// src/i18n/zh.ts
+var zh = {
+  // 用户偏好默认值
+  "prefs.comment_style": "\u4FDD\u6301\u73B0\u6709\u4EE3\u7801\u6CE8\u91CA\u98CE\u683C",
+  "prefs.sudo": "\u5217\u51FA\u547D\u4EE4\u8BA9\u7528\u6237\u624B\u52A8\u6267\u884C",
+  // 决策日志
+  "decision.title": "# \u51B3\u7B56\u65E5\u5FD7 \u2014 {date}",
+  "decision.affected_file": "**\u5F71\u54CD\u6587\u4EF6**: {path}",
+  "decision.name_change": "**\u540D\u79F0\u53D8\u66F4**: `{old}` \u2192 `{new}`",
+  "decision.stats_title": "## \u53D8\u66F4\u7EDF\u8BA1",
+  "decision.lines_added": "- \u65B0\u589E\u884C: {count}",
+  "decision.lines_removed": "- \u5220\u9664\u884C: {count}",
+  "decision.structure_title": "## \u7ED3\u6784\u53D8\u66F4",
+  "decision.section_removed": "**\u79FB\u9664\u7AE0\u8282**: {sections}",
+  "decision.section_added": "**\u65B0\u589E\u7AE0\u8282**: {sections}",
+  "decision.reason_title": "## \u53D8\u66F4\u539F\u56E0",
+  "decision.reason_placeholder": "_\uFF08\u8BF7\u5728\u6B64\u8865\u5145\u53D8\u66F4\u539F\u56E0\uFF09_",
+  // 迁移映射
+  "migration.entry": "- `{old}/` \u2192 \u5DF2\u6709 `{new}`"
+};
+var zh_default = zh;
+
+// src/i18n/index.ts
+var LOCALES = { en: en_default, zh: zh_default };
+var DEFAULT_LOCALE = "en";
+function detectLocale() {
+  try {
+    const lang = Intl.DateTimeFormat().resolvedOptions().locale.split("-")[0].toLowerCase();
+    if (LOCALES[lang]) return lang;
+  } catch {
+  }
+  return DEFAULT_LOCALE;
+}
+var activeLocale = detectLocale();
+function t(key, params) {
+  const locale = LOCALES[activeLocale] ?? LOCALES[DEFAULT_LOCALE];
+  let msg = locale[key] ?? LOCALES[DEFAULT_LOCALE][key] ?? key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      msg = msg.replace(`{${k}}`, String(v));
+    }
+  }
+  return msg;
+}
+
+// src/layers/user-layer.ts
+function defaultPreferences() {
+  return {
+    user: process.env.USER || process.env.USERNAME || "unknown",
+    last_updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    output_preferences: {
+      comment_style: t("prefs.comment_style"),
+      language: languageInstruction(detectSystemLanguage()),
+      verbosity: "concise"
+    },
+    security_boundaries: {
+      sudo: t("prefs.sudo")
+    }
+  };
+}
+function userProfilePath(config) {
+  const storage = config.resolvedStorages.user;
+  if (storage.type !== "local") return "";
+  const user = process.env.USER || process.env.USERNAME || "unknown";
+  return join4(storage.basePath, storage.template.replace("{name}", user));
+}
+function loadUserPreferences(config) {
+  const defaults = defaultPreferences();
+  const path = userProfilePath(config);
+  if (!path) return defaults;
+  try {
+    const raw = readFileSync5(path, "utf-8");
+    return { ...defaults, ...JSON.parse(raw) };
+  } catch {
+    return defaults;
+  }
+}
+
+// src/detection/toolchain.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { platform as platform3 } from "os";
+var execAsync = promisify(exec);
+var TOOL_DETECTORS = {
+  java: {
+    binary: "java",
+    versionFlag: "-version 2>&1",
+    versionRegex: /version\s+"?([\d._]+)"?/,
+    extraPath: ["javac", "mvn"]
+  },
+  go: {
+    binary: "go",
+    versionFlag: "version",
+    versionRegex: /go(\d+\.\d+\.\d+)/,
+    extraPath: ["gofmt"]
+  },
+  node: {
+    binary: "node",
+    versionFlag: "--version",
+    versionRegex: /v(\d+\.\d+\.\d+)/,
+    extraPath: ["npm", "npx"]
+  },
+  python: {
+    binary: "python3",
+    versionFlag: "--version 2>&1",
+    versionRegex: /Python (\d+\.\d+\.\d+)/,
+    extraPath: ["pip3"]
+  }
+};
+async function detectCommand(cmd) {
+  try {
+    const isWin = platform3() === "win32";
+    const shellCmd = isWin ? `where ${cmd} 2>nul` : `command -v ${cmd}`;
+    const { stdout } = await execAsync(shellCmd, { timeout: 5e3 });
+    return stdout.trim().split("\n")[0] || null;
+  } catch {
+    return null;
+  }
+}
+async function detectVersion(cmd, flag) {
+  try {
+    const { stdout, stderr } = await execAsync(`${cmd} ${flag}`, { timeout: 1e4 });
+    const output = stdout + stderr;
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function detectToolchain() {
+  const result = {
+    java: null,
+    go: null,
+    node: null,
+    python: null
+  };
+  for (const [domain, detector] of Object.entries(TOOL_DETECTORS)) {
+    const binaryPath = await detectCommand(detector.binary);
+    if (!binaryPath) continue;
+    const versionOutput = await detectVersion(detector.binary, detector.versionFlag);
+    const versionMatch = versionOutput?.match(detector.versionRegex);
+    const version = versionMatch?.[1] || "unknown";
+    const paths = {};
+    const versions = {};
+    paths[detector.binary] = binaryPath;
+    versions[detector.binary] = version;
+    if (detector.extraPath) {
+      for (const extra of detector.extraPath) {
+        const p = await detectCommand(extra);
+        if (p) paths[extra] = p;
+        const v = await detectVersion(extra, "--version 2>&1");
+        if (v) versions[extra] = v.trim();
+      }
+    }
+    result[domain] = { paths, versions };
+  }
+  return result;
+}
+
+// src/hooks/session-created.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join6 } from "path";
+
+// src/audit/migration-map.ts
+import { readFileSync as readFileSync6, existsSync as existsSync3, readdirSync } from "fs";
+import { join as join5 } from "path";
+function parseMigrationMap(content, sourceFile) {
+  const entries = [];
+  const mapSection = content.match(/### Migration Map\n([\s\S]*?)(?=\n###|\n##|\n#|$)/);
+  if (!mapSection) return entries;
+  const lines = mapSection[1].split("\n");
+  for (const line of lines) {
+    const match = line.match(
+      /-\s*`([^`]+)`\s*(?:→|is replaced by)\s*(?:已有\s*)?`?([^`\n]+?)`?\s*$/
+    );
+    if (match) {
+      entries.push({
+        oldPath: match[1].trim(),
+        newApi: match[2].trim(),
+        sourceFile
+      });
+    }
+  }
+  return entries;
+}
+function findSkillFiles(skillsDir) {
+  const results = [];
+  function walk(dir) {
+    if (!existsSync3(dir)) return;
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join5(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (!entry.name.startsWith("_archive") && !entry.name.startsWith("decisions")) {
+            walk(fullPath);
+          }
+        } else if (entry.name.endsWith("SKILL.md") || entry.name.endsWith("skill.md")) {
+          results.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(skillsDir);
+  return results;
+}
+function parseAllMigrationMaps(skillsDir) {
+  const results = [];
+  const files = findSkillFiles(skillsDir);
+  for (const file of files) {
+    try {
+      const raw = readFileSync6(file, "utf-8");
+      const entries = parseMigrationMap(raw, file);
+      results.push(...entries);
+    } catch {
+    }
+  }
+  return results;
+}
+function formatMigrationHints(entries) {
+  if (entries.length === 0) return "";
+  const lines = [];
+  lines.push("## Available Migrations");
+  lines.push("");
+  lines.push("When modifying these files, consider upgrading:");
+  lines.push("");
+  for (const entry of entries) {
+    lines.push(`- \`${entry.oldPath}\` is replaced by \`${entry.newApi}\``);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/hooks/session-created.ts
+function getCurrentBranch(projectRoot) {
+  try {
+    return execSync2("git branch --show-current", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function getProjectName(config) {
+  try {
+    const pkg = JSON.parse(
+      readFileSync7(join6(config.projectRoot, "package.json"), "utf-8")
+    );
+    return pkg.name || config.projectRoot.split("/").pop() || "unknown";
+  } catch {
+    return config.projectRoot.split("/").pop() || "unknown";
+  }
+}
+function domainNames(domains) {
+  return Object.keys(domains).join(", ") || "none";
+}
+function buildKnowledgeRoutingRules(config) {
+  return config.behavior_rules.filter((r) => r.enabled).map((r) => `- ${r.rule}`).join("\n");
+}
+function createSessionCreatedHandler(client, config, _registry) {
+  return async (input, _output) => {
+    const sessionId = input.sessionId || input.path?.id;
+    if (!sessionId) return;
+    const platform4 = getPlatformContext(config);
+    const toolchain = await detectToolchain();
+    const domains = {};
+    for (const [name, t2] of Object.entries(toolchain)) {
+      if (t2) {
+        domains[`${name}_dev`] = { paths: t2.paths, versions: t2.versions };
+      }
+    }
+    let machine = loadMachineProfile(config);
+    if (!machine) {
+      machine = createMachineProfile(config, domains);
+      saveMachineProfile(config, machine);
+    } else if (Object.keys(domains).length > 0) {
+      machine.domains = { ...domains, ...machine.domains };
+      saveMachineProfile(config, machine);
+    }
+    const runtime = getProjectRuntime(config);
+    const recorded = getRecordedRequirements(config);
+    const versionWarnings = diffRuntimeVersions(runtime, recorded);
+    const branch = getCurrentBranch(config.projectRoot);
+    const userPrefs = loadUserPreferences(config);
+    const projectName = getProjectName(config);
+    const skillsDir = config.resolvedStorages.project?.basePath;
+    const migrationEntries = skillsDir ? parseAllMigrationMaps(skillsDir) : [];
+    const contextParts = [];
+    contextParts.push("## Session Context");
+    contextParts.push("");
+    contextParts.push(formatPlatformContext(platform4));
+    contextParts.push(`Your machine: ${machine.machine_id} (${machine.hostname})`);
+    contextParts.push(`Available toolchains: ${domainNames(machine.domains)}`);
+    contextParts.push(
+      "Call get_machine_context(domain) for detailed toolchain info"
+    );
+    contextParts.push(
+      "To switch tool versions, add a `switching` command in .opencode/skills/_shared/runtime-requirements.yaml"
+    );
+    contextParts.push("");
+    contextParts.push("## User Preferences");
+    contextParts.push("");
+    const prefs = userPrefs.output_preferences;
+    contextParts.push(`Comment style: ${prefs.comment_style}`);
+    contextParts.push(`Language: ${prefs.language}`);
+    contextParts.push("(Replies automatically adapt to the user's language)");
+    contextParts.push(`Verbosity: ${prefs.verbosity}`);
+    contextParts.push(`Security boundary: ${userPrefs.security_boundaries.sudo}`);
+    contextParts.push("");
+    if (runtime.languages.length > 0) {
+      contextParts.push("## Project Info");
+      contextParts.push("");
+      contextParts.push(`Current project: ${projectName}`);
+      contextParts.push(`Languages: ${runtime.languages.join(", ")}`);
+      if (Object.keys(runtime.versions).length > 0) {
+        contextParts.push(
+          `Runtime versions: ${Object.entries(runtime.versions).map(([k, v]) => `${k}=${v}`).join(", ")}`
+        );
+      }
+      if (runtime.build) contextParts.push(`Build command: ${runtime.build}`);
+      if (runtime.test) contextParts.push(`Test command: ${runtime.test}`);
+      if (branch !== "unknown") {
+        contextParts.push(`Current branch: ${branch}`);
+      }
+      contextParts.push("");
+    }
+    contextParts.push("## Knowledge Routing Rules");
+    contextParts.push("");
+    contextParts.push("When discovering knowledge worth recording, follow these rules:");
+    contextParts.push(buildKnowledgeRoutingRules(config));
+    contextParts.push("When uncertain \u2192 write to SKILL.md and ask the user");
+    contextParts.push("");
+    if (migrationEntries.length > 0) {
+      contextParts.push(formatMigrationHints(migrationEntries));
+    }
+    if (versionWarnings.length > 0) {
+      contextParts.push("## Version Mismatch Detected");
+      contextParts.push("");
+      for (const w of versionWarnings) {
+        contextParts.push(`- ${w}`);
+      }
+      contextParts.push("If the upgrade is intentional, update runtime-requirements.yaml");
+      contextParts.push("");
+    }
+    const compiledContext = contextParts.join("\n");
+    try {
+      await client.session.prompt({
+        path: { id: sessionId },
+        body: {
+          noReply: true,
+          parts: [{ type: "text", text: compiledContext }]
+        }
+      });
+    } catch {
+    }
+  };
+}
+
+// src/hooks/file-edited.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { relative } from "path";
+
+// src/audit/change-detector.ts
+function extractFrontmatterName(content) {
+  const match = content.match(/^---\s*\nname:\s*(\S+)/m);
+  return match?.[1]?.trim() || null;
+}
+function extractHeadings(content) {
+  const matches = content.match(/^##\s+(.+)$/gm);
+  return matches ? matches.map((m) => m.replace(/^##\s+/, "").trim()) : [];
+}
+function lineDiff(oldContent, newContent) {
+  const oldLines = oldContent.split("\n").length;
+  const newLines = newContent.split("\n").length;
+  const diff = newLines - oldLines;
+  return {
+    added: diff > 0 ? diff : 0,
+    removed: diff < 0 ? -diff : 0
+  };
+}
+function analyzeChange(oldContent, newContent, filePath) {
+  if (!oldContent) {
+    return {
+      isSubstantial: false,
+      oldName: null,
+      newName: extractFrontmatterName(newContent),
+      oldHeadings: [],
+      newHeadings: extractHeadings(newContent),
+      linesAdded: 0,
+      linesRemoved: 0
+    };
+  }
+  const oldName = extractFrontmatterName(oldContent);
+  const newName = extractFrontmatterName(newContent);
+  const nameChanged = oldName !== null && newName !== null && oldName !== newName;
+  const diff = lineDiff(oldContent, newContent);
+  const totalLines = Math.max(oldContent.split("\n").length, 1);
+  const diffRatio = (diff.added + diff.removed) / totalLines;
+  const isSubstantial = nameChanged || diff.added + diff.removed > 5 || diffRatio > 0.2;
+  return {
+    isSubstantial,
+    oldName,
+    newName,
+    oldHeadings: extractHeadings(oldContent),
+    newHeadings: extractHeadings(newContent),
+    linesAdded: diff.added,
+    linesRemoved: diff.removed
+  };
+}
+
+// src/audit/archive-manager.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync4, renameSync } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
+function moduleDir(filePath) {
+  const segments = filePath.split("/");
+  const skillsIdx = segments.lastIndexOf(".opencode");
+  if (skillsIdx === -1) return dirname2(filePath);
+  const skillsDir = join7(segments.slice(0, skillsIdx + 2).join("/"));
+  const relative2 = filePath.replace(skillsDir + "/", "");
+  const parts = relative2.split("/");
+  return parts.length > 1 ? join7(skillsDir, parts[0]) : skillsDir;
+}
+function createDecisionLog(filePath, change) {
+  const dir = moduleDir(filePath);
+  const decisionsDir = join7(dir, "decisions");
+  mkdirSync2(decisionsDir, { recursive: true });
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const topic = change.oldName || change.newName || "skill";
+  const logPath = join7(decisionsDir, `${date}-${topic}.md`);
+  const lines = [];
+  lines.push(t("decision.title", { date }));
+  lines.push("");
+  lines.push(t("decision.affected_file", { path: filePath }));
+  lines.push("");
+  if (change.oldName && change.newName && change.oldName !== change.newName) {
+    lines.push(t("decision.name_change", { old: change.oldName, new: change.newName }));
+    lines.push("");
+  }
+  lines.push(t("decision.stats_title"));
+  lines.push("");
+  lines.push(t("decision.lines_added", { count: change.linesAdded }));
+  lines.push(t("decision.lines_removed", { count: change.linesRemoved }));
+  lines.push("");
+  if (change.oldHeadings.length > 0 || change.newHeadings.length > 0) {
+    lines.push(t("decision.structure_title"));
+    lines.push("");
+    const removed = change.oldHeadings.filter((h) => !change.newHeadings.includes(h));
+    const added = change.newHeadings.filter((h) => !change.oldHeadings.includes(h));
+    if (removed.length > 0) {
+      lines.push(t("decision.section_removed", { sections: removed.join(", ") }));
+    }
+    if (added.length > 0) {
+      lines.push(t("decision.section_added", { sections: added.join(", ") }));
+    }
+    lines.push("");
+  }
+  lines.push(t("decision.reason_title"));
+  lines.push("");
+  lines.push(t("decision.reason_placeholder"));
+  lines.push("");
+  writeFileSync2(logPath, lines.join("\n"), "utf-8");
+  return logPath;
+}
+function archiveOldVariant(filePath, change) {
+  if (!change.oldName || !change.newName || change.oldName === change.newName) {
+    return null;
+  }
+  const dir = moduleDir(filePath);
+  const archiveDir = join7(dir, "_archive", change.oldName);
+  mkdirSync2(archiveDir, { recursive: true });
+  const archivePath = join7(archiveDir, "SKILL.md");
+  if (existsSync4(filePath)) {
+    try {
+      renameSync(filePath, archivePath);
+    } catch {
+      const content = readFileSync8(filePath, "utf-8");
+      writeFileSync2(archivePath, content, "utf-8");
+    }
+  }
+  return archivePath;
+}
+function updateMigrationMap(filePath, oldName, newName) {
+  try {
+    const content = readFileSync8(filePath, "utf-8");
+    const lines = content.split("\n");
+    let migrationIdx = lines.findIndex((l) => l.startsWith("### Migration Map"));
+    const entry = t("migration.entry", { old: oldName, new: newName });
+    if (migrationIdx === -1) {
+      lines.push("");
+      lines.push("### Migration Map");
+      lines.push(entry);
+    } else {
+      let insertIdx = migrationIdx + 2;
+      while (insertIdx < lines.length && (lines[insertIdx].trim() === "" || lines[insertIdx].startsWith("-"))) {
+        insertIdx++;
+      }
+      lines.splice(insertIdx, 0, entry);
+    }
+    writeFileSync2(filePath, lines.join("\n"), "utf-8");
+  } catch {
+  }
+}
+
+// src/hooks/file-edited.ts
+function getOldContent(filePath, projectRoot) {
+  try {
+    const relPath = relative(projectRoot, filePath);
+    return execSync3(`git show HEAD:"${relPath}"`, {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).toString();
+  } catch {
+    return null;
+  }
+}
+function createFileEditedHandler(config, _registry) {
+  return async (input, _output) => {
+    const filePath = input.filePath || input.path || "";
+    if (!filePath) return;
+    const skillsDir = config.resolvedStorages.project?.basePath;
+    if (!skillsDir || !filePath.startsWith(skillsDir)) return;
+    const isSkillFile = filePath.endsWith("SKILL.md") || filePath.endsWith("skill.md");
+    if (!isSkillFile) return;
+    let newContent;
+    try {
+      newContent = readFileSync9(filePath, "utf-8");
+    } catch {
+      return;
+    }
+    const oldContent = getOldContent(filePath, config.projectRoot);
+    const change = analyzeChange(oldContent, newContent, filePath);
+    if (!change.isSubstantial) return;
+    createDecisionLog(filePath, change);
+    if (change.oldName && change.newName && change.oldName !== change.newName) {
+      archiveOldVariant(filePath, change);
+      updateMigrationMap(filePath, change.oldName, change.newName);
+    }
+  };
+}
+
+// src/security/sanitizer.ts
+var SENSITIVE_CONTENT_PATTERNS = [
+  /-----BEGIN\s+(RSA|DSA|EC|OPENSSH)?\s*PRIVATE\s+KEY-----/,
+  /export\s+\w*TOKEN\w*\s*=\s*\S+/i,
+  /export\s+\w*SECRET\w*\s*=\s*\S+/i,
+  /export\s+\w*KEY\w*\s*=\s*\S+/i,
+  /export\s+\w*PASSWORD\w*\s*=\s*\S+/i,
+  /[\w-]{20,}={2,}$/
+];
+function containsSensitiveContent(content) {
+  const found = [];
+  for (const pattern of SENSITIVE_CONTENT_PATTERNS) {
+    if (pattern.test(content)) {
+      found.push(pattern.source);
+    }
+  }
+  return found;
+}
+function shouldBlockRead(filePath) {
+  if (filePath.includes(".env")) return true;
+  const sshMatch = /\/\.ssh\//;
+  if (sshMatch.test(filePath)) return true;
+  const gnupgMatch = /\/\.gnupg\//;
+  if (gnupgMatch.test(filePath)) return true;
+  return false;
+}
+
+// src/hooks/tool-execute-before.ts
+var BUILD_RUN_PATTERNS = {
+  java: ["mvn ", "gradle ", "gradlew ", "java ", "javac "],
+  go: ["go build", "go test", "go run", "go install", "go generate"],
+  node: ["npm ", "npx ", "node ", "yarn ", "pnpm "],
+  python: ["python ", "python3 ", "pip ", "pip3 ", "pytest"],
+  rust: ["cargo "],
+  generic: ["make ", "cmake "]
+};
+function isBuildOrRunCommand(command) {
+  for (const patterns of Object.values(BUILD_RUN_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (command.startsWith(pattern)) return true;
+    }
+  }
+  return false;
+}
+function detectLanguage(command) {
+  for (const [lang, patterns] of Object.entries(BUILD_RUN_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (command.startsWith(pattern)) return lang;
+    }
+  }
+  return null;
+}
+function buildJavaSwitching(toolchain, requiredVersion) {
+  const java = toolchain.java;
+  if (!java?.paths?.java) return "";
+  const javaPath = java.paths.java;
+  const javaHome = javaPath.replace(/\/bin\/java$/, "");
+  if (requiredVersion && java.versions?.java) {
+    if (!java.versions.java.includes(requiredVersion.replace(/^(\d+).*/, "$1"))) {
+      const lower = requiredVersion.replace(/^(\d+).*/, "$1");
+      const altPath = javaPath.replace(/java-?\d+/, `java-${lower}`);
+      return `export JAVA_HOME="${altPath.replace(/\/bin\/java$/, "")}" && export PATH="$JAVA_HOME/bin:$PATH" && `;
+    }
+  }
+  return `export JAVA_HOME="${javaHome}" && export PATH="$JAVA_HOME/bin:$PATH" && `;
+}
+function buildGoSwitching(toolchain) {
+  const go = toolchain.go;
+  if (!go?.paths?.go) return "";
+  return `export PATH="${go.paths.go.replace(/\/go$/, "")}:$PATH" && `;
+}
+function getRuntimeSwitchingCmd(recordedRequirements, lang) {
+  if (!recordedRequirements) return null;
+  return recordedRequirements[lang]?.switching || null;
+}
+function createToolExecuteBeforeHandler(config, _registry) {
+  return async (input, output) => {
+    if (input.tool === "read" && output.args?.filePath) {
+      if (shouldBlockRead(output.args.filePath)) {
+        throw new Error("Cannot read sensitive files (.env, .ssh/, .gnupg/)");
+      }
+    }
+    if (input.tool !== "bash" || !output.args?.command) return;
+    const command = output.args.command;
+    if (!isBuildOrRunCommand(command)) return;
+    const lang = detectLanguage(command);
+    if (!lang || lang === "generic") return;
+    const recorded = getRecordedRequirements(config);
+    let switchingCmd = getRuntimeSwitchingCmd(recorded, lang);
+    if (switchingCmd) {
+      output.args.command = `${switchingCmd} && ${output.args.command}`;
+      return;
+    }
+    const machine = loadMachineProfile(config);
+    if (machine?.domains) {
+      const machineDomain = machine.domains[`${lang}_dev`];
+      if (machineDomain?.versions) {
+        const required = recorded?.[lang]?.version;
+        for (const [binary, version] of Object.entries(machineDomain.versions)) {
+          if (required && !version.includes(required.replace(/[+>=<~^]/, ""))) {
+            continue;
+          }
+          const binaryPath = machineDomain.paths?.[binary];
+          if (binaryPath && lang === "java") {
+            const javaHome = binaryPath.replace(/\/bin\/java$/, "");
+            output.args.command = `export JAVA_HOME="${javaHome}" && export PATH="$JAVA_HOME/bin:$PATH" && ${output.args.command}`;
+            return;
+          }
+        }
+      }
+    }
+    const toolchain = await detectToolchain();
+    switch (lang) {
+      case "java":
+        switchingCmd = buildJavaSwitching(toolchain, recorded?.["java"]?.version);
+        break;
+      case "go":
+        switchingCmd = buildGoSwitching(toolchain);
+        break;
+    }
+    if (switchingCmd) {
+      output.args.command = `${switchingCmd}${output.args.command}`;
+    }
+  };
+}
+
+// src/tools/note-discovery.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/utils/parsers.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
+var parserRegistry = /* @__PURE__ */ new Map();
+function registerParser(ext, parser) {
+  parserRegistry.set(ext, parser);
+}
+function readParsed(basePath, relPath) {
+  const fullPath = join8(basePath, relPath);
+  try {
+    if (!existsSync6(fullPath)) return null;
+    const raw = readFileSync10(fullPath, "utf-8");
+    const ext = relPath.split(".").pop() || "";
+    const parser = parserRegistry.get(ext);
+    return { raw, parsed: parser ? parser(raw) : null };
+  } catch {
+    return null;
+  }
+}
+function defaultYamlParser(content) {
+  const result = {};
+  const lines = content.split("\n");
+  let currentKey = "";
+  for (const line of lines) {
+    const match = line.match(/^(\w[\w.-]*):\s*(.*)/);
+    if (match) {
+      currentKey = match[1];
+      result[currentKey] = match[2] || "";
+    } else if (currentKey) {
+      result[currentKey] = result[currentKey] + "\n" + line;
+    }
+  }
+  return result;
+}
+registerParser("yaml", defaultYamlParser);
+registerParser("yml", defaultYamlParser);
+registerParser("json", (c) => JSON.parse(c));
+registerParser("md", (c) => ({ raw: c }));
+
+// src/utils/knowledge-router.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join9 } from "path";
+import { execSync as execSync4 } from "child_process";
+function isGitRepo(projectRoot) {
+  try {
+    const output = execSync4("git rev-parse --is-inside-work-tree", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.trim() === "true";
+  } catch {
+    return existsSync7(join9(projectRoot, ".git"));
+  }
+}
+function isCoreArchitecture(content) {
+  const keywords = [
+    "architecture",
+    "\u8BBE\u8BA1\u51B3\u7B56",
+    "design decision",
+    "interface contract",
+    "\u63A5\u53E3\u7EA6\u5B9A",
+    "\u63A5\u53E3",
+    "interface",
+    "protocol",
+    "\u6743\u9650\u6A21\u578B",
+    "permission model",
+    "token",
+    "auth",
+    "authentication",
+    "\u8BA4\u8BC1",
+    "authorization",
+    "api contract"
+  ];
+  return keywords.some((kw) => content.toLowerCase().includes(kw.toLowerCase()));
+}
+function determineScope(note, config) {
+  if (note.scope === "cross") return "cross";
+  if (note.layer === "project") {
+    if (isCoreArchitecture(note.content) && isGitRepo(config.projectRoot)) {
+      return "cross";
+    }
+  }
+  return "branch";
+}
+
+// src/tools/note-discovery.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, existsSync as existsSync8 } from "fs";
+import { join as join10, dirname as dirname4 } from "path";
+function createNoteDiscoveryTool(config) {
+  return tool({
+    description: "Record discovered knowledge. Core architecture/design decisions \u2192 _shared/ (cross-branch). Branch progress \u2192 SKILL.md. Only tool outputs go to Machine/Platform layers; user assumptions never enter any layer.",
+    args: {
+      domain: tool.schema.string().describe("Domain the knowledge belongs to"),
+      content: tool.schema.string().describe("Knowledge content to record"),
+      layer: tool.schema.enum(["project", "machine", "user"]).describe("Target layer"),
+      scope: tool.schema.enum(["branch", "cross"]).optional().describe("Scope; auto-determined if not specified")
+    },
+    async execute(args, _context) {
+      const note = {
+        domain: args.domain,
+        content: args.content,
+        layer: args.layer,
+        scope: args.scope
+      };
+      const sensitive = containsSensitiveContent(note.content);
+      if (sensitive.length > 0) {
+        return "Content contains sensitive data (private keys, tokens, secrets) and will not be recorded";
+      }
+      const scope = determineScope(note, config);
+      if (note.layer === "project") {
+        const storage = config.resolvedStorages.project;
+        if (storage.type !== "local") {
+          return `Project layer storage not configured; cannot record "${note.domain}"`;
+        }
+        let targetPath;
+        if (scope === "cross") {
+          targetPath = join10(storage.basePath, "_shared", `${note.domain}.md`);
+        } else {
+          targetPath = join10(storage.basePath, `${note.domain}.md`);
+        }
+        mkdirSync4(dirname4(targetPath), { recursive: true });
+        const existing = existsSync8(targetPath) ? readParsed(storage.basePath, targetPath)?.raw || "" : "";
+        const marker = scope === "cross" ? "## Cross-branch Knowledge\n\n" : "## Branch Knowledge\n\n";
+        const entry = existing ? `${existing}
+
+---
+
+${marker}${note.content}` : `# ${note.domain}
+
+${marker}${note.content}`;
+        writeFileSync4(targetPath, entry, "utf-8");
+        return scope === "cross" ? `Knowledge "${note.domain}" written to _shared/${note.domain}.md (cross-branch)` : `Knowledge "${note.domain}" written to SKILL.md (${note.domain}.md) (branch)`;
+      }
+      if (note.layer === "machine") {
+        const storage = config.resolvedStorages.machine;
+        if (storage.type !== "local") {
+          return "Machine layer storage not configured; cannot record knowledge";
+        }
+        const machine = loadMachineProfile(config);
+        if (!machine) {
+          return "Machine profile does not exist; waiting for auto-initialization";
+        }
+        const domainKey = note.domain.endsWith("_dev") ? note.domain : `${note.domain}_dev`;
+        if (!machine.domains[domainKey]) {
+          machine.domains[domainKey] = {};
+        }
+        machine.domains[domainKey].versions ||= {};
+        machine.domains[domainKey].versions[note.domain] = note.content;
+        saveMachineProfile(config, machine);
+        return `Machine layer ${domainKey} updated`;
+      }
+      return `Knowledge "${note.domain}" recorded to ${note.layer} layer (${scope})`;
+    }
+  });
+}
+
+// src/tools/get-machine-context.ts
+import { tool as tool2 } from "@opencode-ai/plugin";
+function createGetMachineContextTool(config) {
+  return tool2({
+    description: "Get full details of a dev toolchain domain, including executable paths and versions",
+    args: {
+      domain: tool2.schema.string().describe("Toolchain domain, e.g. java_dev, go_dev, node_dev, python_dev")
+    },
+    async execute(args, _context) {
+      const domain = args.domain;
+      const machine = loadMachineProfile(config);
+      if (machine?.domains?.[domain]) {
+        const d = machine.domains[domain];
+        const paths2 = d.paths ? Object.entries(d.paths).map(([k, v]) => `  ${k}: ${v}`).join("\n") : "";
+        const versions2 = d.versions ? Object.entries(d.versions).map(([k, v]) => `  ${k}: ${v}`).join("\n") : "";
+        return [
+          `Machine domain: ${domain}`,
+          paths2 ? `Executable paths:
+${paths2}` : "",
+          versions2 ? `Versions:
+${versions2}` : "",
+          d.nvm_dir ? `NVM: ${d.nvm_dir}` : "",
+          d.gopath ? `GOPATH: ${d.gopath}` : ""
+        ].filter(Boolean).join("\n");
+      }
+      const toolchain = await detectToolchain();
+      const result = toolchain[domain?.replace("_dev", "")];
+      if (!result) {
+        return `No toolchain found for ${domain}; ensure the relevant dev tools are installed and on PATH`;
+      }
+      const paths = Object.entries(result.paths).map(([k, v]) => `  ${k}: ${v}`).join("\n");
+      const versions = Object.entries(result.versions).map(([k, v]) => `  ${k}: ${v}`).join("\n");
+      return [
+        `Machine domain: ${domain} (live detection)`,
+        `Executable paths:
+${paths}`,
+        `Versions:
+${versions}`
+      ].join("\n");
+    }
+  });
+}
+
+// src/index.ts
+var plugin = (async (ctx) => {
+  const config = resolvePluginConfig(ctx.directory);
+  const registry = new LayerRegistry(config.layers);
+  return {
+    "session.created": createSessionCreatedHandler(ctx.client, config, registry),
+    "file.edited": createFileEditedHandler(config, registry),
+    "tool.execute.before": createToolExecuteBeforeHandler(config, registry),
+    tool: {
+      note_discovery: createNoteDiscoveryTool(config),
+      get_machine_context: createGetMachineContextTool(config)
+    }
+  };
+});
+var index_default = plugin;
+export {
+  index_default as default
+};