@martinloop/mcp 0.3.9 → 0.5.0

package/dist/vendor/core/mission/aggregate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Mission aggregation — C2
+ *
+ * Computes verified-outcome and cost metrics from a mission's linked runs.
+ * Does not hit the filesystem — operates on already-loaded MissionRecord.
+ */
+import type { MissionCost, MissionRecord, MissionRunLink } from "../../contracts/index.js";
+export interface MissionMetrics {
+    totalActualUsd: number;
+    verifiedOutcomeCount: number;
+    totalRunCount: number;
+    /** USD per verified outcome. Infinity when verifiedOutcomeCount === 0. */
+    costPerVerifiedOutcome: number;
+    /** Fraction of runs with verified outcomes (0–1). */
+    verifiedRate: number;
+}
+/**
+ * Re-derive mission cost metrics from the run links.
+ * Use this to rebuild the cost object from ledger-authoritative data
+ * rather than trusting the cached mission.json cost field.
+ */
+export declare function aggregateMissionMetrics(runLinks: MissionRunLink[]): MissionMetrics;
+/**
+ * Rebuild the MissionCost record from the authoritative run links.
+ * Call after loading from ledger to ensure the cached cost field is consistent.
+ */
+export declare function rebuildMissionCost(mission: MissionRecord): MissionCost;

package/dist/vendor/core/mission/aggregate.js

@@ -0,0 +1,42 @@
+/**
+ * Mission aggregation — C2
+ *
+ * Computes verified-outcome and cost metrics from a mission's linked runs.
+ * Does not hit the filesystem — operates on already-loaded MissionRecord.
+ */
+/**
+ * Re-derive mission cost metrics from the run links.
+ * Use this to rebuild the cost object from ledger-authoritative data
+ * rather than trusting the cached mission.json cost field.
+ */
+export function aggregateMissionMetrics(runLinks) {
+    let totalActualUsd = 0;
+    let verifiedOutcomeCount = 0;
+    for (const link of runLinks) {
+        totalActualUsd += link.actualUsd ?? 0;
+        if (link.verifiedOutcome === true)
+            verifiedOutcomeCount += 1;
+    }
+    const totalRunCount = runLinks.length;
+    const costPerVerifiedOutcome = verifiedOutcomeCount === 0 ? Infinity : totalActualUsd / verifiedOutcomeCount;
+    const verifiedRate = totalRunCount === 0 ? 0 : verifiedOutcomeCount / totalRunCount;
+    return {
+        totalActualUsd,
+        verifiedOutcomeCount,
+        totalRunCount,
+        costPerVerifiedOutcome,
+        verifiedRate
+    };
+}
+/**
+ * Rebuild the MissionCost record from the authoritative run links.
+ * Call after loading from ledger to ensure the cached cost field is consistent.
+ */
+export function rebuildMissionCost(mission) {
+    const metrics = aggregateMissionMetrics(mission.runLinks);
+    return {
+        totalActualUsd: metrics.totalActualUsd,
+        verifiedOutcomeCount: metrics.verifiedOutcomeCount,
+        totalRunCount: metrics.totalRunCount
+    };
+}

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

@@ -0,0 +1,2 @@
+export { aggregateMissionMetrics, rebuildMissionCost } from "./aggregate.js";
+export type { MissionMetrics } from "./aggregate.js";

package/dist/vendor/core/mission/index.js

@@ -0,0 +1 @@
+export { aggregateMissionMetrics, rebuildMissionCost } from "./aggregate.js";

package/dist/vendor/core/persistence/compiler.d.ts

@@ -1,4 +1,5 @@
 import { type CompilerAdapterRequest, type PromptPacket } from "../compiler.js";
