openhermes 4.12.1 → 4.13.0

package/harness/lib/routing/routing.test.ts

@@ -1,195 +1,195 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { consumeRouteGuidance, parseSkillFrontmatter, resolveRoute } from "./index.ts";
-
-describe("routing frontmatter", () => {
-  it("parses scalar route values", () => {
-    const parsed = parseSkillFrontmatter(`---
-name: oh-test
-route:
-  pass: oh-builder
-  fail: oh-review
-  blocker: surface
----`);
-
-    assert.ok(parsed);
-    assert.deepEqual(parsed.route, {
-      pass: ["oh-builder"],
-      fail: ["oh-review"],
-      blocker: ["surface"],
-    });
-  });
-
-  it("parses yaml route lists", () => {
-    const parsed = parseSkillFrontmatter(`---
-name: oh-test
-route:
-  pass:
-    - oh-gauntlet
-    - oh-ship
-  fail:
-    - oh-builder
-  blocker: surface
----`);
-
-    assert.ok(parsed);
-    assert.deepEqual(parsed.route, {
-      pass: ["oh-gauntlet", "oh-ship"],
-      fail: ["oh-builder"],
-      blocker: ["surface"],
-    });
-  });
-
-  it("parses inline route arrays", () => {
-    const parsed = parseSkillFrontmatter(`---
-name: oh-test
-route:
-  pass: [oh-gauntlet, oh-ship]
-  fail: [surface, oh-expert]
-  blocker: surface
----`);
-
-    assert.ok(parsed);
-    assert.deepEqual(parsed.route, {
-      pass: ["oh-gauntlet", "oh-ship"],
-      fail: ["surface", "oh-expert"],
-      blocker: ["surface"],
-    });
-  });
-});
-
-describe("resolveRoute", () => {
-  const route = {
-    pass: ["oh-gauntlet", "oh-ship"],
-    fail: ["oh-builder"],
-    blocker: ["surface"],
-  };
-
-  it("defaults to the first candidate for an outcome", () => {
-    const resolved = resolveRoute(route, { outcome: "pass" });
-    assert.deepEqual(resolved, {
-      outcome: "pass",
-      candidates: ["oh-gauntlet", "oh-ship"],
-      selected: "oh-gauntlet",
-      reason: 'Selected first declared route for outcome "pass".',
-    });
-  });
-
-  it("prefers an evidence target when it matches a candidate", () => {
-    const resolved = resolveRoute(route, { outcome: "pass", target: "oh-ship" });
-    assert.deepEqual(resolved, {
-      outcome: "pass",
-      candidates: ["oh-gauntlet", "oh-ship"],
-      selected: "oh-ship",
-      reason: 'Selected "oh-ship" from output evidence.',
-    });
-  });
-
-  it("prefers oh-ship for verified done ship work", () => {
-    const resolved = resolveRoute(route, {
-      outcome: "pass",
-      verification: "verified",
-      action: "done",
-      work: "ship",
-    });
-
-    assert.deepEqual(resolved, {
-      outcome: "pass",
-      verification: "verified",
-      action: "done",
-      work: "ship",
-      candidates: ["oh-gauntlet", "oh-ship"],
-      selected: "oh-ship",
-      reason: 'Selected "oh-ship" for verified ship-ready work.',
-    });
-  });
-
-  it("prefers oh-gauntlet for unverified work", () => {
-    const resolved = resolveRoute(route, {
-      outcome: "pass",
-      verification: "unverified",
-      action: "done",
-      work: "ship",
-    });
-
-    assert.deepEqual(resolved, {
-      outcome: "pass",
-      verification: "unverified",
-      action: "done",
-      work: "ship",
-      candidates: ["oh-gauntlet", "oh-ship"],
-      selected: "oh-gauntlet",
-      reason: 'Selected "oh-gauntlet" because work is still unverified.',
-    });
-  });
-
-  it("prefers oh-gauntlet for verify work", () => {
-    const resolved = resolveRoute(route, {
-      outcome: "pass",
-      verification: "verified",
-      action: "done",
-      work: "verify",
-    });
-
-    assert.deepEqual(resolved, {
-      outcome: "pass",
-      verification: "verified",
-      action: "done",
-      work: "verify",
-      candidates: ["oh-gauntlet", "oh-ship"],
-      selected: "oh-gauntlet",
-      reason: 'Selected "oh-gauntlet" for verification work.',
-    });
-  });
-
-  it("prefers oh-builder for fixable implementation work", () => {
-    const resolved = resolveRoute({
-      pass: ["oh-gauntlet", "oh-ship", "oh-builder"],
-      fail: ["oh-builder"],
-      blocker: ["surface"],
-    }, {
-      outcome: "pass",
-      verification: "verified",
-      action: "fixable",
-      work: "implement",
-    });
-
-    assert.deepEqual(resolved, {
-      outcome: "pass",
-      verification: "verified",
-      action: "fixable",
-      work: "implement",
-      candidates: ["oh-gauntlet", "oh-ship", "oh-builder"],
-      selected: "oh-builder",
-      reason: 'Selected "oh-builder" for fixable implementation work.',
-    });
-  });
-});
-
-describe("consumeRouteGuidance", () => {
-  it("promotes a selected route into an explicit next-route instruction", () => {
-    const consumed = consumeRouteGuidance([
-      "Review complete",
-      'ROUTE_GUIDANCE: {"outcome":"pass","candidates":["oh-gauntlet","oh-ship"],"selected":"oh-ship","reason":"Selected \\\"oh-ship\\\" from output evidence."}',
-    ].join("\n"));
-
-    assert.equal(consumed.selected, "oh-ship");
-    assert.match(consumed.output, /NEXT_ROUTE: oh-ship/);
-  });
-
-  it("leaves output unchanged when no route guidance is present", () => {
-    const output = "plain output";
-    const consumed = consumeRouteGuidance(output);
-
-    assert.equal(consumed.selected, null);
-    assert.equal(consumed.output, output);
-  });
-
-  it("ignores malformed route guidance safely", () => {
-    const output = 'Review complete\nROUTE_GUIDANCE: {"selected":42}';
-    const consumed = consumeRouteGuidance(output);
-
-    assert.equal(consumed.selected, null);
-    assert.equal(consumed.output, output);
-  });
-});
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { consumeRouteGuidance, parseSkillFrontmatter, resolveRoute } from "./index.ts";
+
+describe("routing frontmatter", () => {
+  it("parses scalar route values", () => {
+    const parsed = parseSkillFrontmatter(`---
+name: oh-test
+route:
+  pass: oh-builder
+  fail: oh-review
+  blocker: surface
+---`);
+
+    assert.ok(parsed);
+    assert.deepEqual(parsed.route, {
+      pass: ["oh-builder"],
+      fail: ["oh-review"],
+      blocker: ["surface"],
+    });
+  });
+
+  it("parses yaml route lists", () => {
+    const parsed = parseSkillFrontmatter(`---
+name: oh-test
+route:
+  pass:
+    - oh-gauntlet
+    - oh-ship
+  fail:
+    - oh-builder
+  blocker: surface
+---`);
+
+    assert.ok(parsed);
+    assert.deepEqual(parsed.route, {
+      pass: ["oh-gauntlet", "oh-ship"],
+      fail: ["oh-builder"],
+      blocker: ["surface"],
+    });
+  });
+
+  it("parses inline route arrays", () => {
+    const parsed = parseSkillFrontmatter(`---
+name: oh-test
+route:
+  pass: [oh-gauntlet, oh-ship]
+  fail: [surface, oh-expert]
+  blocker: surface
+---`);
+
+    assert.ok(parsed);
+    assert.deepEqual(parsed.route, {
+      pass: ["oh-gauntlet", "oh-ship"],
+      fail: ["surface", "oh-expert"],
+      blocker: ["surface"],
+    });
+  });
+});
+
+describe("resolveRoute", () => {
+  const route = {
+    pass: ["oh-gauntlet", "oh-ship"],
+    fail: ["oh-builder"],
+    blocker: ["surface"],
+  };
+
+  it("defaults to the first candidate for an outcome", () => {
+    const resolved = resolveRoute(route, { outcome: "pass" });
+    assert.deepEqual(resolved, {
+      outcome: "pass",
+      candidates: ["oh-gauntlet", "oh-ship"],
+      selected: "oh-gauntlet",
+      reason: 'Selected first declared route for outcome "pass".',
+    });
+  });
+
+  it("prefers an evidence target when it matches a candidate", () => {
+    const resolved = resolveRoute(route, { outcome: "pass", target: "oh-ship" });
+    assert.deepEqual(resolved, {
+      outcome: "pass",
+      candidates: ["oh-gauntlet", "oh-ship"],
+      selected: "oh-ship",
+      reason: 'Selected "oh-ship" from output evidence.',
+    });
+  });
+
+  it("prefers oh-ship for verified done ship work", () => {
+    const resolved = resolveRoute(route, {
+      outcome: "pass",
+      verification: "verified",
+      action: "done",
+      work: "ship",
+    });
+
+    assert.deepEqual(resolved, {
+      outcome: "pass",
+      verification: "verified",
+      action: "done",
+      work: "ship",
+      candidates: ["oh-gauntlet", "oh-ship"],
+      selected: "oh-ship",
+      reason: 'Selected "oh-ship" for verified ship-ready work.',
+    });
+  });
+
+  it("prefers oh-gauntlet for unverified work", () => {
+    const resolved = resolveRoute(route, {
+      outcome: "pass",
+      verification: "unverified",
+      action: "done",
+      work: "ship",
+    });
+
+    assert.deepEqual(resolved, {
+      outcome: "pass",
+      verification: "unverified",
+      action: "done",
+      work: "ship",
+      candidates: ["oh-gauntlet", "oh-ship"],
+      selected: "oh-gauntlet",
+      reason: 'Selected "oh-gauntlet" because work is still unverified.',
+    });
+  });
+
+  it("prefers oh-gauntlet for verify work", () => {
+    const resolved = resolveRoute(route, {
+      outcome: "pass",
+      verification: "verified",
+      action: "done",
+      work: "verify",
+    });
+
+    assert.deepEqual(resolved, {
+      outcome: "pass",
+      verification: "verified",
+      action: "done",
+      work: "verify",
+      candidates: ["oh-gauntlet", "oh-ship"],
+      selected: "oh-gauntlet",
+      reason: 'Selected "oh-gauntlet" for verification work.',
+    });
+  });
+
+  it("prefers oh-builder for fixable implementation work", () => {
+    const resolved = resolveRoute({
+      pass: ["oh-gauntlet", "oh-ship", "oh-builder"],
+      fail: ["oh-builder"],
+      blocker: ["surface"],
+    }, {
+      outcome: "pass",
+      verification: "verified",
+      action: "fixable",
+      work: "implement",
+    });
+
+    assert.deepEqual(resolved, {
+      outcome: "pass",
+      verification: "verified",
+      action: "fixable",
+      work: "implement",
+      candidates: ["oh-gauntlet", "oh-ship", "oh-builder"],
+      selected: "oh-builder",
+      reason: 'Selected "oh-builder" for fixable implementation work.',
+    });
+  });
+});
+
+describe("consumeRouteGuidance", () => {
+  it("promotes a selected route into an explicit next-route instruction", () => {
+    const consumed = consumeRouteGuidance([
+      "Review complete",
+      'ROUTE_GUIDANCE: {"outcome":"pass","candidates":["oh-gauntlet","oh-ship"],"selected":"oh-ship","reason":"Selected \\\"oh-ship\\\" from output evidence."}',
+    ].join("\n"));
+
+    assert.equal(consumed.selected, "oh-ship");
+    assert.match(consumed.output, /NEXT_ROUTE: oh-ship/);
+  });
+
+  it("leaves output unchanged when no route guidance is present", () => {
+    const output = "plain output";
+    const consumed = consumeRouteGuidance(output);
+
+    assert.equal(consumed.selected, null);
+    assert.equal(consumed.output, output);
+  });
+
+  it("ignores malformed route guidance safely", () => {
+    const output = 'Review complete\nROUTE_GUIDANCE: {"selected":42}';
+    const consumed = consumeRouteGuidance(output);
+
+    assert.equal(consumed.selected, null);
+    assert.equal(consumed.output, output);
+  });
+});

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

@@ -1,125 +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],
-  };
-}
+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],
+  };
+}