@martinloop/mcp 0.3.3 → 0.3.5

package/dist/vendor/core/identity.js

@@ -0,0 +1,86 @@
+import { createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
+import { cloneIdentityAttestation, cloneIdentityClaims, cloneIdentityToken } from "../contracts/index.js";
+export function createLocalIdentityAuthority(input = {}) {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    return {
+        keyId: input.keyId ?? `martin-local-${Date.now().toString(36)}`,
+        algorithm: "ed25519",
+        privateKeyPem: privateKey.export({ format: "pem", type: "pkcs8" }).toString(),
+        publicKeyPem: publicKey.export({ format: "pem", type: "spki" }).toString()
+    };
+}
+export function issueIdentityToken(input) {
+    const claims = cloneIdentityClaims(input.claims);
+    const signer = createPrivateKey(input.authority.privateKeyPem);
+    const payload = serializeIdentityClaims(claims);
+    const signature = sign(null, payload, signer).toString("base64");
+    return cloneIdentityToken({
+        schemaVersion: "martin.identity.v1",
+        algorithm: input.authority.algorithm,
+        keyId: input.authority.keyId,
+        claims,
+        signature
+    });
+}
+export function verifyIdentityToken(input) {
+    const token = cloneIdentityToken(input.token);
+    const verifier = createPublicKey(input.publicKeyPem);
+    const payload = serializeIdentityClaims(token.claims);
+    const verifiedAt = input.now ?? new Date().toISOString();
+    if (token.schemaVersion !== "martin.identity.v1") {
+        return cloneIdentityAttestation({
+            valid: false,
+            verifiedAt,
+            reason: `Unsupported identity schema version '${token.schemaVersion}'.`,
+            token
+        });
+    }
+    const signatureValid = verify(null, payload, verifier, Buffer.from(token.signature, "base64"));
+    if (!signatureValid) {
+        return cloneIdentityAttestation({
+            valid: false,
+            verifiedAt,
+            reason: "Identity signature verification failed.",
+            token
+        });
+    }
+    const expiresAt = token.claims.expiresAt ? Date.parse(token.claims.expiresAt) : undefined;
+    if (expiresAt !== undefined && Number.isFinite(expiresAt) && expiresAt <= Date.parse(verifiedAt)) {
+        return cloneIdentityAttestation({
+            valid: false,
+            verifiedAt,
+            reason: "Identity token is expired.",
+            token
+        });
+    }
+    return cloneIdentityAttestation({
+        valid: true,
+        verifiedAt,
+        reason: `Identity token for role '${token.claims.role}' verified successfully.`,
+        token
+    });
+}
+export function hasIdentityScope(token, requiredScope) {
+    const required = requiredScope.trim().toLowerCase();
+    if (required.length === 0) {
+        return false;
+    }
+    return token.claims.scopes.some((scope) => scope.trim().toLowerCase() === required);
+}
+function serializeIdentityClaims(claims) {
+    return Buffer.from(JSON.stringify(claims, sortKeys), "utf8");
+}
+function sortKeys(_, value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        return Object.keys(value)
+            .sort()
+            .reduce((sorted, key) => {
+            sorted[key] = value[key];
+            return sorted;
+        }, {});
+    }
+    return value;
+}

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

@@ -4,11 +4,18 @@ import { evaluateChangeApprovalLeash, evaluateFilesystemLeash, evaluateSecretLea
 import { buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations } from "./grounding.js";
 import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary } from "./rollback.js";
 import { type RunStore } from "./persistence/index.js";
-export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase } from "../contracts/index.js";
+export type { ApprovalPolicy, BudgetPreflightEstimate, BudgetSettlement, CostProvenance, EvidenceVector, ExecutionProfile, FailureClass, InterventionType, PatchDecision, PatchDecisionArtifact, PatchDecisionReasonCode, PatchScore, MutationMode, RollbackBoundaryArtifact, RollbackBoundaryStrategy, RollbackFileSnapshot, RollbackOutcomeArtifact, RollbackOutcomeStatus, PolicyPhase, CallStage, AgentRole, FirstDelta, RoutingEconomics } from "../contracts/index.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
 export type { BudgetPreflightDecision, BudgetPreflightInput, CostGovernorState, EvidenceVectorInput, EvaluatedPatchDecision, ExitDecision, FailureAssessment, PatchDecisionInput, RecoveryDecision, RecoveryRecipe } from "./policy.js";
 export type { ResolvedExecutionProfile, SafetyLeashDecision, SafetyViolation } from "./leash.js";
 export type { GroundingScanResult, GroundingViolation, GroundingViolationKind, RepoGroundingHit, RepoGroundingIndex } from "./grounding.js";
