openhermes 4.12.1 → 4.13.0

package/harness/lib/guards/guard-config.ts

@@ -1,72 +1,72 @@
-// ---------------------------------------------------------------------------
-// GuardConfig — centralized configuration for all loop/safety guards
-// ---------------------------------------------------------------------------
-
-export interface GuardConfig {
-  /** Max times the same skill can repeat in one chain before STOP */
-  maxSkillRepeats: number
-  /** Max consecutive unproductive hops before STOP (0 = disabled) */
-  maxUnproductiveHops: number
-  /** Max delegation (sub-agent) depth before STOP */
-  maxDelegationDepth: number
-  /** Consecutive anomalies before recovery escalation */
-  maxConsecutiveAnomalies: number
-  /** Max subagent failures on same task before BLOCKER */
-  maxSubagentFailures: number
-  /** Enable progressive warning at thresholds before hard stop */
-  progressiveGuards: boolean
-  /** Ratio of limit at which to warn (e.g. 0.6 = 60%) */
-  progressiveWarnThreshold: number
-  /** Ratio of limit at which to escalate (e.g. 0.8 = 80%) */
-  progressiveEscalateThreshold: number
-}
-
-export const DEFAULT_GUARD_CONFIG: GuardConfig = {
-  maxSkillRepeats: 5,
-  maxUnproductiveHops: 8,
-  maxDelegationDepth: 25,
-  maxConsecutiveAnomalies: 2,
-  maxSubagentFailures: 5,
-  progressiveGuards: true,
-  progressiveWarnThreshold: 0.6,
-  progressiveEscalateThreshold: 0.8,
-}
-
-export type GuardLevel = "ok" | "warn" | "escalate" | "stop"
-
-export interface GuardProgression {
-  level: GuardLevel
-  current: number
-  limit: number
-  /**
-   * If progressive guards are disabled: stop at limit, ok otherwise.
-   * If enabled: ok < warn% < escalate% < stop.
-   */
-}
-
-export function checkGuardProgression(
-  current: number,
-  limit: number,
-  config: GuardConfig,
-): GuardProgression {
-  if (!config.progressiveGuards || limit <= 0) {
-    return {
-      level: current >= limit ? "stop" as GuardLevel : "ok" as GuardLevel,
-      current,
-      limit,
-    }
-  }
-  if (current >= limit) return { level: "stop", current, limit }
-  if (current / limit >= config.progressiveEscalateThreshold) return { level: "escalate" as GuardLevel, current, limit }
-  if (current / limit >= config.progressiveWarnThreshold) return { level: "warn" as GuardLevel, current, limit }
-  return { level: "ok" as GuardLevel, current, limit }
-}
-
-/**
- * Merge partial user config(s) with defaults.
- * Priority: defaults → earlier args → later args (last wins).
- * Supports single-arg calls and multi-override chains.
- */
-export function mergeGuardConfig(...overrides: Array<Partial<GuardConfig> | undefined>): GuardConfig {
-  return Object.assign({}, DEFAULT_GUARD_CONFIG, ...overrides.filter(Boolean));
-}
+// ---------------------------------------------------------------------------
+// GuardConfig — centralized configuration for all loop/safety guards
+// ---------------------------------------------------------------------------
+
+export interface GuardConfig {
+  /** Max times the same skill can repeat in one chain before STOP */
+  maxSkillRepeats: number
+  /** Max consecutive unproductive hops before STOP (0 = disabled) */
+  maxUnproductiveHops: number
+  /** Max delegation (sub-agent) depth before STOP */
+  maxDelegationDepth: number
+  /** Consecutive anomalies before guard escalation */
+  maxConsecutiveAnomalies: number
+  /** Max subagent failures on same task before BLOCKER */
+  maxSubagentFailures: number
+  /** Enable progressive warning at thresholds before hard stop */
+  progressiveGuards: boolean
+  /** Ratio of limit at which to warn (e.g. 0.6 = 60%) */
+  progressiveWarnThreshold: number
+  /** Ratio of limit at which to escalate (e.g. 0.8 = 80%) */
+  progressiveEscalateThreshold: number
+}
+
+export const DEFAULT_GUARD_CONFIG: GuardConfig = {
+  maxSkillRepeats: 5,
+  maxUnproductiveHops: 8,
+  maxDelegationDepth: 25,
+  maxConsecutiveAnomalies: 2,
+  maxSubagentFailures: 5,
+  progressiveGuards: true,
+  progressiveWarnThreshold: 0.6,
+  progressiveEscalateThreshold: 0.8,
+}
+
+export type GuardLevel = "ok" | "warn" | "escalate" | "stop"
+
+export interface GuardProgression {
+  level: GuardLevel
+  current: number
+  limit: number
+  /**
+   * If progressive guards are disabled: stop at limit, ok otherwise.
+   * If enabled: ok < warn% < escalate% < stop.
+   */
+}
+
+export function checkGuardProgression(
+  current: number,
+  limit: number,
+  config: GuardConfig,
+): GuardProgression {
+  if (!config.progressiveGuards || limit <= 0) {
+    return {
+      level: current >= limit ? "stop" as GuardLevel : "ok" as GuardLevel,
+      current,
+      limit,
+    }
+  }
+  if (current >= limit) return { level: "stop", current, limit }
+  if (current / limit >= config.progressiveEscalateThreshold) return { level: "escalate" as GuardLevel, current, limit }
+  if (current / limit >= config.progressiveWarnThreshold) return { level: "warn" as GuardLevel, current, limit }
+  return { level: "ok" as GuardLevel, current, limit }
+}
+
+/**
+ * Merge partial user config(s) with defaults.
+ * Priority: defaults → earlier args → later args (last wins).
+ * Supports single-arg calls and multi-override chains.
+ */
+export function mergeGuardConfig(...overrides: Array<Partial<GuardConfig> | undefined>): GuardConfig {
+  return Object.assign({}, DEFAULT_GUARD_CONFIG, ...overrides.filter(Boolean));
+}

