@nodeint/migent 0.1.5 → 0.1.6

package/dist/commands/agent.js

@@ -1,6 +1,7 @@
+import { readFileSync } from "node:fs";
 import path from "node:path";
-import { AgentToolRunner, CancellationRequested, ConfigurationError, createAgentSession, loadRoleInstructions, loadYamlMapping, log, prependRoleInstructions, requireAgentSession, isSessionLockLost, repairSessionUnlocked, SessionLock, resolveRoleTarget, SessionStore, } from "@nodeint/migent-kernel";
-import { printAgent, printError, printNotice } from "../display.js";
+import { AgentToolRunner, CancellationRequested, ConfigurationError, ProviderEventReporter, SessionStore, createAgentSession, loadRoleInstructions, loadYamlMapping, log, prependRoleInstructions, requireAgentSession, isSessionLockLost, repairSessionUnlocked, SessionLock, stringOptions, resolveRoleTarget, waitUntil, } from "@nodeint/migent-kernel";
+import { printAgent, printError, printNotice, printResumeCommand } from "../display.js";
 import { cliHooks } from "../hooks.js";
 import { requireCurrentSchema } from "../migrate.js";
 import { bindCancellationSignals } from "../signals.js";
@@ -65,6 +66,17 @@ export async function dispatchAgent(workspace, args) {
         let resumedMany = null;
         try {
             const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            const waitedUntil = new Map();
+            const rerun = (prompt, resumeId) => runner.run({
+                provider: target.provider,
+                model: target.model,
+                options: { ...target.options },
+                prompt,
+                workspace,
+                sessionId: resolvedSessionId,
+                resumeExecutionId: resumeId,
+                stageId: args.role,
+            });
             if (resumeCancelled) {
                 const reopened = new SessionStore(workspace).reopenCancelledExecutions(resolvedSessionId);
                 for (const item of reopened) {
@@ -78,32 +90,37 @@ export async function dispatchAgent(workspace, args) {
                 if (continued.length === 0) {
                     throw new ConfigurationError(`Session ${resolvedSessionId} is cancelled without an execution.`);
                 }
-                if (continued.length === 1)
-                    result = continued[0];
+                const finished = [];
+                for (const item of continued) {
+                    finished.push(await rerunQuota(workspace, resolvedSessionId, item, (current) => lastUserPrompt(workspace, resolvedSessionId, current.execution_id), rerun, waitedUntil, args.waitHooks));
+                }
+                if (finished.length === 1)
+                    result = finished[0];
                 else
-                    resumedMany = continued;
+                    resumedMany = finished;
             }
             else {
-                result = await runner.run({
+                const prompt = prependRoleInstructions(loadRoleInstructions(loadYamlMapping(path.join(workspace, ".migent", "config.yaml")), args.role), resolvePrompt({
+                    prompt: args.prompt ?? null,
+                    promptFile: args.promptFile ?? null,
+                    promptStdin: args.promptStdin ?? false,
+                }));
+                result = await rerunQuota(workspace, resolvedSessionId, await runner.run({
                     provider: target.provider,
                     model: target.model,
                     options: { ...target.options },
-                    prompt: prependRoleInstructions(loadRoleInstructions(loadYamlMapping(path.join(workspace, ".migent", "config.yaml")), args.role), resolvePrompt({
-                        prompt: args.prompt ?? null,
-                        promptFile: args.promptFile ?? null,
-                        promptStdin: args.promptStdin ?? false,
-                    })),
+                    prompt,
                     workspace,
                     sessionId: resolvedSessionId,
                     resumeExecutionId,
                     stageId: args.role,
-                });
+                }), () => prompt, rerun, waitedUntil, args.waitHooks);
             }
         }
         catch (error) {
             if (error instanceof CancellationRequested) {
                 log(error.message);
-                return 130;
+                return finishRole(resolvedSessionId, 130);
             }
             if (error instanceof ConfigurationError)
                 throw error;
@@ -123,9 +140,10 @@ export async function dispatchAgent(workspace, args) {
                 for (const item of resumedMany)
                     printAgent({ ...item }, args.role, target.provider, target.model);
             }
-            if (resumedMany.some((item) => item.failure_reason === "verify_exhausted"))
-                return 6;
-            return resumedMany.every((item) => item.outcome_status === "complete") ? 0 : 1;
+            if (resumedMany.some((item) => item.failure_reason === "verify_exhausted")) {
+                return finishRole(resolvedSessionId, 6);
+            }
+            return finishRole(resolvedSessionId, resumedMany.every((item) => item.outcome_status === "complete") ? 0 : 1);
         }
         if (result === undefined)
             throw new Error("Agent run produced no result.");
@@ -133,7 +151,262 @@ export async function dispatchAgent(workspace, args) {
             process.stdout.write(`${JSON.stringify(result)}\n`);
         else
             printAgent({ ...result }, args.role, target.provider, target.model);
-        return result.outcome_status === "complete" ? 0 : 1;
+        return finishRole(resolvedSessionId, result.outcome_status === "complete" ? 0 : 1);
+    }
+}
+export async function continueAgent(workspace, args) {
+    requireCurrentSchema(workspace);
+    requireAgentSession(workspace, args.sessionId);
+    let lock;
+    try {
+        lock = SessionLock.acquire(path.join(workspace, ".migent", "sessions", args.sessionId));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            printError(error.message);
+            return 2;
+        }
+        throw error;
+    }
+    try {
+        return await continueLocked();
+    }
+    catch (error) {
+        if (isSessionLockLost(error)) {
+            printError(error.message);
+            return 2;
+        }
+        throw error;
+    }
+    finally {
+        lock.release();
+    }
+    async function continueLocked() {
+        repairSessionUnlocked(workspace, args.sessionId);
+        const store = new SessionStore(workspace);
+        const status = store.readSessionStatus(args.sessionId);
+        const sessionStatus = typeof status.status === "string" ? status.status : "";
+        const role = typeof status.role === "string" ? status.role : "";
+        if (role === "")
+            throw new ConfigurationError(`Session ${args.sessionId} has no role.`);
+        if (sessionStatus === "completed" && args.reply === null) {
+            printNotice(`Session ${args.sessionId} is completed.`);
+            return 0;
+        }
+        if (sessionStatus === "cancelled" && args.reply !== null) {
+            throw new ConfigurationError(`Session ${args.sessionId} was cancelled. session continue resumes that execution. Omit --reply.`);
+        }
+        const latest = store.latestExecution(args.sessionId);
+        if (latest === null)
+            throw new ConfigurationError(`Session ${args.sessionId} has no execution.`);
+        const profile = executionProfile(latest.directory, latest.executionId);
+        const optionLabel = Object.entries(profile.options)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join(", ") || "default";
+        printNotice(`agent ${role} · ${profile.provider}/${profile.model} (${optionLabel}).`);
+        const unbind = bindCancellationSignals();
+        try {
+            const runner = args.runner ?? cliHooks.runner ?? new AgentToolRunner(adapterMap());
+            if (sessionStatus === "cancelled") {
+                return await runCancelledRole(workspace, args.sessionId, role, profile, runner, false, args.waitHooks);
+            }
+            let prompt;
+            if (args.reply !== null) {
+                prompt = rolePrompt(workspace, role, args.reply);
+            }
+            else if (sessionStatus === "blocked") {
+                const blocker = executionBlocker(latest.directory);
+                const resumed = store.resumeBlockedSession(args.sessionId);
+                for (const item of resumed) {
+                    log(`session ${args.sessionId} was blocked by ${item.executionId}. Resuming ${role}.`);
+                }
+                const lines = ["Previous attempt:", `- execution: ${latest.executionId}`];
+                if (blocker)
+                    lines.push(`- blocker: ${blocker}`);
+                lines.push("That attempt ended blocked. The blocker was handled outside this session. Continue.");
+                prompt = rolePrompt(workspace, role, lines.join("\n"));
+            }
+            else if (sessionStatus === "active") {
+                log(`session ${args.sessionId} is active. Resuming ${role} with its last prompt.`);
+                prompt = lastUserPrompt(workspace, args.sessionId, latest.executionId);
+            }
+            else {
+                throw new ConfigurationError(`Session ${args.sessionId} is ${sessionStatus || "unknown"}.`);
+            }
+            const waitedUntil = new Map();
+            const rerun = (nextPrompt, resumeId) => runner.run({
+                provider: profile.provider,
+                model: profile.model,
+                options: { ...profile.options },
+                prompt: nextPrompt,
+                workspace,
+                sessionId: args.sessionId,
+                resumeExecutionId: resumeId,
+                stageId: role,
+            });
+            const result = await rerunQuota(workspace, args.sessionId, await rerun(prompt, latest.executionId), () => prompt, rerun, waitedUntil, args.waitHooks);
+            printAgent({ ...result }, role, profile.provider, profile.model);
+            return finishRole(args.sessionId, result.outcome_status === "complete" ? 0 : 1);
+        }
+        catch (error) {
+            if (error instanceof CancellationRequested) {
+                log(error.message);
+                return finishRole(args.sessionId, 130);
+            }
+            if (error instanceof ConfigurationError)
+                throw error;
+            if (error instanceof Error) {
+                printError(error.message);
+                return 2;
+            }
+            throw error;
+        }
+        finally {
+            unbind();
+        }
+    }
+}
+async function runCancelledRole(workspace, sessionId, role, profile, runner, asJson, waitHooks) {
+    const reopened = new SessionStore(workspace).reopenCancelledExecutions(sessionId);
+    for (const item of reopened) {
+        log(`session ${sessionId} was cancelled during ${item.executionId}. Resuming that execution.`);
+    }
+    const waitedUntil = new Map();
+    const rerun = (prompt, resumeId) => runner.run({
+        provider: profile.provider,
+        model: profile.model,
+        options: { ...profile.options },
+        prompt,
+        workspace,
+        sessionId,
+        resumeExecutionId: resumeId,
+        stageId: role,
+    });
+    const settled = await Promise.allSettled(reopened.map((item) => runner.continueCancelled(workspace, sessionId, item.executionId)));
+    const rejected = settled.find((item) => item.status === "rejected");
+    if (rejected && rejected.status === "rejected")
+        throw rejected.reason;
+    const continued = settled.flatMap((item) => (item.status === "fulfilled" ? [item.value] : []));
+    if (continued.length === 0) {
+        throw new ConfigurationError(`Session ${sessionId} is cancelled without an execution.`);
+    }
+    const finished = [];
+    for (const item of continued) {
+        finished.push(await rerunQuota(workspace, sessionId, item, (current) => lastUserPrompt(workspace, sessionId, current.execution_id), rerun, waitedUntil, waitHooks));
+    }
+    if (finished.length === 1) {
+        const result = finished[0];
+        if (result === undefined)
+            throw new Error("Agent run produced no result.");
+        if (asJson)
+            process.stdout.write(`${JSON.stringify(result)}\n`);
+        else
+            printAgent({ ...result }, role, profile.provider, profile.model);
+        return finishRole(sessionId, result.outcome_status === "complete" ? 0 : 1);
+    }
+    if (asJson)
+        process.stdout.write(`${JSON.stringify(finished)}\n`);
+    else {
+        for (const item of finished)
+            printAgent({ ...item }, role, profile.provider, profile.model);
+    }
+    if (finished.some((item) => item.failure_reason === "verify_exhausted"))
+        return finishRole(sessionId, 6);
+    return finishRole(sessionId, finished.every((item) => item.outcome_status === "complete") ? 0 : 1);
+}
+async function rerunQuota(workspace, sessionId, initial, promptFor, run, waitedUntil, hooks) {
+    let current = initial;
+    let armed = null;
+    while (current.failure_kind === "quota" && current.reset_at !== "") {
+        if (armed !== null && !laterInstant(current.reset_at, armed))
+            return current;
+        const resetAt = current.reset_at;
+        const provider = current.provider;
+        const shared = waitedUntil.get(provider);
+        const now = hooks?.now ?? Date.now;
+        const past = !Number.isFinite(Date.parse(resetAt)) || now() >= Date.parse(resetAt);
+        if (!past && (shared === undefined || laterInstant(resetAt, shared))) {
+            emitRoleQuota(workspace, sessionId, current);
+            await waitUntil(resetAt, hooks).promise;
+        }
+        waitedUntil.set(provider, resetAt);
+        armed = resetAt;
+        current = await run(promptFor(current), current.execution_id);
+    }
+    return current;
+}
+function laterInstant(next, previous) {
+    const left = Date.parse(next);
+    const right = Date.parse(previous);
+    if (Number.isFinite(left) && Number.isFinite(right))
+        return left > right;
+    return next > previous;
+}
+function emitRoleQuota(workspace, sessionId, result) {
+    const store = new SessionStore(workspace);
+    const context = store.executionContext(sessionId, result.execution_id);
+    if (context === null)
+        return;
+    let model = "";
+    try {
+        const metadata = JSON.parse(readFileSync(path.join(context.directory, "execution.json"), "utf8"));
+        if (isRecord(metadata) && typeof metadata.model === "string")
+            model = metadata.model;
+    }
+    catch {
+        model = "";
+    }
+    const summary = [result.response, result.reset_at].filter((item) => item !== "").join(" ");
+    new ProviderEventReporter(store, context, result.provider, model).emit("provider.quota", summary, {
+        retry_at: result.reset_at,
+        provider: result.provider,
+    });
+}
+function lastUserPrompt(workspace, sessionId, executionId) {
+    const context = new SessionStore(workspace).executionContext(sessionId, executionId);
+    if (context === null)
+        throw new ConfigurationError(`Execution ${executionId} was not found.`);
+    const raw = JSON.parse(readFileSync(context.conversationReadPath, "utf8"));
+    const history = Array.isArray(raw) ? raw : isRecord(raw) && Array.isArray(raw.history) ? raw.history : [];
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const entry = history[index];
+        if (isRecord(entry) && entry.role === "user" && typeof entry.content === "string" && entry.content !== "") {
+            return entry.content;
+        }
+    }
+    throw new ConfigurationError(`Execution ${executionId} has no prompt to resume.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finishRole(sessionId, code) {
+    if (code === 1 || code === 6 || code === 130)
+        printResumeCommand(sessionId);
+    return code;
+}
+function rolePrompt(workspace, role, text) {
+    return prependRoleInstructions(loadRoleInstructions(loadYamlMapping(path.join(workspace, ".migent", "config.yaml")), role), text);
+}
+function executionProfile(directory, executionId) {
+    const raw = JSON.parse(readFileSync(path.join(directory, "execution.json"), "utf8"));
+    if (!isRecord(raw) ||
+        typeof raw.provider !== "string" ||
+        raw.provider === "" ||
+        typeof raw.model !== "string" ||
+        raw.model === "") {
+        throw new ConfigurationError(`Execution ${executionId} has no provider.`);
+    }
+    return { provider: raw.provider, model: raw.model, options: stringOptions(raw.options) };
+}
+function executionBlocker(directory) {
+    try {
+        const raw = JSON.parse(readFileSync(path.join(directory, "execution.json"), "utf8"));
+        if (!isRecord(raw) || !isRecord(raw.outcome))
+            return null;
+        return typeof raw.outcome.blocker === "string" && raw.outcome.blocker !== "" ? raw.outcome.blocker : null;
+    }
+    catch {
+        return null;
     }
 }
 function resolveSession(workspace, sessionId, role, task) {

package/dist/commands/config.js

@@ -1,7 +1,7 @@
 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";
@@ -316,6 +316,8 @@ function validateChange(before, after, workflows, adapters) {
     }
     for (const document of workflows) {
         for (const stage of Object.values(document.stages)) {
+            if (!isRoleStage(stage))
+                continue;
             let beforeTarget;
             let afterTarget;
             try {

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,4 +1,7 @@
-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";
@@ -9,7 +12,6 @@ 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());
     runner.itemProgress = options.itemProgress === true;
@@ -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/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) {

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;

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)

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.`,
 ];