@nodeint/migent 0.1.5 → 0.1.7

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

@@ -1,8 +1,5 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { listSessionMetrics, listSessionRows, sessionMetrics, ConfigurationError } from "@nodeint/migent-kernel";
+import { listSealedMetrics, listSessionRows, readSealedMetrics, ConfigurationError } from "@nodeint/migent-kernel";
 import { printError, printSessions } from "../display.js";
-import { adapterMap } from "../provider.js";
 import { SESSION_COLUMN, sessionFields } from "../session-row.js";
 import { optionalText } from "../text.js";
 import { followSession } from "./watch.js";
@@ -36,9 +33,8 @@ export function runSessionMetrics(workspace, session, options) {
         printError("List filters cannot be combined with a session.");
         return 2;
     }
-    const adapters = adapterMap();
     if (sessionId === null) {
-        const rows = listSessionMetrics(workspace, adapters, {
+        const rows = listSealedMetrics(workspace, {
             workflow: selection.workflow ?? null,
             status: selection.status ?? null,
             limit: selection.limit ?? null,
@@ -47,12 +43,16 @@ export function runSessionMetrics(workspace, session, options) {
             process.stdout.write(`${JSON.stringify(row)}\n`);
         return 0;
     }
-    const eventsPath = path.join(workspace, ".migent", "sessions", sessionId, "events.jsonl");
-    if (!existsSync(eventsPath)) {
-        printError(`No events found for session: ${sessionId}`);
+    const sealed = readSealedMetrics(workspace, sessionId);
+    if (sealed.state === "missing") {
+        printError(`No metrics for session: ${sessionId}. Metrics are recorded when a workflow session completes.`);
         return 2;
     }
-    process.stdout.write(`${JSON.stringify(sessionMetrics(workspace, sessionId, adapters))}\n`);
+    if (sealed.state === "corrupt") {
+        printError(`metrics.json for session ${sessionId} is not valid JSON.`);
+        return 2;
+    }
+    process.stdout.write(`${JSON.stringify(sealed.metrics)}\n`);
     return 0;
 }
 export async function runSessions(workspace, session, options) {
@@ -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/commands/skill.js

@@ -7,7 +7,14 @@ import { isDirectory, isFile } from "../fs-utils.js";
 const SKILL_RELATIVE = path.join(".agents", "skills", "migent");
 const STATE_FILENAME = ".migent-template.json";
 const TEMPLATE_VERSION = 1;
-const MANAGED = ["SKILL.md", "references/schema-config.yaml", "references/schema-workflow.yaml"];
+const MANAGED = [
+    "SKILL.md",
+    "references/schema-config.yaml",
+    "references/schema-workflow.yaml",
+    "references/sessions.md",
+    "references/inspect.md",
+    "references/config.md",
+];
 export function installSkill(workspace) {
     const skillDirectory = path.join(workspace, SKILL_RELATIVE);
     if (existsSync(skillDirectory)) {

package/dist/display.d.ts

@@ -1,6 +1,7 @@
 import type { Check } from "@nodeint/migent-kernel";
 export declare function printError(message: string): void;
 export declare function printNotice(message: string): void;
+export declare function printResumeCommand(sessionId: string): void;
 export declare function printCreated(paths: readonly string[], nextCommand: string): void;
 export declare function printAlreadyInitialized(): void;
 export declare function printInitConflicts(paths: readonly string[]): void;
@@ -10,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;

package/dist/display.js

@@ -12,6 +12,9 @@ export function printNotice(message) {
     const prefix = tty ? pc.cyan(pc.bold("[migent] ")) : "[migent] ";
     process.stderr.write(`${prefix}${message}\n`);
 }
+export function printResumeCommand(sessionId) {
+    process.stderr.write(`Resume with:\nmigent session continue ${sessionId}\n`);
+}
 export function printCreated(paths, nextCommand) {
     process.stdout.write("Created:\n");
     for (const filePath of paths)
@@ -47,7 +50,8 @@ export function printSessions(rows) {
     }
     for (const row of rows) {
         const fields = sessionFields(row);
-        process.stdout.write(`${fields.session}  ${fields.workflow}  ${fields.status}  ${fields.execution}  ${fields.decision}  ${fields.outputs}  ${fields.task}\n`);
+        const identity = fields.title !== "" && fields.title !== fields.session ? `${fields.title}  ${fields.session}` : fields.session;
+        process.stdout.write(`${identity}  ${fields.workflow}  ${fields.status}  ${fields.execution}  ${fields.decision}  ${fields.outputs}  ${fields.task}\n`);
     }
 }
 export function printAgent(result, role, provider, model) {
@@ -70,6 +74,10 @@ export function printWatchSnapshot(snapshot) {
         ["session_id", String(snapshot.session_id ?? "--")],
         ["status", String(snapshot.status ?? "unknown")],
     ];
+    const title = snapshot.title;
+    if (typeof title === "string" && title !== "" && title !== lines[0]?.[1]) {
+        lines.splice(1, 0, ["title", title]);
+    }
     if (typeof snapshot.workflow_id === "string" && snapshot.workflow_id) {
         lines.push(["workflow", snapshot.workflow_id]);
     }
@@ -130,6 +138,40 @@ export function formatWatchTimestamp(timestamp) {
         return timestamp.trim();
     return parsed.toISOString().replace("T", " ").replace(/\.\d+Z$/, "+00:00").replace("Z", "+00:00");
 }
+export function printProviders(rows) {
+    const tty = Boolean(process.stdout.isTTY);
+    for (const row of rows) {
+        const ok = row.problems.length === 0 && row.models.length > 0;
+        const status = ok ? (tty ? pc.green("ok") : "ok") : tty ? pc.red("failed") : "failed";
+        process.stdout.write(`${row.name.padEnd(12)}${status}\n`);
+        if (row.path !== null) {
+            const line = `  path: ${row.path}`;
+            process.stdout.write(`${tty ? pc.dim(line) : line}\n`);
+        }
+        else {
+            const line = `  path: not found`;
+            process.stdout.write(`${tty ? pc.dim(line) : line}\n`);
+        }
+        if (row.models.length > 0) {
+            process.stdout.write(`  models:\n`);
+            for (const model of row.models) {
+                const marked = model === row.default_model ? `${model} (default)` : model;
+                const line = `    ${marked}`;
+                process.stdout.write(`${tty ? pc.dim(line) : line}\n`);
+            }
+        }
+        if (row.options.length > 0) {
+            process.stdout.write(`  options:\n`);
+            for (const opt of row.options) {
+                const line = `    ${opt.name}`;
+                process.stdout.write(`${tty ? pc.dim(line) : line}\n`);
+            }
+        }
+        for (const problem of row.problems) {
+            process.stdout.write(`  ${problem}\n`);
+        }
+    }
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/exits.d.ts

@@ -1,10 +1,12 @@
 export declare const EXIT_OK = 0;
 export declare const EXIT_BLOCKED = 1;
 export declare const EXIT_CONFIG = 2;
-export declare const EXIT_ATTEMPTS = 3;
+export declare const EXIT_STAGE_FAILED = 3;
+export declare const EXIT_QUOTA = 8;
 export declare const EXIT_REVISIONS = 4;
 export declare const EXIT_DISPATCHES = 5;
 export declare const EXIT_VERIFY = 6;
+export declare const EXIT_VERIFY_FAILED = 7;
 export declare const EXIT_CANCELLED = 130;
 export declare const LOOP_EXITS: string[];
 export declare const STAGE_EXITS: string[];

package/dist/exits.js

@@ -1,26 +1,33 @@
 export const EXIT_OK = 0;
 export const EXIT_BLOCKED = 1;
 export const EXIT_CONFIG = 2;
-export const EXIT_ATTEMPTS = 3;
+export const EXIT_STAGE_FAILED = 3;
+export const EXIT_QUOTA = 8;
 export const EXIT_REVISIONS = 4;
 export const EXIT_DISPATCHES = 5;
 export const EXIT_VERIFY = 6;
+export const EXIT_VERIFY_FAILED = 7;
 export const EXIT_CANCELLED = 130;
 export const LOOP_EXITS = [
     `Exit ${EXIT_OK} when the session is completed.`,
     `Exit ${EXIT_BLOCKED} when the session is blocked. session continue runs that stage again.`,
     `Exit ${EXIT_CONFIG} on a configuration error.`,
-    `Exit ${EXIT_ATTEMPTS} when --attempts is spent. The session stays active.`,
+    `Exit ${EXIT_STAGE_FAILED} when a stage fails and the command does not wait. The session stays active.`,
+    `Exit ${EXIT_QUOTA} when --once or --stage hits a provider quota and does not wait. The session stays active.`,
     `Exit ${EXIT_REVISIONS} when a route would exceed max_revisions. The session stays active.`,
     `Exit ${EXIT_DISPATCHES} when --max-dispatches is spent. The session stays active.`,
     `Exit ${EXIT_VERIFY} when verify fails max_verify times. The session stays active.`,
+    `Exit ${EXIT_VERIFY_FAILED} when a stage with no role fails verify. The session stays active.`,
     `Exit ${EXIT_CANCELLED} when cancelled. session continue resumes that execution.`,
 ];
 export const STAGE_EXITS = [
     `Exit ${EXIT_OK} when the stage outcome is complete, or the session is already completed.`,
     `Exit ${EXIT_BLOCKED} when the stage is not complete, or the session is blocked.`,
     `Exit ${EXIT_CONFIG} on a configuration error.`,
+    `Exit ${EXIT_STAGE_FAILED} when a non-continue --once or --stage finds a failed stage with no resume marker.`,
+    `Exit ${EXIT_QUOTA} when --once or --stage hits a provider quota and does not wait.`,
     `Exit ${EXIT_REVISIONS} when a route would exceed max_revisions. The session stays active.`,
     `Exit ${EXIT_VERIFY} when verify fails max_verify times. The session stays active.`,
+    `Exit ${EXIT_VERIFY_FAILED} when a stage with no role fails verify. The session stays active.`,
     `Exit ${EXIT_CANCELLED} when cancelled. session continue resumes that execution.`,
 ];

package/dist/hooks.d.ts

@@ -1,6 +1,8 @@
 import type { AgentToolRunner } from "@nodeint/migent-kernel";
+import type { RunCommand } from "./provider.js";
 /** Test seams. Production leaves both null. */
 export declare const cliHooks: {
     which: ((command: string) => string | null) | null;
     runner: AgentToolRunner | null;
+    runCommand: RunCommand | null;
 };

package/dist/hooks.js

@@ -2,4 +2,5 @@
 export const cliHooks = {
     which: null,
     runner: null,
+    runCommand: null,
 };

package/dist/index.js

@@ -36,6 +36,7 @@ export async function main(argv = process.argv.slice(2), cwd) {
         setInvocationCwd(undefined);
         cliHooks.which = null;
         cliHooks.runner = null;
+        cliHooks.runCommand = null;
     }
 }
 function isDirectRun() {

package/dist/migrate.d.ts

@@ -1,8 +1,8 @@
-import { type MigrationAdapter } from "@nodeint/migent-kernel";
+import { type MigrationProvider } from "@nodeint/migent-kernel";
 export declare function requireCurrentSchema(workspace: string): void;
 export declare function runMigrate(workspace: string, options?: {
     assumeYes?: boolean;
     confirm?: ((message: string) => boolean | Promise<boolean>) | null;
-    adapters?: Record<string, MigrationAdapter> | null;
+    providers?: Record<string, MigrationProvider> | null;
 }): Promise<number>;
-export declare function migrationAdapters(adapters?: Record<string, unknown>): Record<string, MigrationAdapter>;
+export declare function migrationProviders(providers?: Record<string, unknown>): Record<string, MigrationProvider>;

package/dist/migrate.js

@@ -4,29 +4,31 @@ import { confirm as clackConfirm, isCancel } from "@clack/prompts";
 import { SCHEMA_VERSION, documentVersion, loadYamlMapping, migrateConfig, migrateWorkflow, patchConfigText, patchWorkflowText, workflowsDirectory, ConfigurationError, } from "@nodeint/migent-kernel";
 import { printError, printNotice } from "./display.js";
 import { isDirectory, isFile } from "./fs-utils.js";
-import { adapterMap } from "./provider.js";
-const OUTDATED = "Schema is outdated. Run `migent migrate` to update.";
+import { providerMap } from "./provider.js";
+function versionList(entries) {
+    const width = Math.max(...entries.map(([label]) => label.length));
+    return entries.map(([label, version]) => `  ${label.padEnd(width)}  v${version}`).join("\n");
+}
 export function requireCurrentSchema(workspace) {
     const newer = [];
-    let outdated = false;
+    const older = [];
     for (const [label, filePath] of schemaFiles(workspace)) {
         const version = storedVersion(filePath);
         if (version === null || version === SCHEMA_VERSION)
             continue;
-        if (version > SCHEMA_VERSION) {
-            newer.push(`${label} schema_version ${version} is newer than this Migent (${SCHEMA_VERSION}).`);
-            continue;
-        }
-        outdated = true;
+        (version > SCHEMA_VERSION ? newer : older).push([label, version]);
+    }
+    if (older.length > 0) {
+        throw new ConfigurationError(`Schema is outdated (this Migent uses v${SCHEMA_VERSION}).\n${versionList(older)}\n\n` +
+            "Run `migent migrate` to update.");
+    }
+    if (newer.length > 0) {
+        throw new ConfigurationError(`Schema is newer than this Migent supports (v${SCHEMA_VERSION}).\n${versionList(newer)}`);
     }
-    if (outdated)
-        throw new ConfigurationError(OUTDATED);
-    if (newer.length > 0)
-        throw new ConfigurationError(newer.join(" "));
 }
 export async function runMigrate(workspace, options = {}) {
-    const adapters = options.adapters ?? migrationAdapters();
-    const rewrites = pendingRewrites(workspace, adapters);
+    const providers = options.providers ?? migrationProviders();
+    const rewrites = pendingRewrites(workspace, providers);
     if (rewrites.length === 0) {
         process.stdout.write("Schema is current.\n");
         return 0;
@@ -43,10 +45,10 @@ export async function runMigrate(workspace, options = {}) {
     process.stdout.write(`Upgraded schema to version ${SCHEMA_VERSION}.\n`);
     return 0;
 }
-export function migrationAdapters(adapters = adapterMap()) {
+export function migrationProviders(providers = providerMap()) {
     const mapped = {};
-    for (const [name, adapter] of Object.entries(adapters)) {
-        const candidate = adapter;
+    for (const [name, provider] of Object.entries(providers)) {
+        const candidate = provider;
         mapped[name] = {
             modelMigrations: candidate.modelMigrations ?? {},
             roleMigrations: candidate.roleMigrations ?? {},
@@ -74,17 +76,17 @@ async function accepted(confirm) {
     }
     return true;
 }
-function pendingRewrites(workspace, adapters) {
+function pendingRewrites(workspace, providers) {
     const configPath = path.join(workspace, ".migent", "config.yaml");
     if (!isFile(configPath))
         return [];
-    const [config, configRewrite] = configRewriteOf(configPath, adapters);
+    const [config, configRewrite] = configRewriteOf(configPath, providers);
     if (config === null)
         return [];
     const rewrites = [];
     if (configRewrite !== null)
         rewrites.push(configRewrite);
-    rewrites.push(...workflowRewrites(workspace, config, adapters));
+    rewrites.push(...workflowRewrites(workspace, config, providers));
     return rewrites;
 }
 function schemaFiles(workspace) {
@@ -109,7 +111,7 @@ function storedVersion(filePath) {
         return null;
     }
 }
-function configRewriteOf(filePath, adapters) {
+function configRewriteOf(filePath, providers) {
     const original = readFileSync(filePath, "utf8");
     let parsed;
     try {
@@ -121,7 +123,7 @@ function configRewriteOf(filePath, adapters) {
     const updated = structuredClone(parsed);
     let notes;
     try {
-        notes = migrateConfig(updated, adapters);
+        notes = migrateConfig(updated, providers);
     }
     catch (error) {
         if (error instanceof ConfigurationError)
@@ -136,7 +138,7 @@ function configRewriteOf(filePath, adapters) {
     const labeled = notes.map((note) => note.startsWith("schema_version") ? `Migrated .migent/config.yaml ${note}` : note);
     return [updated, { path: filePath, text: rewritten, notes: labeled }];
 }
-function workflowRewrites(workspace, config, adapters) {
+function workflowRewrites(workspace, config, providers) {
     const directory = workflowsDirectory(workspace);
     if (!isDirectory(directory))
         return [];
@@ -156,7 +158,7 @@ function workflowRewrites(workspace, config, adapters) {
         const updated = structuredClone(parsed);
         let changed;
         try {
-            changed = migrateWorkflow(updated, config, adapters);
+            changed = migrateWorkflow(updated, config, providers);
         }
         catch (error) {
             if (error instanceof ConfigurationError)