+export { buildContextGraphSnapshot, queryContextGraph } from "./context-graph.js";
+export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, verifyIdentityToken } from "./identity.js";
+export type { LocalIdentityAuthority } from "./identity.js";
+export { compileExecutionPolicy } from "./policy-compiler.js";
+export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
+export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
+export type { RouteDecision, RouteClassificationInput } from "./routing.js";
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 export type { ContextIntegrityPrecheck, ContextIntegrityVerdict } from "./context-integrity.js";
 export { compilePromptPacket } from "./compiler.js";
@@ -132,6 +139,8 @@ export interface AttemptPolicyDecision {
     allowed: boolean;
     reason: string;
     recommendedIntervention?: InterventionType;
+    trajectoryAssessment?: import("../contracts/index.js").TrajectoryAssessment;
+    circuitBreakDecision?: import("../contracts/index.js").CircuitBreakDecision;
 }
 /**
  * Admission gate — must pass before any attempt is executed.

package/dist/vendor/core/index.js

@@ -6,7 +6,14 @@ import { captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreR
 import { compilePromptPacket } from "./compiler.js";
 import { makeLedgerEvent, resolveRunsRoot, runDir } from "./persistence/index.js";
 import { runContextIntegrityPrecheck } from "./context-integrity.js";
+import { decideCircuitBreak } from "./trajectory.js";
 export { classifyFailure, computeEvidenceVector, evaluatePatchDecision, evaluateCostGovernor, evaluateBudgetPreflight, inferExit, nextPolicyPhase, policyPhaseToLifecycleState, scorePatchDecision, selectRecoveryRecipe, evaluateVerificationLeash, evaluateFilesystemLeash, evaluateChangeApprovalLeash, evaluateSecretLeash, resolveExecutionProfile, redactSecretsFromText, buildRepoGroundingIndex, loadOrBuildRepoGroundingIndex, queryRepoGroundingIndex, scanPatchForGroundingViolations, captureRollbackBoundary, listAttemptChangedFilesSinceBoundary, restoreRollbackBoundary };
+export { buildContextGraphSnapshot, queryContextGraph } from "./context-graph.js";
+export { createLocalIdentityAuthority, hasIdentityScope, issueIdentityToken, verifyIdentityToken } from "./identity.js";
+export { compileExecutionPolicy } from "./policy-compiler.js";
+export { assessTrajectory, decideCircuitBreak } from "./trajectory.js";
+// ─── Routing economics ─────────────────────────────────────────────────────
+export { classifyRoute, evaluatePreworkBurnPolicy } from "./routing.js";
 // ─── Context Integrity Pre-gate ──────────────────────────────────────────────
 export { runContextIntegrityPrecheck } from "./context-integrity.js";
 // ─── Prompt packet compiler ──────────────────────────────────────────────────
@@ -21,12 +28,35 @@ export { compileAndPersistContext } from "./persistence/index.js";
  */
 export function evaluateAttemptPolicy(input) {
     const { request, projectedUsd } = input;
+    const trajectoryAttempts = request.previousAttempts.map((attempt) => ({
+        index: attempt.index,
+        summary: attempt.summary,
+        failureClass: attempt.failureClass
+    }));
+    const circuitBreakDecision = decideCircuitBreak({
+        objective: request.context.objective,
+        verificationPlan: request.context.verificationPlan,
+        attempts: trajectoryAttempts,
+        remainingIterations: request.context.remainingIterations
+    });
+    const trajectoryAssessment = circuitBreakDecision.assessment;
+    if (circuitBreakDecision.shouldStop) {
+        return {
+            allowed: false,
+            reason: circuitBreakDecision.reason,
+            recommendedIntervention: circuitBreakDecision.recommendedIntervention,
+            trajectoryAssessment,
+            circuitBreakDecision
+        };
+    }
     // Budget gate: reject if projected cost exceeds remaining
     if (projectedUsd > request.context.remainingBudgetUsd) {
         return {
             allowed: false,
             reason: `Projected cost $${projectedUsd} exceeds remaining budget $${request.context.remainingBudgetUsd}.`,
-            recommendedIntervention: "stop_loop"
+            recommendedIntervention: "stop_loop",
+            trajectoryAssessment,
+            circuitBreakDecision
         };
     }
     // Iteration gate
@@ -34,7 +64,9 @@ export function evaluateAttemptPolicy(input) {
         return {
             allowed: false,
             reason: "No remaining iterations in the budget.",
-            recommendedIntervention: "stop_loop"
+            recommendedIntervention: "stop_loop",
+            trajectoryAssessment,
+            circuitBreakDecision
         };
     }
     // Oscillation detection: A/B/A pattern in failure classes
@@ -48,7 +80,9 @@ export function evaluateAttemptPolicy(input) {
             return {
                 allowed: false,
                 reason: "Oscillating failure pattern detected. Escalating to human.",
-                recommendedIntervention: "escalate_human"
+                recommendedIntervention: "escalate_human",
+                trajectoryAssessment,
+                circuitBreakDecision
             };
         }
     }
