martin-loop 0.1.4 → 1.3.0

package/dist/vendor/cli/commands/migration.d.ts

@@ -0,0 +1,8 @@
+export interface MigrationCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function handleMigrationCommand(args: string[], options?: {
+    cwd?: string;
+}): Promise<MigrationCommandResult>;

package/dist/vendor/cli/commands/migration.js

@@ -0,0 +1,67 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { verifyMigrationPlan } from "@martin/sdk";
+export async function handleMigrationCommand(args, options = {}) {
+    const subcommand = args[0];
+    try {
+        if (subcommand !== "verify") {
+            return {
+                stdout: "",
+                stderr: [
+                    "Usage: martin migration verify --plan <path> [options]",
+                    "",
+                    "Options:",
+                    "  --now <timestamp>",
+                    "  --release-windows <start/end,start/end>",
+                    "  --output <path>"
+                ].join("\n"),
+                exitCode: 1
+            };
+        }
+        const planPath = parseFlag(args, "--plan");
+        if (!planPath) {
+            return { stdout: "", stderr: "Missing --plan", exitCode: 1 };
+        }
+        const cwd = options.cwd ?? process.cwd();
+        const resolvedPlanPath = resolve(cwd, planPath);
+        const rawPlan = await readFile(resolvedPlanPath, "utf8");
+        const plan = JSON.parse(rawPlan);
+        const releaseWindows = parseCsvFlag(args, "--release-windows");
+        const now = parseFlag(args, "--now");
+        const verificationOptions = {
+            ...(now ? { now } : {}),
+            ...(releaseWindows.length > 0 ? { releaseWindows } : {})
+        };
+        const readiness = verifyMigrationPlan(plan, verificationOptions);
+        const outputPath = resolve(cwd, parseFlag(args, "--output") ?? "cutover-readiness.json");
+        await mkdir(dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, JSON.stringify(readiness, null, 2), "utf8");
+        return {
+            stdout: JSON.stringify({
+                command: "migration.verify",
+                outputPath,
+                result: readiness
+            }, null, 2),
+            stderr: "",
+            exitCode: 0
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { stdout: "", stderr: message, exitCode: 1 };
+    }
+}
+function parseFlag(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function parseCsvFlag(args, flag) {
+    const value = parseFlag(args, flag);
+    return value
+        ? value
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)
+        : [];
+}
+//# sourceMappingURL=migration.js.map

package/dist/vendor/cli/commands/prior.d.ts

@@ -0,0 +1,23 @@
+export interface PriorCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function resolvePriorStoreDir(cwd?: string): string;
+/**
+ * Handles `martin prior <subcommand> [args]`
+ *
+ * Subcommands:
+ *   list                                          — list all PriorSets
+ *   status --prior-set-id <id>                    — show current gate for a PriorSet
+ *   promote --prior-set-id <id> --gate <gate>     — advance gate (sequential only)
+ *   rollback --prior-set-id <id>                  — revert to previous gate
+ */
+export declare function handlePriorCommand(args: string[], options?: {
+    cwd?: string;
+}): Promise<PriorCommandResult>;
+/**
+ * Seeds a PriorSet into the store if it doesn't already exist.
+ * Used by tests and the CLI init flow.
+ */
+export declare function seedPriorSet(priorSetId: string, taskClass: string, priors: Record<string, number>, storeDir: string): Promise<void>;

package/dist/vendor/cli/commands/prior.js

@@ -0,0 +1,145 @@
+import { join } from "node:path";
+import { listPriorSets, getPriorSet, promotePriorSet, rollbackPriorSet, createPriorSet, savePriorStore, loadPriorStore } from "../../core/index.js";
+const VALID_GATES = ["development", "backtest", "shadow", "live"];
+// ─── Store path resolution ────────────────────────────────────────────────────
+export function resolvePriorStoreDir(cwd) {
+    return join(cwd ?? process.cwd(), ".martin");
+}
+// ─── Command handler ──────────────────────────────────────────────────────────
+/**
+ * Handles `martin prior <subcommand> [args]`
+ *
+ * Subcommands:
+ *   list                                          — list all PriorSets
+ *   status --prior-set-id <id>                    — show current gate for a PriorSet
+ *   promote --prior-set-id <id> --gate <gate>     — advance gate (sequential only)
+ *   rollback --prior-set-id <id>                  — revert to previous gate
+ */
+export async function handlePriorCommand(args, options = {}) {
+    const storeDir = resolvePriorStoreDir(options.cwd);
+    const subcommand = args[0];
+    try {
+        switch (subcommand) {
+            case "list": {
+                const priorSets = await listPriorSets(storeDir);
+                if (priorSets.length === 0) {
+                    return {
+                        stdout: JSON.stringify({ priorSets: [], message: "No PriorSets found." }, null, 2),
+                        stderr: "",
+                        exitCode: 0
+                    };
+                }
+                return {
+                    stdout: JSON.stringify({ priorSets }, null, 2),
+                    stderr: "",
+                    exitCode: 0
+                };
+            }
+            case "status": {
+                const priorSetId = parseFlag(args, "--prior-set-id");
+                if (!priorSetId) {
+                    return { stdout: "", stderr: "Missing --prior-set-id", exitCode: 1 };
+                }
+                const ps = await getPriorSet(priorSetId, storeDir);
+                if (!ps) {
+                    return { stdout: "", stderr: `PriorSet not found: ${priorSetId}`, exitCode: 1 };
+                }
+                return {
+                    stdout: JSON.stringify({
+                        priorSetId: ps.priorSetId,
+                        taskClass: ps.taskClass,
+                        promotionGate: ps.promotionGate,
+                        version: ps.version,
+                        sampleCount: ps.sampleCount,
+                        confidence: ps.confidence
+                    }, null, 2),
+                    stderr: "",
+                    exitCode: 0
+                };
+            }
+            case "promote": {
+                const priorSetId = parseFlag(args, "--prior-set-id");
+                const gate = parseFlag(args, "--gate");
+                if (!priorSetId)
+                    return { stdout: "", stderr: "Missing --prior-set-id", exitCode: 1 };
+                if (!gate)
+                    return { stdout: "", stderr: "Missing --gate", exitCode: 1 };
+                if (!VALID_GATES.includes(gate)) {
+                    return {
+                        stdout: "",
+                        stderr: `Invalid gate: ${gate}. Must be one of: ${VALID_GATES.join(", ")}`,
+                        exitCode: 1
+                    };
+                }
+                const updated = await promotePriorSet(priorSetId, gate, storeDir);
+                return {
+                    stdout: JSON.stringify({
+                        message: `PriorSet ${priorSetId} promoted to ${gate}`,
+                        priorSetId: updated.priorSetId,
+                        promotionGate: updated.promotionGate,
+                        version: updated.version
+                    }, null, 2),
+                    stderr: "",
+                    exitCode: 0
+                };
+            }
+            case "rollback": {
+                const priorSetId = parseFlag(args, "--prior-set-id");
+                if (!priorSetId)
+                    return { stdout: "", stderr: "Missing --prior-set-id", exitCode: 1 };
+                const reverted = await rollbackPriorSet(priorSetId, storeDir);
+                return {
+                    stdout: JSON.stringify({
+                        message: `PriorSet ${priorSetId} rolled back to ${reverted.promotionGate}`,
+                        priorSetId: reverted.priorSetId,
+                        promotionGate: reverted.promotionGate,
+                        version: reverted.version
+                    }, null, 2),
+                    stderr: "",
+                    exitCode: 0
+                };
+            }
+            default:
+                return {
+                    stdout: "",
+                    stderr: [
+                        "Usage: martin prior <subcommand> [options]",
+                        "",
+                        "Subcommands:",
+                        "  list                                        List all PriorSets",
+                        "  status --prior-set-id <id>                  Show current gate",
+                        "  promote --prior-set-id <id> --gate <gate>   Promote to next gate",
+                        "  rollback --prior-set-id <id>                Revert to previous gate",
+                        "",
+                        "Gates (sequential): development → backtest → shadow → live"
+                    ].join("\n"),
+                    exitCode: 1
+                };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { stdout: "", stderr: message, exitCode: 1 };
+    }
+}
+// ─── Seed helper (for testing / initial setup) ────────────────────────────────
+/**
+ * Seeds a PriorSet into the store if it doesn't already exist.
+ * Used by tests and the CLI init flow.
+ */
+export async function seedPriorSet(priorSetId, taskClass, priors, storeDir) {
+    const store = await loadPriorStore(storeDir);
+    if (store.priorSets.some(p => p.priorSetId === priorSetId))
+        return;
+    const ps = createPriorSet({ priorSetId, taskClass, priors });
+    store.priorSets.push(ps);
+    await savePriorStore(store, storeDir);
+}
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function parseFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx >= args.length - 1)
+        return undefined;
+    return args[idx + 1];
+}
+//# sourceMappingURL=prior.js.map

