martin-loop 0.1.4 → 1.3.0

package/dist/vendor/core/types.d.ts

@@ -0,0 +1,115 @@
+import type { FailureClass, InterventionType, LoopArtifact, LoopAttempt, LoopBudget, LoopCost, LoopLifecycleState, LoopRecord, LoopTask } from "../contracts/index.js";
+export type AdapterExecutionStatus = "completed" | "failed" | "stalled";
+export interface DistillContextOptions {
+    maxRecentAttempts?: number;
+}
+export interface DistilledAttempt {
+    attemptId: string;
+    index: number;
+    summary: string;
+    failureClass?: FailureClass;
+    intervention?: InterventionType;
+}
+export interface DistilledContext {
+    taskTitle: string;
+    objective: string;
+    repoRoot?: string;
+    verificationPlan: string[];
+    recentAttempts: DistilledAttempt[];
+    constraints: {
+        remainingBudgetUsd: number;
+        remainingIterations: number;
+        remainingTokens: number;
+    };
+    focus: string;
+}
+export interface CostGovernorInput {
+    budget: LoopBudget;
+    cost: LoopCost;
+    attemptsUsed: number;
+    projectedUsage?: Partial<Pick<LoopCost, "actualUsd" | "tokensIn" | "tokensOut">>;
+}
+export interface CostGovernorState {
+    pressure: "healthy" | "soft_limit" | "hard_limit";
+    shouldStop: boolean;
+    remainingBudgetUsd: number;
+    remainingIterations: number;
+    remainingTokens: number;
+    recommendedIntervention?: InterventionType;
+}
+export interface MartinAdapterRequest {
+    loopId: string;
+    workspaceId: string;
+    projectId: string;
+    teamId?: string;
+    attemptIndex: number;
+    task: LoopTask;
+    context: DistilledContext;
+    budget: LoopBudget;
+    costState: CostGovernorState;
+}
+export interface MartinAdapterUsage {
+    actualUsd: number;
+    avoidedUsd?: number;
+    tokensIn: number;
+    tokensOut: number;
+}
+export interface MartinAdapterVerification {
+    passed: boolean;
+    summary: string;
+}
+export interface MartinAdapterFailure {
+    message: string;
+    classHint?: FailureClass;
+}
+export interface MartinAdapterResult {
+    status: AdapterExecutionStatus;
+    summary: string;
+    usage: MartinAdapterUsage;
+    verification: MartinAdapterVerification;
+    failure?: MartinAdapterFailure;
+    artifacts?: LoopArtifact[];
+}
+export interface MartinAdapter {
+    adapterId: string;
+    kind: string;
+    label: string;
+    metadata: Record<string, string>;
+    execute(request: MartinAdapterRequest): Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export interface FailureClassificationInput {
+    attempts: LoopAttempt[];
+    result: MartinAdapterResult;
+}
+export interface FailureAssessment {
+    failureClass: FailureClass;
+    rationale: string;
+    retryable: boolean;
+    recommendedIntervention: InterventionType;
+}
+export interface ExitIntelligenceInput {
+    loop: Pick<LoopRecord, "budget" | "cost" | "attempts">;
+    lastResult?: MartinAdapterResult;
+    lastFailure?: FailureAssessment;
+    costState: CostGovernorState;
+}
+export interface ExitDecision {
+    shouldExit: boolean;
+    lifecycleState: LoopLifecycleState;
+    reason: string;
+}
+export interface RunMartinOptions {
+    workspaceId: string;
+    projectId: string;
+    teamId?: string;
+    task: LoopTask;
+    budget?: Partial<LoopBudget>;
+    adapter: MartinAdapter;
+    now?: () => string;
+    idFactory?: (prefix: string) => string;
+}
+export interface RunMartinResult {
+    loop: LoopRecord;
+    decision: ExitDecision;
+    finalContext: DistilledContext;
+}

package/dist/vendor/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/vendor/core/verification/tiered-verify.d.ts

@@ -0,0 +1,17 @@
+export interface RiskTierVerificationInput {
+    scenarioId: string;
+    riskTier: "low" | "medium" | "high" | "critical";
+    blastRadiusScore: number;
+    claimSurfaceTouched: boolean;
+    privilegedAction: boolean;
+    securitySensitive: boolean;
+}
+export interface RiskTierVerificationPlan {
+    scenarioId: string;
+    tier: "standard" | "independent" | "consensus";
+    requiredVerifiers: string[];
+    mustPassAll: boolean;
+    allowedClaimWording: string;
+    nonClaims: string[];
+}
+export declare function buildRiskTierVerificationPlan(input: RiskTierVerificationInput): RiskTierVerificationPlan;

package/dist/vendor/core/verification/tiered-verify.js

@@ -0,0 +1,29 @@
+export function buildRiskTierVerificationPlan(input) {
+    const tier = input.riskTier === "critical" || input.privilegedAction || (input.claimSurfaceTouched && input.riskTier !== "low")
+        ? "consensus"
+        : input.riskTier === "high" || input.securitySensitive || input.claimSurfaceTouched
+            ? "independent"
+            : "standard";
+    const requiredVerifiers = ["targeted_verifier"];
+    if (tier !== "standard") {
+        requiredVerifiers.push("independent_reviewer");
+    }
+    if (input.securitySensitive) {
+        requiredVerifiers.push("security_review");
+    }
+    if (input.claimSurfaceTouched) {
+        requiredVerifiers.push("claim_boundary_audit");
+    }
+    if (input.privilegedAction) {
+        requiredVerifiers.push("human_owner");
+    }
+    return {
+        scenarioId: input.scenarioId,
+        tier,
+        requiredVerifiers: [...new Set(requiredVerifiers)],
+        mustPassAll: tier !== "standard",
+        allowedClaimWording: "risk-tiered cross-verification adds independent review only where blast radius, privileges, or claim boundaries justify it.",
+        nonClaims: ["universal multi-model consensus", "consensus on every low-risk run"]
+    };
+}
+//# sourceMappingURL=tiered-verify.js.map

package/dist/vendor/core/verifier-pyramid.d.ts

@@ -0,0 +1,32 @@
+import { type PatchDecisionReasonCode } from "../contracts/index.js";
+export interface StreamScanResult {
+    isTrap: boolean;
+    reasonCode?: PatchDecisionReasonCode;
+    detail?: string;
+    severity: "fatal" | "warning" | "info";
+    corroborated: boolean;
+}
+/**
+ * Trap 9: Severity-Tiered, Corroboration-Aware Stream Scanner
+ *
+ * Mandated by CTO:
+ * - Fatal by default: Triggers trap immediately.
+ * - Warning by default: Logged as evidence but not fatal unless corroborated.
+ * - Corroboration: exitCode !== 0, or verifier failure, or critical denylist matches.
+ */
+export declare function scanStreamsForTraps(stdout: string, stderr: string, options: {
+    exitCode: number;
+    verifierPassed: boolean;
+}): StreamScanResult;
+export interface HallucinatedTestOutputResult {
+    trapId: "T05";
+    detail: string;
+}
+/**
+ * Detects when stdout claims tests passed but the process exit code indicates
+ * failure — a hallucinated or fabricated test result.
+ */
+export declare function detectHallucinatedTestOutput(input: {
+    stdout: string;
+    exitCode: number;
+}): HallucinatedTestOutputResult | null;

package/dist/vendor/core/verifier-pyramid.js

@@ -0,0 +1,111 @@
+const FATAL_PATTERNS = [
+    /\bERROR\b/i,
+    /\bEXCEPTION\b/i,
+    /\bFATAL\b/i,
+    /\bTraceback\b/i,
+    /\bUnhandled\b/i,
+    /\bpanic\b/i,
+    /\bSegmentation fault\b/i,
+    /\bAssertion failed\b/i
+];
+const WARNING_PATTERNS = [
+    /\bWarning:\b/i,
+    /\bDeprecated\b/i,
+    /\bNotice\b/i,
+    /generic lint warning/i
+];
+const CRITICAL_DENYLIST = [
+    /module not found/i,
+    /cannot resolve/i,
+    /failed to compile/i,
+    /permission denied/i,
+    /budget exceeded/i,
+    /authentication failed/i
+];
+/**
+ * Trap 9: Severity-Tiered, Corroboration-Aware Stream Scanner
+ *
+ * Mandated by CTO:
+ * - Fatal by default: Triggers trap immediately.
+ * - Warning by default: Logged as evidence but not fatal unless corroborated.
+ * - Corroboration: exitCode !== 0, or verifier failure, or critical denylist matches.
+ */
+export function scanStreamsForTraps(stdout, stderr, options) {
+    const combined = `${stdout}\n${stderr}`;
+    // 1. Check Fatal Patterns (Fast Track)
+    for (const pattern of FATAL_PATTERNS) {
+        if (pattern.test(combined)) {
+            return {
+                isTrap: true,
+                reasonCode: "severity_stream_trap",
+                detail: `Fatal pattern detected in stream: ${pattern.toString()}`,
+                severity: "fatal",
+                corroborated: true
+            };
+        }
+    }
+    // 2. Check Critical Denylist (Escalated regardless of severity)
+    for (const pattern of CRITICAL_DENYLIST) {
+        if (pattern.test(combined)) {
+            return {
+                isTrap: true,
+                reasonCode: "severity_stream_trap",
+                detail: `Critical failure matched in stream: ${pattern.toString()}`,
+                severity: "fatal",
+                corroborated: true
+            };
+        }
+    }
+    // 3. Check Warning Patterns
+    let hasWarning = false;
+    let matchingWarning = "";
+    for (const pattern of WARNING_PATTERNS) {
+        if (pattern.test(combined)) {
+            hasWarning = true;
+            matchingWarning = pattern.toString();
+            break;
+        }
+    }
+    if (hasWarning) {
+        const corroborated = options.exitCode !== 0 || !options.verifierPassed;
+        return {
+            isTrap: corroborated,
+            ...(corroborated ? { reasonCode: "severity_stream_trap" } : {}),
+            detail: corroborated
+                ? `Warning corroborated as failure: ${matchingWarning} (Exit Code: ${options.exitCode})`
+                : `Non-blocking warning detected: ${matchingWarning}`,
+            severity: "warning",
+            corroborated
+        };
+    }
+    return {
+        isTrap: false,
+        severity: "info",
+        corroborated: false
+    };
+}
+const SUCCESS_CLAIM_PATTERNS = [
+    /all tests? passed/i,
+    /\d+\/\d+ passing/i,
+    /\d+ tests? passed/i,
+    /test suite passed/i,
+    /ok \d+ passed/i
+];
+/**
+ * Detects when stdout claims tests passed but the process exit code indicates
+ * failure — a hallucinated or fabricated test result.
+ */
+export function detectHallucinatedTestOutput(input) {
+    if (input.exitCode === 0)
+        return null;
+    for (const pattern of SUCCESS_CLAIM_PATTERNS) {
+        if (pattern.test(input.stdout)) {
+            return {
+                trapId: "T05",
+                detail: `stdout claims success ("${input.stdout.trim().slice(0, 120)}") but exitCode=${input.exitCode}`
+            };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=verifier-pyramid.js.map

package/dist/vendor/core/workflow-artifacts.d.ts

@@ -0,0 +1,99 @@
+import { type LoopLifecycleState, type LoopRecord, type MachineState } from "../contracts/index.js";
+import { type SignedAgentReceipt } from "./agent/receipts.js";
+import { type AttestationVerificationResult } from "./attestation/sign.js";
+import { type ContextUtilityScoreArtifact } from "./context-utility.js";
+export interface WorkflowArtifactPaths {
+    runRoot: string;
+    contractPath: string;
+    statePath: string;
+    loopRecordPath: string;
+    loopRecordSignaturePath: string;
+    loopRecordPublicKeyPath: string;
+    ledgerPath: string;
+    artifactsRoot: string;
+    contextUtilityScorePath: string;
+    workflowReceiptPath: string;
+    workflowHandoffJsonPath: string;
+    workflowHandoffMarkdownPath: string;
+}
+export interface WorkflowHandoffSourceDigest {
+    path: string;
+    kind: "contract" | "state" | "ledger" | "artifact";
+    sha256: string;
+}
+export interface WorkflowHandoffCompaction {
+    schemaVersion: "martin.workflow.handoff.compaction.v1";
+    sourceManifestDigest: string;
+    sources: WorkflowHandoffSourceDigest[];
+    state: {
+        phase?: MachineState["phase"];
+        currentAttempt?: number;
+        activeModel?: string;
+        lastFailureSurface?: string;
+        openAlerts: string[];
+    };
+    verification: {
+        status: "verified" | "unverified";
+        summary: string;
+        attemptIndex?: number;
+    };
+    verificationPlan?: WorkflowVerificationPlanSummary;
+    contextUtility?: ContextUtilityScoreArtifact;
+    touchedSurfaces: string[];
+    blockers: string[];
+    nextPrompt: string;
+}
+export interface WorkflowVerificationPlanSummary {
+    tier?: string;
+    mustPassAll: boolean;
+    requiredChecks: string[];
+    optionalChecks: string[];
+    requiredVerifiers: string[];
+    summary: string;
+}
+export interface WorkflowHandoffArtifact {
+    schemaVersion: "martin.workflow.handoff.v1";
+    loopId: string;
+    workspaceId: string;
+    projectId: string;
+    status: LoopRecord["status"];
+    lifecycleState: LoopLifecycleState;
+    objective: string;
+    verificationPlan: string[];
+    attemptCount: number;
+    actualUsd: number;
+    reportedTotalUsd: number;
+    ledgerHash: string;
+    verificationStatus: "passed" | "blocked";
+    nextAction: string;
+    runRoot: string;
+    loopRecordPath: string;
+    workflowReceiptPath: string;
+    ledgerPath: string;
+    compaction: WorkflowHandoffCompaction;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PersistedWorkflowArtifacts {
+    paths: WorkflowArtifactPaths;
+    ledgerHash: string;
+    receipt: SignedAgentReceipt;
+    handoff: WorkflowHandoffArtifact;
+}
+export interface WorkflowHandoffVerificationResult {
+    ok: boolean;
+    reason?: string;
+    changedSources: string[];
+    attestation?: AttestationVerificationResult;
+}
+export declare function resolveWorkflowArtifactPaths(runsRoot: string, loopId: string): WorkflowArtifactPaths;
+export declare function persistWorkflowArtifacts(input: {
+    loop: LoopRecord;
+    runsRoot: string;
+    martinHome: string;
+}): Promise<PersistedWorkflowArtifacts>;
+export declare function buildWorkflowHandoffArtifact(loop: LoopRecord, paths: WorkflowArtifactPaths, ledgerHash: string, compaction: WorkflowHandoffCompaction): WorkflowHandoffArtifact;
+export declare function renderWorkflowHandoffMarkdown(handoff: WorkflowHandoffArtifact): string;
+export declare function computeLedgerHash(ledgerPath: string): Promise<string>;
+export declare function compactWorkflowHandoffSources(paths: WorkflowArtifactPaths): Promise<WorkflowHandoffCompaction>;
+export declare function verifyWorkflowHandoffForResume(runRoot: string): Promise<WorkflowHandoffVerificationResult>;