@@ -69,14 +103,18 @@ export function evaluateAttemptPolicy(input) {
                 return {
                     allowed: false,
                     reason: "Materially repetitive attempts detected. Escalating to human.",
-                    recommendedIntervention: "escalate_human"
+                    recommendedIntervention: "escalate_human",
+                    trajectoryAssessment,
+                    circuitBreakDecision
                 };
             }
         }
     }
     return {
         allowed: true,
-        reason: "Attempt admitted."
+        reason: "Attempt admitted.",
+        trajectoryAssessment,
+        circuitBreakDecision
     };
 }
 export function distillContext(loop, options = {}) {
@@ -226,6 +264,13 @@ export async function runMartin(input) {
     // Explicit PolicyPhase state machine — starts at GATHER, advances per attempt
     let currentPhase = "GATHER";
     let phaseRetryCount = 0;
+    // Routing economics: track first meaningful workspace delta
+    const runStartMs = Date.now();
+    let firstDeltaDetected = false;
+    let firstDeltaTimestampMs;
+    let firstDeltaFilePath;
+    let firstDeltaChangeType;
+    let preDeltaCostUsd = 0;
     while (loop.attempts.length < loop.budget.maxIterations) {
         const distilled = distillContext(loop, {
             maxRecentAttempts: useCompressedContext ? 1 : (input.maxRecentAttempts ?? 3)
@@ -452,7 +497,8 @@ export async function runMartin(input) {
             ...(failure?.failureClass ? { failureClass: failure.failureClass } : {}),
             ...(failure?.recommendedIntervention
                 ? { intervention: failure.recommendedIntervention }
-                : {})
+                : {}),
+            ...(failure?.diagnosticHint ? { diagnosticHint: failure.diagnosticHint } : {})
         };
         loop = {
             ...loop,
@@ -611,6 +657,20 @@ export async function runMartin(input) {
         const changedFiles = tracksWorkspaceMutations
             ? resolveChangedFiles(result, request.context.repoRoot, rollbackBoundary)
             : [];
+        // Routing economics: detect first meaningful workspace delta
+        if (!firstDeltaDetected && changedFiles.length > 0) {
+            const meaningfulFile = changedFiles.find((f) => !isMartinLoopMetadata(f));
+            if (meaningfulFile) {
+                firstDeltaDetected = true;
+                firstDeltaTimestampMs = Date.now();
+                firstDeltaFilePath = meaningfulFile;
+                firstDeltaChangeType = "modify";
+                preDeltaCostUsd = roundUsd(loop.cost.actualUsd - getUsageUsd(result.usage));
+            }
+        }
+        if (!firstDeltaDetected) {
+            preDeltaCostUsd = loop.cost.actualUsd;
+        }
         // Evidence is only reliable when the adapter explicitly reported files OR git actually
         // returned a non-empty list. A repoRoot alone is insufficient — git may fail (e.g. not
         // a git repo) and silently return [], which would falsely trigger no_code_change.
@@ -1033,7 +1093,8 @@ export async function runMartin(input) {
                     payload: createRunExitPayload(decision)
                 }));
             }
-            const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory);
+            const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
+            const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
             await persistLoopRecordIfSupported(input.store, finalizedLoop);
             return {
                 loop: finalizedLoop,
@@ -1054,7 +1115,8 @@ export async function runMartin(input) {
             payload: createRunExitPayload(decision)
         }));
     }
