@glrs-dev/cli 2.4.0 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @glrs-dev/cli
 
+## 2.6.0
+
+### Minor Changes
+
+- [#79](https://github.com/iceglober/glrs/pull/79) [`3d19166`](https://github.com/iceglober/glrs/commit/3d1916633ff6796238f08616c88038fd5b734174) Thanks [@iceglober](https://github.com/iceglober)! - Refactor harness subagent prompts for consistency and register `glrs loop` CLI subcommand.
+
+  **Harness prompt refactor:**
+
+  - Remove inline SPEAR protocol from prime.md (41% reduction); spear-protocol skill is now the sole canonical source
+  - Consolidate three identical reviewer permission blocks into one shared `REVIEWER_PERMISSIONS` constant
+  - Remove UI evaluation ladder from plan-reviewer and gap-analyzer (neither verifies web UI)
+  - Remove repo-specific assumptions from docs-maintainer prompt
+  - Fix broken bash snippet reference in scoper.md (was a placeholder, now the actual snippet)
+  - Fix circular self-reference in plan.md defensive posture section
+  - Standardize question-tool phrasing across all utility agents
+  - Clean up research.md self-reference and redundant invocation docs
+  - Update test assertions to match refactored content
+
+  **CLI:**
+
+  - Register `glrs loop` as a top-level subcommand (was defined but never routed)
+  - Add `glrs autopilot` and `glrs loop` to help text
+
+## 2.5.0
+
+### Patch Changes
+
+- [#77](https://github.com/iceglober/glrs/pull/77) [`d684392`](https://github.com/iceglober/glrs/commit/d68439287a0a4bd9496011232e3e81d72bbda398) Thanks [@iceglober](https://github.com/iceglober)! - Fix phase cost summaries showing $0.00 by returning cumulativeCostUsd from all runRalphLoop exit paths. Route `glrs autopilot` through cmd-ts so --plan, --fast, and other flags are parsed.
+
+- Updated dependencies [[`d684392`](https://github.com/iceglober/glrs/commit/d68439287a0a4bd9496011232e3e81d72bbda398)]:
+  - @glrs-dev/autopilot@0.1.1
+  - @glrs-dev/adapter-claude-code@0.1.1
+  - @glrs-dev/adapter-opencode@0.1.1
+
+## 2.4.1
+
+### Patch Changes
+
+- [#75](https://github.com/iceglober/glrs/pull/75) [`9532a63`](https://github.com/iceglober/glrs/commit/9532a63157cc0edad7822452e710848052dde9fa) Thanks [@iceglober](https://github.com/iceglober)! - Fix `@glrs-dev/cli@2.4.0` install failure caused by `workspace:*` references to private packages leaking into the published tarball. The cli now vendors `@glrs-dev/autopilot` and `@glrs-dev/adapter-opencode` into its `dist/node_modules/` and strips workspace references from the published `package.json`.
+
 ## 2.4.0
 
 ## 2.3.0

package/dist/{chunk-HQUCVJ4G.js → chunk-FBXSGZAA.js}

@@ -52,6 +52,8 @@ USAGE
 SUBCOMMANDS
   oc         OpenCode agent harness (install, pilot, etc.)
   wt         Worktree management (create, list, switch, delete, cleanup)
+  autopilot  Run the autopilot orchestrator (scope \u2192 plan \u2192 execute)
+  loop       Run the Ralph loop with a raw prompt
   dashboard  Live TUI dashboard for all running autopilot sessions
 
 Run 'glrs <subcommand> --help' for per-command help.
@@ -61,6 +63,8 @@ EXAMPLES
   glrs wt new
   glrs wt list
   glrs wt switch
+  glrs autopilot --plan docs/plans/my-plan/
+  glrs loop "implement the auth middleware"
   glrs dashboard
 
 REQUIREMENTS

package/dist/chunk-J3FXSHMA.js

@@ -0,0 +1,263 @@
+// src/adapter-factory.ts
+import { resolveModel } from "@glrs-dev/autopilot";
+var ADAPTER_NAMES = ["opencode", "claude-code-cli"];
+var DEFAULT_ADAPTER = "opencode";
+async function createAdapter(name, config) {
+  const resolvedConfig = config || {
+    adapter: "opencode",
+    models: {
+      enrichment: "deep",
+      execution: "autopilot-execute",
+      debrief: "deep"
+    },
+    agents: {},
+    enrichment: {},
+    execution: {},
+    hooks: {},
+    phases: {},
+    adapters: {
+      opencode: { agents: {} },
+      claude_code_cli: { skip_permissions: true, allowed_tools: [] }
+    }
+  };
+  const adapter = resolvedConfig.adapter || "opencode";
+  switch (adapter) {
+    case "opencode": {
+      const { OpenCodeAdapter } = await import("@glrs-dev/adapter-opencode");
+      return new OpenCodeAdapter();
+    }
+    case "claude-code-cli": {
+      const { ClaudeCodeCliAdapter } = await import("@glrs-dev/adapter-claude-code");
+      const cliConfig = resolvedConfig.adapters?.claude_code_cli || {};
+      return new ClaudeCodeCliAdapter({
+        dangerouslySkipPermissions: cliConfig.skip_permissions ?? true,
+        models: {
+          enrich: resolveModel(resolvedConfig.models?.enrichment || "deep", "claude-code-cli"),
+          execute: resolveModel(resolvedConfig.models?.execution || "autopilot-execute", "claude-code-cli")
+        },
+        ...cliConfig.allowed_tools ? { allowedTools: cliConfig.allowed_tools } : {},
+        ...cliConfig.max_turns != null ? { maxTurns: cliConfig.max_turns } : {}
+      });
+    }
+    default:
+      throw new Error(
+        `Unknown adapter: ${adapter}. Available: ${ADAPTER_NAMES.join(", ")}`
+      );
+  }
+}
+
+// src/autopilot/config-reader.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+
+// src/autopilot/autopilot-config.ts
+var DEFAULT_AUTOPILOT_CONFIG = {
+  /** Default to OpenCode adapter. */
+  adapter: "opencode",
+  /** Default models — OpenCode tier names (interpreted by OpenCode adapter). */
+  models: {
+    enrichment: "deep",
+    execution: "autopilot-execute",
+    debrief: "deep"
+  },
+  /** No global agent overrides by default. */
+  agents: {},
+  /** No enrichment phase config by default. */
+  enrichment: {},
+  /** No execution phase config by default. */
+  execution: {},
+  /** No hooks by default. */
+  hooks: {},
+  /** No phase-specific config by default. */
+  phases: {},
+  /** No webhook notification by default. */
+  notify_url: void 0,
+  notify_events: void 0,
+  /** Default to TDD execution style. */
+  execution_style: "tdd",
+  /** Adapter-specific defaults for both adapters. */
+  adapters: {
+    /** OpenCode adapter — no agent overrides by default. */
+    opencode: {
+      agents: {}
+    },
+    /** Claude Code CLI adapter — skip permissions, allow all tools by default. */
+    claude_code_cli: {
+      skip_permissions: true,
+      allowed_tools: []
+    }
+  }
+};
+
+// src/autopilot/config-reader.ts
+var ConfigPath = ".glrs/autopilot.yaml";
+var AgentOverrideSchema = z.record(z.string(), z.unknown());
+var PhaseConfigSchema = z.record(z.string(), z.unknown());
+var ModelsSchema = z.object({
+  enrichment: z.string().optional(),
+  execution: z.string().optional(),
+  debrief: z.string().optional()
+}).strict();
+var OpencodeAdapterSchema = z.object({
+  agents: z.record(z.string(), AgentOverrideSchema).optional()
+}).strict();
+var ClaudeCodeCliAdapterSchema = z.object({
+  skip_permissions: z.boolean().optional(),
+  allowed_tools: z.array(z.string()).optional()
+}).strict();
+var AdaptersSchema = z.object({
+  opencode: OpencodeAdapterSchema.optional(),
+  claude_code_cli: ClaudeCodeCliAdapterSchema.optional()
+}).strict();
+var WebhookEventTypeSchema = z.enum([
+  "iteration_complete",
+  "phase_complete",
+  "run_complete",
+  "error",
+  "struggle",
+  "stall"
+]);
+var AutopilotConfigSchema = z.object({
+  adapter: z.enum(["opencode", "claude-code-cli"]).optional(),
+  models: ModelsSchema.optional(),
+  agents: z.record(z.string(), AgentOverrideSchema).optional(),
+  enrichment: z.record(z.string(), z.unknown()).optional(),
+  execution: z.record(z.string(), z.unknown()).optional(),
+  hooks: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+  phases: z.record(z.string(), PhaseConfigSchema).optional(),
+  notify_url: z.string().optional(),
+  notify_events: z.array(WebhookEventTypeSchema).optional(),
+  adapters: AdaptersSchema.optional()
+}).strict().transform((val) => val);
+function readAutopilotConfig(repoRoot) {
+  const configPath = path.join(repoRoot, ConfigPath);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  let fileContent;
+  try {
+    fileContent = fs.readFileSync(configPath, "utf8");
+  } catch (err) {
+    throw new Error(`Failed to read ${ConfigPath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(fileContent);
+  } catch (err) {
+    throw new Error(`Failed to parse ${ConfigPath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  try {
+    return AutopilotConfigSchema.parse(parsed);
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      const unknownFields = err.issues.filter((issue) => issue.code === "unrecognized_keys").flatMap((issue) => issue.keys ? issue.keys : []);
+      if (unknownFields.length > 0) {
+        const fieldList = unknownFields.map((field) => `"${field}"`).join(", ");
+        throw new Error(`Invalid ${ConfigPath}: unknown keys: ${fieldList}`);
+      }
+      const messages = err.issues.map((issue) => {
+        const pathStr = issue.path.join(".");
+        return `${pathStr || "root"}: ${issue.message}`;
+      });
+      throw new Error(`Invalid ${ConfigPath}:
+${messages.join("\n")}`);
+    }
+    throw err;
+  }
+}
+function derivePlanSlug(planPath) {
+  if (!planPath || planPath === ".") {
+    return "";
+  }
+  const normalized = planPath.replace(/\/$/, "");
+  const basename2 = path.basename(normalized);
+  if (basename2.endsWith(".md")) {
+    return basename2.slice(0, -3);
+  }
+  return basename2;
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+      continue;
+    }
+    for (const key in obj) {
+      const srcValue = obj[key];
+      if (srcValue && typeof srcValue === "object" && !Array.isArray(srcValue) && !(srcValue instanceof Date)) {
+        const targetValue = result[key];
+        if (targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && !(targetValue instanceof Date)) {
+          result[key] = deepMerge(
+            targetValue,
+            srcValue
+          );
+        } else {
+          result[key] = srcValue;
+        }
+      } else {
+        result[key] = srcValue;
+      }
+    }
+  }
+  return result;
+}
+function resolveConfig(repoRoot, planPath = ".") {
+  const projectConfig = readAutopilotConfig(repoRoot) ?? {};
+  const slug = derivePlanSlug(planPath);
+  let planConfig = {};
+  if (slug) {
+    const planConfigPath = path.join(repoRoot, ".glrs", "plans", slug, "autopilot.yaml");
+    if (fs.existsSync(planConfigPath)) {
+      let fileContent;
+      try {
+        fileContent = fs.readFileSync(planConfigPath, "utf8");
+      } catch (err) {
+        throw new Error(`Failed to read plan config at ${planConfigPath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      let parsed;
+      try {
+        parsed = parseYaml(fileContent);
+      } catch (err) {
+        throw new Error(`Failed to parse plan config at ${planConfigPath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (parsed !== null && parsed !== void 0) {
+        try {
+          planConfig = AutopilotConfigSchema.parse(parsed);
+        } catch (err) {
+          if (err instanceof z.ZodError) {
+            const unknownFields = err.issues.filter((issue) => issue.code === "unrecognized_keys").flatMap((issue) => issue.keys ? issue.keys : []);
+            if (unknownFields.length > 0) {
+              const fieldList = unknownFields.map((field) => `"${field}"`).join(", ");
+              throw new Error(`Invalid plan config at ${planConfigPath}: unknown keys: ${fieldList}`);
+            }
+            const messages = err.issues.map((issue) => {
+              const pathStr = issue.path.join(".");
+              return `${pathStr || "root"}: ${issue.message}`;
+            });
+            throw new Error(`Invalid plan config at ${planConfigPath}:
+${messages.join("\n")}`);
+          }
+          throw err;
+        }
+      }
+    }
+  }
+  const merged = deepMerge(
+    DEFAULT_AUTOPILOT_CONFIG,
+    projectConfig,
+    planConfig
+  );
+  return merged;
+}
+
+export {
+  ADAPTER_NAMES,
+  DEFAULT_ADAPTER,
+  createAdapter,
+  resolveConfig
+};

package/dist/{chunk-5ZVUFNCP.js → chunk-S6N5E2GG.js}

@@ -1,4 +1,5 @@
 // src/commands/debrief.ts
+import { resolveModel } from "@glrs-dev/autopilot/src/model-resolver.js";
 function shouldRunDebrief(opts) {
   if (opts.noDebrief) return false;
   const envVal = opts.env["GLRS_AUTOPILOT_DEBRIEF"];
@@ -112,8 +113,14 @@ async function runDebrief(opts) {
   try {
     const gitDiffStat = await _execGitDiffStat(opts.cwd).catch(() => "(git diff unavailable)");
     const contextMessage = buildContextMessage(opts.loopResult, opts.prompt, gitDiffStat);
+    const adapterName = adapter.name;
+    const cfgObj = opts.config;
+    const models = cfgObj?.models;
+    const debriefSpecifier = models?.debrief;
+    const debriefModel = debriefSpecifier ? resolveModel(debriefSpecifier, adapterName) : void 0;
     const sessionId = await adapter.createSession(handle, {
-      agentName: "debriefer"
+      agentName: "debriefer",
+      model: debriefModel
     });
     await adapter.sendAndWait(handle, {
       sessionId,

package/dist/{chunk-2VMFXAJH.js → chunk-UO7WHIKY.js}

@@ -1,3 +1,8 @@
+import {
+  DEFAULT_ADAPTER,
+  createAdapter,
+  resolveConfig
+} from "./chunk-J3FXSHMA.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -456,14 +461,19 @@ function LogRow({ entry, maxWidth }) {
 }
 function applyEvent(prev, event) {
   switch (event.type) {
-    case "session:start":
+    case "session:start": {
+      const adapterLabel = event.adapter ?? "opencode";
+      const branchLabel = event.branch ?? "unknown";
+      const logs = appendLog(prev.logEntries, `${event.cwd} \xB7 ${branchLabel} \xB7 ${adapterLabel}`);
+      const logs2 = appendLog(logs, `enrich: ${event.enrichModel ?? "unknown"} \xB7 execute: ${event.executeModel ?? "unknown"}`);
       return {
         ...prev,
         planPath: event.planPath,
         startedAt: Date.now(),
         executionMode: event.fast ? "fast" : "deep",
-        logEntries: appendLog(prev.logEntries, `session started (enrich: ${event.enrichModel ?? "prime"} \xB7 execute: ${event.executeModel ?? "build"})`)
+        logEntries: logs2
       };
+    }
     case "enrich:start":
       return {
         ...prev,
@@ -728,8 +738,7 @@ function applyEvent(prev, event) {
 
 // src/commands/autopilot-tui.ts
 import { SessionRunner } from "@glrs-dev/autopilot";
-import { OpenCodeAdapter } from "@glrs-dev/adapter-opencode";
-async function runAutopilot() {
+async function runAutopilot(adapterName) {
   const cwd = process.cwd();
   if (!process.stderr.isTTY) {
     process.stderr.write("glrs autopilot requires a TTY.\n");
@@ -739,7 +748,11 @@ async function runAutopilot() {
   if (!planPath) {
     return;
   }
-  const adapter = new OpenCodeAdapter();
+  const config = resolveConfig(cwd, planPath);
+  if (adapterName) {
+    config.adapter = adapterName;
+  }
+  const adapter = await createAdapter(config.adapter ?? DEFAULT_ADAPTER, config);
   const runner = new SessionRunner({
     planPath,
     cwd,

package/dist/cli.js

@@ -20,10 +20,11 @@ import {
   SUBCOMMANDS,
   WORKTREE_HELP_TEXT,
   resolveSubcommand
-} from "./chunk-HQUCVJ4G.js";
+} from "./chunk-FBXSGZAA.js";
 import {
   runAutopilot
-} from "./chunk-2VMFXAJH.js";
+} from "./chunk-UO7WHIKY.js";
+import "./chunk-J3FXSHMA.js";
 import {
   cleanup
 } from "./chunk-2P3ETOT2.js";
@@ -97,8 +98,14 @@ if (sub === "wt" || sub === "worktree") {
   await run(wt, wtArgs);
   process.exit(0);
 }
+if (sub === "loop") {
+  const { loopCmd } = await import("./commands/loop.js");
+  await run(loopCmd, args.slice(1));
+  process.exit(0);
+}
 if (sub === "autopilot") {
-  await runAutopilot();
+  const { autopilotInteractiveCmd } = await import("./commands/autopilot.js");
+  await run(autopilotInteractiveCmd, args.slice(1));
   process.exit(0);
 }
 if (sub === "dashboard") {

package/dist/commands/autopilot-tui.d.ts

@@ -1,7 +1,17 @@
+/**
+ * Adapter factory — resolves an adapter name to an AgentAdapter instance.
+ *
+ * Used by autopilot, loop, and TUI commands. Reads the resolved AutopilotConfig
+ * to configure adapter-specific settings (models, permissions, etc).
+ */
+
+declare const ADAPTER_NAMES: readonly ["opencode", "claude-code-cli"];
+type AdapterName = (typeof ADAPTER_NAMES)[number];
+
 /**
  * `glrs autopilot` — TUI plan picker at cwd, then run the autopilot session
  * with live event rendering to stderr.
  */
-declare function runAutopilot(): Promise<void>;
+declare function runAutopilot(adapterName?: AdapterName): Promise<void>;
 
 export { runAutopilot };

package/dist/commands/autopilot-tui.js

@@ -1,6 +1,7 @@
 import {
   runAutopilot
-} from "../chunk-2VMFXAJH.js";
+} from "../chunk-UO7WHIKY.js";
+import "../chunk-J3FXSHMA.js";
 import "../chunk-3RG5ZIWI.js";
 export {
   runAutopilot

package/dist/commands/autopilot.d.ts

@@ -23,6 +23,7 @@ declare const autopilotInteractiveCmd: Partial<cmd_ts_dist_cjs_argparser_js.Regi
         parallel: number | undefined;
         ship: boolean;
         status: boolean;
+        adapter: string | undefined;
     }>>;
 } & cmd_ts_dist_cjs_helpdoc_js.PrintHelp & cmd_ts_dist_cjs_helpdoc_js.ProvidesHelp & cmd_ts_dist_cjs_helpdoc_js.Named & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned> & cmd_ts_dist_cjs_argparser_js.Register & cmd_ts_dist_cjs_runner_js.Handling<{
     plan: string | undefined;
@@ -32,6 +33,7 @@ declare const autopilotInteractiveCmd: Partial<cmd_ts_dist_cjs_argparser_js.Regi
     parallel: number | undefined;
     ship: boolean;
     status: boolean;
+    adapter: string | undefined;
 }, Promise<void>> & {
     run(context: cmd_ts_dist_cjs_argparser_js.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js.ParsingResult<Promise<void>>>;
 } & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned & cmd_ts_dist_cjs_helpdoc_js.Descriptive & cmd_ts_dist_cjs_helpdoc_js.Aliased>;

package/dist/commands/autopilot.js

@@ -1,10 +1,16 @@
+import {
+  ADAPTER_NAMES,
+  DEFAULT_ADAPTER,
+  createAdapter,
+  resolveConfig
+} from "../chunk-J3FXSHMA.js";
 import "../chunk-3RG5ZIWI.js";
 
 // src/commands/autopilot.ts
-import { command, flag, option, optional, string as stringType, number as numberType } from "cmd-ts";
+import { command, flag, option, optional, string as stringType, number as numberType, oneOf } from "cmd-ts";
 import * as path from "path";
 import * as fs from "fs";
-import { formatElapsed, formatCost as formatCost2, EventStreamReader, deriveState } from "@glrs-dev/autopilot";
+import { formatElapsed, formatCost as formatCost2, EventStreamReader, deriveState, applyCLIOverrides } from "@glrs-dev/autopilot";
 import { SessionRunner } from "@glrs-dev/autopilot";
 
 // src/cli-renderer.ts
@@ -218,9 +224,15 @@ var autopilotInteractiveCmd = command({
     status: flag({
       long: "status",
       description: "Read and pretty-print the current autopilot status from .agent/autopilot-status.json. Exits 0 if found, 1 if not running."
+    }),
+    adapter: option({
+      long: "adapter",
+      short: "a",
+      type: optional(oneOf(ADAPTER_NAMES)),
+      description: `Agent adapter to use (default: ${DEFAULT_ADAPTER}). Available: ${ADAPTER_NAMES.join(", ")}`
     })
   },
-  handler: async ({ plan, fast, resume, maxIterationsPerPhase, parallel, ship, status }) => {
+  handler: async ({ plan, fast, resume, maxIterationsPerPhase, parallel, ship, status, adapter: adapterName }) => {
     const cwd = process.cwd();
     if (status) {
       const eventFilePath = path.join(cwd, ".agent", "autopilot-events.jsonl");
@@ -340,6 +352,15 @@ var autopilotInteractiveCmd = command({
       }
       planPath = picked;
     }
+    const resolvedConfig = resolveConfig(cwd, planPath);
+    const config = applyCLIOverrides(resolvedConfig, {
+      adapter: adapterName,
+      fast,
+      resume,
+      maxIterationsPerPhase,
+      parallel,
+      ship
+    });
     const { validatePlan } = await import("@glrs-dev/autopilot");
     const validation = validatePlan(path.resolve(process.cwd(), planPath));
     for (const w of validation.warnings) {
@@ -364,30 +385,50 @@ var autopilotInteractiveCmd = command({
       process.stderr.write("\n\x1B[1m\u2192 Enriching plan for fast execution\x1B[0m (deep model reads codebase, adds context)\n");
       process.stderr.write("  Adding mirror refs, code pointers, and conventions...\n");
     }
-    const runner = new SessionRunner({
-      planPath: path.resolve(process.cwd(), planPath),
-      cwd: process.cwd(),
-      fast,
-      resume,
-      maxIterationsPerPhase,
-      parallel,
-      ship
-    });
-    const renderer = createCliRenderer(runner.events);
-    const result = await runner.run();
-    renderer.unsubscribe();
-    if (fast && planPath) {
-      process.stderr.write("  \u2713 Plan enriched \u2014 executing with fast model (mid-execute tier)\n\n");
+    const priorAgentOverridesEnv = process.env["GLRS_AGENT_OVERRIDES"];
+    const finalAdapterName = config.adapter ?? DEFAULT_ADAPTER;
+    if (finalAdapterName === "opencode") {
+      const agentOverrides = config.adapters?.opencode?.agents;
+      if (agentOverrides && Object.keys(agentOverrides).length > 0) {
+        process.env["GLRS_AGENT_OVERRIDES"] = JSON.stringify(agentOverrides);
+      }
     }
-    const costStr = result.loopResult.cumulativeCostUsd ? ` \xB7 $${result.loopResult.cumulativeCostUsd.toFixed(2)}` : "";
-    process.stdout.write(
-      `
+    try {
+      const adapter = await createAdapter(finalAdapterName, config);
+      const runner = new SessionRunner({
+        planPath: path.resolve(process.cwd(), planPath),
+        cwd: process.cwd(),
+        fast,
+        resume,
+        maxIterationsPerPhase,
+        parallel,
+        ship,
+        adapter,
+        enrichmentConfig: config.enrichment,
+        config
+      });
+      const renderer = createCliRenderer(runner.events);
+      const result = await runner.run();
+      renderer.unsubscribe();
+      if (fast && planPath) {
+        process.stderr.write("  \u2713 Plan enriched \u2014 executing with fast model (mid-execute tier)\n\n");
+      }
+      const costStr = result.loopResult.cumulativeCostUsd ? ` \xB7 $${result.loopResult.cumulativeCostUsd.toFixed(2)}` : "";
+      process.stdout.write(
+        `
 \x1B[1m\u2713 Autopilot complete\x1B[0m
   Plan:   ${result.planPath}
   Result: ${result.loopResult.exitReason} after ${result.loopResult.iterations} iteration(s)${costStr}
 
 `
-    );
+      );
+    } finally {
+      if (priorAgentOverridesEnv === void 0) {
+        delete process.env["GLRS_AGENT_OVERRIDES"];
+      } else {
+        process.env["GLRS_AGENT_OVERRIDES"] = priorAgentOverridesEnv;
+      }
+    }
   }
 });
 export {

package/dist/commands/debrief.d.ts

@@ -26,6 +26,8 @@ interface DebriefOptions {
     prompt: string;
     /** Working directory (used for git diff stat). */
     cwd: string;
+    /** Autopilot configuration (for model resolution). */
+    config?: unknown;
     /**
      * Injectable dependencies for testing.
      * @internal

package/dist/commands/debrief.js

@@ -1,7 +1,7 @@
 import {
   runDebrief,
   shouldRunDebrief
-} from "../chunk-5ZVUFNCP.js";
+} from "../chunk-S6N5E2GG.js";
 import "../chunk-3RG5ZIWI.js";
 export {
   runDebrief,

package/dist/commands/loop.d.ts

@@ -26,6 +26,7 @@ declare const loopCmd: Partial<cmd_ts_dist_cjs_argparser_js.Register> & {
         noDebrief: boolean;
         notify: string | undefined;
         debriefOnly: boolean;
+        adapter: string | undefined;
     }>>;
 } & cmd_ts_dist_cjs_helpdoc_js.PrintHelp & cmd_ts_dist_cjs_helpdoc_js.ProvidesHelp & cmd_ts_dist_cjs_helpdoc_js.Named & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned> & cmd_ts_dist_cjs_argparser_js.Register & cmd_ts_dist_cjs_runner_js.Handling<{
     prompt: string;
@@ -35,6 +36,7 @@ declare const loopCmd: Partial<cmd_ts_dist_cjs_argparser_js.Register> & {
     noDebrief: boolean;
     notify: string | undefined;
     debriefOnly: boolean;
+    adapter: string | undefined;
 }, Promise<never>> & {
     run(context: cmd_ts_dist_cjs_argparser_js.ParseContext): Promise<cmd_ts_dist_cjs_argparser_js.ParsingResult<Promise<never>>>;
 } & Partial<cmd_ts_dist_cjs_helpdoc_js.Versioned & cmd_ts_dist_cjs_helpdoc_js.Descriptive & cmd_ts_dist_cjs_helpdoc_js.Aliased>;