openhermes 4.12.1 → 4.13.0

package/harness/lib/hooks/types.ts

@@ -1,119 +1,116 @@
-// ---------------------------------------------------------------------------
-// Hook System — type definitions
-// ---------------------------------------------------------------------------
-
-export enum HookPhase {
-  EARLY = 0,
-  NORMAL = 1,
-  LATE = 2,
-}
-
-export interface HookContextBase {
-  sessionId: string;
-  agent: string;
-  directory: string;
-  sessions: Map<string, unknown>;
-}
-
-export interface HookContextExtras {
-  _planCheck?: "missing" | "found";
-  _planFilePath?: string;
-  _planCheckInstruction?: string;
-
-  _shellPlatform?: string;
-  _shellType?: string;
-  _shellPreamble?: string;
-
-  _delegationDepth?: number;
-  _depthExceeded?: boolean;
-  _depthError?: string;
-
-  _confidenceLevel?: "HIGH" | "MEDIUM" | "LOW" | string;
-  _confidenceExchanges?: number;
-
-  // Guard configuration (centralized — replaces _routeTrackingConfig and _maxDelegationDepth)
-  _guardConfig?: import("../guards/guard-config.ts").GuardConfig;
-  _guardProgression?: import("../guards/guard-config.ts").GuardProgression;
-
-  // Subagent failure tracking
-  _subagentFailures?: number;
-  _subagentFailureThreshold?: number;
-  _optiRoute?: {
-    reason: string;
-    chain: Array<{
-      skill: string;
-      timestamp: number;
-      producedArtifact: boolean;
-    }>;
-    skillCounts: Record<string, number>;
-    unproductiveCount: number;
-    maxSkillRepeats: number;
-    maxUnproductiveHops: number;
-  };
-
-  _memorySyncCount?: number;
-  _recoveryAttempt?: number;
-  _routingSkillsDir?: string;
-  _nextRoute?: import("../routing/index.ts").RuntimeRouteDecision;
-
-  [key: string]: unknown;
-}
-
-export type HookContext = HookContextBase & HookContextExtras;
-
-export type HookContextPatch = Partial<HookContextBase> &
-  Partial<HookContextExtras>;
-
-export interface HookMetadata {
-  name: string;
-  priority: number;       // 0-100, higher = earlier within phase
-  phase: HookPhase;
-  dependencies: string[]; // hook names this depends on
-  errorHandling: "propagate" | "isolate" | "retry";
-}
-
-export enum HookResult {
-  CONTINUE = "continue",
-  STOP = "stop",
-  INJECT = "inject",
-}
-
-export interface PreToolUseHook {
-  metadata: HookMetadata;
-  execute(
-    context: HookContext,
-  ): Promise<{ result: HookResult; modifiedContext?: HookContextPatch }>;
-}
-
-export interface PostToolUseHook {
-  metadata: HookMetadata;
-  execute(
-    context: HookContext,
-    output: string,
-  ): Promise<{
-    result: HookResult;
-    modifiedOutput?: string;
-    injectRecovery?: string;
-  }>;
-}
-
-export interface RouteHook {
-  metadata: HookMetadata;
-  execute(
-    context: HookContext,
-    route: string,
-  ): Promise<{ result: HookResult; modifiedRoute?: string }>;
-}
-
-export interface SessionHook {
-  metadata: HookMetadata;
-  onSessionStart(context: HookContext): Promise<void>;
-  onSessionEnd(context: HookContext): Promise<void>;
-}
-
-// Union type for any hook in the registry
-export type AnyHook =
-  | PreToolUseHook
-  | PostToolUseHook
-  | RouteHook
-  | SessionHook;
+// ---------------------------------------------------------------------------
+// Hook System — type definitions
+// ---------------------------------------------------------------------------
+
+export enum HookPhase {
+  EARLY = 0,
+  NORMAL = 1,
+  LATE = 2,
+}
+
+export interface HookContextBase {
+  sessionId: string;
+  agent: string;
+  directory: string;
+  sessions: Map<string, unknown>;
+}
+
+export interface HookContextExtras {
+  _planCheck?: "missing" | "found";
+  _planFilePath?: string;
+  _planCheckInstruction?: string;
+
+  _shellPlatform?: string;
+  _shellType?: string;
+  _shellPreamble?: string;
+
+  _delegationDepth?: number;
+  _depthExceeded?: boolean;
+  _depthError?: string;
+
+  _confidenceLevel?: "HIGH" | "MEDIUM" | "LOW" | string;
+  _confidenceExchanges?: number;
+
+  // Guard configuration (centralized — replaces _routeTrackingConfig and _maxDelegationDepth)
+  _guardConfig?: import("../guards/guard-config.ts").GuardConfig;
+  _guardProgression?: import("../guards/guard-config.ts").GuardProgression;
+
+  // Subagent failure tracking
+  _subagentFailures?: number;
+  _subagentFailureThreshold?: number;
+  _optiRoute?: {
+    reason: string;
+    chain: Array<{
+      skill: string;
+      timestamp: number;
+      producedArtifact: boolean;
+    }>;
+    skillCounts: Record<string, number>;
+    unproductiveCount: number;
+    maxSkillRepeats: number;
+    maxUnproductiveHops: number;
+  };
+
+  _routingSkillsDir?: string;
+  _nextRoute?: import("../routing/index.ts").RuntimeRouteDecision;
+
+  [key: string]: unknown;
+}
+
+export type HookContext = HookContextBase & HookContextExtras;
+
+export type HookContextPatch = Partial<HookContextBase> &
+  Partial<HookContextExtras>;
+
+export interface HookMetadata {
+  name: string;
+  priority: number;       // 0-100, higher = earlier within phase
+  phase: HookPhase;
+  dependencies: string[]; // hook names this depends on
+  errorHandling: "propagate" | "isolate" | "retry";
+}
+
+export enum HookResult {
+  CONTINUE = "continue",
+  STOP = "stop",
+  INJECT = "inject",
+}
+
+export interface PreToolUseHook {
+  metadata: HookMetadata;
+  execute(
+    context: HookContext,
+  ): Promise<{ result: HookResult; modifiedContext?: HookContextPatch }>;
+}
+
+export interface PostToolUseHook {
+  metadata: HookMetadata;
+  execute(
+    context: HookContext,
+    output: string,
+  ): Promise<{
+    result: HookResult;
+    modifiedOutput?: string;
+  }>;
+}
+
+export interface RouteHook {
+  metadata: HookMetadata;
+  execute(
+    context: HookContext,
+    route: string,
+  ): Promise<{ result: HookResult; modifiedRoute?: string }>;
+}
+
+export interface SessionHook {
+  metadata: HookMetadata;
+  onSessionStart(context: HookContext): Promise<void>;
+  onSessionEnd(context: HookContext): Promise<void>;
+}
+
+// Union type for any hook in the registry
+export type AnyHook =
+  | PreToolUseHook
+  | PostToolUseHook
+  | RouteHook
+  | SessionHook;