+import { type ContextAdapter } from "../context-compiler.js";
 import type { RunStore } from "./store.js";
 export interface CompileResult {
     packet: PromptPacket;
@@ -10,9 +11,16 @@ export interface CompileResult {
  *
  * R3.7: Context compiler produces deterministic compiled-context.json.
  * R3.8: Any attempt prompt can be reconstructed from disk artifacts alone.
+ *
+ * A-CTX-0: After compiling, emit a shadow manifest via compileContextShadow
+ * and append a context.shadow_compiled ledger event. Shadow failure must not
+ * break the governed run — original packet is returned unchanged in all cases.
  */
 export declare function compileAndPersistContext(request: CompilerAdapterRequest, options: {
     attemptIndex: number;
     store?: RunStore;
     now?: string;
+    nowMs?: number;
+    contextShadowBudgetTokens?: number;
+    contextAdapter?: ContextAdapter;
 }): Promise<CompileResult>;

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

@@ -1,4 +1,7 @@
+import { createHash } from "node:crypto";
 import { compilePromptPacket } from "../compiler.js";
+import { compileContext, HEURISTIC_ADAPTER } from "../context-compiler.js";
+import { compileContextShadow } from "../context-shadow.js";
 import { makeLedgerEvent } from "./ledger.js";
 /**
  * Compile a deterministic PromptPacket from the request state and, when a
@@ -7,6 +10,10 @@ import { makeLedgerEvent } from "./ledger.js";
  *
  * R3.7: Context compiler produces deterministic compiled-context.json.
  * R3.8: Any attempt prompt can be reconstructed from disk artifacts alone.
+ *
+ * A-CTX-0: After compiling, emit a shadow manifest via compileContextShadow
+ * and append a context.shadow_compiled ledger event. Shadow failure must not
+ * break the governed run — original packet is returned unchanged in all cases.
  */
 export async function compileAndPersistContext(request, options) {
     const packet = compilePromptPacket(request);
@@ -29,6 +36,155 @@ export async function compileAndPersistContext(request, options) {
             },
             timestamp: ts
         }));
