opencode-swarm 7.107.2 → 7.107.4

package/dist/cli/{index-9wstcavp.js → index-bpgqbwmf.js}

@@ -1,956 +1,52 @@
 // @bun
+import {
+  ALLOWED_SKILL_PATH_PREFIXES,
+  validateSkillPath
+} from "./index-dfdg4ws5.js";
+import {
+  effectiveRetrievalOutcomes,
+  readKnowledgeCounterRollups
+} from "./index-kxm3bdjh.js";
 import {
   computeOutcomeSignal,
-  findNearDuplicate,
-  inferTags,
   readKnowledge,
   resolveHiveKnowledgePath,
-  resolveKnowledgeStoreDir,
   resolveSwarmKnowledgePath,
-  resolveSwarmRejectedPath,
-  rewriteKnowledge,
-  transactKnowledge
-} from "./index-f7nma02k.js";
-import {
-  atomicWriteFile
-} from "./index-9b7qp18e.js";
+  rewriteKnowledge
+} from "./index-xmarctsf.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
 import {
-  require_proper_lockfile
-} from "./index-3naa2ajc.js";
-import {
-  __require,
-  __toESM
+  __require
 } from "./index-a76rekgs.js";
 
 // src/services/skill-generator.ts
-import { existsSync as existsSync3, unlinkSync } from "fs";
-import { mkdir as mkdir5, readFile as readFile4, rename as rename2, unlink, writeFile as writeFile3 } from "fs/promises";
-import * as path5 from "path";
-
-// src/hooks/knowledge-events.ts
-import { existsSync } from "fs";
-import { appendFile, mkdir, readFile, stat } from "fs/promises";
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import * as path from "path";
-init_logger();
-var counterRollupCache = new Map;
-var MAX_COUNTER_ROLLUP_CACHE_DIRS = 32;
-var RECEIPT_EVENT_TYPES = new Set([
-  "acknowledged",
-  "applied",
-  "ignored",
-  "contradicted",
-  "violated",
-  "n_a",
-  "override"
-]);
-function resolveKnowledgeEventsPath(directory) {
-  return path.join(resolveKnowledgeStoreDir(directory), "knowledge-events.jsonl");
-}
-function resolveKnowledgeCounterBaselinePath(directory) {
-  return path.join(resolveKnowledgeStoreDir(directory), "knowledge-counter-baseline.json");
-}
-function resolveLegacyApplicationLogPath(directory) {
-  return path.join(resolveKnowledgeStoreDir(directory), "knowledge-application.jsonl");
-}
-async function readKnowledgeEvents(directory, maxEvents) {
-  const filePath = resolveKnowledgeEventsPath(directory);
-  if (!existsSync(filePath))
-    return [];
-  const content = await readFile(filePath, "utf-8");
-  const out = [];
-  const max = maxEvents !== undefined && maxEvents > 0 ? maxEvents : Infinity;
-  for (const line of content.split(`
-`)) {
-    if (out.length >= max)
-      break;
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-async function readLegacyApplicationRecords(directory) {
-  const filePath = resolveLegacyApplicationLogPath(directory);
-  if (!existsSync(filePath))
-    return [];
-  const content = await readFile(filePath, "utf-8");
-  const out = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
-}
-var MAX_VIOLATION_TIMESTAMPS = 10;
-function emptyRollup() {
-  return {
-    shown_count: 0,
-    acknowledged_count: 0,
-    applied_explicit_count: 0,
-    ignored_count: 0,
-    violated_count: 0,
-    contradicted_count: 0,
-    n_a_count: 0,
-    succeeded_after_shown_count: 0,
-    failed_after_shown_count: 0,
-    partial_after_shown_count: 0,
-    violation_timestamps: []
-  };
-}
-function cloneRollup(input) {
-  return {
-    ...emptyRollup(),
-    ...input,
-    violation_timestamps: [...input.violation_timestamps ?? []]
-  };
-}
-function cloneRollupMap(input) {
-  const out = new Map;
-  for (const [id, rollup] of input) {
-    out.set(id, cloneRollup(rollup));
-  }
-  return out;
-}
-function normalizeRollupTimestamps(rollup) {
-  if (rollup.violation_timestamps.length > 1) {
-    rollup.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
-  }
-  if (rollup.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
-    rollup.violation_timestamps = rollup.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
-  }
-  return rollup;
-}
-function get(map, id) {
-  let r = map.get(id);
-  if (!r) {
-    r = emptyRollup();
-    map.set(id, r);
-  }
-  return r;
-}
-function maxIso(current, candidate) {
-  if (!current)
-    return candidate;
-  return candidate > current ? candidate : current;
-}
-async function readCounterBaseline(directory) {
-  const filePath = resolveKnowledgeCounterBaselinePath(directory);
-  if (!existsSync(filePath))
-    return new Map;
-  let raw;
-  try {
-    raw = JSON.parse(await readFile(filePath, "utf-8"));
-  } catch (err) {
-    warn(`[knowledge-events] corrupted counter baseline at ${filePath}; ignoring folded baseline and replaying live events only: ${err instanceof Error ? err.message : String(err)}`);
-    return new Map;
-  }
-  const map = new Map;
-  for (const [id, rollup] of Object.entries(raw)) {
-    map.set(id, normalizeRollupTimestamps(cloneRollup(rollup)));
-  }
-  return map;
-}
-async function statCacheKey(filePath) {
-  try {
-    const fileStat = await stat(filePath);
-    return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return "missing";
-    throw err;
-  }
-}
-async function buildCounterRollupCacheKey(directory) {
-  const [eventsKey, legacyKey, baselineKey] = await Promise.all([
-    statCacheKey(resolveKnowledgeEventsPath(directory)),
-    statCacheKey(resolveLegacyApplicationLogPath(directory)),
-    statCacheKey(resolveKnowledgeCounterBaselinePath(directory))
-  ]);
-  return `${eventsKey}|${legacyKey}|${baselineKey}`;
-}
-function setCounterRollupCache(directory, key, rollups) {
-  if (counterRollupCache.has(directory)) {
-    counterRollupCache.delete(directory);
-  }
-  counterRollupCache.set(directory, {
-    key,
-    rollups: cloneRollupMap(rollups)
-  });
-  while (counterRollupCache.size > MAX_COUNTER_ROLLUP_CACHE_DIRS) {
-    const oldestKey = counterRollupCache.keys().next().value;
-    if (oldestKey === undefined)
-      break;
-    counterRollupCache.delete(oldestKey);
-  }
-}
-function recomputeCounters(events, legacyRecords = [], baseline = new Map) {
-  const map = new Map;
-  const retrievedIds = new Set;
-  for (const [id, rollup] of baseline) {
-    map.set(id, cloneRollup(rollup));
-    if ((rollup.shown_count ?? 0) > 0)
-      retrievedIds.add(id);
-  }
-  for (const e of events) {
-    switch (e.type) {
-      case "retrieved": {
-        for (const id of e.result_ids) {
-          retrievedIds.add(id);
-          get(map, id).shown_count += 1;
-        }
-        break;
-      }
-      case "acknowledged": {
-        const r = get(map, e.knowledge_id);
-        r.acknowledged_count += 1;
-        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
-        break;
-      }
-      case "applied": {
-        const r = get(map, e.knowledge_id);
-        r.applied_explicit_count += 1;
-        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
-        break;
-      }
-      case "ignored":
-        get(map, e.knowledge_id).ignored_count += 1;
-        break;
-      case "violated": {
-        const r = get(map, e.knowledge_id);
-        r.violated_count += 1;
-        r.violation_timestamps.push(e.timestamp);
-        break;
-      }
-      case "contradicted":
-        get(map, e.knowledge_id).contradicted_count += 1;
-        break;
-      case "n_a":
-        get(map, e.knowledge_id).n_a_count += 1;
-        break;
-      case "outcome": {
-        if (!e.knowledge_id)
-          break;
-        const r = get(map, e.knowledge_id);
-        if (e.outcome === "success")
-          r.succeeded_after_shown_count += 1;
-        else if (e.outcome === "failure")
-          r.failed_after_shown_count += 1;
-        else if (e.outcome === "partial")
-          r.partial_after_shown_count += 1;
-        break;
-      }
-    }
-  }
-  for (const rec of legacyRecords) {
-    const r = get(map, rec.knowledgeId);
-    switch (rec.result) {
-      case "shown":
-        if (!retrievedIds.has(rec.knowledgeId))
-          r.shown_count += 1;
-        break;
-      case "acknowledged":
-        r.acknowledged_count += 1;
-        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
-        break;
-      case "applied":
-        r.applied_explicit_count += 1;
-        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
-        break;
-      case "ignored":
-        r.ignored_count += 1;
-        break;
-      case "violated":
-        r.violated_count += 1;
-        r.violation_timestamps.push(rec.timestamp);
-        break;
-    }
-  }
-  for (const r of map.values()) {
-    normalizeRollupTimestamps(r);
-  }
-  return map;
-}
-async function readKnowledgeCounterRollups(directory) {
-  try {
-    const cacheKey = await buildCounterRollupCacheKey(directory);
-    const cached = counterRollupCache.get(directory);
-    if (cached?.key === cacheKey) {
-      counterRollupCache.delete(directory);
-      counterRollupCache.set(directory, cached);
-      return cloneRollupMap(cached.rollups);
-    }
-    const [events, legacyRecords, baseline] = await Promise.all([
-      readKnowledgeEvents(directory),
-      readLegacyApplicationRecords(directory),
-      readCounterBaseline(directory)
-    ]);
-    const rollups = recomputeCounters(events, legacyRecords, baseline);
-    setCounterRollupCache(directory, cacheKey, rollups);
-    return cloneRollupMap(rollups);
-  } catch (err) {
-    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
-    return new Map;
-  }
-}
-function effectiveRetrievalOutcomes(stored, rollup) {
-  const base = stored ?? {
-    applied_count: 0,
-    succeeded_after_count: 0,
-    failed_after_count: 0
-  };
-  if (!rollup)
-    return base;
-  const { n_a_count: _na, ...rollupWithoutNa } = rollup;
-  return {
-    ...base,
-    ...rollupWithoutNa,
-    succeeded_after_shown_count: (base.succeeded_after_shown_count ?? 0) + (rollup.succeeded_after_shown_count ?? 0),
-    failed_after_shown_count: (base.failed_after_shown_count ?? 0) + (rollup.failed_after_shown_count ?? 0)
-  };
-}
-
-// src/hooks/knowledge-validator.ts
-var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
-import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
-import * as path2 from "path";
-init_logger();
-var DANGEROUS_COMMAND_ERROR_PATTERNS = [
-  /\brm\s+-rf\b/,
-  /\bsudo\s+rm\b/,
-  /\bmkfs\b/,
-  /\bdd\s+if=/,
-  /:\(\)\s*\{/,
-  /\bchmod\s+-R\s+777\b/i,
-  /\bdeltree\b/,
-  /\brmdir\s+\/s\b/
-];
-var DANGEROUS_COMMAND_WARNING_PATTERNS = [
-  /\bformat\b/,
-  /\bkill\s+-9\b/,
-  /\bpkill\b/,
-  /\bkillall\b/,
-  /`[^`]*`/,
-  /\$\([^)]*\)/
-];
-var DANGEROUS_COMMAND_PATTERNS = [
-  ...DANGEROUS_COMMAND_ERROR_PATTERNS,
-  ...DANGEROUS_COMMAND_WARNING_PATTERNS
-];
-var SECURITY_DEGRADING_PATTERNS = [
-  /disable\s+.{0,50}firewall/i,
-  /turn\s+off\s+.{0,50}security/i,
-  /skip\s+.{0,50}auth/i,
-  /bypass\s+.{0,50}auth/i,
-  /ignore\s+.{0,50}certificate/i,
-  /disable\s+.{0,50}tls/i,
-  /disable\s+.{0,50}ssl/i,
-  /no\s+.{0,50}validation/i,
-  /disable\s+.{0,50}2fa/i,
-  /remove\s+.{0,50}password/i
-];
-var INVISIBLE_FORMAT_CHARS = /[\u00AD\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/g;
-var INJECTION_PATTERNS = [
-  /[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f\x0d]/,
-  /[\u00AD\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/,
-  /^system\s*:/i,
-  /<script/i,
-  /javascript:/i,
-  /\beval\(/i,
-  /\b__proto__\b/,
-  /\bconstructor\[/,
-  /\.prototype\[/
-];
-var VALID_CATEGORIES = new Set([
-  "process",
-  "architecture",
-  "tooling",
-  "security",
-  "testing",
-  "debugging",
-  "performance",
-  "integration",
-  "todo",
-  "other"
-]);
-var TECH_REFERENCE_WORDS = new Set([
-  "git",
-  "docker",
-  "typescript",
-  "bun",
-  "vitest",
-  "node",
-  "python",
-  "react",
-  "sql",
-  "api",
-  "hook",
-  "test",
-  "schema",
-  "config",
-  "file",
-  "function",
-  "class",
-  "module",
-  "import",
-  "export"
-]);
-var ACTION_VERB_WORDS = new Set([
-  "use",
-  "avoid",
-  "prefer",
-  "run",
-  "check",
-  "always",
-  "never",
-  "ensure",
-  "call",
-  "write",
-  "add",
-  "remove",
-  "update",
-  "set",
-  "enable",
-  "disable"
-]);
-var NEGATION_PAIRS = [
-  ["always", "never"],
-  ["must", "must not"],
-  ["must", "should not"],
-  ["enable", "disable"],
-  ["use", "avoid"],
-  ["use", "don't use"],
-  ["recommended", "not recommended"]
-];
-function normalizeText(text) {
-  return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-function extractContextWords(text, word, contextWindow = 3) {
-  const words = text.split(" ");
-  const context = new Set;
-  if (!word.includes(" ")) {
-    let from = 0;
-    let idx = words.indexOf(word, from);
-    while (idx !== -1) {
-      const start = Math.max(0, idx - contextWindow);
-      const end = Math.min(words.length, idx + contextWindow + 1);
-      for (let i2 = start;i2 < end; i2++) {
-        if (i2 !== idx && words[i2] && words[i2].length > 0) {
-          context.add(words[i2]);
-        }
-      }
-      from = idx + 1;
-      idx = words.indexOf(word, from);
-    }
-    return context;
-  }
-  const termLen = word.split(" ").length;
-  let i = 0;
-  while (i <= words.length - termLen) {
-    const slice = words.slice(i, i + termLen).join(" ");
-    if (slice === word) {
-      const start = Math.max(0, i - contextWindow);
-      const end = Math.min(words.length, i + termLen + contextWindow);
-      for (let j = start;j < end; j++) {
-        if (j < i || j >= i + termLen) {
-          if (words[j] && words[j].length > 0) {
-            context.add(words[j]);
-          }
-        }
-      }
-      i += termLen;
-    } else {
-      i += 1;
-    }
-  }
-  return context;
-}
-function hasSignificantOverlap(set1, set2) {
-  if (set1.size === 0 || set2.size === 0)
-    return false;
-  return [...set1].some((word) => set2.has(word));
-}
-function detectContradiction(candidate, existingLessons) {
-  const candidateTags = inferTags(candidate);
-  if (candidateTags.length === 0)
-    return false;
-  const candidateNorm = normalizeText(candidate);
-  for (const existing of existingLessons) {
-    const existingTags = inferTags(existing);
-    const shared = candidateTags.some((t) => existingTags.includes(t));
-    if (!shared)
-      continue;
-    const existingNorm = normalizeText(existing);
-    for (const [wordA, wordB] of NEGATION_PAIRS) {
-      if (candidateNorm.includes(wordA) && existingNorm.includes(wordB)) {
-        const contextA = extractContextWords(candidateNorm, wordA);
-        const contextB = extractContextWords(existingNorm, wordB);
-        if (hasSignificantOverlap(contextA, contextB)) {
-          return true;
-        }
-      }
-      if (candidateNorm.includes(wordB) && existingNorm.includes(wordA)) {
-        const contextB = extractContextWords(candidateNorm, wordB);
-        const contextA = extractContextWords(existingNorm, wordA);
-        if (hasSignificantOverlap(contextA, contextB)) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-function isVagueLesson(lesson) {
-  const lower = normalizeText(lesson);
-  const words = lower.split(/\s+/);
-  const hasTechRef = words.some((w) => TECH_REFERENCE_WORDS.has(w));
-  const hasActionVerb = words.some((w) => ACTION_VERB_WORDS.has(w));
-  return !hasTechRef && !hasActionVerb;
-}
-function validateLesson(candidate, existingLessons, meta) {
-  if (!candidate || typeof candidate !== "string") {
-    return {
-      valid: false,
-      layer: 1,
-      reason: "lesson too short (min 15 chars)",
-      severity: "error"
-    };
-  }
-  if (!Array.isArray(existingLessons)) {
-    existingLessons = [];
-  }
-  if (candidate.length < 15) {
-    return {
-      valid: false,
-      layer: 1,
-      reason: "lesson too short (min 15 chars)",
-      severity: "error"
-    };
-  }
-  if (candidate.length > 280) {
-    return {
-      valid: false,
-      layer: 1,
-      reason: "lesson too long (max 280 chars)",
-      severity: "error"
-    };
-  }
-  if (!VALID_CATEGORIES.has(meta.category)) {
-    return {
-      valid: false,
-      layer: 1,
-      reason: `invalid category: ${meta.category}`,
-      severity: "error"
-    };
-  }
-  const isGlobalScope = meta.scope === "global";
-  const isStackScope = /^stack:[a-zA-Z0-9_-]{1,64}$/.test(meta.scope);
-  if (!isGlobalScope && !isStackScope) {
-    return {
-      valid: false,
-      layer: 1,
-      reason: "invalid scope: must be 'global' or 'stack:<name>'",
-      severity: "error"
-    };
-  }
-  if (!(meta.confidence >= 0 && meta.confidence <= 1)) {
-    return {
-      valid: false,
-      layer: 1,
-      reason: "confidence out of range [0.0, 1.0]",
-      severity: "error"
-    };
-  }
-  const normalizedCandidate = candidate.normalize("NFKC").replace(INVISIBLE_FORMAT_CHARS, " ").replace(/\s+/g, " ").toLowerCase();
-  for (const pattern of DANGEROUS_COMMAND_ERROR_PATTERNS) {
-    if (pattern.test(normalizedCandidate)) {
-      return {
-        valid: false,
-        layer: 2,
-        reason: "dangerous command pattern detected",
-        severity: "error"
-      };
-    }
-  }
-  for (const pattern of DANGEROUS_COMMAND_WARNING_PATTERNS) {
-    if (pattern.test(normalizedCandidate)) {
-      return {
-        valid: true,
-        layer: 2,
-        reason: "potentially dangerous command pattern queued for review",
-        severity: "warning"
-      };
-    }
-  }
-  for (const pattern of SECURITY_DEGRADING_PATTERNS) {
-    if (pattern.test(normalizedCandidate)) {
-      return {
-        valid: false,
-        layer: 2,
-        reason: "security-degrading instruction detected",
-        severity: "error"
-      };
-    }
-  }
-  for (const pattern of INJECTION_PATTERNS) {
-    if (pattern.test(candidate)) {
-      return {
-        valid: false,
-        layer: 2,
-        reason: "injection pattern detected",
-        severity: "error"
-      };
-    }
-  }
-  if (detectContradiction(candidate, existingLessons)) {
-    return {
-      valid: true,
-      layer: 3,
-      reason: "possible contradiction with an existing lesson with shared tags",
-      severity: "warning"
-    };
-  }
-  if (isVagueLesson(candidate)) {
-    return {
-      valid: true,
-      layer: 3,
-      reason: "lesson may be too vague (no tech reference or action verb)",
-      severity: "warning"
-    };
-  }
-  return {
-    valid: true,
-    layer: null,
-    reason: null,
-    severity: null
-  };
-}
-var ACTIONABLE_STRING_MAX = 200;
-var ACTIONABLE_LIST_MAX = 20;
-var NAME_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;
-var SOURCE_REF_FORBIDDEN = /(\.\.\/|\.\.\\|\0|[\x00-\x1f\x7f])/;
-var ALLOWED_SKILL_PATH_PREFIXES = [
-  ".opencode/skills/generated/",
-  ".swarm/skills/proposals/",
-  ".swarm/skills/candidates/"
-];
-var VALID_DIRECTIVE_PRIORITIES = new Set([
-  "low",
-  "medium",
-  "high",
-  "critical"
-]);
-function isCleanShortString(s) {
-  if (typeof s !== "string")
-    return false;
-  if (s.length === 0 || s.length > ACTIONABLE_STRING_MAX)
-    return false;
-  return !/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]/.test(s);
-}
-function validateSkillPath(p) {
-  if (typeof p !== "string")
-    return false;
-  if (p.length === 0 || p.length > 256)
-    return false;
-  if (p.includes("\x00"))
-    return false;
-  if (path2.isAbsolute(p))
-    return false;
-  if (p.includes(".."))
-    return false;
-  const norm = p.replace(/\\/g, "/");
-  return ALLOWED_SKILL_PATH_PREFIXES.some((prefix) => norm.startsWith(prefix));
-}
-function validateActionableFields(fields) {
-  const errors = [];
-  if (!fields)
-    return { valid: true, errors };
-  function checkStringList(name, list) {
-    if (list === undefined)
-      return;
-    if (!Array.isArray(list)) {
-      errors.push(`${name} must be an array`);
-      return;
-    }
-    if (list.length > ACTIONABLE_LIST_MAX) {
-      errors.push(`${name} exceeds ${ACTIONABLE_LIST_MAX} items`);
-    }
-    for (const item of list) {
-      if (!isCleanShortString(item)) {
-        errors.push(`${name} contains invalid string`);
-        return;
-      }
-    }
-  }
-  function checkNameList(name, list) {
-    if (list === undefined)
-      return;
-    if (!Array.isArray(list)) {
-      errors.push(`${name} must be an array`);
-      return;
-    }
-    if (list.length > ACTIONABLE_LIST_MAX) {
-      errors.push(`${name} exceeds ${ACTIONABLE_LIST_MAX} items`);
-    }
-    for (const item of list) {
-      if (typeof item !== "string" || !NAME_PATTERN.test(item)) {
-        errors.push(`${name} contains invalid name`);
-        return;
-      }
-    }
-  }
-  checkStringList("triggers", fields.triggers);
-  checkStringList("required_actions", fields.required_actions);
-  checkStringList("forbidden_actions", fields.forbidden_actions);
-  checkStringList("verification_checks", fields.verification_checks);
-  checkNameList("applies_to_agents", fields.applies_to_agents);
-  checkNameList("applies_to_tools", fields.applies_to_tools);
-  if (fields.source_refs !== undefined) {
-    if (!Array.isArray(fields.source_refs)) {
-      errors.push("source_refs must be an array");
-    } else if (fields.source_refs.length > ACTIONABLE_LIST_MAX) {
-      errors.push(`source_refs exceeds ${ACTIONABLE_LIST_MAX} items`);
-    } else {
-      for (const ref of fields.source_refs) {
-        if (typeof ref !== "string" || ref.length === 0 || ref.length > ACTIONABLE_STRING_MAX || SOURCE_REF_FORBIDDEN.test(ref)) {
-          errors.push("source_refs contains invalid value");
-          break;
-        }
-      }
-    }
-  }
-  if (fields.source_knowledge_ids !== undefined) {
-    if (!Array.isArray(fields.source_knowledge_ids)) {
-      errors.push("source_knowledge_ids must be an array");
-    } else {
-      for (const id of fields.source_knowledge_ids) {
-        if (typeof id !== "string" || id.length === 0 || id.length > 64) {
-          errors.push("source_knowledge_ids contains invalid value");
-          break;
-        }
-      }
-    }
-  }
-  if (fields.directive_priority !== undefined && !VALID_DIRECTIVE_PRIORITIES.has(String(fields.directive_priority))) {
-    errors.push("directive_priority must be low|medium|high|critical");
-  }
-  if (fields.generated_skill_slug !== undefined) {
-    if (typeof fields.generated_skill_slug !== "string" || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(fields.generated_skill_slug)) {
-      errors.push("generated_skill_slug must be a kebab-case slug");
-    }
-  }
-  if (fields.generated_skill_path !== undefined && !validateSkillPath(fields.generated_skill_path)) {
-    errors.push("generated_skill_path must be repo-local under allowed prefix");
-  }
-  return { valid: errors.length === 0, errors };
-}
-function hasNonEmptyList(v) {
-  return Array.isArray(v) && v.length > 0;
-}
-function validateActionability(entry) {
-  const hasPredicate = hasNonEmptyList(entry.forbidden_actions) || hasNonEmptyList(entry.required_actions) || hasNonEmptyList(entry.verification_checks) || typeof entry.verification_predicate === "string" && entry.verification_predicate.trim().length > 0;
-  const hasScope = hasNonEmptyList(entry.applies_to_tools) || hasNonEmptyList(entry.applies_to_agents);
-  if (hasPredicate && hasScope)
-    return { actionable: true };
-  const reason = !hasPredicate && !hasScope ? "missing_predicate_and_scope" : !hasPredicate ? "missing_predicate" : "missing_scope";
-  return { actionable: false, reason };
-}
-function resolveUnactionablePath(directory) {
-  return path2.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
-}
-async function appendUnactionable(directory, entry, reason) {
-  const filePath = resolveUnactionablePath(directory);
-  const dirPath = path2.dirname(filePath);
-  await mkdir2(dirPath, { recursive: true });
-  await transactKnowledge(filePath, (existing) => {
-    const record = {
-      ...entry,
-      status: "quarantined_unactionable",
-      unactionable_reason: reason,
-      quarantined_at: new Date().toISOString()
-    };
-    const duplicate = findNearDuplicate(record.lesson, existing, 0.6);
-    if (duplicate?.unactionable_reason === reason) {
-      duplicate.quarantined_at = record.quarantined_at;
-      duplicate.updated_at = record.updated_at;
-      return existing;
-    }
-    const next = [...existing, record];
-    return next.length > 200 ? next.slice(-200) : next;
-  });
-}
-async function quarantineEntry(directory, entryId, reason, reportedBy) {
-  if (!directory || directory.includes("..")) {
-    warn("[knowledge-validator] quarantineEntry: directory traversal attempt blocked");
-    return;
-  }
-  if (!entryId || entryId.includes("\x00") || entryId.includes(`
-`)) {
-    warn("[knowledge-validator] quarantineEntry: invalid entryId rejected");
-    return;
-  }
-  const validReportedBy = ["architect", "user", "auto"];
-  if (!validReportedBy.includes(reportedBy)) {
-    return;
-  }
-  const sanitizedReason = reason.slice(0, 500).replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f\x0d]/g, "");
-  const knowledgePath = resolveSwarmKnowledgePath(directory);
-  const quarantinePath = path2.join(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
-  const rejectedPath = resolveSwarmRejectedPath(directory);
-  const swarmDir = resolveKnowledgeStoreDir(directory);
-  await mkdir2(swarmDir, { recursive: true });
-  let release;
-  try {
-    release = await import_proper_lockfile2.default.lock(swarmDir, {
-      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
-      stale: 5000
-    });
-    const entries = await readKnowledge(knowledgePath);
-    const entry = entries.find((e) => e.id === entryId);
-    if (!entry) {
-      return;
-    }
-    const remaining = entries.filter((e) => e.id !== entryId);
-    const quarantined = {
-      ...entry,
-      status: "quarantined",
-      original_status: entry.status,
-      quarantine_reason: sanitizedReason,
-      quarantined_at: new Date().toISOString(),
-      reported_by: reportedBy
-    };
-    const jsonlContent = remaining.length > 0 ? `${remaining.map((e) => JSON.stringify(e)).join(`
-`)}
-` : "";
-    await atomicWriteFile(knowledgePath, jsonlContent);
-    await appendFile2(quarantinePath, `${JSON.stringify(quarantined)}
-`, "utf-8");
-    const quarantinedEntries = await readKnowledge(quarantinePath);
-    if (quarantinedEntries.length > 100) {
-      const trimmed = quarantinedEntries.slice(-100);
-      const capContent = trimmed.length > 0 ? `${trimmed.map((e) => JSON.stringify(e)).join(`
-`)}
-` : "";
-      await atomicWriteFile(quarantinePath, capContent);
-    }
-    const rejectedRecord = {
-      id: entryId,
-      lesson: entry.lesson,
-      rejection_reason: sanitizedReason,
-      rejected_at: new Date().toISOString(),
-      rejection_layer: 3
-    };
-    await appendFile2(rejectedPath, `${JSON.stringify(rejectedRecord)}
-`, "utf-8");
-  } finally {
-    if (release) {
-      await release();
-    }
-  }
-}
-async function restoreEntry(directory, entryId) {
-  if (!directory || directory.includes("..")) {
-    warn("[knowledge-validator] restoreEntry: directory traversal attempt blocked");
-    return;
-  }
-  if (!entryId || entryId.includes("\x00") || entryId.includes(`
-`)) {
-    warn("[knowledge-validator] restoreEntry: invalid entryId rejected");
-    return;
-  }
-  const storeDir = resolveKnowledgeStoreDir(directory);
-  const knowledgePath = resolveSwarmKnowledgePath(directory);
-  const quarantinePath = path2.join(storeDir, "knowledge-quarantined.jsonl");
-  const rejectedPath = resolveSwarmRejectedPath(directory);
-  const swarmDir = storeDir;
-  await mkdir2(swarmDir, { recursive: true });
-  let release;
-  try {
-    release = await import_proper_lockfile2.default.lock(swarmDir, {
-      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
-      stale: 5000
-    });
-    const quarantinedEntries = await readKnowledge(quarantinePath);
-    const entryToRestore = quarantinedEntries.find((e) => e.id === entryId);
-    if (!entryToRestore) {
-      return;
-    }
-    const remaining = quarantinedEntries.filter((e) => e.id !== entryId);
-    const {
-      quarantine_reason,
-      quarantined_at,
-      reported_by,
-      original_status,
-      status: _quarantineStatus,
-      ...rest
-    } = entryToRestore;
-    const original = { ...rest, status: original_status ?? "candidate" };
-    const validation = validateLesson(original.lesson, [], {
-      category: original.category,
-      scope: original.scope,
-      confidence: original.confidence
-    });
-    if (!validation.valid) {
-      warn(`[knowledge-validator] restoreEntry: entry ${entryId} failed re-validation: ${validation.reason}`);
-      return;
-    }
-    const jsonlContent = remaining.length > 0 ? `${remaining.map((e) => JSON.stringify(e)).join(`
-`)}
-` : "";
-    await atomicWriteFile(quarantinePath, jsonlContent);
-    await appendFile2(knowledgePath, `${JSON.stringify(original)}
-`, "utf-8");
-    const rejectedEntries = await readKnowledge(rejectedPath);
-    const filtered = rejectedEntries.filter((e) => e.id !== entryId);
-    const rejectedContent = filtered.length > 0 ? `${filtered.map((e) => JSON.stringify(e)).join(`
-`)}
-` : "";
-    await atomicWriteFile(rejectedPath, rejectedContent);
-  } finally {
-    if (release) {
-      await release();
-    }
-  }
-}
-
-// src/services/skill-generator.ts
+import { existsSync as existsSync2, unlinkSync } from "fs";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, unlink, writeFile as writeFile3 } from "fs/promises";
+import * as path3 from "path";
 init_logger();
 
 // src/services/skill-changelog.ts
 init_logger();
-import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile2, writeFile } from "fs/promises";
-import * as path3 from "path";
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import * as path from "path";
 var MAX_CHANGELOG_ENTRIES_PER_SKILL = 200;
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
     throw new Error(`Invalid skill slug: ${slug} \u2014 must not contain "..", "/" or "\\"`);
   }
-  return path3.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
+  return path.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
 }
 async function appendSkillChangelog(directory, slug, entry) {
   const filePath = resolveSkillChangelogPath(directory, slug);
-  const dirPath = path3.dirname(filePath);
-  await mkdir3(dirPath, { recursive: true });
-  await appendFile3(filePath, `${JSON.stringify(entry)}
+  const dirPath = path.dirname(filePath);
+  await mkdir(dirPath, { recursive: true });
+  await appendFile(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
   try {
-    const content = await readFile2(filePath, "utf-8");
+    const content = await readFile(filePath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     if (lines.length > MAX_CHANGELOG_ENTRIES_PER_SKILL) {
@@ -966,18 +62,18 @@ async function appendSkillChangelog(directory, slug, entry) {
 
 // src/services/skill-evaluator.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import {
   lstat,
-  mkdir as mkdir4,
+  mkdir as mkdir2,
   readdir,
-  readFile as readFile3,
+  readFile as readFile2,
   realpath,
   rename,
-  stat as stat2,
+  stat,
   writeFile as writeFile2
 } from "fs/promises";
-import * as path4 from "path";
+import * as path2 from "path";
 var SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 var MAX_EVAL_FILES = 50;
 var MAX_EVAL_FILE_BYTES = 64 * 1024;
@@ -1043,15 +139,15 @@ function casesFromParsedJson(parsed, fileLabel) {
   return cases;
 }
 function evalRoot(directory, slug) {
-  return path4.join(directory, ".swarm", "skills", "evals", slug);
+  return path2.join(directory, ".swarm", "skills", "evals", slug);
 }
 function isInsidePath(root, target) {
-  const resolvedRoot = path4.resolve(root);
-  const resolvedTarget = path4.resolve(target);
-  return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path4.sep);
+  const resolvedRoot = path2.resolve(root);
+  const resolvedTarget = path2.resolve(target);
+  return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path2.sep);
 }
 function rejectedEditsPath(directory) {
-  return path4.join(directory, ".swarm", "skills", "rejected-edits.jsonl");
+  return path2.join(directory, ".swarm", "skills", "rejected-edits.jsonl");
 }
 async function loadEvalSet(directory, slug) {
   if (!isValidSlug(slug)) {
@@ -1063,7 +159,7 @@ async function loadEvalSet(directory, slug) {
     };
   }
   const root = evalRoot(directory, slug);
-  if (!existsSync2(root)) {
+  if (!existsSync(root)) {
     return { status: "missing", files: [], cases: [] };
   }
   let realRoot;
@@ -1104,9 +200,9 @@ async function loadEvalSet(directory, slug) {
   const cases = [];
   const fileLabels = [];
   for (const file of files) {
-    const fullPath = path4.join(root, file);
-    const resolved = path4.resolve(fullPath);
-    const resolvedRoot = path4.resolve(root);
+    const fullPath = path2.join(root, file);
+    const resolved = path2.resolve(fullPath);
+    const resolvedRoot = path2.resolve(root);
     if (!isInsidePath(resolvedRoot, resolved)) {
       return {
         status: "invalid",
@@ -1130,7 +226,7 @@ async function loadEvalSet(directory, slug) {
           };
         }
         readPath = realFile;
-        info = await stat2(realFile);
+        info = await stat(realFile);
       } else {
         if (!linkInfo.isFile())
           continue;
@@ -1156,7 +252,7 @@ async function loadEvalSet(directory, slug) {
     }
     let parsed;
     try {
-      parsed = JSON.parse(await readFile3(readPath, "utf-8"));
+      parsed = JSON.parse(await readFile2(readPath, "utf-8"));
     } catch (err) {
       return {
         status: "invalid",
@@ -1165,7 +261,7 @@ async function loadEvalSet(directory, slug) {
         reason: `eval file invalid JSON: ${file}: ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    fileLabels.push(path4.relative(directory, fullPath).replace(/\\/g, "/"));
+    fileLabels.push(path2.relative(directory, fullPath).replace(/\\/g, "/"));
     cases.push(...casesFromParsedJson(parsed, file));
     if (cases.length >= MAX_EVAL_CASES)
       break;
@@ -1283,7 +379,7 @@ async function evaluateSkillChange(req) {
   };
 }
 async function atomicWrite(filePath, content) {
-  await mkdir4(path4.dirname(filePath), { recursive: true });
+  await mkdir2(path2.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile2(tmp, content, "utf-8");
   await rename(tmp, filePath);
@@ -1306,7 +402,7 @@ async function appendRejectedSkillEdit(req, evaluation) {
   };
   let prior = [];
   try {
-    prior = (await readFile3(filePath, "utf-8")).split(/\r?\n/).filter((line) => line.trim().length > 0);
+    prior = (await readFile2(filePath, "utf-8")).split(/\r?\n/).filter((line) => line.trim().length > 0);
   } catch {
     prior = [];
   }
@@ -1323,7 +419,7 @@ async function isRejectedSkillContent(directory, slug, content) {
   const normalizedHash = hashNormalizedContent(content);
   let raw = "";
   try {
-    raw = await readFile3(rejectedEditsPath(directory), "utf-8");
+    raw = await readFile2(rejectedEditsPath(directory), "utf-8");
   } catch {
     return false;
   }
@@ -1360,10 +456,10 @@ function isValidSlug2(slug) {
   return SLUG_PATTERN2.test(slug);
 }
 function proposalPath(directory, slug) {
-  return path5.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
+  return path3.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
 }
 function activePath(directory, slug) {
-  return path5.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
+  return path3.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
 }
 function activeRepoRelativePath(slug) {
   return `.opencode/skills/generated/${slug}/SKILL.md`;
@@ -1375,7 +471,7 @@ var HIGH_PRIORITY_SKILL_MIN_CONFIDENCE = 0.6;
 async function selectCandidateEntries(directory, opts) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync3(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync2(hivePath) ? await readKnowledge(hivePath) : [];
   const all = [...swarm, ...hive];
   const counterRollups = await readKnowledgeCounterRollups(directory);
   const selected = [];
@@ -1588,7 +684,7 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite2(p, content) {
-  await mkdir5(path5.dirname(p), { recursive: true });
+  await mkdir3(path3.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile3(tmp, content, "utf-8");
   await rename2(tmp, p);
@@ -1605,7 +701,7 @@ async function generateSkills(req) {
     const idSet = new Set(req.sourceKnowledgeIds);
     const swarm = await readKnowledge(resolveSwarmKnowledgePath(req.directory));
     const hivePath = resolveHiveKnowledgePath();
-    const hive = existsSync3(hivePath) ? await readKnowledge(hivePath) : [];
+    const hive = existsSync2(hivePath) ? await readKnowledge(hivePath) : [];
     const rollups = await readKnowledgeCounterRollups(req.directory);
     pool = [...swarm, ...hive].filter((e) => idSet.has(e.id) && e.status !== "archived").map((e) => ({
       ...e,
@@ -1637,7 +733,7 @@ async function generateSkills(req) {
       continue;
     }
     const targetPath = req.mode === "active" ? activePath(req.directory, cluster.slug) : proposalPath(req.directory, cluster.slug);
-    const repoRel = path5.relative(req.directory, targetPath).replace(/\\/g, "/");
+    const repoRel = path3.relative(req.directory, targetPath).replace(/\\/g, "/");
     if (!validateSkillPath(repoRel)) {
       result.skipped.push({
         slug: cluster.slug,
@@ -1646,8 +742,8 @@ async function generateSkills(req) {
       continue;
     }
     let preserved = false;
-    if (req.mode === "active" && existsSync3(targetPath) && !req.force) {
-      const existing = await readFile4(targetPath, "utf-8");
+    if (req.mode === "active" && existsSync2(targetPath) && !req.force) {
+      const existing = await readFile3(targetPath, "utf-8");
       if (!existing.includes("generated by opencode-swarm skill-generator")) {
         preserved = true;
         result.skipped.push({
@@ -1669,9 +765,9 @@ async function generateSkills(req) {
     if (req.evaluate) {
       let incumbentContent;
       const existingActivePath = activePath(req.directory, cluster.slug);
-      if (existsSync3(existingActivePath)) {
+      if (existsSync2(existingActivePath)) {
         try {
-          incumbentContent = await readFile4(existingActivePath, "utf-8");
+          incumbentContent = await readFile3(existingActivePath, "utf-8");
         } catch {
           incumbentContent = undefined;
         }
@@ -1791,7 +887,7 @@ async function stampSourceEntries(directory, slug, ids) {
     await rewriteKnowledge(swarmPath, swarm);
   stamped.push(...found);
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync3(hivePath)) {
+  if (!existsSync2(hivePath)) {
     for (const id of ids) {
       if (!found.has(id))
         missing.push(id);
@@ -1936,7 +1032,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   }
   const from = proposalPath(directory, cleanSlug);
   const to = activePath(directory, cleanSlug);
-  if (!existsSync3(from)) {
+  if (!existsSync2(from)) {
     return {
       activated: false,
       from,
@@ -1944,8 +1040,8 @@ async function activateProposal(directory, slug, force = false, options = {}) {
       reason: `proposal not found: ${from}`
     };
   }
-  if (existsSync3(to) && !force) {
-    const existing = await readFile4(to, "utf-8");
+  if (existsSync2(to) && !force) {
+    const existing = await readFile3(to, "utf-8");
     if (!existing.includes("generated by opencode-swarm skill-generator")) {
       return {
         activated: false,
@@ -1957,7 +1053,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   }
   let proposalContent;
   try {
-    proposalContent = await readFile4(from, "utf-8");
+    proposalContent = await readFile3(from, "utf-8");
   } catch (readErr) {
     return {
       activated: false,
@@ -1978,9 +1074,9 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   let evaluation;
   if (options.evaluate) {
     let incumbentContent;
-    if (existsSync3(to)) {
+    if (existsSync2(to)) {
       try {
-        incumbentContent = await readFile4(to, "utf-8");
+        incumbentContent = await readFile3(to, "utf-8");
       } catch {
         incumbentContent = undefined;
       }
@@ -2046,24 +1142,24 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   }
 }
 async function findSkillsBySourceKnowledgeId(directory, sourceId) {
-  const activeDir = path5.join(directory, ".opencode", "skills", "generated");
+  const activeDir = path3.join(directory, ".opencode", "skills", "generated");
   const fs = await import("fs/promises");
-  if (!existsSync3(activeDir))
+  if (!existsSync2(activeDir))
     return [];
   const entries = await fs.readdir(activeDir, { withFileTypes: true });
   const matches = [];
   for (const e of entries) {
     if (!e.isDirectory())
       continue;
-    const skillDir = path5.join(activeDir, e.name);
-    const retiredMarker = path5.join(skillDir, "retired.marker");
-    if (existsSync3(retiredMarker))
+    const skillDir = path3.join(activeDir, e.name);
+    const retiredMarker = path3.join(skillDir, "retired.marker");
+    if (existsSync2(retiredMarker))
       continue;
-    const staleMarker = path5.join(skillDir, "stale.marker");
-    if (existsSync3(staleMarker))
+    const staleMarker = path3.join(skillDir, "stale.marker");
+    if (existsSync2(staleMarker))
       continue;
-    const skillPath = path5.join(skillDir, "SKILL.md");
-    if (!existsSync3(skillPath))
+    const skillPath = path3.join(skillDir, "SKILL.md");
+    if (!existsSync2(skillPath))
       continue;
     let content;
     try {
@@ -2079,8 +1175,8 @@ async function findSkillsBySourceKnowledgeId(directory, sourceId) {
   return matches;
 }
 async function findStaleSkillsBySourceKnowledgeId(directory, archivedIds) {
-  const activeDir = path5.join(directory, ".opencode", "skills", "generated");
-  if (!existsSync3(activeDir))
+  const activeDir = path3.join(directory, ".opencode", "skills", "generated");
+  if (!existsSync2(activeDir))
     return [];
   const fs = await import("fs/promises");
   const entries = await fs.readdir(activeDir, { withFileTypes: true });
@@ -2088,15 +1184,15 @@ async function findStaleSkillsBySourceKnowledgeId(directory, archivedIds) {
   for (const e of entries) {
     if (!e.isDirectory())
       continue;
-    const skillDir = path5.join(activeDir, e.name);
-    const retiredMarker = path5.join(skillDir, "retired.marker");
-    if (existsSync3(retiredMarker))
+    const skillDir = path3.join(activeDir, e.name);
+    const retiredMarker = path3.join(skillDir, "retired.marker");
+    if (existsSync2(retiredMarker))
       continue;
-    const staleMarker = path5.join(skillDir, "stale.marker");
-    if (!existsSync3(staleMarker))
+    const staleMarker = path3.join(skillDir, "stale.marker");
+    if (!existsSync2(staleMarker))
       continue;
-    const skillPath = path5.join(skillDir, "SKILL.md");
-    if (!existsSync3(skillPath))
+    const skillPath = path3.join(skillDir, "SKILL.md");
+    if (!existsSync2(skillPath))
       continue;
     let content;
     try {
@@ -2121,10 +1217,10 @@ async function listSkills(directory) {
     active: [],
     stale: []
   };
-  const proposalsDir = path5.join(directory, ".swarm", "skills", "proposals");
-  const activeDir = path5.join(directory, ".opencode", "skills", "generated");
+  const proposalsDir = path3.join(directory, ".swarm", "skills", "proposals");
+  const activeDir = path3.join(directory, ".opencode", "skills", "generated");
   const fs = await import("fs/promises");
-  if (existsSync3(proposalsDir)) {
+  if (existsSync2(proposalsDir)) {
     const entries = await fs.readdir(proposalsDir);
     for (const f of entries) {
       if (!f.endsWith(".md"))
@@ -2132,20 +1228,20 @@ async function listSkills(directory) {
       const slug = f.replace(/\.md$/, "");
       result.proposals.push({
         slug,
-        path: path5.join(proposalsDir, f)
+        path: path3.join(proposalsDir, f)
       });
     }
   }
-  if (existsSync3(activeDir)) {
+  if (existsSync2(activeDir)) {
     const entries = await fs.readdir(activeDir, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
-      const retiredMarker = path5.join(activeDir, e.name, "retired.marker");
-      if (existsSync3(retiredMarker))
+      const retiredMarker = path3.join(activeDir, e.name, "retired.marker");
+      if (existsSync2(retiredMarker))
         continue;
-      const staleMarker = path5.join(activeDir, e.name, "stale.marker");
-      if (existsSync3(staleMarker)) {
+      const staleMarker = path3.join(activeDir, e.name, "stale.marker");
+      if (existsSync2(staleMarker)) {
         let reason = "stale";
         try {
           const content = await fs.readFile(staleMarker, "utf-8");
@@ -2154,8 +1250,8 @@ async function listSkills(directory) {
         result.stale.push({ slug: e.name, reason });
         continue;
       }
-      const skillPath = path5.join(activeDir, e.name, "SKILL.md");
-      if (existsSync3(skillPath)) {
+      const skillPath = path3.join(activeDir, e.name, "SKILL.md");
+      if (existsSync2(skillPath)) {
         result.active.push({
           slug: e.name,
           path: skillPath
@@ -2179,7 +1275,7 @@ async function autoApplyProposals(directory, llmDelegate) {
     }
     let content;
     try {
-      content = await readFile4(proposal.path, "utf-8");
+      content = await readFile3(proposal.path, "utf-8");
     } catch {
       result.skipped.push(proposal.slug);
       continue;
@@ -2238,14 +1334,14 @@ async function inspectSkill(directory, slug, prefer = "auto") {
   if (prefer === "proposal" || prefer === "auto")
     candidates.push({ p: proposalPath(directory, cleanSlug), m: "draft" });
   for (const c of candidates) {
-    if (existsSync3(c.p)) {
-      const content = await readFile4(c.p, "utf-8");
+    if (existsSync2(c.p)) {
+      const content = await readFile3(c.p, "utf-8");
       const result = { found: true, path: c.p, content, mode: c.m };
       const fm = parseDraftFrontmatter(content);
       if (fm && fm.sourceKnowledgeIds.length > 0) {
         const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
         const hivePath = resolveHiveKnowledgePath();
-        const hive = existsSync3(hivePath) ? await readKnowledge(hivePath) : [];
+        const hive = existsSync2(hivePath) ? await readKnowledge(hivePath) : [];
         const allEntries = [...swarm, ...hive];
         const entryMap = new Map(allEntries.map((e) => [e.id, e]));
         result.source_knowledge_status = fm.sourceKnowledgeIds.map((id) => {
@@ -2259,11 +1355,11 @@ async function inspectSkill(directory, slug, prefer = "auto") {
         });
       }
       if (c.m === "active") {
-        const skillDir = path5.join(directory, ".opencode", "skills", "generated", cleanSlug);
-        const staleMarker = path5.join(skillDir, "stale.marker");
-        if (existsSync3(staleMarker)) {
+        const skillDir = path3.join(directory, ".opencode", "skills", "generated", cleanSlug);
+        const staleMarker = path3.join(skillDir, "stale.marker");
+        if (existsSync2(staleMarker)) {
           try {
-            result.stale_reason = await readFile4(staleMarker, "utf-8");
+            result.stale_reason = await readFile3(staleMarker, "utf-8");
           } catch {}
         }
       }
@@ -2278,26 +1374,26 @@ async function retireSkill(directory, slug, reason) {
     return {
       retired: false,
       path: activePath(directory, cleanSlug),
-      markerPath: path5.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
+      markerPath: path3.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
       reason: "invalid slug"
     };
   }
   const skillPath = activePath(directory, cleanSlug);
-  if (!existsSync3(skillPath)) {
+  if (!existsSync2(skillPath)) {
     return {
       retired: false,
       path: skillPath,
-      markerPath: path5.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
+      markerPath: path3.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
       reason: "active skill not found"
     };
   }
-  const markerDir = path5.join(directory, ".opencode", "skills", "generated", cleanSlug);
-  const markerPath = path5.join(markerDir, "retired.marker");
+  const markerDir = path3.join(directory, ".opencode", "skills", "generated", cleanSlug);
+  const markerPath = path3.join(markerDir, "retired.marker");
   const markerContent = JSON.stringify({
     retiredAt: new Date().toISOString(),
     reason: reason ?? "manual_retire"
   });
-  await mkdir5(markerDir, { recursive: true });
+  await mkdir3(markerDir, { recursive: true });
   await writeFile3(markerPath, markerContent, "utf-8");
   return {
     retired: true,
@@ -2307,11 +1403,11 @@ async function retireSkill(directory, slug, reason) {
   };
 }
 async function markSkillStale(skillDir, reason) {
-  await mkdir5(skillDir, { recursive: true });
-  await writeFile3(path5.join(skillDir, "stale.marker"), reason, "utf-8");
+  await mkdir3(skillDir, { recursive: true });
+  await writeFile3(path3.join(skillDir, "stale.marker"), reason, "utf-8");
 }
 async function clearSkillStale(skillDir) {
-  const markerPath = path5.join(skillDir, "stale.marker");
+  const markerPath = path3.join(skillDir, "stale.marker");
   try {
     await unlink(markerPath);
   } catch (err) {
@@ -2323,10 +1419,10 @@ async function clearSkillStale(skillDir) {
 }
 async function retireOrMarkStale(directory, skillDir, archivedKnowledgeIds) {
   const fs = await import("fs/promises");
-  const skillPath = path5.join(skillDir, "SKILL.md");
-  if (!existsSync3(skillPath)) {
+  const skillPath = path3.join(skillDir, "SKILL.md");
+  if (!existsSync2(skillPath)) {
     await markSkillStale(skillDir, "source knowledge archived, SKILL.md missing");
-    const slug2 = path5.basename(skillDir);
+    const slug2 = path3.basename(skillDir);
     return { action: "stale", slug: slug2, skillDir };
   }
   let content;
@@ -2334,18 +1430,18 @@ async function retireOrMarkStale(directory, skillDir, archivedKnowledgeIds) {
     content = await fs.readFile(skillPath, "utf-8");
   } catch {
     await markSkillStale(skillDir, "source knowledge archived, SKILL.md unreadable");
-    const slug2 = path5.basename(skillDir);
+    const slug2 = path3.basename(skillDir);
     return { action: "stale", slug: slug2, skillDir };
   }
   const fm = parseDraftFrontmatter(content);
   const sourceIds = fm?.sourceKnowledgeIds ?? [];
   if (sourceIds.length === 0) {
     await markSkillStale(skillDir, "source knowledge archived, no source_knowledge_ids in frontmatter");
-    const slug2 = path5.basename(skillDir);
+    const slug2 = path3.basename(skillDir);
     return { action: "stale", slug: slug2, skillDir };
   }
   const allArchived = sourceIds.every((id) => archivedKnowledgeIds.has(id));
-  const slug = path5.basename(skillDir);
+  const slug = path3.basename(skillDir);
   if (allArchived) {
     await retireSkill(directory, slug, "all source knowledge entries archived or deleted");
     return { action: "retire", slug, skillDir };
@@ -2365,7 +1461,7 @@ async function regenerateSkill(directory, slug, options = {}) {
     };
   }
   const skillPath = activePath(directory, cleanSlug);
-  if (!existsSync3(skillPath)) {
+  if (!existsSync2(skillPath)) {
     return {
       regenerated: false,
       path: skillPath,
@@ -2375,7 +1471,7 @@ async function regenerateSkill(directory, slug, options = {}) {
   }
   let existingContent;
   try {
-    existingContent = await readFile4(skillPath, "utf-8");
+    existingContent = await readFile3(skillPath, "utf-8");
   } catch (err) {
     return {
       regenerated: false,
@@ -2390,7 +1486,7 @@ async function regenerateSkill(directory, slug, options = {}) {
     try {
       const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
       const hivePath = resolveHiveKnowledgePath();
-      const hive = existsSync3(hivePath) ? await readKnowledge(hivePath) : [];
+      const hive = existsSync2(hivePath) ? await readKnowledge(hivePath) : [];
       const all = [...swarm, ...hive];
       const idSet = new Set(fm.sourceKnowledgeIds);
       matchedEntries = all.filter((e) => idSet.has(e.id));
@@ -2513,7 +1609,7 @@ async function regenerateSkill(directory, slug, options = {}) {
   try {
     await atomicWrite2(skillPath, content);
     await stampSourceEntries(directory, cleanSlug, matchedEntries.map((e) => e.id));
-    await clearSkillStale(path5.dirname(activePath(directory, cleanSlug)));
+    await clearSkillStale(path3.dirname(activePath(directory, cleanSlug)));
   } catch (writeErr) {
     return {
       regenerated: false,
@@ -2561,4 +1657,4 @@ var _internals = {
   unlinkSync
 };
 
-export { resolveKnowledgeEventsPath, readKnowledgeEvents, readKnowledgeCounterRollups, effectiveRetrievalOutcomes, validateLesson, validateActionableFields, validateActionability, resolveUnactionablePath, appendUnactionable, quarantineEntry, restoreEntry, appendSkillChangelog, evaluateSkillChange, appendRejectedSkillEdit, sanitizeSlug, isValidSlug2 as isValidSlug, proposalPath, activePath, activeRepoRelativePath, DEFAULT_SKILL_MIN_CONFIDENCE, DEFAULT_SKILL_MIN_CONFIRMATIONS, STRONG_SKILL_OUTCOME_COUNT, HIGH_PRIORITY_SKILL_MIN_CONFIDENCE, selectCandidateEntries, isSkillMaturityEligible, clusterEntries, renderSkillMarkdown, generateSkills, parseDraftFrontmatter, activateProposal, findSkillsBySourceKnowledgeId, findStaleSkillsBySourceKnowledgeId, listSkills, autoApplyProposals, inspectSkill, retireSkill, markSkillStale, clearSkillStale, retireOrMarkStale, regenerateSkill, _internals };
+export { appendSkillChangelog, evaluateSkillChange, appendRejectedSkillEdit, sanitizeSlug, isValidSlug2 as isValidSlug, proposalPath, activePath, activeRepoRelativePath, DEFAULT_SKILL_MIN_CONFIDENCE, DEFAULT_SKILL_MIN_CONFIRMATIONS, STRONG_SKILL_OUTCOME_COUNT, HIGH_PRIORITY_SKILL_MIN_CONFIDENCE, selectCandidateEntries, isSkillMaturityEligible, clusterEntries, renderSkillMarkdown, generateSkills, parseDraftFrontmatter, activateProposal, findSkillsBySourceKnowledgeId, findStaleSkillsBySourceKnowledgeId, listSkills, autoApplyProposals, inspectSkill, retireSkill, markSkillStale, clearSkillStale, retireOrMarkStale, regenerateSkill, _internals };