@nodeint/migent 0.1.5 → 0.1.7

package/dist/commands/config.js

@@ -1,12 +1,12 @@
 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, resolveStageSpec, setRoleOptions, upsertModel, whichSync, } from "@nodeint/migent-kernel";
+import { ConfigEditError, ConfigurationError, assignRoles, describeChange, diagnose, inspectConfig, loadModelTarget, loadWorkflowCatalog, loadYamlMapping, matchingModelName, patchConfigText, placeRoleModel, isRoleStage, resolveStageSpec, setRoleOptions, 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");
@@ -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,10 +312,12 @@ 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)) {
+            if (!isRoleStage(stage))
+                continue;
             let beforeTarget;
             let afterTarget;
             try {
@@ -329,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]);
@@ -384,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.d.ts

@@ -5,11 +5,10 @@ export interface ExecuteWorkflowOptions {
     task?: string | null;
     sessionId?: string | null;
     priorSessionId?: string | null;
-    maxAttempts?: number | null;
     maxDispatches?: number | null;
+    continueFailed?: boolean;
     stageId?: string | null;
     runner?: AgentToolRunner | null;
-    verbose?: boolean;
     itemProgress?: boolean;
     startPrepared?: boolean;
     refreshWorkflow?: boolean;

package/dist/commands/execute.js

@@ -1,7 +1,10 @@
-import { AgentToolRunner, DEFAULT_MAX_DISPATCHES, executeNamedWorkflow, } from "@nodeint/migent-kernel";
+import { readdirSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { AgentToolRunner, DEFAULT_MAX_DISPATCHES, executeNamedWorkflow, formatDuration, log, } from "@nodeint/migent-kernel";
+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);
@@ -9,9 +12,8 @@ export async function executeWorkflow(workspace, options) {
     const startPrepared = options.startPrepared === true;
     const sessionId = text(options.sessionId);
     const creating = !startPrepared && (options.action === "start" || (once && sessionId === null));
-    const maxAttempts = options.maxAttempts === undefined ? 3 : options.maxAttempts;
     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,
@@ -19,37 +21,104 @@ export async function executeWorkflow(workspace, options) {
         sessionId: creating ? null : sessionId,
         priorSessionId: options.priorSessionId ?? null,
         startPrepared,
-        maxAttempts: once ? null : maxAttempts,
         maxDispatches: once ? null : maxDispatches,
+        continueFailed: options.continueFailed === true,
         stageId: options.stageId ?? null,
         once,
         resetRevisions: options.action === "continue",
         refreshWorkflow: options.refreshWorkflow === true,
         reply: options.reply ?? null,
     }, runner);
-    printResult(result, options.verbose === true);
-    if (result.stopReason === "retry_exhausted" ||
-        result.stopReason === "revisions_exhausted" ||
-        result.stopReason === "dispatch_limit" ||
-        result.stopReason === "verify_exhausted") {
-        process.stderr.write(`Resume with: migent session continue ${result.sessionId}\n`);
-    }
+    printResult(workspace, result);
+    printResumeHint(result);
     return result.code;
 }
-const INSPECT_EXIT_CODES = new Set([1, 3, 6]);
-function printResult(result, verbose) {
-    const payload = {
-        session_id: result.sessionId,
-        session_status: result.status,
-        stop_reason: result.stopReason,
-        latest_decision: result.latestDecision,
-        outputs: result.outputs,
-    };
+function printResumeHint(result) {
+    if (result.sessionId === "" || result.status === "completed" || result.stopReason === "completed")
+        return;
+    if (result.stopReason === "configuration")
+        return;
+    printResumeCommand(result.sessionId);
+}
+const INSPECT_EXIT_CODES = new Set([1, 3, 6, 8]);
+function printResult(workspace, result) {
+    if (result.status === "completed" || result.stopReason === "completed") {
+        const duration = sessionDurationLabel(workspace, result.sessionId);
+        log(duration === null ? "completed" : `completed · ${duration}`);
+        for (const filePath of artifactPaths(workspace, result.sessionId, result.outputs)) {
+            log(`artifact: ${filePath}`);
+        }
+        return;
+    }
     if (INSPECT_EXIT_CODES.has(result.code) && result.latestExecutionId) {
-        payload.latest_execution_id = result.latestExecutionId;
-        payload.response_path = `executions/${result.latestExecutionId}/response.md`;
+        log(`response: executions/${result.latestExecutionId}/response.md`);
+    }
+    if (result.code === 7 && result.latestExecutionId) {
+        log(`verify: executions/${result.latestExecutionId}/turns/01/verify.md`);
+    }
+}
+function artifactPaths(workspace, sessionId, outputs) {
+    if (sessionId === "")
+        return [];
+    const sessionDir = path.resolve(workspace, ".migent", "sessions", sessionId);
+    const paths = [];
+    for (const [name, value] of Object.entries(outputs)) {
+        const record = isRecord(value) ? value : {};
+        const relative = typeof record.path === "string" && record.path !== "" ? record.path : path.join("outputs", name);
+        paths.push(absoluteFromRoot(path.resolve(sessionDir, relative)));
+    }
+    return paths;
+}
+function absoluteFromRoot(target) {
+    try {
+        return realpathSync(target);
+    }
+    catch {
+        return path.resolve(target);
     }
-    if (verbose)
-        payload.stages = result.stages;
-    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+function sessionDurationLabel(workspace, sessionId) {
+    if (sessionId === "")
+        return null;
+    const executions = path.join(workspace, ".migent", "sessions", sessionId, "executions");
+    let names;
+    try {
+        names = readdirSync(executions);
+    }
+    catch {
+        return null;
+    }
+    let total = 0;
+    let counted = false;
+    for (const name of names) {
+        const elapsed = executionElapsedMs(path.join(executions, name, "execution.json"));
+        if (elapsed === null)
+            continue;
+        total += elapsed;
+        counted = true;
+    }
+    return counted ? formatDuration(total) : null;
+}
+function executionElapsedMs(filePath) {
+    try {
+        const metadata = JSON.parse(readFileSync(filePath, "utf8"));
+        if (!isRecord(metadata))
+            return null;
+        const started = parsedTime(metadata.created_at);
+        if (started === null)
+            return null;
+        return (parsedTime(metadata.completed_at) ?? Date.now()) - started;
+    }
+    catch {
+        return null;
+    }
+}
+function parsedTime(value) {
+    if (typeof value !== "string" || value === "")
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }

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>;