@triedotdev/mcp 1.0.101 → 1.0.103

package/dist/{chunk-JDHR5BDR.js → chunk-6JPPYG7F.js}

@@ -3,241 +3,6 @@ import {
   getWorkingDirectory
 } from "./chunk-R4AAPFXC.js";
 
-// 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/compactor.ts
 import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
@@ -682,27 +447,262 @@ async function getHistoricalInsights(projectDir) {
   };
 }
 
-// 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,
+// 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
   }));
@@ -1123,6 +1123,675 @@ function hashIssue(issue) {
   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,
@@ -1138,6 +1807,7 @@ export {
   getMemoryStats,
   getRecentIssues,
   purgeIssues,
-  getDailyLogs
+  getDailyLogs,
+  getGuardianState
 };
-//# sourceMappingURL=chunk-JDHR5BDR.js.map
+//# sourceMappingURL=chunk-6JPPYG7F.js.map