@toyako/hive 1.0.0

package/src/stability/StabilityEngine.ts

@@ -0,0 +1,216 @@
+/**
+ * StabilityEngine v2 — overlay layer for tracking consecutive stable tasks.
+ * Adds: input_exception, counter trace log, hidden failure rate.
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+export type FailureType = "execution_failure" | "reasoning_failure" | "context_failure" | "reviewer_failure" | "silent_failure" | "human_override" | "non_reproducible_failure" | "input_exception" | null;
+
+export interface StabilityRecord {
+  task_id: string;
+  stable: boolean;
+  failure_type: FailureType;
+  reset_agent: string | null;
+  counter_after: number;
+  task_output: string;
+  timestamp: string;
+  system_version: string;
+  environment_id: string;
+  runtime_hash: string;
+}
+
+export interface StabilityWindowStats {
+  stable_window_avg: number;
+  stable_window_max: number;
+  stable_window_min: number;
+  total_tasks: number;
+  total_stable: number;
+  total_resets: number;
+  failure_density: number;
+  hidden_failure_rate: number;
+}
+
+export class StabilityEngine {
+  private counter = 0;
+  private records: StabilityRecord[] = [];
+  private windows: number[] = [];
+  private currentWindow = 0;
+  private logDir: string;
+  private systemVersion: string;
+  private counterTraceFile: string;
+  private recordsFile: string;
+
+  constructor(logDir?: string, systemVersion = "v1.11.0") {
+    this.logDir = logDir || path.resolve(process.cwd(), ".agent-hive/stability");
+    fs.mkdirSync(this.logDir, { recursive: true });
+    this.systemVersion = systemVersion;
+    this.counterTraceFile = path.join(this.logDir, "stability_counter_trace.log");
+    this.recordsFile = path.join(this.logDir, "stability_records.json");
+    this.loadPersistedRecords();
+  }
+
+  /**
+   * Load persisted records from disk on construction.
+   * Rebuilds counter and windows from the record history.
+   */
+  private loadPersistedRecords(): void {
+    try {
+      if (!fs.existsSync(this.recordsFile)) return;
+      const raw = fs.readFileSync(this.recordsFile, "utf-8");
+      const parsed: StabilityRecord[] = JSON.parse(raw);
+      if (!Array.isArray(parsed) || parsed.length === 0) return;
+
+      this.records = parsed;
+
+      // Rebuild counter and windows from records
+      this.windows = [];
+      this.currentWindow = 0;
+      this.counter = 0;
+
+      for (const record of this.records) {
+        if (record.stable) {
+          this.counter = record.counter_after;
+          this.currentWindow++;
+        } else {
+          if (this.currentWindow > 0) {
+            this.windows.push(this.currentWindow);
+          }
+          this.counter = 0;
+          this.currentWindow = 0;
+        }
+      }
+    } catch (e) {
+      // Corrupt file or parse error — start fresh (safe fallback)
+      console.warn("[StabilityEngine] Failed to load persisted records:", e);
+      this.records = [];
+      this.counter = 0;
+      this.windows = [];
+      this.currentWindow = 0;
+    }
+  }
+
+  /**
+   * Persist all records to disk after each evaluate().
+   * Consolidated JSON file for reliable restart recovery.
+   */
+  private persistRecord(): void {
+    try {
+      fs.writeFileSync(this.recordsFile, JSON.stringify(this.records, null, 2));
+    } catch (e) {
+      // Non-fatal: persistence failure shouldn't crash the engine
+      console.warn("[StabilityEngine] Failed to persist records:", e);
+    }
+  }
+
+  evaluate(task: {
+    task_id: string;
+    execution_success: boolean;
+    reasoning_failure?: boolean;
+    context_failure?: boolean;
+    reviewer_failure?: boolean;
+    silent_failure?: boolean;
+    human_override?: boolean;
+    non_reproducible?: boolean;
+    input_exception?: boolean;
+    task_output?: string;
+    reset_agent?: string;
+  }): StabilityRecord {
+    const failureType = this.detectFailure(task);
+    const isStable = failureType === null;
+
+    if (isStable) {
+      this.counter++;
+      this.currentWindow++;
+    } else {
+      if (this.currentWindow > 0) this.windows.push(this.currentWindow);
+      this.counter = 0;
+      this.currentWindow = 0;
+    }
+
+    const record: StabilityRecord = {
+      task_id: task.task_id,
+      stable: isStable,
+      failure_type: failureType,
+      reset_agent: isStable ? null : (task.reset_agent || null),
+      counter_after: this.counter,
+      task_output: task.task_output || "",
+      timestamp: new Date().toISOString(),
+      system_version: this.systemVersion,
+      environment_id: process.platform + "-" + process.arch,
+      runtime_hash: this.computeHash(task),
+    };
+
+    this.records.push(record);
+    this.persistRecord();
+    this.writeLog(record);
+    this.writeCounterTrace(record);
+
+    return record;
+  }
+
+  getCounter(): number { return this.counter; }
+
+  getTier(): string {
+    if (this.counter >= 300) return "system_maturity";
+    if (this.counter >= 100) return "architecture_freeze";
+    if (this.counter >= 30) return "light_observation";
+    return "warm_up";
+  }
+
+  getStats(): StabilityWindowStats {
+    const allWindows = [...this.windows, this.currentWindow];
+    const stable = this.records.filter(r => r.stable).length;
+    const resets = this.records.filter(r => !r.stable).length;
+    const hidden = this.records.filter(r => r.failure_type === "silent_failure").length;
+
+    return {
+      stable_window_avg: allWindows.length > 0 ? allWindows.reduce((a, b) => a + b, 0) / allWindows.length : 0,
+      stable_window_max: allWindows.length > 0 ? Math.max(...allWindows) : 0,
+      stable_window_min: allWindows.length > 0 ? Math.min(...allWindows) : 0,
+      total_tasks: this.records.length,
+      total_stable: stable,
+      total_resets: resets,
+      failure_density: this.records.length > 0 ? resets / this.records.length : 0,
+      hidden_failure_rate: this.records.length > 0 ? hidden / this.records.length : 0,
+    };
+  }
+
+  getRecords(): StabilityRecord[] { return [...this.records]; }
+  getRecent(n: number): StabilityRecord[] { return this.records.slice(-n); }
+
+  private detectFailure(task: any): FailureType {
+    if (!task.execution_success) return "execution_failure";
+    if (task.reasoning_failure) return "reasoning_failure";
+    if (task.context_failure) return "context_failure";
+    if (task.reviewer_failure) return "reviewer_failure";
+    if (task.silent_failure) return "silent_failure";
+    if (task.human_override) return "human_override";
+    if (task.non_reproducible) return "non_reproducible_failure";
+    if (task.input_exception) return "input_exception";
+    return null;
+  }
+
+  private computeHash(task: any): string {
+    const data = JSON.stringify({ id: task.task_id, out: task.task_output, ok: task.execution_success });
+    let h = 0;
+    for (let i = 0; i < data.length; i++) h = ((h << 5) - h + data.charCodeAt(i)) | 0;
+    return Math.abs(h).toString(36);
+  }
+
+  private writeLog(record: StabilityRecord): void {
+    // Use full timestamp (HHmmSSmmm) to prevent data loss when multiple
+    // records are written within the same minute (batch execution).
+    // Previous: slice(11,16) = HHmm → only 1 file/minute, later writes overwrite earlier.
+    // Fixed:   slice(11,23) = HHmmSSmmm → unique per-record filenames.
+    const d = record.timestamp.slice(0, 10).replace(/-/g, "");
+    const t = record.timestamp.slice(11, 23).replace(/[:.]/g, "");
+    fs.writeFileSync(path.join(this.logDir, `stability_window_trace_${d}_${t}.json`), JSON.stringify(record, null, 2));
+  }
+
+  private writeCounterTrace(record: StabilityRecord): void {
+    const status = record.stable ? "STABLE" : "RESET";
+    const line = `[${record.timestamp}] ${status} counter=${record.counter_after} task=${record.task_id} failure=${record.failure_type || "none"}\n`;
+    fs.appendFileSync(this.counterTraceFile, line);
+  }
+}