+        // ── A-CTX-0: Shadow manifest emission ────────────────────────────────
+        // Use the serialized PromptPacket as the single shadow segment.
+        // This is a A-CTX-0 fallback — A-CTX-1 will map structured segments.
+        // Shadow failure MUST NOT break the governed run.
+        try {
+            const nowMs = options.nowMs ?? Date.now();
+            const shadow = compileContextShadow({
+                runId: request.loopId,
+                adapter: "martin-core",
+                nowMs,
+                shadowBudgetTokens: options.contextShadowBudgetTokens ?? 8_000,
+                modelWindowEvidence: "unknown",
+                segments: [
+                    {
+                        segmentId: "compiled-prompt",
+                        kind: "compiled_prompt",
+                        required: true,
+                        text: JSON.stringify(packet)
+                    }
+                ]
+            });
+            await options.store.appendLedger(request.loopId, makeLedgerEvent({
+                kind: "context.shadow_compiled",
+                runId: request.loopId,
+                attemptIndex: options.attemptIndex,
+                payload: shadow.receipt,
+                timestamp: ts
+            }));
+        }
+        catch (shadowErr) {
+            // Shadow telemetry failure is non-fatal. Emit a diagnostic ledger entry
+            // so the failure is visible without breaking the governed run.
+            const errorKind = shadowErr instanceof Error ? shadowErr.name : "UnknownError";
+            try {
+                await options.store.appendLedger(request.loopId, makeLedgerEvent({
+                    kind: "context.shadow_compiled",
+                    runId: request.loopId,
+                    attemptIndex: options.attemptIndex,
+                    payload: {
+                        mode: "shadow",
+                        error: "shadow_emit_failed",
+                        errorKind
+                    },
+                    timestamp: ts
+                }));
+            }
+            catch {
+                // Last-resort: if the diagnostic ledger write also fails, swallow it
+                // so the governed run completes. No prompt content is stored here.
+            }
+        }
+        // ── End A-CTX-0 shadow emission ───────────────────────────────────────
+        // ── A-CTX-1: Deterministic governed context compilation ───────────────
+        // Shadow mode: compute manifest but return original packet unchanged.
+        // nowMs captured once here — never passed as Date.now() inside compileContext.
+        // Failure must not break the governed run.
+        try {
+            const nowMs = options.nowMs ?? Date.now();
+            const adapter = options.contextAdapter ?? HEURISTIC_ADAPTER;
+            // Build one candidate from the serialized packet.
+            // Only the hash goes into the manifest — never the raw text.
+            const packetText = JSON.stringify(packet);
+            const packetHash = createHash("sha256").update(packetText, "utf8").digest("hex");
+            const estimatedTokens = Math.max(1, Math.ceil(Buffer.byteLength(packetText, "utf8") / 4));
+            const result = compileContext({
+                taskId: request.attemptId,
+                runId: request.loopId,
+                nowMs,
+                candidates: [
+                    {
+                        id: "compiled-prompt",
+                        kind: "task",
+                        priority: "required",
+                        trust: "authoritative",
+                        sensitivity: "workspace",
+                        sourceRef: `run://${request.loopId}/compiled-context`,
+                        contentHash: packetHash,
+                        estimatedTokens
+                    }
+                ],
+                budget: {
+                    modelWindowTokens: 200_000,
+                    systemReserveTokens: 2_000,
+                    outputReserveTokens: 4_000,
+                    toolReserveTokens: 3_000,
+                    overflowReserveTokens: 2_000,
+                    maxWorkingSetTokens: options.contextShadowBudgetTokens ?? 8_000,
+                    pinnedTokensMax: 1_500
+                },
+                policy: {
+                    policyHash: "shadow-passthrough-v1",
+                    deniedSensitivities: ["secret"],
+                    deniedTrustLevels: [],
+                    requiredOverBudgetAction: "explicit_escalation",
+                    maxCompilerDurationMs: 250,
+                    maxOverheadRatio: 0.15
+                },
+                adapter
+            });
+            if (result.ok) {
+                await options.store.appendLedger(request.loopId, makeLedgerEvent({
+                    kind: "context.manifest_compiled",
+                    runId: request.loopId,
+                    attemptIndex: options.attemptIndex,
+                    payload: result.ledgerEntry,
+                    timestamp: ts
+                }));
+            }
+            else {
+                // Explicit compiler failure (required_over_budget or recount_exceeded_passes).
+                // Record as a diagnostic — not a crash, not silent.
+                await options.store.appendLedger(request.loopId, makeLedgerEvent({
+                    kind: "context.manifest_compiled",
+                    runId: request.loopId,
+                    attemptIndex: options.attemptIndex,
+                    payload: {
+                        mode: "shadow",
+                        error: "compiler_failed",
+                        reason: result.reason
+                    },
+                    timestamp: ts
+                }));
+            }
+        }
+        catch (compilerErr) {
+            // Unexpected compiler failure is non-fatal. Emit a named diagnostic so
+            // the failure is visible in the ledger without breaking the governed run.
+            // Only error.name (e.g. "TypeError") is recorded — never error.message,
+            // which could contain prompt or segment text.
+            const errorKind = compilerErr instanceof Error ? compilerErr.name : "UnknownError";
+            try {
+                await options.store.appendLedger(request.loopId, makeLedgerEvent({
+                    kind: "context.manifest_compiled",
+                    runId: request.loopId,
+                    attemptIndex: options.attemptIndex,
+                    payload: {
+                        mode: "shadow",
+                        error: "compiler_threw",
+                        errorKind
+                    },
+                    timestamp: ts
+                }));
+            }
+            catch {
+                // Last-resort: diagnostic write failed too. The run must not be affected.
+                // No prompt content is stored anywhere in this path.
+            }
+        }
+        // ── End A-CTX-1 compiler ──────────────────────────────────────────────
     }
     return { packet };
 }

