@neuraloom/contracts 0.0.0-stage → 0.1.22

package/dist/schemas/workflow/engineering-context.schema.d.ts

@@ -0,0 +1,2235 @@
+/**
+ * Engineering Context — durable, revision-aware task context that survives agent resets.
+ *
+ * Connects the existing mechanisms (task capsule → context bundle → durable execution
+ * spine → workflow artifacts) into one task-specific workflow:
+ *
+ *   capsule (intake)  →  engineering brief (evidence assembly, bounded)
+ *                     →  task checkpoint (durable milestones, provider-independent)
+ *                     →  verification result (what was genuinely tested)
+ *                     →  resume (invalidate stale evidence, rebuild brief, continue)
+ *
+ * Canonical storage: workflow_artifacts rows with artifact_type in
+ *   'engineeringBrief' | 'taskCheckpoint' | 'verificationResult'.
+ * Execution linkage: execution_runs / execution_tasks (CAN-021) — never a second spine.
+ *
+ * Source facts, accepted decisions and hypotheses are separate fields by design:
+ * an agent's plausible interpretation must never become an authoritative fact
+ * merely because it was saved.
+ */
+import { z } from 'zod';
+export declare const ENGINEERING_CONTEXT_SCHEMA_VERSION: "1.0.0";
+/** Starting budget for a worker brief (chars ≈ tokens × 4). Tunable, not a universal limit. */
+export declare const ENGINEERING_BRIEF_DEFAULT_MAX_CHARS: 24000;
+export declare const ENGINEERING_BRIEF_MAX_EVIDENCE_REFS: 200;
+export declare const ENGINEERING_BRIEF_MAX_RELATIONSHIPS: 400;
+export declare const VERIFICATION_ERROR_EXCERPT_MAX_CHARS: 4000;
+export declare const CommitShaSchema: z.ZodString;
+export declare const RevisionRoleSchema: z.ZodEnum<["primary", "dependency", "consumer"]>;
+export type RevisionRole = z.infer<typeof RevisionRoleSchema>;
+/**
+ * One participating repository at an exact revision. A task across connected
+ * codebases needs one entry per repo — a single commit SHA is insufficient.
+ * `installedVersions` records what a consuming app actually has installed of a
+ * shared package so an agent cannot assume a new producer API is available.
+ */
+export declare const RevisionMapEntrySchema: z.ZodObject<{
+    repo: z.ZodString;
+    branch: z.ZodNullable<z.ZodString>;
+    commit: z.ZodString;
+    dirty: z.ZodDefault<z.ZodBoolean>;
+    uncommittedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    role: z.ZodDefault<z.ZodEnum<["primary", "dependency", "consumer"]>>;
+    installedVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    dirty: boolean;
+    branch: string | null;
+    role: "primary" | "dependency" | "consumer";
+    commit: string;
+    uncommittedFiles: string[];
+    installedVersions?: Record<string, string> | undefined;
+}, {
+    repo: string;
+    branch: string | null;
+    commit: string;
+    dirty?: boolean | undefined;
+    role?: "primary" | "dependency" | "consumer" | undefined;
+    uncommittedFiles?: string[] | undefined;
+    installedVersions?: Record<string, string> | undefined;
+}>;
+export type RevisionMapEntry = z.infer<typeof RevisionMapEntrySchema>;
+export declare const RevisionMapSchema: z.ZodArray<z.ZodObject<{
+    repo: z.ZodString;
+    branch: z.ZodNullable<z.ZodString>;
+    commit: z.ZodString;
+    dirty: z.ZodDefault<z.ZodBoolean>;
+    uncommittedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    role: z.ZodDefault<z.ZodEnum<["primary", "dependency", "consumer"]>>;
+    installedVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    dirty: boolean;
+    branch: string | null;
+    role: "primary" | "dependency" | "consumer";
+    commit: string;
+    uncommittedFiles: string[];
+    installedVersions?: Record<string, string> | undefined;
+}, {
+    repo: string;
+    branch: string | null;
+    commit: string;
+    dirty?: boolean | undefined;
+    role?: "primary" | "dependency" | "consumer" | undefined;
+    uncommittedFiles?: string[] | undefined;
+    installedVersions?: Record<string, string> | undefined;
+}>, "many">;
+export type RevisionMap = z.infer<typeof RevisionMapSchema>;
+export declare const EvidenceKindSchema: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+export type EvidenceKind = z.infer<typeof EvidenceKindSchema>;
+/** How an evidence item was selected — exact resolution ranks above keyword hits. */
+export declare const EvidenceRelevanceSchema: z.ZodEnum<["exact", "dependency", "reference", "governance", "keyword"]>;
+export type EvidenceRelevance = z.infer<typeof EvidenceRelevanceSchema>;
+export declare const EvidenceRefSchema: z.ZodObject<{
+    /** Stable evidence id, e.g. `node:<uuid>`, `file:<path>`, `drift:<finding-id>`. */
+    id: z.ZodString;
+    kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+    /** Path, stable key, artifact uuid, route path or finding id the id points at. */
+    ref: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    /** Commit the evidence was observed at; null when not revision-bound. */
+    revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Content hash (sha256) when the evidence body was hashed; null otherwise. */
+    contentHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    relevance: z.ZodEnum<["exact", "dependency", "reference", "governance", "keyword"]>;
+    /** Resolver that selected this item (symbol_index, dependency_traversal, …). */
+    selectedBy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+    ref: string;
+    revision: string | null;
+    contentHash: string | null;
+    relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+    repo?: string | undefined;
+    label?: string | undefined;
+    selectedBy?: string | undefined;
+}, {
+    id: string;
+    kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+    ref: string;
+    relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+    repo?: string | undefined;
+    label?: string | undefined;
+    revision?: string | null | undefined;
+    contentHash?: string | null | undefined;
+    selectedBy?: string | undefined;
+}>;
+export type EvidenceRef = z.infer<typeof EvidenceRefSchema>;
+export declare const EvidenceRelationshipSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    relation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sourceId: string;
+    targetId: string;
+    relation: string;
+}, {
+    sourceId: string;
+    targetId: string;
+    relation: string;
+}>;
+export type EvidenceRelationship = z.infer<typeof EvidenceRelationshipSchema>;
+/** Explicit, expandable truncation: what was left out and how to fetch more. */
+export declare const EvidenceOmissionSchema: z.ZodObject<{
+    kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+    totalCount: z.ZodNumber;
+    omittedCount: z.ZodNumber;
+    continuationToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+    totalCount: number;
+    omittedCount: number;
+    continuationToken: string | null;
+}, {
+    kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+    totalCount: number;
+    omittedCount: number;
+    continuationToken?: string | null | undefined;
+}>;
+export type EvidenceOmission = z.infer<typeof EvidenceOmissionSchema>;
+export declare const MandatoryRuleSourceSchema: z.ZodEnum<["constitution", "repo_policy", "tombstone", "ownership", "capsule", "agent_rules"]>;
+/** Governing requirements that context reduction must never drop. */
+export declare const MandatoryRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodEnum<["constitution", "repo_policy", "tombstone", "ownership", "capsule", "agent_rules"]>;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+    text: string;
+}, {
+    id: string;
+    source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+    text: string;
+}>;
+export type MandatoryRule = z.infer<typeof MandatoryRuleSchema>;
+export declare const DecisionSourceSchema: z.ZodEnum<["human", "agent"]>;
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    decision: z.ZodString;
+    rationale: z.ZodDefault<z.ZodString>;
+    evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    source: z.ZodEnum<["human", "agent"]>;
+    decidedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    source: "agent" | "human";
+    decidedAt: string;
+    decision: string;
+    rationale: string;
+    evidenceIds: string[];
+}, {
+    id: string;
+    source: "agent" | "human";
+    decidedAt: string;
+    decision: string;
+    rationale?: string | undefined;
+    evidenceIds?: string[] | undefined;
+}>;
+export type Decision = z.infer<typeof DecisionSchema>;
+export declare const HypothesisStatusSchema: z.ZodEnum<["open", "confirmed", "rejected"]>;
+export declare const HypothesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    statement: z.ZodString;
+    status: z.ZodEnum<["open", "confirmed", "rejected"]>;
+    evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    note: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "rejected" | "open" | "confirmed";
+    statement: string;
+    evidenceIds: string[];
+    note?: string | undefined;
+}, {
+    id: string;
+    status: "rejected" | "open" | "confirmed";
+    statement: string;
+    note?: string | undefined;
+    evidenceIds?: string[] | undefined;
+}>;
+export type Hypothesis = z.infer<typeof HypothesisSchema>;
+export declare const KnownFailureStatusSchema: z.ZodEnum<["open", "resolved", "rejected"]>;
+export declare const KnownFailureSchema: z.ZodObject<{
+    id: z.ZodString;
+    summary: z.ZodString;
+    evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    status: z.ZodDefault<z.ZodEnum<["open", "resolved", "rejected"]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "rejected" | "open" | "resolved";
+    summary: string;
+    evidenceIds: string[];
+}, {
+    id: string;
+    summary: string;
+    status?: "rejected" | "open" | "resolved" | undefined;
+    evidenceIds?: string[] | undefined;
+}>;
+export type KnownFailure = z.infer<typeof KnownFailureSchema>;
+export declare const PatchRefSchema: z.ZodObject<{
+    repo: z.ZodString;
+    branch: z.ZodNullable<z.ZodString>;
+    worktree: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    headSha: z.ZodNullable<z.ZodString>;
+    dirty: z.ZodDefault<z.ZodBoolean>;
+    /** sha256 of the current diff, so a resumed agent can detect a changed patch. */
+    diffHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    patchArtifactId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    dirty: boolean;
+    branch: string | null;
+    headSha: string | null;
+    worktree: string | null;
+    diffHash: string | null;
+    patchArtifactId: string | null;
+}, {
+    repo: string;
+    branch: string | null;
+    headSha: string | null;
+    dirty?: boolean | undefined;
+    worktree?: string | null | undefined;
+    diffHash?: string | null | undefined;
+    patchArtifactId?: string | null | undefined;
+}>;
+export type PatchRef = z.infer<typeof PatchRefSchema>;
+export declare const VerificationStatusSchema: z.ZodEnum<["passed", "failed", "blocked", "not_run"]>;
+export type VerificationStatus = z.infer<typeof VerificationStatusSchema>;
+export declare const ToolchainIdentitySchema: z.ZodObject<{
+    node: z.ZodOptional<z.ZodString>;
+    pnpm: z.ZodOptional<z.ZodString>;
+    os: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    environment?: string | undefined;
+    pnpm?: string | undefined;
+    node?: string | undefined;
+    os?: string | undefined;
+}, {
+    environment?: string | undefined;
+    pnpm?: string | undefined;
+    node?: string | undefined;
+    os?: string | undefined;
+}>;
+/**
+ * One verification result: exact revision + patch tested, command identity,
+ * failure excerpt first, full log on demand. Producer tests passing does not
+ * prove the consumer still works — `contractSides` records both.
+ */
+export declare const VerificationResultPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    taskId: z.ZodString;
+    checkpointSequence: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    revision: z.ZodObject<{
+        repo: z.ZodString;
+        commit: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        commit: string;
+    }, {
+        repo: string;
+        commit: string;
+    }>;
+    patchRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        repo: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        worktree: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        headSha: z.ZodNullable<z.ZodString>;
+        dirty: z.ZodDefault<z.ZodBoolean>;
+        /** sha256 of the current diff, so a resumed agent can detect a changed patch. */
+        diffHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        patchArtifactId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        headSha: string | null;
+        worktree: string | null;
+        diffHash: string | null;
+        patchArtifactId: string | null;
+    }, {
+        repo: string;
+        branch: string | null;
+        headSha: string | null;
+        dirty?: boolean | undefined;
+        worktree?: string | null | undefined;
+        diffHash?: string | null | undefined;
+        patchArtifactId?: string | null | undefined;
+    }>>>;
+    command: z.ZodString;
+    cwd: z.ZodString;
+    toolchain: z.ZodDefault<z.ZodObject<{
+        node: z.ZodOptional<z.ZodString>;
+        pnpm: z.ZodOptional<z.ZodString>;
+        os: z.ZodOptional<z.ZodString>;
+        environment: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        environment?: string | undefined;
+        pnpm?: string | undefined;
+        node?: string | undefined;
+        os?: string | undefined;
+    }, {
+        environment?: string | undefined;
+        pnpm?: string | undefined;
+        node?: string | undefined;
+        os?: string | undefined;
+    }>>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<["passed", "failed", "blocked", "not_run"]>;
+    failingTests: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    errorExcerpt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    logArtifactRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** True when the same failure reproduces without the patch; null when unknown. */
+    preExistingFailure: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    affectedSymbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    contractSides: z.ZodOptional<z.ZodObject<{
+        producer: z.ZodOptional<z.ZodEnum<["passed", "failed", "blocked", "not_run"]>>;
+        consumer: z.ZodOptional<z.ZodEnum<["passed", "failed", "blocked", "not_run"]>>;
+    }, "strip", z.ZodTypeAny, {
+        producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+    }, {
+        producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+    }>>;
+    durationMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    recordedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "failed" | "blocked" | "passed" | "not_run";
+    schemaVersion: "1.0.0";
+    recordedAt: string;
+    durationMs: number | null;
+    taskId: string;
+    revision: {
+        repo: string;
+        commit: string;
+    };
+    command: string;
+    checkpointSequence: number | null;
+    patchRef: {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        headSha: string | null;
+        worktree: string | null;
+        diffHash: string | null;
+        patchArtifactId: string | null;
+    } | null;
+    cwd: string;
+    toolchain: {
+        environment?: string | undefined;
+        pnpm?: string | undefined;
+        node?: string | undefined;
+        os?: string | undefined;
+    };
+    exitCode: number | null;
+    failingTests: string[];
+    errorExcerpt: string | null;
+    logArtifactRef: string | null;
+    preExistingFailure: boolean | null;
+    affectedSymbols: string[];
+    contractSides?: {
+        producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+    } | undefined;
+}, {
+    status: "failed" | "blocked" | "passed" | "not_run";
+    schemaVersion: "1.0.0";
+    recordedAt: string;
+    taskId: string;
+    revision: {
+        repo: string;
+        commit: string;
+    };
+    command: string;
+    cwd: string;
+    exitCode: number | null;
+    durationMs?: number | null | undefined;
+    checkpointSequence?: number | null | undefined;
+    patchRef?: {
+        repo: string;
+        branch: string | null;
+        headSha: string | null;
+        dirty?: boolean | undefined;
+        worktree?: string | null | undefined;
+        diffHash?: string | null | undefined;
+        patchArtifactId?: string | null | undefined;
+    } | null | undefined;
+    toolchain?: {
+        environment?: string | undefined;
+        pnpm?: string | undefined;
+        node?: string | undefined;
+        os?: string | undefined;
+    } | undefined;
+    failingTests?: string[] | undefined;
+    errorExcerpt?: string | null | undefined;
+    logArtifactRef?: string | null | undefined;
+    preExistingFailure?: boolean | null | undefined;
+    affectedSymbols?: string[] | undefined;
+    contractSides?: {
+        producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+    } | undefined;
+}>;
+export type VerificationResultPayload = z.infer<typeof VerificationResultPayloadSchema>;
+export declare const InvestigationMethodSchema: z.ZodEnum<["symbol_index", "dependency_traversal", "route_trace", "knowledge_retrieval", "git_diff", "test_mapping", "manual"]>;
+export type InvestigationMethod = z.infer<typeof InvestigationMethodSchema>;
+export declare const CompletedInvestigationSchema: z.ZodObject<{
+    id: z.ZodString;
+    query: z.ZodString;
+    method: z.ZodEnum<["symbol_index", "dependency_traversal", "route_trace", "knowledge_retrieval", "git_diff", "test_mapping", "manual"]>;
+    summary: z.ZodDefault<z.ZodString>;
+    evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    summary: string;
+    method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+    query: string;
+    evidenceIds: string[];
+}, {
+    id: string;
+    method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+    query: string;
+    summary?: string | undefined;
+    evidenceIds?: string[] | undefined;
+}>;
+export type CompletedInvestigation = z.infer<typeof CompletedInvestigationSchema>;
+export declare const EngineeringBriefBudgetSchema: z.ZodObject<{
+    maxChars: z.ZodNumber;
+    usedChars: z.ZodNumber;
+    estimatedTokens: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxChars: number;
+    usedChars: number;
+    estimatedTokens: number;
+}, {
+    maxChars: number;
+    usedChars: number;
+    estimatedTokens: number;
+}>;
+/**
+ * The compact worker brief. Objective → rules → relevant implementation →
+ * relationships → known failures → acceptance criteria → next action.
+ */
+export declare const EngineeringBriefPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    taskId: z.ZodString;
+    capsuleArtifactId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    /** Execution task (execution_tasks.id) whose checkpoint this brief was built from. */
+    executionTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    executionRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    compiledAt: z.ZodString;
+    objective: z.ZodString;
+    acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    mandatoryRules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodEnum<["constitution", "repo_policy", "tombstone", "ownership", "capsule", "agent_rules"]>;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+        text: string;
+    }, {
+        id: string;
+        source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+        text: string;
+    }>, "many">;
+    revisionMap: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        commit: z.ZodString;
+        dirty: z.ZodDefault<z.ZodBoolean>;
+        uncommittedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        role: z.ZodDefault<z.ZodEnum<["primary", "dependency", "consumer"]>>;
+        installedVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        role: "primary" | "dependency" | "consumer";
+        commit: string;
+        uncommittedFiles: string[];
+        installedVersions?: Record<string, string> | undefined;
+    }, {
+        repo: string;
+        branch: string | null;
+        commit: string;
+        dirty?: boolean | undefined;
+        role?: "primary" | "dependency" | "consumer" | undefined;
+        uncommittedFiles?: string[] | undefined;
+        installedVersions?: Record<string, string> | undefined;
+    }>, "many">;
+    policyVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    selectedEvidence: z.ZodArray<z.ZodObject<{
+        /** Stable evidence id, e.g. `node:<uuid>`, `file:<path>`, `drift:<finding-id>`. */
+        id: z.ZodString;
+        kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+        /** Path, stable key, artifact uuid, route path or finding id the id points at. */
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        repo: z.ZodOptional<z.ZodString>;
+        /** Commit the evidence was observed at; null when not revision-bound. */
+        revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Content hash (sha256) when the evidence body was hashed; null otherwise. */
+        contentHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        relevance: z.ZodEnum<["exact", "dependency", "reference", "governance", "keyword"]>;
+        /** Resolver that selected this item (symbol_index, dependency_traversal, …). */
+        selectedBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        revision: string | null;
+        contentHash: string | null;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        selectedBy?: string | undefined;
+    }, {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        revision?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        selectedBy?: string | undefined;
+    }>, "many">;
+    relationships: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        targetId: z.ZodString;
+        relation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sourceId: string;
+        targetId: string;
+        relation: string;
+    }, {
+        sourceId: string;
+        targetId: string;
+        relation: string;
+    }>, "many">;
+    omissions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+        totalCount: z.ZodNumber;
+        omittedCount: z.ZodNumber;
+        continuationToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        totalCount: number;
+        omittedCount: number;
+        continuationToken: string | null;
+    }, {
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        totalCount: number;
+        omittedCount: number;
+        continuationToken?: string | null | undefined;
+    }>, "many">;
+    knownFailures: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        summary: z.ZodString;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        status: z.ZodDefault<z.ZodEnum<["open", "resolved", "rejected"]>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "rejected" | "open" | "resolved";
+        summary: string;
+        evidenceIds: string[];
+    }, {
+        id: string;
+        summary: string;
+        status?: "rejected" | "open" | "resolved" | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">;
+    priorDecisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        decision: z.ZodString;
+        rationale: z.ZodDefault<z.ZodString>;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        source: z.ZodEnum<["human", "agent"]>;
+        decidedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale: string;
+        evidenceIds: string[];
+    }, {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">;
+    nextAction: z.ZodString;
+    budget: z.ZodObject<{
+        maxChars: z.ZodNumber;
+        usedChars: z.ZodNumber;
+        estimatedTokens: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        maxChars: number;
+        usedChars: number;
+        estimatedTokens: number;
+    }, {
+        maxChars: number;
+        usedChars: number;
+        estimatedTokens: number;
+    }>;
+    /** Content-addressed identity: repos + revisions + policy + scope + task. */
+    cacheKey: z.ZodString;
+    /** Hash of the access scope (never raw scope identifiers). */
+    scopeKey: z.ZodString;
+    promptMarkdown: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "1.0.0";
+    executionRunId: string | null;
+    executionTaskId: string | null;
+    nextAction: string;
+    taskId: string;
+    acceptanceCriteria: string[];
+    budget: {
+        maxChars: number;
+        usedChars: number;
+        estimatedTokens: number;
+    };
+    compiledAt: string;
+    objective: string;
+    relationships: {
+        sourceId: string;
+        targetId: string;
+        relation: string;
+    }[];
+    capsuleArtifactId: string | null;
+    mandatoryRules: {
+        id: string;
+        source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+        text: string;
+    }[];
+    revisionMap: {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        role: "primary" | "dependency" | "consumer";
+        commit: string;
+        uncommittedFiles: string[];
+        installedVersions?: Record<string, string> | undefined;
+    }[];
+    policyVersion: string | null;
+    selectedEvidence: {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        revision: string | null;
+        contentHash: string | null;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        selectedBy?: string | undefined;
+    }[];
+    omissions: {
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        totalCount: number;
+        omittedCount: number;
+        continuationToken: string | null;
+    }[];
+    knownFailures: {
+        id: string;
+        status: "rejected" | "open" | "resolved";
+        summary: string;
+        evidenceIds: string[];
+    }[];
+    priorDecisions: {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale: string;
+        evidenceIds: string[];
+    }[];
+    cacheKey: string;
+    scopeKey: string;
+    promptMarkdown: string;
+}, {
+    schemaVersion: "1.0.0";
+    nextAction: string;
+    taskId: string;
+    acceptanceCriteria: string[];
+    budget: {
+        maxChars: number;
+        usedChars: number;
+        estimatedTokens: number;
+    };
+    compiledAt: string;
+    objective: string;
+    relationships: {
+        sourceId: string;
+        targetId: string;
+        relation: string;
+    }[];
+    mandatoryRules: {
+        id: string;
+        source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+        text: string;
+    }[];
+    revisionMap: {
+        repo: string;
+        branch: string | null;
+        commit: string;
+        dirty?: boolean | undefined;
+        role?: "primary" | "dependency" | "consumer" | undefined;
+        uncommittedFiles?: string[] | undefined;
+        installedVersions?: Record<string, string> | undefined;
+    }[];
+    selectedEvidence: {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        revision?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        selectedBy?: string | undefined;
+    }[];
+    omissions: {
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        totalCount: number;
+        omittedCount: number;
+        continuationToken?: string | null | undefined;
+    }[];
+    knownFailures: {
+        id: string;
+        summary: string;
+        status?: "rejected" | "open" | "resolved" | undefined;
+        evidenceIds?: string[] | undefined;
+    }[];
+    priorDecisions: {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }[];
+    cacheKey: string;
+    scopeKey: string;
+    promptMarkdown: string;
+    executionRunId?: string | null | undefined;
+    executionTaskId?: string | null | undefined;
+    capsuleArtifactId?: string | null | undefined;
+    policyVersion?: string | null | undefined;
+}>;
+export type EngineeringBriefPayload = z.infer<typeof EngineeringBriefPayloadSchema>;
+export declare const CheckpointProviderSchema: z.ZodObject<{
+    conversationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    responseId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    responseId: string | null;
+    model: string | null;
+    conversationId: string | null;
+}, {
+    responseId?: string | null | undefined;
+    model?: string | null | undefined;
+    conversationId?: string | null | undefined;
+}>;
+/**
+ * Durable milestone. Sufficient to resume in a fresh conversation with a
+ * different model; a provider conversation id is an optional convenience.
+ * Stores concise conclusions and evidence — never private reasoning.
+ */
+export declare const TaskCheckpointPayloadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    taskId: z.ZodString;
+    executionRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    executionTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    cortexTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sequence: z.ZodNumber;
+    milestone: z.ZodString;
+    createdAt: z.ZodString;
+    revisionMap: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        commit: z.ZodString;
+        dirty: z.ZodDefault<z.ZodBoolean>;
+        uncommittedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        role: z.ZodDefault<z.ZodEnum<["primary", "dependency", "consumer"]>>;
+        installedVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        role: "primary" | "dependency" | "consumer";
+        commit: string;
+        uncommittedFiles: string[];
+        installedVersions?: Record<string, string> | undefined;
+    }, {
+        repo: string;
+        branch: string | null;
+        commit: string;
+        dirty?: boolean | undefined;
+        role?: "primary" | "dependency" | "consumer" | undefined;
+        uncommittedFiles?: string[] | undefined;
+        installedVersions?: Record<string, string> | undefined;
+    }>, "many">;
+    policyVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    completedInvestigation: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        query: z.ZodString;
+        method: z.ZodEnum<["symbol_index", "dependency_traversal", "route_trace", "knowledge_retrieval", "git_diff", "test_mapping", "manual"]>;
+        summary: z.ZodDefault<z.ZodString>;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        summary: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        evidenceIds: string[];
+    }, {
+        id: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        summary?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Stable evidence id, e.g. `node:<uuid>`, `file:<path>`, `drift:<finding-id>`. */
+        id: z.ZodString;
+        kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+        /** Path, stable key, artifact uuid, route path or finding id the id points at. */
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        repo: z.ZodOptional<z.ZodString>;
+        /** Commit the evidence was observed at; null when not revision-bound. */
+        revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Content hash (sha256) when the evidence body was hashed; null otherwise. */
+        contentHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        relevance: z.ZodEnum<["exact", "dependency", "reference", "governance", "keyword"]>;
+        /** Resolver that selected this item (symbol_index, dependency_traversal, …). */
+        selectedBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        revision: string | null;
+        contentHash: string | null;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        selectedBy?: string | undefined;
+    }, {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        revision?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        selectedBy?: string | undefined;
+    }>, "many">>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        decision: z.ZodString;
+        rationale: z.ZodDefault<z.ZodString>;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        source: z.ZodEnum<["human", "agent"]>;
+        decidedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale: string;
+        evidenceIds: string[];
+    }, {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">>;
+    hypotheses: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        status: z.ZodEnum<["open", "confirmed", "rejected"]>;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "rejected" | "open" | "confirmed";
+        statement: string;
+        evidenceIds: string[];
+        note?: string | undefined;
+    }, {
+        id: string;
+        status: "rejected" | "open" | "confirmed";
+        statement: string;
+        note?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">>;
+    patchRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        repo: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        worktree: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        headSha: z.ZodNullable<z.ZodString>;
+        dirty: z.ZodDefault<z.ZodBoolean>;
+        /** sha256 of the current diff, so a resumed agent can detect a changed patch. */
+        diffHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        patchArtifactId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        headSha: string | null;
+        worktree: string | null;
+        diffHash: string | null;
+        patchArtifactId: string | null;
+    }, {
+        repo: string;
+        branch: string | null;
+        headSha: string | null;
+        dirty?: boolean | undefined;
+        worktree?: string | null | undefined;
+        diffHash?: string | null | undefined;
+        patchArtifactId?: string | null | undefined;
+    }>>>;
+    verification: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        taskId: z.ZodString;
+        checkpointSequence: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        revision: z.ZodObject<{
+            repo: z.ZodString;
+            commit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            repo: string;
+            commit: string;
+        }, {
+            repo: string;
+            commit: string;
+        }>;
+        patchRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            repo: z.ZodString;
+            branch: z.ZodNullable<z.ZodString>;
+            worktree: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            headSha: z.ZodNullable<z.ZodString>;
+            dirty: z.ZodDefault<z.ZodBoolean>;
+            /** sha256 of the current diff, so a resumed agent can detect a changed patch. */
+            diffHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            patchArtifactId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            repo: string;
+            dirty: boolean;
+            branch: string | null;
+            headSha: string | null;
+            worktree: string | null;
+            diffHash: string | null;
+            patchArtifactId: string | null;
+        }, {
+            repo: string;
+            branch: string | null;
+            headSha: string | null;
+            dirty?: boolean | undefined;
+            worktree?: string | null | undefined;
+            diffHash?: string | null | undefined;
+            patchArtifactId?: string | null | undefined;
+        }>>>;
+        command: z.ZodString;
+        cwd: z.ZodString;
+        toolchain: z.ZodDefault<z.ZodObject<{
+            node: z.ZodOptional<z.ZodString>;
+            pnpm: z.ZodOptional<z.ZodString>;
+            os: z.ZodOptional<z.ZodString>;
+            environment: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            environment?: string | undefined;
+            pnpm?: string | undefined;
+            node?: string | undefined;
+            os?: string | undefined;
+        }, {
+            environment?: string | undefined;
+            pnpm?: string | undefined;
+            node?: string | undefined;
+            os?: string | undefined;
+        }>>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<["passed", "failed", "blocked", "not_run"]>;
+        failingTests: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        errorExcerpt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        logArtifactRef: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** True when the same failure reproduces without the patch; null when unknown. */
+        preExistingFailure: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+        affectedSymbols: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        contractSides: z.ZodOptional<z.ZodObject<{
+            producer: z.ZodOptional<z.ZodEnum<["passed", "failed", "blocked", "not_run"]>>;
+            consumer: z.ZodOptional<z.ZodEnum<["passed", "failed", "blocked", "not_run"]>>;
+        }, "strip", z.ZodTypeAny, {
+            producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+            consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        }, {
+            producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+            consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        }>>;
+        durationMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        recordedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: "failed" | "blocked" | "passed" | "not_run";
+        schemaVersion: "1.0.0";
+        recordedAt: string;
+        durationMs: number | null;
+        taskId: string;
+        revision: {
+            repo: string;
+            commit: string;
+        };
+        command: string;
+        checkpointSequence: number | null;
+        patchRef: {
+            repo: string;
+            dirty: boolean;
+            branch: string | null;
+            headSha: string | null;
+            worktree: string | null;
+            diffHash: string | null;
+            patchArtifactId: string | null;
+        } | null;
+        cwd: string;
+        toolchain: {
+            environment?: string | undefined;
+            pnpm?: string | undefined;
+            node?: string | undefined;
+            os?: string | undefined;
+        };
+        exitCode: number | null;
+        failingTests: string[];
+        errorExcerpt: string | null;
+        logArtifactRef: string | null;
+        preExistingFailure: boolean | null;
+        affectedSymbols: string[];
+        contractSides?: {
+            producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+            consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        } | undefined;
+    }, {
+        status: "failed" | "blocked" | "passed" | "not_run";
+        schemaVersion: "1.0.0";
+        recordedAt: string;
+        taskId: string;
+        revision: {
+            repo: string;
+            commit: string;
+        };
+        command: string;
+        cwd: string;
+        exitCode: number | null;
+        durationMs?: number | null | undefined;
+        checkpointSequence?: number | null | undefined;
+        patchRef?: {
+            repo: string;
+            branch: string | null;
+            headSha: string | null;
+            dirty?: boolean | undefined;
+            worktree?: string | null | undefined;
+            diffHash?: string | null | undefined;
+            patchArtifactId?: string | null | undefined;
+        } | null | undefined;
+        toolchain?: {
+            environment?: string | undefined;
+            pnpm?: string | undefined;
+            node?: string | undefined;
+            os?: string | undefined;
+        } | undefined;
+        failingTests?: string[] | undefined;
+        errorExcerpt?: string | null | undefined;
+        logArtifactRef?: string | null | undefined;
+        preExistingFailure?: boolean | null | undefined;
+        affectedSymbols?: string[] | undefined;
+        contractSides?: {
+            producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+            consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        } | undefined;
+    }>, "many">>;
+    remainingWork: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    nextAction: z.ZodString;
+    provider: z.ZodDefault<z.ZodObject<{
+        conversationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        responseId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        responseId: string | null;
+        model: string | null;
+        conversationId: string | null;
+    }, {
+        responseId?: string | null | undefined;
+        model?: string | null | undefined;
+        conversationId?: string | null | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "1.0.0";
+    createdAt: string;
+    executionRunId: string | null;
+    executionTaskId: string | null;
+    provider: {
+        responseId: string | null;
+        model: string | null;
+        conversationId: string | null;
+    };
+    evidence: {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        revision: string | null;
+        contentHash: string | null;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        selectedBy?: string | undefined;
+    }[];
+    nextAction: string;
+    taskId: string;
+    decisions: {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale: string;
+        evidenceIds: string[];
+    }[];
+    verification: {
+        status: "failed" | "blocked" | "passed" | "not_run";
+        schemaVersion: "1.0.0";
+        recordedAt: string;
+        durationMs: number | null;
+        taskId: string;
+        revision: {
+            repo: string;
+            commit: string;
+        };
+        command: string;
+        checkpointSequence: number | null;
+        patchRef: {
+            repo: string;
+            dirty: boolean;
+            branch: string | null;
+            headSha: string | null;
+            worktree: string | null;
+            diffHash: string | null;
+            patchArtifactId: string | null;
+        } | null;
+        cwd: string;
+        toolchain: {
+            environment?: string | undefined;
+            pnpm?: string | undefined;
+            node?: string | undefined;
+            os?: string | undefined;
+        };
+        exitCode: number | null;
+        failingTests: string[];
+        errorExcerpt: string | null;
+        logArtifactRef: string | null;
+        preExistingFailure: boolean | null;
+        affectedSymbols: string[];
+        contractSides?: {
+            producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+            consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        } | undefined;
+    }[];
+    patchRef: {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        headSha: string | null;
+        worktree: string | null;
+        diffHash: string | null;
+        patchArtifactId: string | null;
+    } | null;
+    revisionMap: {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        role: "primary" | "dependency" | "consumer";
+        commit: string;
+        uncommittedFiles: string[];
+        installedVersions?: Record<string, string> | undefined;
+    }[];
+    policyVersion: string | null;
+    cortexTaskId: string | null;
+    sequence: number;
+    milestone: string;
+    completedInvestigation: {
+        id: string;
+        summary: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        evidenceIds: string[];
+    }[];
+    hypotheses: {
+        id: string;
+        status: "rejected" | "open" | "confirmed";
+        statement: string;
+        evidenceIds: string[];
+        note?: string | undefined;
+    }[];
+    remainingWork: string[];
+}, {
+    schemaVersion: "1.0.0";
+    createdAt: string;
+    nextAction: string;
+    taskId: string;
+    revisionMap: {
+        repo: string;
+        branch: string | null;
+        commit: string;
+        dirty?: boolean | undefined;
+        role?: "primary" | "dependency" | "consumer" | undefined;
+        uncommittedFiles?: string[] | undefined;
+        installedVersions?: Record<string, string> | undefined;
+    }[];
+    sequence: number;
+    milestone: string;
+    executionRunId?: string | null | undefined;
+    executionTaskId?: string | null | undefined;
+    provider?: {
+        responseId?: string | null | undefined;
+        model?: string | null | undefined;
+        conversationId?: string | null | undefined;
+    } | undefined;
+    evidence?: {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        revision?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        selectedBy?: string | undefined;
+    }[] | undefined;
+    decisions?: {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }[] | undefined;
+    verification?: {
+        status: "failed" | "blocked" | "passed" | "not_run";
+        schemaVersion: "1.0.0";
+        recordedAt: string;
+        taskId: string;
+        revision: {
+            repo: string;
+            commit: string;
+        };
+        command: string;
+        cwd: string;
+        exitCode: number | null;
+        durationMs?: number | null | undefined;
+        checkpointSequence?: number | null | undefined;
+        patchRef?: {
+            repo: string;
+            branch: string | null;
+            headSha: string | null;
+            dirty?: boolean | undefined;
+            worktree?: string | null | undefined;
+            diffHash?: string | null | undefined;
+            patchArtifactId?: string | null | undefined;
+        } | null | undefined;
+        toolchain?: {
+            environment?: string | undefined;
+            pnpm?: string | undefined;
+            node?: string | undefined;
+            os?: string | undefined;
+        } | undefined;
+        failingTests?: string[] | undefined;
+        errorExcerpt?: string | null | undefined;
+        logArtifactRef?: string | null | undefined;
+        preExistingFailure?: boolean | null | undefined;
+        affectedSymbols?: string[] | undefined;
+        contractSides?: {
+            producer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+            consumer?: "failed" | "blocked" | "passed" | "not_run" | undefined;
+        } | undefined;
+    }[] | undefined;
+    patchRef?: {
+        repo: string;
+        branch: string | null;
+        headSha: string | null;
+        dirty?: boolean | undefined;
+        worktree?: string | null | undefined;
+        diffHash?: string | null | undefined;
+        patchArtifactId?: string | null | undefined;
+    } | null | undefined;
+    policyVersion?: string | null | undefined;
+    cortexTaskId?: string | null | undefined;
+    completedInvestigation?: {
+        id: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        summary?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }[] | undefined;
+    hypotheses?: {
+        id: string;
+        status: "rejected" | "open" | "confirmed";
+        statement: string;
+        note?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }[] | undefined;
+    remainingWork?: string[] | undefined;
+}>;
+export type TaskCheckpointPayload = z.infer<typeof TaskCheckpointPayloadSchema>;
+export declare const EvidenceInvalidationReasonSchema: z.ZodEnum<["revision_changed", "file_changed", "repo_missing", "policy_changed", "hash_mismatch"]>;
+export type EvidenceInvalidationReason = z.infer<typeof EvidenceInvalidationReasonSchema>;
+export declare const InvalidatedEvidenceSchema: z.ZodObject<{
+    evidenceId: z.ZodString;
+    reason: z.ZodEnum<["revision_changed", "file_changed", "repo_missing", "policy_changed", "hash_mismatch"]>;
+}, "strip", z.ZodTypeAny, {
+    reason: "repo_missing" | "revision_changed" | "file_changed" | "policy_changed" | "hash_mismatch";
+    evidenceId: string;
+}, {
+    reason: "repo_missing" | "revision_changed" | "file_changed" | "policy_changed" | "hash_mismatch";
+    evidenceId: string;
+}>;
+export type InvalidatedEvidence = z.infer<typeof InvalidatedEvidenceSchema>;
+export declare const StaleRevisionSchema: z.ZodObject<{
+    repo: z.ZodString;
+    checkpointCommit: z.ZodNullable<z.ZodString>;
+    currentCommit: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    repo: string;
+    checkpointCommit: string | null;
+    currentCommit: string | null;
+}, {
+    repo: string;
+    checkpointCommit: string | null;
+    currentCommit: string | null;
+}>;
+export type StaleRevision = z.infer<typeof StaleRevisionSchema>;
+export declare const CheckpointResumeRequestSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    currentRevisionMap: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        commit: z.ZodString;
+        dirty: z.ZodDefault<z.ZodBoolean>;
+        uncommittedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        role: z.ZodDefault<z.ZodEnum<["primary", "dependency", "consumer"]>>;
+        installedVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        role: "primary" | "dependency" | "consumer";
+        commit: string;
+        uncommittedFiles: string[];
+        installedVersions?: Record<string, string> | undefined;
+    }, {
+        repo: string;
+        branch: string | null;
+        commit: string;
+        dirty?: boolean | undefined;
+        role?: "primary" | "dependency" | "consumer" | undefined;
+        uncommittedFiles?: string[] | undefined;
+        installedVersions?: Record<string, string> | undefined;
+    }>, "many">;
+    /** Repo-relative paths changed since the checkpoint (git diff + graph diff). */
+    changedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    policyVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    policyVersion: string | null;
+    currentRevisionMap: {
+        repo: string;
+        dirty: boolean;
+        branch: string | null;
+        role: "primary" | "dependency" | "consumer";
+        commit: string;
+        uncommittedFiles: string[];
+        installedVersions?: Record<string, string> | undefined;
+    }[];
+    changedFiles: string[];
+}, {
+    taskId: string;
+    currentRevisionMap: {
+        repo: string;
+        branch: string | null;
+        commit: string;
+        dirty?: boolean | undefined;
+        role?: "primary" | "dependency" | "consumer" | undefined;
+        uncommittedFiles?: string[] | undefined;
+        installedVersions?: Record<string, string> | undefined;
+    }[];
+    policyVersion?: string | null | undefined;
+    changedFiles?: string[] | undefined;
+}>;
+export type CheckpointResumeRequest = z.infer<typeof CheckpointResumeRequestSchema>;
+export declare const CheckpointResumeOutcomeSchema: z.ZodEnum<["resumed", "no_checkpoint"]>;
+export declare const CheckpointResumeResponseSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    outcome: z.ZodEnum<["resumed", "no_checkpoint"]>;
+    /** Execution task the resumed checkpoint lives on (single persistence path). */
+    executionTaskId: z.ZodNullable<z.ZodString>;
+    sequence: z.ZodNullable<z.ZodNumber>;
+    staleRevisions: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        checkpointCommit: z.ZodNullable<z.ZodString>;
+        currentCommit: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        repo: string;
+        checkpointCommit: string | null;
+        currentCommit: string | null;
+    }, {
+        repo: string;
+        checkpointCommit: string | null;
+        currentCommit: string | null;
+    }>, "many">;
+    validEvidence: z.ZodArray<z.ZodObject<{
+        /** Stable evidence id, e.g. `node:<uuid>`, `file:<path>`, `drift:<finding-id>`. */
+        id: z.ZodString;
+        kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+        /** Path, stable key, artifact uuid, route path or finding id the id points at. */
+        ref: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        repo: z.ZodOptional<z.ZodString>;
+        /** Commit the evidence was observed at; null when not revision-bound. */
+        revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Content hash (sha256) when the evidence body was hashed; null otherwise. */
+        contentHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        relevance: z.ZodEnum<["exact", "dependency", "reference", "governance", "keyword"]>;
+        /** Resolver that selected this item (symbol_index, dependency_traversal, …). */
+        selectedBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        revision: string | null;
+        contentHash: string | null;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        selectedBy?: string | undefined;
+    }, {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        revision?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        selectedBy?: string | undefined;
+    }>, "many">;
+    invalidatedEvidence: z.ZodArray<z.ZodObject<{
+        evidenceId: z.ZodString;
+        reason: z.ZodEnum<["revision_changed", "file_changed", "repo_missing", "policy_changed", "hash_mismatch"]>;
+    }, "strip", z.ZodTypeAny, {
+        reason: "repo_missing" | "revision_changed" | "file_changed" | "policy_changed" | "hash_mismatch";
+        evidenceId: string;
+    }, {
+        reason: "repo_missing" | "revision_changed" | "file_changed" | "policy_changed" | "hash_mismatch";
+        evidenceId: string;
+    }>, "many">;
+    /** Hypotheses whose supporting evidence was invalidated are re-opened, not deleted. */
+    reopenedHypothesisIds: z.ZodArray<z.ZodString, "many">;
+    /** Verification results that no longer describe the current revision/patch. */
+    staleVerificationCount: z.ZodNumber;
+    completedInvestigation: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        query: z.ZodString;
+        method: z.ZodEnum<["symbol_index", "dependency_traversal", "route_trace", "knowledge_retrieval", "git_diff", "test_mapping", "manual"]>;
+        summary: z.ZodDefault<z.ZodString>;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        summary: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        evidenceIds: string[];
+    }, {
+        id: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        summary?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">;
+    decisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        decision: z.ZodString;
+        rationale: z.ZodDefault<z.ZodString>;
+        evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        source: z.ZodEnum<["human", "agent"]>;
+        decidedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale: string;
+        evidenceIds: string[];
+    }, {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }>, "many">;
+    remainingWork: z.ZodArray<z.ZodString, "many">;
+    nextAction: z.ZodNullable<z.ZodString>;
+    brief: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0.0">;
+        taskId: z.ZodString;
+        capsuleArtifactId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** Execution task (execution_tasks.id) whose checkpoint this brief was built from. */
+        executionTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        executionRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        compiledAt: z.ZodString;
+        objective: z.ZodString;
+        acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+        mandatoryRules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            source: z.ZodEnum<["constitution", "repo_policy", "tombstone", "ownership", "capsule", "agent_rules"]>;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+            text: string;
+        }, {
+            id: string;
+            source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+            text: string;
+        }>, "many">;
+        revisionMap: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            branch: z.ZodNullable<z.ZodString>;
+            commit: z.ZodString;
+            dirty: z.ZodDefault<z.ZodBoolean>;
+            uncommittedFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            role: z.ZodDefault<z.ZodEnum<["primary", "dependency", "consumer"]>>;
+            installedVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            repo: string;
+            dirty: boolean;
+            branch: string | null;
+            role: "primary" | "dependency" | "consumer";
+            commit: string;
+            uncommittedFiles: string[];
+            installedVersions?: Record<string, string> | undefined;
+        }, {
+            repo: string;
+            branch: string | null;
+            commit: string;
+            dirty?: boolean | undefined;
+            role?: "primary" | "dependency" | "consumer" | undefined;
+            uncommittedFiles?: string[] | undefined;
+            installedVersions?: Record<string, string> | undefined;
+        }>, "many">;
+        policyVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        selectedEvidence: z.ZodArray<z.ZodObject<{
+            /** Stable evidence id, e.g. `node:<uuid>`, `file:<path>`, `drift:<finding-id>`. */
+            id: z.ZodString;
+            kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+            /** Path, stable key, artifact uuid, route path or finding id the id points at. */
+            ref: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            /** Commit the evidence was observed at; null when not revision-bound. */
+            revision: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            /** Content hash (sha256) when the evidence body was hashed; null otherwise. */
+            contentHash: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            relevance: z.ZodEnum<["exact", "dependency", "reference", "governance", "keyword"]>;
+            /** Resolver that selected this item (symbol_index, dependency_traversal, …). */
+            selectedBy: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            ref: string;
+            revision: string | null;
+            contentHash: string | null;
+            relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+            repo?: string | undefined;
+            label?: string | undefined;
+            selectedBy?: string | undefined;
+        }, {
+            id: string;
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            ref: string;
+            relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+            repo?: string | undefined;
+            label?: string | undefined;
+            revision?: string | null | undefined;
+            contentHash?: string | null | undefined;
+            selectedBy?: string | undefined;
+        }>, "many">;
+        relationships: z.ZodArray<z.ZodObject<{
+            sourceId: z.ZodString;
+            targetId: z.ZodString;
+            relation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            sourceId: string;
+            targetId: string;
+            relation: string;
+        }, {
+            sourceId: string;
+            targetId: string;
+            relation: string;
+        }>, "many">;
+        omissions: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<["node", "edge", "file", "symbol", "route", "contract", "drift_finding", "decision", "test", "verification", "log", "artifact", "knowledge"]>;
+            totalCount: z.ZodNumber;
+            omittedCount: z.ZodNumber;
+            continuationToken: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            totalCount: number;
+            omittedCount: number;
+            continuationToken: string | null;
+        }, {
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            totalCount: number;
+            omittedCount: number;
+            continuationToken?: string | null | undefined;
+        }>, "many">;
+        knownFailures: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            summary: z.ZodString;
+            evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            status: z.ZodDefault<z.ZodEnum<["open", "resolved", "rejected"]>>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            status: "rejected" | "open" | "resolved";
+            summary: string;
+            evidenceIds: string[];
+        }, {
+            id: string;
+            summary: string;
+            status?: "rejected" | "open" | "resolved" | undefined;
+            evidenceIds?: string[] | undefined;
+        }>, "many">;
+        priorDecisions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            decision: z.ZodString;
+            rationale: z.ZodDefault<z.ZodString>;
+            evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            source: z.ZodEnum<["human", "agent"]>;
+            decidedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            source: "agent" | "human";
+            decidedAt: string;
+            decision: string;
+            rationale: string;
+            evidenceIds: string[];
+        }, {
+            id: string;
+            source: "agent" | "human";
+            decidedAt: string;
+            decision: string;
+            rationale?: string | undefined;
+            evidenceIds?: string[] | undefined;
+        }>, "many">;
+        nextAction: z.ZodString;
+        budget: z.ZodObject<{
+            maxChars: z.ZodNumber;
+            usedChars: z.ZodNumber;
+            estimatedTokens: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            maxChars: number;
+            usedChars: number;
+            estimatedTokens: number;
+        }, {
+            maxChars: number;
+            usedChars: number;
+            estimatedTokens: number;
+        }>;
+        /** Content-addressed identity: repos + revisions + policy + scope + task. */
+        cacheKey: z.ZodString;
+        /** Hash of the access scope (never raw scope identifiers). */
+        scopeKey: z.ZodString;
+        promptMarkdown: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        schemaVersion: "1.0.0";
+        executionRunId: string | null;
+        executionTaskId: string | null;
+        nextAction: string;
+        taskId: string;
+        acceptanceCriteria: string[];
+        budget: {
+            maxChars: number;
+            usedChars: number;
+            estimatedTokens: number;
+        };
+        compiledAt: string;
+        objective: string;
+        relationships: {
+            sourceId: string;
+            targetId: string;
+            relation: string;
+        }[];
+        capsuleArtifactId: string | null;
+        mandatoryRules: {
+            id: string;
+            source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+            text: string;
+        }[];
+        revisionMap: {
+            repo: string;
+            dirty: boolean;
+            branch: string | null;
+            role: "primary" | "dependency" | "consumer";
+            commit: string;
+            uncommittedFiles: string[];
+            installedVersions?: Record<string, string> | undefined;
+        }[];
+        policyVersion: string | null;
+        selectedEvidence: {
+            id: string;
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            ref: string;
+            revision: string | null;
+            contentHash: string | null;
+            relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+            repo?: string | undefined;
+            label?: string | undefined;
+            selectedBy?: string | undefined;
+        }[];
+        omissions: {
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            totalCount: number;
+            omittedCount: number;
+            continuationToken: string | null;
+        }[];
+        knownFailures: {
+            id: string;
+            status: "rejected" | "open" | "resolved";
+            summary: string;
+            evidenceIds: string[];
+        }[];
+        priorDecisions: {
+            id: string;
+            source: "agent" | "human";
+            decidedAt: string;
+            decision: string;
+            rationale: string;
+            evidenceIds: string[];
+        }[];
+        cacheKey: string;
+        scopeKey: string;
+        promptMarkdown: string;
+    }, {
+        schemaVersion: "1.0.0";
+        nextAction: string;
+        taskId: string;
+        acceptanceCriteria: string[];
+        budget: {
+            maxChars: number;
+            usedChars: number;
+            estimatedTokens: number;
+        };
+        compiledAt: string;
+        objective: string;
+        relationships: {
+            sourceId: string;
+            targetId: string;
+            relation: string;
+        }[];
+        mandatoryRules: {
+            id: string;
+            source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+            text: string;
+        }[];
+        revisionMap: {
+            repo: string;
+            branch: string | null;
+            commit: string;
+            dirty?: boolean | undefined;
+            role?: "primary" | "dependency" | "consumer" | undefined;
+            uncommittedFiles?: string[] | undefined;
+            installedVersions?: Record<string, string> | undefined;
+        }[];
+        selectedEvidence: {
+            id: string;
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            ref: string;
+            relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+            repo?: string | undefined;
+            label?: string | undefined;
+            revision?: string | null | undefined;
+            contentHash?: string | null | undefined;
+            selectedBy?: string | undefined;
+        }[];
+        omissions: {
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            totalCount: number;
+            omittedCount: number;
+            continuationToken?: string | null | undefined;
+        }[];
+        knownFailures: {
+            id: string;
+            summary: string;
+            status?: "rejected" | "open" | "resolved" | undefined;
+            evidenceIds?: string[] | undefined;
+        }[];
+        priorDecisions: {
+            id: string;
+            source: "agent" | "human";
+            decidedAt: string;
+            decision: string;
+            rationale?: string | undefined;
+            evidenceIds?: string[] | undefined;
+        }[];
+        cacheKey: string;
+        scopeKey: string;
+        promptMarkdown: string;
+        executionRunId?: string | null | undefined;
+        executionTaskId?: string | null | undefined;
+        capsuleArtifactId?: string | null | undefined;
+        policyVersion?: string | null | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    executionTaskId: string | null;
+    nextAction: string | null;
+    taskId: string;
+    decisions: {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale: string;
+        evidenceIds: string[];
+    }[];
+    outcome: "resumed" | "no_checkpoint";
+    brief: {
+        schemaVersion: "1.0.0";
+        executionRunId: string | null;
+        executionTaskId: string | null;
+        nextAction: string;
+        taskId: string;
+        acceptanceCriteria: string[];
+        budget: {
+            maxChars: number;
+            usedChars: number;
+            estimatedTokens: number;
+        };
+        compiledAt: string;
+        objective: string;
+        relationships: {
+            sourceId: string;
+            targetId: string;
+            relation: string;
+        }[];
+        capsuleArtifactId: string | null;
+        mandatoryRules: {
+            id: string;
+            source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+            text: string;
+        }[];
+        revisionMap: {
+            repo: string;
+            dirty: boolean;
+            branch: string | null;
+            role: "primary" | "dependency" | "consumer";
+            commit: string;
+            uncommittedFiles: string[];
+            installedVersions?: Record<string, string> | undefined;
+        }[];
+        policyVersion: string | null;
+        selectedEvidence: {
+            id: string;
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            ref: string;
+            revision: string | null;
+            contentHash: string | null;
+            relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+            repo?: string | undefined;
+            label?: string | undefined;
+            selectedBy?: string | undefined;
+        }[];
+        omissions: {
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            totalCount: number;
+            omittedCount: number;
+            continuationToken: string | null;
+        }[];
+        knownFailures: {
+            id: string;
+            status: "rejected" | "open" | "resolved";
+            summary: string;
+            evidenceIds: string[];
+        }[];
+        priorDecisions: {
+            id: string;
+            source: "agent" | "human";
+            decidedAt: string;
+            decision: string;
+            rationale: string;
+            evidenceIds: string[];
+        }[];
+        cacheKey: string;
+        scopeKey: string;
+        promptMarkdown: string;
+    } | null;
+    sequence: number | null;
+    completedInvestigation: {
+        id: string;
+        summary: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        evidenceIds: string[];
+    }[];
+    remainingWork: string[];
+    staleRevisions: {
+        repo: string;
+        checkpointCommit: string | null;
+        currentCommit: string | null;
+    }[];
+    validEvidence: {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        revision: string | null;
+        contentHash: string | null;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        selectedBy?: string | undefined;
+    }[];
+    invalidatedEvidence: {
+        reason: "repo_missing" | "revision_changed" | "file_changed" | "policy_changed" | "hash_mismatch";
+        evidenceId: string;
+    }[];
+    reopenedHypothesisIds: string[];
+    staleVerificationCount: number;
+}, {
+    executionTaskId: string | null;
+    nextAction: string | null;
+    taskId: string;
+    decisions: {
+        id: string;
+        source: "agent" | "human";
+        decidedAt: string;
+        decision: string;
+        rationale?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }[];
+    outcome: "resumed" | "no_checkpoint";
+    brief: {
+        schemaVersion: "1.0.0";
+        nextAction: string;
+        taskId: string;
+        acceptanceCriteria: string[];
+        budget: {
+            maxChars: number;
+            usedChars: number;
+            estimatedTokens: number;
+        };
+        compiledAt: string;
+        objective: string;
+        relationships: {
+            sourceId: string;
+            targetId: string;
+            relation: string;
+        }[];
+        mandatoryRules: {
+            id: string;
+            source: "constitution" | "repo_policy" | "tombstone" | "ownership" | "capsule" | "agent_rules";
+            text: string;
+        }[];
+        revisionMap: {
+            repo: string;
+            branch: string | null;
+            commit: string;
+            dirty?: boolean | undefined;
+            role?: "primary" | "dependency" | "consumer" | undefined;
+            uncommittedFiles?: string[] | undefined;
+            installedVersions?: Record<string, string> | undefined;
+        }[];
+        selectedEvidence: {
+            id: string;
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            ref: string;
+            relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+            repo?: string | undefined;
+            label?: string | undefined;
+            revision?: string | null | undefined;
+            contentHash?: string | null | undefined;
+            selectedBy?: string | undefined;
+        }[];
+        omissions: {
+            kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+            totalCount: number;
+            omittedCount: number;
+            continuationToken?: string | null | undefined;
+        }[];
+        knownFailures: {
+            id: string;
+            summary: string;
+            status?: "rejected" | "open" | "resolved" | undefined;
+            evidenceIds?: string[] | undefined;
+        }[];
+        priorDecisions: {
+            id: string;
+            source: "agent" | "human";
+            decidedAt: string;
+            decision: string;
+            rationale?: string | undefined;
+            evidenceIds?: string[] | undefined;
+        }[];
+        cacheKey: string;
+        scopeKey: string;
+        promptMarkdown: string;
+        executionRunId?: string | null | undefined;
+        executionTaskId?: string | null | undefined;
+        capsuleArtifactId?: string | null | undefined;
+        policyVersion?: string | null | undefined;
+    } | null;
+    sequence: number | null;
+    completedInvestigation: {
+        id: string;
+        method: "manual" | "symbol_index" | "dependency_traversal" | "route_trace" | "knowledge_retrieval" | "git_diff" | "test_mapping";
+        query: string;
+        summary?: string | undefined;
+        evidenceIds?: string[] | undefined;
+    }[];
+    remainingWork: string[];
+    staleRevisions: {
+        repo: string;
+        checkpointCommit: string | null;
+        currentCommit: string | null;
+    }[];
+    validEvidence: {
+        id: string;
+        kind: "symbol" | "knowledge" | "decision" | "test" | "file" | "route" | "artifact" | "log" | "node" | "edge" | "contract" | "drift_finding" | "verification";
+        ref: string;
+        relevance: "governance" | "exact" | "dependency" | "reference" | "keyword";
+        repo?: string | undefined;
+        label?: string | undefined;
+        revision?: string | null | undefined;
+        contentHash?: string | null | undefined;
+        selectedBy?: string | undefined;
+    }[];
+    invalidatedEvidence: {
+        reason: "repo_missing" | "revision_changed" | "file_changed" | "policy_changed" | "hash_mismatch";
+        evidenceId: string;
+    }[];
+    reopenedHypothesisIds: string[];
+    staleVerificationCount: number;
+}>;
+export type CheckpointResumeResponse = z.infer<typeof CheckpointResumeResponseSchema>;
+export type EvidenceInvalidationInput = {
+    checkpoint: Pick<TaskCheckpointPayload, 'revisionMap' | 'evidence' | 'hypotheses' | 'verification' | 'policyVersion' | 'patchRef'>;
+    currentRevisionMap: RevisionMap;
+    changedFiles?: readonly string[];
+    policyVersion?: string | null;
+};
+export type EvidenceInvalidationResult = {
+    staleRevisions: StaleRevision[];
+    validEvidence: EvidenceRef[];
+    invalidatedEvidence: InvalidatedEvidence[];
+    reopenedHypothesisIds: string[];
+    staleVerificationCount: number;
+    policyChanged: boolean;
+};
+/**
+ * Compare a checkpoint against the current revision map and changed files.
+ * Evidence bound to a repo whose commit moved is invalidated only when its file
+ * is in `changedFiles` (git diff + graph diff) or when it is revision-bound to
+ * the old commit and no changed-file list was supplied. Evidence whose repo is
+ * no longer present is invalidated. A policy version change invalidates
+ * governance evidence. Everything else stays valid — refresh what changed,
+ * retain what remains valid.
+ */
+export declare function computeEvidenceInvalidation(input: EvidenceInvalidationInput): EvidenceInvalidationResult;
+/** Stable, order-independent serialization for cache keys. */
+export declare function serializeRevisionMap(map: RevisionMap): string;
+/**
+ * Cache key material: task + repos/revisions/worktree state + policy + scope.
+ * Callers hash this (sha256) — hashing is left to the runtime so contracts stay
+ * dependency-free. The task text alone is never a sufficient key.
+ */
+export declare function buildEngineeringContextCacheMaterial(input: {
+    taskId: string;
+    revisionMap: RevisionMap;
+    policyVersion: string | null;
+    scopeKey: string;
+    step?: string | null;
+}): string;
+/** Rough token estimate for budget accounting (4 chars ≈ 1 token). */
+export declare function estimateTokensFromChars(chars: number): number;
+/**
+ * The ONLY place a task checkpoint is stored. It rides the existing durable
+ * execution spine (CAN-021) as `execution_tasks.metadata.stage_metadata[KEY]`;
+ * there is no artifact table, no second store, no history table. Sequence and
+ * verification history live inside the payload.
+ */
+export declare const ENGINEERING_CHECKPOINT_STAGE_METADATA_KEY: "engineeringCheckpoint";
+/** Stage id that routes brief preparation through the cheaper model policy in executeStage. */
+export declare const ENGINEERING_BRIEF_PREPARATION_STAGE_ID: "engineering_brief_preparation";
+export declare const CheckpointMissReasonSchema: z.ZodEnum<["stage_metadata_missing", "checkpoint_absent", "checkpoint_invalid"]>;
+export type CheckpointMissReason = z.infer<typeof CheckpointMissReasonSchema>;
+/** Defensive reader for stage metadata; never throws. */
+export declare function readTaskCheckpointFromStageMetadata(stageMetadata: unknown): {
+    checkpoint: TaskCheckpointPayload | null;
+    missReason: CheckpointMissReason | null;
+};
+/** Merge a checkpoint into stage metadata (pure). */
+export declare function mergeTaskCheckpointIntoStageMetadata(stageMetadata: Record<string, unknown> | null, checkpoint: TaskCheckpointPayload): Record<string, unknown>;
+export type ContractChangeInvalidation = {
+    invalidatedEvidenceIds: string[];
+    preservedEvidenceIds: string[];
+    /** Consumers still on the previous producer revision get their own verification command. */
+    consumerChecks: Array<{
+        repo: string;
+        command: string;
+        cwd: string;
+        reason: string;
+    }>;
+};
+/**
+ * A shared contract changed at exactly (repo, previousRevision → nextRevision).
+ * Only evidence observed at that producer revision is invalidated; everything
+ * else is preserved. Producer tests passing never proves a consumer: every
+ * consumer entry whose installed version of `packageName` is unknown or still
+ * the previous one receives its own verification command.
+ */
+export declare function computeContractChangeInvalidation(input: {
+    evidence: readonly EvidenceRef[];
+    revisionMap: RevisionMap;
+    changed: {
+        repo: string;
+        previousRevision: string;
+        nextRevision: string;
+        packageName: string;
+        /** Version string consumers had installed before the change, when known. */
+        previousVersion?: string | null;
+    };
+}): ContractChangeInvalidation;
+export declare const EngineeringContextMissingReasonSchema: z.ZodEnum<["no_matches", "source_unavailable", "not_approved", "retrieval_failed", "stale_revision"]>;
+export type EngineeringContextMissingReason = z.infer<typeof EngineeringContextMissingReasonSchema>;
+export declare const EngineeringContextTraceSchema: z.ZodObject<{
+    taskReachedNeuraLoom: z.ZodBoolean;
+    cortexTaskId: z.ZodNullable<z.ZodString>;
+    executionRunId: z.ZodNullable<z.ZodString>;
+    executionTaskId: z.ZodNullable<z.ZodString>;
+    requestedRevision: z.ZodNullable<z.ZodString>;
+    indexedRevision: z.ZodNullable<z.ZodString>;
+    indexedRevisionMatches: z.ZodNullable<z.ZodBoolean>;
+    missingContextReason: z.ZodNullable<z.ZodEnum<["no_matches", "source_unavailable", "not_approved", "retrieval_failed", "stale_revision"]>>;
+    checkpointMissReason: z.ZodNullable<z.ZodEnum<["stage_metadata_missing", "checkpoint_absent", "checkpoint_invalid"]>>;
+    sequence: z.ZodNullable<z.ZodNumber>;
+    verificationTestedPatch: z.ZodBoolean;
+    canResume: z.ZodBoolean;
+    nextAction: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    executionRunId: string | null;
+    executionTaskId: string | null;
+    nextAction: string | null;
+    cortexTaskId: string | null;
+    sequence: number | null;
+    taskReachedNeuraLoom: boolean;
+    requestedRevision: string | null;
+    indexedRevision: string | null;
+    indexedRevisionMatches: boolean | null;
+    missingContextReason: "no_matches" | "source_unavailable" | "not_approved" | "retrieval_failed" | "stale_revision" | null;
+    checkpointMissReason: "stage_metadata_missing" | "checkpoint_absent" | "checkpoint_invalid" | null;
+    verificationTestedPatch: boolean;
+    canResume: boolean;
+}, {
+    executionRunId: string | null;
+    executionTaskId: string | null;
+    nextAction: string | null;
+    cortexTaskId: string | null;
+    sequence: number | null;
+    taskReachedNeuraLoom: boolean;
+    requestedRevision: string | null;
+    indexedRevision: string | null;
+    indexedRevisionMatches: boolean | null;
+    missingContextReason: "no_matches" | "source_unavailable" | "not_approved" | "retrieval_failed" | "stale_revision" | null;
+    checkpointMissReason: "stage_metadata_missing" | "checkpoint_absent" | "checkpoint_invalid" | null;
+    verificationTestedPatch: boolean;
+    canResume: boolean;
+}>;
+export type EngineeringContextTrace = z.infer<typeof EngineeringContextTraceSchema>;
+export declare function diagnoseEngineeringContext(input: {
+    checkpoint: TaskCheckpointPayload | null;
+    checkpointMissReason: CheckpointMissReason | null;
+    indexedRevision: string | null;
+    missingContextReason: EngineeringContextMissingReason | null;
+}): EngineeringContextTrace;