@linghun/tui 0.1.0

package/dist/chunk-GCMH5P4W.js

@@ -0,0 +1,422 @@
+// src/workflow-plan-schema.ts
+var ALLOWED_TOOL_CLASSES = /* @__PURE__ */ new Set([
+  "readonly",
+  "codebase-memory-readonly",
+  "workspace-reference",
+  "verification",
+  "details",
+  "job-control",
+  "agent-control",
+  "workflow-template",
+  "mcp-local-stdio"
+]);
+var PASS_BANNED_EVIDENCE_KINDS = /* @__PURE__ */ new Set([
+  "agent_summary",
+  "job_completed",
+  "remote_event",
+  "failure_learning"
+]);
+var ALLOWED_SLASH_TARGETS = /* @__PURE__ */ new Set(["/job", "/fork", "/agents", "/workflows"]);
+var MUTATING_SLASH_ACTIONS = /* @__PURE__ */ new Set(["create", "run", "pause", "resume", "cancel"]);
+function normalizeWorkflowPlan(input, options = {}) {
+  const errors = [];
+  scanForbiddenRawFields(input, "$", errors);
+  const phases = Array.isArray(input.phases) ? input.phases : [];
+  if (!input.id?.trim()) {
+    errors.push({ path: "$.id", message: "workflow id is required" });
+  }
+  if (!input.title?.trim()) {
+    errors.push({ path: "$.title", message: "workflow title is required" });
+  }
+  if (!Date.parse(input.createdAt)) {
+    errors.push({ path: "$.createdAt", message: "createdAt must be an ISO-like timestamp" });
+  }
+  if (!Array.isArray(input.phases) || input.phases.length === 0) {
+    errors.push({ path: "$.phases", message: "at least one workflow phase is required" });
+  }
+  validateBudget(input.budget, "$.budget", errors);
+  const permissionMode = options.permissionMode ?? input.permissionMode ?? "default";
+  const runningCap = normalizeRunningCap(options.runningCap ?? input.budget?.maxRunningAgents) ?? deriveWorkflowRunningCap(phases);
+  const phaseIds = new Set(phases.map((phase) => phase.id).filter(Boolean));
+  const sliceIds = new Set(
+    phases.flatMap(
+      (phase) => Array.isArray(phase.slices) ? phase.slices.map((slice) => slice.id).filter(Boolean) : []
+    )
+  );
+  const normalizedPhases = [];
+  let runningSlices = 0;
+  validateDuplicateIds(
+    phases.map((phase) => phase.id),
+    "$.phases",
+    "duplicate phase id",
+    errors
+  );
+  validateDuplicateIds(
+    phases.flatMap(
+      (phase) => Array.isArray(phase.slices) ? phase.slices.map((slice) => slice.id) : []
+    ),
+    "$.phases[].slices",
+    "duplicate slice id",
+    errors
+  );
+  phases.forEach((phase, phaseIndex) => {
+    const phasePath = `$.phases[${phaseIndex}]`;
+    const slices = Array.isArray(phase.slices) ? phase.slices : [];
+    if (!phase.id?.trim()) {
+      errors.push({ path: `${phasePath}.id`, message: "phase id is required" });
+    }
+    if (!phase.title?.trim()) {
+      errors.push({ path: `${phasePath}.title`, message: "phase title is required" });
+    }
+    if (!phase.stopPoint?.required || !phase.stopPoint.confirmationRequired) {
+      errors.push({
+        path: `${phasePath}.stopPoint`,
+        message: "each phase must have a required stop point with confirmationRequired=true"
+      });
+    }
+    if (phase.autoAdvance === true) {
+      errors.push({
+        path: `${phasePath}.autoAdvance`,
+        message: "phase auto-advance is forbidden; stop at the phase boundary"
+      });
+    }
+    for (const dep of phase.dependsOnPhaseIds ?? []) {
+      if (!phaseIds.has(dep) || dep === phase.id) {
+        errors.push({
+          path: `${phasePath}.dependsOnPhaseIds`,
+          message: `unknown or self phase dependency: ${dep}`
+        });
+      }
+    }
+    if (!Array.isArray(phase.slices) || phase.slices.length === 0) {
+      errors.push({ path: `${phasePath}.slices`, message: "phase requires at least one slice" });
+    }
+    validateBudget(phase.budget, `${phasePath}.budget`, errors);
+    const normalizedSlices = slices.map((slice, sliceIndex) => {
+      const slicePath = `${phasePath}.slices[${sliceIndex}]`;
+      validateSlice(slice, slicePath, sliceIds, permissionMode, errors);
+      let status = slice.status ?? "queued";
+      if (status === "running") {
+        if (runningSlices >= runningCap) {
+          status = "queued";
+        } else {
+          runningSlices += 1;
+        }
+      }
+      return {
+        ...slice,
+        status,
+        dependsOnSliceIds: slice.dependsOnSliceIds ?? [],
+        independent: slice.independent === true,
+        canRunInParallel: slice.canRunInParallel === true,
+        allowedToolClasses: slice.allowedToolClasses ?? [],
+        evidence: slice.evidence ?? [],
+        references: slice.references ?? []
+      };
+    });
+    normalizedPhases.push({
+      ...phase,
+      status: phase.status ?? "pending",
+      slices: normalizedSlices
+    });
+  });
+  validateEvidence(input.evidence ?? [], "$.evidence", errors);
+  validateReferences(input.references ?? [], "$.references", errors);
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return {
+    ok: true,
+    plan: {
+      ...input,
+      permissionMode,
+      budget: {
+        ...input.budget,
+        maxRunningAgents: runningCap
+      },
+      phases: normalizedPhases,
+      stopConditions: input.stopConditions && input.stopConditions.length > 0 ? input.stopConditions : ["stop after each phase and wait for explicit user confirmation"]
+    }
+  };
+}
+function projectWorkflowPlan(plan) {
+  const currentPhase = plan.phases.find((phase) => phase.id === plan.currentPhaseId) ?? plan.phases.find((phase) => phase.status === "running" || phase.status === "blocked") ?? plan.phases[0];
+  const slices = plan.phases.flatMap((phase) => phase.slices);
+  const done = slices.filter((slice) => slice.status === "completed").length;
+  const running = slices.filter((slice) => slice.status === "running").length;
+  const blocked = slices.filter(
+    (slice) => slice.status === "blocked" || slice.status === "failed"
+  ).length;
+  const evidenceCount = (plan.evidence ?? []).length + slices.reduce((count, slice) => count + (slice.evidence ?? []).length, 0);
+  const maxTokens = plan.budget.maxTokens ?? plan.phases.reduce(
+    (sum, phase) => sum + (phase.budget?.maxTokens ?? 0) + phase.slices.reduce((sliceSum, slice) => sliceSum + (slice.budget?.maxTokens ?? 0), 0),
+    0
+  );
+  const maxCost = plan.budget.maxCostCny;
+  const nextAction = currentPhase?.stopPoint.reason ?? "Review workflow plan before execution.";
+  const tokenCostSummary = [
+    maxTokens ? `tokens <= ${maxTokens}` : "tokens unset",
+    maxCost ? `cost <= ${maxCost} CNY` : "cost unset"
+  ].join("; ");
+  const summaryText = [
+    `Workflow ${plan.title}`,
+    `Current phase: ${currentPhase?.title ?? "unknown"}`,
+    `Agents: done ${done}, running ${running}, blocked ${blocked}`,
+    `Evidence refs: ${evidenceCount}`,
+    `Budget: ${tokenCostSummary}`,
+    `Next: ${nextAction}`
+  ].join("\n");
+  const detailsText = [
+    `Workflow Matrix details for ${plan.title}`,
+    "phase | slice | role | status | dependsOn | parallel | evidence refs | budget | next action",
+    ...plan.phases.flatMap(
+      (phase) => phase.slices.map(
+        (slice) => [
+          phase.title,
+          slice.title,
+          slice.role,
+          slice.status,
+          (slice.dependsOnSliceIds ?? []).join(",") || "none",
+          slice.independent || slice.canRunInParallel ? "yes" : "no",
+          (slice.evidence ?? []).map((item) => item.ref).join(",") || "none",
+          formatSliceBudget(slice),
+          slice.nextAction ?? phase.stopPoint.reason
+        ].join(" | ")
+      )
+    )
+  ].join("\n");
+  const mobileSummary = sanitizeMobileSummary(
+    [
+      `Workflow ${plan.title}`,
+      `Phase: ${currentPhase?.title ?? "unknown"}`,
+      `Agents done/running/blocked: ${done}/${running}/${blocked}`,
+      `Evidence: ${evidenceCount}`,
+      `Budget: ${tokenCostSummary}`,
+      `Next: ${nextAction}`
+    ].join("\n")
+  );
+  return {
+    surface: "task-summary",
+    summary: {
+      currentPhase: currentPhase?.title ?? "unknown",
+      agents: { done, running, blocked },
+      evidenceCount,
+      tokenCostSummary,
+      nextAction
+    },
+    summaryText,
+    detailsText,
+    mobileSummary
+  };
+}
+function normalizeRunningCap(value) {
+  if (!Number.isFinite(value) || value === void 0 || value < 1) {
+    return void 0;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function deriveWorkflowRunningCap(phases) {
+  const sliceCount = phases.reduce(
+    (total, phase) => total + (Array.isArray(phase.slices) ? phase.slices.length : 0),
+    0
+  );
+  return Math.max(1, sliceCount);
+}
+function validateDuplicateIds(ids, path, message, errors) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!id) continue;
+    if (seen.has(id)) {
+      errors.push({ path, message: `${message}: ${id}` });
+      continue;
+    }
+    seen.add(id);
+  }
+}
+function validateSlice(slice, path, allSliceIds, permissionMode, errors) {
+  if (!slice.id?.trim()) {
+    errors.push({ path: `${path}.id`, message: "slice id is required" });
+  }
+  if (!slice.title?.trim()) {
+    errors.push({ path: `${path}.title`, message: "slice title is required" });
+  }
+  if (!["explorer", "worker", "verifier", "planner"].includes(slice.role)) {
+    errors.push({ path: `${path}.role`, message: `unknown agent role: ${slice.role}` });
+  }
+  for (const dep of slice.dependsOnSliceIds ?? []) {
+    if (!allSliceIds.has(dep) || dep === slice.id) {
+      errors.push({
+        path: `${path}.dependsOnSliceIds`,
+        message: `unknown or self slice dependency: ${dep}`
+      });
+    }
+  }
+  validateBudget(slice.budget, `${path}.budget`, errors);
+  const dependsOnSliceIds = slice.dependsOnSliceIds ?? [];
+  if (slice.independent === true && dependsOnSliceIds.length > 0) {
+    errors.push({
+      path: `${path}.independent`,
+      message: "independent slices must not declare dependsOnSliceIds"
+    });
+  }
+  if (slice.canRunInParallel === true && slice.independent !== true) {
+    errors.push({
+      path: `${path}.canRunInParallel`,
+      message: "canRunInParallel requires independent=true"
+    });
+  }
+  validateToolClasses(slice.allowedToolClasses ?? [], `${path}.allowedToolClasses`, errors);
+  validateToolProposals(slice.toolProposals ?? [], `${path}.toolProposals`, errors);
+  validateEvidence(slice.evidence ?? [], `${path}.evidence`, errors);
+  validateReferences(slice.references ?? [], `${path}.references`, errors);
+  validateRuntimeTarget(slice.targetRuntime, `${path}.targetRuntime`, permissionMode, errors);
+}
+function validateBudget(budget, path, errors) {
+  if (!budget) return;
+  for (const [field, value] of Object.entries(budget)) {
+    if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
+      errors.push({ path: `${path}.${field}`, message: "budget values must be non-negative" });
+    }
+  }
+}
+function validateToolClasses(classes, path, errors) {
+  classes.forEach((toolClass, index) => {
+    if (!ALLOWED_TOOL_CLASSES.has(toolClass)) {
+      errors.push({ path: `${path}[${index}]`, message: `unknown tool class: ${toolClass}` });
+    }
+  });
+}
+function validateToolProposals(proposals, path, errors) {
+  proposals.forEach((proposal, index) => {
+    const proposalPath = `${path}[${index}]`;
+    validateToolClasses([proposal.toolClass], `${proposalPath}.toolClass`, errors);
+    if (proposal.execution !== "execute") return;
+    if (!proposal.discovered || !proposal.trusted || !proposal.executable) {
+      errors.push({
+        path: proposalPath,
+        message: "tool execution proposal requires discovered=true, trusted=true, and executable=true"
+      });
+    }
+    if (proposal.toolClass === "mcp-local-stdio" && !proposal.toolName?.startsWith("mcp:")) {
+      errors.push({
+        path: `${proposalPath}.toolName`,
+        message: "mcp-local-stdio execution must reference an mcp:<server>:<tool> name"
+      });
+    }
+  });
+}
+function validateEvidence(evidence, path, errors) {
+  evidence.forEach((item, index) => {
+    const evidencePath = `${path}[${index}]`;
+    if (!item.ref?.trim()) {
+      errors.push({ path: `${evidencePath}.ref`, message: "evidence ref is required" });
+    }
+    if (PASS_BANNED_EVIDENCE_KINDS.has(item.kind) && (item.requiredForPass || item.passEvidence)) {
+      errors.push({
+        path: evidencePath,
+        message: `${item.kind} cannot be used as PASS evidence`
+      });
+    }
+  });
+}
+function validateReferences(refs, path, errors) {
+  refs.forEach((ref, index) => {
+    const refPath = `${path}[${index}]`;
+    if (!ref.ref?.trim()) {
+      errors.push({ path: `${refPath}.ref`, message: "reference id/path is required" });
+    }
+    if (ref.summary && ref.summary.length > 1e3) {
+      errors.push({
+        path: `${refPath}.summary`,
+        message: "reference summary is too large; use a bounded ref instead"
+      });
+    }
+  });
+}
+function validateRuntimeTarget(target, path, permissionMode, errors) {
+  if (!target) return;
+  const raw = target;
+  if (typeof raw.command === "string" || typeof raw.rawCommand === "string") {
+    errors.push({
+      path,
+      message: "runtime mapping must be a structured main-chain target, not a raw command string"
+    });
+  }
+  if (target.kind === "slash") {
+    if (!ALLOWED_SLASH_TARGETS.has(target.slash)) {
+      errors.push({ path: `${path}.slash`, message: `unknown slash target: ${target.slash}` });
+    }
+    const action = "action" in target ? target.action : void 0;
+    if (action && MUTATING_SLASH_ACTIONS.has(action) && !target.mutating) {
+      errors.push({
+        path: `${path}.mutating`,
+        message: `slash action ${target.slash} ${action} must be marked mutating`
+      });
+    }
+  }
+  if (permissionMode === "plan" && target.mutating) {
+    errors.push({
+      path,
+      message: "plan mode cannot contain mutating execution proposals"
+    });
+  }
+}
+function scanForbiddenRawFields(value, path, errors) {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => scanForbiddenRawFields(item, `${path}[${index}]`, errors));
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const normalizedKey = key.toLowerCase();
+    if ([
+      "rawtranscript",
+      "rawfulltranscript",
+      "fulltranscript",
+      "rawsource",
+      "fullsource",
+      "sourcecode",
+      "rawlog",
+      "fulllog",
+      "largelog",
+      "logbody"
+    ].includes(normalizedKey)) {
+      errors.push({
+        path: `${path}.${key}`,
+        message: "raw transcript/source/log injection is forbidden; use bounded refs instead"
+      });
+      continue;
+    }
+    scanForbiddenRawFields(child, `${path}.${key}`, errors);
+  }
+}
+function formatSliceBudget(slice) {
+  const parts = [
+    slice.budget?.maxTokens ? `tokens <= ${slice.budget.maxTokens}` : "tokens unset",
+    slice.budget?.maxDurationMs ? `duration <= ${slice.budget.maxDurationMs}ms` : "duration unset"
+  ];
+  return parts.join(";");
+}
+function sanitizeMobileSummary(value) {
+  return value.replace(/[A-Za-z]:\\[^\s]+/gu, "[local-path]").replace(/\/(?:Users|home|var|tmp|private|mnt)\/[^\s]+/gu, "[local-path]").replace(/sk-[A-Za-z0-9_-]{8,}/gu, "[masked-key]").replace(/(api[_-]?key\s*[=:]\s*)\S+/giu, "$1[masked-key]").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/giu, "Bearer [masked-key]").replace(
+    /\b(?:full transcript|raw transcript|full source|raw source|full log|raw log)\b/giu,
+    "[redacted-detail]"
+  ).slice(0, 800);
+}
+function mapWorkflowSliceStatusToDurableJobAgentStatus(status) {
+  if (status === "created") return "created";
+  if (status === "queued") return "queued";
+  if (status === "sleeping") return "sleeping";
+  if (status === "blocked") return "blocked";
+  if (status === "running") return "running";
+  if (status === "completed") return "completed";
+  if (status === "partial") return "created";
+  return "failed";
+}
+
+export {
+  PASS_BANNED_EVIDENCE_KINDS,
+  normalizeWorkflowPlan,
+  projectWorkflowPlan,
+  mapWorkflowSliceStatusToDurableJobAgentStatus
+};

