docks-kit 0.18.1 → 0.19.1

package/cli/src/engine-native/liveModels.ts

@@ -0,0 +1,263 @@
+import { readFileSync } from "node:fs";
+
+import { capture, p, which } from "./exec";
+import { LEGACY_SELECTION, readHarnessSelection } from "./harnesses";
+import { isObject, parseJson } from "./jq";
+import { isNonBlankString, readCache, writeCache } from "./kitDb";
+import { modelCatalog } from "./models";
+import type { CatalogSource, CatalogTool, FetchLike, ResolvedCatalog } from "./sharedTypes";
+
+export interface LiveCatalogInputs {
+  readonly home: string;
+  readonly refresh: boolean;
+  readonly fetch: FetchLike;
+  readonly which: (name: string) => string;
+  readonly capture: (cmd: string, args: ReadonlyArray<string>) => Promise<string>;
+  readonly now: () => number;
+}
+
+export const defaultLiveInputs = (home: string, refresh = false): LiveCatalogInputs => ({
+  home,
+  refresh,
+  fetch: globalThis.fetch,
+  which,
+  capture,
+  now: Date.now,
+});
+
+type LiveModel = ResolvedCatalog["models"][number];
+type LiveLookup = {
+  readonly source: Exclude<CatalogSource, "curated">;
+  readonly fetchedAt?: string;
+  readonly models: ReadonlyArray<LiveModel>;
+};
+type Lookup = LiveLookup | { readonly fallbackReason: string };
+
+export function curatedCatalog(tool: CatalogTool): ResolvedCatalog {
+  if (tool === "omp") return { tool, source: "curated", verified: "?", models: [] };
+  return { tool, source: "curated", ...modelCatalog(tool) };
+}
+
+function mergeCurated(curated: ResolvedCatalog, live: ReadonlyArray<LiveModel>): Array<LiveModel> {
+  const models: Array<LiveModel> = [];
+  const notes = new Map<string, string>();
+  for (const entry of curated.models) {
+    if (entry.kind === "alias") models.push(entry);
+    if (entry.note !== undefined) notes.set(entry.id, entry.note);
+  }
+  for (const entry of live) {
+    const note = notes.get(entry.id) ?? entry.note;
+    models.push(
+      note === undefined ? { id: entry.id, kind: "id" } : { id: entry.id, kind: "id", note },
+    );
+  }
+  return models;
+}
+
+export async function resolveCatalog(
+  tool: CatalogTool,
+  inputs: LiveCatalogInputs,
+): Promise<ResolvedCatalog> {
+  const curated = curatedCatalog(tool);
+  if (!(readHarnessSelection(inputs.home) ?? LEGACY_SELECTION).includes(tool)) {
+    return { ...curated, fallbackReason: `${tool} harness not enabled (docks-kit harnesses)` };
+  }
+
+  const lookup =
+    tool === "claude"
+      ? await claudeCatalog(inputs)
+      : tool === "codex"
+        ? codexCatalog(inputs.home)
+        : await ompCatalog(inputs);
+  if ("fallbackReason" in lookup) return { ...curated, fallbackReason: lookup.fallbackReason };
+  return {
+    ...curated,
+    source: lookup.source,
+    ...(lookup.fetchedAt === undefined ? {} : { fetchedAt: lookup.fetchedAt }),
+    models: tool === "omp" ? lookup.models : mergeCurated(curated, lookup.models),
+  };
+}
+
+const ANTHROPIC_CACHE_KEY = "models:anthropic";
+const ANTHROPIC_CACHE_TTL = 6 * 3600_000;
+const NO_CLAUDE_LOGIN = "no Claude Code login found in ~/.claude/.credentials.json";
+
+function cachedClaudeCatalog(payload: string): LiveLookup | undefined {
+  const cached = parseJson(payload);
+  if (cached === undefined || !isObject(cached)) return undefined;
+  const fetchedAt = cached["fetchedAt"];
+  const ids = cached["ids"];
+  if (typeof fetchedAt !== "string" || !Array.isArray(ids)) {
+    return undefined;
+  }
+  if (!ids.every(isNonBlankString)) return undefined;
+  const displayNames = cached["displayNames"];
+  // Names align with ids; older cache rows contain ids only.
+  const names =
+    Array.isArray(displayNames) &&
+    displayNames.length === ids.length &&
+    displayNames.every((name) => name === null || isNonBlankString(name))
+      ? displayNames
+      : undefined;
+  return {
+    source: "anthropic-api",
+    fetchedAt,
+    models: ids.map((id, index) => {
+      const name = names?.[index];
+      return typeof name === "string" ? { id, kind: "id", note: name } : { id, kind: "id" };
+    }),
+  };
+}
+
+async function claudeCatalog(inputs: LiveCatalogInputs): Promise<Lookup> {
+  if (!inputs.refresh) {
+    const cached = readCache(inputs.home, ANTHROPIC_CACHE_KEY, ANTHROPIC_CACHE_TTL, inputs.now());
+    if (cached !== undefined) {
+      const catalog = cachedClaudeCatalog(cached);
+      if (catalog !== undefined) return catalog;
+    }
+  }
+
+  let credentialsText: string;
+  try {
+    credentialsText = readFileSync(p(inputs.home, ".claude", ".credentials.json"), "utf8");
+  } catch {
+    return { fallbackReason: NO_CLAUDE_LOGIN };
+  }
+  const credentials = parseJson(credentialsText);
+  const oauth =
+    credentials !== undefined && isObject(credentials) ? credentials["claudeAiOauth"] : undefined;
+  if (oauth === undefined || !isObject(oauth)) return { fallbackReason: NO_CLAUDE_LOGIN };
+  const token = oauth["accessToken"];
+  const expiresAt = oauth["expiresAt"];
+  if (!isNonBlankString(token) || typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) {
+    return { fallbackReason: NO_CLAUDE_LOGIN };
+  }
+  if (expiresAt <= inputs.now()) {
+    return { fallbackReason: "Claude Code login expired; start claude once to refresh it" };
+  }
+
+  const models: Array<LiveModel> = [];
+  let afterId: string | undefined;
+  try {
+    for (;;) {
+      const url = `https://api.anthropic.com/v1/models?limit=1000${afterId === undefined ? "" : `&after_id=${encodeURIComponent(afterId)}`}`;
+      const response = await inputs.fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "anthropic-version": "2023-06-01",
+          "anthropic-beta": "oauth-2025-04-20",
+        },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (response.status !== 200) {
+        return { fallbackReason: `Anthropic API returned HTTP ${response.status}` };
+      }
+      const page: unknown = await response.json();
+      if (typeof page !== "object" || page === null || Array.isArray(page)) {
+        throw new Error("invalid response");
+      }
+      if (
+        !("data" in page) ||
+        !Array.isArray(page.data) ||
+        !("has_more" in page) ||
+        typeof page.has_more !== "boolean"
+      ) {
+        throw new Error("invalid response");
+      }
+      for (const row of page.data) {
+        if (typeof row !== "object" || row === null || Array.isArray(row) || !("id" in row))
+          continue;
+        const id = row.id;
+        if (!isNonBlankString(id)) continue;
+        const name = "display_name" in row ? row.display_name : undefined;
+        models.push(isNonBlankString(name) ? { id, kind: "id", note: name } : { id, kind: "id" });
+      }
+      if (!page.has_more) break;
+      const lastId = "last_id" in page ? page.last_id : undefined;
+      if (!isNonBlankString(lastId) || lastId === afterId) throw new Error("invalid response");
+      afterId = lastId;
+    }
+  } catch (error) {
+    return {
+      fallbackReason: `Anthropic API unreachable: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+
+  // An empty list would drop every curated id; never cache it.
+  if (models.length === 0) return { fallbackReason: "Anthropic API returned no models" };
+  const fetched = inputs.now();
+  const fetchedAt = new Date(fetched).toISOString();
+  writeCache(
+    inputs.home,
+    ANTHROPIC_CACHE_KEY,
+    JSON.stringify({
+      fetchedAt,
+      ids: models.map((model) => model.id),
+      displayNames: models.map((model) => model.note ?? null),
+    }),
+    fetched,
+  );
+  return { source: "anthropic-api", fetchedAt, models };
+}
+
+const NO_CODEX_CACHE = "no Codex model cache (~/.codex/models_cache.json); run codex once";
+const UNREADABLE_CODEX_CACHE = "Codex model cache is unreadable";
+
+function codexCatalog(home: string): Lookup {
+  let text: string;
+  try {
+    text = readFileSync(p(home, ".codex", "models_cache.json"), "utf8");
+  } catch (error) {
+    const missing =
+      typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+    return { fallbackReason: missing ? NO_CODEX_CACHE : UNREADABLE_CODEX_CACHE };
+  }
+  const cache = parseJson(text);
+  if (cache === undefined || !isObject(cache) || !Array.isArray(cache["models"])) {
+    return { fallbackReason: UNREADABLE_CODEX_CACHE };
+  }
+  const models: Array<LiveModel> = [];
+  for (const row of cache["models"]) {
+    if (!isObject(row) || row["visibility"] !== "list") continue;
+    const id = row["slug"];
+    if (!isNonBlankString(id)) continue;
+    const name = row["display_name"];
+    models.push(isNonBlankString(name) ? { id, kind: "id", note: name } : { id, kind: "id" });
+  }
+  if (models.length === 0) return { fallbackReason: "Codex model cache lists no models" };
+  const fetchedAt = cache["fetched_at"];
+  return {
+    source: "codex-cache",
+    ...(typeof fetchedAt === "string" ? { fetchedAt } : {}),
+    models,
+  };
+}
+
+const NO_OMP_CATALOG = "'omp models --json' returned no usable catalog";
+
+async function ompCatalog(inputs: LiveCatalogInputs): Promise<Lookup> {
+  const omp = inputs.which("omp");
+  if (omp === "") return { fallbackReason: "omp not found on PATH" };
+  let raw: string;
+  try {
+    raw = await inputs.capture(omp, ["models", "--json"]);
+  } catch {
+    return { fallbackReason: NO_OMP_CATALOG };
+  }
+  const catalog = parseJson(raw);
+  if (catalog === undefined || !isObject(catalog) || !Array.isArray(catalog["models"])) {
+    return { fallbackReason: NO_OMP_CATALOG };
+  }
+  const models: Array<LiveModel> = [];
+  for (const row of catalog["models"]) {
+    if (!isObject(row) || row["kind"] !== "chat") continue;
+    const id = row["selector"];
+    if (!isNonBlankString(id)) continue;
+    const name = row["name"];
+    models.push(isNonBlankString(name) ? { id, kind: "id", note: name } : { id, kind: "id" });
+  }
+  if (models.length === 0) return { fallbackReason: NO_OMP_CATALOG };
+  return { source: "omp-cli", fetchedAt: new Date(inputs.now()).toISOString(), models };
+}

package/cli/src/engine-native/models.ts

@@ -1,23 +1,25 @@
 /**
- * Model-catalog helpers: manifest listing plus Claude/Codex model validation.
- * Message strings are covered by the golden suites.
+ * Model-catalog helpers: SoT parsing, listing, and Claude/Codex model validation.
+ * Curated message strings are covered by the golden suites.
  */
 import type { Ctx } from "./index";
 import { isObject, parseJson } from "./jq";
 import { payloadDisplayPath, payloadText } from "../payload";
-import type { JsonObject } from "./sharedTypes";
+import type { CatalogSource, JsonObject, ResolvedCatalog } from "./sharedTypes";
 
-export interface ModelEntry {
-  readonly id: string;
-  readonly kind: "alias" | "id";
-  readonly note?: string;
-}
+export type ModelEntry = ResolvedCatalog["models"][number];
 
 export interface ModelCatalog {
   readonly verified: string;
   readonly models: ReadonlyArray<ModelEntry>;
 }
 
+const LIVE_SOURCE_LABELS: Record<Exclude<CatalogSource, "curated">, string> = {
+  "anthropic-api": "Anthropic API via Claude Code login",
+  "codex-cache": "~/.codex/models_cache.json",
+  "omp-cli": "omp models --json",
+};
+
 function toolEntry(tool: string): JsonObject | undefined {
   const doc = parseJson(payloadText("SoT/models.json"));
   if (doc === undefined || !isObject(doc)) return undefined;
@@ -49,43 +51,47 @@ export function modelCatalog(tool: string): ModelCatalog {
   return { verified: typeof verified === "string" ? verified : "?", models };
 }
 
-export function printModels(ctx: Ctx, tool: string): void {
+export function printModels(ctx: Ctx, catalog: ResolvedCatalog): void {
   const { echo, warn } = ctx.services.logger;
-  const entry = toolEntry(tool);
-  if (entry === undefined) {
+  const { tool, models, source, verified, fetchedAt } = catalog;
+  if (source === "curated" && models.length === 0) {
     warn(`Model catalog unavailable (${payloadDisplayPath("SoT/models.json")})`);
     return;
   }
-  const verified = typeof entry["verified"] === "string" ? entry["verified"] : "?";
-  const lines = [`Available ${tool} models (kit-verified ${verified} — SoT/models.json):`];
-  for (const m of modelEntries(entry)) {
-    const note = typeof m["note"] === "string" ? `  — ${m["note"]}` : "";
-    lines.push(`  ${String(m["id"] ?? "")}${note}`);
+  const header =
+    source === "curated"
+      ? `Available ${tool} models (kit-verified ${verified} — SoT/models.json):`
+      : `Available ${tool} models (live — ${LIVE_SOURCE_LABELS[source]}, fetched ${fetchedAt ?? "?"}; aliases and notes from SoT/models.json):`;
+  echo(header);
+  for (const model of models) {
+    echo(`  ${model.id}${model.note === undefined ? "" : `  — ${model.note}`}`);
   }
   if (tool === "claude")
-    lines.push("  (full claude-* model IDs outside the catalog are accepted with a warning)");
-  if (tool === "codex")
-    lines.push("  (well-formed IDs outside the catalog are accepted with a warning)");
-  for (const line of lines) echo(line);
+    echo("  (full claude-* model IDs outside the catalog are accepted with a warning)");
+  if (tool === "codex") echo("  (well-formed IDs outside the catalog are accepted with a warning)");
 }
 
-export function validateClaudeModel(ctx: Ctx, m: string): boolean {
+export function validateClaudeModel(ctx: Ctx, m: string, catalog: ResolvedCatalog): boolean {
   if (m === "") return false;
-  if (modelCatalog("claude").models.some((entry) => entry.id === m)) return true;
+  if (catalog.models.some((entry) => entry.id === m)) return true;
   if (m.startsWith("claude-")) {
     ctx.services.logger.warn(
-      `Claude model '${m}' is not in the kit-verified catalog (SoT/models.json) — applying anyway`,
+      catalog.source === "curated"
+        ? `Claude model '${m}' is not in the kit-verified catalog (SoT/models.json) — applying anyway`
+        : `Claude model '${m}' is not in the live Anthropic model list — applying anyway`,
     );
     return true;
   }
   return false;
 }
 
-export function validateCodexModel(ctx: Ctx, m: string): boolean {
+export function validateCodexModel(ctx: Ctx, m: string, catalog: ResolvedCatalog): boolean {
   if (!/^[A-Za-z0-9._-]+$/.test(m)) return false;
-  if (!modelCatalog("codex").models.some((entry) => entry.id === m)) {
+  if (!catalog.models.some((entry) => entry.id === m)) {
     ctx.services.logger.warn(
-      `Codex model '${m}' is not in the kit-verified catalog (SoT/models.json) — applying anyway (check ~/.codex/config.toml if Codex rejects it)`,
+      catalog.source === "curated"
+        ? `Codex model '${m}' is not in the kit-verified catalog (SoT/models.json) — applying anyway (check ~/.codex/config.toml if Codex rejects it)`
+        : `Codex model '${m}' is not in the live Codex model list — applying anyway (check ~/.codex/config.toml if Codex rejects it)`,
     );
   }
   return true;

package/cli/src/engine-native/modes.ts

@@ -11,12 +11,14 @@ import { syncCodexModel } from "./codexToml";
 import type { Ctx } from "./index";
 import { isObject, parseJson, type Json } from "./jq";
 import { printModels, validateClaudeModel, validateCodexModel } from "./models";
+import { defaultLiveInputs, resolveCatalog } from "./liveModels";
 import { bunBootstrap } from "./bun";
-import { installedVersion, present, report } from "./toolchain";
+import { installedVersion, outdatedReport, present, report } from "./toolchain";
+import { topLevelTomlString } from "../manifests";
 
-export function modeModel(ctx: Ctx, args: ReadonlyArray<string>): number {
+export async function modeModel(ctx: Ctx, args: ReadonlyArray<string>): Promise<number> {
   const { echo, err, warn } = ctx.services.logger;
-  let tool = "";
+  let tool: "claude" | "codex" | "" = "";
   let value = "";
   for (const arg of args) {
     if (arg === "--dry-run") ctx.dryRun = true;
@@ -32,7 +34,7 @@ export function modeModel(ctx: Ctx, args: ReadonlyArray<string>): number {
     err("Usage: model <claude|codex> [value] [--dry-run]");
     return 2;
   }
-
+  const catalog = await resolveCatalog(tool, defaultLiveInputs(ctx.home));
   if (value === "") {
     if (tool === "claude") {
       const deployed = p(ctx.home, ".claude", "settings.json");
@@ -58,23 +60,23 @@ export function modeModel(ctx: Ctx, args: ReadonlyArray<string>): number {
         err(`Failed to read ~/.codex/config.toml: ${String(result.error)}`);
         return 1;
       }
-      echo(`deployed: ${tomlModelText(result.data)}`);
-      echo(`SoT:      ${tomlModelText(payloadText("SoT/.codex/config.toml"))}`);
+      echo(`deployed: ${topLevelTomlString(result.data, "model") ?? ""}`);
+      echo(`SoT:      ${topLevelTomlString(payloadText("SoT/.codex/config.toml"), "model") ?? ""}`);
     }
-    printModels(ctx, tool);
+    printModels(ctx, catalog);
     return 0;
   }
 
   if (tool === "claude") {
-    if (!validateClaudeModel(ctx, value)) {
-      printModels(ctx, "claude");
+    if (!validateClaudeModel(ctx, value, catalog)) {
+      printModels(ctx, catalog);
       err(`Invalid Claude model '${value}'`);
       return 2;
     }
     syncClaudeModel(ctx, value);
   } else {
-    if (!validateCodexModel(ctx, value)) {
-      printModels(ctx, "codex");
+    if (!validateCodexModel(ctx, value, catalog)) {
+      printModels(ctx, catalog);
       err(`Invalid Codex model '${value}'`);
       return 2;
     }
@@ -111,15 +113,6 @@ function jsonModelText(text: string): string {
   return typeof v === "string" ? v : JSON.stringify(v);
 }
 
-/** `awk -F'"' '/^model[[:space:]]*=/{print $2; exit}'`. */
-
-function tomlModelText(text: string): string {
-  for (const line of text.split("\n")) {
-    if (/^model[ \t]*=/.test(line)) return line.split('"')[1] ?? "";
-  }
-  return "";
-}
-
 export async function modeToolchain(ctx: Ctx, args: ReadonlyArray<string>): Promise<number> {
   const { echo, err, verbose } = ctx.services.logger;
   const words = args.filter((arg) => !arg.startsWith("--"));
@@ -128,13 +121,21 @@ export async function modeToolchain(ctx: Ctx, args: ReadonlyArray<string>): Prom
   for (const arg of args) {
     if (arg === "--verbose") ctx.verbose = true;
   }
+  if (words.length > (op === "ensure" ? 2 : 1)) {
+    err("Usage: toolchain [check|ensure <tool>|outdated [--refresh]]");
+    return 2;
+  }
 
   if (op === "check") {
     await report(ctx);
     return 0;
   }
+  if (op === "outdated") {
+    await outdatedReport(ctx, { refresh: args.includes("--refresh") });
+    return 0;
+  }
   if (op !== "ensure") {
-    err("Usage: toolchain [check|ensure <tool>]");
+    err("Usage: toolchain [check|ensure <tool>|outdated [--refresh]]");
     return 2;
   }
   if (tool === "") {

package/cli/src/engine-native/parseArgs.ts

@@ -8,6 +8,7 @@ import type { Ctx } from "./index";
 import { LEGACY_SELECTION, readHarnessSelection, type Harness } from "./harnesses";
 import { advisorCatalog, advisorFlagGrammar, effortCatalog, effortFlagGrammar } from "../efforts";
 import { printModels } from "./models";
+import { curatedCatalog } from "./liveModels";
 import { ExitError, printCatalog, printUsage } from "./parseHelp";
 import {
   KNOWN_CLAUDE_OPTIN_PLUGINS,
@@ -93,11 +94,11 @@ export function parseArgs(ctx: Ctx, args: ReadonlyArray<string>): void {
         ctx.verbose = true;
         continue;
       case "--claude-model":
-        printModels(ctx, "claude");
+        printModels(ctx, curatedCatalog("claude"));
         err("--claude-model requires a value: --claude-model=<model>");
         throw new ExitError(2);
       case "--codex-model":
-        printModels(ctx, "codex");
+        printModels(ctx, curatedCatalog("codex"));
         err("--codex-model requires a value: --codex-model=<model>");
         throw new ExitError(2);
       case "--claude-effort":

package/cli/src/engine-native/parseModifiers.ts

@@ -17,6 +17,7 @@ import {
   isEffortModifierValue,
 } from "../efforts";
 import { printModels, validateClaudeModel, validateCodexModel } from "./models";
+import { defaultLiveInputs, resolveCatalog } from "./liveModels";
 import { ExitError, printCatalog } from "./parseHelp";
 
 export const KNOWN_CLAUDE_OPTIN_PLUGINS = ["supabase", "n8n"];
@@ -169,7 +170,7 @@ export function isScalarModifierFlag(value: string): value is ScalarModifierFlag
   return SCALAR_MODIFIER_FLAGS[value as ScalarModifierFlag] === true;
 }
 
-export function validateModifierFlags(ctx: Ctx): void {
+export async function validateModifierFlags(ctx: Ctx): Promise<void> {
   const { err, warn } = ctx.services.logger;
   const supplied = (flag: ModifierFlag): boolean =>
     MODIFIER_METADATA[flag].hasValue(ctx) || ctx.modifierFlags?.has(flag) === true;
@@ -185,8 +186,9 @@ export function validateModifierFlags(ctx: Ctx): void {
   }
 
   if (supplied("--claude-model")) {
-    if (!validateClaudeModel(ctx, ctx.claudeModel)) {
-      printModels(ctx, "claude");
+    const catalog = await resolveCatalog("claude", defaultLiveInputs(ctx.home));
+    if (!validateClaudeModel(ctx, ctx.claudeModel, catalog)) {
+      printModels(ctx, catalog);
       err(`Invalid Claude model '${ctx.claudeModel}' — use an alias above or a full claude-* ID`);
       throw new ExitError(2);
     }
@@ -206,8 +208,9 @@ export function validateModifierFlags(ctx: Ctx): void {
     }
   }
   if (supplied("--codex-model")) {
-    if (!validateCodexModel(ctx, ctx.codexModel)) {
-      printModels(ctx, "codex");
+    const catalog = await resolveCatalog("codex", defaultLiveInputs(ctx.home));
+    if (!validateCodexModel(ctx, ctx.codexModel, catalog)) {
+      printModels(ctx, catalog);
       err(`Invalid Codex model '${ctx.codexModel}' — must match ^[A-Za-z0-9._-]+$`);
       throw new ExitError(2);
     }

package/cli/src/engine-native/sharedTypes.d.ts

@@ -9,6 +9,22 @@ import type { ModifierFlag } from "./engineCtx";
 /** Manifest-record object: the `{ [key]: Json }` shape redeclared across manifest readers. */
 export type JsonObject = { [key: string]: Json };
 
+export type CatalogTool = "claude" | "codex" | "omp";
+export type CatalogSource = "anthropic-api" | "codex-cache" | "omp-cli" | "curated";
+
+export interface ResolvedCatalog {
+  readonly tool: CatalogTool;
+  readonly source: CatalogSource;
+  readonly verified: string;
+  readonly fetchedAt?: string;
+  readonly fallbackReason?: string;
+  readonly models: ReadonlyArray<{
+    readonly id: string;
+    readonly kind: "alias" | "id";
+    readonly note?: string;
+  }>;
+}
+
 /**
  * Shared core of per-tool settings-edit descriptors (Claude JSON modifiers,
  * Codex TOML passes). Each tool narrows `key` to its own vocabulary and keeps
@@ -44,3 +60,6 @@ export type ScalarModifierFlag = Exclude<
   ModifierFlag,
   "--claude-compact-window" | "--claude-permissive" | "--claude-plugin"
 >;
+
+/** Injected HTTP client: the subset of fetch the network lookups call. */
+export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;

package/cli/src/engine-native/syncDispatch.ts

@@ -21,7 +21,7 @@ import {
 export async function engineSync(ctx: Ctx, args: ReadonlyArray<string>): Promise<number> {
   const { acquireTerminal, echo, err } = ctx.services.logger;
   parseArgs(ctx, args);
-  validateModifierFlags(ctx);
+  await validateModifierFlags(ctx);
   const configuredConcurrency = process.env["DOCKS_KIT_SYNC_CONCURRENCY"];
   if (configuredConcurrency === undefined || configuredConcurrency === "") {
     ctx.syncConcurrency = 3;