@nodeint/migent 0.1.6 → 0.1.7

package/README.md

@@ -1,6 +1,7 @@
 # Migent
 
 <p align="center">
+  <img src="assets/stylized-m.svg" alt="Migent logo" width="150" /><br>
   <strong>Autonomous, multi-stage engineering pipelines for your coding agents.</strong><br>
   Repeatable workflows. Multi-agent orchestration. Native CLI execution. Full observability.
 </p>
@@ -73,7 +74,7 @@ migent session metrics <session-id> --json
 | :--- | :--- |
 | **Manual handoffs:** Copying plans and pasting stack traces across conversations. | **Automated handoffs:** Upstream artifacts and diffs pass automatically into downstream stages. |
 | **Single-agent bottleneck:** One model handles planning, coding, and review, accumulating context bloat. | **Specialized roles:** Multi-agent pipeline with dedicated models per role (e.g., Planner $\rightarrow$ Coder $\rightarrow$ Reviewer). |
-| **Vendor lock-in & wrappers:** Restricted to one provider or requiring custom API adapters. | **Native CLI execution:** Drives your installed agent CLIs (`agy`, `claude`, `codex`, `grok`) directly in your workspace. |
+| **Vendor lock-in & wrappers:** Restricted to one provider or requiring custom API providers. | **Native CLI execution:** Drives your installed agent CLIs (`agy`, `claude`, `codex`, `grok`) directly in your workspace. |
 | **Blind trust:** Agents claim "all tests pass" without actually running project commands. | **Verification gates:** Real local checks (`pnpm test`, `pytest`, `cargo test`) must succeed before advancing. |
 | **Fragile one-off prompts:** Team members execute tasks with inconsistent, ad-hoc instructions. | **Process as code:** Workflows live in Git (`.migent/workflows/`), making best practices versioned and repeatable. |
 | **No execution visibility:** No record of how long tasks took, why checks failed, or how many retries occurred. | **Telemetry & Metrics:** Append-only event logs, live streaming, and full JSON metrics for duration, retries, and token cost. |
@@ -117,6 +118,8 @@ Decouple **what** a stage does from **which model** executes it. Migent drives t
 | **Google Antigravity** | `agy` | Deep repository analysis, plan generation & review |
 | **OpenAI Codex** | `codex` | Fast, focused implementation & unit test authoring |
 | **xAI Grok** | `grok` | Independent logic review & edge case discovery |
+| **OpenCode** | `opencode` | Multi-vendor models behind one CLI, for any role |
+| **BytePlus ModelArk** | none (set `client` per model) | BytePlus models run through another installed CLI, e.g. `opencode` |
 
 Switch models anytime in `.migent/config.yaml` without touching your workflow logic.
 
@@ -210,6 +213,7 @@ outputs:
 # Setup & Health
 migent init --preset plan           # Initialize starter configuration
 migent doctor                      # Validate configuration, schemas, and CLI availability
+migent provider list               # List registered provider providers and their available models
 migent skill install               # Install the Migent Skill for coding agents (.agents/skills/migent/)
 
 # Execution

package/dist/commands/agent.js

@@ -5,7 +5,7 @@ import { printAgent, printError, printNotice, printResumeCommand } from "../disp
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
 import { bindCancellationSignals } from "../signals.js";