package/harness/lib/hooks/builtins/confidence-gate-hook.ts

@@ -23,21 +23,21 @@ export const confidenceGateHook: RouteHook = {
     errorHandling: "isolate",
   },
 
-  async execute(context: HookContext, route: string) {
-    // Read confidence state from context if available
-    const confidenceLevel = context._confidenceLevel;
+  async execute(context: HookContext, route: string) {
+    // Read confidence state from context if available
+    const confidenceLevel = context._confidenceLevel;
 
     if (!confidenceLevel) {
       // No confidence gate info — pass through unchanged
       return { result: HookResult.CONTINUE, modifiedRoute: route };
     }
 
-    // Store the confidence assessment for routing decisions
-    const state: ConfidenceGateState = {
-      level: confidenceLevel as ConfidenceGateState["level"],
-      exchanges: context._confidenceExchanges ?? 0,
-      lastAction: "assessed",
-    };
+    // Store the confidence assessment for routing decisions
+    const state: ConfidenceGateState = {
+      level: confidenceLevel as ConfidenceGateState["level"],
+      exchanges: context._confidenceExchanges ?? 0,
+      lastAction: "assessed",
+    };
 
     // HIGH confidence: proceed without modification
     if (state.level === "HIGH") {

package/harness/lib/hooks/builtins/delegation-depth-hook.ts

@@ -75,4 +75,4 @@ export const delegationDepthHook: PreToolUseHook = {
       },
     };
   },
-};
+};

package/harness/lib/hooks/builtins/dynamic-route-hook.ts

