@triedotdev/mcp 1.0.113 → 1.0.115

package/dist/chunk-KRH642MT.js

@@ -0,0 +1,947 @@
+import {
+  atomicWriteJSON
+} from "./chunk-43X6JBEM.js";
+import {
+  getTrieDirectory
+} from "./chunk-R4AAPFXC.js";
+
+// src/guardian/guardian-state.ts
+import { mkdir, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+
+// src/utils/backup-manager.ts
+import { copyFile, readdir, unlink, readFile, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, 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 = dirname(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 unlink(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 unlink(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/guardian/guardian-state.ts
+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
+  metadata: z2.record(z2.any()).optional()
+  // Track caught/fixed counts and other metadata
+});
+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 join2(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 (existsSync2(storePath)) {
+        const content = await readFile2(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 readFile2(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 = join2(getTrieDirectory(this.projectPath), "memory");
+    await mkdir(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 {
+  BackupManager,
+  IssueIndexSchema,
+  GlobalPatternsIndexSchema,
+  CompactedSummariesIndexSchema,
+  safeParseAndValidate,
+  getGuardianState
+};
+//# sourceMappingURL=chunk-KRH642MT.js.map