bilmem 0.1.0 → 0.2.0

package/dist/core/index.js

@@ -316,7 +316,7 @@ function createKnowledge(params) {
     type: params.type ?? "lesson",
     status,
     stage: initialStage,
-    statement: params.statement.trim(),
+    statement: (params.statement ?? params.question ?? params.id).trim(),
     positive: Array.from(new Set(params.positive?.map((p) => p.trim().toLowerCase()) ?? [])),
     negative: Array.from(new Set(params.negative?.map((n) => n.trim().toLowerCase()) ?? [])),
     relations: Array.from(new Set(params.relations?.map((r) => r.trim()) ?? [])),
@@ -346,6 +346,11 @@ function createKnowledge(params) {
     },
     history,
     value: 0,
+    lesson: params.lesson,
+    failure_details: params.failure_details,
+    context: params.context,
+    contradicts: params.contradicts ? Array.from(new Set(params.contradicts)) : void 0,
+    blocking: params.blocking,
     createdAt: now,
     updatedAt: now
   };
@@ -1599,6 +1604,7 @@ var Retriever = class {
 // src/core/resolver.ts
 var RELATIVE_COSTS = {
   USE_KNOWLEDGE: 1,
+  REVALIDATE: 2,
   INSPECT_TEST: 2,
   INSPECT_FILE: 2,
   INSPECT_SYMBOL: 2.5,
@@ -1938,6 +1944,616 @@ async function resolveEpistemicQuery(options, storage, retriever) {
     receiptId
   };
 }
+
+// src/core/preflight.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import * as path from "path";
+import * as fs from "fs/promises";
+import YAML from "yaml";
+var execFileAsync = promisify(execFile);
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "add",
+  "implement",
+  "create",
+  "support",
+  "with",
+  "the",
+  "a",
+  "an",
+  "for",
+  "in",
+  "to",
+  "and",
+  "of",
+  "on",
+  "from",
+  "using",
+  "via",
+  "into",
+  "by",
+  "our",
+  "new",
+  "use",
+  "make",
+  "allow",
+  "enable",
+  "provide",
+  "setup",
+  "set"
+]);
+var DOMAIN_KEYWORDS = {
+  authentication: ["auth", "oauth", "login", "logout", "session", "jwt", "token", "credential", "sso", "password"],
+  session: ["session", "cookie", "cookies", "expiry", "refresh", "token"],
+  "user-identity": ["user", "account", "profile", "identity", "member", "role", "permission"],
+  database: ["db", "database", "sql", "postgres", "sqlite", "migration", "schema", "table", "query"],
+  storage: ["storage", "s3", "bucket", "file", "upload", "disk", "blob"],
+  api: ["api", "endpoint", "http", "rest", "route", "controller", "middleware", "graphql"],
+  caching: ["cache", "redis", "memcached", "ttl", "invalidation"],
+  billing: ["payment", "stripe", "checkout", "billing", "subscription", "invoice", "credit"],
+  "data-processing": ["import", "export", "csv", "bulk", "batch", "stream", "pipeline"]
+};
+function tokenizeGoal(goal) {
+  return goal.toLowerCase().replace(/[^a-z0-9_-]/g, " ").split(/\s+/).filter((t) => t.length > 2 && !STOP_WORDS.has(t));
+}
+function inferLikelyDomains(tokens, knowledgeTags) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+      if (keywords.includes(token) || token.includes(domain)) {
+        domains.add(domain);
+      }
+    }
+  }
+  for (const tag of knowledgeTags) {
+    const norm = tag.toLowerCase().trim();
+    if (DOMAIN_KEYWORDS[norm]) {
+      domains.add(norm);
+    }
+  }
+  return Array.from(domains);
+}
+function classifyUnknown(unknown, goalTokens, domainCues) {
+  const text = `${unknown.id} ${unknown.statement || ""} ${unknown.question || unknown.next?.question || ""}`.toLowerCase();
+  if (unknown.blocking === true) {
+    const isDecision2 = /\b(should|whether|how to handle|what happens when|policy|strategy|linking|collision|merge|choice)\b/i.test(text);
+    return {
+      classification: "BLOCKING",
+      isDecision: isDecision2 || true,
+      reason: unknown.reason || "Blocking unknown identified for this goal"
+    };
+  }
+  if (unknown.blocking === false) {
+    const isDecision2 = /\b(should|whether|how to handle|what happens when|policy|strategy|choice)\b/i.test(text);
+    return {
+      classification: "NON_BLOCKING",
+      isDecision: isDecision2,
+      reason: "Operational or instrumentation detail not blocking core functionality"
+    };
+  }
+  const isNonBlocking = /\b(analytics|telemetry|metric|event name|logging level|log format|button color|styling|theme)\b/i.test(text);
+  if (isNonBlocking) {
+    return {
+      classification: "NON_BLOCKING",
+      isDecision: /\b(should|which name|choice)\b/i.test(text),
+      reason: "Operational or instrumentation detail not blocking core functionality"
+    };
+  }
+  const isDecision = /\b(should|whether|how to handle|what happens when|policy|strategy|linking|collision|merge)\b/i.test(text);
+  const isBlockingCandidate = /\b(link|linking|collision|duplicate|merge|security|permission|storage-engine|protocol|auth-flow|credentials)\b/i.test(text);
+  const overlapsGoal = goalTokens.some((t) => text.includes(t)) || domainCues.some((d) => text.includes(d));
+  if (isBlockingCandidate && (overlapsGoal || unknown.reason === "UNRESOLVABLE_LOCALLY")) {
+    return {
+      classification: "BLOCKING",
+      isDecision: true,
+      reason: "Unresolved architectural or behavioral decision critical to goal implementation"
+    };
+  }
+  return {
+    classification: "IMPORTANT",
+    isDecision,
+    reason: isDecision ? "Product or behavior decision requiring attention" : "Important implementation detail"
+  };
+}
+function prioritizeQuestions(rawQuestions, blockingUnknowns) {
+  const consolidated = /* @__PURE__ */ new Map();
+  for (const rq of rawQuestions) {
+    const qText = rq.question.trim();
+    if (!qText) continue;
+    const topic = rq.targetTopic || qText.toLowerCase().replace(/[^a-z0-9]/g, " ").slice(0, 30);
+    let expectedResolutionValue = 1;
+    if (rq.isBlocking) expectedResolutionValue += 2;
+    if (rq.outcomeScore && rq.outcomeScore > 0) expectedResolutionValue += 1;
+    if (rq.outcomeScore && rq.outcomeScore < 0) expectedResolutionValue -= 0.5;
+    const interactionCost = 1;
+    const priorityScore = Math.max(0.1, expectedResolutionValue) / interactionCost;
+    const existing = consolidated.get(topic);
+    if (!existing || priorityScore > (existing.priorityScore ?? 0)) {
+      consolidated.set(topic, {
+        question: qText,
+        reason: rq.reason,
+        targetTopic: rq.targetTopic,
+        expectedResolutionValue,
+        interactionCost,
+        priorityScore
+      });
+    }
+  }
+  return Array.from(consolidated.values()).sort((a, b) => (b.priorityScore ?? 0) - (a.priorityScore ?? 0));
+}
+async function executePreflight(options, storage, retriever, index) {
+  const goal = options.goal.trim();
+  const explicitPositive = (options.positive ?? []).map((p) => p.trim().toLowerCase());
+  const negative = (options.negative ?? []).map((n) => n.trim().toLowerCase());
+  const scope = options.scope ?? "project";
+  const goalTokens = tokenizeGoal(goal);
+  const allKnowledge = await storage.getAllKnowledge();
+  const allTags = allKnowledge.flatMap((k) => k.tags ?? []);
+  const likelyDomains = inferLikelyDomains(goalTokens, allTags);
+  const contextualPositive = Array.from(/* @__PURE__ */ new Set([...explicitPositive, ...likelyDomains, ...goalTokens]));
+  let candidatePool = [];
+  if (retriever) {
+    const jevCandidates = await retriever.lookup({
+      query: goal,
+      positive: contextualPositive,
+      negative,
+      scope,
+      limit: options.maxCandidates ?? 25,
+      includeRejected: true
+    });
+    for (const r of jevCandidates) {
+      if (r.knowledge) candidatePool.push(r.knowledge);
+    }
+  }
+  if (candidatePool.length === 0) {
+    candidatePool = allKnowledge.filter((k) => k.status !== "invalid" && k.status !== "superseded");
+  } else {
+    for (const k of allKnowledge) {
+      if (!candidatePool.some((c) => c.id === k.id) && k.status !== "invalid" && k.status !== "superseded") {
+        const matchesToken = goalTokens.some((t) => k.id.toLowerCase().includes(t) || k.statement.toLowerCase().includes(t));
+        const matchesCues = k.positive.some((p) => contextualPositive.includes(p));
+        if (matchesToken || matchesCues) {
+          candidatePool.push(k);
+        }
+      }
+    }
+  }
+  const jevResults = rerankCandidates(candidatePool, {
+    query: goal,
+    positive: contextualPositive,
+    negative,
+    scope
+  });
+  const matchingItems = [];
+  const rejectedItems = [];
+  for (const res of jevResults) {
+    if (res.status === "REJECT") {
+      const reason = res.explanation.negativeConflicts.length > 0 ? `Inapplicable: ${res.explanation.negativeConflicts.join(", ")} conflicts with current context` : res.explanation.reasons[0] || "Context mismatch";
+      rejectedItems.push({ id: res.knowledge.id, reason });
+    } else {
+      matchingItems.push(res.knowledge);
+    }
+  }
+  if (options.deep) {
+    try {
+      const { stdout: diffOutput } = await execFileAsync(
+        "git",
+        ["diff", "--name-only", "HEAD~1"],
+        { cwd: storage.getBaseDir() ? path.dirname(storage.getBaseDir()) : process.cwd() }
+      );
+      const changedFiles = diffOutput.split("\n").map((f) => f.trim()).filter(Boolean);
+      if (changedFiles.length > 0) {
+        const staleness = checkKnowledgeListStaleness(matchingItems, changedFiles);
+        for (const affected of staleness.affectedKnowledge) {
+          const matchIdx = matchingItems.findIndex((m) => m.id === affected.id);
+          if (matchIdx >= 0) {
+            matchingItems[matchIdx] = affected;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const constraints = [];
+  const lessons = [];
+  const pastFailures = [];
+  const stale = [];
+  const known = [];
+  let conflictedCount = 0;
+  const CONSTRAINT_PATTERN = /\b(must|must not|never|only|cannot|require|required|boundary|strictly|prohibited|forbidden)\b/i;
+  const FAILURE_PATTERN = /(fail|bug|error|crash|duplicate write|race condition|pressure|leak|revert|timeout)/i;
+  const rootDir = storage.getBaseDir() ? path.dirname(storage.getBaseDir()) : process.cwd();
+  for (const k of matchingItems) {
+    const matchesContradiction = k.status === "contradicted" || k.contradicts && k.contradicts.some((cid) => matchingItems.some((m) => m.id === cid));
+    if (matchesContradiction) {
+      conflictedCount++;
+    }
+    let isStale = k.status === "needs_revalidation" || k.status === "stale";
+    let staleReason = k.history?.[k.history.length - 1]?.reason || "Supporting source changed after last validation";
+    const changedDeps = [];
+    const candidateDeps = [...k.depends_on ?? [], ...k.evidence ?? []];
+    const timestampStr = k.updated_at ?? k.updatedAt ?? k.createdAt;
+    const knowledgeTime = new Date(timestampStr).getTime();
+    for (const dep of candidateDeps) {
+      const cleanPath = dep.replace(/^(file|code|test|doc):/, "").trim();
+      if (!cleanPath) continue;
+      const absPath = path.isAbsolute(cleanPath) ? cleanPath : path.resolve(rootDir, cleanPath);
+      try {
+        const stat2 = await fs.stat(absPath);
+        if (stat2.mtimeMs > knowledgeTime + 500) {
+          isStale = true;
+          changedDeps.push(cleanPath);
+          staleReason = `Supporting source changed after last validation (${cleanPath})`;
+        }
+      } catch {
+      }
+    }
+    if (isStale) {
+      stale.push({
+        id: k.id,
+        statement: k.statement,
+        reason: staleReason,
+        changedSources: changedDeps.length > 0 ? changedDeps : k.depends_on
+      });
+      continue;
+    }
+    const isConstraint = k.type === "rule" || k.type === "decision" || k.type === "convention" || CONSTRAINT_PATTERN.test(k.statement);
+    if (isConstraint) {
+      constraints.push({
+        id: k.id,
+        statement: k.statement,
+        type: k.type,
+        confidence: k.confidence,
+        confidenceTier: k.confidenceTier,
+        source: k.evidence?.[0]
+      });
+      continue;
+    }
+    const isFailure = k.type === "failure" || k.statement.startsWith("[FAILURE]") || k.statement.startsWith("[REVERT]") || FAILURE_PATTERN.test(k.statement) || k.metrics.failed_outcomes > 0;
+    if (isFailure) {
+      pastFailures.push({
+        id: k.id,
+        statement: k.statement,
+        context: k.context || {
+          positive: k.positive,
+          negative: k.negative
+        },
+        failure: k.statement,
+        lesson: k.lesson || k.reasoning || k.resolves?.[0],
+        evidence: k.evidence
+      });
+      continue;
+    }
+    const isLesson = k.type === "lesson" && (k.id.includes("lesson") || k.tags?.includes("lesson") || k.statement.toLowerCase().includes("lesson")) || k.statement.toLowerCase().startsWith("lesson:") || k.statement.toLowerCase().includes("lesson:");
+    if (isLesson) {
+      lessons.push({
+        id: k.id,
+        statement: k.statement,
+        confidence: k.confidence,
+        domain: k.tags?.[0],
+        evidence: k.evidence
+      });
+      continue;
+    }
+    if (k.status === "active" || k.stage === "active" || k.stage === "probation" || !k.status) {
+      known.push({
+        id: k.id,
+        statement: k.statement,
+        confidence: k.confidence,
+        confidenceTier: k.confidenceTier,
+        stage: k.stage
+      });
+    }
+  }
+  const unknownsFromStorage = await storage.getAllUnknowns();
+  const unknownKnowledge = allKnowledge.filter((k) => k.type === "unknown");
+  const unifiedUnknowns = [];
+  const seenUnknownIds = /* @__PURE__ */ new Set();
+  for (const u of unknownsFromStorage) {
+    seenUnknownIds.add(u.id);
+    unifiedUnknowns.push({
+      id: u.id,
+      statement: u.statement || u.id,
+      reason: u.reason,
+      question: u.question || u.next?.question,
+      next: u.next,
+      blocking: u.blocking,
+      positive: u.positive,
+      negative: u.negative,
+      checked: u.checked
+    });
+  }
+  for (const k of unknownKnowledge) {
+    if (!seenUnknownIds.has(k.id)) {
+      seenUnknownIds.add(k.id);
+      unifiedUnknowns.push({
+        id: k.id,
+        statement: k.statement,
+        reason: k.history?.[0]?.reason,
+        question: k.question || (k.statement.includes("?") ? k.statement : void 0),
+        next: {
+          type: "ask",
+          target: k.id,
+          question: k.question || k.statement
+        },
+        blocking: k.blocking,
+        positive: k.positive,
+        negative: k.negative,
+        checked: k.depends_on || k.evidence
+      });
+    }
+  }
+  const unknowns = [];
+  const missing = [];
+  const rawQuestions = [];
+  for (const u of unifiedUnknowns) {
+    const text = `${u.id} ${u.statement || ""} ${u.question || ""}`.toLowerCase();
+    const overlaps = goalTokens.some((t) => text.includes(t)) || likelyDomains.some((d) => text.includes(d)) || u.positive && u.positive.some((p) => contextualPositive.includes(p));
+    if (u.negative && u.negative.some((n) => contextualPositive.includes(n))) {
+      continue;
+    }
+    if (overlaps) {
+      const { classification, isDecision, reason } = classifyUnknown(u, goalTokens, likelyDomains);
+      const isBlocking = classification === "BLOCKING";
+      unknowns.push({
+        id: u.id,
+        statement: u.statement,
+        question: u.question || u.statement,
+        classification,
+        blocking: isBlocking,
+        reason
+      });
+      if (isDecision) {
+        missing.push({
+          type: "decision",
+          subject: u.id,
+          question: u.question || u.statement,
+          reason
+        });
+      } else {
+        missing.push({
+          type: "evidence",
+          subject: u.id,
+          question: u.question || u.statement,
+          reason
+        });
+      }
+      const qText = u.question || (u.statement && u.statement.includes("?") ? u.statement : void 0);
+      if (qText) {
+        rawQuestions.push({
+          question: qText,
+          reason: `Unknown: ${u.id} (${reason})`,
+          targetTopic: u.id,
+          isBlocking
+        });
+      }
+    }
+  }
+  const questionKnowledge = allKnowledge.filter((k) => k.type === "question");
+  for (const qk of questionKnowledge) {
+    const matchesCues = qk.positive.some((p) => contextualPositive.includes(p));
+    const conflicts = qk.negative.some((n) => negative.includes(n));
+    if (matchesCues && !conflicts && qk.question) {
+      rawQuestions.push({
+        question: qk.question,
+        reason: `Learned question for [${qk.positive.join(", ")}] uncertainty`,
+        targetTopic: qk.resolves?.[0] || qk.id,
+        outcomeScore: (qk.metrics?.successful_outcomes ?? 0) - (qk.metrics?.failed_outcomes ?? 0)
+      });
+    }
+  }
+  const questions = prioritizeQuestions(rawQuestions, unknowns);
+  const receipts = await storage.getAllReceipts();
+  const alreadyInvestigated = [];
+  const investigatedSources = /* @__PURE__ */ new Set();
+  for (const r of receipts) {
+    const qTokens = r.question.toLowerCase().split(/\s+/).filter(Boolean);
+    const overlapsGoal = qTokens.some((t) => goalTokens.includes(t));
+    const overlapsCues = r.positive && r.positive.some((p) => contextualPositive.includes(p));
+    if (overlapsGoal || overlapsCues) {
+      for (const checked of r.checked) {
+        investigatedSources.add(checked.toLowerCase());
+        alreadyInvestigated.push({
+          source: checked,
+          result: r.findings[0] || r.rejected[0]?.reason || "Did not establish requested behavior",
+          nextSuggestion: "ASK_USER"
+        });
+      }
+    }
+  }
+  let readiness = "READY";
+  const totalRelevantKnowledge = known.length + constraints.length + lessons.length + pastFailures.length + stale.length;
+  const hasBlockingUnknown = unknowns.some((u) => u.blocking);
+  const hasMissingDecision = missing.some((m) => m.type === "decision");
+  if (totalRelevantKnowledge === 0 && unknowns.length === 0) {
+    readiness = "INSUFFICIENT_KNOWLEDGE";
+  } else if (conflictedCount > 0) {
+    readiness = "CONFLICTED";
+  } else if (hasBlockingUnknown || hasMissingDecision) {
+    readiness = "NEEDS_CLARIFICATION";
+  } else if (stale.length > 0) {
+    readiness = "NEEDS_REVALIDATION";
+  } else {
+    readiness = "READY";
+  }
+  const next = [];
+  for (const m of missing) {
+    if (m.type === "decision") {
+      next.push({
+        type: "ASK_USER",
+        target: m.subject,
+        reason: m.question || m.reason,
+        relativeCost: 1,
+        expectedInfoGain: 0.95
+      });
+    }
+  }
+  for (const s of stale) {
+    next.push({
+      type: "REVALIDATE",
+      target: s.id,
+      reason: s.reason,
+      relativeCost: 2,
+      expectedInfoGain: 0.85
+    });
+  }
+  for (const m of missing) {
+    if (m.type === "evidence") {
+      const wasChecked = investigatedSources.has(m.subject.toLowerCase()) || alreadyInvestigated.length > 0;
+      if (wasChecked) {
+        if (!next.some((n) => n.type === "ASK_USER")) {
+          next.push({
+            type: "ASK_USER",
+            target: m.subject,
+            reason: `Already investigated (${Array.from(investigatedSources).join(", ")}); did not establish requested behavior. Clarification required.`,
+            relativeCost: 1,
+            expectedInfoGain: 0.9
+          });
+        }
+      } else {
+        const isFilePath = m.subject.includes("/") || m.subject.includes(".");
+        next.push({
+          type: isFilePath ? "INSPECT_FILE" : "SEARCH_REPOSITORY",
+          target: m.subject,
+          reason: m.reason,
+          relativeCost: isFilePath ? 2 : 2.5,
+          expectedInfoGain: 0.8
+        });
+      }
+    }
+  }
+  if (alreadyInvestigated.length > 0 && !next.some((n) => n.type === "ASK_USER")) {
+    next.push({
+      type: "ASK_USER",
+      target: alreadyInvestigated[0].source,
+      reason: `Already investigated ${alreadyInvestigated[0].source}; clarification required`,
+      relativeCost: 1,
+      expectedInfoGain: 0.9
+    });
+  }
+  if (next.length === 0 && known.length > 0) {
+    next.push({
+      type: "USE_KNOWLEDGE",
+      target: known[0].id,
+      reason: "Proceed with implementation using verified knowledge and constraints",
+      relativeCost: 1,
+      expectedInfoGain: 1
+    });
+  }
+  const knowledgeImpact = {
+    relevantKnowledge: totalRelevantKnowledge,
+    validated: known.filter((k) => k.confidenceTier === "high").length + constraints.length,
+    needsRevalidation: stale.length,
+    conflicted: conflictedCount,
+    blockingUnknowns: unknowns.filter((u) => u.blocking).length,
+    relevantFailures: pastFailures.length
+  };
+  const similarWork = [];
+  for (const l of lessons) {
+    similarWork.push({
+      topic: l.domain || l.id,
+      lesson: l.statement
+    });
+  }
+  for (const f of pastFailures) {
+    similarWork.push({
+      topic: f.id,
+      failure: f.statement
+    });
+  }
+  await storage.appendMetricEvent({
+    type: "preflight",
+    goal,
+    readiness,
+    blockingUnknownsCount: knowledgeImpact.blockingUnknowns,
+    staleKnowledgeCount: stale.length,
+    pastFailuresCount: pastFailures.length,
+    questionsCount: questions.length,
+    repeatedChecksAvoidedCount: alreadyInvestigated.length,
+    timestamp: Date.now()
+  });
+  return {
+    goal,
+    readiness,
+    known,
+    constraints,
+    lessons,
+    past_failures: pastFailures,
+    unknowns,
+    stale,
+    missing,
+    questions,
+    likely_domains: likelyDomains,
+    similar_work: similarWork.length > 0 ? similarWork.slice(0, 5) : void 0,
+    already_investigated: alreadyInvestigated.length > 0 ? alreadyInvestigated : void 0,
+    knowledge_impact: knowledgeImpact,
+    next
+  };
+}
+function formatPreflightReport(result) {
+  const plainObject = {
+    goal: result.goal,
+    readiness: result.readiness
+  };
+  if (result.known.length > 0) {
+    plainObject.known = result.known.map((k) => ({
+      id: k.id,
+      statement: k.statement,
+      confidence: k.confidenceTier || (typeof k.confidence === "number" ? k.confidence >= 0.9 ? "high" : k.confidence >= 0.7 ? "medium" : "low" : k.confidence)
+    }));
+  }
+  if (result.constraints.length > 0) {
+    plainObject.constraints = result.constraints.map((c) => ({
+      id: c.id,
+      statement: c.statement
+    }));
+  }
+  if (result.lessons.length > 0) {
+    plainObject.lessons = result.lessons.map((l) => ({
+      id: l.id,
+      statement: l.statement
+    }));
+  }
+  if (result.past_failures.length > 0) {
+    plainObject.past_failures = result.past_failures.map((f) => ({
+      id: f.id,
+      statement: f.statement
+    }));
+  }
+  if (result.unknowns.length > 0) {
+    plainObject.unknowns = result.unknowns.map((u) => ({
+      id: u.id,
+      question: u.question || u.statement,
+      blocking: u.blocking
+    }));
+  }
+  if (result.stale.length > 0) {
+    plainObject.stale = result.stale.map((s) => ({
+      id: s.id,
+      reason: s.reason
+    }));
+  }
+  if (result.questions.length > 0) {
+    plainObject.questions = result.questions.map((q) => ({
+      question: q.question,
+      reason: q.reason
+    }));
+  }
+  if (result.likely_domains.length > 0) {
+    plainObject.likely_domains = result.likely_domains;
+  }
+  if (result.already_investigated && result.already_investigated.length > 0) {
+    plainObject.already_investigated = result.already_investigated;
+  }
+  if (result.next.length > 0) {
+    plainObject.next = result.next.map((n) => ({
+      type: n.type,
+      target: n.target,
+      reason: n.reason
+    }));
+  }
+  return YAML.stringify(plainObject);
+}
 export {
   EvidenceGraph,
   MetricsTracker,
@@ -1949,6 +2565,7 @@ export {
   calculateKnowledgeValue,
   checkKnowledgeListStaleness,
   checkKnowledgeStaleness,
+  classifyUnknown,
   confidenceToTier,
   createEvidence,
   createKnowledge,
@@ -1960,16 +2577,21 @@ export {
   distillTrajectory,
   enforceKnowledgeBudget,
   evaluatePromotion,
+  executePreflight,
+  formatPreflightReport,
   hasBeenInvestigated,
   hashString,
+  inferLikelyDomains,
   learnFromTrajectory,
   markStaleKnowledge,
   normalizeSourceKey,
+  prioritizeQuestions,
   processUserCorrection,
   reconcileKnowledge,
   recordOutcomeOnKnowledge,
   resolveEpistemicQuery,
   tierToConfidence,
+  tokenizeGoal,
   updateUnknown
 };
 //# sourceMappingURL=index.js.map