openhermes 4.11.2 → 4.12.1

package/harness/lib/routing/skill-frontmatter.ts

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import type { RouteOutcome, SkillRouteMap, SkillRoutingFrontmatter } from "./types.ts";
+
+const EMPTY_ROUTES: SkillRouteMap = {
+  pass: [],
+  fail: [],
+  blocker: [],
+};
+
+function stripQuotes(value: string): string {
+  return value.trim().replace(/^['"]|['"]$/g, "");
+}
+
+function parseRouteValue(value: string): string[] {
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed
+      .slice(1, -1)
+      .split(",")
+      .map((entry) => stripQuotes(entry))
+      .filter(Boolean);
+  }
+
+  return [stripQuotes(trimmed)].filter(Boolean);
+}
+
+function isRouteOutcome(value: string): value is RouteOutcome {
+  return value === "pass" || value === "fail" || value === "blocker";
+}
+
+export function extractFrontmatter(source: string): string | null {
+  const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  return match?.[1] ?? null;
+}
+
+export function parseSkillFrontmatter(source: string): SkillRoutingFrontmatter | null {
+  const rawFrontmatter = extractFrontmatter(source);
+  if (!rawFrontmatter) return null;
+
+  const route: SkillRouteMap = {
+    pass: [],
+    fail: [],
+    blocker: [],
+  };
+
+  let name: string | undefined;
+  let description: string | undefined;
+  let tier: string | undefined;
+  let inRouteBlock = false;
+  let activeRouteKey: RouteOutcome | null = null;
+
+  for (const rawLine of rawFrontmatter.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    const trimmed = line.trim();
+
+    if (!trimmed) continue;
+
+    if (/^route:\s*$/.test(trimmed)) {
+      inRouteBlock = true;
+      activeRouteKey = null;
+      continue;
+    }
+
+    if (inRouteBlock) {
+      const routeMatch = line.match(/^\s{2,}(pass|fail|blocker):\s*(.*)$/);
+      if (routeMatch && isRouteOutcome(routeMatch[1])) {
+        activeRouteKey = routeMatch[1];
+        route[activeRouteKey].push(...parseRouteValue(routeMatch[2]));
+        continue;
+      }
+
+      const listMatch = line.match(/^\s{4,}-\s+(.+)$/);
+      if (listMatch && activeRouteKey) {
+        route[activeRouteKey].push(stripQuotes(listMatch[1]));
+        continue;
+      }
+
+      if (!/^\s/.test(line)) {
+        inRouteBlock = false;
+        activeRouteKey = null;
+      } else {
+        activeRouteKey = null;
+        continue;
+      }
+    }
+
+    const fieldMatch = line.match(/^(name|description|tier):\s*(.+)$/);
+    if (!fieldMatch) continue;
+
+    const value = stripQuotes(fieldMatch[2]);
+    switch (fieldMatch[1]) {
+      case "name":
+        name = value;
+        break;
+      case "description":
+        description = value;
+        break;
+      case "tier":
+        tier = value;
+        break;
+    }
+  }
+
+  return {
+    name,
+    description,
+    tier,
+    route,
+  };
+}
+
+export function readSkillFrontmatter(skillFilePath: string): SkillRoutingFrontmatter | null {
+  if (!fs.existsSync(skillFilePath)) return null;
+  return parseSkillFrontmatter(fs.readFileSync(skillFilePath, "utf8"));
+}
+
+export function emptySkillRoutes(): SkillRouteMap {
+  return {
+    pass: [...EMPTY_ROUTES.pass],
+    fail: [...EMPTY_ROUTES.fail],
+    blocker: [...EMPTY_ROUTES.blocker],
+  };
+}

package/harness/lib/routing/types.ts

@@ -0,0 +1,52 @@
+export const ROUTE_OUTCOMES = ["pass", "fail", "blocker"] as const;
+export const ROUTE_VERIFICATIONS = ["verified", "unverified"] as const;
+export const ROUTE_ACTIONS = ["done", "fixable", "needs-context", "blocked"] as const;
+export const ROUTE_WORK_TYPES = ["implement", "verify", "ship", "diagnose", "surface"] as const;
+
+export type RouteOutcome = (typeof ROUTE_OUTCOMES)[number];
+export type RouteVerification = (typeof ROUTE_VERIFICATIONS)[number];
+export type RouteAction = (typeof ROUTE_ACTIONS)[number];
+export type RouteWork = (typeof ROUTE_WORK_TYPES)[number];
+
+export interface SkillRouteMap {
+  pass: string[];
+  fail: string[];
+  blocker: string[];
+}
+
+export interface SkillRoutingFrontmatter {
+  name?: string;
+  description?: string;
+  tier?: string;
+  route: SkillRouteMap;
+}
+
+export interface RouteEvidence {
+  outcome: RouteOutcome;
+  verification?: RouteVerification;
+  action?: RouteAction;
+  work?: RouteWork;
+  target?: string;
+  reason?: string;
+}
+
+export interface RouteResolution {
+  outcome: RouteOutcome;
+  verification?: RouteVerification;
+  action?: RouteAction;
+  work?: RouteWork;
+  candidates: string[];
+  selected: string | null;
+  reason: string;
+}
+
+export interface RuntimeRouteDecision {
+  selected: string;
+  source: "next_route" | "route_guidance";
+  outcome?: RouteOutcome;
+  verification?: RouteVerification;
+  action?: RouteAction;
+  work?: RouteWork;
+  candidates?: string[];
+  reason?: string;
+}

package/harness/lib/sanity/checker.ts

@@ -16,10 +16,10 @@ import { AnomalyTracker } from "./anomaly-tracker.ts";
  *
  * Accepts an optional AnomalyTracker for cross-invocation dedup detection.
  */
-export function checkOutputSanity(
-  text: unknown,
-  anomalyTracker?: AnomalyTracker,
-): SanityResult {
+export function checkOutputSanity(
+  text: unknown,
+  anomalyTracker?: AnomalyTracker,
+): SanityResult {
   if (typeof text !== "string") {
     return {
       isHealthy: false,
@@ -113,36 +113,47 @@ export function checkOutputSanity(
     }
   }
 
-  // ═══════════════════════════════════════════════════════════════════
-  // WARNING checks — mild or context-dependent issues
-  // ═══════════════════════════════════════════════════════════════════
-
-  // ── 6. Excessive JSON/error stack lines ─────────────────────────
-  const errorStackLines = text.split(/\r?\n/).filter(
-    (l) => l.includes("Error:") || l.trim().startsWith("at ") || l.includes("Exception:"),
-  );
-  if (errorStackLines.length > 5) {
-    return {
-      isHealthy: false,
-      severity: "warning",
-      reason: `Error stack bleed detected: ${errorStackLines.length} error/stack lines`,
-      patternName: "error_stack_bleed",
-    };
-  }
-
-  // ── 7. Line-by-line repetition ──────────────────────────────────
-  const lines = text.split(/\r?\n/).filter((l) => l.trim().length > 10);
-  if (lines.length > 10) {
-    const uniqueLines = new Set(lines);
-    if (uniqueLines.size < lines.length * 0.2) {
-      return {
-        isHealthy: false,
-        severity: "warning",
-        reason: `Excessive line repetition: ${uniqueLines.size} unique lines out of ${lines.length} (${(uniqueLines.size / lines.length * 100).toFixed(0)}% unique)`,
-        patternName: "line_repetition",
-      };
-    }
-  }
+  // ═══════════════════════════════════════════════════════════════════
+  // WARNING checks — mild or context-dependent issues
+  // ═══════════════════════════════════════════════════════════════════
+
+  // ── 6. Excessive JSON/error stack lines ─────────────────────────
+  const lines = text.split(/\r?\n/);
+  let errorStackLineCount = 0;
+  const repetitionLines: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (line.includes("Error:") || trimmed.startsWith("at ") || line.includes("Exception:")) {
+      errorStackLineCount++;
+    }
+
+    if (trimmed.length > 10) {
+      repetitionLines.push(line);
+    }
+  }
+
+  if (errorStackLineCount > 5) {
+    return {
+      isHealthy: false,
+      severity: "warning",
+      reason: `Error stack bleed detected: ${errorStackLineCount} error/stack lines`,
+      patternName: "error_stack_bleed",
+    };
+  }
+
+  // ── 7. Line-by-line repetition ──────────────────────────────────
+  if (repetitionLines.length > 10) {
+    const uniqueLines = new Set(repetitionLines);
+    if (uniqueLines.size < repetitionLines.length * 0.2) {
+      return {
+        isHealthy: false,
+        severity: "warning",
+        reason: `Excessive line repetition: ${uniqueLines.size} unique lines out of ${repetitionLines.length} (${(uniqueLines.size / repetitionLines.length * 100).toFixed(0)}% unique)`,
+        patternName: "line_repetition",
+      };
+    }
+  }
 
   // ── 8. Empty/tiny output ────────────────────────────────────────
   // Only flag if the entire output is small enough to be suspicious

package/harness/lib/sync/file-watcher.ts

@@ -14,8 +14,8 @@ const DEBOUNCE_MS = 500; // Debounce window for file-change events
 // PlanFileWatcher
 // ---------------------------------------------------------------------------
 
-export class PlanFileWatcher {
-  private static instance: PlanFileWatcher;
+export class PlanFileWatcher {
+  private static instance: PlanFileWatcher | null = null;
 
   /** Active fs.FSWatcher instances keyed by directory path. */
   private watchers = new Map<string, fs.FSWatcher>();
@@ -39,14 +39,14 @@ export class PlanFileWatcher {
     return PlanFileWatcher.instance;
   }
 
-  /** Reset singleton — used in tests. */
-  static resetInstance(): void {
-    const inst = PlanFileWatcher.instance;
-    if (inst) {
-      inst.destroy();
-      PlanFileWatcher.instance = null as unknown as PlanFileWatcher;
-    }
-  }
+  /** Reset singleton — used in tests. */
+  static resetInstance(): void {
+    const inst = PlanFileWatcher.instance;
+    if (inst) {
+      inst.destroy();
+      PlanFileWatcher.instance = null;
+    }
+  }
 
   // -----------------------------------------------------------------------
   // Public API
@@ -120,21 +120,22 @@ export class PlanFileWatcher {
     this.callbacks.delete(directory);
   }
 
-  /**
-   * Pause change-notification without losing watch-registrations.
-   * While paused, events are still debounced but callbacks are suppressed.
-   */
-  pause(): void {
-    this._paused = true;
-  }
-
-  /**
-   * Resume change-notification after a pause.
-   * Pending debounced callbacks will fire on the next event.
-   */
-  resume(): void {
-    this._paused = false;
-  }
+  /**
+   * Pause change-notification without losing watch-registrations.
+   * While paused, events are still debounced but callbacks are suppressed.
+   * Missed changes are not queued or replayed on resume.
+   */
+  pause(): void {
+    this._paused = true;
+  }
+
+  /**
+   * Resume change-notification after a pause.
+   * Only future events will notify callbacks.
+   */
+  resume(): void {
+    this._paused = false;
+  }
 
   /** Check if the watcher is currently paused. */
   get paused(): boolean {

package/harness/lib/sync/plan-sync.ts

@@ -34,7 +34,7 @@ function normalizeEol(text: string): string {
 // ---------------------------------------------------------------------------
 
 export class PlanSync {
-  private static instance: PlanSync;
+  private static instance: PlanSync | null = null;
 
   private constructor() {}
 
@@ -48,7 +48,7 @@ export class PlanSync {
 
   /** Reset singleton — used in tests to get a clean slate. */
   static resetInstance(): void {
-    PlanSync.instance = null as unknown as PlanSync;
+    PlanSync.instance = null;
   }
 
   // -----------------------------------------------------------------------
@@ -286,24 +286,19 @@ export class PlanSync {
     // Parse per-entry metadata (version, description, status)
     const entryMeta = new Map<string, Record<string, string>>();
     for (const line of metaLines) {
-      const ev = line.match(/^entry-(task-\d+)-version:\s*(\d+)$/i);
-      if (ev) {
-        const m = entryMeta.get(ev[1]) ?? {};
-        m.version = ev[2];
-        entryMeta.set(ev[1], m);
-      }
-      const ed = line.match(/^entry-(task-\d+)-description:\s*(.+)$/i);
-      if (ed) {
-        const m = entryMeta.get(ed[1]) ?? {};
-        m.description = ed[2].trim();
-        entryMeta.set(ed[1], m);
-      }
-      const es = line.match(/^entry-(task-\d+)-status:\s*(.+)$/i);
-      if (es) {
-        const m = entryMeta.get(es[1]) ?? {};
-        m.status = es[2].trim().toLowerCase();
-        entryMeta.set(es[1], m);
+      const keyMatch = line.match(/^entry-(task-\d+)-(version|description|status):\s*(.+)$/i);
+      if (!keyMatch) continue;
+
+      const m = entryMeta.get(keyMatch[1]) ?? {};
+      if (keyMatch[2] === "status") {
+        m.status = keyMatch[3].trim().toLowerCase();
+      } else if (keyMatch[2] === "description") {
+        m.description = keyMatch[3].trim();
+      } else {
+        m.version = keyMatch[3].trim();
       }
+
+      entryMeta.set(keyMatch[1], m);
     }
 
     // ---- 2. Find relevant sections ----
@@ -374,6 +369,8 @@ export class PlanSync {
    * each starting with `### Task N:`.
    */
   private splitTaskBlocks(tasksContent: string): string[] {
+    if (!tasksContent.includes("### Task ")) return [];
+
     // Split on lines starting with `### `
     const parts = tasksContent.split(/\n(?=### )/);
     return parts.filter((p) => /^###\s+Task\s+\d+\s*:/m.test(p));
@@ -392,16 +389,16 @@ export class PlanSync {
     completedContent: string | null,
     activeContent: string | null,
   ): SyncPlanEntry["status"] {
+    const taskRef = new RegExp(`Task\\s+${taskNum}\\s*:`, "i");
+
     // Check Completed section
-    if (completedContent) {
-      const re = new RegExp(`Task\\s+${taskNum}\\s*:`, "i");
-      if (re.test(completedContent)) return "completed";
+    if (completedContent && taskRef.test(completedContent)) {
+      return "completed";
     }
 
     // Check Active Task section
-    if (activeContent) {
-      const re = new RegExp(`Task\\s+${taskNum}\\s*:`, "i");
-      if (re.test(activeContent)) return "in_progress";
+    if (activeContent && taskRef.test(activeContent)) {
+      return "in_progress";
     }
 
     // Check success-criteria checkboxes

package/harness/lib/sync/sync.test.ts

@@ -776,6 +776,11 @@ describe("PlanFileWatcher", () => {
       await delay(800);
 
       const countDuringPause = callbacks.length;
+      assert.equal(
+        countDuringPause,
+        0,
+        "pause should suppress callbacks while active",
+      );
 
       // Resume
       watcher.resume();
@@ -785,10 +790,31 @@ describe("PlanFileWatcher", () => {
       await fs.promises.writeFile(filePath, content + "\n\n\n\n", "utf8");
       await delay(800);
 
-      // The pause should have prevented the first write's callback
-      // (but note: fs.watch on Windows may batch events; we verify pause
-      //  at least prevented the callback that would have fired during pause)
-      assert.ok(watcher.paused === false, "watcher should not be paused after resume");
+      assert.ok(
+        callbacks.length > countDuringPause,
+        "resume should allow new callbacks; paused changes are not replayed",
+      );
+      assert.equal(watcher.paused, false);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("resetInstance returns a fresh watcher with cleared state", async () => {
+    const content = makePlanContent([{ num: 1, title: "Reset" }]);
+    const { dir, cleanup } = await createTestPlan(content);
+
+    try {
+      const watcher = PlanFileWatcher.getInstance();
+      watcher.watch(dir, () => {});
+      watcher.pause();
+
+      PlanFileWatcher.resetInstance();
+
+      const fresh = PlanFileWatcher.getInstance();
+      assert.notEqual(fresh, watcher);
+      assert.equal(fresh.paused, false);
+      assert.equal(fresh.watchedDirectories().length, 0);
     } finally {
       await cleanup();
     }