package/harness/lib/plans/plan-location.ts

@@ -1,134 +1,134 @@
-import fs from "node:fs"
-import os from "node:os"
-import path from "node:path"
-
-let _planStorageOverride: string | undefined
-
-export interface PlanAccess {
-  path: string
-  status: string | null
-  objective: string | null
-  summary: string | null
-}
-
-export function setPlanStorageDirForTest(dir: string | undefined): void {
-  _planStorageOverride = dir
-}
-
-export function planStorageDir(): string {
-  return _planStorageOverride ?? path.join(os.homedir(), ".local", "share", "openhermes", "plans")
-}
-
-function getProjectName(projectDir: string): string {
-  return path.basename(projectDir)
-}
-
-function ensureDir(dir: string): void {
-  try {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true })
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
-    console.error(`[openhermes] Failed to create directory ${dir}: ${msg}`)
-  }
-}
-
-function readPlanAccess(filePath: string): PlanAccess | null {
-  if (!fs.existsSync(filePath)) return null
-  const source = fs.readFileSync(filePath, "utf8")
-  const status = source.match(/^Status:\s*(.+)$/m)?.[1]?.trim() ?? null
-  const objective = source.match(/^Objective:\s*(.+)$/m)?.[1]?.trim() ?? null
-  if (!status && !objective) return null
-  const parts = [status ? `status=${status}` : null, objective ? `objective=${objective}` : null].filter(Boolean)
-  return {
-    path: filePath,
-    status,
-    objective,
-    summary: `Active plan: ${parts.join(" | ")}`,
-  }
-}
-
-export function resolvePlanAccess(projectDir: string): PlanAccess | null {
-  const latest = findLatestPlanFile(projectDir)
-  if (!latest) return null
-  return readPlanAccess(latest)
-}
-
-export function findLatestPlanFile(projectDir: string): string | null {
-  const projectName = getProjectName(projectDir)
-  const storage = planStorageDir()
-  const projectDirPath = path.join(storage, projectName)
-  if (!fs.existsSync(projectDirPath)) return null
-  let latest: string | null = null
-  let highest = -1
-  try {
-    for (const entry of fs.readdirSync(projectDirPath)) {
-      const m = entry.match(/^plan-(\d{3})\.md$/)
-      if (m) {
-        const n = parseInt(m[1], 10)
-        if (n > highest) {
-          highest = n
-          latest = path.join(projectDirPath, entry)
-        }
-      }
-    }
-  } catch {
-    return null
-  }
-  return latest
-}
-
-export function ensurePlanFile(projectDir: string): string {
-  const access = resolvePlanAccess(projectDir)
-  if (access?.status === "active" || access?.status === "in-progress") {
-    return access.path
-  }
-
-  const projectName = getProjectName(projectDir)
-  const storage = planStorageDir()
-  const projectDirPath = path.join(storage, projectName)
-  ensureDir(projectDirPath)
-
-  const latest = access?.path ?? findLatestPlanFile(projectDir)
-  let nextSeq = 1
-  if (latest) {
-    const m = path.basename(latest).match(/^plan-(\d{3})\.md$/)
-    if (m) nextSeq = parseInt(m[1], 10) + 1
-  }
-
-  const seq = String(nextSeq).padStart(3, "0")
-  const planId = `${projectName}/plan-${seq}.md`
-  const planPath = path.join(projectDirPath, `plan-${seq}.md`)
-  const now = new Date().toISOString().replace("T", " ").slice(0, 16)
-
-  const content = [
-    `# PLAN: ${projectName}`,
-    "",
-    `Plan ID: ${planId}`,
-    `Project: ${projectName}`,
-    `Status: active`,
-    `Created: ${now}`,
-    `Updated: ${now}`,
-    `Project Path: ${projectDir}`,
-    `Plan Path: ${planPath}`,
-    `Objective: (pending classification)`,
-    "",
-    "## Tasks",
-    "",
-    "- [ ] (discoverable — pending classification)",
-    "",
-  ].join("\n")
-
-  try {
-    fs.writeFileSync(planPath, content, "utf8")
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err)
-    console.error(`[openhermes] Failed to write plan file ${planPath}: ${msg}`)
-  }
-  return planPath
-}
-
-export function readPlanSummary(projectDir: string): string | null {
-  return resolvePlanAccess(projectDir)?.summary ?? null
-}
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+let _planStorageOverride: string | undefined
+
+export interface PlanAccess {
+  path: string
+  status: string | null
+  objective: string | null
+  summary: string | null
+}
+
+export function setPlanStorageDirForTest(dir: string | undefined): void {
+  _planStorageOverride = dir
+}
+
+export function planStorageDir(): string {
+  return _planStorageOverride ?? path.join(os.homedir(), ".local", "share", "openhermes", "plans")
+}
+
+function getProjectName(projectDir: string): string {
+  return path.basename(projectDir)
+}
+
+function ensureDir(dir: string): void {
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error(`[openhermes] Failed to create directory ${dir}: ${msg}`)
+  }
+}
+
+function readPlanAccess(filePath: string): PlanAccess | null {
+  if (!fs.existsSync(filePath)) return null
+  const source = fs.readFileSync(filePath, "utf8")
+  const status = source.match(/^Status:\s*(.+)$/m)?.[1]?.trim() ?? null
+  const objective = source.match(/^Objective:\s*(.+)$/m)?.[1]?.trim() ?? null
+  if (!status && !objective) return null
+  const parts = [status ? `status=${status}` : null, objective ? `objective=${objective}` : null].filter(Boolean)
+  return {
+    path: filePath,
+    status,
+    objective,
+    summary: `Active plan: ${parts.join(" | ")}`,
+  }
+}
+
+export function resolvePlanAccess(projectDir: string): PlanAccess | null {
+  const latest = findLatestPlanFile(projectDir)
+  if (!latest) return null
+  return readPlanAccess(latest)
+}
+
+export function findLatestPlanFile(projectDir: string): string | null {
+  const projectName = getProjectName(projectDir)
+  const storage = planStorageDir()
+  const projectDirPath = path.join(storage, projectName)
+  if (!fs.existsSync(projectDirPath)) return null
+  let latest: string | null = null
+  let highest = -1
+  try {
+    for (const entry of fs.readdirSync(projectDirPath)) {
+      const m = entry.match(/^plan-(\d{3})\.md$/)
+      if (m) {
+        const n = parseInt(m[1], 10)
+        if (n > highest) {
+          highest = n
+          latest = path.join(projectDirPath, entry)
+        }
+      }
+    }
+  } catch {
+    return null
+  }
+  return latest
+}
+
+export function ensurePlanFile(projectDir: string): string {
+  const access = resolvePlanAccess(projectDir)
+  if (access?.status === "active" || access?.status === "in-progress") {
+    return access.path
+  }
+
+  const projectName = getProjectName(projectDir)
+  const storage = planStorageDir()
+  const projectDirPath = path.join(storage, projectName)
+  ensureDir(projectDirPath)
+
+  const latest = access?.path ?? findLatestPlanFile(projectDir)
+  let nextSeq = 1
+  if (latest) {
+    const m = path.basename(latest).match(/^plan-(\d{3})\.md$/)
+    if (m) nextSeq = parseInt(m[1], 10) + 1
+  }
+
+  const seq = String(nextSeq).padStart(3, "0")
+  const planId = `${projectName}/plan-${seq}.md`
+  const planPath = path.join(projectDirPath, `plan-${seq}.md`)
+  const now = new Date().toISOString().replace("T", " ").slice(0, 16)
+
+  const content = [
+    `# PLAN: ${projectName}`,
+    "",
+    `Plan ID: ${planId}`,
+    `Project: ${projectName}`,
+    `Status: active`,
+    `Created: ${now}`,
+    `Updated: ${now}`,
+    `Project Path: ${projectDir}`,
+    `Plan Path: ${planPath}`,
+    `Objective: (pending classification)`,
+    "",
+    "## Tasks",
+    "",
+    "- [ ] (discoverable — pending classification)",
+    "",
+  ].join("\n")
+
+  try {
+    fs.writeFileSync(planPath, content, "utf8")
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error(`[openhermes] Failed to write plan file ${planPath}: ${msg}`)
+  }
+  return planPath
+}
+
+export function readPlanSummary(projectDir: string): string | null {
+  return resolvePlanAccess(projectDir)?.summary ?? null
+}

