martin-loop 0.1.4 → 1.3.0

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

@@ -0,0 +1,396 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { buildAutonomousPromotionArtifact, buildCoreAutonomousPromotionArtifactInput, buildImprovementEvidenceSummary, buildImprovementResult, buildImprovementTask, ensureCanonicalAttemptEvidenceArtifacts, resolveImprovementArtifactPaths, selectTopImprovementTarget, writeAutonomousPromotionArtifact, writeImprovementResultArtifact, writePostChangeHoldoutArtifact } from "@martin/trace-intelligence";
+export async function handleImproveCommand(args) {
+    const reportPath = parseFlag(args, "--report") ?? "trace-report.json";
+    const rawPatternKind = parseFlag(args, "--pattern");
+    const dryRun = args.includes("--dry-run");
+    const live = args.includes("--live");
+    const certifyTraceAutonomy = args.includes("--certify-trace-autonomy");
+    const traceAutonomyNegativeControl = args.includes("--negative-control") ||
+        process.env["MARTIN_TRACE_AUTONOMY_NEGATIVE_CONTROL"] === "1" ||
+        process.env["MARTIN_TRACE_AUTONOMY_NEGATIVE_CONTROL"]?.toLowerCase() === "true";
+    if (dryRun && live) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: "Choose either --dry-run or --live; trace-autonomy certification previews are available in --dry-run mode."
+        };
+    }
+    // Validate pattern kind before reading report — prevents confusing downstream errors
+    const VALID_PATTERN_KINDS = new Set([
+        "oscillation_loop", "budget_blowout", "grounding_cluster", "scope_creep_pattern",
+        "hallucinated_tool_calls", "refusal_loop", "verification_blind_spot",
+        "recovery_exhaustion", "stagnation_signature", "admission_churn"
+    ]);
+    if (rawPatternKind && !VALID_PATTERN_KINDS.has(rawPatternKind)) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: `Invalid pattern kind: "${rawPatternKind}". Valid: ${[...VALID_PATTERN_KINDS].join(", ")}`
+        };
+    }
+    const patternKind = rawPatternKind;
+    try {
+        const repoRoot = resolveImproveRepoRoot();
+        const raw = await readFile(resolve(reportPath), "utf8").catch(() => {
+            throw new Error(`Trace report not found at ${reportPath}. Run martin analyze first.`);
+        });
+        const report = JSON.parse(raw);
+        let target = selectTopImprovementTarget(report);
+        if (patternKind) {
+            const match = report.patterns.find(p => p.kind === patternKind);
+            if (!match) {
+                return {
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: `No pattern of kind "${patternKind}" found in the report.\nAvailable: ${report.patterns.map(p => p.kind).join(", ") || "none"}`
+                };
+            }
+            target = match;
+        }
+        if (!target) {
+            return {
+                exitCode: 0,
+                stdout: "No patterns found in the report — nothing to improve.",
+                stderr: ""
+            };
+        }
+        const task = buildImprovementTask(target, {
+            repoRoot,
+            surfaceScope: certifyTraceAutonomy ? "trace_autonomy_stage1" : "phase3_default"
+        });
+        const dryRunPaths = resolveImprovementArtifactPaths(resolve(repoRoot, ".martin", "improvements"), task.loopTask.metadata.candidateId ?? target.kind);
+        const dryRunEvidence = buildImprovementEvidenceSummary(task, dryRunPaths);
+        const dryRunCertificationMetadata = await buildOptionalTraceAutonomyCertificationMetadata({
+            source: "cli.improve",
+            stage: "stage_1_trace_intelligence_only",
+            mode: "dry_run",
+            report,
+            targetPattern: target,
+            task,
+            evidence: dryRunEvidence,
+            artifactPaths: dryRunPaths,
+            runsRoot: resolve(repoRoot, ".martin", "improvements")
+        });
+        if (dryRun) {
+            return {
+                exitCode: 0,
+                stdout: JSON.stringify({
+                    dryRun: true,
+                    targetPattern: target.kind,
+                    severity: target.severity,
+                    affectedRunCount: target.affectedRunCount,
+                    ...dryRunEvidence,
+                    ...dryRunCertificationMetadata,
+                    traceAutonomyCertificationMode: "preview_only",
+                    loopTask: task.loopTask
+                }, null, 2),
+                stderr: ""
+            };
+        }
+        // Real run: import core and execute the improvement task
+        const core = await import("../../core/index.js");
+        const { runMartin, createFileRunStore, resolveRunsRoot } = core;
+        const { createClaudeCliAdapter, createCodexCliAdapter } = await import("../../adapters/index.js");
+        const runsRoot = resolveRunsRoot(process.env);
+        const store = createFileRunStore({ runsRoot });
+        const adapterSelection = resolveImproveAdapterSelection(args, process.env);
+        const adapterOptions = {
+            workingDirectory: repoRoot,
+            timeoutMs: resolveImproveLiveAdapterTimeoutMs(),
+            ...(adapterSelection.model ? { model: adapterSelection.model } : {})
+        };
+        const adapter = adapterSelection.engine === "codex"
+            ? createCodexCliAdapter(adapterOptions)
+            : createClaudeCliAdapter(adapterOptions);
+        const maxIterations = resolveImproveMaxIterations(args, process.env, {
+            certifyTraceAutonomy
+        });
+        const beforeArtifactMaterial = `${JSON.stringify(report, null, 2)}\n`;
+        // Certification runs must produce one auditable ledger entry per invocation;
+        // retries are disabled there so partial evidence cannot be hidden by a later pass.
+        const TRANSIENT_PATTERNS = ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "spawn"];
+        const retryLimit = resolveImproveRetryLimit({ certifyTraceAutonomy });
+        let result;
+        let livePaths;
+        let lastErr;
+        for (let attempt = 0; attempt < retryLimit; attempt++) {
+            const reservedLoopId = createReservedLoopId("improve");
+            const attemptLivePaths = resolveImprovementArtifactPaths(runsRoot, reservedLoopId);
+            try {
+                await writeTextArtifact(attemptLivePaths.beforeArtifactPath, beforeArtifactMaterial);
+                result = await runMartin({
+                    workspaceId: "ws_improve",
+                    projectId: "proj_improve",
+                    task: task.loopTask,
+                    budget: { maxUsd: 2.0, softLimitUsd: 1.5, maxIterations, maxTokens: 20_000 },
+                    adapter,
+                    idFactory: createReservedLoopIdFactory(reservedLoopId),
+                    store
+                });
+                if (result.loop.loopId !== reservedLoopId) {
+                    throw new Error(`Reserved loop id mismatch: expected ${reservedLoopId}, got ${result.loop.loopId}.`);
+                }
+                livePaths = attemptLivePaths;
+                break;
+            }
+            catch (err) {
+                lastErr = err;
+                const msg = err instanceof Error ? err.message : String(err);
+                const isTransient = TRANSIENT_PATTERNS.some(p => msg.includes(p));
+                if (!isTransient || attempt === retryLimit - 1)
+                    throw err;
+                await new Promise(res => setTimeout(res, 2 ** attempt * 1000));
+            }
+        }
+        if (!result || !livePaths)
+            throw lastErr;
+        const liveEvidence = buildImprovementEvidenceSummary(task, livePaths, {
+            allowAutonomousPromotion: certifyTraceAutonomy && !traceAutonomyNegativeControl
+        });
+        const improvementResult = buildImprovementResult(target, result.loop.loopId, summarizeTraceReport(report), undefined);
+        await writeImprovementResultArtifact(livePaths.improvementResultPath, improvementResult);
+        await ensureCanonicalAttemptEvidenceArtifacts({
+            runsRoot,
+            loopRunId: result.loop.loopId,
+            attemptCount: result.loop.attempts.length,
+            beforeArtifactPath: livePaths.beforeArtifactPath,
+            improvementResultPath: livePaths.improvementResultPath,
+            reason: result.loop.attempts.length === 0
+                ? "pre_attempt_policy_denial_no_mutation"
+                : "fail_closed_no_tracked_mutation",
+            createdAt: result.loop.updatedAt
+        });
+        await writePostChangeHoldoutArtifact(livePaths.holdoutArtifactPath, {
+            task,
+            loopRunId: result.loop.loopId,
+            runsRoot,
+            beforeArtifactMaterial,
+            beforeArtifactPath: livePaths.beforeArtifactPath,
+            improvementResultPath: livePaths.improvementResultPath,
+            verifierImproved: result.decision.lifecycleState === "completed",
+            budgetCritical: result.loop.cost.actualUsd >= result.loop.budget.maxUsd,
+            attemptCount: result.loop.attempts.length,
+            groundingFailureCount: countGroundingFailures(result.loop)
+        });
+        const autonomousPromotionArtifact = await buildCoreCompatibleAutonomousPromotionArtifact(core, task, liveEvidence, result.loop.loopId, runsRoot, beforeArtifactMaterial, livePaths.beforeArtifactPath, livePaths.improvementResultPath, livePaths.holdoutArtifactPath, result.decision.lifecycleState === "completed", result.loop.cost.actualUsd >= result.loop.budget.maxUsd, result.loop.attempts.length, report, countGroundingFailures(result.loop));
+        await persistSignedAutonomousPromotionArtifact(core, resolve(runsRoot, result.loop.loopId), livePaths.autonomousPromotionPath, autonomousPromotionArtifact);
+        const liveCertificationMetadata = await buildOptionalTraceAutonomyCertificationMetadata({
+            source: "cli.improve",
+            stage: "stage_1_trace_intelligence_only",
+            mode: "live",
+            recordCertificationEvidence: certifyTraceAutonomy,
+            report,
+            targetPattern: target,
+            task,
+            evidence: liveEvidence,
+            artifactPaths: livePaths,
+            runsRoot,
+            loopRunId: result.loop.loopId,
+            loopOutcome: result.decision.lifecycleState,
+            costUsd: result.loop.cost.actualUsd,
+            attemptCount: result.loop.attempts.length,
+            negativeControl: traceAutonomyNegativeControl,
+            improvementResult,
+            autonomousPromotionArtifact
+        });
+        return {
+            exitCode: result.decision.lifecycleState === "completed" ? 0 : 1,
+            stdout: JSON.stringify({
+                outcome: result.decision.lifecycleState,
+                targetPattern: target.kind,
+                loopId: result.loop.loopId,
+                cost: result.loop.cost.actualUsd,
+                ...mergeArtifactEvidence(liveEvidence, autonomousPromotionArtifact),
+                ...liveCertificationMetadata,
+                traceAutonomyCertificationMode: certifyTraceAutonomy ? "recorded" : "preview_only"
+            }, null, 2),
+            stderr: ""
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { exitCode: 1, stdout: "", stderr: `Error: ${message}` };
+    }
+}
+function parseFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+function parsePositiveInteger(raw, label) {
+    if (raw === undefined || raw.trim() === "") {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return value;
+}
+export function resolveImproveAdapterSelection(args, env = process.env) {
+    const rawEngine = (parseFlag(args, "--engine") ?? env["MARTIN_CLI_IMPROVE_ENGINE"] ?? "claude")
+        .trim()
+        .toLowerCase();
+    if (rawEngine !== "claude" && rawEngine !== "codex") {
+        throw new Error(`--engine must be "claude" or "codex", got "${rawEngine}".`);
+    }
+    const model = (parseFlag(args, "--model") ?? env["MARTIN_CLI_IMPROVE_MODEL"])?.trim();
+    return {
+        engine: rawEngine,
+        ...(model ? { model } : {})
+    };
+}
+export function resolveImproveLiveAdapterTimeoutMs(env = process.env) {
+    const configured = Number(env["MARTIN_CLI_AGENT_TIMEOUT_MS"]);
+    return Number.isFinite(configured) && configured > 0 ? Math.floor(configured) : 300_000;
+}
+export function resolveImproveMaxIterations(args, env = process.env, options = {}) {
+    const configured = parsePositiveInteger(parseFlag(args, "--max-iterations") ?? env["MARTIN_CLI_IMPROVE_MAX_ITERATIONS"], "--max-iterations");
+    if (configured !== undefined) {
+        return configured;
+    }
+    return options.certifyTraceAutonomy ? 1 : 3;
+}
+export function resolveImproveRetryLimit(options = {}) {
+    return options.certifyTraceAutonomy ? 1 : 3;
+}
+function resolveImproveRepoRoot() {
+    const explicitRoot = process.env.MARTIN_REPO_ROOT?.trim();
+    if (explicitRoot) {
+        return resolve(explicitRoot);
+    }
+    const initCwd = process.env.INIT_CWD?.trim();
+    if (initCwd && isLikelyRepoRoot(initCwd)) {
+        return resolve(initCwd);
+    }
+    return process.cwd();
+}
+function isLikelyRepoRoot(path) {
+    return (existsSync(path) &&
+        (existsSync(resolve(path, "pnpm-workspace.yaml")) ||
+            existsSync(resolve(path, ".git")) ||
+            existsSync(resolve(path, "package.json"))));
+}
+function summarizeTraceReport(report) {
+    return {
+        runsAnalyzed: report.runsAnalyzed,
+        patternsFound: report.patterns.length,
+        avgKeepRate: report.stats.totalAttempts > 0
+            ? report.stats.totalKeptAttempts / report.stats.totalAttempts
+            : 0
+    };
+}
+async function buildCoreCompatibleAutonomousPromotionArtifact(core, task, evidence, loopRunId, runsRoot, beforeArtifactMaterial, beforeArtifactPath, improvementResultPath, holdoutArtifactPath, verifierImproved, budgetCritical, attemptCount, report, groundingFailureCount) {
+    const maybeCore = core;
+    const corePromotionInput = await buildCoreAutonomousPromotionArtifactInput({
+        task,
+        evidence,
+        loopRunId,
+        runsRoot,
+        beforeArtifactMaterial,
+        beforeArtifactPath,
+        improvementResultPath,
+        holdoutArtifactPath,
+        verifierImproved,
+        budgetCritical,
+        attemptCount,
+        report,
+        groundingFailureCount
+    });
+    if (typeof maybeCore.buildAutonomousPromotionArtifact === "function") {
+        try {
+            return maybeCore.buildAutonomousPromotionArtifact(corePromotionInput);
+        }
+        catch {
+            // Fall back to the trace-intelligence compatibility artifact until core owns all callers.
+        }
+    }
+    return buildAutonomousPromotionArtifact(task, evidence);
+}
+function mergeArtifactEvidence(fallback, artifact) {
+    const maybeArtifact = artifact;
+    const verifierReceiptPresent = typeof maybeArtifact.evidence?.verifierReceiptPresent === "boolean"
+        ? maybeArtifact.evidence.verifierReceiptPresent
+        : fallback.verifierReceiptPresent;
+    const verifierReceiptOutcome = typeof maybeArtifact.evidence?.verifierReceiptOutcome === "string"
+        ? maybeArtifact.evidence.verifierReceiptOutcome
+        : fallback.verifierReceiptOutcome;
+    return {
+        ...fallback,
+        surfaceClass: maybeArtifact.surfaceClass ?? fallback.surfaceClass,
+        promotionPolicyVerdict: maybeArtifact.promotionPolicyVerdict ?? fallback.promotionPolicyVerdict,
+        tripwireVerdict: maybeArtifact.tripwireVerdict ?? fallback.tripwireVerdict,
+        verifierReceiptPresent,
+        verifierReceiptOutcome
+    };
+}
+async function buildOptionalTraceAutonomyCertificationMetadata(input) {
+    const traceIntelligence = await import("@martin/trace-intelligence");
+    const buildMetadata = traceIntelligence.buildTraceAutonomyCertificationMetadata;
+    if (typeof buildMetadata !== "function") {
+        return {};
+    }
+    return normalizeTraceAutonomyCertificationMetadata(await buildMetadata(input));
+}
+function normalizeTraceAutonomyCertificationMetadata(metadata) {
+    const candidate = metadata;
+    const normalized = {};
+    if (typeof candidate["certificationRunId"] === "string") {
+        normalized.certificationRunId = candidate["certificationRunId"];
+    }
+    if (typeof candidate["certificationStatus"] === "string") {
+        normalized.certificationStatus = candidate["certificationStatus"];
+    }
+    if (typeof candidate["evidenceRunCount"] === "number" &&
+        Number.isFinite(candidate["evidenceRunCount"])) {
+        normalized.evidenceRunCount = candidate["evidenceRunCount"];
+    }
+    if (typeof candidate["claimReadiness"] === "string") {
+        normalized.claimReadiness = candidate["claimReadiness"];
+    }
+    if (typeof candidate["allowedClaimWording"] === "string") {
+        normalized.allowedClaimWording = candidate["allowedClaimWording"];
+    }
+    if (Array.isArray(candidate["blockedClaimReasons"]) &&
+        candidate["blockedClaimReasons"].every((reason) => typeof reason === "string")) {
+        normalized.blockedClaimReasons = [...candidate["blockedClaimReasons"]];
+    }
+    return normalized;
+}
+function countGroundingFailures(loop) {
+    const attemptFailures = loop.attempts?.filter((attempt) => attempt.failureClass === "repo_grounding_failure").length ?? 0;
+    const eventFailures = loop.events?.filter((event) => event.type === "failure.classified" &&
+        event.payload?.failureClass === "repo_grounding_failure").length ?? 0;
+    return Math.max(attemptFailures, eventFailures);
+}
+async function persistSignedAutonomousPromotionArtifact(core, root, fallbackPath, artifact) {
+    const maybeCore = core;
+    if (typeof maybeCore.persistAutonomousPromotionArtifact === "function" && isRecord(artifact)) {
+        const persisted = await maybeCore.persistAutonomousPromotionArtifact({ root, artifact });
+        return persisted.path;
+    }
+    return writeAutonomousPromotionArtifact(fallbackPath, artifact);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object";
+}
+async function writeTextArtifact(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, value, "utf8");
+}
+function createReservedLoopId(scope) {
+    const entropy = randomUUID().replace(/-/gu, "").slice(0, 16);
+    return `loop_${scope}_${Date.now().toString(36)}_${entropy}`;
+}
+function createReservedLoopIdFactory(loopId) {
+    return (prefix) => {
+        if (prefix === "loop") {
+            return loopId;
+        }
+        return `${prefix}_${randomUUID().replace(/-/gu, "").slice(0, 16)}`;
+    };
+}
+//# sourceMappingURL=improve.js.map

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

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

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