martin-loop 0.1.5 → 1.3.0

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

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

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

@@ -0,0 +1,60 @@
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pushOtlp, readRuns, runsToOtlp } from "@martin/trace-intelligence";
+export async function handleExportCommand(args) {
+    const maxRuns = parseIntFlag(args, "--runs") ?? 20;
+    const since = parseFlag(args, "--since");
+    const runsRoot = parseFlag(args, "--runs-root");
+    const outputPath = parseFlag(args, "--output") ?? "spans.json";
+    const endpoint = parseFlag(args, "--endpoint");
+    try {
+        const runs = await readRuns({ maxRuns, since, runsRoot });
+        if (runs.length === 0) {
+            return {
+                exitCode: 0,
+                stdout: "",
+                stderr: "No runs found. Run martin-loop at least once to generate trace data."
+            };
+        }
+        const otlpRequest = runsToOtlp(runs);
+        const totalSpans = otlpRequest.resourceSpans.reduce((sum, rs) => sum + rs.scopeSpans.reduce((s, ss) => s + ss.spans.length, 0), 0);
+        if (endpoint) {
+            const pushResult = await pushOtlp(otlpRequest, endpoint);
+            if (!pushResult.ok) {
+                return {
+                    exitCode: 1,
+                    stdout: "",
+                    stderr: `OTLP push failed (HTTP ${pushResult.status}): ${pushResult.body}`
+                };
+            }
+            return {
+                exitCode: 0,
+                stdout: `Exported ${totalSpans} spans from ${runs.length} runs to ${endpoint}`,
+                stderr: ""
+            };
+        }
+        const resolved = resolve(outputPath);
+        await writeFile(resolved, JSON.stringify(otlpRequest, null, 2), "utf8");
+        return {
+            exitCode: 0,
+            stdout: `Exported ${totalSpans} spans from ${runs.length} runs to ${resolved}`,
+            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 parseIntFlag(args, flag) {
+    const val = parseFlag(args, flag);
+    if (val === undefined)
+        return undefined;
+    const n = parseInt(val, 10);
+    return isNaN(n) ? undefined : n;
+}
+//# sourceMappingURL=export.js.map

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

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

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

@@ -0,0 +1,95 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createBlastRadiusReport } from "@martin/sdk";
+export async function handleGovernanceCommand(args, options = {}) {
+    const subcommand = args[0];
+    try {
+        if (subcommand !== "check") {
+            return {
+                stdout: "",
+                stderr: [
+                    "Usage: martin governance check --change-description <text> --repos <repo1,repo2> [options]",
+                    "",
+                    "Options:",
+                    "  --services <svc1,svc2>",
+                    "  --truth-facts <fact1,fact2>",
+                    "  --active-treaties <treaty1,treaty2>",
+                    "  --release-window-conflicts <conflict1,conflict2>",
+                    "  --lock-conflicts <resource@holder@expiresAt,...>",
+                    "  --window-ends-at <timestamp>",
+                    "  --output <path>"
+                ].join("\n"),
+                exitCode: 1
+            };
+        }
+        const changeDescription = parseFlag(args, "--change-description");
+        const reposAffected = parseCsvFlag(args, "--repos");
+        if (!changeDescription) {
+            return { stdout: "", stderr: "Missing --change-description", exitCode: 1 };
+        }
+        if (reposAffected.length === 0) {
+            return { stdout: "", stderr: "Missing --repos", exitCode: 1 };
+        }
+        const report = createBlastRadiusReport({
+            proposedChange: changeDescription,
+            reposAffected,
+            servicesAffected: parseCsvFlag(args, "--services"),
+            truthFactsAffected: parseCsvFlag(args, "--truth-facts"),
+            activeTreatiesAffected: parseCsvFlag(args, "--active-treaties"),
+            releaseWindowConflicts: parseCsvFlag(args, "--release-window-conflicts"),
+            lockConflicts: parseLockConflicts(parseFlag(args, "--lock-conflicts")),
+            ...(parseFlag(args, "--window-ends-at")
+                ? { evaluationWindowEndsAt: parseFlag(args, "--window-ends-at") }
+                : {})
+        });
+        const outputPath = parseFlag(args, "--output");
+        if (outputPath) {
+            const resolvedOutputPath = resolve(options.cwd ?? process.cwd(), outputPath);
+            await mkdir(dirname(resolvedOutputPath), { recursive: true });
+            await writeFile(resolvedOutputPath, JSON.stringify(report, null, 2), "utf8");
+        }
+        return {
+            stdout: JSON.stringify(report, 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)
+        : [];
+}
+function parseLockConflicts(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => {
+        const [resource, lockHolder, expiresAt] = entry.split("@");
+        if (!resource || !lockHolder) {
+            throw new Error(`Invalid lock conflict entry: ${entry}`);
+        }
+        return {
+            resource,
+            lockHolder,
+            ...(expiresAt ? { expiresAt } : {})
+        };
+    });
+}
+//# sourceMappingURL=governance.js.map

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

@@ -0,0 +1,18 @@
+export declare function handleImproveCommand(args: string[]): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+export type ImproveLiveEngine = "claude" | "codex";
+export interface ImproveAdapterSelection {
+    engine: ImproveLiveEngine;
+    model?: string;
+}
+export declare function resolveImproveAdapterSelection(args: string[], env?: NodeJS.ProcessEnv): ImproveAdapterSelection;
+export declare function resolveImproveLiveAdapterTimeoutMs(env?: NodeJS.ProcessEnv): number;
+export declare function resolveImproveMaxIterations(args: string[], env?: NodeJS.ProcessEnv, options?: {
+    certifyTraceAutonomy?: boolean;
+}): number;
+export declare function resolveImproveRetryLimit(options?: {
+    certifyTraceAutonomy?: boolean;
+}): number;

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>;