-import { adapterMap, parseOptions } from "../provider.js";
+import { providerMap, parseOptions } from "../provider.js";
 import { resolvePrompt } from "../workspace.js";
 export async function dispatchAgent(workspace, args) {
     requireCurrentSchema(workspace);
@@ -65,7 +65,7 @@ export async function dispatchAgent(workspace, args) {
         let result;
         let resumedMany = null;
         try {
-            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(providerMap());
             const waitedUntil = new Map();
             const rerun = (prompt, resumeId) => runner.run({
                 provider: target.provider,
@@ -206,7 +206,7 @@ export async function continueAgent(workspace, args) {
         printNotice(`agent ${role} · ${profile.provider}/${profile.model} (${optionLabel}).`);
         const unbind = bindCancellationSignals();
         try {
-            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(providerMap());
             if (sessionStatus === "cancelled") {
                 return await runCancelledRole(workspace, args.sessionId, role, profile, runner, false, args.waitHooks);
             }

package/dist/commands/config.d.ts

@@ -1,4 +1,4 @@
-import { type AgentAdapter } from "@nodeint/migent-kernel";
+import { type Provider } from "@nodeint/migent-kernel";
 import { type RunCommand, type Which } from "../provider.js";
 export interface ConfigPrompter {
     select(message: string, choices: ReadonlyArray<readonly [string, string]>, defaultValue?: string | null): string | Promise<string>;
@@ -14,7 +14,7 @@ export declare function runConfigModel(workspace: string, options?: {
     clearOptions?: readonly string[];
     asJson?: boolean;
     interactive?: boolean;
-    adapters?: Record<string, AgentAdapter> | null;
+    providers?: Record<string, Provider> | null;
     which?: Which | null;
     prompter?: ConfigPrompter | null;
     runCommand?: RunCommand | null;
@@ -28,7 +28,7 @@ export declare function runConfigRole(workspace: string, options?: {
     clearOptions?: readonly string[];
     asJson?: boolean;
     interactive?: boolean;
-    adapters?: Record<string, AgentAdapter> | null;
+    providers?: Record<string, Provider> | null;
     which?: Which | null;
     prompter?: ConfigPrompter | null;
     runCommand?: RunCommand | null;

package/dist/commands/config.js

@@ -6,7 +6,7 @@ import { printError } from "../display.js";
 import { PromptCancelled } from "../errors.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
-import { acceptedOptions, adapterMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireAdapter, runProviderCommand, } from "../provider.js";
+import { acceptedOptions, providerMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireProvider, runProviderCommand, } from "../provider.js";
 import { runDoctor } from "./doctor.js";
 const NEW = "__new__";
 const UNSET = Symbol("unset");
@@ -19,7 +19,7 @@ export async function runConfigModel(workspace, options = {}) {
     try {
         return await runModel(workspace, {
             ...options,
-            adapters: options.adapters ?? adapterMap(),
+            providers: options.providers ?? providerMap(),
             which: options.which ?? cliHooks.which ?? whichSync,
             prompter: options.prompter ?? new ClackConfigPrompter(),
             runCommand: options.runCommand ?? runProviderCommand,
@@ -39,7 +39,7 @@ export async function runConfigRole(workspace, options = {}) {
     try {
         return await runRole(workspace, {
             ...options,
-            adapters: options.adapters ?? adapterMap(),
+            providers: options.providers ?? providerMap(),
             which: options.which ?? cliHooks.which ?? whichSync,
             prompter: options.prompter ?? new ClackConfigPrompter(),
             runCommand: options.runCommand ?? runProviderCommand,
@@ -69,7 +69,7 @@ async function runModel(workspace, args) {
     const mutating = provider !== null || optionUpdates !== UNSET;
     if (key === null && !mutating) {
         if (interactive) {
-            return interactiveModels(workspace, config, workflows, view, args.adapters, args.which, args.prompter, args.runCommand, asJson);
+            return interactiveModels(workspace, config, workflows, view, args.providers, args.which, args.prompter, args.runCommand, asJson);
         }
         emitView(view, asJson, true, false);
         return 0;
@@ -78,19 +78,19 @@ async function runModel(workspace, args) {
         throw new ConfigEditError("Pass a name.");
     if (!mutating) {
         if (interactive) {
-            return editModel(workspace, config, workflows, view, key, args.adapters, args.which, args.prompter, args.runCommand, asJson);
+            return editModel(workspace, config, workflows, view, key, args.providers, args.which, args.prompter, args.runCommand, asJson);
         }
         emitModels(selectedModels(view, [key]), asJson);
         return 0;
     }
     let catalog = null;
     if (provider !== null && model !== null) {
-        [provider, model, catalog] = await catalogModel(args.adapters, args.which, args.runCommand, provider, model);
+        [provider, model, catalog] = await catalogModel(args.providers, args.which, args.runCommand, provider, model);
     }
     if (optionUpdates !== UNSET) {
         const currentProvider = provider ?? modelProvider(config, key);
         const currentModel = model ?? loadModelTarget(config, key).model;
-        optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, currentProvider, currentModel, optionUpdates, provider !== null ? catalog : null);
+        optionUpdates = await checkedOptions(args.providers, args.which, args.runCommand, currentProvider, currentModel, optionUpdates, provider !== null ? catalog : null);
     }
     const change = upsertModel(config, key, {
         provider,
@@ -98,7 +98,7 @@ async function runModel(workspace, args) {
         ...(optionUpdates === UNSET ? {} : { options: optionUpdates }),
         workflows,
     });
-    validateChange(config, change.config, workflows, args.adapters);
+    validateChange(config, change.config, workflows, args.providers);
     return await commit(workspace, change, { asJson, which: args.which });
 }
 async function runRole(workspace, args) {
@@ -119,7 +119,7 @@ async function runRole(workspace, args) {
     const mutating = modelName !== null || provider !== null || optionUpdates !== UNSET;
     if (roles.length === 0 && !mutating) {
         if (interactive) {
-            return interactiveRoles(workspace, config, workflows, view, args.adapters, args.which, args.prompter, args.runCommand, asJson);
+            return interactiveRoles(workspace, config, workflows, view, args.providers, args.which, args.prompter, args.runCommand, asJson);
         }
         emitView(view, asJson, false, true);
         return 0;
@@ -132,7 +132,7 @@ async function runRole(workspace, args) {
     if (!mutating) {
         if (interactive && roles.length === 1) {
             knownRole(view, roles[0] ?? "");
-            return pointRole(workspace, config, workflows, view, roles[0] ?? "", args.adapters, args.which, args.prompter, args.runCommand, asJson);
+            return pointRole(workspace, config, workflows, view, roles[0] ?? "", args.providers, args.which, args.prompter, args.runCommand, asJson);
         }
         emitRoles(selectedRoles(view, roles), asJson);
         return 0;
@@ -140,9 +140,9 @@ async function runRole(workspace, args) {
     let change;
     if (provider !== null && model !== null) {
         let catalog;
-        [provider, model, catalog] = await catalogModel(args.adapters, args.which, args.runCommand, provider, model);
+        [provider, model, catalog] = await catalogModel(args.providers, args.which, args.runCommand, provider, model);
         if (optionUpdates !== UNSET) {
-            optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, provider, model, optionUpdates, catalog);
+            optionUpdates = await checkedOptions(args.providers, args.which, args.runCommand, provider, model, optionUpdates, catalog);
         }
         change = placeRoleModel(config, roles[0] ?? "", {
             provider,
@@ -155,7 +155,7 @@ async function runRole(workspace, args) {
         change = assignRoles(config, roles, modelName, { workflows });
         if (optionUpdates !== UNSET) {
             const target = loadModelTarget(change.config, modelName);
-            optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, target.provider, target.model, optionUpdates);
+            optionUpdates = await checkedOptions(args.providers, args.which, args.runCommand, target.provider, target.model, optionUpdates);
             const follow = setRoleOptions(change.config, roles[0] ?? "", optionUpdates, { workflows });
             change = describeChange(config, follow.config, workflows);
         }
@@ -164,40 +164,40 @@ async function runRole(workspace, args) {
         const target = roleModel(config, roles[0] ?? "");
         if (optionUpdates === UNSET)
             throw new ConfigEditError("Pass a role.");
-        optionUpdates = await checkedOptions(args.adapters, args.which, args.runCommand, target.provider, target.model, optionUpdates);
+        optionUpdates = await checkedOptions(args.providers, args.which, args.runCommand, target.provider, target.model, optionUpdates);
         change = setRoleOptions(config, roles[0] ?? "", optionUpdates, { workflows });
     }
-    validateChange(config, change.config, workflows, args.adapters);
+    validateChange(config, change.config, workflows, args.providers);
     return await commit(workspace, change, { asJson, which: args.which });
 }
-async function interactiveModels(workspace, config, workflows, view, adapters, which, prompter, runCommand, asJson) {
+async function interactiveModels(workspace, config, workflows, view, providers, which, prompter, runCommand, asJson) {
     const choices = view.models.map((model) => [modelLabel(model), model.key]);
     choices.push(["New model", NEW]);
     const selected = await prompter.select("Model", choices, view.models[0]?.key ?? NEW);
     if (selected === NEW)
-        return addModel(workspace, config, workflows, null, adapters, which, prompter, runCommand, asJson);
-    return editModel(workspace, config, workflows, view, selected, adapters, which, prompter, runCommand, asJson);
+        return addModel(workspace, config, workflows, null, providers, which, prompter, runCommand, asJson);
+    return editModel(workspace, config, workflows, view, selected, providers, which, prompter, runCommand, asJson);
 }
-async function editModel(workspace, config, workflows, view, key, adapters, which, prompter, runCommand, asJson) {
+async function editModel(workspace, config, workflows, view, key, providers, which, prompter, runCommand, asJson) {
     const current = selectedModels(view, [key])[0];
     if (current === undefined)
         throw new ConfigEditError(`Unknown name: ${key}.`);
-    const provider = await selectProvider(prompter, adapters, which, "Provider", current.provider);
-    const adapter = requireAdapter(adapters, provider);
-    const catalog = await loadCatalog(adapter, which, runCommand);
+    const provider = await selectProvider(prompter, providers, which, "Provider", current.provider);
+    const impl = requireProvider(providers, provider);
+    const catalog = await loadCatalog(impl, which, runCommand);
     const initial = catalog.ids.includes(current.model) ? current.model : (catalog.defaultId ?? undefined);
     let modelId = knownModel(await prompter.select("Model", catalog.ids.map((item) => [item, item]), initial), catalog);
-    const stored = await promptedOptions(prompter, adapter, modelId, catalog, which, runCommand, current.options);
+    const stored = await promptedOptions(prompter, impl, modelId, catalog, which, runCommand, current.options);
     const change = upsertModel(config, key, { provider, model: modelId, options: stored, workflows });
-    validateChange(config, change.config, workflows, adapters);
+    validateChange(config, change.config, workflows, providers);
     return confirmAndCommit(workspace, change, prompter, asJson, which);
 }
-async function addModel(workspace, config, workflows, role, adapters, which, prompter, runCommand, asJson) {
-    const provider = await selectProvider(prompter, adapters, which, "Provider", null);
-    const adapter = requireAdapter(adapters, provider);
-    const catalog = await loadCatalog(adapter, which, runCommand);
+async function addModel(workspace, config, workflows, role, providers, which, prompter, runCommand, asJson) {
+    const provider = await selectProvider(prompter, providers, which, "Provider", null);
+    const impl = requireProvider(providers, provider);
+    const catalog = await loadCatalog(impl, which, runCommand);
     const modelId = knownModel(await prompter.select("Model", catalog.ids.map((item) => [item, item]), catalog.defaultId), catalog);
-    const options = await promptedOptions(prompter, adapter, modelId, catalog, which, runCommand, {});
+    const options = await promptedOptions(prompter, impl, modelId, catalog, which, runCommand, {});
     const present = presentOptions(options);
     const existing = matchingModelName(config, { provider, model: modelId, options: present });
     let change;
@@ -224,10 +224,10 @@ async function addModel(workspace, config, workflows, role, adapters, which, pro
             change = describeChange(config, assigned.config, workflows);
         }
     }
-    validateChange(config, change.config, workflows, adapters);
+    validateChange(config, change.config, workflows, providers);
     return confirmAndCommit(workspace, change, prompter, asJson, which);
 }
-async function interactiveRoles(workspace, config, workflows, view, adapters, which, prompter, runCommand, asJson) {
+async function interactiveRoles(workspace, config, workflows, view, providers, which, prompter, runCommand, asJson) {
     const choices = view.roles.map((role) => [roleLabel(role), role.role]);
     choices.push(["New role", NEW]);
     const selected = await prompter.select("Role", choices, view.roles[0]?.role ?? NEW);
@@ -237,20 +237,20 @@ async function interactiveRoles(workspace, config, workflows, view, adapters, wh
             throw new ConfigEditError("Role name is required.");
         if (view.roles.some((role) => role.role === name))
             throw new ConfigEditError(`Role ${name} already exists.`);
-        return pointRole(workspace, config, workflows, view, name, adapters, which, prompter, runCommand, asJson);
+        return pointRole(workspace, config, workflows, view, name, providers, which, prompter, runCommand, asJson);
     }
-    return pointRole(workspace, config, workflows, view, selected, adapters, which, prompter, runCommand, asJson);
+    return pointRole(workspace, config, workflows, view, selected, providers, which, prompter, runCommand, asJson);
 }
-async function pointRole(workspace, config, workflows, view, role, adapters, which, prompter, runCommand, asJson) {
+async function pointRole(workspace, config, workflows, view, role, providers, which, prompter, runCommand, asJson) {
     const current = view.roles.find((item) => item.role === role) ?? null;
     const choices = view.models.map((model) => [modelLabel(model), model.key]);
     choices.push(["New model", NEW]);
     const selected = await prompter.select("Model", choices, current?.modelName ?? NEW);
     if (selected === NEW) {
-        return addModel(workspace, config, workflows, role, adapters, which, prompter, runCommand, asJson);
+        return addModel(workspace, config, workflows, role, providers, which, prompter, runCommand, asJson);
     }
     const change = assignRoles(config, [role], selected, { workflows });
-    validateChange(config, change.config, workflows, adapters);
+    validateChange(config, change.config, workflows, providers);
     return confirmAndCommit(workspace, change, prompter, asJson, which);
 }
 async function confirmAndCommit(workspace, change, prompter, asJson, which) {
@@ -274,7 +274,7 @@ async function commit(workspace, change, args) {
     }
     writeFileSync(filePath, updated, "utf8");
     if (args.asJson) {
-        const checks = diagnose(workspace, { adapters: adapterMap(), which: args.which });
+        const checks = diagnose(workspace, { providers: providerMap(), which: args.which });
         const doctor = doctorPayload(checks);
         process.stdout.write(`${JSON.stringify(changePayload(change, true, doctor))}\n`);
         return doctor.ok ? 0 : 1;
@@ -283,7 +283,7 @@ async function commit(workspace, change, args) {
         printChange(change);
     return runDoctor(workspace, { which: args.which });
 }
-function validateChange(before, after, workflows, adapters) {
+function validateChange(before, after, workflows, providers) {
     const beforeModels = isRecord(before.models) ? before.models : {};
     const afterModels = isRecord(after.models) ? after.models : {};
     const changed = new Set();
@@ -294,7 +294,7 @@ function validateChange(before, after, workflows, adapters) {
     }
     for (const key of changed) {
         const target = loadModelTarget(after, key);
-        requireAdapter(adapters, target.provider).validateOptions(target.options);
+        requireProvider(providers, target.provider).validateOptions(target.options);
     }
     const beforeRoles = isRecord(before.roles) ? before.roles : {};
     const afterRoles = isRecord(after.roles) ? after.roles : {};
@@ -312,7 +312,7 @@ function validateChange(before, after, workflows, adapters) {
                     options[optionName] = value.trim();
             }
         }
-        requireAdapter(adapters, target.provider).validateOptions(options);
+        requireProvider(providers, target.provider).validateOptions(options);
     }
     for (const document of workflows) {
         for (const stage of Object.values(document.stages)) {
@@ -331,35 +331,35 @@ function validateChange(before, after, workflows, adapters) {
             }
             if (sameTarget(beforeTarget, afterTarget))
                 continue;
-            requireAdapter(adapters, afterTarget.provider).validateOptions(afterTarget.options);
+            requireProvider(providers, afterTarget.provider).validateOptions(afterTarget.options);
         }
     }
 }
-async function catalogModel(adapters, which, runCommand, provider, model) {
-    const adapter = requireAdapter(adapters, provider);
-    const catalog = await loadCatalog(adapter, which, runCommand);
+async function catalogModel(providers, which, runCommand, provider, model) {
+    const impl = requireProvider(providers, provider);
+    const catalog = await loadCatalog(impl, which, runCommand);
     return [provider, knownModel(model, catalog), catalog];
 }
-async function checkedOptions(adapters, which, runCommand, provider, model, updates, catalog = null) {
-    const adapter = requireAdapter(adapters, provider);
-    const resolved = catalog ?? (await loadCatalog(adapter, which, runCommand));
+async function checkedOptions(providers, which, runCommand, provider, model, updates, catalog = null) {
+    const impl = requireProvider(providers, provider);
+    const resolved = catalog ?? (await loadCatalog(impl, which, runCommand));
     const present = {};
     for (const [key, value] of Object.entries(updates)) {
         if (value !== null)
             present[key] = value;
     }
     if (Object.keys(present).length > 0) {
-        await acceptedOptions(adapter, model, resolved, which, runCommand, present);
+        await acceptedOptions(impl, model, resolved, which, runCommand, present);
     }
     return { ...updates };
 }
-async function promptedOptions(prompter, adapter, model, catalog, which, runCommand, current) {
+async function promptedOptions(prompter, provider, model, catalog, which, runCommand, current) {
     const stored = {};
-    const catalogAdapter = asCatalog(adapter);
-    for (const spec of catalogAdapter.providerOptions()) {
+    const catalogProvider = asCatalog(provider);
+    for (const spec of catalogProvider.providerOptions()) {
         if (!spec.prompt)
             continue;
-        const values = await loadOptionValues(adapter, spec.name, model, catalog, which, runCommand);
+        const values = await loadOptionValues(provider, spec.name, model, catalog, which, runCommand);
         if (values === null || values.length === 0)
             continue;
         const choices = values.map((value) => [value, value]);
@@ -386,8 +386,8 @@ function optionUpdatesOf(options, clearOptions) {
     }
     return updates;
 }
-async function selectProvider(prompter, adapters, which, message, defaultValue) {
-    const rows = detected(adapters, which);
+async function selectProvider(prompter, providers, which, message, defaultValue) {
+    const rows = detected(providers, which);
     if (rows.length === 0)
         throw new ConfigurationError("No providers are available.");
     const names = new Set(rows.map(([name]) => name));

package/dist/commands/doctor.js

@@ -2,11 +2,11 @@ import { diagnose, whichSync } from "@nodeint/migent-kernel";
 import { printDoctor } from "../display.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
-import { adapterMap } from "../provider.js";
+import { providerMap } from "../provider.js";
 export async function runDoctor(workspace, options = {}) {
     requireCurrentSchema(workspace);
     const which = options.which ?? cliHooks.which ?? whichSync;
-    const checks = diagnose(workspace, { adapters: adapterMap(), which });
+    const checks = diagnose(workspace, { providers: providerMap(), which });
     if (options.asJson)
         process.stdout.write(`${JSON.stringify(payload(checks))}\n`);
     else

package/dist/commands/execute.js

@@ -4,7 +4,7 @@ import { AgentToolRunner, DEFAULT_MAX_DISPATCHES, executeNamedWorkflow, formatDu
 import { printResumeCommand } from "../display.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
-import { adapterMap } from "../provider.js";
+import { providerMap } from "../provider.js";
 import { text } from "../text.js";
 export async function executeWorkflow(workspace, options) {
     requireCurrentSchema(workspace);
@@ -13,7 +13,7 @@ export async function executeWorkflow(workspace, options) {
     const sessionId = text(options.sessionId);
     const creating = !startPrepared && (options.action === "start" || (once && sessionId === null));
     const maxDispatches = options.maxDispatches === undefined ? DEFAULT_MAX_DISPATCHES : options.maxDispatches;
-    const runner = options.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+    const runner = options.runner ?? cliHooks.runner ?? new AgentToolRunner(providerMap());
     runner.itemProgress = options.itemProgress === true;
     const result = await executeNamedWorkflow(workspace, {
         workflowId: creating || startPrepared ? (options.workflowId ?? null) : null,

package/dist/commands/init.d.ts

@@ -1,5 +1,5 @@
 import type { ModelCatalog } from "@nodeint/migent-adapters";
-import { type AgentAdapter } from "@nodeint/migent-kernel";
+import { type Provider } from "@nodeint/migent-kernel";
 import { type RunCommand, type Which } from "../provider.js";
 export declare const PRESETS: readonly ["implement", "plan"];
 export interface ModelChoice {
@@ -8,7 +8,7 @@ export interface ModelChoice {
     options: Record<string, string>;
 }
 export interface Prompter {
-    selectProvider(rows: ReadonlyArray<readonly [string, string | null, AgentAdapter]>, message: string): string | Promise<string>;
+    selectProvider(rows: ReadonlyArray<readonly [string, string | null, Provider]>, message: string): string | Promise<string>;
     selectModel(provider: string, catalog: ModelCatalog, message: string): string | Promise<string>;
     selectOption(name: string, values: readonly string[], allowDefault: boolean): string | Promise<string>;
     confirm(message: string): boolean | Promise<boolean>;
@@ -21,7 +21,7 @@ export declare function runInit(workspace: string, options?: {
     presetExplicit?: boolean;
     skill?: boolean;
     interactive?: boolean;
-    adapters?: Record<string, AgentAdapter> | null;
+    providers?: Record<string, Provider> | null;
     which?: Which | null;
     prompter?: Prompter | null;
     runCommand?: RunCommand | null;

package/dist/commands/init.js

@@ -8,7 +8,7 @@ import { printAlreadyInitialized, printCreated, printError, printInitConflicts,
 import { cliHooks } from "../hooks.js";
 import { runDoctor } from "./doctor.js";
 import { installSkill } from "./skill.js";
-import { acceptedOptions, adapterMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireAdapter, runProviderCommand, } from "../provider.js";
+import { acceptedOptions, providerMap, asCatalog, detected, knownModel, loadCatalog, loadOptionValues, parseOptions, requireProvider, runProviderCommand, } from "../provider.js";
 export const PRESETS = ["implement", "plan"];
 export async function runInit(workspace, options = {}) {
     const provider = options.provider ?? null;
@@ -16,7 +16,7 @@ export async function runInit(workspace, options = {}) {
     const preset = options.preset ?? "implement";
     const skill = options.skill === true;
     const interactive = options.interactive ?? false;
-    const chosen = options.adapters ?? adapterMap();
+    const chosen = options.providers ?? providerMap();
     const resolve = options.which ?? cliHooks.which ?? whichSync;
     const prompt = options.prompter ?? new ClackPrompter();
     const execute = options.runCommand ?? runProviderCommand;
@@ -94,42 +94,42 @@ export async function runInit(workspace, options = {}) {
     }
     return 0;
 }
-function writeDoctorProblems(workspace, adapters, which) {
-    const problems = diagnose(workspace, { adapters, which }).flatMap((check) => check.problems);
+function writeDoctorProblems(workspace, providers, which) {
+    const problems = diagnose(workspace, { providers, which }).flatMap((check) => check.problems);
     if (problems.length === 0)
         return;
     process.stderr.write("Doctor reported problems:\n");
     for (const problem of problems)
         process.stderr.write(`${problem}\n`);
 }
-async function choices(adapters, which, prompt, args) {
+async function choices(providers, which, prompt, args) {
     let provider = args.provider;
     let model = args.model;
     let stored;
     if (provider === null) {
-        const rows = detected(adapters, which);
+        const rows = detected(providers, which);
         provider = await prompt.selectProvider(rows, "Default provider");
-        const adapter = adapters[provider];
-        if (adapter === undefined)
+        const impl = providers[provider];
+        if (impl === undefined)
             throw new ConfigurationError(`Unknown provider: ${provider}.`);
-        const catalog = await loadCatalog(adapter, which, args.runCommand);
+        const catalog = await loadCatalog(impl, which, args.runCommand);
         model = await prompt.selectModel(provider, catalog, "Model");
-        stored = await promptOptions(adapter, model, catalog, which, args.runCommand, prompt);
+        stored = await promptOptions(impl, model, catalog, which, args.runCommand, prompt);
     }
     else {
-        const adapter = requireAdapter(adapters, provider);
+        const impl = requireProvider(providers, provider);
         if (model === null)
             throw new ConfigurationError("Model is required.");
-        const catalog = await loadCatalog(adapter, which, args.runCommand);
+        const catalog = await loadCatalog(impl, which, args.runCommand);
         model = knownModel(model, catalog);
-        stored = await acceptedOptions(adapter, model, catalog, which, args.runCommand, args.options);
+        stored = await acceptedOptions(impl, model, catalog, which, args.runCommand, args.options);
     }
     if (model.trim() === "")
         throw new ConfigurationError("Model is required.");
     const primary = { provider, model: model.trim(), options: stored };
     return primary;
 }
-function classify(workspace, adapters, which) {
+function classify(workspace, providers, which) {
     const root = path.join(workspace, ".migent");
     const config = path.join(root, "config.yaml");
     const workflows = path.join(root, "workflows");
@@ -154,7 +154,7 @@ function classify(workspace, adapters, which) {
         ? readdirSync(workflows).filter((name) => name.endsWith(".yaml") && isFile(path.join(workflows, name)))
         : [];
     if (isFile(config) && yamlFiles.length > 0) {
-        const checks = diagnose(workspace, { adapters, which });
+        const checks = diagnose(workspace, { providers, which });
         const byName = new Map(checks.map((check) => [check.name, check]));
         if (byName.get("config")?.ok && byName.get("workflows")?.ok)
             return { state: "ready", conflicts: [] };
@@ -236,12 +236,12 @@ function renderWorkflow(preset) {
         "    from_stage: plan\n" +
         "    artifact: plan.md\n");
 }
-async function promptOptions(adapter, model, catalog, which, runCommand, prompt) {
+async function promptOptions(provider, model, catalog, which, runCommand, prompt) {
     const stored = {};
-    for (const spec of providerOptions(adapter)) {
+    for (const spec of providerOptions(provider)) {
         if (!spec.prompt)
             continue;
-        const values = await loadOptionValues(adapter, spec.name, model, catalog, which, runCommand);
+        const values = await loadOptionValues(provider, spec.name, model, catalog, which, runCommand);
         if (values === null || values.length === 0)
             continue;
         const picked = await prompt.selectOption(spec.name, values, spec.allowDefault ?? false);
@@ -250,8 +250,8 @@ async function promptOptions(adapter, model, catalog, which, runCommand, prompt)
     }
     return stored;
 }
-function providerOptions(adapter) {
-    return asCatalog(adapter).providerOptions();
+function providerOptions(provider) {
+    return asCatalog(provider).providerOptions();
 }
 class ClackPrompter {
     async selectProvider(rows, message) {

package/dist/commands/prepare.js

@@ -5,6 +5,7 @@ export function prepareWorkflowSession(workspace, sessionId, workflowId, priorSe
     const id = createPreparedSession(workspace, sessionId, workflowId, priorSessionId);
     const payload = {
         session_id: id,
+        title: sessionId.trim(),
         status: "prepared",
         task_path: relativeTaskPath(id),
     };

package/dist/commands/provider.d.ts

@@ -0,0 +1,10 @@
+import { type Provider } from "@nodeint/migent-kernel";
+import { type ProviderRow } from "../display.js";
+import { type RunCommand, type Which } from "../provider.js";
+export declare function collectProviders(providers: Record<string, Provider>, which: Which, runCommand: RunCommand): Promise<ProviderRow[]>;
+export declare function runProviderList(options?: {
+    asJson?: boolean;
+    providers?: Record<string, Provider> | null;
+    which?: Which | null;
+    runCommand?: RunCommand | null;
+}): Promise<number>;

package/dist/commands/provider.js

@@ -0,0 +1,77 @@
+import { whichSync } from "@nodeint/migent-kernel";
+import { printProviders } from "../display.js";
+import { cliHooks } from "../hooks.js";
+import { providerMap, loadCatalog, runProviderCommand, } from "../provider.js";
+function mapProviderOption(opt) {
+    return {
+        name: opt.name,
+        prompt: opt.prompt === true,
+        allow_default: opt.allowDefault === true,
+        overridable: opt.overridable === true,
+    };
+}
+function getProviderOptions(provider) {
+    const candidate = provider;
+    if (typeof candidate.providerOptions === "function") {
+        return candidate.providerOptions().map(mapProviderOption);
+    }
+    return [];
+}
+export async function collectProviders(providers, which, runCommand) {
+    // A provider without a default client has no CLI of its own to probe.
+    const names = Object.keys(providers).filter((name) => providers[name].requiresClient !== true).sort();
+    const rows = [];
+    for (const name of names) {
+        const provider = providers[name];
+        const path = which(provider.command);
+        const options = getProviderOptions(provider);
+        const problems = [];
+        let models = [];
+        let default_model = null;
+        if (path === null) {
+            problems.push(`${provider.command} is not on PATH.`);
+        }
+        else {
+            try {
+                const catalog = await loadCatalog(provider, which, runCommand);
+                models = [...catalog.ids];
+                default_model = catalog.defaultId;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                problems.push(message);
+            }
+        }
+        rows.push({
+            name,
+            command: provider.command,
+            path,
+            available: path !== null,
+            models,
+            default_model,
+            options,
+            problems,
+        });
+    }
+    return rows;
+}
+function providerPayload(rows) {
+    return {
+        ok: rows.every((row) => row.problems.length === 0),
+        providers: rows.map((row) => ({ ...row })),
+    };
+}
+export async function runProviderList(options = {}) {
+    const providers = options.providers ?? providerMap();
+    const which = options.which ?? cliHooks.which ?? whichSync;
+    const runCommand = options.runCommand ?? cliHooks.runCommand ?? runProviderCommand;
+    const rows = await collectProviders(providers, which, runCommand);
+    if (options.asJson) {
+        process.stdout.write(`${JSON.stringify(providerPayload(rows))}\n`);
+    }
+    else {
+        printProviders(rows);
+    }
+    const hasAnyModels = rows.some((row) => row.models.length > 0);
+    return hasAnyModels ? 0 : 1;
+}