package/src/stability/TaskQualityGate.ts

@@ -0,0 +1,119 @@
+/**
+ * TaskQualityGate — validates tasks before they enter the system.
+ * Rejects tasks that don't meet quality standards.
+ */
+
+export type TaskPriority = "P0" | "P1" | "P2" | "P3";
+
+export interface TaskEntry {
+  task_id: string;
+  task_type: TaskPriority;
+  description: string;
+  data_source?: string;
+  success_criteria: string;
+  input_data?: string;
+  novelty_score?: number;
+}
+
+export interface QualityCheckResult {
+  accepted: boolean;
+  checks: {
+    input_validity: boolean;
+    output_verifiability: boolean;
+    failure_traceability: boolean;
+  };
+  rejection_reason?: string;
+}
+
+export class TaskQualityGate {
+  private seenPatterns: Set<string> = new Set();
+  private specVersion = "1.0.0";
+
+  /** Validate a task before it enters the system */
+  validate(entry: TaskEntry): QualityCheckResult {
+    const checks = {
+      input_validity: this.checkInputValidity(entry),
+      output_verifiability: this.checkOutputVerifiability(entry),
+      failure_traceability: this.checkFailureTraceability(entry),
+    };
+
+    const accepted = checks.input_validity && checks.output_verifiability && checks.failure_traceability;
+
+    if (!accepted) {
+      const failed = Object.entries(checks).filter(([_, v]) => !v).map(([k]) => k);
+      return { accepted: false, checks, rejection_reason: `Failed checks: ${failed.join(", ")}` };
+    }
+
+    // Track pattern for Blind Evaluation
+    this.seenPatterns.add(this.normalizePattern(entry.description));
+
+    return { accepted: true, checks };
+  }
+
+  /** Check if task has valid input */
+  private checkInputValidity(entry: TaskEntry): boolean {
+    // Must have description
+    if (!entry.description || entry.description.trim().length < 10) return false;
+
+    // Must not be purely hypothetical
+    const hypothetical = ["what if", "imagine", "suppose", "hypothetically"];
+    const lower = entry.description.toLowerCase();
+    if (hypothetical.some(h => lower.startsWith(h))) return false;
+
+    return true;
+  }
+
+  /** Check if output is verifiable */
+  private checkOutputVerifiability(entry: TaskEntry): boolean {
+    // Must have success_criteria
+    if (!entry.success_criteria || entry.success_criteria.trim().length < 5) return false;
+
+    // Must not be unverifiable
+    const unverifiable = ["see if it works", "check manually", "feel", "look at"];
+    const lower = entry.success_criteria.toLowerCase();
+    if (unverifiable.some(u => lower.includes(u))) return false;
+
+    return true;
+  }
+
+  /** Check if failure is traceable */
+  private checkFailureTraceability(entry: TaskEntry): boolean {
+    // Must have task_id
+    if (!entry.task_id || entry.task_id.trim().length === 0) return false;
+
+    // Must have task_type
+    if (!entry.task_type) return false;
+
+    return true;
+  }
+
+  /** Check if task is novel (Blind Evaluation) */
+  isNovel(description: string, track = true): boolean {
+    const pattern = this.normalizePattern(description);
+    const novel = !this.seenPatterns.has(pattern);
+    if (track && novel) this.seenPatterns.add(pattern);
+    return novel;
+  }
+
+  /** Get novelty score */
+  getNoveltyScore(description: string): number {
+    const pattern = this.normalizePattern(description);
+    if (!this.seenPatterns.has(pattern)) return 1.0; // Completely new
+
+    // Partial novelty based on word overlap
+    const words = pattern.split(" ");
+    let maxOverlap = 0;
+    for (const seen of this.seenPatterns) {
+      const seenWords = seen.split(" ");
+      const overlap = words.filter(w => seenWords.includes(w)).length;
+      const ratio = overlap / Math.max(words.length, seenWords.length);
+      maxOverlap = Math.max(maxOverlap, ratio);
+    }
+
+    return Math.max(0, 1 - maxOverlap);
+  }
+
+  private normalizePattern(description: string): string {
+    return description.toLowerCase().replace(/[^a-z0-9 ]/g, "").replace(/\s+/g, " ").trim().slice(0, 50);
+  }
+}