package/dist/vendor/cli/commands/resume.d.ts

@@ -0,0 +1,21 @@
+/**
+ * resume.ts — SLICE-23: Resumable loops CLI handler
+ *
+ * Usage: martin resume <loop-id> [--force]
+ *
+ * 1. Reads checkpoint from ~/.martin/loops/<loop-id>/checkpoint.json
+ * 2. Validates workspace hashes
+ * 3. If modified and no --force: prints error and exits with code 1
+ * 4. If valid (or --force): prints resume state and exits with instructions
+ *    (actual resume wiring into runMartin is future work — this slice ships
+ *     the checkpoint infrastructure and the CLI entry point)
+ * 5. Prints: "Resuming loop <id> from attempt <N>. Cost so far: $<M>"
+ */
+export interface ResumeCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function handleResumeCommand(args: string[], _options?: {
+    cwd?: string;
+}): Promise<ResumeCommandResult>;

package/dist/vendor/cli/commands/resume.js

@@ -0,0 +1,73 @@
+/**
+ * resume.ts — SLICE-23: Resumable loops CLI handler
+ *
+ * Usage: martin resume <loop-id> [--force]
+ *
+ * 1. Reads checkpoint from ~/.martin/loops/<loop-id>/checkpoint.json
+ * 2. Validates workspace hashes
+ * 3. If modified and no --force: prints error and exits with code 1
+ * 4. If valid (or --force): prints resume state and exits with instructions
+ *    (actual resume wiring into runMartin is future work — this slice ships
+ *     the checkpoint infrastructure and the CLI entry point)
+ * 5. Prints: "Resuming loop <id> from attempt <N>. Cost so far: $<M>"
+ */
+export async function handleResumeCommand(args, _options = {}) {
+    const loopId = readPositional(args);
+    const force = args.includes("--force");
+    if (!loopId) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: "Error: resume requires a loop ID. Usage: martin resume <loopId> [--force]"
+        };
+    }
+    const { getCheckpointStorageDir, readCheckpoint, validateWorkspaceHashes, WorkspaceModifiedError } = await import("../../core/index.js");
+    const storageDir = getCheckpointStorageDir();
+    const checkpoint = readCheckpoint(loopId, storageDir);
+    if (!checkpoint) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: `Error: no checkpoint found for loop ${loopId}. Run has not been interrupted or checkpoint was cleaned up.`
+        };
+    }
+    const { valid, modifiedFiles } = validateWorkspaceHashes(checkpoint, force);
+    if (!valid) {
+        const fileList = modifiedFiles.join(", ");
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: [
+                `Error: workspace has been modified since checkpoint for loop ${loopId}.`,
+                `Modified files: ${fileList}`,
+                "Use --force to resume anyway."
+            ].join("\n")
+        };
+    }
+    const resumeFromAttempt = checkpoint.lastCompletedAttempt + 1;
+    const costFormatted = checkpoint.costSoFar.toFixed(4);
+    const summary = [
+        `Resuming loop ${loopId} from attempt ${resumeFromAttempt}. Cost so far: $${costFormatted}`,
+        `Phase at checkpoint: ${checkpoint.phase}`,
+        `Last attempt rolled back: ${String(checkpoint.lastAttemptRolledBack)}`,
+        ...(force && modifiedFiles.length > 0
+            ? [`Warning: resuming with --force despite ${modifiedFiles.length} modified file(s).`]
+            : []),
+        "",
+        "Note: this command prints resume state only. Pass the loop ID to martin run to re-execute."
+    ].join("\n");
+    return {
+        exitCode: 0,
+        stdout: summary,
+        stderr: ""
+    };
+}
+function readPositional(args) {
+    for (const arg of args) {
+        if (!arg.startsWith("--")) {
+            return arg;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=resume.js.map

package/dist/vendor/cli/commands/verify.d.ts

@@ -0,0 +1,6 @@
+export interface VerifyCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function handleVerifyCommand(args: string[]): Promise<VerifyCommandResult>;

package/dist/vendor/cli/commands/verify.js

@@ -0,0 +1,43 @@
+import { join } from "node:path";
+import { resolveRunsRoot, verifyLoopRecordAttestation } from "../../core/index.js";
+export async function handleVerifyCommand(args) {
+    const loopId = parseFlag(args, "--loop") ?? args[0];
+    if (!loopId) {
+        return {
+            stdout: "",
+            stderr: "Missing --loop. Usage: martin verify --loop <id>",
+            exitCode: 1
+        };
+    }
+    const runRoot = join(resolveRunsRoot(process.env), loopId);
+    const verification = await verifyLoopRecordAttestation(runRoot);
+    if (verification.ok) {
+        return {
+            stdout: JSON.stringify({
+                command: "verify",
+                status: "passed",
+                loopId,
+                file: verification.file,
+                keyId: verification.keyId
+            }, null, 2),
+            stderr: "",
+            exitCode: 0
+        };
+    }
+    return {
+        stdout: "",
+        stderr: JSON.stringify({
+            command: "verify",
+            status: "failed",
+            loopId,
+            file: verification.file,
+            reason: verification.reason
+        }, null, 2),
+        exitCode: 1
+    };
+}
+function parseFlag(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+//# sourceMappingURL=verify.js.map

package/dist/vendor/cli/index.d.ts

@@ -1,4 +1,4 @@
-import { type LoopBudget } from "../contracts/index.js";
+import { type LoopBudget, type MutationMode } from "../contracts/index.js";
 export type RunCommandRequest = {
     workspaceId: string;
     projectId: string;
@@ -11,6 +11,7 @@ export type RunCommandRequest = {
     cwd?: string;
     model?: string;
     engine?: string;
+    mutationMode?: MutationMode;
     allowedPaths?: string[];
     deniedPaths?: string[];
     acceptanceCriteria?: string[];
@@ -23,6 +24,10 @@ export type ParsedCliArguments = {
 } | {
     command: "bench";
     suiteId: string;
+} | {
+    command: "demo";
+    directory: string;
+    force: boolean;
 } | {
     command: "inspect";
     file: string;

package/dist/vendor/cli/index.js

@@ -1,7 +1,8 @@
-import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { appendFile, cp, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import { createClaudeCliAdapter, createCodexCliAdapter, createStubDirectProviderAdapter } from "../adapters/index.js";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createClaudeCliAdapter, createCodexCliAdapter, createStubDirectProviderAdapter, createVerifierOnlyAdapter } from "../adapters/index.js";
 import { runMartin } from "../core/index.js";
 import { buildPortfolioSnapshot, createLoopRecord } from "../contracts/index.js";
 export async function executeCli(args) {
@@ -30,7 +31,7 @@ export async function executeCli(args) {
                 }
             };
             const workingDirectory = parsed.request.cwd ?? readOption(args, "--cwd") ?? process.cwd();
-            const adapter = selectAdapter(args, workingDirectory, parsed.request.model, parsed.request.engine);
+            const adapter = selectAdapter(args, workingDirectory, parsed.request.model, parsed.request.engine, parsed.request.mutationMode);
             let result;
             try {
                 result = await runMartin({
@@ -40,6 +41,7 @@ export async function executeCli(args) {
                         title: resolvedRequest.title,
                         objective: resolvedRequest.objective,
                         verificationPlan: resolvedRequest.verificationPlan,
+                        ...(resolvedRequest.mutationMode ? { mutationMode: resolvedRequest.mutationMode } : {}),
                         repoRoot: workingDirectory,
                         ...(resolvedRequest.allowedPaths?.length ? { allowedPaths: resolvedRequest.allowedPaths } : {}),
                         ...(resolvedRequest.deniedPaths?.length ? { deniedPaths: resolvedRequest.deniedPaths } : {}),
@@ -58,6 +60,7 @@ export async function executeCli(args) {
                         title: resolvedRequest.title,
                         objective: resolvedRequest.objective,
                         verificationPlan: resolvedRequest.verificationPlan,
+                        ...(resolvedRequest.mutationMode ? { mutationMode: resolvedRequest.mutationMode } : {}),
                         repoRoot: workingDirectory
                     },
                     budget: resolvedRequest.budget,
@@ -115,6 +118,27 @@ export async function executeCli(args) {
                 stderr: "The benchmark harness remains a workspace-only RC surface and is not part of the publishable @martin/cli boundary yet. Use pnpm --filter @martin/benchmarks test or pnpm --filter @martin/benchmarks eval:phase12 from the repo root instead."
             };
         }
+        case "demo": {
+            try {
+                const targetDirectory = await createDemoWorkspace({
+                    targetDirectory: parsed.directory,
+                    force: parsed.force
+                });
+                return {
+                    exitCode: 0,
+                    stdout: renderDemoInstructions(targetDirectory),
+                    stderr: ""
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: `Error: ${message}`
+                };
+            }
+        }
         case "inspect": {
             try {
                 const contents = await readFile(parsed.file, "utf8");
@@ -295,6 +319,9 @@ export function parseCliArguments(args) {
                     request.cwd = next;
                     index += 1;
                     break;
+                case "--verify-only":
+                    request.mutationMode = "verify_only";
+                    break;
                 case "--allow-path":
                     if (next) {
                         request.allowedPaths = [...(request.allowedPaths ?? []), next];
@@ -339,6 +366,7 @@ export function parseCliArguments(args) {
                 ...(request.cwd ? { cwd: request.cwd } : {}),
                 ...(request.model ? { model: request.model } : {}),
                 ...(request.engine ? { engine: request.engine } : {}),
+                ...(request.mutationMode ? { mutationMode: request.mutationMode } : {}),
                 ...(request.allowedPaths?.length ? { allowedPaths: request.allowedPaths } : {}),
                 ...(request.deniedPaths?.length ? { deniedPaths: request.deniedPaths } : {}),
                 ...(request.acceptanceCriteria?.length ? { acceptanceCriteria: request.acceptanceCriteria } : {})
@@ -351,6 +379,13 @@ export function parseCliArguments(args) {
             suiteId: readOption(rest, "--suite") ?? "ralphy-smoke"
         };
     }
+    if (command === "demo") {
+        return {
+            command: "demo",
+            directory: resolve(readOption(rest, "--dir") ?? join(process.cwd(), "martin-loop-demo")),
+            force: hasFlag(rest, "--force")
+        };
+    }
     if (command === "inspect") {
         return {
             command: "inspect",
@@ -373,12 +408,14 @@ export function renderCliHelp() {
         "  martin-loop run <objective> [options]",
         "  martin run <objective> [options]       (alias)",
         "  martin-loop run --objective <text> [options]",
+        "  martin-loop demo [--dir <path>] [--force]",
         "  martin-loop inspect --file <path>",
         "  martin-loop resume <loopId>",
         "  martin-loop bench --suite <suiteId>",
         "",
         "Commands:",
         "  run      Execute a bounded Martin loop against the current repository.",
+        "  demo     Copy a safe local sandbox so you can try MartinLoop outside your own repo.",
         "  inspect  Read a persisted loop record and summarize its portfolio metrics.",
         "  resume   Load a persisted loop record by loop ID from ~/.martin/runs/.",
         "  bench    Redirect to the workspace-only RC benchmark harness.",
@@ -390,12 +427,19 @@ export function renderCliHelp() {
         "  --cwd <path>            Set the repo root used for repo-backed runs.",
         "  --budget <n>            Set the hard cost cap in USD (subprocess killed at limit).",
         "  --budget-usd <n>        Alias for --budget.",
-        "  --verify <cmd>          Shell command to run as the verifier after each attempt.",
+        "  --soft-limit-usd <n>    Soft budget warning threshold in USD.",
         "  --max-iterations <n>    Set the maximum number of attempts.",
+        "  --max-tokens <n>        Set the maximum total token budget.",
+        "  --verify <cmd>          Shell command to run as the verifier after each attempt.",
+        "  --verify-only           Skip the coding adapter and run the verifier only.",
         "  --allow-path <glob>     Restrict agent writes to this path pattern (repeatable).",
         "  --deny-path <glob>      Block agent from this path pattern (repeatable).",
         "  --accept <criterion>    Add an acceptance criterion to the prompt (repeatable).",
-        "  --config <path>         Path to martin.config.yaml."
+        "  --config <path>         Path to martin.config.yaml.",
+        "",
+        "Demo options:",
+        "  --dir <path>            Target directory for the copied demo sandbox.",
+        "  --force                 Replace an existing non-empty demo target."
     ].join("\n");
 }
 function readOption(tokens, flag) {
@@ -418,6 +462,76 @@ function parseLoopRecords(contents) {
         return lines.map((line) => JSON.parse(line));
     }
 }
+async function createDemoWorkspace(input) {
+    const rootDir = await findMartinPackageRoot();
+    const sourceDirectory = join(rootDir, "demo", "seeded-workspace");
+    try {
+        await readdir(sourceDirectory);
+    }
+    catch (error) {
+        if (isNodeErrorWithCode(error, "ENOENT")) {
+            throw new Error(`Demo assets are missing from this install: ${sourceDirectory}`);
+        }
+        throw error;
+    }
+    const targetDirectory = resolve(input.targetDirectory);
+    const existingEntries = await readdir(targetDirectory).catch((error) => {
+        if (isNodeErrorWithCode(error, "ENOENT")) {
+            return undefined;
+        }
+        throw error;
+    });
+    if (existingEntries) {
+        if (existingEntries.length > 0 && !input.force) {
+            throw new Error(`Demo target already exists and is not empty: ${targetDirectory}. Re-run with --force to replace it.`);
+        }
+        await rm(targetDirectory, { force: true, recursive: true });
+    }
+    await mkdir(dirname(targetDirectory), { recursive: true });
+    await cp(sourceDirectory, targetDirectory, { recursive: true });
+    return targetDirectory;
+}
+async function findMartinPackageRoot() {
+    let currentDirectory = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 8; depth += 1) {
+        const manifestPath = join(currentDirectory, "package.json");
+        try {
+            const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+            if (manifest.name === "martin-loop") {
+                return currentDirectory;
+            }
+        }
+        catch (error) {
+            if (!isNodeErrorWithCode(error, "ENOENT")) {
+                throw error;
+            }
+        }
+        const parentDirectory = dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            break;
+        }
+        currentDirectory = parentDirectory;
+    }
+    throw new Error("Unable to resolve the martin-loop package root for demo assets.");
+}
+function renderDemoInstructions(targetDirectory) {
+    return [
+        `MartinLoop demo sandbox created at ${targetDirectory}`,
+        "",
+        "Next steps:",
+        `  cd ${targetDirectory}`,
+        "  npm install",
+        "  npm test",
+        "",
+        "Safe first run (no provider spend):",
+        '  MARTIN_LIVE=false npx martin-loop run "Summarize the demo workspace and confirm the verifier is green" --verify "npm test"',
+        "",
+        "Optional live run:",
+        '  npx martin-loop run "Add support for a discount percentage to summarizeInvoice and update the tests" --verify "npm test" --engine codex',
+        "",
+        `Task ideas live in ${join(targetDirectory, "TASKS.md")}`
+    ].join("\n");
+}
 async function resolveGuardrails(request, rawArgs) {
     const tokens = rawArgs.slice(1);
     const { config, configPath } = await loadGuardrailsConfig(request.configPath);
@@ -615,7 +729,10 @@ function isNodeErrorWithCode(error, code) {
  * --engine codex             — real Codex CLI subprocess
  * MARTIN_LIVE=false          — stub adapter (for tests / dry-runs)
  */
-function selectAdapter(rawArgs, workingDirectory, modelOverride, engineOverride) {
+function selectAdapter(rawArgs, workingDirectory, modelOverride, engineOverride, mutationMode) {
+    if (mutationMode === "verify_only") {
+        return createVerifierOnlyAdapter({ workingDirectory });
+    }
     if (process.env.MARTIN_LIVE === "false") {
         return createStubDirectProviderAdapter({
             label: "Stub adapter (MARTIN_LIVE=false)",