@nodeint/migent 0.1.5 → 0.1.7

package/dist/program.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { Command } from "commander";
-import { ConfigurationError, DEFAULT_MAX_DISPATCHES } from "@nodeint/migent-kernel";
-import { dispatchAgent } from "./commands/agent.js";
+import { ConfigurationError, DEFAULT_MAX_DISPATCHES, requireAgentSession } from "@nodeint/migent-kernel";
+import { continueAgent, dispatchAgent } from "./commands/agent.js";
 import { runConfigModel, runConfigRole, runConfigShow } from "./commands/config.js";
 import { runDoctor } from "./commands/doctor.js";
 import { executeWorkflow } from "./commands/execute.js";
@@ -11,6 +11,7 @@ import { runInit } from "./commands/init.js";
 import { runSessionMetrics, runSessions } from "./commands/sessions.js";
 import { parsePort, runServiceStart, runServiceStatus, runServiceStop } from "./commands/service.js";
 import { installSkill, updateSkill } from "./commands/skill.js";
+import { runProviderList } from "./commands/provider.js";
 import { runRegister, runRemove, runWorkspaceList } from "./commands/workspace-registry.js";
 import { printError } from "./display.js";
 import { LOOP_EXITS, STAGE_EXITS } from "./exits.js";
@@ -20,7 +21,7 @@ import { PACKAGE_VERSION } from "./version.js";
 import { findWorkspace, invocationCwdPath } from "./workspace.js";
 const PRIOR_HELP = "Completed session with the workflow id and decision named in requires. Checked before outputs are injected.";
 const PROGRESS_HELP = "Print each tool call when it finishes. The default prints one line when a stage starts and one when it finishes.";