@@ -1,99 +1,99 @@
-import path from "node:path";
-import { HookPhase, HookResult } from "../types.ts";
-import type { HookContext, PostToolUseHook } from "../types.ts";
-import { readSkillFrontmatter, resolveRoute } from "../../routing/index.ts";
-import type { RouteEvidence } from "../../routing/index.ts";
-import { ROUTE_GUIDANCE_PREFIX } from "../../routing/index.ts";
-import {
-  ROUTE_ACTIONS,
-  ROUTE_OUTCOMES,
-  ROUTE_VERIFICATIONS,
-  ROUTE_WORK_TYPES,
-} from "../../routing/types.ts";
-
-const ROUTE_EVIDENCE_PREFIX = "ROUTE_EVIDENCE:";
-
-function isRouteOutcome(value: unknown): value is RouteEvidence["outcome"] {
-  return typeof value === "string" && ROUTE_OUTCOMES.includes(value as RouteEvidence["outcome"]);
-}
-
-function isRouteVerification(value: unknown): value is NonNullable<RouteEvidence["verification"]> {
-  return typeof value === "string" && ROUTE_VERIFICATIONS.includes(value as NonNullable<RouteEvidence["verification"]>);
-}
-
-function isRouteAction(value: unknown): value is NonNullable<RouteEvidence["action"]> {
-  return typeof value === "string" && ROUTE_ACTIONS.includes(value as NonNullable<RouteEvidence["action"]>);
-}
-
-function isRouteWork(value: unknown): value is NonNullable<RouteEvidence["work"]> {
-  return typeof value === "string" && ROUTE_WORK_TYPES.includes(value as NonNullable<RouteEvidence["work"]>);
-}
-
-function parseRouteEvidence(output: string): RouteEvidence | null {
-  const evidenceLine = output
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .find((line) => line.startsWith(ROUTE_EVIDENCE_PREFIX));
-
-  if (!evidenceLine) return null;
-
-  const raw = evidenceLine.slice(ROUTE_EVIDENCE_PREFIX.length).trim();
-  if (!raw) return null;
-
-  try {
-    const parsed = JSON.parse(raw) as Partial<RouteEvidence>;
-    if (!isRouteOutcome(parsed.outcome)) return null;
-    if (parsed.verification !== undefined && !isRouteVerification(parsed.verification)) return null;
-    if (parsed.action !== undefined && !isRouteAction(parsed.action)) return null;
-    if (parsed.work !== undefined && !isRouteWork(parsed.work)) return null;
-    if (parsed.target !== undefined && typeof parsed.target !== "string") return null;
-    if (parsed.reason !== undefined && typeof parsed.reason !== "string") return null;
-
-    return {
-      outcome: parsed.outcome,
-      ...(parsed.verification ? { verification: parsed.verification } : {}),
-      ...(parsed.action ? { action: parsed.action } : {}),
-      ...(parsed.work ? { work: parsed.work } : {}),
-      ...(parsed.target ? { target: parsed.target } : {}),
-      ...(parsed.reason ? { reason: parsed.reason } : {}),
-    };
-  } catch {
-    return null;
-  }
-}
-
-export const dynamicRouteHook: PostToolUseHook = {
-  metadata: {
-    name: "dynamic-route",
-    priority: 20,
-    phase: HookPhase.LATE,
-    dependencies: [],
-    errorHandling: "isolate",
-  },
-
-  async execute(context: HookContext, output: string) {
-    const evidence = parseRouteEvidence(output);
-    const skillsDir = typeof context._routingSkillsDir === "string" ? context._routingSkillsDir : undefined;
-
-    if (!evidence || !skillsDir || !context.agent) {
-      return { result: HookResult.CONTINUE };
-    }
-
-    const skillFilePath = path.join(skillsDir, context.agent, "SKILL.md");
-    const frontmatter = readSkillFrontmatter(skillFilePath);
-    if (!frontmatter) {
-      return { result: HookResult.CONTINUE };
-    }
-
-    const resolution = resolveRoute(frontmatter.route, evidence);
-    const guidance = `${ROUTE_GUIDANCE_PREFIX} ${JSON.stringify(resolution)}`;
-    const modifiedOutput = output.includes(ROUTE_GUIDANCE_PREFIX)
-      ? output
-      : `${output.trimEnd()}\n${guidance}`.trim();
-
-    return {
-      result: HookResult.INJECT,
-      modifiedOutput,
-    };
-  },
-};
+import path from "node:path";
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, PostToolUseHook } from "../types.ts";
+import { readSkillFrontmatter, resolveRoute } from "../../routing/index.ts";
+import type { RouteEvidence } from "../../routing/index.ts";
+import { ROUTE_GUIDANCE_PREFIX } from "../../routing/index.ts";
+import {
+  ROUTE_ACTIONS,
+  ROUTE_OUTCOMES,
+  ROUTE_VERIFICATIONS,
+  ROUTE_WORK_TYPES,
+} from "../../routing/types.ts";
+
+const ROUTE_EVIDENCE_PREFIX = "ROUTE_EVIDENCE:";
+
+function isRouteOutcome(value: unknown): value is RouteEvidence["outcome"] {
+  return typeof value === "string" && ROUTE_OUTCOMES.includes(value as RouteEvidence["outcome"]);
+}
+
+function isRouteVerification(value: unknown): value is NonNullable<RouteEvidence["verification"]> {
+  return typeof value === "string" && ROUTE_VERIFICATIONS.includes(value as NonNullable<RouteEvidence["verification"]>);
+}
+
+function isRouteAction(value: unknown): value is NonNullable<RouteEvidence["action"]> {
+  return typeof value === "string" && ROUTE_ACTIONS.includes(value as NonNullable<RouteEvidence["action"]>);
+}
+
+function isRouteWork(value: unknown): value is NonNullable<RouteEvidence["work"]> {
+  return typeof value === "string" && ROUTE_WORK_TYPES.includes(value as NonNullable<RouteEvidence["work"]>);
+}
+
+function parseRouteEvidence(output: string): RouteEvidence | null {
+  const evidenceLine = output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line.startsWith(ROUTE_EVIDENCE_PREFIX));
+
+  if (!evidenceLine) return null;
+
+  const raw = evidenceLine.slice(ROUTE_EVIDENCE_PREFIX.length).trim();
+  if (!raw) return null;
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<RouteEvidence>;
+    if (!isRouteOutcome(parsed.outcome)) return null;
+    if (parsed.verification !== undefined && !isRouteVerification(parsed.verification)) return null;
+    if (parsed.action !== undefined && !isRouteAction(parsed.action)) return null;
+    if (parsed.work !== undefined && !isRouteWork(parsed.work)) return null;
+    if (parsed.target !== undefined && typeof parsed.target !== "string") return null;
+    if (parsed.reason !== undefined && typeof parsed.reason !== "string") return null;
+
+    return {
+      outcome: parsed.outcome,
+      ...(parsed.verification ? { verification: parsed.verification } : {}),
+      ...(parsed.action ? { action: parsed.action } : {}),
+      ...(parsed.work ? { work: parsed.work } : {}),
+      ...(parsed.target ? { target: parsed.target } : {}),
+      ...(parsed.reason ? { reason: parsed.reason } : {}),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export const dynamicRouteHook: PostToolUseHook = {
+  metadata: {
+    name: "dynamic-route",
+    priority: 20,
+    phase: HookPhase.LATE,
+    dependencies: [],
+    errorHandling: "isolate",
+  },
+
+  async execute(context: HookContext, output: string) {
+    const evidence = parseRouteEvidence(output);
+    const skillsDir = typeof context._routingSkillsDir === "string" ? context._routingSkillsDir : undefined;
+
+    if (!evidence || !skillsDir || !context.agent) {
+      return { result: HookResult.CONTINUE };
+    }
+
+    const skillFilePath = path.join(skillsDir, context.agent, "SKILL.md");
+    const frontmatter = readSkillFrontmatter(skillFilePath);
+    if (!frontmatter) {
+      return { result: HookResult.CONTINUE };
+    }
+
+    const resolution = resolveRoute(frontmatter.route, evidence);
+    const guidance = `${ROUTE_GUIDANCE_PREFIX} ${JSON.stringify(resolution)}`;
+    const modifiedOutput = output.includes(ROUTE_GUIDANCE_PREFIX)
+      ? output
+      : `${output.trimEnd()}\n${guidance}`.trim();
+
+    return {
+      result: HookResult.INJECT,
+      modifiedOutput,
+    };
+  },
+};

package/harness/lib/hooks/builtins/next-route-hook.ts

@@ -1,24 +1,24 @@
-import { HookPhase, HookResult } from "../types.ts";
-import type { HookContext, RouteHook } from "../types.ts";
-
-export const nextRouteHook: RouteHook = {
-  metadata: {
-    name: "next-route",
-    priority: 90,
-    phase: HookPhase.EARLY,
-    dependencies: [],
-    errorHandling: "isolate",
-  },
-
-  async execute(context: HookContext, route: string) {
-    const nextRoute = context._nextRoute?.selected;
-    if (!nextRoute || nextRoute === route) {
-      return { result: HookResult.CONTINUE, modifiedRoute: route };
-    }
-
-    return {
-      result: HookResult.CONTINUE,
-      modifiedRoute: nextRoute,
-    };
-  },
-};
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, RouteHook } from "../types.ts";
+
+export const nextRouteHook: RouteHook = {
+  metadata: {
+    name: "next-route",
+    priority: 90,
+    phase: HookPhase.EARLY,
+    dependencies: [],
+    errorHandling: "isolate",
+  },
+
+  async execute(context: HookContext, route: string) {
+    const nextRoute = context._nextRoute?.selected;
+    if (!nextRoute || nextRoute === route) {
+      return { result: HookResult.CONTINUE, modifiedRoute: route };
+    }
+
+    return {
+      result: HookResult.CONTINUE,
+      modifiedRoute: nextRoute,
+    };
+  },
+};

package/harness/lib/hooks/builtins/plan-check-hook.ts

@@ -5,9 +5,9 @@
 // If missing, inject "create plan first" instruction.
 // ---------------------------------------------------------------------------
 
-import { HookPhase, HookResult } from "../types.ts";
-import type { HookContext, PreToolUseHook } from "../types.ts";
-import { resolvePlanAccess } from "../../plans/plan-location.ts";
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, PreToolUseHook } from "../types.ts";
+import { resolvePlanAccess } from "../../plans/plan-location.ts";
 
 export const planCheckHook: PreToolUseHook = {
   metadata: {
@@ -18,8 +18,8 @@ export const planCheckHook: PreToolUseHook = {
     errorHandling: "propagate",
   },
 
-  async execute(context: HookContext) {
-    const planFile = resolvePlanAccess(context.directory)?.path ?? null;
+  async execute(context: HookContext) {
+    const planFile = resolvePlanAccess(context.directory)?.path ?? null;
 
     if (!planFile) {
       return {

package/harness/lib/hooks/builtins/route-tracking-hook.ts

@@ -198,4 +198,4 @@ export const routeTrackingHook: RouteHook = {
 
     return { result: HookResult.CONTINUE, modifiedRoute: route };
   },
-};
+};