{"version":3,"sources":["../src/core/trajectory.ts","../src/core/agent-protocol.ts","../src/core/budget/multi.ts","../src/core/middleware/budget.ts","../src/core/middleware/runner.ts","../src/core/middleware/telemetry.ts","../src/core/wrapper.ts","../src/core/middleware/evaluator.ts","../src/core/middleware/probe.ts","../src/core/middleware/stagnation.ts","../src/core/orchestrator.ts","../src/core/evaluators/delta-score.ts","../src/core/ladder/proportional.ts","../src/reference/index.ts","../src/core/probes/entropy-probe.ts","../src/core/probes/hit-count-probe.ts","../src/core/budget/control-budget.ts","../src/adapters/github/index.ts","../src/adapters/github/agent-evaluator.ts","../src/adapters/github/search-tool.ts","../src/adapters/github/agent-policy.ts","../src/adapters/github/telemetry.ts","../src/adapters/github/env.ts","../src/adapters/github/evaluator.ts","../src/adapters/github/policy.ts","../src/adapters/github/probes.ts","../src/adapters/github/selector.ts"],"names":["logger","Octokit","tool","z","Agent","run","pino"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * A generic control subject that produces a sequence of semantic states.\n *\n * `Trajectory<S>` is the foundational abstraction for CyberLoop's control loop.\n * Any process that can be modeled as a sequence of states — agent reasoning,\n * document scanning, narrative evaluation, corpus analysis — can implement\n * this interface and be wrapped with `cyberloop()`.\n *\n * `SteppableAgent` extends this interface, so existing agent code continues\n * to work unchanged.\n *\n * @typeParam S - The state type carried through the trajectory.\n *\n * @example\n * ```ts\n * // A corpus scanner as a Trajectory\n * const scanner: Trajectory<ChunkState> = {\n *   getInitialState: (corpus) => loadFirstChunk(corpus),\n *   advance: (state) => embedAndScoreNextChunk(state),\n *   isTerminal: (state) => state.chunkIndex >= state.totalChunks,\n *   toOutput: (state) => state.manifoldReport,\n * };\n *\n * const controlled = cyberloop(scanner, {\n *   middleware: [manifoldMiddleware({ corpus: companyDocs })],\n * });\n * ```\n */\nexport interface Trajectory<S> {\n  /** Derive the initial state from the input. */\n  getInitialState(input: unknown): Promise<S>;\n  /** Advance the trajectory by one frame from the current state. */\n  advance(state: S): Promise<TrajectoryFrame<S>>;\n  /** Check whether the trajectory has reached a terminal state. */\n  isTerminal(state: S): boolean;\n  /** Convert the final state into an output value. */\n  toOutput(state: S): unknown;\n}\n\n/**\n * A single frame in a trajectory — the result of one `advance()` call.\n */\nexport interface TrajectoryFrame<S> {\n  /** The new state after this frame. */\n  state: S;\n  /** The action taken (for logging/middleware). */\n  action?: unknown;\n  /** Cost incurred by this frame (for budget tracking). */\n  cost?: number;\n}\n\n/**\n * Type guard: checks whether a value implements the Trajectory interface.\n */\nexport function isTrajectory<S>(value: unknown): value is Trajectory<S> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'getInitialState' in value &&\n    'advance' in value &&\n    'isTerminal' in value &&\n    'toOutput' in value\n  );\n}\n","import type { Trajectory, TrajectoryFrame } from './trajectory';\nexport type { Trajectory, TrajectoryFrame } from './trajectory';\nexport { isTrajectory } from './trajectory';\n\n/**\n * Minimal agent interface. Any object with a `run()` method qualifies.\n *\n * This is the only requirement for using `cyberloop()` in opaque mode —\n * CyberLoop wraps the entire `run()` call with middleware.\n */\nexport interface AgentLike<I = string, O extends AgentResult = AgentResult> {\n  run(input: I): Promise<O>;\n}\n\n/**\n * Result returned by an agent's `run()` method.\n */\nexport interface AgentResult {\n  output: string;\n  [key: string]: unknown;\n}\n\n/**\n * An agent that exposes step-level control, enabling per-step middleware.\n *\n * `SteppableAgent` extends both `AgentLike` (for `run()`) and `Trajectory`\n * (for frame-by-frame control). The `step`/`isDone`/`toResult` methods are\n * the agent-specific names; they map to the generic `Trajectory` methods:\n *\n * | SteppableAgent | Trajectory   |\n * |----------------|--------------|\n * | `step()`       | `advance()`  |\n * | `isDone()`     | `isTerminal()` |\n * | `toResult()`   | `toOutput()` |\n * | `getInitialState()` | `getInitialState()` |\n *\n * When wrapped with `cyberloop()`, the wrapper drives the step loop:\n * ```\n * state = getInitialState(input)\n * while (!isDone(state)) {\n *   // middleware beforeStep\n *   stepOutput = step(state)\n *   // middleware afterStep\n *   state = stepOutput.state\n * }\n * return toResult(state)\n * ```\n */\nexport interface SteppableAgent<S = unknown, I = string, O extends AgentResult = AgentResult>\n  extends AgentLike<I, O>, Trajectory<S> {\n  /** Execute a single step from the current state. */\n  step(state: S): Promise<StepOutput<S>>;\n  /** Derive the initial state from the input. */\n  getInitialState(input: I): Promise<S>;\n  /** Check whether the agent has reached a terminal state. */\n  isDone(state: S): boolean;\n  /** Convert the final state into an AgentResult. */\n  toResult(state: S): O;\n\n  // --- Trajectory<S> implementation (maps to agent methods) ---\n\n  /** Alias for `step()` — advances the trajectory by one frame. */\n  advance(state: S): Promise<TrajectoryFrame<S>>;\n  /** Alias for `isDone()` — checks if the trajectory is terminal. */\n  isTerminal(state: S): boolean;\n  /** Alias for `toResult()` — converts final state to output. */\n  toOutput(state: S): O;\n}\n\n/**\n * Output of a single agent step.\n */\nexport interface StepOutput<S> {\n  /** The new state after this step. */\n  state: S;\n  /** The action taken (for logging/middleware). */\n  action?: unknown;\n  /** Cost incurred by this step (for budget tracking). */\n  cost?: number;\n}\n\n/**\n * Type guard: checks whether an agent implements SteppableAgent.\n */\nexport function isSteppable<S, I, O extends AgentResult>(\n  agent: AgentLike<I, O>,\n): agent is SteppableAgent<S, I, O> {\n  return (\n    'step' in agent &&\n    'getInitialState' in agent &&\n    'isDone' in agent &&\n    'toResult' in agent\n  );\n}\n","import type { BudgetTracker } from '../interfaces'\nimport type { Cost } from '../types'\n\n/** Tracks multiple resource caps (e.g., steps, tokens, latency) simultaneously. */\nexport class MultiBudget implements BudgetTracker {\n  private readonly used: Record<string, number> = {}\n\n  constructor(private readonly caps: Record<string, number>) { }\n\n  record(cost: Cost): void {\n    const entries: [string, number][] =\n      typeof cost === 'number'\n        ? [['steps', cost]]\n        : Object.entries(cost)\n    for (const [key, value] of entries) {\n      if (value === undefined) continue\n      this.used[key] = (this.used[key] ?? 0) + value\n    }\n  }\n\n  remaining(): number {\n    const ratios = Object.keys(this.caps).map(key => {\n      const cap = this.caps[key]\n      if (cap <= 0) return 0\n      const used = this.used[key] ?? 0\n      return (cap - used) / cap\n    })\n    if (!ratios.length) return Infinity\n    return Math.max(0, Math.min(...ratios))\n  }\n\n  shouldStop(): boolean {\n    return Object.keys(this.caps).some(key => {\n      const cap = this.caps[key]\n      return cap > 0 && (this.used[key] ?? 0) >= cap\n    })\n  }\n\n  reset(valueMap?: Record<string, number>): void {\n    for (const key of Object.keys(this.used)) {\n      delete this.used[key]\n    }\n    if (valueMap) {\n      for (const [key, value] of Object.entries(valueMap)) {\n        this.used[key] = value\n      }\n    }\n  }\n\n  snapshot(): { used: Record<string, number>; caps: Record<string, number> } {\n    return {\n      caps: { ...this.caps },\n      used: { ...this.used },\n    }\n  }\n}\n","import type { BudgetTracker } from '../interfaces';\nimport type { Middleware, StepContext, StepResult } from './types';\n\n/**\n * Middleware that enforces a budget by delegating to an existing BudgetTracker.\n *\n * - `beforeStep`: halts if budget is exhausted, populates ctx.budget snapshot.\n * - `afterStep`: records the step cost (defaults to 1 if not specified).\n */\nexport function budgetMiddleware<S>(tracker: BudgetTracker): Middleware<S> {\n  return {\n    name: 'budget',\n\n    beforeStep(ctx: StepContext<S>): Promise<StepContext<S> | 'halt'> {\n      if (tracker.shouldStop()) {\n        return Promise.resolve('halt');\n      }\n      const remaining = tracker.remaining();\n      return Promise.resolve({\n        ...ctx,\n        budget: { used: ctx.step, remaining },\n      });\n    },\n\n    afterStep(_ctx: StepContext<S>, result: StepResult<S>): Promise<void> {\n      tracker.record(result.cost ?? 1);\n      return Promise.resolve();\n    },\n  };\n}\n","import type { Middleware, StepContext, StepResult } from './types';\n\n/**\n * Executes a chain of middleware around agent steps.\n *\n * - `beforeStep` hooks run in registration order (first registered → first to run).\n * - `afterStep` hooks run in reverse order (Koa-style onion model).\n * - `setup` and `teardown` run in registration order.\n *\n * If any `beforeStep` returns `'halt'`, the step is skipped and the loop should stop.\n */\nexport class MiddlewareRunner<S = unknown> {\n  private readonly stack: Middleware<S>[];\n\n  constructor(middleware: Middleware<S>[] = []) {\n    this.stack = [...middleware];\n  }\n\n  /** Add a middleware to the end of the chain. */\n  use(mw: Middleware<S>): void {\n    this.stack.push(mw);\n  }\n\n  /** Number of middleware in the chain. */\n  get size(): number {\n    return this.stack.length;\n  }\n\n  /**\n   * Run all `setup` hooks in registration order.\n   */\n  async runSetup(ctx: { input: unknown }): Promise<void> {\n    for (const mw of this.stack) {\n      if (mw.setup) {\n        await mw.setup(ctx);\n      }\n    }\n  }\n\n  /**\n   * Run all `teardown` hooks in registration order.\n   */\n  async runTeardown(ctx: { reason: string }): Promise<void> {\n    for (const mw of this.stack) {\n      if (mw.teardown) {\n        await mw.teardown(ctx);\n      }\n    }\n  }\n\n  /**\n   * Run all `beforeStep` hooks in registration order.\n   *\n   * Each middleware receives the (possibly modified) context from the previous one.\n   * If any middleware returns `'halt'`, execution stops immediately and `'halt'` is returned.\n   *\n   * @returns The final `StepContext` to pass to the agent, or `'halt'` to stop the loop.\n   */\n  async runBeforeStep(ctx: StepContext<S>): Promise<StepContext<S> | 'halt'> {\n    let current: StepContext<S> = ctx;\n\n    for (const mw of this.stack) {\n      if (mw.beforeStep) {\n        const result = await mw.beforeStep(current);\n        if (result === 'halt') {\n          return 'halt';\n        }\n        current = result;\n      }\n    }\n\n    return current;\n  }\n\n  /**\n   * Run all `afterStep` hooks in reverse registration order (onion model).\n   */\n  async runAfterStep(ctx: StepContext<S>, result: StepResult<S>): Promise<void> {\n    for (let i = this.stack.length - 1; i >= 0; i--) {\n      const mw = this.stack[i];\n      if (mw.afterStep) {\n        await mw.afterStep(ctx, result);\n      }\n    }\n  }\n}\n","import type { Logger } from '../interfaces';\nimport type { Middleware, StepContext, StepResult } from './types';\n\n/**\n * Middleware that logs structured telemetry for each lifecycle event.\n *\n * - `setup`: logs loop start.\n * - `beforeStep`: logs step start with state and budget.\n * - `afterStep`: logs step end with action, cost, and feedback.\n * - `teardown`: logs loop end with reason.\n */\nexport function telemetryMiddleware<S>(logger: Logger): Middleware<S> {\n  return {\n    name: 'telemetry',\n\n    setup(ctx: { input: string }): Promise<void> {\n      logger.info({ input: ctx.input }, 'Loop started');\n      return Promise.resolve();\n    },\n\n    beforeStep(ctx: StepContext<S>): Promise<StepContext<S>> {\n      logger.debug(\n        { step: ctx.step, budget: ctx.budget },\n        `Step ${ctx.step} starting`,\n      );\n      return Promise.resolve(ctx);\n    },\n\n    afterStep(ctx: StepContext<S>, result: StepResult<S>): Promise<void> {\n      logger.debug(\n        {\n          step: ctx.step,\n          action: result.action,\n          cost: result.cost,\n          feedback: ctx.metadata['feedback'],\n        },\n        `Step ${ctx.step} completed`,\n      );\n      return Promise.resolve();\n    },\n\n    teardown(ctx: { reason: string }): Promise<void> {\n      logger.info({ reason: ctx.reason }, 'Loop ended');\n      return Promise.resolve();\n    },\n  };\n}\n","import type { AgentLike, AgentResult, SteppableAgent } from './agent-protocol';\nimport { isSteppable } from './agent-protocol';\nimport { MultiBudget } from './budget/multi';\nimport type { CyberLoopOpts } from './config';\nimport { budgetMiddleware } from './middleware/budget';\nimport { MiddlewareRunner } from './middleware/runner';\nimport { telemetryMiddleware } from './middleware/telemetry';\nimport type { Middleware, StepContext, StepResult } from './middleware/types';\nimport type { Trajectory } from './trajectory';\nimport { isTrajectory } from './trajectory';\n\n/**\n * Wrap any agent or trajectory with CyberLoop middleware.\n *\n * This is the **Assistive SDK** entry point (v2.2+). It instruments the inner\n * loop with composable middleware (budget, policy, kinematics, telemetry)\n * while leaving the outer loop (failure handling, replanning, orchestration\n * topology) entirely in user code.\n *\n * Accepts three kinds of control subjects:\n *\n * - **Opaque agents** (`AgentLike`): middleware runs once around the entire `run()` call.\n * - **Steppable agents** (`SteppableAgent`): middleware runs around each `step()` call.\n * - **Trajectories** (`Trajectory<S>`): middleware runs around each `advance()` call.\n *   Returns an `AgentLike` whose `run()` drives the trajectory loop.\n *\n * Returns a new `AgentLike` with the same `run()` signature.\n *\n * For the prescriptive inner/outer loop controller where CyberLoop owns the\n * full plan → explore → evaluate → replan cycle, see {@link Orchestrator}\n * in `./orchestrator.ts`.\n *\n * @see docs/guide/choosing-your-api.md — When to use cyberloop() vs Orchestrator\n *\n * @example\n * ```ts\n * // Agent usage (existing)\n * const wrapped = cyberloop(myAgent, {\n *   budget: { maxSteps: 20 },\n *   middleware: [probeMiddleware(myProbe)],\n *   logger: pino(),\n * });\n * const result = await wrapped.run(\"find the answer\");\n *\n * // Trajectory usage (v2.3+)\n * const controlled = cyberloop(myTrajectory, {\n *   budget: { maxSteps: 100 },\n *   middleware: [manifoldMiddleware({ corpus })],\n * });\n * const result = await controlled.run(corpusInput);\n * ```\n */\nexport function cyberloop<S, I = string, O extends AgentResult = AgentResult>(\n  subject: AgentLike<I, O> | Trajectory<S>,\n  opts: CyberLoopOpts<S> = {},\n): AgentLike<I, O> {\n  return {\n    async run(input: I): Promise<O> {\n      const runner = buildRunner<S>(opts);\n\n      // Trajectory path: subject has advance/isTerminal/toOutput but no run()\n      if (isTrajectory<S>(subject) && !('run' in subject)) {\n        return runTrajectory(subject, input, runner, opts);\n      }\n\n      // Agent paths (existing)\n      const agent = subject as AgentLike<I, O>;\n      if (isSteppable<S, I, O>(agent)) {\n        return runSteppable(agent, input, runner, opts);\n      }\n      return runOpaque(agent, input, runner, opts);\n    },\n  };\n}\n\n/**\n * Build a MiddlewareRunner from opts, inserting built-in middleware first.\n */\nfunction buildRunner<S>(opts: CyberLoopOpts<S>): MiddlewareRunner<S> {\n  const stack: Middleware<S>[] = [];\n\n  // Built-in: budget (always present)\n  const maxSteps = opts.budget?.maxSteps ?? 50;\n  const tracker = new MultiBudget({ steps: maxSteps });\n  stack.push(budgetMiddleware<S>(tracker));\n\n  // Built-in: telemetry (if logger provided)\n  if (opts.logger) {\n    stack.push(telemetryMiddleware<S>(opts.logger));\n  }\n\n  // User middleware\n  if (opts.middleware) {\n    stack.push(...opts.middleware);\n  }\n\n  // Event hooks as inline middleware\n  if (opts.on) {\n    const hooks = opts.on;\n    stack.push({\n      name: 'event-hooks',\n      beforeStep(ctx: StepContext<S>): Promise<StepContext<S>> {\n        hooks.beforeStep?.(ctx);\n        return Promise.resolve(ctx);\n      },\n      afterStep(ctx: StepContext<S>, result: StepResult<S>): Promise<void> {\n        hooks.afterStep?.(ctx, result);\n        return Promise.resolve();\n      },\n    });\n  }\n\n  return new MiddlewareRunner<S>(stack);\n}\n\n/**\n * Opaque path: middleware wraps the entire run() as a single step.\n */\nasync function runOpaque<S, I, O extends AgentResult>(\n  agent: AgentLike<I, O>,\n  input: I,\n  runner: MiddlewareRunner<S>,\n  opts: CyberLoopOpts<S>,\n): Promise<O> {\n  await runner.runSetup({ input });\n\n  const ctx: StepContext<S> = {\n    step: 0,\n    state: input as unknown as S,\n    budget: { used: 0, remaining: 1 },\n    metadata: {},\n  };\n\n  const beforeResult = await runner.runBeforeStep(ctx);\n  if (beforeResult === 'halt') {\n    opts.on?.onHalt?.('budget');\n    await runner.runTeardown({ reason: 'halted before execution' });\n    return { output: '' } as O;\n  }\n\n  const output = await agent.run(input);\n\n  const stepResult: StepResult<S> = {\n    state: output as unknown as S,\n    action: 'run',\n    cost: 1,\n  };\n  await runner.runAfterStep(beforeResult, stepResult);\n  await runner.runTeardown({ reason: 'completed' });\n\n  return output;\n}\n\n/**\n * Steppable path: middleware wraps each step() call individually.\n */\nasync function runSteppable<S, I, O extends AgentResult>(\n  agent: SteppableAgent<S, I, O>,\n  input: I,\n  runner: MiddlewareRunner<S>,\n  opts: CyberLoopOpts<S>,\n): Promise<O> {\n  await runner.runSetup({ input });\n\n  let state: S = await agent.getInitialState(input);\n  let step = 0;\n  let prevState: S | undefined;\n\n  while (!agent.isDone(state)) {\n    const ctx: StepContext<S> = {\n      step,\n      state,\n      prevState,\n      budget: { used: step, remaining: 0 },\n      metadata: {},\n    };\n\n    const beforeResult = await runner.runBeforeStep(ctx);\n    if (beforeResult === 'halt') {\n      opts.on?.onHalt?.('budget');\n      break;\n    }\n\n    const currentCtx = beforeResult;\n    const stepOutput = await agent.step(currentCtx.state);\n\n    const stepResult: StepResult<S> = {\n      state: stepOutput.state,\n      action: stepOutput.action,\n      cost: stepOutput.cost,\n    };\n    await runner.runAfterStep(currentCtx, stepResult);\n\n    prevState = currentCtx.state;\n    state = stepOutput.state;\n    step++;\n  }\n\n  await runner.runTeardown({ reason: agent.isDone(state) ? 'completed' : 'halted' });\n  return agent.toResult(state);\n}\n\n/**\n * Trajectory path: middleware wraps each advance() call individually.\n *\n * This is the generic control path for any `Trajectory<S>` — documents,\n * corpora, narratives, or any process modeled as a sequence of states.\n */\nasync function runTrajectory<S, I, O extends AgentResult>(\n  trajectory: Trajectory<S>,\n  input: I,\n  runner: MiddlewareRunner<S>,\n  opts: CyberLoopOpts<S>,\n): Promise<O> {\n  await runner.runSetup({ input });\n\n  let state: S = await trajectory.getInitialState(input);\n  let step = 0;\n  let prevState: S | undefined;\n\n  while (!trajectory.isTerminal(state)) {\n    const ctx: StepContext<S> = {\n      step,\n      state,\n      prevState,\n      budget: { used: step, remaining: 0 },\n      metadata: {},\n    };\n\n    const beforeResult = await runner.runBeforeStep(ctx);\n    if (beforeResult === 'halt') {\n      opts.on?.onHalt?.('budget');\n      break;\n    }\n\n    const currentCtx = beforeResult;\n    const frame = await trajectory.advance(currentCtx.state);\n\n    const stepResult: StepResult<S> = {\n      state: frame.state,\n      action: frame.action,\n      cost: frame.cost,\n    };\n    await runner.runAfterStep(currentCtx, stepResult);\n\n    prevState = currentCtx.state;\n    state = frame.state;\n    step++;\n  }\n\n  await runner.runTeardown({ reason: trajectory.isTerminal(state) ? 'completed' : 'halted' });\n  return trajectory.toOutput(state) as O;\n}\n","import type { Evaluator } from '../interfaces';\nimport type { Middleware, StepContext, StepResult } from './types';\n\n/**\n * Middleware that computes feedback after each step using an Evaluator.\n *\n * - `afterStep`: if `prevState` exists, calls `evaluator.evaluate(prev, next)`\n *   and stores the feedback in `ctx.metadata['feedback']`.\n */\nexport function evaluatorMiddleware<S>(evaluator: Evaluator<S>): Middleware<S> {\n  return {\n    name: 'evaluator',\n\n    async afterStep(ctx: StepContext<S>, result: StepResult<S>): Promise<void> {\n      if (ctx.prevState !== undefined) {\n        const feedback = await evaluator.evaluate(ctx.prevState, result.state);\n        ctx.metadata['feedback'] = feedback;\n      }\n    },\n  };\n}\n","import type { Probe } from '../interfaces';\nimport type { Middleware, StepContext } from './types';\n\n/**\n * Middleware that runs a Probe before each step and attaches the result to metadata.\n *\n * - `beforeStep`: runs `probe.test(state)`, stores result in `ctx.metadata[probe.id]`.\n */\nexport function probeMiddleware<S>(probe: Probe<S>): Middleware<S> {\n  return {\n    name: `probe:${probe.id}`,\n\n    async beforeStep(ctx: StepContext<S>): Promise<StepContext<S>> {\n      const result = await probe.test(ctx.state);\n      return {\n        ...ctx,\n        metadata: { ...ctx.metadata, [probe.id]: result },\n      };\n    },\n  };\n}\n","import type { Middleware, StepContext, StepResult } from './types';\n\nexport interface StagnationOpts {\n  /** Number of consecutive non-improving steps before halting. Default: 5 */\n  maxStagnantSteps?: number;\n  /** Minimum feedback value to count as improvement. Default: 0 */\n  minImprovement?: number;\n}\n\n/**\n * Middleware that halts the loop when feedback stagnates.\n *\n * - `afterStep`: reads `ctx.metadata['feedback']` (typically set by evaluatorMiddleware).\n *   If feedback ≤ minImprovement, increments stagnation counter. Resets on improvement.\n * - `beforeStep`: halts if stagnation counter ≥ maxStagnantSteps.\n * - `setup`: resets counter.\n */\nexport function stagnationMiddleware<S>(opts: StagnationOpts = {}): Middleware<S> {\n  const maxStagnant = opts.maxStagnantSteps ?? 5;\n  const minImprovement = opts.minImprovement ?? 0;\n  let stagnantCount = 0;\n\n  return {\n    name: 'stagnation',\n\n    setup(): Promise<void> {\n      stagnantCount = 0;\n      return Promise.resolve();\n    },\n\n    beforeStep(ctx: StepContext<S>): Promise<StepContext<S> | 'halt'> {\n      if (stagnantCount >= maxStagnant) {\n        return Promise.resolve('halt');\n      }\n      return Promise.resolve(ctx);\n    },\n\n    afterStep(_ctx: StepContext<S>, _result: StepResult<S>): Promise<void> {\n      const feedback = _ctx.metadata['feedback'];\n      if (typeof feedback === 'number' && feedback > minImprovement) {\n        stagnantCount = 0;\n      } else {\n        stagnantCount++;\n      }\n      return Promise.resolve();\n    },\n  };\n}\n","/**\n * @module Orchestrator (Legacy / Full Control)\n *\n * Prescriptive inner/outer loop controller. You provide Planner, ProbePolicy,\n * Environment, Evaluator, Ladder, Budget, and Probes — the Orchestrator\n * coordinates the full plan → explore → evaluate → replan cycle.\n *\n * CyberLoop owns both loops: the outer loop (Planner) decides strategy,\n * the inner loop (ProbePolicy + Ladder) handles cheap, deterministic exploration.\n *\n * For a lighter-weight approach where you keep your existing agent and add\n * control via composable middleware, see {@link cyberloop} in `./wrapper.ts`.\n *\n * @see docs/guide/choosing-your-api.md — When to use Orchestrator vs cyberloop()\n */\n\nimport type { ControlBudget } from './budget/control-budget'\nimport type {\n  Environment,\n  Evaluator,\n  Ladder,\n  Logger,\n  Planner,\n  Probe,\n  ProbePolicy,\n} from './interfaces'\nimport type { Action, AggregateProbeResult, Feedback, ProbeData, ProbeResult, State } from './types'\n\n/**\n * ExplorationResult - Result of inner loop exploration\n */\nexport interface ExplorationResult<S, D, R extends ProbeResult<D>> {\n  status: 'stable' | 'budget-exhausted'\n  state: S\n  history: S[]\n  probeResults: AggregateProbeResult<D, R>[]\n}\n\n/**\n * StepLog - Log entry for each inner loop iteration\n */\nexport interface StepLog<S, A, F, D, R extends ProbeResult<D>> {\n  t: number\n  state: S\n  action?: A\n  next?: S\n  feedback?: F\n  ladderLevel: number\n  innerBudgetRemaining: number\n  probeResult?: AggregateProbeResult<D, R>\n  isStable: boolean\n}\n\n/**\n * OrchestratorResult - Final result from orchestrator\n */\nexport interface OrchestratorResult<S, A, F, D, R extends ProbeResult<D>> {\n  output: string\n  explorationAttempts: number\n  innerLoopSteps: number\n  outerLoopCalls: number\n  logs: StepLog<S, A, F, D, R>[]\n}\n\n/**\n * OrchestratorOpts - Configuration for orchestrator\n */\nexport interface OrchestratorOpts<S, A, F, D, R extends ProbeResult<D>> {\n  env: Environment<S, A>\n  probePolicy: ProbePolicy<S, A, F>\n  planner: Planner<S>\n  probes: Probe<S, D, R>[]\n  evaluator: Evaluator<S, F>\n  ladder: Ladder<F>\n  budget: ControlBudget\n  maxInnerSteps?: number\n  logger?: Logger\n}\n\n/**\n * Orchestrator - Hierarchical control loop with inner/outer loops\n *\n * Architecture:\n * - Inner loop: Fast, reflexive control using ProbePolicy\n * - Outer loop: Slow, strategic control using Planner\n *\n * Flow:\n * 1. Planner creates initial plan from user input (outer loop call #1)\n * 2. Inner loop explores deterministically until stable or budget exhausted\n * 3. If stable: Planner evaluates results (outer loop call #2)\n * 4. If budget exhausted: Planner replans (outer loop call #3), goto step 2\n * 5. Return final output\n */\nexport class Orchestrator<S = State, A = Action, F = Feedback, D = ProbeData, R extends ProbeResult<D> = ProbeResult<D>> {\n  private readonly env: Environment<S, A>\n  private readonly probePolicy: ProbePolicy<S, A, F>\n  private readonly planner: Planner<S>\n  private readonly probes: Probe<S, D, R>[]\n  private readonly evaluator: Evaluator<S, F>\n  private readonly ladder: Ladder<F>\n  private readonly budget: ControlBudget\n  private readonly maxInnerSteps: number\n  private readonly logger: Logger | undefined\n\n  public logs: StepLog<S, A, F, D, R>[] = []\n\n  constructor(opts: OrchestratorOpts<S, A, F, D, R>) {\n    this.env = opts.env\n    this.probePolicy = opts.probePolicy\n    this.planner = opts.planner\n    this.probes = opts.probes\n    this.evaluator = opts.evaluator\n    this.ladder = opts.ladder\n    this.budget = opts.budget\n    this.maxInnerSteps = opts.maxInnerSteps ?? 50\n    this.logger = opts.logger\n  }\n\n  /**\n   * Run the orchestrator with user input\n   *\n   * @param userInput - User's natural language input\n   * @returns Final output and statistics\n   */\n  async run(userInput: string): Promise<OrchestratorResult<S, A, F, D, R>> {\n    this.logs = []\n    let explorationAttempts = 0\n    let innerLoopSteps = 0\n    let outerLoopCalls = 0\n\n    // Outer loop call #1: Initial planning\n    this.logger?.info('\\n[Outer Loop] Calling planner.plan()...')\n    let state = await this.planner.plan(userInput)\n\n    // Use inspectState if available, otherwise log full state\n    const stateInspection = this.probes[0]?.inspectState?.(state) ?? state\n    this.logger?.info(stateInspection, `[Outer Loop] Initial state`)\n\n    outerLoopCalls++\n    this.budget.outerLoop.record(2.0) // Cost of LLM call\n\n    // Initialize probe policy with initial state\n    this.probePolicy.initialize(state)\n    this.logger?.info('[Outer Loop] ProbePolicy initialized\\n')\n\n    // Main control loop\n    while (!this.budget.shouldStop()) {\n      explorationAttempts++\n\n      // Inner loop: Deterministic exploration\n      const result = await this.exploreInnerLoop(state)\n      innerLoopSteps += result.history.length\n\n      if (result.status === 'stable') {\n        // Success! Outer loop call #2: Evaluate results\n        this.logger?.info('\\n[Outer Loop] Stable state found! Calling planner.evaluate()...')\n        const output = await this.planner.evaluate(result.state, result.history)\n        outerLoopCalls++\n        this.budget.outerLoop.record(2.0)\n\n        return {\n          output,\n          explorationAttempts,\n          innerLoopSteps,\n          outerLoopCalls,\n          logs: this.logs,\n        }\n      }\n\n      if (result.status === 'budget-exhausted' && !this.budget.outerLoop.shouldStop()) {\n        // Inner loop exhausted, try replanning\n        // Outer loop call #3: Replan\n        this.logger?.info('\\n[Outer Loop] Inner loop exhausted. Calling planner.replan()...')\n        const newState = await this.planner.replan(result.state, result.history)\n        outerLoopCalls++\n        this.budget.outerLoop.record(2.0)\n\n        if (newState) {\n          state = newState\n          this.probePolicy.initialize(newState)\n          // Reset inner loop budget for new attempt\n          this.budget.innerLoop.reset?.()\n          continue\n        }\n      }\n\n      // Can't replan or outer budget exhausted\n      break\n    }\n\n    // Fallback: Evaluate whatever state we have, even if not stable\n    // This ensures we always produce output rather than just giving up\n    this.logger?.info('\\n[Outer Loop] Budget exhausted without finding stable state. Evaluating final state...')\n    const finalOutput = await this.planner.evaluate(state, [])\n    outerLoopCalls++\n    this.budget.outerLoop.record(2.0)\n\n    return {\n      output: finalOutput,\n      explorationAttempts,\n      innerLoopSteps,\n      outerLoopCalls,\n      logs: this.logs,\n    }\n  }\n\n  /**\n   * Inner loop: Fast, deterministic exploration\n   *\n   * Uses ProbePolicy to make quick adjustments based on probe signals\n   * until state is stable or inner loop budget exhausted.\n   */\n  private async exploreInnerLoop(initialState: S): Promise<ExplorationResult<S, D, R>> {\n    let state = initialState\n    const history: S[] = [state]\n    const probeResults: AggregateProbeResult<D, R>[] = []\n\n    for (let t = 0; t < this.maxInnerSteps && !this.budget.innerLoop.shouldStop(); t++) {\n      // Run probes to get gradient signals\n      const probeResult = await this.runProbes(state)\n      probeResults.push(probeResult)\n      this.budget.innerLoop.record(0.05) // Cheap probe cost\n\n      // Check if state is stable (good enough)\n      const isStable = this.probePolicy.isStable(state)\n\n      // Log this step\n      this.logs.push({\n        t,\n        state,\n        ladderLevel: this.ladder.level(),\n        innerBudgetRemaining: this.budget.innerLoop.remaining(),\n        probeResult,\n        isStable,\n      })\n\n      // Debug logging\n      let stateInspection = this.probes[0]?.inspectState?.(state);\n\n      // Fallback: Create a sanitized object (not string) using JSON parse/stringify hack with replacer\n      // This ensures pino logs it as a structured object under a key, not as the message string.\n      stateInspection ??= JSON.parse(JSON.stringify(state, (key, value: unknown) => {\n        if (key === 'summary' && typeof value === 'string' && value.length > 150) {\n          return value.substring(0, 150) + '... (truncated)'\n        }\n        // Also truncate vectors in state if any\n        if (Array.isArray(value) && value.length > 5 && typeof value[0] === 'number') {\n          return `[Vector(${value.length})]`\n        }\n        return value\n      })) as Record<string, unknown>;\n\n      this.logger?.info({ state: stateInspection }, `[Inner Loop t=${t}], stable=${isStable}, budget=${this.budget.innerLoop.remaining().toFixed(2)}`)\n\n      if (isStable) {\n        return {\n          status: 'stable',\n          state,\n          history,\n          probeResults,\n        }\n      }\n\n      // Probe policy decides next action (deterministic, no LLM!)\n      const action = await this.probePolicy.decide(state, this.ladder)\n\n      const logAction = JSON.stringify(action, (_key, value: unknown) => {\n        if (Array.isArray(value) && value.length > 5 && typeof value[0] === 'number') {\n          return `[Vector(${value.length})]`\n        }\n        return value\n      })\n\n      this.logger?.info(`[Inner Loop t=${t}] Action: ${logAction}`)\n      this.budget.innerLoop.record(0.1) // Cheap decision cost\n\n      // Apply action to environment\n      const nextState = await this.env.apply(action)\n\n      // Evaluate and update ladder\n      const feedback = await this.evaluator.evaluate(state, nextState)\n      this.ladder.update(feedback)\n\n      // Update policy (optional adaptation)\n      this.probePolicy.adapt?.(feedback, this.ladder)\n\n      // Update log with action and feedback\n      const lastLog = this.logs[this.logs.length - 1]\n      if (lastLog) {\n        lastLog.action = action\n        lastLog.next = nextState\n        lastLog.feedback = feedback\n      }\n\n      state = nextState\n      history.push(state)\n    }\n\n    return {\n      status: 'budget-exhausted',\n      state,\n      history,\n      probeResults,\n    }\n  }\n\n  /**\n   * Run all probes and combine results\n   */\n  private async runProbes(state: S): Promise<AggregateProbeResult<D, R>> {\n    const results = await Promise.all(\n      this.probes.map(probe => Promise.resolve(probe.test(state)))\n    )\n\n    // Combine probe results (simple strategy: fail if any fails)\n    const allPass = results.every(r => r.pass)\n    const reasons = results.filter(r => !r.pass).map(r => r.reason).filter(Boolean)\n\n    return {\n      pass: allPass,\n      reason: reasons.join(', ') || undefined,\n      results,\n    }\n  }\n}\n","/**\n * Turns an arbitrary scoring function into an evaluator compatible with the loop.\n */\nexport const DeltaScoreEvaluator = <S>(\n  score: (prev: S, next: S) => number,\n) => ({\n  evaluate: (prev: S, next: S) => score(prev, next),\n})\n","import type { Ladder } from '../interfaces'\n\n/**\n * Proportional controller that scales ladder level by feedback signal.\n * Positive feedback raises the level, negative lowers it.\n */\nexport class ProportionalLadder implements Ladder<number> {\n  private levelValue = 0\n\n  constructor(\n    private readonly opts: { gainUp?: number; gainDown?: number; max?: number } = {},\n  ) { }\n\n  update(feedback: number): void {\n    const up = this.opts.gainUp ?? 0.5\n    const down = this.opts.gainDown ?? 0.5\n    const max = this.opts.max ?? 3\n\n    if (feedback >= 0) {\n      this.levelValue = Math.min(max, this.levelValue + up * feedback)\n    } else {\n      this.levelValue = Math.max(0, this.levelValue + down * feedback)\n    }\n  }\n\n  level(): number {\n    return this.levelValue\n  }\n}\n","/**\n * Reference Implementations for Optional Meta-Control Components\n *\n * This module provides example implementations of optional AICL interfaces.\n * These are educational examples showing how to implement advanced meta-control\n * components like StrategySelector, FailureClassifier, and TerminationPolicy.\n *\n * ## When to use these\n *\n * Most applications DON'T need these components. They're for advanced scenarios:\n * - Multi-strategy routing across different domains\n * - Complex failure diagnosis and recovery\n * - Multi-objective termination criteria\n *\n * ## Recommended approach\n *\n * Instead of using these generic implementations, create domain-specific components\n * tailored to your use case. See `src/adapters/github` for the recommended pattern:\n * - Custom ProbePolicy (DeterministicSearchPolicy)\n * - Domain-specific probes (hasHitsProbe, dropGuardProbe, entropyGuardProbe)\n * - Simple evaluators and ladders from core/\n *\n * ## What's in this module\n *\n * - SimpleBudgetTracker - Basic budget tracking (use ControlBudget instead)\n * - RuleBasedStrategySelector - Multi-strategy routing example\n * - CheapPassProbe - No-op probe for testing\n * - ThresholdEvaluator - Placeholder evaluator for testing\n * - StagnationTerminationPolicy - Multi-objective stopping criteria\n * - ReasonFailureClassifier - Rule-based failure diagnosis\n */\n\nimport type {\n  BudgetTracker,\n  FailureClassifier,\n  Policy,\n  Probe,\n  StrategySelector,\n  TerminationPolicy,\n} from '../core/interfaces'\nimport type { FailureType } from '../core/types'\n\n/**\n * Reference implementation: Simple budget tracker.\n * Tracks a finite total budget. Decrements each time `record()` is called.\n * Note: Production code should use ControlBudget for hierarchical inner/outer loop tracking.\n */\nexport class SimpleBudgetTracker implements BudgetTracker {\n  private current: number\n  constructor(private total: number) { this.current = total }\n  record(cost: number | Record<string, number>): void {\n    const amount = typeof cost === 'number'\n      ? cost\n      : Object.values(cost).reduce((sum, value) => sum + (value ?? 0), 0)\n    this.current = Math.max(0, this.current - (amount || 0))\n  }\n  remaining(): number { return this.current }\n  shouldStop(): boolean { return this.current <= 0 }\n  reset(v?: number): void { this.current = v ?? this.total }\n}\n\n/**\n * Reference implementation: Rule-based strategy selector.\n * Optional meta-control component for multi-strategy routing.\n * Chooses the cheapest probe/policy pair based on failure type and ladder level.\n * Most applications use a single policy and don't need this.\n */\nexport class RuleBasedStrategySelector<S, A> implements StrategySelector<S, A> {\n  select(input: {\n    failure: FailureType\n    ladderLevel: number\n    budgetRemaining: number\n    probes: Probe<S>[]\n    policies: Policy<S, A>[]\n  }): { probe: Probe<S>; policy: Policy<S, A> } {\n    const { failure, ladderLevel, probes, policies } = input\n\n    const sortedProbes = [...probes].sort(\n      (a, b) => (a.capabilities?.()?.cost ?? 0) - (b.capabilities?.()?.cost ?? 0),\n    )\n    const probe =\n      sortedProbes.find(p => p.capabilities?.()?.supports?.includes(failure)) ??\n      sortedProbes[0]\n\n    const inWindow = policies.filter(p => {\n      const [min, max] = p.capabilities?.()?.explorationRange ?? [0, Infinity]\n      return ladderLevel >= min && ladderLevel <= max\n    })\n    const candidates = inWindow.length ? inWindow : policies\n    candidates.sort(\n      (a, b) =>\n        (a.capabilities?.()?.cost?.step ?? 1) -\n        (b.capabilities?.()?.cost?.step ?? 1),\n    )\n    const policy = candidates[0]\n\n    return { probe, policy }\n  }\n}\n\n/**\n * Reference implementation: No-op probe for testing.\n * Always passes with zero cost. Useful for quick experiments and testing.\n */\nexport const CheapPassProbe = <S>(id = 'cheap-pass'): Probe<S> => ({\n  id,\n  capabilities: () => ({ cost: 0 }),\n  test: () => ({ pass: true }),\n})\n\n/**\n * Reference implementation: Constant-score evaluator.\n * Placeholder for testing. Production code should implement domain-specific evaluation logic.\n */\nexport class ThresholdEvaluator<S> {\n  constructor(private threshold = 0) { }\n  evaluate(_prev: S, _next: S): number {\n    return 1 // always positive feedback for testing\n  }\n}\n\n/**\n * Reference implementation: Stagnation-based termination policy.\n * Optional meta-control component for complex stopping criteria.\n * Stops when budget exhausted or improvements stall.\n * Most applications use ControlBudget's built-in termination.\n */\nexport class StagnationTerminationPolicy implements TerminationPolicy {\n  constructor(private opts: { maxStagnantSteps?: number; minFeedback?: number } = {}) { }\n  shouldStop(input: {\n    t: number\n    budgetRemaining: number\n    noImprovementSteps: number\n    lastFeedback?: number\n  }): { stop: boolean; reason?: string } {\n    if (input.budgetRemaining <= 0) {\n      return { stop: true, reason: 'budget-exhausted' }\n    }\n    if (\n      this.opts.maxStagnantSteps !== undefined &&\n      input.noImprovementSteps >= this.opts.maxStagnantSteps\n    ) {\n      return { stop: true, reason: 'stagnation' }\n    }\n    if (\n      this.opts.minFeedback !== undefined &&\n      (input.lastFeedback ?? 0) <= this.opts.minFeedback\n    ) {\n      return { stop: true, reason: 'feedback-threshold' }\n    }\n    return { stop: false }\n  }\n}\n\n/**\n * Reference implementation: Rule-based failure classifier.\n * Optional meta-control component for diagnosing complex failure modes.\n * Classifies failures based on probe reasons and metrics (entropy, hit counts, etc.).\n * Most applications handle failures directly in their ProbePolicy.\n */\nexport class ReasonFailureClassifier<S, A> implements FailureClassifier<S, A> {\n  constructor(\n    private opts: {\n      entropyHigh?: number\n      entropyLow?: number\n      sparseHits?: number\n      denseHits?: number\n    } = {},\n  ) { }\n\n  classify(input: {\n    prev: S\n    next?: S\n    action?: A\n    probeReason?: string\n    metrics?: Record<string, unknown>\n  }): FailureType {\n    const reason = input.probeReason ?? ''\n    const metrics = input.metrics ?? {}\n    const hits = typeof metrics.hitCount === 'number' ? metrics.hitCount : undefined\n    const entropy = typeof metrics.entropy === 'number' ? metrics.entropy : undefined\n    const lastFeedback =\n      typeof metrics.feedback === 'number' ? metrics.feedback : undefined\n\n    if (/no[-\\s]?hits|empty/i.test(reason) || hits === 0) return 'NoData'\n    if (/rate[-\\s]?limit/i.test(reason)) return 'RateLimited'\n    if (/auth/i.test(reason)) return 'AuthDenied'\n    if (/missing[-\\s]?tool/i.test(reason)) return 'ToolMissing'\n    if (/infeasible/i.test(reason)) return 'Infeasible'\n\n    const entropyHigh = this.opts.entropyHigh ?? 0.85\n    const entropyLow = this.opts.entropyLow ?? 0.2\n    if (entropy !== undefined) {\n      if (entropy > entropyHigh) return 'TooBroad'\n      if (entropy < entropyLow) return 'TooNarrow'\n    }\n\n    const denseHits = this.opts.denseHits ?? 100\n    const sparseHits = this.opts.sparseHits ?? 3\n    if (hits !== undefined) {\n      if (hits > denseHits) return 'TooBroad'\n      if (hits > 0 && hits < sparseHits) return 'TooNarrow'\n    }\n\n    if (lastFeedback !== undefined && lastFeedback < 0) {\n      return 'Unknown'\n    }\n\n    return 'Unknown'\n  }\n}\n","import type { Probe } from '../interfaces'\n\nexport interface EntropyProbeOpts {\n  id?: string\n  max?: number\n  min?: number\n  cost?: number\n}\n\n/**\n * Rejects states whose entropy suggests over-broad or over-narrow exploration.\n */\nexport const EntropyProbe = <S>(\n  getEntropy: (state: S) => number,\n  opts: EntropyProbeOpts = {},\n  inspector?: (state: S) => Record<string, unknown>,\n): Probe<S> => {\n  const max = opts.max ?? 0.85\n  const min = opts.min ?? 0\n  const cost = opts.cost ?? 0.2\n  return {\n    id: opts.id ?? 'entropy',\n    capabilities: () => ({\n      cost,\n      supports: ['TooBroad', 'TooNarrow', 'Unknown'],\n    }),\n    test: (state) => {\n      const entropy = getEntropy(state)\n      if (!Number.isFinite(entropy)) {\n        return { pass: false, reason: 'entropy-invalid' }\n      }\n      if (entropy > max) {\n        return { pass: false, reason: 'entropy-high' }\n      }\n      if (entropy < min) {\n        return { pass: false, reason: 'entropy-low' }\n      }\n      return { pass: true }\n    },\n    inspectState: inspector,\n  }\n}\n","import type { Probe } from '../interfaces'\n\nexport interface HitCountProbeOpts {\n  id?: string\n  min?: number\n  max?: number\n  cost?: number\n}\n\n/**\n * Rejects states whose hit count is zero or outside desired bounds.\n * Useful as a cheap guard before executing wider exploration policies.\n */\nexport const HitCountProbe = <S>(\n  getCount: (state: S) => number,\n  opts: HitCountProbeOpts = {},\n  inspector?: (state: S) => Record<string, unknown>,\n): Probe<S> => {\n  const min = opts.min ?? 1\n  const max = opts.max ?? Infinity\n  const cost = opts.cost ?? 0.1\n  return {\n    id: opts.id ?? 'hit-count',\n    capabilities: () => ({\n      cost,\n      supports: ['Unknown', 'NoData', 'TooBroad', 'TooNarrow'],\n    }),\n    test: (state) => {\n      const count = getCount(state)\n      if (!Number.isFinite(count)) {\n        return { pass: false, reason: 'hit-count-invalid', data: { count } }\n      }\n      if (count < min) {\n        return { pass: false, reason: 'no-hits', data: { count, min } }\n      }\n      if (count > max) {\n        return { pass: false, reason: 'too-many-hits', data: { count, max } }\n      }\n      return { pass: true, data: { count, min, max } }\n    },\n    inspectState: inspector,\n  }\n}\n","import type { BudgetTracker } from '../interfaces/budget-tracker'\nimport type { Cost } from '../types'\n\n/**\n * ControlBudget - Hierarchical budget for inner/outer control loops\n * \n * Separates cheap operations (inner loop: probes, local adjustments)\n * from expensive operations (outer loop: LLM calls, planning).\n * \n * Inspired by hierarchical control theory where fast inner loops\n * operate at high frequency with low cost, while slow outer loops\n * provide strategic guidance at low frequency with high cost.\n */\nexport interface ControlBudget {\n  /** Inner loop budget - cheap, high-frequency operations */\n  innerLoop: BudgetTracker\n  \n  /** Outer loop budget - expensive, low-frequency operations */\n  outerLoop: BudgetTracker\n  \n  /** Check if any budget is exhausted */\n  shouldStop(): boolean\n}\n\n/**\n * Simple implementation of ControlBudget\n */\nexport class SimpleControlBudget implements ControlBudget {\n  constructor(\n    public innerLoop: BudgetTracker,\n    public outerLoop: BudgetTracker,\n  ) {}\n\n  shouldStop(): boolean {\n    return this.innerLoop.shouldStop() || this.outerLoop.shouldStop()\n  }\n}\n\n/**\n * Create a control budget with specified initial values\n */\nexport function createControlBudget(\n  innerLoopBudget: Cost,\n  outerLoopBudget: Cost,\n): ControlBudget {\n  return new SimpleControlBudget(\n    createSimpleBudget(innerLoopBudget),\n    createSimpleBudget(outerLoopBudget),\n  )\n}\n\n/**\n * Simple budget tracker implementation\n */\nfunction createSimpleBudget(initial: Cost): BudgetTracker {\n  let current = typeof initial === 'number' ? initial : 0\n\n  return {\n    record(cost: Cost): void {\n      const costValue = typeof cost === 'number' ? cost : 0\n      current -= costValue\n    },\n    remaining(): number {\n      return current\n    },\n    shouldStop(): boolean {\n      return current <= 0\n    },\n    reset(value?: Cost): void {\n      current = typeof value === 'number' ? value : (typeof initial === 'number' ? initial : 0)\n    },\n  }\n}\n","export * from './agent-evaluator'\nexport * from './agent-policy'\nexport * from './env'\nexport * from './evaluator'\nexport * from './policy'\nexport * from './probes'\nexport * from './search-tool'\nexport * from './selector'\nexport * from './telemetry'\n","import type { Evaluator } from '@/core/interfaces'\n\nimport type { GhState } from './env'\n\nexport class AgentRelevanceEvaluator implements Evaluator<GhState, number> {\n  async evaluate(prev: GhState, next: GhState): Promise<number> {\n    const deltaHits = next.hits - prev.hits\n    const entropyImprovement = prev.entropy - next.entropy\n    const normalizedDelta = deltaHits / Math.max(1, prev.hits + next.hits)\n    return normalizedDelta * 0.6 + entropyImprovement * 0.4\n  }\n}\n","import { Octokit } from '@octokit/rest'\nimport { tool } from '@openai/agents'\n\nexport interface GitHubSearchItem {\n  title: string\n  url: string\n  labels: string[]\n  stars: number\n}\n\nexport interface GitHubSearchResult {\n  hits: number\n  entropy: number\n  items: GitHubSearchItem[]\n}\n\nexport interface SearchFilters {\n  keywords: string[]        // Main search terms (AND combined)\n  orKeywords?: string[]     // Alternative terms (OR combined)\n  language?: string         // Programming language filter\n  minStars?: number         // Minimum star count\n  maxStars?: number         // Maximum star count\n  topic?: string            // GitHub topic filter\n  inName?: boolean          // Search in repository name only\n  inDescription?: boolean   // Search in description\n}\n\nexport interface GitHubSearchApi {\n  search(query: string | SearchFilters, opts?: { perPage?: number }): Promise<GitHubSearchResult>\n}\n\ninterface GitHubSearchInput {\n  keywords: string[]\n  or_keywords?: string[]\n  language?: string\n  min_stars?: number\n  max_stars?: number\n  topic?: string\n  in_name?: boolean\n  in_description?: boolean\n  per_page?: number\n}\n\nfunction parseGitHubSearchInput(input: unknown): GitHubSearchInput {\n  if (!input || typeof input !== 'object') {\n    throw new Error('github_search parameters must be an object')\n  }\n\n  const maybeRecord = input as Record<string, unknown>\n  const { keywords, or_keywords, language, min_stars, max_stars, topic, in_name, in_description, per_page } = maybeRecord\n\n  if (!Array.isArray(keywords) || keywords.length === 0) {\n    throw new Error('github_search requires a non-empty \"keywords\" array')\n  }\n\n  if (!keywords.every(k => typeof k === 'string')) {\n    throw new Error('all keywords must be strings')\n  }\n\n  const result: GitHubSearchInput = { keywords }\n\n  if (or_keywords !== undefined) {\n    if (!Array.isArray(or_keywords)) throw new Error('\"or_keywords\" must be an array')\n    result.or_keywords = or_keywords\n  }\n  if (language !== undefined) {\n    if (typeof language !== 'string') throw new Error('\"language\" must be a string')\n    result.language = language\n  }\n  if (min_stars !== undefined) {\n    if (typeof min_stars !== 'number') throw new Error('\"min_stars\" must be a number')\n    result.min_stars = min_stars\n  }\n  if (max_stars !== undefined) {\n    if (typeof max_stars !== 'number') throw new Error('\"max_stars\" must be a number')\n    result.max_stars = max_stars\n  }\n  if (topic !== undefined) {\n    if (typeof topic !== 'string') throw new Error('\"topic\" must be a string')\n    result.topic = topic\n  }\n  if (in_name !== undefined) {\n    if (typeof in_name !== 'boolean') throw new Error('\"in_name\" must be a boolean')\n    result.in_name = in_name\n  }\n  if (in_description !== undefined) {\n    if (typeof in_description !== 'boolean') throw new Error('\"in_description\" must be a boolean')\n    result.in_description = in_description\n  }\n  if (per_page !== undefined) {\n    if (typeof per_page !== 'number' || !Number.isInteger(per_page)) {\n      throw new Error('\"per_page\" must be an integer')\n    }\n    if (per_page < 1 || per_page > 30) {\n      throw new Error('\"per_page\" must be between 1 and 30')\n    }\n    result.per_page = per_page\n  }\n\n  return result\n}\n\nfunction buildGitHubQuery(filters: SearchFilters): string {\n  const parts: string[] = []\n\n  // Main keywords (AND combined)\n  const mainQuery = filters.keywords.join(' ')\n  parts.push(mainQuery)\n\n  // OR keywords\n  if (filters.orKeywords && filters.orKeywords.length > 0) {\n    parts.push('OR ' + filters.orKeywords.join(' OR '))\n  }\n\n  // Language filter\n  if (filters.language) {\n    parts.push(`language:${filters.language}`)\n  }\n\n  // Star filters\n  if (filters.minStars !== undefined && filters.maxStars !== undefined) {\n    parts.push(`stars:${filters.minStars}..${filters.maxStars}`)\n  } else if (filters.minStars !== undefined) {\n    parts.push(`stars:>=${filters.minStars}`)\n  } else if (filters.maxStars !== undefined) {\n    parts.push(`stars:<=${filters.maxStars}`)\n  }\n\n  // Topic filter\n  if (filters.topic) {\n    parts.push(`topic:${filters.topic}`)\n  }\n\n  // Search scope filters\n  if (filters.inName) {\n    parts.push('in:name')\n  }\n  if (filters.inDescription) {\n    parts.push('in:description')\n  }\n\n  return parts.join(' ')\n}\n\nexport function createGitHubSearchApi(token = process.env.GITHUB_TOKEN): GitHubSearchApi {\n  if (!token) throw new Error('GITHUB_TOKEN env variable is required for live GitHub search.')\n  const octokit = new Octokit({ auth: token })\n  return {\n    async search(queryOrFilters, opts = {}) {\n      // Support both string queries (backward compat) and structured filters\n      const query = typeof queryOrFilters === 'string' \n        ? queryOrFilters \n        : buildGitHubQuery(queryOrFilters)\n      \n      const perPage = opts.perPage ?? 10\n      const response = await octokit.rest.search.repos({\n        q: query,\n        per_page: perPage,\n        sort: 'stars',\n        order: 'desc',\n      })\n      const repos = (response.data.items ?? []) as {\n        full_name: string\n        description?: string | null\n        stargazers_count?: number\n        html_url?: string\n      }[]\n      const items = repos.map(item => ({\n        title: item.full_name,\n        labels: item.description ? [item.description] : [],\n        stars: item.stargazers_count ?? 0,\n        url: item.html_url ?? '',\n      }))\n      return {\n        hits: response.data.total_count ?? items.length,\n        entropy: computeEntropy(items),\n        items,\n      }\n    },\n  }\n}\n\nexport function createGitHubSearchTool(api: GitHubSearchApi) {\n  return tool({\n    name: 'github_search',\n    description: 'Search GitHub repositories with structured filters. Use multiple dimensions to narrow or broaden search.',\n    strict: false,\n    parameters: {\n      type: 'object',\n      properties: {\n        keywords: {\n          type: 'array',\n          items: { type: 'string' },\n          description: 'Main search keywords (AND combined). E.g. [\"rust\", \"async\", \"runtime\"]',\n        },\n        or_keywords: {\n          type: 'array',\n          items: { type: 'string' },\n          description: 'Alternative keywords (OR combined). E.g. [\"tokio\", \"async-std\"]',\n        },\n        language: {\n          type: 'string',\n          description: 'Filter by programming language. E.g. \"rust\", \"python\", \"javascript\"',\n        },\n        min_stars: {\n          type: 'integer',\n          description: 'Minimum star count',\n        },\n        max_stars: {\n          type: 'integer',\n          description: 'Maximum star count',\n        },\n        topic: {\n          type: 'string',\n          description: 'GitHub topic filter. E.g. \"async\", \"web-framework\"',\n        },\n        in_name: {\n          type: 'boolean',\n          description: 'Search only in repository name',\n        },\n        in_description: {\n          type: 'boolean',\n          description: 'Search only in repository description',\n        },\n      },\n      required: ['keywords'],\n      additionalProperties: true,\n    } as const,\n    async execute(rawInput: unknown) {\n      const { keywords, or_keywords, language, min_stars, max_stars, topic, in_name, in_description, per_page } = parseGitHubSearchInput(rawInput)\n      return api.search({\n        keywords,\n        orKeywords: or_keywords,\n        language,\n        minStars: min_stars,\n        maxStars: max_stars,\n        topic,\n        inName: in_name,\n        inDescription: in_description,\n      }, { perPage: per_page })\n    },\n  })\n}\n\nfunction computeEntropy(items: GitHubSearchItem[]): number {\n  if (!items.length) return 0\n  const starCounts = items.map(i => i.stars || 0)\n  const max = Math.max(...starCounts)\n  const min = Math.min(...starCounts)\n  if (max === 0) return 0\n  return (max - min) / (max + 1)\n}\n","import { Agent, run } from '@openai/agents'\nimport { z } from 'zod'\n\nimport type { Ladder, Policy } from '@/core/interfaces'\n\nimport type { GhAction, GhState } from './env'\nimport type { GitHubSearchApi } from './search-tool'\nimport { createGitHubSearchTool } from './search-tool'\n\nconst ProbeSchema = z.object({\n  id: z.string(),\n  pass: z.boolean(),\n  reason: z.string().optional(),\n  data: z.unknown().optional(),\n})\n\nconst AgentInputSchema = z.object({\n  query: z.string(),\n  hits: z.number(),\n  entropy: z.number(),\n  lastProbe: ProbeSchema.optional(),\n  probeHistory: z.array(ProbeSchema).max(10),\n  items: z.array(\n    z.object({\n      title: z.string(),\n      url: z.string().optional(),\n      labels: z.array(z.string()).optional(),\n      stars: z.number().optional(),\n    }),\n  ).max(5),\n  history: z\n    .array(z.object({ query: z.string(), hits: z.number() }))\n    .max(5)\n    .optional(),\n  suggested_mode: z.enum(['broaden', 'narrow', 'rephrase']),\n})\n\nconst ActionSchema = z.object({\n  type: z.enum(['broaden', 'narrow', 'rephrase']).optional(),\n  payload: z.object({\n    synonyms: z.array(z.string()).max(5).optional(),\n    exact: z.array(z.string()).max(5).optional(),\n    pattern: z.string().max(140).optional(),\n  }).partial().optional(),\n})\n\nexport class AgentQueryPolicy implements Policy<GhState, GhAction, number> {\n  readonly id = 'agent-query-policy'\n  private readonly githubTool: ReturnType<typeof createGitHubSearchTool>\n\n  constructor(private readonly api: GitHubSearchApi) {\n    this.githubTool = createGitHubSearchTool(api)\n  }\n\n  capabilities() {\n    return {\n      explorationRange: [0, 3] as [number, number],\n      cost: { step: 2 },\n      handles: ['Unknown', 'TooBroad', 'TooNarrow', 'NoData'],\n    }\n  }\n\n  async decide(state: GhState, ladder: Ladder<number>): Promise<GhAction> {\n    // Determine mode based on ladder level AND probe failure signals\n    let mode: GhAction['type'] = ladder.level() < 1 ? 'narrow' : ladder.level() > 2 ? 'broaden' : 'rephrase'\n    \n    // Override mode based on probe history signals (gradient-based adaptation)\n    const recentProbes = (state.probes ?? []).slice(-3)\n    const hasNoHitsFailures = recentProbes.some(p => !p.pass && (p.reason?.includes('no-hits') ?? p.reason?.includes('drop-to-zero')))\n    const hasStuckAtZero = recentProbes.some(p => !p.pass && p.reason?.includes('stuck-at-zero'))\n    \n    // If we're stuck with no hits, force broaden mode\n    if (hasStuckAtZero || (hasNoHitsFailures && state.hits === 0)) {\n      mode = 'broaden'\n    }\n    \n    const agent = new Agent<GhAction>({\n      name: 'GitHubQueryAgent',\n      instructions: buildInstructions(mode),\n      tools: [this.githubTool],\n    })\n\n    const lastProbe = (state.probes ?? []).slice(-1)[0]\n    const agentInput = AgentInputSchema.parse({\n      query: state.query,\n      hits: state.hits,\n      entropy: state.entropy,\n      lastProbe,\n      probeHistory: state.probes ?? [],\n      items: (state.items ?? []).slice(0, 5),\n      history: state.history?.slice(-5),\n      suggested_mode: mode,\n    })\n\n    const runResult = await run(agent, JSON.stringify(agentInput))\n\n    return normalizeAction(runResult.finalOutput, mode)\n  }\n\n  adapt(_feedback: number, _ladder: Ladder<number>): void {\n    // no-op adaptation for now\n  }\n}\n\nfunction buildInstructions(mode: GhAction['type']): string {\n  return `\nYou are assisting with GitHub repository search refinement using a control-theoretic approach.\n\n**Context:**\n- Input provides the current query, hit count, entropy, sample items, and probe history.\n- The probe history shows deterministic checks (hasHits, entropyGuard, dropGuard) that act as canary signals.\n- These probes help you quickly rule out or widen conditions, but YOU should explore multiple strategies.\n\n**Your Task:**\n- Use probe results as INTERNAL GRADIENT SIGNALS to guide your exploration.\n- If probes failed (pass=false), their reasons indicate promising directions to adjust.\n- You can make MULTIPLE tool calls to github_search to test hypotheses before deciding.\n- The suggested mode is \"${mode}\", but you may deviate if probe signals suggest otherwise.\n\n**Output Format:**\nReturn JSON with shape: { \"type\": \"broaden\"|\"narrow\"|\"rephrase\", \"payload\": { ... } }\n- For broaden: { synonyms: string[] }\n- For narrow: { exact: string[] }\n- For rephrase: { pattern: string }\n\n**Strategy:**\n1. Analyze probe history to understand what failed and why\n2. Test hypotheses with github_search tool calls if needed\n3. Choose action that addresses root causes revealed by probes\n4. Keep payload concise and actionable\n  `.trim()\n}\n\nfunction normalizeAction(output: unknown, fallback: GhAction['type']): GhAction {\n  const raw = typeof output === 'string' ? safeParse(output) : output\n  if (raw && typeof raw === 'object') {\n    const parsed = ActionSchema.safeParse(raw)\n    if (parsed.success) {\n      return buildAction(parsed.data, fallback)\n    }\n  }\n  return { type: fallback, payload: {} }\n}\n\nfunction buildAction(parsed: z.infer<typeof ActionSchema>, fallback: GhAction['type']): GhAction {\n  const type = parsed.type ?? fallback\n  const payload = parsed.payload\n  if (type === 'broaden') {\n    return payload?.synonyms?.length\n      ? { type: 'broaden', payload: { synonyms: payload.synonyms } }\n      : { type: 'broaden' }\n  }\n  if (type === 'narrow') {\n    return payload?.exact?.length\n      ? { type: 'narrow', payload: { exact: payload.exact } }\n      : { type: 'narrow' }\n  }\n  if (payload?.pattern) {\n    return { type: 'rephrase', payload: { pattern: payload.pattern } }\n  }\n  return { type: 'rephrase' }\n}\n\nfunction safeParse(value: string): unknown {\n  try {\n    return JSON.parse(value)\n  } catch {\n    return undefined\n  }\n}\n","import pino from 'pino'\n\nimport type { Logger } from '@/core/interfaces'\n\nexport const logger: Logger = pino({\n  transport: {\n    target: 'pino-pretty'\n  },\n})\n","import type { Environment } from '@/core/interfaces'\n\nimport type { GitHubSearchApi, SearchFilters } from './search-tool'\nimport { logger } from './telemetry'\n\nexport interface GhState {\n  query: string // Legacy - for display\n  filters: SearchFilters\n  hits: number\n  entropy: number\n  items?: { title: string; url: string; labels?: string[]; stars?: number }[]\n  history?: { filters: SearchFilters; hits: number }[]\n  probes?: { id: string; pass: boolean; reason?: string; data?: unknown }[]\n}\n\nexport type GhAction =\n  | { type: 'broaden'; payload?: { synonyms?: string[] } }\n  | { type: 'narrow'; payload?: { exact?: string[] } }\n  | { type: 'rephrase'; payload?: { pattern?: string } }\n\nexport const GitHubSearchEnv = (\n  api: GitHubSearchApi,\n  initialFilters: SearchFilters,\n  options: { initialFetch?: boolean; log?: boolean } = {},\n): Environment<GhState, GhAction> => {\n  let current: GhState = {\n    query: initialFilters.keywords.join(' '),\n    filters: initialFilters,\n    hits: 0,\n    entropy: 1,\n    history: [],\n    probes: []\n  }\n  let initialized = false\n  const initialFetch = options.initialFetch ?? true\n  const log = options.log ?? false\n\n  if (initialFetch) {\n    void (async () => {\n      const result = await api.search(initialFilters)\n      current = {\n        ...current,\n        history: [...(current.history ?? []), { filters: initialFilters, hits: result.hits }],\n        probes: current.probes ?? [],\n        hits: result.hits,\n        entropy: result.entropy,\n        items: result.items,\n      }\n      initialized = true\n    })()\n  }\n  const fetch = async (filters: SearchFilters) => {\n    const response = await api.search(filters, { perPage: 10 })\n    const history = (current.history ?? []).concat({ filters, hits: response.hits }).slice(-10)\n    // Preserve probe history across state transitions\n    current = {\n      query: filters.keywords.join(' '),\n      filters,\n      ...response,\n      history,\n      probes: current.probes ?? []\n    }\n    if (log) {\n      logger.info({\n        query: current.query,\n        hits: current.hits,\n        entropy: current.entropy,\n        probes: current.probes?.length ?? 0,\n      }, '[GitHubSearchEnv] fetch')\n    }\n    initialized = true\n    return current\n  }\n\n  return {\n    observe: async () => {\n      if (!initialized && initialFetch) {\n        await fetch(current.filters)\n      }\n      return current\n    },\n    apply: async (action) => {\n      const nextFilters = mutateFilters(current.filters, action)\n      if (log) {\n        logger.info({ action, nextFilters }, '[GitHubSearchEnv] apply')\n      }\n      return fetch(nextFilters)\n    },\n  }\n}\n\nfunction mutateFilters(filters: SearchFilters, action: GhAction): SearchFilters {\n  switch (action.type) {\n    case 'broaden':\n      // Handle special broadening directives\n      if (action.payload?.synonyms) {\n        const synonym = action.payload.synonyms[0]\n        // Check if it's a stars directive to remove minStars\n        if (synonym === 'stars:>0') {\n          return {\n            ...filters,\n            minStars: undefined,\n          }\n        }\n        // Otherwise add as OR keywords\n        return {\n          ...filters,\n          orKeywords: action.payload.synonyms,\n        }\n      }\n      // Remove last keyword if no payload\n      if (filters.keywords.length > 1) {\n        return {\n          ...filters,\n          keywords: filters.keywords.slice(0, -1),\n        }\n      }\n      return filters\n    case 'narrow':\n      // Handle special narrowing directives\n      if (action.payload?.exact) {\n        const exact = action.payload.exact[0]\n        // Check if it's a stars directive\n        if (exact?.startsWith('stars:>')) {\n          const minStars = parseInt(exact.replace('stars:>', ''), 10)\n          return {\n            ...filters,\n            minStars,\n          }\n        }\n        // Otherwise add as keyword\n        return {\n          ...filters,\n          keywords: [...filters.keywords, ...action.payload.exact],\n        }\n      }\n      return filters\n    case 'rephrase':\n      // Keep same filters (no-op)\n      return filters\n    default:\n      return filters\n  }\n}\n","export const HitGainEvaluator = {\n  evaluate: (prev: { hits: number }, next: { hits: number }) => next.hits - prev.hits,\n}\n","import type { Ladder, Policy } from '@/core/interfaces'\n\nimport type { GhAction, GhState } from './env'\n\nexport const QueryMutatePolicy: Policy<GhState, GhAction, number> = {\n  id: 'query-mutate',\n  capabilities: () => ({\n    explorationRange: [0, 3] as [number, number],\n    cost: { step: 1 },\n    handles: ['Unknown', 'NoData', 'TooBroad', 'TooNarrow'],\n  }),\n  decide: async (state: GhState, ladder: Ladder<number>) => {\n    const level = ladder.level()\n    if (state.hits === 0) return { type: 'broaden' }\n    if (state.entropy > 0.8 && level < 1.5) return { type: 'narrow' }\n    if (level > 2) {\n      return {\n        type: 'broaden',\n        payload: { synonyms: ['guide', 'tutorial', 'best practices'] },\n      }\n    }\n    return { type: 'rephrase', payload: { pattern: 'techniques' } }\n  },\n}\n","import type { Probe } from '@/core/interfaces'\nimport { EntropyProbe, HitCountProbe } from '@/core/probes'\n\nimport type { GhState } from './env'\n\nconst stateInspector = function (this: void, state: GhState): {\n  query: string\n  hits: number\n  entropy: number\n  items: string[] | undefined\n  history: { filters: string; hits: number }[] | undefined\n} {\n  const { query, hits, entropy, items, history } = state\n  const itemSummary = items?.map(i => i.title)\n  const historySummary = history?.map(h => {\n    const filters = Object.entries(h.filters).map(([key, value]) => `${key}: ${value}`).join(', ')\n    return {\n      filters,\n      hits: h.hits,\n    }\n  })\n  const inspection = {\n    query,\n    hits,\n    entropy,\n    items: itemSummary,\n    history: historySummary,\n  }\n  return inspection\n}\n\nexport const hasHitsProbe = HitCountProbe<GhState>(state => state.hits, {\n  id: 'gh-hit-count',\n  min: 1,\n  cost: 0.05,\n}, stateInspector)\n\n// Drop guard probe that checks if hits dropped significantly from history\nexport const dropGuardProbe: Probe<GhState> = {\n  id: 'gh-hit-drop',\n  capabilities: () => ({ cost: 0, supports: ['NoData', 'TooNarrow'] }),\n  test: (state) => {\n    const current = state.hits\n    const history = state.history ?? []\n\n    // If no history, just check if we have any hits\n    if (history.length === 0) {\n      return current > 0\n        ? { pass: true }\n        : { pass: false, reason: 'no-hits-initial', data: { current, previous: null } }\n    }\n\n    // Check last hit count (history includes current query, so look at second-to-last)\n    const previous = history.length >= 2\n      ? history[history.length - 2]?.hits ?? 0\n      : history[history.length - 1]?.hits ?? 0\n\n    // If we had hits before but now have 0, that's a drop\n    if (previous > 0 && current === 0) {\n      return {\n        pass: false,\n        reason: 'hit-drop-to-zero',\n        data: { current, previous, dropPercent: 100 }\n      }\n    }\n\n    // If we had many hits and dropped by >80%, that's concerning\n    if (previous > 10 && current < previous * 0.2) {\n      const dropPercent = Math.round((1 - current / previous) * 100)\n      return {\n        pass: false,\n        reason: 'significant-hit-drop',\n        data: { current, previous, dropPercent }\n      }\n    }\n\n    // If hits are consistently 0, signal to broaden\n    const recentHits = history.slice(-3).map(h => h.hits)\n    if (recentHits.every(h => h === 0) && current === 0) {\n      return {\n        pass: false,\n        reason: 'stuck-at-zero',\n        data: { current, previous, recentHits }\n      }\n    }\n\n    return { pass: true, data: { current, previous } }\n  },\n\n  inspectState: stateInspector,\n}\n\nexport const entropyGuardProbe = EntropyProbe<GhState>(state => state.entropy, {\n  max: 0.85,\n  min: 0.15,\n  cost: 0.1,\n})\n","import type { Policy, Probe, StrategySelector } from '@/core/interfaces'\nimport type { FailureType } from '@/core/types'\n\nimport type { GhAction, GhState } from './env'\n\nconst failurePreferredPolicy: Record<FailureType, GhAction['type']> = {\n  Unknown: 'rephrase',\n  NoData: 'broaden',\n  TooNarrow: 'rephrase',\n  TooBroad: 'narrow',\n  AuthDenied: 'rephrase',\n  RateLimited: 'rephrase',\n  ToolMissing: 'rephrase',\n  Infeasible: 'rephrase',\n}\n\nexport class SearchFailureSelector\n  implements StrategySelector<GhState, GhAction>\n{\n  constructor(private readonly opts: { preferLlm?: boolean } = {}) { }\n\n  select(input: {\n    failure: FailureType\n    ladderLevel: number\n    budgetRemaining: number\n    probes: Probe<GhState>[]\n    policies: Policy<GhState, GhAction>[]\n  }): { probe: Probe<GhState>; policy: Policy<GhState, GhAction> } {\n    const { failure, ladderLevel, probes, policies } = input\n\n    const probe = pickProbe(probes, failure)\n    const policy = pickPolicy(policies, failure, ladderLevel, this.opts)\n\n    return { probe, policy }\n  }\n}\n\nfunction pickProbe(probes: Probe<GhState>[], failure: FailureType): Probe<GhState> {\n  const sorted = [...probes].sort(\n    (a, b) => (a.capabilities?.()?.cost ?? 0) - (b.capabilities?.()?.cost ?? 0),\n  )\n  return (\n    sorted.find(p => p.capabilities?.()?.supports?.includes(failure)) ?? sorted[0]\n  )\n}\n\nfunction pickPolicy(\n  policies: Policy<GhState, GhAction>[],\n  failure: FailureType,\n  ladderLevel: number,\n  opts: { preferLlm?: boolean },\n): Policy<GhState, GhAction> {\n  const inWindow = policies.filter(p => {\n    const [min, max] = p.capabilities?.()?.explorationRange ?? [0, Infinity]\n    return ladderLevel >= min && ladderLevel <= max\n  })\n  const viable = (inWindow.length ? inWindow : policies).sort(\n    (a, b) => (a.capabilities?.()?.cost?.step ?? 1) - (b.capabilities?.()?.cost?.step ?? 1),\n  )\n  const target = failurePreferredPolicy[failure] ?? 'rephrase'\n  if (opts.preferLlm && failure !== 'NoData') {\n    const llmPolicy = viable.find(p => /llm|agent/i.test(p.id))\n    if (llmPolicy) return llmPolicy\n  }\n  const handled = viable.filter(p => p.capabilities?.()?.handles?.includes(failure))\n  if (handled.length) return handled[0]\n  const matchingId = viable.find(p => p.id.includes(target))\n  if (matchingId) return matchingId\n  return viable[0]\n}\n"]}