package/dist/chunk-GDQQNPBP.js

@@ -0,0 +1,251 @@
+import {
+  stableHash
+} from "./chunk-4T5DJW54.js";
+import {
+  formatError
+} from "./chunk-OMZYPQVA.js";
+
+// src/failure-learning-runtime.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { basename, dirname } from "path";
+import { join } from "path";
+import { resolveStoragePaths } from "@linghun/config";
+var MAX_FAILURE_RECORDS = 100;
+var FAILURE_SUMMARY_WIDTH = 200;
+var AVOID_WIDTH = 160;
+var ROOT_CAUSE_WIDTH = 160;
+var TARGET_WIDTH = 80;
+var PROMPT_TOP_K = 5;
+var PROMPT_ITEM_WIDTH = 160;
+var PROMPT_TOTAL_WIDTH = 900;
+function sanitizeFailureText(text) {
+  if (!text) return "";
+  return text.replace(/sk-[A-Za-z0-9_-]+/gu, "sk-***").replace(/(?:gh[pousr])_[A-Za-z0-9]{20,}/gu, "ghx-***").replace(/(?:AKIA|ASIA)[A-Z0-9]{16}/gu, "AKIA-***").replace(/xox[bpras]-[A-Za-z0-9-]+/gu, "xox-***").replace(
+    /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----[\s\S]*?-----END[^-]*-----/gu,
+    "[private-key]"
+  ).replace(/(?:Authorization|authorization)\s*[:=]\s*[^\s,;]+/gu, "Authorization=***").replace(/Bearer\s+[A-Za-z0-9._~+/-]+=*/giu, "Bearer ***").replace(
+    /\b(api[_-]?key|token|secret|password|credential|access[_-]?key)\b\s*[:=]\s*[^\s,;]+/giu,
+    "$1=***"
+  ).replace(/https?:\/\/[^\s"'<>]+/giu, "[url]").replace(/[A-Za-z]:[\\/][^\s"'<>]+/gu, "[local-path]").replace(/(?:\/[^\s"'<>/]+){2,}/gu, "[local-path]").replace(/\s+/gu, " ").trim();
+}
+function sanitizeRelatedTarget(target) {
+  if (!target) return void 0;
+  const cleaned = sanitizeFailureText(target);
+  if (!cleaned) return void 0;
+  return cleaned.slice(0, TARGET_WIDTH);
+}
+function clamp(text, width) {
+  const sanitized = sanitizeFailureText(text);
+  return sanitized.length > width ? `${sanitized.slice(0, width - 1)}\u2026` : sanitized;
+}
+function resolveFailureProjectScope(projectPath) {
+  const base = basename(projectPath || "").trim();
+  return base ? sanitizeFailureText(base).slice(0, 80) || "project" : "project";
+}
+function resolveFailureProjectScopeFromDirectory(directory, projectPath) {
+  if (!process.env.LINGHUN_DATA_DIR) {
+    return resolveFailureProjectScope(projectPath);
+  }
+  const namespace = basename(dirname(directory)).trim();
+  return namespace || "project";
+}
+function getFailureLearningDirectory(projectPath, config) {
+  return resolveStoragePaths(config, projectPath).failures;
+}
+function failureDedupeHash(input) {
+  const normalizedMessage = sanitizeFailureText(input.failureSummary).toLowerCase().replace(/\b\d[\d.:_-]*\b/gu, "#").replace(/\s+/gu, " ").trim().slice(0, 160);
+  return stableHash({
+    scope: input.projectScope,
+    category: input.category,
+    target: sanitizeRelatedTarget(input.relatedTarget) ?? "",
+    message: normalizedMessage
+  });
+}
+function createFailureLearningState(projectPath, config) {
+  const directory = getFailureLearningDirectory(projectPath, config);
+  return {
+    directory,
+    projectScope: resolveFailureProjectScopeFromDirectory(directory, projectPath),
+    records: [],
+    degradedWarnings: []
+  };
+}
+function buildFailureRecord(state, input, now = /* @__PURE__ */ new Date()) {
+  const iso = now.toISOString();
+  const failureSummary = clamp(input.failureSummary, FAILURE_SUMMARY_WIDTH);
+  const relatedTarget = sanitizeRelatedTarget(input.relatedTarget);
+  const dedupeHash = failureDedupeHash({
+    category: input.category,
+    relatedTarget,
+    failureSummary,
+    projectScope: state.projectScope
+  });
+  return {
+    id: randomUUID(),
+    createdAt: iso,
+    lastSeen: iso,
+    projectScope: state.projectScope,
+    sourceRef: clamp(input.sourceRef, 120),
+    category: input.category,
+    failureSummary,
+    rootCauseGuess: clamp(input.rootCauseGuess, ROOT_CAUSE_WIDTH),
+    inferred: true,
+    avoidNextTime: clamp(input.avoidNextTime, AVOID_WIDTH),
+    ...relatedTarget ? { relatedTarget } : {},
+    severity: input.severity ?? "medium",
+    dedupeHash,
+    count: 1,
+    status: "active"
+  };
+}
+function mergeFailureRecord(state, input, now = /* @__PURE__ */ new Date()) {
+  const candidate = buildFailureRecord(state, input, now);
+  const existing = state.records.find((r) => r.dedupeHash === candidate.dedupeHash);
+  if (existing) {
+    existing.count += 1;
+    existing.lastSeen = candidate.lastSeen;
+    existing.sourceRef = candidate.sourceRef;
+    existing.failureSummary = candidate.failureSummary;
+    existing.rootCauseGuess = candidate.rootCauseGuess;
+    existing.avoidNextTime = candidate.avoidNextTime;
+    if (candidate.relatedTarget) existing.relatedTarget = candidate.relatedTarget;
+    existing.severity = candidate.severity;
+    if (existing.status === "resolved") existing.status = "active";
+    return { record: existing, isNew: false };
+  }
+  state.records.unshift(candidate);
+  if (state.records.length > MAX_FAILURE_RECORDS) {
+    state.records.length = MAX_FAILURE_RECORDS;
+  }
+  return { record: candidate, isNew: true };
+}
+async function writeFailureRecord(state, record) {
+  try {
+    await mkdir(state.directory, { recursive: true });
+    await writeFile(
+      join(state.directory, `${record.id}.json`),
+      `${JSON.stringify(record, null, 2)}
+`,
+      "utf8"
+    );
+  } catch (error) {
+    recordFailureLearningDegradedWarning(
+      state,
+      `write_failed directory=${state.directory} id=${record.id} reason=${formatError(error)}`
+    );
+    throw error;
+  }
+}
+async function removeFailureRecordFile(state, id) {
+  await rm(join(state.directory, `${id}.json`), { force: true });
+}
+function parseFailureRecord(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const v = value;
+  if (typeof v.id !== "string" || typeof v.dedupeHash !== "string") return null;
+  if (typeof v.category !== "string" || typeof v.failureSummary !== "string") return null;
+  const status = v.status === "active" || v.status === "resolved" || v.status === "ignored" ? v.status : "active";
+  const severity = v.severity === "low" || v.severity === "medium" || v.severity === "high" ? v.severity : "medium";
+  return {
+    id: v.id,
+    createdAt: typeof v.createdAt === "string" ? v.createdAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    lastSeen: typeof v.lastSeen === "string" ? v.lastSeen : (/* @__PURE__ */ new Date(0)).toISOString(),
+    projectScope: typeof v.projectScope === "string" ? v.projectScope : "project",
+    sourceRef: typeof v.sourceRef === "string" ? v.sourceRef : "",
+    category: v.category,
+    failureSummary: v.failureSummary,
+    rootCauseGuess: typeof v.rootCauseGuess === "string" ? v.rootCauseGuess : "",
+    inferred: true,
+    avoidNextTime: typeof v.avoidNextTime === "string" ? v.avoidNextTime : "",
+    ...typeof v.relatedTarget === "string" ? { relatedTarget: v.relatedTarget } : {},
+    severity,
+    dedupeHash: v.dedupeHash,
+    count: typeof v.count === "number" && v.count > 0 ? v.count : 1,
+    status
+  };
+}
+async function loadFailureRecords(state) {
+  let files;
+  try {
+    files = await readdir(state.directory);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      recordFailureLearningDegradedWarning(
+        state,
+        `read_failed directory=${state.directory} reason=${formatError(error)}`
+      );
+    }
+    return [];
+  }
+  const records = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const parsed = parseFailureRecord(
+        JSON.parse(await readFile(join(state.directory, file), "utf8"))
+      );
+      if (parsed) records.push(parsed);
+    } catch {
+    }
+  }
+  return records.sort((a, b) => b.lastSeen.localeCompare(a.lastSeen)).slice(0, MAX_FAILURE_RECORDS);
+}
+function recordFailureLearningDegradedWarning(state, warning) {
+  const sanitized = sanitizeFailureText(warning).slice(0, 240);
+  if (!sanitized || state.degradedWarnings.includes(sanitized)) {
+    return;
+  }
+  state.degradedWarnings.unshift(sanitized);
+  state.degradedWarnings = state.degradedWarnings.slice(0, 5);
+}
+function findFailureRecord(state, id) {
+  if (!id) return void 0;
+  return state.records.find((r) => r.id === id || r.id.startsWith(id));
+}
+var SEVERITY_RANK = { high: 3, medium: 2, low: 1 };
+function selectActiveLessons(state, limit = PROMPT_TOP_K) {
+  return state.records.filter((r) => r.status === "active" && r.projectScope === state.projectScope).sort((a, b) => {
+    const sev = SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity];
+    return sev !== 0 ? sev : b.lastSeen.localeCompare(a.lastSeen);
+  }).slice(0, limit);
+}
+function buildFailureLearningSummaryForPrompt(state) {
+  const lessons = selectActiveLessons(state);
+  if (lessons.length === 0) return null;
+  const items = lessons.map((r) => ({
+    category: r.category,
+    avoid: clamp(r.avoidNextTime, PROMPT_ITEM_WIDTH),
+    severity: r.severity,
+    count: r.count
+  }));
+  let kept = items.length;
+  let json = JSON.stringify(items);
+  while (json.length > PROMPT_TOTAL_WIDTH && kept > 1) {
+    kept -= 1;
+    json = JSON.stringify(items.slice(0, kept));
+  }
+  return { count: kept, text: json };
+}
+function setFailureRecordStatus(record, status) {
+  record.status = status;
+}
+
+export {
+  sanitizeFailureText,
+  sanitizeRelatedTarget,
+  resolveFailureProjectScope,
+  getFailureLearningDirectory,
+  failureDedupeHash,
+  createFailureLearningState,
+  buildFailureRecord,
+  mergeFailureRecord,
+  writeFailureRecord,
+  removeFailureRecordFile,
+  loadFailureRecords,
+  recordFailureLearningDegradedWarning,
+  findFailureRecord,
+  selectActiveLessons,
+  buildFailureLearningSummaryForPrompt,
+  setFailureRecordStatus
+};