package/dist/vendor/core/persistence/context-handoff-store.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Context Handoff Store — A-CTX-2 persistence layer.
+ *
+ * Produces, writes, and reads ContextHandoffReceipt files so that
+ * downstream processes can verify them without rerunning the upstream agent.
+ *
+ * Storage layout (under runsRoot/<runId>/):
+ *   context-handoff.json        — the receipt produced by this run for the next hop
+ *
+ * The producerReceiptHash is computed as SHA-256 of the receipt-integrity.json
+ * file written by writeLoopRecord. If that file is absent, upstreamIntegrity is
+ * set to "evidence_boundary" — the receipt is still written but will not pass
+ * verifyContextHandoff.
+ */
+import type { ContextHandoffArtifact, ContextHandoffClaim, ContextHandoffReceipt } from "../../contracts/index.js";
+/** Compute the SHA-256 hex digest of a file's raw bytes. */
+export declare function computeFileHash(filePath: string): Promise<string>;
+export declare function contextHandoffPath(runsRoot: string, runId: string): string;
+/**
+ * Persist a ContextHandoffReceipt for this run so the next hop can load it.
+ * Overwrites any existing file — callers must not call this more than once per run.
+ */
+export declare function writeContextHandoff(runsRoot: string, runId: string, receipt: ContextHandoffReceipt): Promise<void>;
+/**
+ * Load a ContextHandoffReceipt from a previous run.
+ * Returns null when the file does not exist (not an error — the consumer
+ * must treat absence as a hard gate failure).
+ */
+export declare function readContextHandoff(runsRoot: string, runId: string): Promise<ContextHandoffReceipt | null>;
+export interface BuildHandoffReceiptInput {
+    runsRoot: string;
+    /** Run that is producing this handoff (the upstream/producer run). */
+    producerRunId: string;
+    /** Stable identifier for the chain. Shared across all hops. */
+    chainId: string;
+    /** Optional mission identifier shared across hops. */
+    missionId?: string;
+    /** Unique ID for this specific handoff crossing. Generated if absent. */
+    handoffId?: string;
+    /** Verified claims the producer is asserting. All must be state "verified". */
+    claims?: ContextHandoffClaim[];
+    /**
+     * File paths whose SHA-256 hashes should be captured as artifacts.
+     * Each file is hashed at call time — callers must call after writing artifacts.
+     */
+    artifactFiles?: Array<{
+        filePath: string;
+        label?: string;
+        required: boolean;
+    }>;
+    /** Optional pre-computed artifacts (bypasses file hashing). */
+    artifacts?: ContextHandoffArtifact[];
+    /** Assumptions that are not yet resolved at handoff time. */
+    unresolvedAssumptions?: string[];
+    /** Parent handoff IDs for multi-hop lineage. */
+    parentHandoffIds?: string[];
+    /** Clock override (defaults to new Date().toISOString()). */
+    now?: () => string;
+}
+/**
+ * Build a ContextHandoffReceipt from a completed run.
+ *
+ * - producerReceiptHash is SHA-256 of the receipt-integrity.json file
+ *   written by writeLoopRecord. If that file is absent, upstreamIntegrity
+ *   is "evidence_boundary".
+ * - Artifact hashes are computed from real files at call time.
+ */
+export declare function buildContextHandoffReceipt(input: BuildHandoffReceiptInput): Promise<ContextHandoffReceipt>;

package/dist/vendor/core/persistence/context-handoff-store.js

