@triedotdev/mcp 1.0.113 → 1.0.114

package/dist/chunk-6JPPYG7F.js

@@ -1,1813 +0,0 @@
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-R4AAPFXC.js";
-
-// src/memory/compactor.ts
-import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-
-// src/utils/atomic-write.ts
-import { writeFile, rename, unlink, mkdir } from "fs/promises";
-import { randomBytes } from "crypto";
-import { dirname } from "path";
-async function atomicWriteFile(filePath, data, options = {}) {
-  const { createDir = true, encoding = "utf-8" } = options;
-  const tempSuffix = randomBytes(6).toString("hex");
-  const tempPath = `${filePath}.${tempSuffix}.tmp`;
-  try {
-    if (createDir) {
-      await mkdir(dirname(filePath), { recursive: true });
-    }
-    if (typeof data === "string") {
-      await writeFile(tempPath, data, { encoding });
-    } else {
-      await writeFile(tempPath, data);
-    }
-    await rename(tempPath, filePath);
-  } catch (error) {
-    try {
-      await unlink(tempPath);
-    } catch {
-    }
-    throw error;
-  }
-}
-async function atomicWriteJSON(filePath, data, options = {}) {
-  const { spaces = 2, ...writeOptions } = options;
-  const json = JSON.stringify(data, null, spaces);
-  await atomicWriteFile(filePath, json, writeOptions);
-}
-
-// src/utils/backup-manager.ts
-import { copyFile, readdir, unlink as unlink2, readFile, stat } from "fs/promises";
-import { existsSync } from "fs";
-import { dirname as dirname2, basename, join } from "path";
-var BackupManager = class {
-  filePath;
-  maxBackups;
-  validator;
-  backupDir;
-  baseFileName;
-  constructor(filePath, options = {}) {
-    this.filePath = filePath;
-    this.maxBackups = options.maxBackups ?? 5;
-    this.validator = options.validator;
-    this.backupDir = dirname2(filePath);
-    this.baseFileName = basename(filePath);
-  }
-  /**
-   * Create a backup of the current file
-   * 
-   * @returns The backup file path, or null if source doesn't exist
-   */
-  async createBackup() {
-    if (!existsSync(this.filePath)) {
-      return null;
-    }
-    const timestamp = Date.now();
-    const backupPath = this.getBackupPath(timestamp);
-    await copyFile(this.filePath, backupPath);
-    await this.pruneOldBackups();
-    return backupPath;
-  }
-  /**
-   * List all backups sorted by timestamp (newest first)
-   */
-  async listBackups() {
-    if (!existsSync(this.backupDir)) {
-      return [];
-    }
-    const files = await readdir(this.backupDir);
-    const backupPattern = new RegExp(
-      `^${this.escapeRegex(this.baseFileName)}\\.backup\\.(\\d+)$`
-    );
-    const backups = [];
-    for (const file of files) {
-      const match = file.match(backupPattern);
-      if (match) {
-        const timestamp = parseInt(match[1], 10);
-        const backupPath = join(this.backupDir, file);
-        try {
-          const stats = await stat(backupPath);
-          backups.push({
-            path: backupPath,
-            timestamp,
-            size: stats.size
-          });
-        } catch {
-        }
-      }
-    }
-    return backups.sort((a, b) => b.timestamp - a.timestamp);
-  }
-  /**
-   * Find the first valid backup
-   * 
-   * Iterates through backups from newest to oldest,
-   * returning the first one that passes validation.
-   * 
-   * @returns Path to valid backup, or null if none found
-   */
-  async findValidBackup() {
-    const backups = await this.listBackups();
-    for (const backup of backups) {
-      if (await this.validateBackup(backup.path)) {
-        return backup.path;
-      }
-    }
-    return null;
-  }
-  /**
-   * Validate a backup file
-   * 
-   * If a custom validator was provided, uses that.
-   * Otherwise, attempts JSON parse for .json files.
-   * 
-   * @returns true if backup is valid
-   */
-  async validateBackup(backupPath) {
-    try {
-      const content = await readFile(backupPath, "utf-8");
-      if (this.validator) {
-        return this.validator(content);
-      }
-      if (this.filePath.endsWith(".json")) {
-        JSON.parse(content);
-        return true;
-      }
-      return content.length > 0;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Recover from the most recent valid backup
-   * 
-   * @returns true if recovery was successful
-   */
-  async recoverFromBackup() {
-    const validBackup = await this.findValidBackup();
-    if (!validBackup) {
-      return false;
-    }
-    await copyFile(validBackup, this.filePath);
-    return true;
-  }
-  /**
-   * Remove old backups beyond the max limit
-   */
-  async pruneOldBackups() {
-    const backups = await this.listBackups();
-    const toRemove = backups.slice(this.maxBackups);
-    for (const backup of toRemove) {
-      try {
-        await unlink2(backup.path);
-      } catch {
-      }
-    }
-  }
-  /**
-   * Get the backup path for a given timestamp
-   */
-  getBackupPath(timestamp) {
-    return join(this.backupDir, `${this.baseFileName}.backup.${timestamp}`);
-  }
-  /**
-   * Escape special regex characters in a string
-   */
-  escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  /**
-   * Get the number of existing backups
-   */
-  async getBackupCount() {
-    const backups = await this.listBackups();
-    return backups.length;
-  }
-  /**
-   * Get the most recent backup timestamp
-   */
-  async getLatestBackupTime() {
-    const backups = await this.listBackups();
-    return backups[0]?.timestamp ?? null;
-  }
-  /**
-   * Delete all backups
-   */
-  async clearBackups() {
-    const backups = await this.listBackups();
-    let deleted = 0;
-    for (const backup of backups) {
-      try {
-        await unlink2(backup.path);
-        deleted++;
-      } catch {
-      }
-    }
-    return deleted;
-  }
-};
-
-// src/memory/validation.ts
-import { z } from "zod";
-var StoredIssueSchema = z.object({
-  id: z.string(),
-  hash: z.string(),
-  severity: z.string(),
-  issue: z.string(),
-  fix: z.string(),
-  file: z.string(),
-  line: z.number().optional(),
-  agent: z.string(),
-  category: z.string().optional(),
-  timestamp: z.string(),
-  project: z.string(),
-  resolved: z.boolean().optional(),
-  resolvedAt: z.string().optional()
-});
-var IssueIndexSchema = z.array(StoredIssueSchema);
-var FixAppliedSchema = z.object({
-  project: z.string(),
-  timestamp: z.string(),
-  fix: z.string()
-});
-var GlobalPatternSchema = z.object({
-  id: z.string(),
-  pattern: z.string(),
-  description: z.string(),
-  severity: z.string(),
-  agent: z.string(),
-  occurrences: z.number(),
-  projects: z.array(z.string()),
-  firstSeen: z.string(),
-  lastSeen: z.string(),
-  fixApplied: FixAppliedSchema.optional()
-});
-var GlobalPatternsIndexSchema = z.array(GlobalPatternSchema);
-var ProjectSummarySchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  lastScan: z.string(),
-  healthScore: z.number(),
-  totalIssues: z.number(),
-  patterns: z.array(z.string())
-});
-var PatternSummarySchema = z.object({
-  pattern: z.string(),
-  count: z.number(),
-  severity: z.string(),
-  agent: z.string(),
-  exampleFix: z.string()
-});
-var HotFileSchema = z.object({
-  file: z.string(),
-  count: z.number()
-});
-var CompactedSummarySchema = z.object({
-  period: z.string(),
-  startDate: z.string(),
-  endDate: z.string(),
-  totalIssues: z.number(),
-  resolvedCount: z.number(),
-  bySeverity: z.record(z.string(), z.number()),
-  byAgent: z.record(z.string(), z.number()),
-  topPatterns: z.array(PatternSummarySchema),
-  hotFiles: z.array(HotFileSchema),
-  compactedAt: z.string()
-});
-var CompactedSummariesIndexSchema = z.array(CompactedSummarySchema);
-function safeParseAndValidate(content, schema) {
-  try {
-    const parsed = JSON.parse(content);
-    const result = schema.safeParse(parsed);
-    if (result.success) {
-      return { success: true, data: result.data };
-    }
-    return {
-      success: false,
-      error: `Validation failed: ${result.error.issues[0]?.message || "Unknown error"}`
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: `JSON parse failed: ${error instanceof Error ? error.message : "Unknown error"}`
-    };
-  }
-}
-
-// src/memory/compactor.ts
-async function compactOldIssues(issues, options = {}) {
-  const keepDays = options.keepDays ?? 30;
-  const minIssues = options.minIssuesToCompact ?? 100;
-  const cutoffDate = /* @__PURE__ */ new Date();
-  cutoffDate.setDate(cutoffDate.getDate() - keepDays);
-  const oldIssues = issues.filter((i) => new Date(i.timestamp) < cutoffDate);
-  const recentIssues = issues.filter((i) => new Date(i.timestamp) >= cutoffDate);
-  if (oldIssues.length < minIssues) {
-    return { summary: null, remaining: issues };
-  }
-  const summary = buildSummary(oldIssues);
-  return { summary, remaining: recentIssues };
-}
-function buildSummary(issues) {
-  const sorted = issues.sort(
-    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-  );
-  const bySeverity = {};
-  const byAgent = {};
-  const patternMap = /* @__PURE__ */ new Map();
-  const fileCount = /* @__PURE__ */ new Map();
-  for (const issue of issues) {
-    bySeverity[issue.severity] = (bySeverity[issue.severity] || 0) + 1;
-    byAgent[issue.agent] = (byAgent[issue.agent] || 0) + 1;
-    const patternKey = normalizePattern(issue.issue);
-    const existing = patternMap.get(patternKey);
-    if (existing) {
-      existing.count++;
-    } else {
-      patternMap.set(patternKey, { count: 1, issue });
-    }
-    const fileName = issue.file.split("/").pop() || issue.file;
-    fileCount.set(fileName, (fileCount.get(fileName) || 0) + 1);
-  }
-  const topPatterns = Array.from(patternMap.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, 10).map(([pattern, data]) => ({
-    pattern: pattern.slice(0, 100),
-    count: data.count,
-    severity: data.issue.severity,
-    agent: data.issue.agent,
-    exampleFix: data.issue.fix.slice(0, 200)
-  }));
-  const hotFiles = Array.from(fileCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, count]) => ({ file, count }));
-  return {
-    period: `${sorted[0]?.timestamp.split("T")[0]} to ${sorted[sorted.length - 1]?.timestamp.split("T")[0]}`,
-    startDate: sorted[0]?.timestamp || "",
-    endDate: sorted[sorted.length - 1]?.timestamp || "",
-    totalIssues: issues.length,
-    resolvedCount: issues.filter((i) => i.resolved).length,
-    bySeverity,
-    byAgent,
-    topPatterns,
-    hotFiles,
-    compactedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizePattern(text) {
-  return text.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/["']/g, "").replace(/\s+/g, " ").trim().slice(0, 150);
-}
-async function saveCompactedSummary(summary, projectDir) {
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  await mkdir2(memoryDir, { recursive: true });
-  const summaryPath = join2(memoryDir, "compacted-summaries.json");
-  let summaries = [];
-  try {
-    if (existsSync2(summaryPath)) {
-      const content = await readFile2(summaryPath, "utf-8");
-      const result = safeParseAndValidate(content, CompactedSummariesIndexSchema);
-      if (result.success) {
-        summaries = result.data;
-      }
-    }
-  } catch {
-    summaries = [];
-  }
-  summaries.push(summary);
-  if (summaries.length > 12) {
-    summaries = summaries.slice(-12);
-  }
-  const backupManager = new BackupManager(summaryPath);
-  await backupManager.createBackup();
-  await atomicWriteJSON(summaryPath, summaries);
-}
-async function loadCompactedSummaries(projectDir) {
-  const summaryPath = join2(getTrieDirectory(projectDir), "memory", "compacted-summaries.json");
-  try {
-    if (existsSync2(summaryPath)) {
-      const content = await readFile2(summaryPath, "utf-8");
-      const result = safeParseAndValidate(content, CompactedSummariesIndexSchema);
-      if (result.success) {
-        return result.data;
-      }
-      const backupManager = new BackupManager(summaryPath);
-      if (await backupManager.recoverFromBackup()) {
-        const recovered = await readFile2(summaryPath, "utf-8");
-        const recoveredResult = safeParseAndValidate(recovered, CompactedSummariesIndexSchema);
-        if (recoveredResult.success) {
-          return recoveredResult.data;
-        }
-      }
-    }
-  } catch {
-  }
-  return [];
-}
-async function getHistoricalInsights(projectDir) {
-  const summaries = await loadCompactedSummaries(projectDir);
-  if (summaries.length === 0) {
-    return {
-      totalHistoricalIssues: 0,
-      recurringPatterns: [],
-      improvementTrend: "unknown"
-    };
-  }
-  const totalHistoricalIssues = summaries.reduce((sum, s) => sum + s.totalIssues, 0);
-  const patternCounts = /* @__PURE__ */ new Map();
-  for (const summary of summaries) {
-    for (const pattern of summary.topPatterns) {
-      const key = pattern.pattern;
-      const existing = patternCounts.get(key);
-      if (existing) {
-        existing.count += pattern.count;
-        existing.appearances++;
-      } else {
-        patternCounts.set(key, { ...pattern, appearances: 1 });
-      }
-    }
-  }
-  const recurringPatterns = Array.from(patternCounts.values()).filter((p) => p.appearances >= 2).sort((a, b) => b.count - a.count).slice(0, 5);
-  let improvementTrend = "unknown";
-  if (summaries.length >= 2) {
-    const recent = summaries.slice(-2);
-    const olderCount = recent[0]?.totalIssues || 0;
-    const newerCount = recent[1]?.totalIssues || 0;
-    if (newerCount < olderCount * 0.8) {
-      improvementTrend = "improving";
-    } else if (newerCount > olderCount * 1.2) {
-      improvementTrend = "declining";
-    } else {
-      improvementTrend = "stable";
-    }
-  }
-  return {
-    totalHistoricalIssues,
-    recurringPatterns,
-    improvementTrend
-  };
-}
-
-// src/memory/issue-store.ts
-import { mkdir as mkdir4, writeFile as writeFile2, readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-
-// src/memory/bm25.ts
-var BM25Index = class _BM25Index {
-  documents = /* @__PURE__ */ new Map();
-  termFrequencies = /* @__PURE__ */ new Map();
-  documentFrequencies = /* @__PURE__ */ new Map();
-  documentLengths = /* @__PURE__ */ new Map();
-  avgDocLength = 0;
-  k1 = 1.5;
-  b = 0.75;
-  /**
-   * Add a document to the index
-   */
-  addDocument(doc) {
-    const tokens = this.tokenize(doc.text);
-    this.documents.set(doc.id, doc);
-    this.documentLengths.set(doc.id, tokens.length);
-    const termFreq = /* @__PURE__ */ new Map();
-    const seenTerms = /* @__PURE__ */ new Set();
-    for (const token of tokens) {
-      termFreq.set(token, (termFreq.get(token) || 0) + 1);
-      if (!seenTerms.has(token)) {
-        seenTerms.add(token);
-        this.documentFrequencies.set(token, (this.documentFrequencies.get(token) || 0) + 1);
-      }
-    }
-    this.termFrequencies.set(doc.id, termFreq);
-    this.updateAvgDocLength();
-  }
-  /**
-   * Add multiple documents
-   */
-  addDocuments(docs) {
-    for (const doc of docs) {
-      this.addDocument(doc);
-    }
-  }
-  /**
-   * Search the index
-   */
-  search(query, limit = 10) {
-    const queryTokens = this.tokenize(query);
-    const scores = /* @__PURE__ */ new Map();
-    const N = this.documents.size;
-    for (const [docId] of this.documents) {
-      let score = 0;
-      const docLength = this.documentLengths.get(docId) || 0;
-      const termFreqs = this.termFrequencies.get(docId);
-      if (!termFreqs) continue;
-      for (const term of queryTokens) {
-        const tf = termFreqs.get(term) || 0;
-        if (tf === 0) continue;
-        const df = this.documentFrequencies.get(term) || 0;
-        const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
-        const numerator = tf * (this.k1 + 1);
-        const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
-        score += idf * (numerator / denominator);
-      }
-      if (score > 0) {
-        scores.set(docId, score);
-      }
-    }
-    return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, score]) => {
-      const metadata = this.documents.get(id)?.metadata;
-      const result = { id, score };
-      if (metadata !== void 0) {
-        result.metadata = metadata;
-      }
-      return result;
-    });
-  }
-  /**
-   * Get document count
-   */
-  get size() {
-    return this.documents.size;
-  }
-  /**
-   * Clear the index
-   */
-  clear() {
-    this.documents.clear();
-    this.termFrequencies.clear();
-    this.documentFrequencies.clear();
-    this.documentLengths.clear();
-    this.avgDocLength = 0;
-  }
-  /**
-   * Serialize the index to JSON
-   */
-  serialize() {
-    return JSON.stringify({
-      documents: Array.from(this.documents.entries()),
-      termFrequencies: Array.from(this.termFrequencies.entries()).map(([k, v]) => [k, Array.from(v.entries())]),
-      documentFrequencies: Array.from(this.documentFrequencies.entries()),
-      documentLengths: Array.from(this.documentLengths.entries()),
-      avgDocLength: this.avgDocLength
-    });
-  }
-  /**
-   * Load from serialized JSON
-   */
-  static deserialize(json) {
-    const data = JSON.parse(json);
-    const index = new _BM25Index();
-    index.documents = new Map(data.documents);
-    index.termFrequencies = new Map(data.termFrequencies.map(([k, v]) => [k, new Map(v)]));
-    index.documentFrequencies = new Map(data.documentFrequencies);
-    index.documentLengths = new Map(data.documentLengths);
-    index.avgDocLength = data.avgDocLength;
-    return index;
-  }
-  tokenize(text) {
-    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 2 && !this.isStopWord(token));
-  }
-  isStopWord(word) {
-    const stopWords = /* @__PURE__ */ new Set([
-      "the",
-      "be",
-      "to",
-      "of",
-      "and",
-      "a",
-      "in",
-      "that",
-      "have",
-      "i",
-      "it",
-      "for",
-      "not",
-      "on",
-      "with",
-      "he",
-      "as",
-      "you",
-      "do",
-      "at",
-      "this",
-      "but",
-      "his",
-      "by",
-      "from",
-      "they",
-      "we",
-      "say",
-      "her",
-      "she",
-      "or",
-      "an",
-      "will",
-      "my",
-      "one",
-      "all",
-      "would",
-      "there",
-      "their",
-      "what",
-      "so",
-      "up",
-      "out",
-      "if",
-      "about",
-      "who",
-      "get",
-      "which",
-      "go",
-      "me",
-      "when",
-      "make",
-      "can",
-      "like",
-      "time",
-      "no",
-      "just",
-      "him",
-      "know",
-      "take",
-      "into",
-      "year",
-      "your",
-      "some",
-      "could",
-      "them",
-      "see",
-      "other",
-      "than",
-      "then",
-      "now",
-      "look",
-      "only",
-      "come",
-      "its",
-      "over",
-      "also",
-      "back",
-      "after",
-      "use",
-      "two",
-      "how",
-      "our",
-      "first",
-      "way",
-      "even",
-      "new",
-      "want",
-      "because",
-      "any",
-      "these",
-      "give",
-      "day",
-      "most",
-      "us",
-      "should",
-      "been",
-      "has",
-      "was",
-      "are"
-    ]);
-    return stopWords.has(word);
-  }
-  updateAvgDocLength() {
-    if (this.documentLengths.size === 0) {
-      this.avgDocLength = 0;
-      return;
-    }
-    const total = Array.from(this.documentLengths.values()).reduce((a, b) => a + b, 0);
-    this.avgDocLength = total / this.documentLengths.size;
-  }
-};
-
-// src/memory/ledger.ts
-import { createHash } from "crypto";
-import { mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-var LEDGER_FILENAME = "ledger.json";
-var GENESIS_HASH = "0".repeat(64);
-var LEDGER_VERSION = 1;
-async function appendIssuesToLedger(issues, workDir) {
-  if (issues.length === 0) return null;
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
-  await mkdir3(memoryDir, { recursive: true });
-  const blocks = await loadLedger(projectDir);
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const entries = issues.map((issue) => ({
-    id: issue.id,
-    hash: issue.hash,
-    severity: issue.severity,
-    file: issue.file,
-    agent: issue.agent,
-    timestamp: issue.timestamp
-  }));
-  const previousBlock = blocks[blocks.length - 1];
-  const block = previousBlock && previousBlock.date === today ? previousBlock : createBlock(today, now, previousBlock?.blockHash ?? GENESIS_HASH);
-  if (block !== previousBlock) {
-    blocks.push(block);
-  }
-  block.entries = [...block.entries, ...entries];
-  block.merkleRoot = computeMerkleRoot(block.entries.map((entry) => entry.hash));
-  block.blockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
-  block.updatedAt = now;
-  await saveLedger(blocks, projectDir);
-  return block;
-}
-function computeMerkleRoot(hashes) {
-  if (hashes.length === 0) {
-    return sha256("");
-  }
-  let level = hashes.slice();
-  while (level.length > 1) {
-    const nextLevel = [];
-    for (let i = 0; i < level.length; i += 2) {
-      const left = level[i];
-      const right = level[i + 1] ?? left;
-      nextLevel.push(sha256(`${left}:${right}`));
-    }
-    level = nextLevel;
-  }
-  return level[0];
-}
-function computeBlockHash(previousHash, merkleRoot, date, version) {
-  return sha256(`${version}:${date}:${previousHash}:${merkleRoot}`);
-}
-function createBlock(date, now, previousHash) {
-  return {
-    version: LEDGER_VERSION,
-    date,
-    entries: [],
-    previousHash,
-    merkleRoot: "",
-    blockHash: "",
-    createdAt: now,
-    updatedAt: now
-  };
-}
-async function loadLedger(projectDir) {
-  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  try {
-    if (!existsSync3(ledgerPath)) return [];
-    const content = await readFile3(ledgerPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (!Array.isArray(parsed)) return [];
-    return parsed;
-  } catch {
-    return [];
-  }
-}
-async function saveLedger(blocks, projectDir) {
-  const ledgerPath = join3(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
-  await atomicWriteJSON(ledgerPath, blocks);
-}
-function sha256(input) {
-  return createHash("sha256").update(input).digest("hex");
-}
-
-// src/memory/issue-store.ts
-async function storeIssues(issues, project, workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join4(getTrieDirectory(projectDir), "memory");
-  await mkdir4(memoryDir, { recursive: true });
-  const stored = [];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const seenHashes = /* @__PURE__ */ new Set();
-  let duplicates = 0;
-  for (const issue of issues) {
-    const hash = hashIssue(issue);
-    if (seenHashes.has(hash)) {
-      duplicates++;
-      continue;
-    }
-    seenHashes.add(hash);
-    const storedIssue = {
-      id: issue.id,
-      hash,
-      severity: issue.severity,
-      issue: issue.issue,
-      fix: issue.fix,
-      file: issue.file,
-      line: issue.line,
-      agent: issue.agent,
-      category: issue.category,
-      timestamp: now,
-      project,
-      resolved: false,
-      resolvedAt: void 0
-    };
-    stored.push(storedIssue);
-  }
-  await appendToDailyLog(stored, projectDir);
-  await appendIssuesToLedger(stored, projectDir);
-  const dedupedCount = await updateIssueIndex(stored, projectDir);
-  return { stored: dedupedCount, duplicates: duplicates + (stored.length - dedupedCount) };
-}
-async function searchIssues(query, options = {}) {
-  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
-  const limit = options.limit || 10;
-  const allIssues = await loadIssueIndex(projectDir);
-  if (allIssues.length === 0) {
-    return [];
-  }
-  const filteredIssues = allIssues.filter((issue) => {
-    if (options.project && issue.project !== options.project) return false;
-    if (options.severity && !options.severity.includes(issue.severity)) return false;
-    if (options.agent && issue.agent !== options.agent) return false;
-    if (!options.includeResolved && issue.resolved) return false;
-    return true;
-  });
-  if (filteredIssues.length === 0) {
-    return [];
-  }
-  const bm25 = new BM25Index();
-  const issueMap = /* @__PURE__ */ new Map();
-  for (const issue of filteredIssues) {
-    const searchText = `${issue.issue} ${issue.fix} ${issue.file} ${issue.agent} ${issue.category || ""} ${issue.severity}`;
-    bm25.addDocument({
-      id: issue.id,
-      text: searchText
-    });
-    issueMap.set(issue.id, issue);
-  }
-  const bm25Results = bm25.search(query, limit);
-  return bm25Results.map((result) => ({
-    issue: issueMap.get(result.id),
-    score: result.score,
-    matchType: "bm25"
-  }));
-}
-async function findSimilarIssues(issue, options = {}) {
-  const query = `${issue.issue} ${issue.fix} ${issue.agent}`;
-  const searchOptions = {
-    limit: (options.limit || 5) + 5,
-    // Get extra to account for filtering
-    includeResolved: true
-  };
-  if (options.workDir !== void 0) {
-    searchOptions.workDir = options.workDir;
-  }
-  const results = await searchIssues(query, searchOptions);
-  let filtered = results.filter((r) => r.issue.id !== issue.id);
-  if (options.excludeSameFile) {
-    filtered = filtered.filter((r) => r.issue.file !== issue.file);
-  }
-  return filtered.slice(0, options.limit || 5);
-}
-async function markIssueResolved(issueId, workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const index = await loadIssueIndex(projectDir);
-  const issue = index.find((i) => i.id === issueId);
-  if (!issue) return false;
-  issue.resolved = true;
-  issue.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await saveIssueIndex(index, projectDir);
-  return true;
-}
-async function autoResolveIssues(newIssueHashes, scannedFiles, workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const index = await loadIssueIndex(projectDir);
-  const scannedFileSet = new Set(scannedFiles.map((f) => f.replace(/\\/g, "/")));
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let resolvedCount = 0;
-  let stillActiveCount = 0;
-  for (const issue of index) {
-    if (issue.resolved) continue;
-    const normalizedFile = issue.file.replace(/\\/g, "/");
-    if (!scannedFileSet.has(normalizedFile)) {
-      stillActiveCount++;
-      continue;
-    }
-    if (!newIssueHashes.has(issue.hash)) {
-      issue.resolved = true;
-      issue.resolvedAt = now;
-      resolvedCount++;
-    } else {
-      stillActiveCount++;
-    }
-  }
-  if (resolvedCount > 0) {
-    await saveIssueIndex(index, projectDir);
-  }
-  return { resolved: resolvedCount, stillActive: stillActiveCount };
-}
-function getIssueHash(issue) {
-  return hashIssue(issue);
-}
-async function getMemoryStats(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const index = await loadIssueIndex(projectDir);
-  const historical = await getHistoricalInsights(projectDir);
-  const MAX_ISSUES = 1e4;
-  const uniqueHashes = new Set(index.map((i) => i.hash));
-  const stats = {
-    totalIssues: index.length,
-    activeIssues: 0,
-    issuesByAgent: {},
-    issuesBySeverity: {},
-    activeIssuesBySeverity: {},
-    oldestIssue: void 0,
-    newestIssue: void 0,
-    resolvedCount: 0,
-    historicalIssues: historical.totalHistoricalIssues,
-    improvementTrend: historical.improvementTrend,
-    capacityInfo: {
-      current: index.length,
-      max: MAX_ISSUES,
-      percentFull: Math.round(index.length / MAX_ISSUES * 100),
-      isAtCap: index.length >= MAX_ISSUES
-    },
-    deduplicationStats: {
-      duplicatesAvoided: index.length - uniqueHashes.size,
-      uniquePatterns: uniqueHashes.size
-    }
-  };
-  for (const issue of index) {
-    stats.issuesByAgent[issue.agent] = (stats.issuesByAgent[issue.agent] || 0) + 1;
-    stats.issuesBySeverity[issue.severity] = (stats.issuesBySeverity[issue.severity] || 0) + 1;
-    if (issue.resolved) {
-      stats.resolvedCount++;
-    } else {
-      stats.activeIssues++;
-      stats.activeIssuesBySeverity[issue.severity] = (stats.activeIssuesBySeverity[issue.severity] || 0) + 1;
-    }
-  }
-  if (index.length > 0) {
-    const sorted = [...index].sort(
-      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-    );
-    const oldest = sorted[0]?.timestamp;
-    const newest = sorted[sorted.length - 1]?.timestamp;
-    if (oldest !== void 0) {
-      stats.oldestIssue = oldest;
-    }
-    if (newest !== void 0) {
-      stats.newestIssue = newest;
-    }
-  }
-  return stats;
-}
-async function getRecentIssues(options = {}) {
-  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
-  const index = await loadIssueIndex(projectDir);
-  const limit = options.limit || 20;
-  const daysBack = options.daysBack || 7;
-  const includeResolved = options.includeResolved ?? false;
-  const cutoff = /* @__PURE__ */ new Date();
-  cutoff.setDate(cutoff.getDate() - daysBack);
-  return index.filter((i) => {
-    if (new Date(i.timestamp) < cutoff) return false;
-    if (!includeResolved && i.resolved) return false;
-    return true;
-  }).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
-}
-async function purgeIssues(strategy, options = {}) {
-  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
-  const index = await loadIssueIndex(projectDir);
-  const originalCount = index.length;
-  let remaining = [];
-  switch (strategy) {
-    case "smart":
-      const thirtyDaysAgo = /* @__PURE__ */ new Date();
-      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
-      remaining = index.filter((i) => {
-        const isRecent = new Date(i.timestamp) >= thirtyDaysAgo;
-        const isImportant = ["critical", "high"].includes(i.severity);
-        const isUnresolved = !i.resolved;
-        return isRecent || isImportant || isUnresolved;
-      });
-      break;
-    case "resolved":
-      remaining = index.filter((i) => !i.resolved);
-      break;
-    case "old":
-      const daysOld = options.daysOld || 90;
-      const cutoffDate = /* @__PURE__ */ new Date();
-      cutoffDate.setDate(cutoffDate.getDate() - daysOld);
-      remaining = index.filter((i) => new Date(i.timestamp) >= cutoffDate);
-      break;
-    case "all":
-      remaining = [];
-      break;
-  }
-  await saveIssueIndex(remaining, projectDir);
-  return {
-    removed: originalCount - remaining.length,
-    remaining: remaining.length,
-    strategy
-  };
-}
-async function getDailyLogs(workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join4(getTrieDirectory(projectDir), "memory");
-  try {
-    if (!existsSync4(memoryDir)) return [];
-    const files = await readdir2(memoryDir);
-    return files.filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
-  } catch {
-    return [];
-  }
-}
-async function appendToDailyLog(issues, projectDir) {
-  const memoryDir = join4(getTrieDirectory(projectDir), "memory");
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const logPath = join4(memoryDir, `${today}.md`);
-  let content = "";
-  try {
-    if (existsSync4(logPath)) {
-      content = await readFile4(logPath, "utf-8");
-    } else {
-      content = `# Issue Log: ${today}
-
-`;
-    }
-  } catch {
-    content = `# Issue Log: ${today}
-
-`;
-  }
-  const time = (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0];
-  const newEntries = issues.map(
-    (i) => `## [${time}] ${i.severity.toUpperCase()}: ${i.issue.slice(0, 80)}${i.issue.length > 80 ? "..." : ""}
-- **File:** \`${i.file}\`${i.line ? `:${i.line}` : ""}
-- **Agent:** ${i.agent}
-- **Fix:** ${i.fix.slice(0, 200)}${i.fix.length > 200 ? "..." : ""}
-`
-  ).join("\n");
-  content += newEntries + "\n";
-  await writeFile2(logPath, content);
-}
-async function loadIssueIndex(projectDir) {
-  const indexPath = join4(getTrieDirectory(projectDir), "memory", "issues.json");
-  try {
-    if (existsSync4(indexPath)) {
-      const content = await readFile4(indexPath, "utf-8");
-      const result = safeParseAndValidate(content, IssueIndexSchema);
-      if (result.success) {
-        return result.data;
-      }
-      console.error(`   Issue index corrupted: ${result.error}`);
-      const backupManager = new BackupManager(indexPath);
-      if (await backupManager.recoverFromBackup()) {
-        console.error("   \u2705 Recovered from backup");
-        const recovered = await readFile4(indexPath, "utf-8");
-        const recoveredResult = safeParseAndValidate(recovered, IssueIndexSchema);
-        if (recoveredResult.success) {
-          return recoveredResult.data;
-        }
-      }
-      console.error("   No valid backup found, starting fresh");
-    }
-  } catch {
-  }
-  return [];
-}
-async function updateIssueIndex(newIssues, projectDir) {
-  const memoryDir = join4(getTrieDirectory(projectDir), "memory");
-  await mkdir4(memoryDir, { recursive: true });
-  let existing = await loadIssueIndex(projectDir);
-  const hashSet = new Set(existing.map((i) => i.hash));
-  const toAdd = newIssues.filter((i) => !hashSet.has(i.hash));
-  const dedupedCount = toAdd.length;
-  existing = [...existing, ...toAdd];
-  if (existing.length > 500) {
-    const { summary, remaining } = await compactOldIssues(existing, {
-      keepDays: 30,
-      minIssuesToCompact: 100
-    });
-    if (summary) {
-      await saveCompactedSummary(summary, projectDir);
-      existing = remaining;
-    }
-  }
-  if (existing.length > 1e4) {
-    existing = intelligentPrune(existing, 1e4);
-  }
-  await saveIssueIndex(existing, projectDir);
-  return dedupedCount;
-}
-function intelligentPrune(issues, targetCount) {
-  const severityWeight = {
-    critical: 100,
-    high: 50,
-    moderate: 20,
-    low: 10,
-    info: 5
-  };
-  const scored = issues.map((issue) => {
-    const ageInDays = (Date.now() - new Date(issue.timestamp).getTime()) / (1e3 * 60 * 60 * 24);
-    const recencyScore = Math.max(0, 100 - ageInDays * 2);
-    const severityScore = severityWeight[issue.severity] || 10;
-    const resolvedPenalty = issue.resolved ? -50 : 0;
-    return {
-      issue,
-      score: recencyScore + severityScore + resolvedPenalty
-    };
-  });
-  return scored.sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.issue);
-}
-async function saveIssueIndex(issues, projectDir) {
-  const memoryDir = join4(getTrieDirectory(projectDir), "memory");
-  await mkdir4(memoryDir, { recursive: true });
-  const indexPath = join4(memoryDir, "issues.json");
-  const backupManager = new BackupManager(indexPath);
-  await backupManager.createBackup();
-  await atomicWriteJSON(indexPath, issues);
-}
-function hashIssue(issue) {
-  const content = `${issue.issue}|${issue.file}|${issue.severity}|${issue.agent}`;
-  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
-}
-
-// src/guardian/guardian-state.ts
-import { mkdir as mkdir5, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
-import { z as z2 } from "zod";
-var GoalSchema = z2.object({
-  id: z2.string(),
-  description: z2.string(),
-  type: z2.enum(["streak", "reduction", "score", "custom"]),
-  metric: z2.string(),
-  target: z2.number(),
-  currentValue: z2.number(),
-  startValue: z2.number().optional(),
-  status: z2.enum(["active", "achieved", "failed", "paused", "rejected"]),
-  autoGenerated: z2.boolean(),
-  confidence: z2.number().min(0).max(1).optional(),
-  // For auto-generated goals
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  achievedAt: z2.string().optional(),
-  deadline: z2.string().optional(),
-  category: z2.enum(["security", "quality", "performance", "coverage", "general"]).optional(),
-  evidence: z2.array(z2.string()).optional()
-  // Why this goal was generated
-});
-var HypothesisSchema = z2.object({
-  id: z2.string(),
-  statement: z2.string(),
-  confidence: z2.number().min(0).max(1),
-  // 0-1, adjusts based on validation
-  status: z2.enum(["proposed", "testing", "validated", "invalidated", "retired"]),
-  evidence: z2.array(z2.object({
-    type: z2.enum(["supporting", "contradicting"]),
-    description: z2.string(),
-    timestamp: z2.string(),
-    weight: z2.number().min(0).max(1).optional()
-  })),
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  validatedAt: z2.string().optional(),
-  testCriteria: z2.string().optional(),
-  category: z2.enum(["timing", "pattern", "team", "code", "general"]).optional()
-});
-var RiskBudgetSchema = z2.object({
-  daily: z2.number(),
-  weekly: z2.number(),
-  usedToday: z2.number(),
-  usedThisWeek: z2.number(),
-  lastResetDay: z2.string(),
-  // ISO date (YYYY-MM-DD)
-  lastResetWeek: z2.string()
-  // ISO week (YYYY-WNN)
-});
-var AgentMetricsSchema = z2.object({
-  predictiveAccuracy: z2.number().min(0).max(1),
-  falsePositiveRate: z2.number().min(0).max(1),
-  userSatisfaction: z2.number().min(0).max(1),
-  hypothesisAccuracy: z2.number().min(0).max(1),
-  totalPredictions: z2.number(),
-  correctPredictions: z2.number(),
-  totalInsights: z2.number(),
-  helpfulInsights: z2.number(),
-  dismissedInsights: z2.number(),
-  actedOnInsights: z2.number()
-});
-var TimingContextSchema = z2.object({
-  quietHoursStart: z2.number().min(0).max(23),
-  // Hour of day (0-23)
-  quietHoursEnd: z2.number().min(0).max(23),
-  quietHoursEnabled: z2.boolean(),
-  workDays: z2.array(z2.number().min(0).max(6)),
-  // 0 = Sunday
-  lastActiveTimestamp: z2.number(),
-  timezone: z2.string().optional(),
-  crunchMode: z2.boolean(),
-  // During crunch, defer low-priority items
-  crunchModeUntil: z2.string().optional()
-});
-var GuardianStateDataSchema = z2.object({
-  version: z2.literal(1),
-  goals: z2.array(GoalSchema),
-  hypotheses: z2.array(HypothesisSchema),
-  riskBudget: RiskBudgetSchema,
-  metrics: AgentMetricsSchema,
-  timing: TimingContextSchema,
-  scanFrequencyMs: z2.number(),
-  // Current scan frequency
-  lastScanTimestamp: z2.number().optional(),
-  lastUpdated: z2.string()
-});
-var GuardianState = class {
-  projectPath;
-  data;
-  loaded = false;
-  dirty = false;
-  constructor(projectPath) {
-    this.projectPath = projectPath;
-    this.data = this.createDefaultState();
-  }
-  /**
-   * Get the storage file path
-   */
-  getStorePath() {
-    return join5(getTrieDirectory(this.projectPath), "memory", "guardian-state.json");
-  }
-  /**
-   * Create default state
-   */
-  createDefaultState() {
-    const now = /* @__PURE__ */ new Date();
-    const today = now.toISOString().split("T")[0];
-    const week = this.getISOWeek(now);
-    return {
-      version: 1,
-      goals: [],
-      hypotheses: [],
-      riskBudget: {
-        daily: 10,
-        weekly: 50,
-        usedToday: 0,
-        usedThisWeek: 0,
-        lastResetDay: today,
-        lastResetWeek: week
-      },
-      metrics: {
-        predictiveAccuracy: 0.5,
-        // Start neutral
-        falsePositiveRate: 0.5,
-        userSatisfaction: 0.5,
-        hypothesisAccuracy: 0.5,
-        totalPredictions: 0,
-        correctPredictions: 0,
-        totalInsights: 0,
-        helpfulInsights: 0,
-        dismissedInsights: 0,
-        actedOnInsights: 0
-      },
-      timing: {
-        quietHoursStart: 21,
-        // 9 PM
-        quietHoursEnd: 8,
-        // 8 AM
-        quietHoursEnabled: true,
-        workDays: [1, 2, 3, 4, 5],
-        // Mon-Fri
-        lastActiveTimestamp: Date.now(),
-        crunchMode: false
-      },
-      scanFrequencyMs: 3e5,
-      // 5 minutes default
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  /**
-   * Get ISO week string (YYYY-WNN)
-   */
-  getISOWeek(date) {
-    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-    const dayNum = d.getUTCDay() || 7;
-    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-    const weekNo = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
-    return `${d.getUTCFullYear()}-W${weekNo.toString().padStart(2, "0")}`;
-  }
-  /**
-   * Load state from disk
-   */
-  async load() {
-    if (this.loaded) {
-      return this.data;
-    }
-    const storePath = this.getStorePath();
-    try {
-      if (existsSync5(storePath)) {
-        const content = await readFile5(storePath, "utf-8");
-        const result = safeParseAndValidate(content, GuardianStateDataSchema);
-        if (result.success) {
-          this.data = result.data;
-          this.loaded = true;
-          await this.checkAndResetBudgets();
-          return this.data;
-        }
-        console.error(`   Guardian state corrupted: ${result.error}`);
-        const backupManager = new BackupManager(storePath);
-        if (await backupManager.recoverFromBackup()) {
-          console.error("   \u2705 Recovered from backup");
-          const recovered = await readFile5(storePath, "utf-8");
-          const recoveredResult = safeParseAndValidate(recovered, GuardianStateDataSchema);
-          if (recoveredResult.success) {
-            this.data = recoveredResult.data;
-            this.loaded = true;
-            return this.data;
-          }
-        }
-        console.error("   No valid backup found, starting fresh");
-      }
-    } catch (error) {
-      console.error(`   Could not load guardian state: ${error}`);
-    }
-    this.data = this.createDefaultState();
-    this.loaded = true;
-    return this.data;
-  }
-  /**
-   * Save state to disk
-   */
-  async save() {
-    if (!this.dirty && this.loaded) {
-      return;
-    }
-    const storePath = this.getStorePath();
-    const memoryDir = join5(getTrieDirectory(this.projectPath), "memory");
-    await mkdir5(memoryDir, { recursive: true });
-    const backupManager = new BackupManager(storePath);
-    await backupManager.createBackup();
-    this.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    await atomicWriteJSON(storePath, this.data);
-    this.dirty = false;
-  }
-  /**
-   * Check and reset daily/weekly budgets if needed
-   */
-  async checkAndResetBudgets() {
-    const now = /* @__PURE__ */ new Date();
-    const today = now.toISOString().split("T")[0];
-    const week = this.getISOWeek(now);
-    let needsSave = false;
-    if (this.data.riskBudget.lastResetDay !== today) {
-      this.data.riskBudget.usedToday = 0;
-      this.data.riskBudget.lastResetDay = today;
-      needsSave = true;
-    }
-    if (this.data.riskBudget.lastResetWeek !== week) {
-      this.data.riskBudget.usedThisWeek = 0;
-      this.data.riskBudget.lastResetWeek = week;
-      needsSave = true;
-    }
-    if (needsSave) {
-      this.dirty = true;
-      await this.save();
-    }
-  }
-  // ========================================================================
-  // Goals
-  // ========================================================================
-  /**
-   * Add a goal
-   */
-  async addGoal(goal) {
-    await this.load();
-    if (this.data.goals.some((g) => g.id === goal.id)) {
-      return false;
-    }
-    this.data.goals.push(goal);
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Update a goal
-   */
-  async updateGoal(goalId, updates) {
-    await this.load();
-    const goal = this.data.goals.find((g) => g.id === goalId);
-    if (!goal) {
-      return false;
-    }
-    Object.assign(goal, updates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Get active goals
-   */
-  getActiveGoals() {
-    return this.data.goals.filter((g) => g.status === "active");
-  }
-  /**
-   * Get all goals
-   */
-  getAllGoals() {
-    return [...this.data.goals];
-  }
-  /**
-   * Get goal by ID
-   */
-  getGoal(goalId) {
-    return this.data.goals.find((g) => g.id === goalId);
-  }
-  /**
-   * Remove a goal
-   */
-  async removeGoal(goalId) {
-    await this.load();
-    const index = this.data.goals.findIndex((g) => g.id === goalId);
-    if (index === -1) {
-      return false;
-    }
-    this.data.goals.splice(index, 1);
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Get auto-generated goals
-   */
-  getAutoGeneratedGoals() {
-    return this.data.goals.filter((g) => g.autoGenerated);
-  }
-  /**
-   * Accept or reject an auto-generated goal
-   */
-  async respondToGoal(goalId, accept) {
-    return this.updateGoal(goalId, {
-      status: accept ? "active" : "rejected"
-    });
-  }
-  // ========================================================================
-  // Hypotheses
-  // ========================================================================
-  /**
-   * Add a hypothesis
-   */
-  async addHypothesis(hypothesis) {
-    await this.load();
-    if (this.data.hypotheses.some((h) => h.id === hypothesis.id)) {
-      return false;
-    }
-    this.data.hypotheses.push(hypothesis);
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Update a hypothesis
-   */
-  async updateHypothesis(hypothesisId, updates) {
-    await this.load();
-    const hypothesis = this.data.hypotheses.find((h) => h.id === hypothesisId);
-    if (!hypothesis) {
-      return false;
-    }
-    Object.assign(hypothesis, updates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Add evidence to a hypothesis
-   */
-  async addEvidence(hypothesisId, evidence) {
-    await this.load();
-    const hypothesis = this.data.hypotheses.find((h) => h.id === hypothesisId);
-    if (!hypothesis) {
-      return false;
-    }
-    hypothesis.evidence.push({
-      ...evidence,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (hypothesis.status === "proposed" && hypothesis.evidence.length === 1) {
-      hypothesis.status = "testing";
-    }
-    const supportingCount = hypothesis.evidence.filter((e) => e.type === "supporting").length;
-    const contradictingCount = hypothesis.evidence.filter((e) => e.type === "contradicting").length;
-    const total = supportingCount + contradictingCount;
-    if (total > 0) {
-      hypothesis.confidence = supportingCount / total;
-      if (hypothesis.status === "testing") {
-        if (hypothesis.confidence > 0.8 && supportingCount >= 3) {
-          hypothesis.status = "validated";
-          hypothesis.validatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        } else if (hypothesis.confidence < 0.2 && contradictingCount >= 3) {
-          hypothesis.status = "invalidated";
-        }
-      }
-    }
-    hypothesis.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Get active hypotheses
-   */
-  getActiveHypotheses() {
-    return this.data.hypotheses.filter(
-      (h) => h.status === "proposed" || h.status === "testing"
-    );
-  }
-  /**
-   * Get validated hypotheses
-   */
-  getValidatedHypotheses() {
-    return this.data.hypotheses.filter((h) => h.status === "validated");
-  }
-  /**
-   * Get all hypotheses
-   */
-  getAllHypotheses() {
-    return [...this.data.hypotheses];
-  }
-  /**
-   * Get hypothesis by ID
-   */
-  getHypothesis(hypothesisId) {
-    return this.data.hypotheses.find((h) => h.id === hypothesisId);
-  }
-  // ========================================================================
-  // Risk Budget
-  // ========================================================================
-  /**
-   * Get current risk budget
-   */
-  getRiskBudget() {
-    return { ...this.data.riskBudget };
-  }
-  /**
-   * Use risk budget
-   */
-  async useRiskBudget(amount) {
-    await this.load();
-    await this.checkAndResetBudgets();
-    if (this.data.riskBudget.usedToday + amount > this.data.riskBudget.daily) {
-      return false;
-    }
-    if (this.data.riskBudget.usedThisWeek + amount > this.data.riskBudget.weekly) {
-      return false;
-    }
-    this.data.riskBudget.usedToday += amount;
-    this.data.riskBudget.usedThisWeek += amount;
-    this.dirty = true;
-    await this.save();
-    return true;
-  }
-  /**
-   * Check if risk budget is available
-   */
-  hasRiskBudget(amount = 1) {
-    return this.data.riskBudget.usedToday + amount <= this.data.riskBudget.daily && this.data.riskBudget.usedThisWeek + amount <= this.data.riskBudget.weekly;
-  }
-  /**
-   * Update risk budget limits
-   */
-  async setRiskBudget(daily, weekly) {
-    await this.load();
-    this.data.riskBudget.daily = daily;
-    this.data.riskBudget.weekly = weekly;
-    this.dirty = true;
-    await this.save();
-  }
-  // ========================================================================
-  // Metrics
-  // ========================================================================
-  /**
-   * Get agent metrics
-   */
-  getMetrics() {
-    return { ...this.data.metrics };
-  }
-  /**
-   * Record a prediction outcome
-   */
-  async recordPrediction(correct) {
-    await this.load();
-    this.data.metrics.totalPredictions++;
-    if (correct) {
-      this.data.metrics.correctPredictions++;
-    }
-    this.data.metrics.predictiveAccuracy = this.data.metrics.correctPredictions / this.data.metrics.totalPredictions;
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Record user feedback on an insight
-   */
-  async recordInsightFeedback(feedback) {
-    await this.load();
-    this.data.metrics.totalInsights++;
-    switch (feedback) {
-      case "helpful":
-        this.data.metrics.helpfulInsights++;
-        break;
-      case "dismissed":
-        this.data.metrics.dismissedInsights++;
-        break;
-      case "acted":
-        this.data.metrics.actedOnInsights++;
-        this.data.metrics.helpfulInsights++;
-        break;
-    }
-    if (this.data.metrics.totalInsights > 0) {
-      this.data.metrics.userSatisfaction = this.data.metrics.helpfulInsights / this.data.metrics.totalInsights;
-      this.data.metrics.falsePositiveRate = this.data.metrics.dismissedInsights / this.data.metrics.totalInsights;
-    }
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Update hypothesis accuracy
-   */
-  async updateHypothesisAccuracy() {
-    await this.load();
-    const validated = this.data.hypotheses.filter((h) => h.status === "validated").length;
-    const invalidated = this.data.hypotheses.filter((h) => h.status === "invalidated").length;
-    const total = validated + invalidated;
-    if (total > 0) {
-      this.data.metrics.hypothesisAccuracy = validated / total;
-      this.dirty = true;
-      await this.save();
-    }
-  }
-  // ========================================================================
-  // Timing Context
-  // ========================================================================
-  /**
-   * Get timing context
-   */
-  getTimingContext() {
-    return { ...this.data.timing };
-  }
-  /**
-   * Check if currently in quiet hours
-   */
-  isQuietHours() {
-    if (!this.data.timing.quietHoursEnabled) {
-      return false;
-    }
-    const now = /* @__PURE__ */ new Date();
-    const hour = now.getHours();
-    const start = this.data.timing.quietHoursStart;
-    const end = this.data.timing.quietHoursEnd;
-    if (start > end) {
-      return hour >= start || hour < end;
-    }
-    return hour >= start && hour < end;
-  }
-  /**
-   * Check if today is a work day
-   */
-  isWorkDay() {
-    const dayOfWeek = (/* @__PURE__ */ new Date()).getDay();
-    return this.data.timing.workDays.includes(dayOfWeek);
-  }
-  /**
-   * Check if in crunch mode
-   */
-  isInCrunchMode() {
-    if (!this.data.timing.crunchMode) {
-      return false;
-    }
-    if (this.data.timing.crunchModeUntil) {
-      const until = new Date(this.data.timing.crunchModeUntil);
-      if (Date.now() > until.getTime()) {
-        this.data.timing.crunchMode = false;
-        this.data.timing.crunchModeUntil = void 0;
-        this.dirty = true;
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Enable crunch mode
-   */
-  async setCrunchMode(enabled, until) {
-    await this.load();
-    this.data.timing.crunchMode = enabled;
-    this.data.timing.crunchModeUntil = until?.toISOString();
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Update quiet hours settings
-   */
-  async setQuietHours(start, end, enabled = true) {
-    await this.load();
-    this.data.timing.quietHoursStart = start;
-    this.data.timing.quietHoursEnd = end;
-    this.data.timing.quietHoursEnabled = enabled;
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Update work days
-   */
-  async setWorkDays(days) {
-    await this.load();
-    this.data.timing.workDays = days;
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Update last active timestamp
-   */
-  async touchActive() {
-    await this.load();
-    this.data.timing.lastActiveTimestamp = Date.now();
-    this.dirty = true;
-    await this.save();
-  }
-  // ========================================================================
-  // Scan Frequency
-  // ========================================================================
-  /**
-   * Get current scan frequency in milliseconds
-   */
-  getScanFrequencyMs() {
-    return this.data.scanFrequencyMs;
-  }
-  /**
-   * Set scan frequency
-   */
-  async setScanFrequency(ms) {
-    await this.load();
-    this.data.scanFrequencyMs = Math.max(1e4, ms);
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Record a scan timestamp
-   */
-  async recordScan() {
-    await this.load();
-    this.data.lastScanTimestamp = Date.now();
-    this.dirty = true;
-    await this.save();
-  }
-  /**
-   * Get last scan timestamp
-   */
-  getLastScanTimestamp() {
-    return this.data.lastScanTimestamp;
-  }
-  // ========================================================================
-  // Utility
-  // ========================================================================
-  /**
-   * Get full state data
-   */
-  getData() {
-    return { ...this.data };
-  }
-  /**
-   * Force reload from disk
-   */
-  async reload() {
-    this.loaded = false;
-    this.dirty = false;
-    return this.load();
-  }
-  /**
-   * Check if loaded
-   */
-  isLoaded() {
-    return this.loaded;
-  }
-};
-var guardianStates = /* @__PURE__ */ new Map();
-function getGuardianState(projectPath) {
-  let state = guardianStates.get(projectPath);
-  if (!state) {
-    state = new GuardianState(projectPath);
-    guardianStates.set(projectPath, state);
-  }
-  return state;
-}
-
-export {
-  atomicWriteJSON,
-  BackupManager,
-  GlobalPatternsIndexSchema,
-  safeParseAndValidate,
-  getHistoricalInsights,
-  storeIssues,
-  searchIssues,
-  findSimilarIssues,
-  markIssueResolved,
-  autoResolveIssues,
-  getIssueHash,
-  getMemoryStats,
-  getRecentIssues,
-  purgeIssues,
-  getDailyLogs,
-  getGuardianState
-};
-//# sourceMappingURL=chunk-6JPPYG7F.js.map