@nodeint/migent 0.1.6 → 0.1.8

package/dist/commands/config.js

@@ -1,25 +1,30 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { confirm as clackConfirm, isCancel, select as clackSelect, text as clackText } from "@clack/prompts";
-import { ConfigEditError, ConfigurationError, assignRoles, describeChange, diagnose, inspectConfig, loadModelTarget, loadWorkflowCatalog, loadYamlMapping, matchingModelName, patchConfigText, placeRoleModel, isRoleStage, resolveStageSpec, setRoleOptions, upsertModel, whichSync, } from "@nodeint/migent-kernel";
+import { ConfigEditError, ConfigurationError, LOCAL_CONFIG_FILE, assignRoles, configPath, describeChange, diagnose, hasLocalConfig, inspectConfig, loadModelTarget, loadWorkflowCatalog, loadWorkspaceConfig, loadYamlMapping, matchingModelName, patchConfigText, placeRoleModel, isRoleStage, resolveStageSpec, setRoleOptions, stringifyConfig, upsertModel, whichSync, } from "@nodeint/migent-kernel";
 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");
 export function runConfigShow(workspace) {
-    const text = readFileSync(path.join(workspace, ".migent", "config.yaml"), "utf8");
-    process.stdout.write(text);
+    if (!hasLocalConfig(workspace)) {
+        process.stdout.write(readFileSync(configPath(workspace), "utf8"));
+        return 0;
+    }
+    process.stdout.write(stringifyConfig(loadWorkspaceConfig(workspace)));
+    process.stderr.write(`Merged with .migent/${LOCAL_CONFIG_FILE}.
+`);
     return 0;
 }
 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 +44,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 +74,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 +83,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 +103,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 +124,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 +137,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 +145,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 +160,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 +169,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 +229,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 +242,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) {
@@ -262,7 +267,8 @@ async function confirmAndCommit(workspace, change, prompter, asJson, which) {
     return commit(workspace, change, { asJson, which, echo: false });
 }
 async function commit(workspace, change, args) {
-    const filePath = path.join(workspace, ".migent", "config.yaml");
+    // Edits patch config.yaml only, so config.local.yaml values never reach the committed file.
+    const filePath = configPath(workspace);
     const original = readFileSync(filePath, "utf8");
     const updated = patchConfigText(original, change.config);
     if (updated === original) {
@@ -274,7 +280,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 +289,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 +300,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 +318,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 +337,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 +392,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));
@@ -395,7 +401,8 @@ async function selectProvider(prompter, adapters, which, message, defaultValue)
 }
 function loaded(workspace) {
     requireCurrentSchema(workspace);
-    const config = loadYamlMapping(path.join(workspace, ".migent", "config.yaml"));
+    // Base file only: this snapshot feeds validation and patching of config.yaml.
+    const config = loadYamlMapping(configPath(workspace));
     const workflows = Object.values(loadWorkflowCatalog(workspace).documents);
     return [config, workflows, inspectConfig(config, workflows)];
 }

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
@@ -21,6 +21,7 @@ function payload(checks) {
             ok: check.ok,
             items: [...check.items],
             problems: [...check.problems],
+            warnings: [...check.warnings],
         })),
     };
 }

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: [] };
@@ -168,7 +168,7 @@ function writeProject(workspace, preset, primary) {
     writeFileSync(path.join(root, "config.yaml"), renderConfig(preset, primary), "utf8");
     const workflowName = `${preset}.yaml`;
     writeFileSync(path.join(workflows, workflowName), renderWorkflow(preset), "utf8");
-    writeFileSync(path.join(root, ".gitignore"), "sessions/\n", "utf8");
+    writeFileSync(path.join(root, ".gitignore"), "sessions/\nconfig.local.yaml\n", "utf8");
     return [".migent/config.yaml", `.migent/workflows/${workflowName}`, ".migent/.gitignore"];
 }
 function renderConfig(preset, primary) {
@@ -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;
+}

package/dist/commands/sessions.js

@@ -130,6 +130,7 @@ function sessionJson(row) {
     const fields = sessionFields(row);
     return {
         session: fields.session,
+        title: fields.title,
         workflow: fields.workflow,
         status: fields.status,
         execution: fields.execution,

package/dist/display.d.ts

@@ -11,3 +11,19 @@ export declare function printAgent(result: Record<string, unknown>, role: string
 export declare function printWatchSnapshot(snapshot: Record<string, unknown>): void;
 export declare function printWatchEvent(event: Record<string, unknown>): void;
 export declare function formatWatchTimestamp(timestamp: unknown): string;
+export interface ProviderRow {
+    name: string;
+    command: string;
+    path: string | null;
+    available: boolean;
+    models: string[];
+    default_model: string | null;
+    options: Array<{
+        name: string;
+        prompt: boolean;
+        allow_default: boolean;
+        overridable: boolean;
+    }>;
+    problems: string[];
+}
+export declare function printProviders(rows: readonly ProviderRow[]): void;