@@ -0,0 +1,112 @@
+/**
+ * Context Handoff Store — A-CTX-2 persistence layer.
+ *
+ * Produces, writes, and reads ContextHandoffReceipt files so that
+ * downstream processes can verify them without rerunning the upstream agent.
+ *
+ * Storage layout (under runsRoot/<runId>/):
+ *   context-handoff.json        — the receipt produced by this run for the next hop
+ *
+ * The producerReceiptHash is computed as SHA-256 of the receipt-integrity.json
+ * file written by writeLoopRecord. If that file is absent, upstreamIntegrity is
+ * set to "evidence_boundary" — the receipt is still written but will not pass
+ * verifyContextHandoff.
+ */
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { HANDOFF_SCHEMA_VERSION } from "../../contracts/index.js";
+import { resolveReceiptIntegrityPath } from "./integrity.js";
+import { runDir } from "./store.js";
+// ─── Hash helpers ──────────────────────────────────────────────────────────────
+/** Compute the SHA-256 hex digest of a file's raw bytes. */
+export async function computeFileHash(filePath) {
+    const buf = await readFile(filePath);
+    return createHash("sha256").update(buf).digest("hex");
+}
+/** Compute the SHA-256 hex digest of a UTF-8 string. */
+function sha256String(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+// ─── Paths ─────────────────────────────────────────────────────────────────────
+export function contextHandoffPath(runsRoot, runId) {
+    return join(runDir(runsRoot, runId), "context-handoff.json");
+}
+// ─── Write ─────────────────────────────────────────────────────────────────────
+/**
+ * Persist a ContextHandoffReceipt for this run so the next hop can load it.
+ * Overwrites any existing file — callers must not call this more than once per run.
+ */
+export async function writeContextHandoff(runsRoot, runId, receipt) {
+    const dir = runDir(runsRoot, runId);
+    await mkdir(dir, { recursive: true });
+    await writeFile(contextHandoffPath(runsRoot, runId), JSON.stringify(receipt, null, 2), "utf8");
+}
+// ─── Read ──────────────────────────────────────────────────────────────────────
+/**
+ * Load a ContextHandoffReceipt from a previous run.
+ * Returns null when the file does not exist (not an error — the consumer
+ * must treat absence as a hard gate failure).
+ */
+export async function readContextHandoff(runsRoot, runId) {
+    const path = contextHandoffPath(runsRoot, runId);
+    const raw = await readFile(path, "utf8").catch(() => null);
+    if (raw === null)
+        return null;
+    return JSON.parse(raw);
+}
+/**
+ * Build a ContextHandoffReceipt from a completed run.
+ *
+ * - producerReceiptHash is SHA-256 of the receipt-integrity.json file
+ *   written by writeLoopRecord. If that file is absent, upstreamIntegrity
+ *   is "evidence_boundary".
+ * - Artifact hashes are computed from real files at call time.
+ */
+export async function buildContextHandoffReceipt(input) {
+    const { runsRoot, producerRunId, chainId, missionId, claims = [], unresolvedAssumptions = [], parentHandoffIds, now = () => new Date().toISOString() } = input;
+    // Determine handoffId
+    const handoffId = input.handoffId ??
+        `hoff_${sha256String(`${chainId}:${producerRunId}:${now()}`).slice(0, 16)}`;
+    // Hash the receipt-integrity.json file to obtain producerReceiptHash
+    const integrityPath = resolveReceiptIntegrityPath(runsRoot, producerRunId);
+    let producerReceiptHash;
+    let upstreamIntegrity;
+    const integrityRaw = await readFile(integrityPath, "utf8").catch(() => null);
+    if (integrityRaw === null) {
+        // No integrity file — cannot establish upstream integrity
+        producerReceiptHash = "";
+        upstreamIntegrity = "evidence_boundary";
+    }
+    else {
+        producerReceiptHash = sha256String(integrityRaw);
+        upstreamIntegrity = "verified";
+    }
+    // Hash artifact files
+    const artifactFiles = input.artifactFiles ?? [];
+    const fileArtifacts = await Promise.all(artifactFiles.map(async (af) => ({
+        path: af.filePath,
+        sha256: await computeFileHash(af.filePath),
+        required: af.required,
+        label: af.label
+    })));
+    const artifacts = [
+        ...(input.artifacts ?? []),
+        ...fileArtifacts
+    ];
+    const receipt = {
+        schemaVersion: HANDOFF_SCHEMA_VERSION,
+        handoffId,
+        chainId,
+        ...(missionId !== undefined ? { missionId } : {}),
+        producerRunId,
+        producerReceiptHash,
+        ...(parentHandoffIds !== undefined ? { parentHandoffIds } : {}),
+        claims,
+        artifacts,
+        unresolvedAssumptions,
+        upstreamIntegrity,
+        createdAt: now()
+    };
+    return receipt;
+}

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

@@ -8,3 +8,7 @@ export { readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile,
 export type { LoopAttemptRecord, LoopRunRecord } from "./runs-reader.js";
 export { compileAndPersistContext } from "./compiler.js";
 export type { CompileResult } from "./compiler.js";
+export { buildContextHandoffReceipt, computeFileHash, contextHandoffPath, readContextHandoff, writeContextHandoff } from "./context-handoff-store.js";
+export type { BuildHandoffReceiptInput } from "./context-handoff-store.js";
+export { attachRun, changeMissionStatus, createMission, missionDir, readMission, readMissionLedger, verifyMissionLedger } from "./mission-store.js";
+export type { AttachRunOptions, ChangeMissionStatusOptions, LedgerIntegrityResult } from "./mission-store.js";

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

@@ -3,3 +3,5 @@ export { resolveReceiptIntegrityPath, verifyReceiptIntegrityFromFiles, writeRece
 export { artifactDir, createFileRunStore, resolveRunsRoot, runDir } from "./store.js";
 export { readAllLoopRecords, readLatestLoopRecord, readLatestLoopRecordFromFile, readLoopRecordsFromFile } from "./runs-reader.js";
 export { compileAndPersistContext } from "./compiler.js";
+export { buildContextHandoffReceipt, computeFileHash, contextHandoffPath, readContextHandoff, writeContextHandoff } from "./context-handoff-store.js";
+export { attachRun, changeMissionStatus, createMission, missionDir, readMission, readMissionLedger, verifyMissionLedger } from "./mission-store.js";

package/dist/vendor/core/persistence/ledger.d.ts

@@ -3,7 +3,7 @@
  * These are WRITE-side events that go into ledger.jsonl — separate from the
  * read-model LoopEventType used by the control plane.
  */
-export type LedgerEventKind = "contract.created" | "attempt.admitted" | "attempt.rejected" | "prompt.compiled" | "patch.generated" | "verification.completed" | "grounding.violations_found" | "safety.violations_found" | "budget.settled" | "attempt.kept" | "attempt.discarded" | "run.exited";
+export type LedgerEventKind = "contract.created" | "attempt.admitted" | "attempt.rejected" | "prompt.compiled" | "patch.generated" | "verification.completed" | "grounding.violations_found" | "safety.violations_found" | "budget.settled" | "attempt.kept" | "attempt.discarded" | "run.exited" | "run.terminated" | "run.diagnostic" | "context.shadow_compiled" | "context.manifest_compiled" | "context.handoff.received" | "context.handoff.verified" | "context.handoff.blocked" | "context.object.excluded";
 export interface LedgerEvent {
     kind: LedgerEventKind;
     runId: string;

package/dist/vendor/core/persistence/mission-store.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Mission Store — C2 durable persistence.
+ *
+ * Layout under <runsRoot>/missions/<missionId>/:
+ *   mission.json      — rebuildable snapshot/cache (NOT the authority)
+ *   ledger.jsonl      — append-only, SHA-256 hash-chained event log (authority)
+ *   ledger-chain.json — chain head hash for tamper detection
+ *   .lock             — cross-process exclusive lock (created with O_EXCL)
+ *
+ * Rules:
+ *   - Ledger is always written before mission.json is updated.
+ *   - mission.json is written atomically (temp file → rename).
+ *   - Cross-process lock is held during every write; stale locks (>8s) are removed.
+ *   - CAS revision must match before any write is accepted.
+ *   - Corrupt or unverifiable ledger data fails closed.
+ *   - Workspace isolation: all paths are under caller-supplied runsRoot.
+ */
+import type { MissionDecision, MissionEvent, MissionRecord, MissionRunRole, MissionStatus } from "../../contracts/index.js";
+export declare function missionDir(runsRoot: string, missionId: string): string;
+/**
+ * Read the current mission snapshot.
+ * Returns null when no mission exists at this path.
+ * Fails closed when the snapshot schema version is not recognised.
+ */
+export declare function readMission(runsRoot: string, missionId: string): Promise<MissionRecord | null>;
+export declare function readMissionLedger(runsRoot: string, missionId: string): Promise<MissionEvent[]>;
+export interface LedgerIntegrityResult {
+    ok: boolean;
+    reason?: string;
+    entryCount: number;
+}
+/**
+ * Verify the stored chain head matches a full replay of the ledger.
+ * Returns ok=false when the ledger has been tampered with or entries are missing.
+ */
+export declare function verifyMissionLedger(runsRoot: string, missionId: string): Promise<LedgerIntegrityResult>;
+export declare function createMission(runsRoot: string, mission: MissionRecord): Promise<void>;
+export interface AttachRunOptions {
+    loopId: string;
+    role: MissionRunRole;
+    verifiedOutcome?: boolean;
+    actualUsd?: number;
+    now?: () => string;
+    /** Expected revision for CAS enforcement. */
+    expectedRevision: number;
+}
+export declare function attachRun(runsRoot: string, missionId: string, options: AttachRunOptions): Promise<MissionRecord>;
+export interface ChangeMissionStatusOptions {
+    toStatus: MissionStatus;
+    expectedRevision: number;
+    decidedBy?: string;
+    decision?: MissionDecision;
+    note?: string;
+    now?: () => string;
+}
+export declare function changeMissionStatus(runsRoot: string, missionId: string, options: ChangeMissionStatusOptions): Promise<MissionRecord>;