-    const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory);
+    const routingInput = { runStartMs, firstDeltaDetected, firstDeltaTimestampMs, firstDeltaFilePath, firstDeltaChangeType, preDeltaCostUsd };
+    const finalizedLoop = finalizeLoop(loop, decision, now(), idFactory, routingInput);
     await persistLoopRecordIfSupported(input.store, finalizedLoop);
     return {
         loop: finalizedLoop,
@@ -1104,19 +1166,78 @@ function safetyLeashReasonCode(decision, safetySurface) {
             return `${safetySurface}_safety_block`;
     }
 }
-function finalizeLoop(loop, decision, timestamp, idFactory) {
+function finalizeLoop(loop, decision, timestamp, idFactory, routingEconomicsInput) {
     const finalized = appendLoopEvent(loop, {
         type: "run.completed",
         lifecycleState: decision.lifecycleState,
         payload: createRunExitPayload(decision)
     }, { now: timestamp, idFactory });
+    const routingEconomics = routingEconomicsInput
+        ? buildRoutingEconomics(finalized, routingEconomicsInput, decision)
+        : undefined;
     return {
         ...finalized,
         status: decision.status,
         lifecycleState: decision.lifecycleState,
-        updatedAt: timestamp
+        updatedAt: timestamp,
+        ...(routingEconomics ? { routingEconomics } : {})
     };
 }
+function buildRoutingEconomics(loop, input, decision) {
+    const totalCost = loop.cost.actualUsd;
+    const preworkCost = roundUsd(Math.max(input.preDeltaCostUsd, 0));
+    const executionCost = roundUsd(Math.max(totalCost - preworkCost, 0));
+    const preworkBurnPct = totalCost > 0 ? Math.round((preworkCost / totalCost) * 100) : 0;
+    const timeToFirstDeltaMs = input.firstDeltaTimestampMs
+        ? input.firstDeltaTimestampMs - input.runStartMs
+        : undefined;
+    const accepted = decision.lifecycleState === "completed";
+    // Route recommendation based on prework burn
+    let routeRecommendation;
+    let routeRecommendationReason;
+    if (preworkBurnPct > 50) {
+        routeRecommendation = "direct_worker";
+        routeRecommendationReason = `${String(preworkBurnPct)}% of spend was pre-work coordination. Use direct execution for similar tasks.`;
+    }
+    else if (preworkBurnPct > 30) {
+        routeRecommendation = "direct_worker";
+        routeRecommendationReason = `${String(preworkBurnPct)}% pre-work burn is high. Consider direct execution.`;
+    }
+    else {
+        routeRecommendation = "same_route";
+        routeRecommendationReason = `Pre-work burn at ${String(preworkBurnPct)}% is within acceptable range.`;
+    }
+    return {
+        preworkCostUsd: preworkCost,
+        executionCostUsd: executionCost,
+        verificationCostUsd: 0,
+        retryCostUsd: 0,
+        totalCostUsd: totalCost,
+        preworkBurnPct,
+        timeToFirstDeltaMs,
+        firstDelta: {
+            detected: input.firstDeltaDetected,
+            ...(input.firstDeltaTimestampMs ? { timestampMs: input.firstDeltaTimestampMs } : {}),
+            ...(input.firstDeltaFilePath ? { filePath: input.firstDeltaFilePath } : {}),
+            ...(input.firstDeltaChangeType ? { changeType: input.firstDeltaChangeType } : {}),
+            ...(timeToFirstDeltaMs !== undefined ? { timeToFirstDeltaMs } : {})
+        },
+        ...(accepted ? { costPerAcceptedChange: totalCost } : {}),
+        routeRecommendation,
+        routeRecommendationReason
+    };
+}
+const MARTINLOOP_METADATA_PATTERNS = [
+    /^PROGRESS\.md$/u,
+    /^\.martin\//u,
+    /\.lock$/u,
+    /^node_modules\//u,
+    /^\.git\//u,
+    /^\.cache\//u,
+];
+function isMartinLoopMetadata(filePath) {
+    return MARTINLOOP_METADATA_PATTERNS.some((p) => p.test(filePath));
+}
 async function persistLoopRecordIfSupported(store, loop) {
     await store?.writeLoopRecord?.(loop.loopId, loop);
 }

package/dist/vendor/core/persistence/integrity.js

@@ -49,9 +49,9 @@ export async function verifyReceiptIntegrityFromFiles(input) {
     ]);
     if (!rawMaterial || !rawLoopRecord || rawLedger === null || !key) {
         return {
-            state: "unsigned",
+            state: "material_missing",
             reason: "Receipt integrity material is missing for this run.",
-            warnings: ["Receipts are local-only and unsigned; trust claims are unavailable."]
+            warnings: ["Receipt integrity material is incomplete; trust claims are unavailable."]
         };
     }
     let material;

