martin-loop 0.1.5 → 1.3.0

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

@@ -0,0 +1,199 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { generateAuditPackFromRunDirectory, verifyAuditPack } from "@martin/contracts/audit";
+import { resolveRunsRoot } from "../../core/index.js";
+export async function handleAuditCommand(args, options = {}) {
+    const subcommand = args[0];
+    try {
+        switch (subcommand) {
+            case "generate": {
+                const runId = parseFlag(args, "--run-id");
+                const output = parseFlag(args, "--output") ?? join(options.cwd ?? process.cwd(), "audit-pack");
+                if (!runId) {
+                    return { stdout: "", stderr: "Missing --run-id", exitCode: 1 };
+                }
+                const result = await generateAuditPackFromRunDirectory({
+                    runId,
+                    runDir: join(resolveRunsRoot(process.env), runId),
+                    outputDir: output,
+                    generatedBy: "martin"
+                });
+                return {
+                    stdout: JSON.stringify({
+                        command: "audit.generate",
+                        runId,
+                        packPath: result.packPath,
+                        manifest: result.manifest
+                    }, null, 2),
+                    stderr: "",
+                    exitCode: 0
+                };
+            }
+            case "verify": {
+                const pack = parseFlag(args, "--pack");
+                if (!pack) {
+                    return { stdout: "", stderr: "Missing --pack", exitCode: 1 };
+                }
+                const result = await verifyAuditPack(pack);
+                return formatVerificationResult(result);
+            }
+            case "show": {
+                const runId = parseFlag(args, "--run-id");
+                if (!runId) {
+                    return { stdout: "", stderr: "Missing --run-id", exitCode: 1 };
+                }
+                const runsRoot = parseFlag(args, "--runs-root") ?? resolveRunsRoot(process.env);
+                const summary = await summarizeRunAudit(join(runsRoot, runId), runId);
+                return {
+                    stdout: JSON.stringify({
+                        command: "audit.show",
+                        ...summary
+                    }, null, 2),
+                    stderr: "",
+                    exitCode: 0
+                };
+            }
+            case "log-verify": {
+                const { runAuditLogVerify } = await import("./audit-log-verify.js");
+                const from = parseFlag(args, "--from");
+                const to = parseFlag(args, "--to");
+                const runsRoot = parseFlag(args, "--runs-root");
+                const result = await runAuditLogVerify({ from, to, runsRoot });
+                const output = JSON.stringify({
+                    command: "audit.log-verify",
+                    ...result,
+                }, null, 2);
+                if (result.verdict === "PASS") {
+                    return { stdout: output, stderr: "", exitCode: 0 };
+                }
+                return { stdout: "", stderr: output, exitCode: 1 };
+            }
+            default:
+                return {
+                    stdout: "",
+                    stderr: [
+                        "Usage: martin audit <subcommand> [options]",
+                        "",
+                        "Subcommands:",
+                        "  generate --run-id <id> --output <dir>   Generate audit pack",
+                        "  verify --pack <dir>                     Verify audit pack manifest",
+                        "  show --run-id <id> [--runs-root <dir>]  Summarize persisted run audit evidence",
+                        "  log-verify [--from ISO] [--to ISO]      Verify Ed25519 signatures across run log"
+                    ].join("\n"),
+                    exitCode: 1
+                };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { stdout: "", stderr: message, exitCode: 1 };
+    }
+}
+async function summarizeRunAudit(runDir, runId) {
+    const [contract, state, loop, ledger, attemptDirs] = await Promise.all([
+        readJsonIfExists(join(runDir, "contract.json")),
+        readJsonIfExists(join(runDir, "state.json")),
+        readJsonIfExists(join(runDir, "loop-record.json")),
+        readLedgerIfExists(join(runDir, "ledger.jsonl")),
+        readAttemptDirs(join(runDir, "artifacts"))
+    ]);
+    const eventKinds = ledger.reduce((counts, event) => {
+        const kind = typeof event.kind === "string" ? event.kind : "unknown";
+        counts[kind] = (counts[kind] ?? 0) + 1;
+        return counts;
+    }, {});
+    const loopRecord = isRecord(loop) ? loop : undefined;
+    const contractRecord = isRecord(contract) ? contract : undefined;
+    const stateRecord = isRecord(state) ? state : undefined;
+    const task = isRecord(loopRecord?.task)
+        ? loopRecord.task
+        : isRecord(contractRecord?.task)
+            ? contractRecord.task
+            : undefined;
+    return {
+        runId,
+        runDir,
+        status: asString(loopRecord?.status) ?? "unknown",
+        lifecycleState: asString(loopRecord?.lifecycleState) ?? asString(stateRecord?.phase) ?? null,
+        taskTitle: asString(task?.title) ?? null,
+        attempts: Array.isArray(loopRecord?.attempts) ? loopRecord.attempts.length : attemptDirs.length,
+        ledgerEvents: ledger.length,
+        eventKinds,
+        cost: isRecord(loopRecord?.cost) ? loopRecord.cost : null,
+        artifacts: {
+            hasContract: contract !== null,
+            hasState: state !== null,
+            hasLoopRecord: loop !== null,
+            attemptDirs
+        }
+    };
+}
+async function readJsonIfExists(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function readLedgerIfExists(path) {
+    try {
+        const contents = await readFile(path, "utf8");
+        return contents
+            .trim()
+            .split(/\r?\n/u)
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+async function readAttemptDirs(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith("attempt-"))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function formatVerificationResult(result) {
+    if (result.ok) {
+        return {
+            stdout: JSON.stringify({
+                command: "audit.verify",
+                status: "passed",
+                manifest: result.manifest,
+                checkedFiles: result.checkedFiles.length
+            }, null, 2),
+            stderr: "",
+            exitCode: 0
+        };
+    }
+    return {
+        stdout: "",
+        stderr: JSON.stringify({
+            command: "audit.verify",
+            status: "failed",
+            failures: result.failures
+        }, null, 2),
+        exitCode: 1
+    };
+}
+function parseFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx >= args.length - 1)
+        return undefined;
+    return args[idx + 1];
+}
+//# sourceMappingURL=audit.js.map

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

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

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

@@ -0,0 +1,60 @@
+import { computeCorpusStats, loadCorpus, resolveEntry, resolveCorpusPath, saveCorpus } from "@martin/trace-intelligence";
+export async function handleCorpusCommand(args) {
+    const subcommand = args[0];
+    const corpusPath = resolveCorpusPath();
+    try {
+        const corpus = await loadCorpus(corpusPath);
+        switch (subcommand) {
+            case "show":
+            case undefined: {
+                const stats = computeCorpusStats(corpus);
+                const lines = [
+                    `Corpus: ${corpusPath}`,
+                    `Entries: ${stats.totalEntries} (${stats.resolvedEntries} resolved, ${stats.activeEntries} open)`,
+                    ""
+                ];
+                if (corpus.entries.length === 0) {
+                    lines.push("No patterns in corpus yet. Run martin analyze to populate.");
+                }
+                else {
+                    for (const entry of corpus.entries) {
+                        const resolved = entry.resolved ? "[resolved]" : "[open]    ";
+                        lines.push(`${resolved} ${entry.fingerprint.slice(0, 12)} ${entry.kind} (${entry.severity}) — seen ${entry.occurrenceCount}x, ${entry.totalAffectedRuns} runs`);
+                    }
+                }
+                return { exitCode: 0, stdout: lines.join("\n"), stderr: "" };
+            }
+            case "clear": {
+                const cleared = { ...corpus, entries: [], updatedAt: new Date().toISOString() };
+                await saveCorpus(cleared, corpusPath);
+                return { exitCode: 0, stdout: `Corpus cleared (${corpus.entries.length} entries removed).`, stderr: "" };
+            }
+            case "resolve": {
+                const fingerprint = args[1];
+                if (!fingerprint) {
+                    return { exitCode: 1, stdout: "", stderr: "Usage: martin corpus resolve <fingerprint>" };
+                }
+                try {
+                    const updated = resolveEntry(corpus, fingerprint);
+                    await saveCorpus(updated, corpusPath);
+                    return { exitCode: 0, stdout: `Entry ${fingerprint} marked as resolved.`, stderr: "" };
+                }
+                catch (resolveErr) {
+                    const msg = resolveErr instanceof Error ? resolveErr.message : String(resolveErr);
+                    return { exitCode: 1, stdout: "", stderr: msg };
+                }
+            }
+            default:
+                return {
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: `Unknown corpus subcommand: ${subcommand}\nUsage: martin corpus [show|clear|resolve <fingerprint>]`
+                };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { exitCode: 1, stdout: "", stderr: `Error: ${message}` };
+    }
+}
+//# sourceMappingURL=corpus.js.map

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

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

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

@@ -0,0 +1,219 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+const RUNS_ROOT = join(homedir(), ".martin", "runs");
+const CONFIG_SEARCH_PATHS = [
+    join(process.cwd(), "martin.config.yaml"),
+    join(homedir(), ".martin", "martin.config.yaml")
+];
+export async function handleDoctorCommand(args, options = {}) {
+    const checkFilter = parseFlag(args, "--check");
+    const allMode = args.includes("--all");
+    const checks = await runChecks(checkFilter, options.cwd ?? process.cwd());
+    const failed = checks.filter((c) => c.status === "fail");
+    const passed = checks.filter((c) => c.status === "pass");
+    if (args.includes("--json")) {
+        return {
+            exitCode: failed.length > 0 ? 1 : 0,
+            stdout: JSON.stringify({ checks, passed: passed.length, failed: failed.length }, null, 2),
+            stderr: ""
+        };
+    }
+    const lines = [
+        "martin doctor",
+        "─".repeat(54)
+    ];
+    for (const check of checks) {
+        const icon = check.status === "pass" ? "✓" : check.status === "skip" ? "─" : "✗";
+        const label = check.name.padEnd(34);
+        const detail = check.detail;
+        lines.push(`${icon}  ${label} ${detail}`);
+        if (check.status === "fail" && check.hint) {
+            lines.push(`   ${" ".repeat(34)} Hint: ${check.hint}`);
+        }
+    }
+    lines.push("─".repeat(54));
+    if (failed.length === 0) {
+        lines.push(`All ${passed.length} checks passed. Martin Loop is ready.`);
+    }
+    else {
+        const plural = failed.length === 1 ? "check" : "checks";
+        lines.push(`${failed.length} ${plural} failed. Fix the above and re-run martin doctor.`);
+    }
+    return {
+        exitCode: failed.length > 0 ? 1 : 0,
+        stdout: lines.join("\n"),
+        stderr: ""
+    };
+}
+async function runChecks(filter, cwd) {
+    const allChecks = [
+        { id: "credentials", fn: checkAdapterCredentials },
+        { id: "budget", fn: () => checkBudgetConfig(cwd) },
+        { id: "policy", fn: () => checkPolicyFile(cwd) },
+        { id: "leash", fn: checkLeashConfig },
+        { id: "store", fn: checkRunStore },
+    ];
+    const selected = filter
+        ? allChecks.filter((c) => c.id === filter)
+        : allChecks;
+    const results = [];
+    for (const check of selected) {
+        try {
+            results.push(await check.fn());
+        }
+        catch (err) {
+            results.push({
+                name: check.id,
+                status: "fail",
+                detail: "FAIL — unexpected error",
+                hint: err instanceof Error ? err.message : String(err)
+            });
+        }
+    }
+    return results;
+}
+async function checkAdapterCredentials() {
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (anthropicKey && anthropicKey.length > 10) {
+        return {
+            name: "Adapter credentials",
+            status: "pass",
+            detail: "OK  (ANTHROPIC_API_KEY set)"
+        };
+    }
+    if (openaiKey && openaiKey.length > 10) {
+        return {
+            name: "Adapter credentials",
+            status: "pass",
+            detail: "OK  (OPENAI_API_KEY set)"
+        };
+    }
+    return {
+        name: "Adapter credentials",
+        status: "fail",
+        detail: "FAIL — no API key found",
+        hint: "Set ANTHROPIC_API_KEY or OPENAI_API_KEY in your environment"
+    };
+}
+async function checkBudgetConfig(cwd) {
+    // Check for config file with a budget set
+    for (const configPath of [join(cwd, "martin.config.yaml"), ...CONFIG_SEARCH_PATHS]) {
+        try {
+            const contents = await readFile(configPath, "utf8");
+            const maxUsdMatch = contents.match(/maxUsd:\s*([0-9.]+)/);
+            const maxUsdValue = maxUsdMatch?.[1];
+            if (maxUsdValue) {
+                const val = parseFloat(maxUsdValue);
+                if (val > 0) {
+                    return {
+                        name: "Budget configured",
+                        status: "pass",
+                        detail: `OK  ($${val.toFixed(2)} max per run in ${basename(configPath)})`
+                    };
+                }
+            }
+        }
+        catch { /* not found — continue */ }
+    }
+    return {
+        name: "Budget configured",
+        status: "pass",
+        detail: "OK  (using default $10.00 — set maxUsd in martin.config.yaml to override)"
+    };
+}
+async function checkPolicyFile(cwd) {
+    const policyPaths = [
+        join(cwd, "martin.policy.yaml"),
+        join(homedir(), ".martin", "martin.policy.yaml")
+    ];
+    for (const policyPath of policyPaths) {
+        try {
+            const contents = await readFile(policyPath, "utf8");
+            // Basic YAML validation: check for obvious typos in known fields
+            const knownFields = ["budgetUsd", "allowedVerifiers", "blockedCommands", "fileScopeGlob", "maxAttempts", "requireApprovalAboveUsd", "siem", "cveCheck", "circuitBreaker", "output"];
+            const lines = contents.split("\n");
+            for (const line of lines) {
+                const topLevelMatch = line.match(/^([A-Za-z][\w-]*):/);
+                const key = topLevelMatch?.[1];
+                if (key) {
+                    if (!knownFields.includes(key)) {
+                        return {
+                            name: "Policy file",
+                            status: "fail",
+                            detail: `FAIL — ${basename(policyPath)}: unknown field '${key}'`,
+                            hint: `Known fields: ${knownFields.join(", ")}`
+                        };
+                    }
+                }
+            }
+            return {
+                name: "Policy file",
+                status: "pass",
+                detail: `OK  (${basename(policyPath)} valid)`
+            };
+        }
+        catch { /* not found — continue */ }
+    }
+    return {
+        name: "Policy file",
+        status: "pass",
+        detail: "OK  (no policy file — using built-in defaults)"
+    };
+}
+async function checkLeashConfig() {
+    // Leash is part of core — if the relevant exports are importable, the guard is active.
+    try {
+        const core = await import("../../core/index.js");
+        if (typeof core.evaluateVerificationLeash === "function") {
+            return {
+                name: "Leash config",
+                status: "pass",
+                detail: "OK  (verification leash loaded)"
+            };
+        }
+        return {
+            name: "Leash config",
+            status: "fail",
+            detail: "FAIL — leash export missing from @martin/core",
+            hint: "Run: pnpm --filter @martin/core build"
+        };
+    }
+    catch (err) {
+        return {
+            name: "Leash config",
+            status: "fail",
+            detail: "FAIL — @martin/core failed to import",
+            hint: "Run: pnpm build in the repo root"
+        };
+    }
+}
+async function checkRunStore() {
+    try {
+        await mkdir(RUNS_ROOT, { recursive: true });
+        // Test write access by creating and removing a temp file
+        const testPath = join(RUNS_ROOT, `.doctor-check-${Date.now()}`);
+        await writeFile(testPath, "ok", "utf8");
+        const { unlink } = await import("node:fs/promises");
+        await unlink(testPath);
+        return {
+            name: "Run store writable",
+            status: "pass",
+            detail: `OK  (${RUNS_ROOT.replace(homedir(), "~")})`
+        };
+    }
+    catch (err) {
+        return {
+            name: "Run store writable",
+            status: "fail",
+            detail: `FAIL — cannot write to ${RUNS_ROOT}`,
+            hint: `Check permissions on ${RUNS_ROOT} or set MARTIN_RUNS_ROOT env var`
+        };
+    }
+}
+function parseFlag(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+//# sourceMappingURL=doctor.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * explain.ts — SLICE-25
+ *
+ * CLI command: martin explain <loop-id>
+ *
+ * Reads stored run artifacts from ~/.martin/loops/<loop-id>/ and produces
+ * plain-English Markdown (or JSON) explaining every gate decision.
+ * No model calls — pure artifact reading.
+ */
+export interface ExplainCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function handleExplainCommand(args: string[], options?: {
+    cwd?: string;
+}): Promise<ExplainCommandResult>;

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

@@ -0,0 +1,176 @@
+/**
+ * explain.ts — SLICE-25
+ *
+ * CLI command: martin explain <loop-id>
+ *
+ * Reads stored run artifacts from ~/.martin/loops/<loop-id>/ and produces
+ * plain-English Markdown (or JSON) explaining every gate decision.
+ * No model calls — pure artifact reading.
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { formatRunExplanation, formatRunTimeline, resolveRunsRoot } from "../../core/index.js";
+export async function handleExplainCommand(args, options = {}) {
+    // Extract loop-id — first positional argument
+    const loopId = args.find(a => !a.startsWith("--")) ?? "";
+    if (!loopId) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: "Error: explain requires a loop ID. Usage: martin explain <loop-id> [--attempt N] [--decision <gate>] [--timeline] [--html] [--json] [--debug]"
+        };
+    }
+    const attemptFlag = parseFlag(args, "--attempt");
+    const decisionFlag = parseFlag(args, "--decision");
+    const timelineMode = args.includes("--timeline");
+    const htmlMode = args.includes("--html");
+    const jsonMode = args.includes("--json");
+    const debugMode = args.includes("--debug");
+    const loopDir = await resolveExplainDirectory(loopId);
+    // Attempt to load artifacts
+    let artifacts;
+    try {
+        artifacts = await loadArtifacts(loopDir, debugMode);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const isNotFound = message.includes("ENOENT") || message.includes("no such file");
+        if (isNotFound) {
+            return {
+                exitCode: 1,
+                stdout: "",
+                stderr: `No artifacts found for loop ${loopId}. Run \`martin doctor\` to check your storage path.`
+            };
+        }
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: `Error reading artifacts: ${message}`
+        };
+    }
+    if (timelineMode) {
+        try {
+            const timelineData = await loadTimelineData(loopDir);
+            const result = formatRunTimeline({
+                loopId,
+                objective: timelineData.objective,
+                lifecycleState: timelineData.lifecycleState,
+                events: timelineData.events,
+                ledgerEvents: timelineData.ledgerEvents
+            });
+            if (jsonMode) {
+                return {
+                    exitCode: 0,
+                    stdout: JSON.stringify(result.json, null, 2),
+                    stderr: ""
+                };
+            }
+            return {
+                exitCode: 0,
+                stdout: htmlMode ? result.html : result.markdown,
+                stderr: ""
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                exitCode: 1,
+                stdout: "",
+                stderr: `Error building timeline: ${message}`
+            };
+        }
+    }
+    if (artifacts.length === 0) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: `No artifacts found for loop ${loopId}. Run \`martin doctor\` to check your storage path.`
+        };
+    }
+    const result = formatRunExplanation(artifacts, {
+        loopId,
+        attemptFilter: attemptFlag != null ? parseInt(attemptFlag, 10) : undefined,
+        decisionFilter: decisionFlag ?? undefined,
+        json: jsonMode
+    });
+    if (jsonMode) {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify(result.json, null, 2),
+            stderr: ""
+        };
+    }
+    return {
+        exitCode: 0,
+        stdout: result.markdown,
+        stderr: ""
+    };
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function loadArtifacts(loopDir, debug) {
+    const entries = await readdir(loopDir);
+    const artifactFiles = entries.filter(f => f.endsWith(".json") && (f.startsWith("attempt-") || f.includes("artifact")));
+    const artifacts = [];
+    for (const file of artifactFiles.sort()) {
+        try {
+            const raw = await readFile(join(loopDir, file), "utf8");
+            const parsed = JSON.parse(raw);
+            artifacts.push(parsed);
+        }
+        catch (err) {
+            if (debug) {
+                const msg = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`[debug] skipped ${file}: ${msg}\n`);
+            }
+            // Non-fatal — skip malformed artifact files
+        }
+    }
+    // Also accept a single loop-record.json that may contain an attempts array
+    if (artifacts.length === 0 && entries.includes("loop-record.json")) {
+        const raw = await readFile(join(loopDir, "loop-record.json"), "utf8");
+        const record = JSON.parse(raw);
+        if (Array.isArray(record.attempts)) {
+            return record.attempts;
+        }
+    }
+    return artifacts;
+}
+async function loadTimelineData(loopDir) {
+    const loopRecordRaw = await readFile(join(loopDir, "loop-record.json"), "utf8");
+    const loopRecord = JSON.parse(loopRecordRaw);
+    const ledgerPath = join(loopDir, "ledger.jsonl");
+    const ledgerRaw = await readFile(ledgerPath, "utf8");
+    const ledgerEvents = ledgerRaw
+        .split(/\r?\n/u)
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+    return {
+        objective: loopRecord.task?.objective ?? "unknown",
+        ...(loopRecord.lifecycleState ? { lifecycleState: loopRecord.lifecycleState } : {}),
+        events: loopRecord.events ?? [],
+        ledgerEvents
+    };
+}
+async function resolveExplainDirectory(loopId) {
+    const roots = [
+        resolveRunsRoot(process.env),
+        join(homedir(), ".martin", "loops")
+    ];
+    for (const root of roots) {
+        const candidate = join(root, loopId);
+        try {
+            await readdir(candidate);
+            return candidate;
+        }
+        catch {
+            // Try the next legacy root.
+        }
+    }
+    return join(roots[0] ?? join(homedir(), ".martin", "runs"), loopId);
+}
+function parseFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+//# sourceMappingURL=explain.js.map