@tangle-network/agent-runtime 0.105.0 → 0.106.0

package/dist/loop-runner-bin-BwjQ1NfH.js

@@ -0,0 +1,268 @@
+import { i as ConfigError } from "./errors-DEAvWQPy.js";
+import { M as runPersonified, d as worktreeFanout, j as definePersona } from "./runtime-BG0BziaP.js";
+import { t as runAnalystLoop } from "./analyst-loop-DGdtVENg.js";
+import { Dt as createExecutorRegistry } from "./supervise-BiRutHS9.js";
+import { t as createKbGate } from "./kb-gate-DpaSwXVx.js";
+//#region src/loop-runner.ts
+/**
+*
+* `runDelegatedLoop` — the configured delegated loop-runner.
+*
+* One typed entrypoint a worker agent (or a scheduled routine) calls to run a
+* disciplined loop in a chosen MODE, over agent-runtime's hardened engines:
+*
+*   code         → build-in-a-loop on the GENERIC recursive path (worktreeLoopRunner: author one
+*                  `AgentProfile` per harness → worktree-CLI leaves → `patchDelivered` gate)
+*   review       → caller-registered runner — a `code` runner with an approval gate over candidates
+*   research     → research-in-a-loop with valid-only KB growth (createKbGate)
+*   audit        → analyze trace/run data → findings (runAnalystLoop, caller-wired)
+*   self-improve → caller-registered `improve(profile, options)` run
+*
+* It is intentionally a thin façade: the value is that EVERY product reuses the
+* one hardened engine instead of forking delegation logic. The dispatcher owns
+* mode routing, timing, fail-loud on an unregistered mode, and a uniform result
+* shape; each mode's engine is a pre-configured runner in the registry (build it
+* with the factories below, or inject your own / a stub).
+*
+* @experimental
+*/
+/** All valid delegated-loop mode names — used for validation and CLI surfaces. @experimental */
+const DELEGATED_LOOP_MODES = [
+	"code",
+	"review",
+	"research",
+	"audit",
+	"self-improve"
+];
+/** Type guard — returns true when `value` is a valid `DelegatedLoopMode` string. @experimental */
+function isDelegatedLoopMode(value) {
+	return typeof value === "string" && DELEGATED_LOOP_MODES.includes(value);
+}
+/**
+*
+* Dispatch a configured loop by mode. Fails loud (throws `ConfigError`) when no
+* runner is registered for the mode — a routine pointed at an unwired mode is a
+* config bug, not a silent no-op. A runner that throws is captured as
+* `{ ok: false }` so unattended runs record the failure rather than crash.
+*
+* @experimental
+*/
+async function runDelegatedLoop(mode, registry, options = {}) {
+	const runner = registry[mode];
+	if (!runner) throw new ConfigError(`runDelegatedLoop: no runner registered for mode '${mode}' (registered: ${Object.keys(registry).join(", ") || "none"})`);
+	const now = options.now ?? Date.now;
+	const signal = options.signal ?? new AbortController().signal;
+	const start = now();
+	try {
+		return {
+			mode,
+			ok: true,
+			output: await runner(signal),
+			durationMs: now() - start
+		};
+	} catch (err) {
+		return {
+			mode,
+			ok: false,
+			error: err instanceof Error ? err.message : String(err),
+			durationMs: now() - start
+		};
+	}
+}
+/**
+*
+* `code` mode on the GENERIC recursive path: author one `AgentProfile` per harness, run them as a
+* `worktreeFanout` (N `createWorktreeCliExecutor` leaves, each `gateOnDeliverable`) through
+* `runPersonified` on the keystone Supervisor. The sandbox-session counterpart that drives the in-box
+* harness over a `SandboxClient` is `detachedSessionDelegate` (`./mcp/delegates`); here there is no
+* `runAgentRounds` driver, no role-coupled delegate — the harness list is the fanout, the gate is
+* `patchDelivered`,
+* the winner is the shared valid-only selector (NOT `defaultSelectWinner`, whose non-valid fallback
+* would surface an ungated patch). Equal-k holds by the conserved budget pool. Returns the winning
+* patch artifact, or throws when no candidate is delivered (fail loud, never a vacuous done).
+*
+* @experimental
+*/
+function worktreeLoopRunner(options) {
+	const shape = worktreeFanout({
+		repoRoot: options.repoRoot,
+		taskPrompt: options.taskPrompt,
+		harnesses: options.harnesses,
+		...options.testCmd !== void 0 ? { testCmd: options.testCmd } : {},
+		...options.typecheckCmd !== void 0 ? { typecheckCmd: options.typecheckCmd } : {},
+		...options.require !== void 0 ? { require: options.require } : {},
+		...options.maxDiffLines !== void 0 ? { maxDiffLines: options.maxDiffLines } : {},
+		...options.forbiddenPaths !== void 0 ? { forbiddenPaths: options.forbiddenPaths } : {},
+		...options.winnerStrategy !== void 0 ? { winnerStrategy: options.winnerStrategy } : {},
+		...options.runGit ? { runGit: options.runGit } : {},
+		...options.runHarness ? { runHarness: options.runHarness } : {},
+		...options.runCommand ? { runCommand: options.runCommand } : {}
+	});
+	const persona = definePersona({
+		name: "worktree-coder",
+		root: {
+			profile: { name: "worktree-coder" },
+			harness: null
+		},
+		directive: "deliver a minimal validated patch on a fresh worktree",
+		context: { role: "coder" },
+		executors: { registry: createExecutorRegistry() }
+	});
+	return async (signal) => {
+		const result = await runPersonified({
+			persona,
+			shape,
+			task: options.taskPrompt,
+			budget: options.budget,
+			signal
+		});
+		if (result.kind !== "winner" || result.out.kind !== "done") {
+			const blockers = result.kind === "winner" && result.out.kind === "blocked" ? result.out.blockers.join("; ") : `supervisor settled ${result.kind}`;
+			throw new Error(`worktreeLoopRunner: no delivered patch (${blockers})`);
+		}
+		return result.out.deliverable;
+	};
+}
+/**
+* `research` mode — research-in-a-loop with valid-only KB growth.
+*
+* Each round: research → gate every candidate (fail-closed; passage MUST be in
+* the source) → accept the clean ones → re-research the vetoed ones next round,
+* up to `maxRounds`. Vetoed facts in the final round are RETURNED (escalate,
+* never silently dropped) so the caller audits vs retries.
+*
+* @experimental
+*/
+function researchLoopRunner(o) {
+	const gate = createKbGate(o.gate);
+	const maxRounds = Math.max(1, Math.trunc(o.maxRounds ?? 1));
+	return async (signal) => {
+		const accepted = [];
+		let vetoed = [];
+		let rounds = 0;
+		for (let round = 0; round < maxRounds; round += 1) {
+			if (signal.aborted) break;
+			rounds += 1;
+			const candidates = await o.research(round, vetoed);
+			if (candidates.length === 0) break;
+			vetoed = [];
+			for (const c of candidates) {
+				const v = await gate(c);
+				if (v.accepted) accepted.push(c);
+				else vetoed.push({
+					candidate: c,
+					vetoedBy: v.vetoedBy,
+					reason: v.reason
+				});
+			}
+			if (vetoed.length === 0) break;
+		}
+		return {
+			accepted,
+			vetoed,
+			rounds
+		};
+	};
+}
+/**
+* `audit` mode — analyst loop over captured trace/run data.
+*
+* @experimental
+*/
+function auditLoopRunner(options) {
+	return async () => runAnalystLoop(options);
+}
+//#endregion
+//#region src/loop-runner-bin.ts
+/**
+*
+* `agent-runtime-loop` — the schedulable entrypoint for the configured
+* delegated loop-runner. A cron job / routine / Makefile target invokes:
+*
+*   agent-runtime-loop --mode research --config ./loops.config.js
+*
+* The config module wires the registry (with full access to env / creds —
+* which is why the deps live there, not in this generic bin). It must default-
+* export a `DelegatedLoopRegistry`, or a `() => DelegatedLoopRegistry | Promise<…>`.
+* The bin runs the selected mode, prints the `DelegatedLoopResult` as JSON, and
+* exits 0 on `ok`, 1 on a recorded failure, 2 on a usage/config error.
+*
+* @experimental
+*/
+/**
+*
+* Pure CLI core (no process / argv / IO) so it's unit-testable: validate the
+* mode, load the registry, dispatch, map to an exit code (0 ok / 1 failed /
+* 2 usage). Exported for embedding in custom runners + tests.
+*
+* @experimental
+*/
+async function runLoopRunnerCli(args) {
+	if (!isDelegatedLoopMode(args.mode)) return {
+		exitCode: 2,
+		error: `unknown mode '${args.mode}' (expected one of: ${DELEGATED_LOOP_MODES.join(", ")})`
+	};
+	let registry;
+	try {
+		registry = await args.loadRegistry();
+	} catch (err) {
+		return {
+			exitCode: 2,
+			error: `failed to load registry: ${errMsg(err)}`
+		};
+	}
+	if (!registry[args.mode]) return {
+		exitCode: 2,
+		error: `config registers no runner for mode '${args.mode}' (registered: ${Object.keys(registry).join(", ") || "none"})`
+	};
+	const result = await runDelegatedLoop(args.mode, registry, { ...args.now ? { now: args.now } : {} });
+	return {
+		exitCode: result.ok ? 0 : 1,
+		result
+	};
+}
+/** Parse `--mode X --config Y` from an argv tail (`process.argv.slice(2)`). */
+function parseLoopRunnerArgv(argv) {
+	const out = {};
+	for (let i = 0; i < argv.length; i += 1) {
+		const a = argv[i];
+		if (a === "--mode") out.mode = argv[++i];
+		else if (a === "--config") out.config = argv[++i];
+		else if (a?.startsWith("--mode=")) out.mode = a.slice(7);
+		else if (a?.startsWith("--config=")) out.config = a.slice(9);
+	}
+	return out;
+}
+/** Normalize a config module's default export → a registry. */
+function resolveRegistry(mod) {
+	const def = mod?.default ?? mod;
+	return typeof def === "function" ? def() : def;
+}
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/** The argv → IO → exit shell. Kept thin; logic lives in `runLoopRunnerCli`. */
+async function main() {
+	const { mode, config } = parseLoopRunnerArgv(process.argv.slice(2));
+	if (!mode || !config) {
+		process.stderr.write(`usage: agent-runtime-loop --mode <mode> --config <module>
+  modes: ${DELEGATED_LOOP_MODES.join(" | ")}\n  config: a JS/TS module default-exporting a DelegatedLoopRegistry (or a factory)
+`);
+		process.exit(2);
+	}
+	const { pathToFileURL } = await import("node:url");
+	const { resolve } = await import("node:path");
+	const cli = await runLoopRunnerCli({
+		mode,
+		loadRegistry: async () => resolveRegistry(await import(pathToFileURL(resolve(config)).href))
+	});
+	process.stdout.write(`${JSON.stringify(cli.result ?? { error: cli.error }, null, 2)}\n`);
+	if (cli.error) process.stderr.write(`${cli.error}\n`);
+	process.exit(cli.exitCode);
+}
+const invokedScript = typeof process !== "undefined" ? process.argv?.[1] : void 0;
+if (invokedScript && /loop-runner-bin\.(js|ts|mjs)$/.test(invokedScript)) main();
+//#endregion
+export { isDelegatedLoopMode as a, worktreeLoopRunner as c, auditLoopRunner as i, runLoopRunnerCli as n, researchLoopRunner as o, DELEGATED_LOOP_MODES as r, runDelegatedLoop as s, parseLoopRunnerArgv as t };
+
+//# sourceMappingURL=loop-runner-bin-BwjQ1NfH.js.map

