opencode-swarm 7.107.2 → 7.107.4

package/dist/cli/index-dfdg4ws5.js

@@ -0,0 +1,741 @@
+// @bun
+import {
+  findNearDuplicate,
+  inferTags,
+  readKnowledge,
+  resolveSwarmKnowledgePath,
+  resolveSwarmRejectedPath,
+  transactKnowledge
+} from "./index-xmarctsf.js";
+import {
+  resolveKnowledgeStoreDir
+} from "./index-n1sptn1w.js";
+import {
+  atomicWriteFile
+} from "./index-9b7qp18e.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
+import {
+  require_proper_lockfile
+} from "./index-3naa2ajc.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/hooks/knowledge-validator.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { appendFile, mkdir } from "fs/promises";
+import * as path 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 (path.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 validateSkillCandidatePath(p) {
+  if (typeof p !== "string")
+    return false;
+  if (p.length === 0 || p.length > 256)
+    return false;
+  if (p.includes("\x00"))
+    return false;
+  if (path.isAbsolute(p))
+    return false;
+  if (p.includes(".."))
+    return false;
+  const norm = p.replace(/\\/g, "/");
+  if (!norm.startsWith(".swarm/skills/candidates/"))
+    return false;
+  const filename = norm.slice(".swarm/skills/candidates/".length);
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.json$/i.test(filename);
+}
+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 path.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
+}
+async function appendUnactionable(directory, entry, reason) {
+  const filePath = resolveUnactionablePath(directory);
+  const dirPath = path.dirname(filePath);
+  await mkdir(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;
+  });
+}
+function auditEntryHealth(entry) {
+  const utilityScore = entry.utility_score;
+  const ro = entry.retrieval_outcomes;
+  const shownCount = ro?.shown_count ?? entry.retrieval_outcomes?.applied_count ?? 0;
+  if (shownCount >= 5 && utilityScore !== undefined && utilityScore <= 0) {
+    return { healthy: false, concern: "Low-utility entry" };
+  }
+  if (entry.confidence < 0.1) {
+    return { healthy: false, concern: "Near-zero confidence" };
+  }
+  if (entry.auto_generated === true && entry.confirmed_by.length === 0) {
+    return { healthy: false, concern: "Unconfirmed auto-generated" };
+  }
+  return { healthy: true };
+}
+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 = path.join(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
+  const rejectedPath = resolveSwarmRejectedPath(directory);
+  const swarmDir = resolveKnowledgeStoreDir(directory);
+  await mkdir(swarmDir, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.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 appendFile(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 appendFile(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 = path.join(storeDir, "knowledge-quarantined.jsonl");
+  const rejectedPath = resolveSwarmRejectedPath(directory);
+  const swarmDir = storeDir;
+  await mkdir(swarmDir, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.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 appendFile(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();
+    }
+  }
+}
+async function unarchiveEntry(directory, entryId) {
+  if (!directory || directory.includes("..")) {
+    warn("[knowledge-validator] unarchiveEntry: directory traversal attempt blocked");
+    return { restored: false, reason: "not_found" };
+  }
+  if (!entryId || entryId.includes("\x00") || entryId.includes(`
+`)) {
+    warn("[knowledge-validator] unarchiveEntry: invalid entryId rejected");
+    return { restored: false, reason: "not_found" };
+  }
+  const storeDir = resolveKnowledgeStoreDir(directory);
+  const knowledgePath = resolveSwarmKnowledgePath(directory);
+  const swarmDir = storeDir;
+  await mkdir(swarmDir, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(swarmDir, {
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
+      stale: 5000
+    });
+    const entries = await readKnowledge(knowledgePath);
+    const target = entries.find((e) => e.id === entryId);
+    if (!target) {
+      return { restored: false, reason: "not_found" };
+    }
+    if (target.status !== "archived") {
+      return { restored: false, reason: "not_archived" };
+    }
+    const validation = validateLesson(target.lesson, [], {
+      category: target.category,
+      scope: target.scope,
+      confidence: target.confidence
+    });
+    if (!validation.valid) {
+      warn(`[knowledge-validator] unarchiveEntry: entry ${entryId} failed re-validation: ${validation.reason}`);
+      return { restored: false, reason: "invalid_lesson" };
+    }
+    const restoredStatus = target.archived_from ?? "candidate";
+    const validRestoreTargets = new Set([
+      "candidate",
+      "established",
+      "promoted"
+    ]);
+    const finalStatus = validRestoreTargets.has(restoredStatus) ? restoredStatus : "candidate";
+    const {
+      archived_from: _af,
+      archived_at: _at,
+      recent_negative_phase_count: _rnpc,
+      last_demotion_phase: _ldp,
+      ...rest
+    } = target;
+    const restored = {
+      ...rest,
+      status: finalStatus,
+      updated_at: new Date().toISOString(),
+      recent_negative_phase_count: 0,
+      last_demotion_phase: undefined
+    };
+    const next = entries.map((e) => e.id === entryId ? restored : e);
+    const jsonlContent = next.length > 0 ? `${next.map((e) => JSON.stringify(e)).join(`
+`)}
+` : "";
+    await atomicWriteFile(knowledgePath, jsonlContent);
+    return { restored: true, restored_to: finalStatus };
+  } finally {
+    if (release) {
+      await release();
+    }
+  }
+}
+var _internals = {
+  validateLesson,
+  auditEntryHealth,
+  quarantineEntry,
+  restoreEntry,
+  unarchiveEntry,
+  extractContextWords,
+  hasSignificantOverlap
+};
+
+export { DANGEROUS_COMMAND_ERROR_PATTERNS, DANGEROUS_COMMAND_WARNING_PATTERNS, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, validateLesson, ACTIONABLE_STRING_MAX, ACTIONABLE_LIST_MAX, ALLOWED_SKILL_PATH_PREFIXES, validateSkillPath, validateSkillCandidatePath, validateActionableFields, validateActionability, resolveUnactionablePath, appendUnactionable, auditEntryHealth, quarantineEntry, restoreEntry, unarchiveEntry, _internals };