package/dist/vendor/core/policy-compiler.d.ts

@@ -0,0 +1,2 @@
+import { type ExecutionPolicy, type ExecutionPolicyCompileInput } from "../contracts/index.js";
+export declare function compileExecutionPolicy(input: ExecutionPolicyCompileInput): ExecutionPolicy;

package/dist/vendor/core/policy-compiler.js

@@ -0,0 +1,195 @@
+import { cloneExecutionPolicy } from "../contracts/index.js";
+export function compileExecutionPolicy(input) {
+    const provenance = [];
+    const budget = {
+        maxUsd: resolveBudgetField("maxUsd", input, provenance),
+        softLimitUsd: resolveBudgetField("softLimitUsd", input, provenance),
+        maxIterations: resolveBudgetField("maxIterations", input, provenance),
+        maxTokens: resolveBudgetField("maxTokens", input, provenance)
+    };
+    if (budget.softLimitUsd >= budget.maxUsd) {
+        budget.softLimitUsd = Math.round(budget.maxUsd * 0.75 * 100) / 100;
+        provenance.push({
+            field: "budget.softLimitUsd",
+            source: "config",
+            value: String(budget.softLimitUsd)
+        });
+    }
+    const governance = {
+        policyProfile: resolveEnumField({
+            field: "governance.policyProfile",
+            defaultsTo: input.defaults.policyProfile,
+            configValue: input.config?.policyProfile,
+            requestValue: input.request.policyProfile,
+            allowed: ["strict", "balanced", "overnight", "debug"],
+            provenance
+        }),
+        telemetryDestination: resolveEnumField({
+            field: "governance.telemetryDestination",
+            defaultsTo: input.defaults.telemetryDestination,
+            configValue: input.config?.governance?.telemetryDestination,
+            requestValue: input.request.telemetryDestination,
+            allowed: ["local-only", "control-plane"],
+            provenance
+        }),
+        destructiveActionPolicy: resolveEnumField({
+            field: "governance.destructiveActionPolicy",
+            defaultsTo: input.defaults.destructiveActionPolicy,
+            configValue: input.config?.governance?.destructiveActionPolicy,
+            allowed: ["never", "approval", "allowed"],
+            provenance
+        })
+    };
+    const verificationPlan = resolveVerificationPlan(input, provenance);
+    const task = {
+        verificationPlan
+    };
+    if (input.request.mutationMode) {
+        task.mutationMode = input.request.mutationMode;
+        provenance.push({
+            field: "task.mutationMode",
+            source: "request",
+            value: input.request.mutationMode
+        });
+    }
+    if (input.request.repoRoot) {
+        task.repoRoot = input.request.repoRoot;
+        provenance.push({
+            field: "task.repoRoot",
+            source: "request",
+            value: input.request.repoRoot
+        });
+    }
+    if ((input.request.allowedPaths?.length ?? 0) > 0) {
+        const allowedPaths = input.request.allowedPaths ?? [];
+        task.allowedPaths = [...allowedPaths];
+        provenance.push({
+            field: "task.allowedPaths",
+            source: "request",
+            value: allowedPaths.join(", ")
+        });
+    }
+    if ((input.request.deniedPaths?.length ?? 0) > 0) {
+        const deniedPaths = input.request.deniedPaths ?? [];
+        task.deniedPaths = [...deniedPaths];
+        provenance.push({
+            field: "task.deniedPaths",
+            source: "request",
+            value: deniedPaths.join(", ")
+        });
+    }
+    if ((input.request.acceptanceCriteria?.length ?? 0) > 0) {
+        const acceptanceCriteria = input.request.acceptanceCriteria ?? [];
+        task.acceptanceCriteria = [...acceptanceCriteria];
+        provenance.push({
+            field: "task.acceptanceCriteria",
+            source: "request",
+            value: acceptanceCriteria.join(", ")
+        });
+    }
+    if (input.request.approvalPolicy) {
+        task.approvalPolicy = { ...input.request.approvalPolicy };
+        provenance.push({
+            field: "task.approvalPolicy",
+            source: "request",
+            value: JSON.stringify(input.request.approvalPolicy)
+        });
+    }
+    return cloneExecutionPolicy({
+        configPath: input.configPath,
+        budget,
+        governance,
+        task,
+        provenance
+    });
+}
+function resolveBudgetField(field, input, provenance) {
+    if (input.request.budgetOverrides?.[field]) {
+        const value = input.request.budget[field];
+        provenance.push({
+            field: `budget.${String(field)}`,
+            source: "request",
+            value: String(value)
+        });
+        return value;
+    }
+    const configValue = input.config?.budget?.[field];
+    if (typeof configValue === "number" && Number.isFinite(configValue)) {
+        provenance.push({
+            field: `budget.${String(field)}`,
+            source: "config",
+            value: String(configValue)
+        });
+        return configValue;
+    }
+    const value = input.defaults.budget[field];
+    provenance.push({
+        field: `budget.${String(field)}`,
+        source: "default",
+        value: String(value)
+    });
+    return value;
+}
+function resolveVerificationPlan(input, provenance) {
+    const requestVerificationPlan = normalizeStringList(input.request.verificationPlan);
+    if (requestVerificationPlan.length > 0) {
+        provenance.push({
+            field: "task.verificationPlan",
+            source: "request",
+            value: requestVerificationPlan.join(", ")
+        });
+        return requestVerificationPlan;
+    }
+    const configVerificationPlan = normalizeStringList(input.config?.governance?.verifierRules);
+    if (configVerificationPlan.length > 0) {
+        provenance.push({
+            field: "task.verificationPlan",
+            source: "config",
+            value: configVerificationPlan.join(", ")
+        });
+        return configVerificationPlan;
+    }
+    const defaultVerificationPlan = normalizeStringList(input.defaults.verifierRules);
+    provenance.push({
+        field: "task.verificationPlan",
+        source: "default",
+        value: defaultVerificationPlan.join(", ")
+    });
+    return defaultVerificationPlan;
+}
+function resolveEnumField(input) {
+    const normalizedRequest = normalizeEnumCandidate(input.requestValue, input.allowed);
+    if (normalizedRequest) {
+        input.provenance.push({
+            field: input.field,
+            source: "request",
+            value: normalizedRequest
+        });
+        return normalizedRequest;
+    }
+    const normalizedConfig = normalizeEnumCandidate(input.configValue, input.allowed);
+    if (normalizedConfig) {
+        input.provenance.push({
+            field: input.field,
+            source: "config",
+            value: normalizedConfig
+        });
+        return normalizedConfig;
+    }
+    input.provenance.push({
+        field: input.field,
+        source: "default",
+        value: input.defaultsTo
+    });
+    return input.defaultsTo;
+}
+function normalizeEnumCandidate(value, allowed) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return allowed.find((candidate) => candidate === trimmed);
+}
+function normalizeStringList(values) {
+    return (values ?? []).map((value) => value.trim()).filter(Boolean);
+}

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

@@ -4,6 +4,8 @@ export interface FailureAssessment {
     rationale: string;
     retryable: boolean;
     recommendedIntervention: InterventionType;
+    /** Actionable diagnosis injected into the next attempt's prompt context. */
+    diagnosticHint?: string;
 }
 export interface CostGovernorState {
     pressure: "healthy" | "soft_limit" | "hard_limit";
@@ -72,6 +74,19 @@ export declare function evaluateCostGovernor(input: {
     cost: LoopCost;
     attemptsUsed: number;
 }): CostGovernorState;
+export interface CostPerOutcome {
+    costPerAcceptedChange: number | undefined;
+    costPerAttempt: number;
+    acceptanceRate: number;
+    wastedCoordinationUsd: number;
+}
+export declare function calculateCostPerOutcome(input: {
+    totalCostUsd: number;
+    preworkCostUsd: number;
+    attemptCount: number;
+    accepted: boolean;
+    verificationPassed: boolean;
+}): CostPerOutcome;
 export declare function inferExit(input: {
     loop: {
         budget: LoopBudget;