-const VERBOSE_HELP = "Include every stage and its response text in the result JSON.";
+const VERBOSE_HELP = "Accepted for compatibility. Stage lines already include the attempt and the time. The response stays in the execution directory.";
 export function createProgram(status) {
     const program = new Command();
     program
@@ -127,6 +128,18 @@ export function createProgram(status) {
         .option("--json", "Print the checks as one JSON object.")
         .addHelpText("after", exitText(["Exit 0 when every check passes.", "Exit 1 when a check fails."]))
         .action((options) => settle(status, () => runDoctor(findWorkspace(invocationCwdPath()), { asJson: options.json === true })));
+    const provider = program.command("provider").description("List registered provider providers and their models.");
+    provider
+        .command("list")
+        .description("List each registered provider, whether its CLI is on PATH, and the models it reports.")
+        .option("--json", "Print the provider list as one JSON object.")
+        .addHelpText("after", exitText([
+        "Exit 0 when the command ran and at least one provider returned models.",
+        "Exit 1 when no provider returned any models.",
+        "A missing optional CLI is not an error.",
+    ]))
+        .action((options) => settle(status, () => runProviderList({ asJson: options.json === true })));
+    showHelpWhenBare(status, provider);
     program
         .command("migrate")
         .description("Upgrade config and workflows to the current schema version.")
@@ -195,10 +208,11 @@ export function createProgram(status) {
     return program;
 }
 const ROLE_EXITS = [
-    "Exit 0 when the outcome is complete.",
+    "Exit 0 when the outcome is complete, or the role session is already completed.",
     "Exit 1 when the outcome is not complete.",
     "Exit 2 on a configuration error.",
-    "Exit 130 when cancelled. A later run of this session resumes that execution.",
+    "Exit 6 when a cancelled role session reopened more than one execution and one exhausted verify.",
+    "Exit 130 when cancelled. session continue resumes that execution.",
 ];
 const RUN_SPLIT = "Pass --workflow for a workflow run, or --role for an agent run.";
 function registerSessionCommand(program, status) {
@@ -218,26 +232,26 @@ function registerSessionCommand(program, status) {
         .option("--prompt <prompt>", "Prompt text for a role run.")
         .option("--file <file>", "Read the role prompt from this file.")
         .option("--stdin", "Read the role prompt from stdin.")
-        .option("--json", "Print the role result as one JSON object. A workflow run is already JSON.")
-        .addHelpText("after", `With --workflow:\n${exitText(LOOP_EXITS)}With --workflow and --once:\n${exitText(STAGE_EXITS)}Without --workflow:\n${exitText(ROLE_EXITS)}Examples:\n  migent session run --workflow plan --task "<one line>"\n  migent session run --session wave-3 --workflow plan\n  migent session run --role reviewer --prompt "<prompt>"\n`)
+        .option("--json", "Print the role result as one JSON object.")
+        .addHelpText("after", `With --workflow:\n${exitText(LOOP_EXITS)}With --workflow and --once:\n${exitText(STAGE_EXITS)}Without --workflow:\n${exitText(ROLE_EXITS)}Examples:\n  migent session run --workflow plan --task "<one line>"\n  migent session run --session <session> --workflow plan\n  migent session run --role reviewer --prompt "<prompt>"\n`)
         .action((options) => settle(status, () => runSessionCommand(options)));
     session
         .command("prepare")
         .description("Create a prepared session and exit. Write task.md, then session run --session <id> --workflow <workflow>.")
-        .argument("<id>", "Session id: a lowercase slug such as wave-3.")
+        .argument("<title>", "Session title shown in the list, such as \"some task title\". The session id is a UUID.")
         .requiredOption("--workflow <workflow>", "Workflow id, or a path to a workflow file.")
         .option("--prior <session>", PRIOR_HELP)
-        .addHelpText("after", `${exitText(["Exit 0 when the session is prepared.", "Exit 2 on a configuration error."])}Examples:\n  migent session prepare wave-3 --workflow plan\n`)
+        .addHelpText("after", `${exitText(["Exit 0 when the session is prepared.", "Exit 2 on a configuration error."])}Examples:\n  migent session prepare "some task title" --workflow plan\n`)
         .action((id, options) => settle(status, () => prepareWorkflowSession(findWorkspace(invocationCwdPath()), id, String(options.workflow), optionalText(options.prior))));
     const continueCommand = session
         .command("continue")
-        .description("Resume an active or blocked workflow session until it stops. Resets revision counts. --once dispatches one stage and does not reset them.")
+        .description("Resume a stopped workflow or role session. A workflow session runs until it stops and resets revision counts. --once dispatches one workflow stage and does not reset them.")
         .argument("<session>", "Session to resume.");
     addDispatchOptions(continueCommand, "Dispatch the next eligible stage once and do not reset revision counts. Without --once, continue resets them.");
     continueCommand
         .option("--reply <text>", "Reply for the blocked stage. The new execution prompt body is this text.")
         .option("--reply-file <file>", "Read the blocked stage's reply from this file.")
-        .addHelpText("after", `${exitText(LOOP_EXITS)}With --once:\n${exitText(STAGE_EXITS)}Examples:\n  migent session continue <session> --once\n  migent session continue <session> --reply "<reply>"\n  migent session continue <session> --stage plan --reply-file answer.md\n`)
+        .addHelpText("after", `Workflow session:\n${exitText(LOOP_EXITS)}With --once:\n${exitText(STAGE_EXITS)}Role session:\n${exitText(ROLE_EXITS)}Examples:\n  migent session continue <session>\n  migent session continue <session> --once\n  migent session continue <session> --reply "<reply>"\n  migent session continue <session> --stage plan --reply-file answer.md\n`)
         .action((id, options) => settle(status, () => continueSession(id, options)));
     session
         .command("repair")
@@ -290,15 +304,15 @@ function registerSessionCommand(program, status) {
     })));
     session
         .command("metrics")
-        .description("Print derived usage, time, and revision counts.")
-        .argument("[session]", "Session to measure. Omit to list sessions.")
+        .description("Print usage, time, and revision counts recorded for a completed workflow session.")
+        .argument("[session]", "Workflow session to read. Omit to list sessions that have metrics.")
         .option("--json", "Print one JSON object, or one object per line for a list.")
         .option("--workflow <id>", "With a list, keep sessions for this workflow.")
         .option("--status <status>", "With a list, keep sessions in this status.")
         .option("--limit <n>", "With a list, keep the newest n sessions.")
         .addHelpText("after", `${exitText([
         "Exit 0 after one session object, or one object per line. An empty list prints nothing.",
-        "Exit 2 when --json is missing, the session has no events.jsonl, or a list flag is invalid.",
+        "Exit 2 when --json is missing, the session has no metrics.json, that file is corrupt, or a list flag is invalid.",
     ])}Examples:\n  migent session metrics <session> --json\n  migent session metrics --json --workflow <id> --status completed --limit 10\n`)
         .action((id, options) => settle(status, () => runSessionMetrics(findWorkspace(invocationCwdPath()), id, {
         asJson: options.json === true,
@@ -393,7 +407,6 @@ function workflowFlagsPresent(options) {
     return (options.once === true ||
         options.stage !== undefined ||
         options.prior !== undefined ||
-        options.attempts !== undefined ||
         options.maxDispatches !== undefined ||
         options.unlimitedDispatches === true ||
         options.progress === true ||
@@ -418,7 +431,6 @@ function runWorkflowCommand(args) {
             sessionId,
             startPrepared: args.prepared,
             priorSessionId: optionalText(args.options.prior),
-            maxAttempts: attemptsOf(args.options),
             maxDispatches: ceiling,
             refreshWorkflow: args.options.refreshWorkflow === true,
             ...outputFlags(args.options),
@@ -432,7 +444,6 @@ function runWorkflowCommand(args) {
         stageId,
         startPrepared: args.prepared,
         priorSessionId: optionalText(args.options.prior),
-        maxAttempts: null,
         maxDispatches: null,
         refreshWorkflow: args.options.refreshWorkflow === true,
         ...outputFlags(args.options),
@@ -443,6 +454,9 @@ function continueSession(session, options) {
         printError("--stage is empty.");
         return 2;
     }
+    const workspace = findWorkspace(invocationCwdPath());
+    if (isAgentSession(workspace, session))
+        return continueRoleSession(workspace, session, options);
     if (rejectOnce(options))
         return 2;
     const reply = readReply(options);
@@ -455,8 +469,8 @@ function continueSession(session, options) {
             sessionId: session,
             stageId,
             priorSessionId: optionalText(options.prior),
-            maxAttempts: null,
             maxDispatches: null,
+            continueFailed: true,
             refreshWorkflow: options.refreshWorkflow === true,
             reply,
             ...outputFlags(options),
@@ -469,13 +483,57 @@ function continueSession(session, options) {
         action: "continue",
         sessionId: session,
         priorSessionId: optionalText(options.prior),
-        maxAttempts: attemptsOf(options),
         maxDispatches: ceiling,
+        continueFailed: true,
         refreshWorkflow: options.refreshWorkflow === true,
         reply,
         ...outputFlags(options),
     });
 }
+function isAgentSession(workspace, sessionId) {
+    try {
+        requireAgentSession(workspace, sessionId);
+        return true;
+    }
+    catch (error) {
+        if (!(error instanceof ConfigurationError))
+            throw error;
+        if (error.message === `Session not found: ${sessionId}.`)
+            return false;
+        if (error.message === `Session ${sessionId} was not created by agent.`)
+            return false;
+        if (error.message.startsWith("Session status file is corrupt:"))
+            return false;
+        throw error;
+    }
+}
+function continueRoleSession(workspace, sessionId, options) {
+    const flags = [];
+    if (options.once === true)
+        flags.push("--once");
+    if (options.stage !== undefined)
+        flags.push("--stage");
+    if (options.prior !== undefined)
+        flags.push("--prior");
+    if (options.maxDispatches !== undefined)
+        flags.push("--max-dispatches");
+    if (options.unlimitedDispatches === true)
+        flags.push("--unlimited-dispatches");
+    if (options.progress === true)
+        flags.push("--progress");
+    if (options.verbose === true)
+        flags.push("--verbose");
+    if (options.refreshWorkflow === true)
+        flags.push("--refresh-workflow");
+    if (flags.length > 0) {
+        printError(`Session ${sessionId} is a role session. Omit ${flags.join(", ")}.`);
+        return 2;
+    }
+    const reply = readReply(options);
+    if (reply === "invalid")
+        return 2;
+    return continueAgent(workspace, { sessionId, reply });
+}
 function readReply(options) {
     const hasReply = options.reply !== undefined;
     const hasFile = options.replyFile !== undefined;
@@ -518,7 +576,6 @@ function addDispatchOptions(command, onceDescription) {
         .option("--once", onceDescription)
         .option("--stage <stage>", "Dispatch this ready stage once. It does not have to be the first ready stage.")
         .option("--prior <session>", PRIOR_HELP)
-        .option("--attempts <count>", "Failed executions allowed for one stage. Default: 3.")
         .option("--max-dispatches <count>", `Stage dispatches allowed in this command. Default: ${DEFAULT_MAX_DISPATCHES}. Pass --unlimited-dispatches to remove the ceiling.`)
         .option("--unlimited-dispatches", "Remove the dispatch ceiling for this command.")
         .option("--progress", PROGRESS_HELP)
@@ -526,7 +583,7 @@ function addDispatchOptions(command, onceDescription) {
         .option("--refresh-workflow", "Use the current workflow, models, and role instructions for this session. Requires an existing session that has a frozen workflow.");
 }
 function outputFlags(options) {
-    return { verbose: options.verbose === true, itemProgress: options.progress === true };
+    return { itemProgress: options.progress === true };
 }
 function showHelpWhenBare(status, command) {
     command.action(() => {
@@ -590,10 +647,6 @@ function rejectOnce(options) {
     if (options.once !== true && options.stage === undefined)
         return false;
     const flag = options.once === true ? "--once" : "--stage";
-    if (options.attempts !== undefined) {
-        printError(`${flag} cannot be combined with --attempts.`);
-        return true;
-    }
     if (options.maxDispatches !== undefined) {
         printError(`${flag} cannot be combined with --max-dispatches.`);
         return true;
@@ -617,12 +670,6 @@ function dispatchCeiling(options) {
         return DEFAULT_MAX_DISPATCHES;
     return integerFlag(maxDispatches, "--max-dispatches");
 }
-function attemptsOf(options) {
-    const raw = optionalText(options.attempts);
-    if (raw === null)
-        return 3;
-    return integerFlag(raw, "--attempts");
-}
 function integerFlag(raw, flag) {
     if (!/^[0-9]+$/.test(raw) || Number(raw) < 1) {
         throw new ConfigurationError(`${flag} must be at least 1.`);

package/dist/provider.d.ts

@@ -1,23 +1,25 @@
 import { ModelCatalog } from "@nodeint/migent-adapters";
-import { type AgentAdapter, type ProviderOption } from "@nodeint/migent-kernel";
-export interface CatalogAdapter extends AgentAdapter {
+import { type Provider, type ProviderOption } from "@nodeint/migent-kernel";
+export interface CatalogProvider extends Provider {
     modelCatalogCommand(): string[];
+    /** Written to the catalog command's stdin when the CLI reads its request there. */
+    modelCatalogInput?(): string;
     parseModelCatalog(stdout: string): ModelCatalog;
     optionValuesCommand(name: string, model: string): string[] | null;
     parseOptionValues(name: string, text: string, model?: string): readonly string[];
     providerOptions(): readonly ProviderOption[];
 }
 export type Which = (command: string) => string | null;
-export type RunCommand = (argv: string[]) => string | Promise<string>;
+export type RunCommand = (argv: string[], input?: string) => string | Promise<string>;
 export declare class ProviderCommandFailed extends Error {
 }
-export declare function adapterMap(): Record<string, AgentAdapter>;
-export declare function asCatalog(adapter: AgentAdapter): CatalogAdapter;
-export declare function requireAdapter(adapters: Record<string, AgentAdapter>, provider: string): AgentAdapter;
-export declare function detected(adapters: Record<string, AgentAdapter>, which: Which): Array<[string, string | null, AgentAdapter]>;
-export declare function loadCatalog(adapter: AgentAdapter, which: Which, runCommand: RunCommand): Promise<ModelCatalog>;
+export declare function providerMap(): Record<string, Provider>;
+export declare function asCatalog(provider: Provider): CatalogProvider;
+export declare function requireProvider(providers: Record<string, Provider>, provider: string): Provider;
+export declare function detected(providers: Record<string, Provider>, which: Which): Array<[string, string | null, Provider]>;
+export declare function loadCatalog(provider: Provider, which: Which, runCommand: RunCommand): Promise<ModelCatalog>;
 export declare function knownModel(model: string, catalog: ModelCatalog): string;
 export declare function parseOptions(pairs: readonly string[]): Record<string, string>;
-export declare function loadOptionValues(adapter: AgentAdapter, name: string, model: string, catalog: ModelCatalog, which: Which, runCommand: RunCommand): Promise<readonly string[] | null>;
-export declare function acceptedOptions(adapter: AgentAdapter, model: string, catalog: ModelCatalog, which: Which, runCommand: RunCommand, options: Readonly<Record<string, string>>): Promise<Record<string, string>>;
-export declare function runProviderCommand(argv: string[]): string;
+export declare function loadOptionValues(provider: Provider, name: string, model: string, catalog: ModelCatalog, which: Which, runCommand: RunCommand): Promise<readonly string[] | null>;
+export declare function acceptedOptions(provider: Provider, model: string, catalog: ModelCatalog, which: Which, runCommand: RunCommand, options: Readonly<Record<string, string>>): Promise<Record<string, string>>;
+export declare function runProviderCommand(argv: string[], input?: string): string;

package/dist/provider.js

@@ -1,27 +1,27 @@
-import { ModelCatalog, defaultAdapters } from "@nodeint/migent-adapters";
+import { ModelCatalog, defaultProviders } from "@nodeint/migent-adapters";
 import { spawnProviderSync } from "@nodeint/migent-kernel";
 export class ProviderCommandFailed extends Error {
 }
-export function adapterMap() {
-    return defaultAdapters();
+export function providerMap() {
+    return defaultProviders();
 }
-export function asCatalog(adapter) {
-    const candidate = adapter;
+export function asCatalog(provider) {
+    const candidate = provider;
     if (typeof candidate.modelCatalogCommand !== "function" || typeof candidate.parseModelCatalog !== "function") {
-        throw new ProviderCommandFailed(`${adapter.command} does not list models.`);
+        throw new ProviderCommandFailed(`${provider.command} does not list models.`);
     }
     return candidate;
 }
-export function requireAdapter(adapters, provider) {
-    const adapter = adapters[provider];
-    if (adapter === undefined) {
-        const supported = Object.keys(adapters).sort().join(", ");
+export function requireProvider(providers, provider) {
+    const impl = providers[provider];
+    if (impl === undefined) {
+        const supported = Object.keys(providers).sort().join(", ");
         throw new ProviderCommandFailed(`Unknown provider: ${provider}. Supported: ${supported}.`);
     }
-    return adapter;
+    return impl;
 }
-export function detected(adapters, which) {
-    const rows = Object.entries(adapters).map(([name, adapter]) => [name, which(adapter.command), adapter]);
+export function detected(providers, which) {
+    const rows = Object.entries(providers).filter(([, provider]) => provider.requiresClient !== true).map(([name, provider]) => [name, which(provider.command), provider]);
     rows.sort((left, right) => {
         const leftMissing = left[1] === null ? 1 : 0;
         const rightMissing = right[1] === null ? 1 : 0;
@@ -35,24 +35,24 @@ export function detected(adapters, which) {
     });
     return rows;
 }
-export async function loadCatalog(adapter, which, runCommand) {
-    if (which(adapter.command) === null) {
-        throw new ProviderCommandFailed(`${adapter.command} is not on PATH, so its models could not be listed.`);
+export async function loadCatalog(provider, which, runCommand) {
+    if (which(provider.command) === null) {
+        throw new ProviderCommandFailed(`${provider.command} is not on PATH, so its models could not be listed.`);
     }
-    const catalogAdapter = asCatalog(adapter);
+    const catalogProvider = asCatalog(provider);
     let stdout;
     try {
-        stdout = await runCommand(catalogAdapter.modelCatalogCommand());
+        stdout = await runCommand(catalogProvider.modelCatalogCommand(), catalogProvider.modelCatalogInput?.());
     }
     catch (error) {
         if (error instanceof ProviderCommandFailed)
             throw error;
         const reason = error instanceof Error ? error.message : String(error);
-        throw new ProviderCommandFailed(`Could not list ${adapter.command} models: ${reason}`);
+        throw new ProviderCommandFailed(`Could not list ${provider.command} models: ${reason}`);
     }
-    const catalog = catalogAdapter.parseModelCatalog(stdout);
+    const catalog = catalogProvider.parseModelCatalog(stdout);
     if (catalog.ids.length === 0)
-        throw new ProviderCommandFailed(`${adapter.command} returned no models.`);
+        throw new ProviderCommandFailed(`${provider.command} returned no models.`);
     return catalog;
 }
 export function knownModel(model, catalog) {
@@ -75,16 +75,16 @@ export function parseOptions(pairs) {
     }
     return parsed;
 }
-export async function loadOptionValues(adapter, name, model, catalog, which, runCommand) {
+export async function loadOptionValues(provider, name, model, catalog, which, runCommand) {
     const found = catalog.valuesFor(model, name);
     if (found !== null)
         return found;
-    const catalogAdapter = asCatalog(adapter);
-    const argv = catalogAdapter.optionValuesCommand(name, model);
+    const catalogProvider = asCatalog(provider);
+    const argv = catalogProvider.optionValuesCommand(name, model);
     if (argv === null)
         return null;
-    if (which(adapter.command) === null) {
-        throw new ProviderCommandFailed(`${adapter.command} is not on PATH, so its ${name} values could not be listed.`);
+    if (which(provider.command) === null) {
+        throw new ProviderCommandFailed(`${provider.command} is not on PATH, so its ${name} values could not be listed.`);
     }
     let text;
     try {
@@ -95,18 +95,18 @@ export async function loadOptionValues(adapter, name, model, catalog, which, run
             text = error.message;
         else {
             const reason = error instanceof Error ? error.message : String(error);
-            throw new ProviderCommandFailed(`Could not list ${adapter.command} ${name} values for ${model}: ${reason}`);
+            throw new ProviderCommandFailed(`Could not list ${provider.command} ${name} values for ${model}: ${reason}`);
         }
     }
-    return catalogAdapter.parseOptionValues(name, text, model);
+    return catalogProvider.parseOptionValues(name, text, model);
 }
-export async function acceptedOptions(adapter, model, catalog, which, runCommand, options) {
+export async function acceptedOptions(provider, model, catalog, which, runCommand, options) {
     if (Object.keys(options).length === 0)
         return {};
-    adapter.validateOptions(options);
+    provider.validateOptions(options);
     const stored = {};
     for (const [name, value] of Object.entries(options)) {
-        const values = await loadOptionValues(adapter, name, model, catalog, which, runCommand);
+        const values = await loadOptionValues(provider, name, model, catalog, which, runCommand);
         if (values === null) {
             stored[name] = value;
             continue;
@@ -120,11 +120,16 @@ export async function acceptedOptions(adapter, model, catalog, which, runCommand
     }
     return stored;
 }
-export function runProviderCommand(argv) {
+export function runProviderCommand(argv, input) {
     const [command, ...args] = argv;
     if (command === undefined)
         throw new ProviderCommandFailed("Provider command is empty.");
-    const completed = spawnProviderSync(command, args, { encoding: "utf8", timeout: 60_000, windowsHide: true });
+    const completed = spawnProviderSync(command, args, {
+        encoding: "utf8",
+        timeout: 60_000,
+        windowsHide: true,
+        ...(input === undefined ? {} : { input }),
+    });
     if (completed.error) {
         throw new Error(completed.error.message);
     }

package/dist/session-row.d.ts

@@ -7,9 +7,11 @@ export declare const SESSION_COLUMN: {
     readonly decision: 5;
     readonly outputs: 6;
     readonly task: 7;
+    readonly title: 8;
 };
 export interface SessionFields {
     session: string;
+    title: string;
     workflow: string;
     status: string;
     execution: string;

package/dist/session-row.js

@@ -7,10 +7,12 @@ export const SESSION_COLUMN = {
     decision: 5,
     outputs: 6,
     task: 7,
+    title: 8,
 };
 export function sessionFields(row) {
     return {
         session: row[SESSION_COLUMN.session] ?? "",
+        title: row[SESSION_COLUMN.title] ?? "",
         workflow: row[SESSION_COLUMN.workflow] ?? "",
         status: row[SESSION_COLUMN.status] ?? "",
         execution: row[SESSION_COLUMN.execution] ?? "",