martin-loop 0.1.5 → 1.3.0

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

@@ -0,0 +1,281 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as readline from "node:readline/promises";
+const POLICY_EXAMPLE = `# martin.policy.yaml — runtime governance rules for Martin Loop
+# This file is safe to commit. It contains no secrets.
+# Secrets (API keys) always go in environment variables.
+
+budgetUsd:
+  perRun: 5.00       # hard cap per individual run
+  perDay: 50.00      # daily cap across all runs (informational)
+
+allowedVerifiers:
+  - "pnpm test"
+  - "bun run test"
+  - "npm test"
+  - "cargo test"
+  - "pytest"
+
+# Commands appended to the built-in leash block list
+blockedCommands:
+  # - "npm publish"
+  # - "git push --force"
+
+# Restrict which files martin may touch (glob, optional)
+# fileScopeGlob: "src/**"
+
+# Hard cap on attempts per run
+maxAttempts: 5
+
+# Pause and require human approval before spending above this
+requireApprovalAboveUsd: 2.00
+
+# SIEM integration (optional — requires SLICE-16)
+# siem:
+#   endpoint: "https://your-siem.example.com/events"
+#   format: "ocsf"   # or "cef"
+#   apiKey: "$SIEM_API_KEY"  # env var reference
+`;
+const MARTIN_CONFIG_TEMPLATE = (adapter, model) => `# martin.config.yaml
+# Core runtime configuration for Martin Loop.
+# Do not commit this file if it contains any secrets.
+
+policyProfile: balanced
+
+budget:
+  maxUsd: 5.00
+  softLimitUsd: 3.75
+  maxIterations: 5
+  maxTokens: 50000
+
+governance:
+  destructiveActionPolicy: approval
+  telemetryDestination: local-only
+  verifierRules:
+    - "pnpm test"
+`;
+const GH_ACTIONS_TEMPLATE = `# .github/workflows/martin-loop.yml
+# Martin Loop governed AI coding runtime — GitHub Actions integration
+# Docs: https://github.com/your-org/martin-loop
+
+name: Martin Loop
+
+on:
+  workflow_dispatch:
+    inputs:
+      objective:
+        description: "What should Martin Loop fix or implement?"
+        required: true
+      budget_usd:
+        description: "Hard budget cap for this run (USD)"
+        required: false
+        default: "5.00"
+  issue_comment:
+    types: [created]
+
+jobs:
+  martin:
+    # Trigger on workflow_dispatch OR on /martin comment in a PR
+    if: |
+      github.event_name == 'workflow_dispatch' ||
+      (github.event_name == 'issue_comment' &&
+       github.event.issue.pull_request != null &&
+       startsWith(github.event.comment.body, '/martin'))
+
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10.17.1
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install martin-loop
+        run: pnpm add -g @martin/cli
+
+      # Pre-flight check — fails the job if environment is misconfigured
+      - name: Pre-flight check
+        run: martin-loop doctor
+        env:
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+
+      - name: Run Martin Loop
+        id: martin
+        run: |
+          # Resolve objective from dispatch input or /martin comment
+          if [ "\${{ github.event_name }}" = "workflow_dispatch" ]; then
+            OBJECTIVE="\${{ github.event.inputs.objective }}"
+            BUDGET="\${{ github.event.inputs.budget_usd }}"
+          else
+            OBJECTIVE="\$(echo '\${{ github.event.comment.body }}' | sed 's|^/martin[[:space:]]*||')"
+            BUDGET="5.00"
+          fi
+
+          martin-loop run \\
+            --objective "\$OBJECTIVE" \\
+            --budget-usd "\$BUDGET" \\
+            --workspace "\${{ github.repository_owner }}" \\
+            --project "\${{ github.repository }}" \\
+            --json > martin-result.json
+        env:
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          MARTIN_NO_SUMMARY: "1"
+
+      - name: Upload audit artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: martin-loop-audit-\${{ github.run_id }}
+          path: ~/.martin/runs/
+          retention-days: 30
+
+      - name: Commit any changes from Martin Loop
+        run: |
+          git config user.name "martin-loop[bot]"
+          git config user.email "martin-loop[bot]@users.noreply.github.com"
+          git add -A
+          git diff --staged --quiet || git commit -m "feat(martin-loop): apply governed patch from run \${{ github.run_id }}"
+          git push
+
+      - name: Post PR comment with run summary
+        if: github.event_name == 'issue_comment'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            let body;
+            try {
+              const result = JSON.parse(fs.readFileSync('martin-result.json', 'utf8'));
+              const decision = result.decision ?? {};
+              const loop = result.loop ?? {};
+              const succeeded = decision.lifecycleState === 'succeeded';
+              const outcome = succeeded ? '✅ SUCCEEDED' : '❌ FAILED';
+              const cost = loop.costUsd ? \`$\${loop.costUsd.toFixed(2)}\` : 'n/a';
+              const loopId = loop.loopId ?? 'unknown';
+              body = [
+                \`## Martin Loop — \${outcome}\`,
+                \`\`,
+                \`| Field | Value |\`,
+                \`|---|---|\`,
+                \`| Outcome | \${decision.lifecycleState ?? 'unknown'} |\`,
+                \`| Cost | \${cost} |\`,
+                \`| Loop ID | \${loopId} |\`,
+                \`\`,
+                succeeded
+                  ? \`Patch applied and committed. Audit artifacts uploaded to this run's Actions artifacts.\`
+                  : \`Run failed. See Actions artifacts for the full audit trail.\\n\\nTip: martin-loop explain \${loopId}\`
+              ].join('\\n');
+            } catch (e) {
+              body = '## Martin Loop\\n\\nRun completed — see Actions artifacts for details.';
+            }
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body
+            });
+`;
+export async function handleInitCommand(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const force = args.includes("--force");
+    const nonInteractive = !process.stdin.isTTY || args.includes("--yes") || args.includes("-y");
+    const configPath = join(cwd, "martin.config.yaml");
+    const policyExamplePath = join(cwd, "martin.policy.yaml.example");
+    const ghWorkflowDir = join(cwd, ".github", "workflows");
+    const ghWorkflowPath = join(ghWorkflowDir, "martin-loop.yml");
+    // Guard against overwriting existing config without --force
+    if (!force && existsSync(configPath)) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: [
+                `martin.config.yaml already exists in ${cwd}.`,
+                `Use --force to overwrite, or delete it manually first.`
+            ].join("\n")
+        };
+    }
+    // Detect adapter from environment
+    const hasAnthropic = !!(process.env.ANTHROPIC_API_KEY && process.env.ANTHROPIC_API_KEY.length > 10);
+    const hasOpenAI = !!(process.env.OPENAI_API_KEY && process.env.OPENAI_API_KEY.length > 10);
+    let adapter = hasAnthropic ? "claude" : hasOpenAI ? "codex" : "claude";
+    let model = adapter === "claude" ? "claude-sonnet-4-6" : "gpt-4o";
+    // Ask for budget in interactive mode
+    let budget = "5.00";
+    let writeGhWorkflow = true;
+    if (!nonInteractive) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const budgetAnswer = await rl.question(`  Budget cap per run (USD) [default: 5.00]: `);
+            if (budgetAnswer.trim()) {
+                const parsed = parseFloat(budgetAnswer.trim());
+                if (!isNaN(parsed) && parsed > 0)
+                    budget = parsed.toFixed(2);
+            }
+            const ghAnswer = await rl.question(`  Write GitHub Actions workflow? (Y/n) [default: Y]: `);
+            writeGhWorkflow = !ghAnswer.trim() || ghAnswer.trim().toLowerCase() !== "n";
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const written = [];
+    // Write martin.config.yaml
+    await writeFile(configPath, MARTIN_CONFIG_TEMPLATE(adapter, model).replace("maxUsd: 5.00", `maxUsd: ${budget}`), "utf8");
+    written.push("  martin.config.yaml");
+    // Write martin.policy.yaml.example
+    await writeFile(policyExamplePath, POLICY_EXAMPLE, "utf8");
+    written.push("  martin.policy.yaml.example");
+    // Write GitHub Actions workflow
+    if (writeGhWorkflow) {
+        await mkdir(ghWorkflowDir, { recursive: true });
+        await writeFile(ghWorkflowPath, GH_ACTIONS_TEMPLATE, "utf8");
+        written.push("  .github/workflows/martin-loop.yml");
+    }
+    // Run doctor check after init
+    let doctorSummary = "";
+    try {
+        const { handleDoctorCommand } = await import("./doctor.js");
+        const doctorResult = await handleDoctorCommand([], { cwd });
+        doctorSummary = "\n" + doctorResult.stdout;
+    }
+    catch {
+        // Non-fatal
+    }
+    const credWarning = !hasAnthropic && !hasOpenAI
+        ? `\n  ⚠  No API key found. Set ANTHROPIC_API_KEY before running martin-loop.\n`
+        : "";
+    const output = [
+        "Martin Loop initialized.",
+        "",
+        "Written:",
+        ...written,
+        "",
+        "Add to .gitignore (optional — no secrets but env-specific):",
+        "  martin.config.yaml",
+        "",
+        credWarning,
+        "Next steps:",
+        "  1. Set ANTHROPIC_API_KEY in your environment or CI secrets",
+        "  2. Run: martin-loop doctor",
+        "  3. Run: martin-loop run --objective \"your first task\"",
+        "",
+        "Docs: https://github.com/your-org/martin-loop",
+        doctorSummary
+    ].filter((line) => line !== undefined).join("\n");
+    return { exitCode: 0, stdout: output, stderr: "" };
+}
+//# sourceMappingURL=init.js.map

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