package/dist/loop-runner-bin-BwjQ1NfH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-runner-bin-BwjQ1NfH.js","names":[],"sources":["../src/loop-runner.ts","../src/loop-runner-bin.ts"],"sourcesContent":["/**\n *\n * `runDelegatedLoop` — the configured delegated loop-runner.\n *\n * One typed entrypoint a worker agent (or a scheduled routine) calls to run a\n * disciplined loop in a chosen MODE, over agent-runtime's hardened engines:\n *\n *   code         → build-in-a-loop on the GENERIC recursive path (worktreeLoopRunner: author one\n *                  `AgentProfile` per harness → worktree-CLI leaves → `patchDelivered` gate)\n *   review       → caller-registered runner — a `code` runner with an approval gate over candidates\n *   research     → research-in-a-loop with valid-only KB growth (createKbGate)\n *   audit        → analyze trace/run data → findings (runAnalystLoop, caller-wired)\n *   self-improve → caller-registered `improve(profile, options)` run\n *\n * It is intentionally a thin façade: the value is that EVERY product reuses the\n * one hardened engine instead of forking delegation logic. The dispatcher owns\n * mode routing, timing, fail-loud on an unregistered mode, and a uniform result\n * shape; each mode's engine is a pre-configured runner in the registry (build it\n * with the factories below, or inject your own / a stub).\n *\n * @experimental\n */\n\nimport { runAnalystLoop } from './analyst-loop'\nimport type { RunAnalystLoopOpts, RunAnalystLoopResult } from './analyst-loop/types'\nimport { ConfigError } from './errors'\nimport { type CreateKbGateOptions, createKbGate, type FactCandidate } from './mcp/kb-gate'\nimport {\n  type AuthoredHarness,\n  type Budget,\n  createExecutorRegistry,\n  definePersona,\n  runPersonified,\n  type WinnerStrategy,\n  type WorktreeFanoutOptions,\n  type WorktreePatchArtifact,\n  worktreeFanout,\n} from './runtime'\n\n/** All valid delegated-loop mode names — used for validation and CLI surfaces. @experimental */\nexport const DELEGATED_LOOP_MODES = ['code', 'review', 'research', 'audit', 'self-improve'] as const\n\n/** @experimental */\nexport type DelegatedLoopMode = (typeof DELEGATED_LOOP_MODES)[number]\n\n/** Type guard — returns true when `value` is a valid `DelegatedLoopMode` string. @experimental */\nexport function isDelegatedLoopMode(value: unknown): value is DelegatedLoopMode {\n  return typeof value === 'string' && (DELEGATED_LOOP_MODES as readonly string[]).includes(value)\n}\n\n/** @experimental A pre-configured loop for one mode. Returns the mode's raw\n *  output; the dispatcher wraps it in a {@link DelegatedLoopResult}. */\nexport type DelegatedLoopRunner<T = unknown> = (signal: AbortSignal) => Promise<T>\n\n/** @experimental Mode → configured runner. Partial: only register the modes a\n *  given product/routine actually uses. */\nexport type DelegatedLoopRegistry = Partial<Record<DelegatedLoopMode, DelegatedLoopRunner>>\n\n/** @experimental Uniform result — never throws from a registered runner; a\n *  thrown engine becomes `{ ok: false, error }` so a routine can record + move on. */\nexport interface DelegatedLoopResult<T = unknown> {\n  mode: DelegatedLoopMode\n  ok: boolean\n  output?: T\n  error?: string\n  durationMs: number\n}\n\n/** @experimental */\nexport interface RunDelegatedLoopOptions {\n  signal?: AbortSignal\n  /** Clock override for deterministic tests. */\n  now?: () => number\n}\n\n/**\n *\n * Dispatch a configured loop by mode. Fails loud (throws `ConfigError`) when no\n * runner is registered for the mode — a routine pointed at an unwired mode is a\n * config bug, not a silent no-op. A runner that throws is captured as\n * `{ ok: false }` so unattended runs record the failure rather than crash.\n *\n * @experimental\n */\nexport async function runDelegatedLoop<T = unknown>(\n  mode: DelegatedLoopMode,\n  registry: DelegatedLoopRegistry,\n  options: RunDelegatedLoopOptions = {},\n): Promise<DelegatedLoopResult<T>> {\n  const runner = registry[mode] as DelegatedLoopRunner<T> | undefined\n  if (!runner) {\n    throw new ConfigError(\n      `runDelegatedLoop: no runner registered for mode '${mode}' (registered: ${\n        Object.keys(registry).join(', ') || 'none'\n      })`,\n    )\n  }\n  const now = options.now ?? Date.now\n  const signal = options.signal ?? new AbortController().signal\n  const start = now()\n  try {\n    const output = await runner(signal)\n    return { mode, ok: true, output, durationMs: now() - start }\n  } catch (err) {\n    return {\n      mode,\n      ok: false,\n      error: err instanceof Error ? err.message : String(err),\n      durationMs: now() - start,\n    }\n  }\n}\n\n/** @experimental Options for the local-repo `code` runner over the GENERIC recursive path. */\nexport interface WorktreeLoopRunnerOptions {\n  /** Absolute path to the local git checkout each worktree is cut from. */\n  repoRoot: string\n  /** The instruction handed to every authored harness (composed under each profile's systemPrompt). */\n  taskPrompt: string\n  /** The supervisor-authored harness profiles — one fanout item (one worktree-CLI leaf) each. */\n  harnesses: ReadonlyArray<AuthoredHarness>\n  /** Conserved budget pool bounding the fanout (equal-k holds by construction). */\n  budget: Budget\n  /** Shell command run in each worktree to derive the tests-PASS signal. */\n  testCmd?: string\n  /** Shell command run in each worktree to derive the typecheck-PASS signal. */\n  typecheckCmd?: string\n  /** Which verification signals the deliverable REQUIRES present-and-passing (default none). */\n  require?: ReadonlyArray<'tests' | 'typecheck'>\n  /** Diff-size cap (lines). */\n  maxDiffLines?: number\n  /** Literal path prefixes the patch must not touch (the secret-floor is always on regardless). */\n  forbiddenPaths?: string[]\n  /** Winner-selection strategy among gated candidates. Default `highest-score`. */\n  winnerStrategy?: WinnerStrategy\n  /** Test seams forwarded to the worktree-CLI leaves so the runner drives offline. */\n  runGit?: WorktreeFanoutOptions['runGit']\n  runHarness?: WorktreeFanoutOptions['runHarness']\n  runCommand?: WorktreeFanoutOptions['runCommand']\n}\n\n/**\n *\n * `code` mode on the GENERIC recursive path: author one `AgentProfile` per harness, run them as a\n * `worktreeFanout` (N `createWorktreeCliExecutor` leaves, each `gateOnDeliverable`) through\n * `runPersonified` on the keystone Supervisor. The sandbox-session counterpart that drives the in-box\n * harness over a `SandboxClient` is `detachedSessionDelegate` (`./mcp/delegates`); here there is no\n * `runAgentRounds` driver, no role-coupled delegate — the harness list is the fanout, the gate is\n * `patchDelivered`,\n * the winner is the shared valid-only selector (NOT `defaultSelectWinner`, whose non-valid fallback\n * would surface an ungated patch). Equal-k holds by the conserved budget pool. Returns the winning\n * patch artifact, or throws when no candidate is delivered (fail loud, never a vacuous done).\n *\n * @experimental\n */\nexport function worktreeLoopRunner(\n  options: WorktreeLoopRunnerOptions,\n): DelegatedLoopRunner<WorktreePatchArtifact> {\n  const shape = worktreeFanout<string>({\n    repoRoot: options.repoRoot,\n    taskPrompt: options.taskPrompt,\n    harnesses: options.harnesses,\n    ...(options.testCmd !== undefined ? { testCmd: options.testCmd } : {}),\n    ...(options.typecheckCmd !== undefined ? { typecheckCmd: options.typecheckCmd } : {}),\n    ...(options.require !== undefined ? { require: options.require } : {}),\n    ...(options.maxDiffLines !== undefined ? { maxDiffLines: options.maxDiffLines } : {}),\n    ...(options.forbiddenPaths !== undefined ? { forbiddenPaths: options.forbiddenPaths } : {}),\n    ...(options.winnerStrategy !== undefined ? { winnerStrategy: options.winnerStrategy } : {}),\n    ...(options.runGit ? { runGit: options.runGit } : {}),\n    ...(options.runHarness ? { runHarness: options.runHarness } : {}),\n    ...(options.runCommand ? { runCommand: options.runCommand } : {}),\n  })\n  // The persona's only role here is to carry the fanout shape onto the Supervisor; each item's\n  // executor is BYO (the gated worktree-CLI leaf), so the registry only needs to pass BYO through.\n  const persona = definePersona<WorktreePatchArtifact>({\n    name: 'worktree-coder',\n    root: { profile: { name: 'worktree-coder' }, harness: null },\n    directive: 'deliver a minimal validated patch on a fresh worktree',\n    context: { role: 'coder' },\n    executors: { registry: createExecutorRegistry() },\n  })\n  return async (signal) => {\n    const result = await runPersonified<string, WorktreePatchArtifact>({\n      persona,\n      shape,\n      task: options.taskPrompt,\n      budget: options.budget,\n      signal,\n    })\n    if (result.kind !== 'winner' || result.out.kind !== 'done') {\n      const blockers =\n        result.kind === 'winner' && result.out.kind === 'blocked'\n          ? result.out.blockers.join('; ')\n          : `supervisor settled ${result.kind}`\n      throw new Error(`worktreeLoopRunner: no delivered patch (${blockers})`)\n    }\n    return result.out.deliverable\n  }\n}\n\n/** @experimental A fact rejected at the KB gate — surfaced, never dropped. */\nexport interface VetoedFact {\n  candidate: FactCandidate\n  vetoedBy?: string\n  reason?: string\n}\n\n/** @experimental */\nexport interface ResearchLoopResult {\n  /** Facts that passed the fail-closed gate — safe to write to the KB. */\n  accepted: FactCandidate[]\n  /** Facts the gate vetoed in the final round — escalate, do not silently drop. */\n  vetoed: VetoedFact[]\n  /** Research rounds actually run. */\n  rounds: number\n}\n\n/** @experimental Options for the default `research` runner. */\nexport interface ResearchLoopRunnerOptions {\n  /**\n   * The research engine (the consumer's web/doc searcher + extractor). Called\n   * each round with the prior round's vetoes so it can re-research the gaps.\n   * Returns fact candidates carrying their grounding (`verbatimPassage` +\n   * `sourceText`).\n   */\n  research: (round: number, vetoed: VetoedFact[]) => Promise<FactCandidate[]>\n  /** Gate config (extra judges, self-artifact kinds, …). The floor is always on. */\n  gate?: CreateKbGateOptions\n  /** Max research rounds (correct-on-veto remediation). Default 1. */\n  maxRounds?: number\n}\n\n/**\n * `research` mode — research-in-a-loop with valid-only KB growth.\n *\n * Each round: research → gate every candidate (fail-closed; passage MUST be in\n * the source) → accept the clean ones → re-research the vetoed ones next round,\n * up to `maxRounds`. Vetoed facts in the final round are RETURNED (escalate,\n * never silently dropped) so the caller audits vs retries.\n *\n * @experimental\n */\nexport function researchLoopRunner(\n  o: ResearchLoopRunnerOptions,\n): DelegatedLoopRunner<ResearchLoopResult> {\n  const gate = createKbGate(o.gate)\n  const maxRounds = Math.max(1, Math.trunc(o.maxRounds ?? 1))\n  return async (signal) => {\n    const accepted: FactCandidate[] = []\n    let vetoed: VetoedFact[] = []\n    let rounds = 0\n    for (let round = 0; round < maxRounds; round += 1) {\n      if (signal.aborted) break\n      rounds += 1\n      const candidates = await o.research(round, vetoed)\n      if (candidates.length === 0) break\n      vetoed = []\n      for (const c of candidates) {\n        const v = await gate(c)\n        if (v.accepted) accepted.push(c)\n        else vetoed.push({ candidate: c, vetoedBy: v.vetoedBy, reason: v.reason })\n      }\n      if (vetoed.length === 0) break\n    }\n    return { accepted, vetoed, rounds }\n  }\n}\n\n/**\n * `audit` mode — analyst loop over captured trace/run data.\n *\n * @experimental\n */\nexport function auditLoopRunner<TProposal = unknown, TEdit = unknown>(\n  options: RunAnalystLoopOpts,\n): DelegatedLoopRunner<RunAnalystLoopResult<TProposal, TEdit>> {\n  return async () => runAnalystLoop<TProposal, TEdit>(options)\n}\n","#!/usr/bin/env node\n/**\n *\n * `agent-runtime-loop` — the schedulable entrypoint for the configured\n * delegated loop-runner. A cron job / routine / Makefile target invokes:\n *\n *   agent-runtime-loop --mode research --config ./loops.config.js\n *\n * The config module wires the registry (with full access to env / creds —\n * which is why the deps live there, not in this generic bin). It must default-\n * export a `DelegatedLoopRegistry`, or a `() => DelegatedLoopRegistry | Promise<…>`.\n * The bin runs the selected mode, prints the `DelegatedLoopResult` as JSON, and\n * exits 0 on `ok`, 1 on a recorded failure, 2 on a usage/config error.\n *\n * @experimental\n */\n\nimport {\n  DELEGATED_LOOP_MODES,\n  type DelegatedLoopMode,\n  type DelegatedLoopRegistry,\n  type DelegatedLoopResult,\n  isDelegatedLoopMode,\n  runDelegatedLoop,\n} from './loop-runner'\n\n/** @experimental Parsed CLI invocation. */\nexport interface LoopRunnerCliArgs {\n  mode: string\n  /** Loads the registry — the bin wires this from `--config`; tests inject a stub. */\n  loadRegistry: () => Promise<DelegatedLoopRegistry> | DelegatedLoopRegistry\n  now?: () => number\n}\n\n/** @experimental */\nexport interface LoopRunnerCliResult {\n  exitCode: number\n  result?: DelegatedLoopResult\n  error?: string\n}\n\n/**\n *\n * Pure CLI core (no process / argv / IO) so it's unit-testable: validate the\n * mode, load the registry, dispatch, map to an exit code (0 ok / 1 failed /\n * 2 usage). Exported for embedding in custom runners + tests.\n *\n * @experimental\n */\nexport async function runLoopRunnerCli(args: LoopRunnerCliArgs): Promise<LoopRunnerCliResult> {\n  if (!isDelegatedLoopMode(args.mode)) {\n    return {\n      exitCode: 2,\n      error: `unknown mode '${args.mode}' (expected one of: ${DELEGATED_LOOP_MODES.join(', ')})`,\n    }\n  }\n  let registry: DelegatedLoopRegistry\n  try {\n    registry = await args.loadRegistry()\n  } catch (err) {\n    return { exitCode: 2, error: `failed to load registry: ${errMsg(err)}` }\n  }\n  if (!registry[args.mode]) {\n    return {\n      exitCode: 2,\n      error: `config registers no runner for mode '${args.mode}' (registered: ${\n        Object.keys(registry).join(', ') || 'none'\n      })`,\n    }\n  }\n  // runDelegatedLoop throws only on a missing runner (guarded above); a failing\n  // engine is captured as { ok: false } → exit 1, not a crash.\n  const result = await runDelegatedLoop(args.mode as DelegatedLoopMode, registry, {\n    ...(args.now ? { now: args.now } : {}),\n  })\n  return { exitCode: result.ok ? 0 : 1, result }\n}\n\n/** Parse `--mode X --config Y` from an argv tail (`process.argv.slice(2)`). */\nexport function parseLoopRunnerArgv(argv: string[]): { mode?: string; config?: string } {\n  const out: { mode?: string; config?: string } = {}\n  for (let i = 0; i < argv.length; i += 1) {\n    const a = argv[i]\n    if (a === '--mode') out.mode = argv[++i]\n    else if (a === '--config') out.config = argv[++i]\n    else if (a?.startsWith('--mode=')) out.mode = a.slice('--mode='.length)\n    else if (a?.startsWith('--config=')) out.config = a.slice('--config='.length)\n  }\n  return out\n}\n\n/** Normalize a config module's default export → a registry. */\nfunction resolveRegistry(mod: unknown): DelegatedLoopRegistry {\n  const def = (mod as { default?: unknown })?.default ?? mod\n  const value = typeof def === 'function' ? (def as () => unknown)() : def\n  return value as DelegatedLoopRegistry\n}\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err)\n}\n\n/** The argv → IO → exit shell. Kept thin; logic lives in `runLoopRunnerCli`. */\nasync function main(): Promise<void> {\n  const { mode, config } = parseLoopRunnerArgv(process.argv.slice(2))\n  if (!mode || !config) {\n    process.stderr.write(\n      'usage: agent-runtime-loop --mode <mode> --config <module>\\n' +\n        `  modes: ${DELEGATED_LOOP_MODES.join(' | ')}\\n` +\n        '  config: a JS/TS module default-exporting a DelegatedLoopRegistry (or a factory)\\n',\n    )\n    process.exit(2)\n  }\n  const { pathToFileURL } = await import('node:url')\n  const { resolve } = await import('node:path')\n  const cli = await runLoopRunnerCli({\n    mode,\n    loadRegistry: async () => resolveRegistry(await import(pathToFileURL(resolve(config)).href)),\n  })\n  process.stdout.write(`${JSON.stringify(cli.result ?? { error: cli.error }, null, 2)}\\n`)\n  if (cli.error) process.stderr.write(`${cli.error}\\n`)\n  process.exit(cli.exitCode)\n}\n\n// Run only when executed as the bin — never when imported for the testable\n// core, and never when bundled into a runtime that has no `process.argv`\n// (e.g. Cloudflare Workers, where `process` is a shim without `argv`). Reading\n// `process.argv[1]` directly would throw at module load there; `process.argv?.`\n// keeps the guard a no-op instead of crashing the Worker on startup.\nconst invokedScript = typeof process !== 'undefined' ? process.argv?.[1] : undefined\nif (invokedScript && /loop-runner-bin\\.(js|ts|mjs)$/.test(invokedScript)) {\n  void main()\n}\n"],"mappings":"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"}

package/dist/loop-runner-bin.d.ts

@@ -1,15 +1,2 @@
-#!/usr/bin/env node
-export { L as LoopRunnerCliArgs, e as LoopRunnerCliResult, p as parseLoopRunnerArgv, k as runLoopRunnerCli } from './loop-runner-bin-68aoM9-7.js';
-import './types-CmYCMbFT.js';
-import '@tangle-network/agent-eval';
-import './kb-gate-CwHO0vz6.js';
-import './types-CvNwMzQt.js';
-import '@tangle-network/agent-interface';
-import '@tangle-network/sandbox';
-import './types-BCoemcXU.js';
-import './types-BwoZWq-i.js';
-import './worktree-fanout-DxhAWr5Z.js';
-import './completion-gate-BMy5LGoP.js';
-import '@tangle-network/agent-profile-materialize';
-import './local-harness-BDNcl6jI.js';
-import 'node:child_process';
+import { i as runLoopRunnerCli, n as LoopRunnerCliResult, r as parseLoopRunnerArgv, t as LoopRunnerCliArgs } from "./loop-runner-bin-BXsFEUcf.js";
+export { LoopRunnerCliArgs, LoopRunnerCliResult, parseLoopRunnerArgv, runLoopRunnerCli };

package/dist/loop-runner-bin.js

@@ -1,25 +1,3 @@
 #!/usr/bin/env node
-import {
-  parseLoopRunnerArgv,
-  runLoopRunnerCli
-} from "./chunk-HNP72PNU.js";
-import "./chunk-SGKPNBXE.js";
-import "./chunk-WRTOVNN4.js";
-import "./chunk-Q2JSAVQ3.js";
-import "./chunk-XBG2W2VW.js";
-import "./chunk-DPEUKJRO.js";
-import "./chunk-YJZA2BIK.js";
-import "./chunk-UPWGXKXB.js";
-import "./chunk-2VZYRB55.js";
-import "./chunk-HLKC4UYB.js";
-import "./chunk-ISPWRSEC.js";
-import "./chunk-KRBFHMV6.js";
-import "./chunk-3MDZX7YU.js";
-import "./chunk-FD2MBMOH.js";
-import "./chunk-M22PL4GH.js";
-import "./chunk-YEJR7IXO.js";
-export {
-  parseLoopRunnerArgv,
-  runLoopRunnerCli
-};
-//# sourceMappingURL=loop-runner-bin.js.map
+import { n as runLoopRunnerCli, t as parseLoopRunnerArgv } from "./loop-runner-bin-BwjQ1NfH.js";
+export { parseLoopRunnerArgv, runLoopRunnerCli };