package/harness/lib/routing/index.ts

@@ -1,21 +1,21 @@
-export { extractFrontmatter, parseSkillFrontmatter, readSkillFrontmatter, emptySkillRoutes } from "./skill-frontmatter.ts";
-export { resolveRoute } from "./route-resolver.ts";
-export {
-  clearRuntimeRouteDecision,
-  consumeRouteGuidance,
-  extractRouteGuidance,
-  extractRuntimeRouteDecision,
-  getRuntimeRouteDecision,
-  NEXT_ROUTE_PREFIX,
-  rememberRuntimeRouteDecision,
-  ROUTE_GUIDANCE_PREFIX,
-} from "./route-guidance.ts";
-export { ROUTE_OUTCOMES } from "./types.ts";
-export type {
-  RouteEvidence,
-  RouteOutcome,
-  RouteResolution,
-  RuntimeRouteDecision,
-  SkillRouteMap,
-  SkillRoutingFrontmatter,
-} from "./types.ts";
+export { extractFrontmatter, parseSkillFrontmatter, readSkillFrontmatter, emptySkillRoutes } from "./skill-frontmatter.ts";
+export { resolveRoute } from "./route-resolver.ts";
+export {
+  clearRuntimeRouteDecision,
+  consumeRouteGuidance,
+  extractRouteGuidance,
+  extractRuntimeRouteDecision,
+  getRuntimeRouteDecision,
+  NEXT_ROUTE_PREFIX,
+  rememberRuntimeRouteDecision,
+  ROUTE_GUIDANCE_PREFIX,
+} from "./route-guidance.ts";
+export { ROUTE_OUTCOMES } from "./types.ts";
+export type {
+  RouteEvidence,
+  RouteOutcome,
+  RouteResolution,
+  RuntimeRouteDecision,
+  SkillRouteMap,
+  SkillRoutingFrontmatter,
+} from "./types.ts";