@neat.is/types 0.9.8-dev.20260829 → 0.9.8

package/dist/index.cjs

@@ -76,6 +76,15 @@ __export(index_exports, {
   HealthResponseSchema: () => HealthResponseSchema,
   HostMismatchDivergenceSchema: () => HostMismatchDivergenceSchema,
   HypotheticalActionSchema: () => HypotheticalActionSchema,
+  IncidentBlastRadiusSchema: () => IncidentBlastRadiusSchema,
+  IncidentCardSchema: () => IncidentCardSchema,
+  IncidentChainHopSchema: () => IncidentChainHopSchema,
+  IncidentDivergenceSchema: () => IncidentDivergenceSchema,
+  IncidentEventPayloadSchema: () => IncidentEventPayloadSchema,
+  IncidentKindSchema: () => IncidentKindSchema,
+  IncidentLocusSchema: () => IncidentLocusSchema,
+  IncidentPolicySchema: () => IncidentPolicySchema,
+  IncidentRootCauseSchema: () => IncidentRootCauseSchema,
   IncidentsResponseSchema: () => IncidentsResponseSchema,
   InfraNodeSchema: () => InfraNodeSchema,
   LatencyMsSchema: () => LatencyMsSchema,
@@ -144,6 +153,7 @@ __export(index_exports, {
   frontierId: () => frontierId,
   graphqlOperationId: () => graphqlOperationId,
   grpcMethodId: () => grpcMethodId,
+  incidentKindOf: () => incidentKindOf,
   inferredEdgeId: () => inferredEdgeId,
   infraId: () => infraId,
   localDatabaseId: () => localDatabaseId,
@@ -950,6 +960,101 @@ var AskResultSchema = import_zod5.z.object({
   provenance: import_zod5.z.array(ProvenanceSchema)
 });
 
+// src/incident-card.ts
+var import_zod6 = require("zod");
+var IncidentKindSchema = import_zod6.z.enum([
+  "exception",
+  "5xx",
+  "4xx-burst",
+  "status-error",
+  "connector"
+]);
+var IncidentChainHopSchema = import_zod6.z.object({
+  node: import_zod6.z.string(),
+  // 'service' | 'file' | 'symbol' | 'table' | 'column' | … — the node's own grain.
+  grain: import_zod6.z.string(),
+  // The edge INTO this hop from the previous one, when cheaply known.
+  edgeType: import_zod6.z.string().optional(),
+  provenance: ProvenanceSchema,
+  carriesSignal: import_zod6.z.boolean().optional()
+});
+var IncidentLocusSchema = import_zod6.z.object({
+  file: import_zod6.z.string(),
+  lineStart: import_zod6.z.number().int().optional(),
+  lineEnd: import_zod6.z.number().int().optional(),
+  symbol: import_zod6.z.string().optional(),
+  service: import_zod6.z.string().optional(),
+  provenance: ProvenanceSchema
+});
+var IncidentRootCauseSchema = import_zod6.z.object({
+  node: import_zod6.z.string(),
+  classification: import_zod6.z.string().optional(),
+  reason: import_zod6.z.string(),
+  confidence: import_zod6.z.number().min(0).max(1),
+  fix: import_zod6.z.string().nullable().optional(),
+  chain: import_zod6.z.array(IncidentChainHopSchema)
+});
+var IncidentBlastRadiusSchema = import_zod6.z.object({
+  totalAffected: import_zod6.z.number().int().nonnegative(),
+  nearest: import_zod6.z.array(
+    import_zod6.z.object({
+      node: import_zod6.z.string(),
+      distance: import_zod6.z.number().int().nonnegative(),
+      provenance: ProvenanceSchema
+    })
+  )
+});
+var IncidentPolicySchema = import_zod6.z.object({
+  policyName: import_zod6.z.string(),
+  severity: import_zod6.z.string(),
+  message: import_zod6.z.string().optional()
+});
+var IncidentDivergenceSchema = import_zod6.z.object({
+  type: import_zod6.z.string(),
+  summary: import_zod6.z.string()
+});
+var IncidentCardSchema = import_zod6.z.object({
+  kind: import_zod6.z.literal("incident"),
+  id: import_zod6.z.string(),
+  // ISO8601 — the incident's own time.
+  at: import_zod6.z.string(),
+  incidentKind: IncidentKindSchema,
+  service: import_zod6.z.string(),
+  affectedNode: import_zod6.z.string(),
+  message: import_zod6.z.string(),
+  exceptionType: import_zod6.z.string().optional(),
+  httpStatusCode: import_zod6.z.number().int().optional(),
+  // Coalesced burst size (ErrorEvent.incidentCount).
+  count: import_zod6.z.number().int().positive().optional(),
+  window: import_zod6.z.object({ first: import_zod6.z.string(), last: import_zod6.z.string() }).optional(),
+  traceId: import_zod6.z.string().optional(),
+  spanId: import_zod6.z.string().optional(),
+  locus: IncidentLocusSchema.nullable(),
+  rootCause: IncidentRootCauseSchema.nullable(),
+  blastRadius: IncidentBlastRadiusSchema.optional(),
+  policies: import_zod6.z.array(IncidentPolicySchema).optional(),
+  divergence: import_zod6.z.array(IncidentDivergenceSchema).optional(),
+  // The rendered one-line sentence — a human/loose-LLM read over the structured
+  // body, never the wire format.
+  headline: import_zod6.z.string()
+});
+var IncidentEventPayloadSchema = import_zod6.z.object({
+  incidentId: import_zod6.z.string(),
+  affectedNode: import_zod6.z.string(),
+  service: import_zod6.z.string(),
+  incidentKind: IncidentKindSchema,
+  at: import_zod6.z.string()
+});
+function incidentKindOf(ev) {
+  const et = ev.errorType;
+  if (et === "grpc-failure") return "status-error";
+  if (et === "http-failure") {
+    return ev.incidentCount && ev.incidentCount > 1 ? "4xx-burst" : "5xx";
+  }
+  if (et) return "connector";
+  return "exception";
+}
+
 // src/identity.ts
 var SERVICE_PREFIX = "service:";
 var DATABASE_PREFIX = "database:";
@@ -1162,11 +1267,11 @@ var PROV_RANK = Object.freeze({
 });
 
 // src/policy.ts
-var import_zod6 = require("zod");
-var PolicySeveritySchema = import_zod6.z.enum(["info", "warning", "error", "critical"]);
-var PolicyActionSchema = import_zod6.z.enum(["log", "alert", "block"]);
-var StructuralRuleSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("structural"),
+var import_zod7 = require("zod");
+var PolicySeveritySchema = import_zod7.z.enum(["info", "warning", "error", "critical"]);
+var PolicyActionSchema = import_zod7.z.enum(["log", "alert", "block"]);
+var StructuralRuleSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("structural"),
   // Node type the rule applies to. Every node of this type must satisfy the
   // edge requirement below.
   fromNodeType: NodeTypeSchema,
@@ -1175,61 +1280,61 @@ var StructuralRuleSchema = import_zod6.z.object({
   // Required target node type at the other end of the edge.
   toNodeType: NodeTypeSchema
 });
-var CompatibilityRuleSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("compatibility"),
+var CompatibilityRuleSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("compatibility"),
   // Optional kind narrowing. When omitted, all four compat shapes
   // (driver-engine, node-engine, package-conflict, deprecated-api) run.
-  kind: import_zod6.z.enum(["driver-engine", "node-engine", "package-conflict", "deprecated-api"]).optional()
+  kind: import_zod7.z.enum(["driver-engine", "node-engine", "package-conflict", "deprecated-api"]).optional()
 });
-var ProvenanceRuleSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("provenance"),
+var ProvenanceRuleSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("provenance"),
   // Edge type the rule applies to.
   edgeType: EdgeTypeSchema,
   // Target node id (e.g. 'service:payments') that incoming edges of edgeType
   // must satisfy. Optional — when omitted, the rule runs against every edge
   // of edgeType regardless of target.
-  targetNodeId: import_zod6.z.string().optional(),
+  targetNodeId: import_zod7.z.string().optional(),
   // Required provenance (single value or one-of). The audit fails if the
   // observed edge's provenance is not in this set.
-  required: import_zod6.z.union([ProvenanceSchema, import_zod6.z.array(ProvenanceSchema).min(1)])
+  required: import_zod7.z.union([ProvenanceSchema, import_zod7.z.array(ProvenanceSchema).min(1)])
 });
-var OwnershipRuleSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("ownership"),
+var OwnershipRuleSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("ownership"),
   // Node type the rule applies to. ServiceNode is the common case; the
   // discriminator stays generic so future node types can opt in.
   nodeType: NodeTypeSchema,
   // Field name on the node attributes that must be non-empty. Defaults to
   // 'owner' if omitted.
-  field: import_zod6.z.string().default("owner")
+  field: import_zod7.z.string().default("owner")
 });
-var BlastRadiusRuleSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("blast-radius"),
+var BlastRadiusRuleSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("blast-radius"),
   // Node type the rule applies to (ServiceNode is the common case).
   nodeType: NodeTypeSchema,
   // Cap on `totalAffected` from getBlastRadius. Inclusive — a node hitting
   // exactly this number passes; > maxAffected fails.
-  maxAffected: import_zod6.z.number().int().positive(),
+  maxAffected: import_zod7.z.number().int().positive(),
   // Depth to evaluate against. Defaults to the contract's blast-radius
   // default (10) when omitted.
-  depth: import_zod6.z.number().int().positive().optional()
+  depth: import_zod7.z.number().int().positive().optional()
 });
-var FieldGuardRuleSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("field-guard"),
+var FieldGuardRuleSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("field-guard"),
   // Node type the rule governs. InfraNode for the Firestore instance.
   nodeType: NodeTypeSchema,
   // Optional narrowing on InfraNode's free-string `kind` sub-type, so the rule
   // applies to `firestore-collection` nodes without governing every InfraNode.
-  nodeKind: import_zod6.z.string().optional(),
+  nodeKind: import_zod7.z.string().optional(),
   // Set A — the named selector the evaluator resolves into the "must be covered"
   // set. 'client-written-columns' reads ColumnAttr whose sdkWrites includes
   // 'client'. A new instance adds a value here plus a resolver branch.
-  subjectSet: import_zod6.z.enum(["client-written-columns"]),
+  subjectSet: import_zod7.z.enum(["client-written-columns"]),
   // Set B — the covering set: the node attribute (a string[]) whose members must
   // include all of set A. 'guardedFields' for Firestore. Absent ⇒ indeterminate
   // ⇒ silent.
-  guardSet: import_zod6.z.string()
+  guardSet: import_zod7.z.string()
 });
-var PolicyRuleSchema = import_zod6.z.discriminatedUnion("type", [
+var PolicyRuleSchema = import_zod7.z.discriminatedUnion("type", [
   StructuralRuleSchema,
   CompatibilityRuleSchema,
   ProvenanceRuleSchema,
@@ -1237,26 +1342,26 @@ var PolicyRuleSchema = import_zod6.z.discriminatedUnion("type", [
   BlastRadiusRuleSchema,
   FieldGuardRuleSchema
 ]);
-var PolicySchema = import_zod6.z.object({
+var PolicySchema = import_zod7.z.object({
   // Unique within the file. Duplicates fail PolicyFileSchema.parse.
-  id: import_zod6.z.string().min(1),
-  name: import_zod6.z.string().min(1),
-  description: import_zod6.z.string().optional(),
+  id: import_zod7.z.string().min(1),
+  name: import_zod7.z.string().min(1),
+  description: import_zod7.z.string().optional(),
   severity: PolicySeveritySchema,
   // When omitted, the engine derives a default from severity per ADR-044
   // (info→log, warning→alert, error→alert, critical→block).
   onViolation: PolicyActionSchema.optional(),
   rule: PolicyRuleSchema
 });
-var PolicyFileSchema = import_zod6.z.object({
-  version: import_zod6.z.literal(1),
-  policies: import_zod6.z.array(PolicySchema)
+var PolicyFileSchema = import_zod7.z.object({
+  version: import_zod7.z.literal(1),
+  policies: import_zod7.z.array(PolicySchema)
 }).superRefine((file, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [i, p] of file.policies.entries()) {
     if (seen.has(p.id)) {
       ctx.addIssue({
-        code: import_zod6.z.ZodIssueCode.custom,
+        code: import_zod7.z.ZodIssueCode.custom,
         path: ["policies", i, "id"],
         message: `duplicate policy id "${p.id}"`
       });
@@ -1264,173 +1369,173 @@ var PolicyFileSchema = import_zod6.z.object({
     seen.add(p.id);
   }
 });
-var HypotheticalActionSchema = import_zod6.z.discriminatedUnion("kind", [
-  import_zod6.z.object({
-    kind: import_zod6.z.literal("promote-frontier"),
+var HypotheticalActionSchema = import_zod7.z.discriminatedUnion("kind", [
+  import_zod7.z.object({
+    kind: import_zod7.z.literal("promote-frontier"),
     // The FrontierNode id that would be promoted.
-    frontierId: import_zod6.z.string().min(1)
+    frontierId: import_zod7.z.string().min(1)
   }),
-  import_zod6.z.object({
-    kind: import_zod6.z.literal("add-edge"),
-    source: import_zod6.z.string().min(1),
-    target: import_zod6.z.string().min(1),
+  import_zod7.z.object({
+    kind: import_zod7.z.literal("add-edge"),
+    source: import_zod7.z.string().min(1),
+    target: import_zod7.z.string().min(1),
     edgeType: EdgeTypeSchema,
     provenance: ProvenanceSchema
   })
 ]);
-var PoliciesCheckBodySchema = import_zod6.z.object({
+var PoliciesCheckBodySchema = import_zod7.z.object({
   hypotheticalAction: HypotheticalActionSchema.optional()
 });
-var CheckPoliciesScopeSchema = import_zod6.z.union([
-  import_zod6.z.enum(["all", "unresolved"]),
-  import_zod6.z.object({ policyId: import_zod6.z.string().min(1) })
+var CheckPoliciesScopeSchema = import_zod7.z.union([
+  import_zod7.z.enum(["all", "unresolved"]),
+  import_zod7.z.object({ policyId: import_zod7.z.string().min(1) })
 ]);
-var ApplicablePolicySchema = import_zod6.z.object({
-  policyId: import_zod6.z.string().min(1),
-  policyName: import_zod6.z.string().min(1),
-  description: import_zod6.z.string().optional(),
+var ApplicablePolicySchema = import_zod7.z.object({
+  policyId: import_zod7.z.string().min(1),
+  policyName: import_zod7.z.string().min(1),
+  description: import_zod7.z.string().optional(),
   severity: PolicySeveritySchema,
   // The action the post-launch kernel gate WOULD take (ADR-093) — resolved
   // from policy.onViolation or the severity default. Shown for awareness only;
   // the soft guardrail never acts on it.
   onViolation: PolicyActionSchema,
-  ruleType: import_zod6.z.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
-  match: import_zod6.z.enum(["subject", "region"]),
+  ruleType: import_zod7.z.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
+  match: import_zod7.z.enum(["subject", "region"]),
   // Human-readable reason the policy applies here — rides into agent context.
-  reason: import_zod6.z.string().min(1)
+  reason: import_zod7.z.string().min(1)
 });
-var ApplicablePoliciesResponseSchema = import_zod6.z.object({
-  node: import_zod6.z.string().min(1),
-  applicable: import_zod6.z.array(ApplicablePolicySchema)
+var ApplicablePoliciesResponseSchema = import_zod7.z.object({
+  node: import_zod7.z.string().min(1),
+  applicable: import_zod7.z.array(ApplicablePolicySchema)
 });
-var PolicyViolationSchema = import_zod6.z.object({
+var PolicyViolationSchema = import_zod7.z.object({
   // ${policy.id}:${violation-context}. The violation-context is shape-
   // specific (e.g. nodeId for structural; edgeId for provenance).
-  id: import_zod6.z.string().min(1),
-  policyId: import_zod6.z.string().min(1),
-  policyName: import_zod6.z.string().min(1),
+  id: import_zod7.z.string().min(1),
+  policyId: import_zod7.z.string().min(1),
+  policyName: import_zod7.z.string().min(1),
   severity: PolicySeveritySchema,
   // Resolved at evaluation time — either the explicit policy.onViolation or
   // the severity-derived default per ADR-044.
   onViolation: PolicyActionSchema,
-  ruleType: import_zod6.z.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
-  subject: import_zod6.z.object({
-    nodeId: import_zod6.z.string().optional(),
-    edgeId: import_zod6.z.string().optional(),
-    path: import_zod6.z.array(import_zod6.z.string()).optional()
+  ruleType: import_zod7.z.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
+  subject: import_zod7.z.object({
+    nodeId: import_zod7.z.string().optional(),
+    edgeId: import_zod7.z.string().optional(),
+    path: import_zod7.z.array(import_zod7.z.string()).optional()
   }).refine(
     (s) => s.nodeId !== void 0 || s.edgeId !== void 0 || s.path !== void 0,
     { message: "subject must carry at least one of nodeId, edgeId, path" }
   ),
-  message: import_zod6.z.string().min(1),
-  observedAt: import_zod6.z.string().datetime()
+  message: import_zod7.z.string().min(1),
+  observedAt: import_zod7.z.string().datetime()
 });
 
 // src/registry.ts
-var import_zod7 = require("zod");
-var RegistryStatusSchema = import_zod7.z.enum(["active", "paused", "broken"]);
-var RegistryEntrySchema = import_zod7.z.object({
+var import_zod8 = require("zod");
+var RegistryStatusSchema = import_zod8.z.enum(["active", "paused", "broken"]);
+var RegistryEntrySchema = import_zod8.z.object({
   // Unique within the registry. Project-scoped operations (`neat watch
   // --project <name>`, `neatd reload <name>`) key on this. Collisions are a
   // hard error at registration time.
-  name: import_zod7.z.string().min(1),
+  name: import_zod8.z.string().min(1),
   // Resolved absolute path on disk. Path normalisation is what keeps two
   // `neat init` calls from different relative paths from creating two entries
   // for the same directory.
-  path: import_zod7.z.string().min(1),
+  path: import_zod8.z.string().min(1),
   // ISO8601, set at first registration.
-  registeredAt: import_zod7.z.string(),
+  registeredAt: import_zod8.z.string(),
   // ISO8601, updated whenever the daemon successfully sees the project.
   // Optional because a freshly-registered project hasn't been seen yet.
-  lastSeenAt: import_zod7.z.string().optional(),
+  lastSeenAt: import_zod8.z.string().optional(),
   // Languages detected at `init` time. Free-form strings keyed off the
   // installer modules — `'javascript'`, `'python'`, …
-  languages: import_zod7.z.array(import_zod7.z.string()),
+  languages: import_zod8.z.array(import_zod8.z.string()),
   status: RegistryStatusSchema
 });
-var RegistryFileSchema = import_zod7.z.object({
-  version: import_zod7.z.literal(1),
-  projects: import_zod7.z.array(RegistryEntrySchema)
+var RegistryFileSchema = import_zod8.z.object({
+  version: import_zod8.z.literal(1),
+  projects: import_zod8.z.array(RegistryEntrySchema)
 });
 var EMPTY_REGISTRY = { version: 1, projects: [] };
 
 // src/divergence.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var commonFields = {
-  source: import_zod8.z.string(),
-  target: import_zod8.z.string(),
-  confidence: import_zod8.z.number().min(0).max(1),
-  reason: import_zod8.z.string(),
-  recommendation: import_zod8.z.string()
+  source: import_zod9.z.string(),
+  target: import_zod9.z.string(),
+  confidence: import_zod9.z.number().min(0).max(1),
+  reason: import_zod9.z.string(),
+  recommendation: import_zod9.z.string()
 };
-var MissingObservedDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("missing-observed"),
+var MissingObservedDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("missing-observed"),
   ...commonFields,
   edgeType: EdgeTypeSchema.optional(),
   extracted: GraphEdgeSchema.optional(),
   // Column locus (ADR-157 §4): the `sql-table` node id and the declared-only column.
-  table: import_zod8.z.string().optional(),
-  column: import_zod8.z.string().optional()
+  table: import_zod9.z.string().optional(),
+  column: import_zod9.z.string().optional()
 });
-var MissingExtractedDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("missing-extracted"),
+var MissingExtractedDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("missing-extracted"),
   ...commonFields,
   edgeType: EdgeTypeSchema.optional(),
   observed: GraphEdgeSchema.optional(),
   // Column locus (ADR-157 §4): the `sql-table` node id and the observed-only column.
-  table: import_zod8.z.string().optional(),
-  column: import_zod8.z.string().optional()
+  table: import_zod9.z.string().optional(),
+  column: import_zod9.z.string().optional()
 });
-var CompatibilityVerdictSchema = import_zod8.z.enum(["incompatible", "deprecated", "unknown"]);
-var VersionMismatchDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("version-mismatch"),
+var CompatibilityVerdictSchema = import_zod9.z.enum(["incompatible", "deprecated", "unknown"]);
+var VersionMismatchDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("version-mismatch"),
   ...commonFields,
-  extractedVersion: import_zod8.z.string(),
-  observedVersion: import_zod8.z.string(),
+  extractedVersion: import_zod9.z.string(),
+  observedVersion: import_zod9.z.string(),
   compatibility: CompatibilityVerdictSchema
 });
-var HostMismatchDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("host-mismatch"),
+var HostMismatchDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("host-mismatch"),
   ...commonFields,
-  extractedHost: import_zod8.z.string(),
-  observedHost: import_zod8.z.string()
-});
-var CompatRuleRefSchema = import_zod8.z.object({
-  kind: import_zod8.z.string(),
-  reason: import_zod8.z.string(),
-  package: import_zod8.z.string().optional(),
-  driver: import_zod8.z.string().optional(),
-  engine: import_zod8.z.string().optional()
-});
-var CompatViolationDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("compat-violation"),
+  extractedHost: import_zod9.z.string(),
+  observedHost: import_zod9.z.string()
+});
+var CompatRuleRefSchema = import_zod9.z.object({
+  kind: import_zod9.z.string(),
+  reason: import_zod9.z.string(),
+  package: import_zod9.z.string().optional(),
+  driver: import_zod9.z.string().optional(),
+  engine: import_zod9.z.string().optional()
+});
+var CompatViolationDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("compat-violation"),
   ...commonFields,
   rule: CompatRuleRefSchema,
   observed: GraphEdgeSchema
 });
-var SymbolMismatchKindSchema = import_zod8.z.enum([
+var SymbolMismatchKindSchema = import_zod9.z.enum([
   "missing-attribute",
   "missing-field",
   "missing-property",
   "missing-column",
   "undefined-method"
 ]);
-var ObservedSymbolMismatchDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("observed-symbol-mismatch"),
+var ObservedSymbolMismatchDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("observed-symbol-mismatch"),
   ...commonFields,
   mismatchKind: SymbolMismatchKindSchema,
-  symbol: import_zod8.z.string().optional(),
-  location: import_zod8.z.string().optional(),
+  symbol: import_zod9.z.string().optional(),
+  location: import_zod9.z.string().optional(),
   provenance: ProvenanceSchema,
   // The OBSERVED incident this fuses — its id and the raw error text — so a
   // consumer can trace the finding back to the recorded failure.
-  incidentId: import_zod8.z.string().optional(),
-  errorMessage: import_zod8.z.string(),
+  incidentId: import_zod9.z.string().optional(),
+  errorMessage: import_zod9.z.string(),
   // How many recorded incidents share this (node, member, mismatch) — the
   // failure has usually fired more than once.
-  incidentCount: import_zod8.z.number().int().positive().optional()
+  incidentCount: import_zod9.z.number().int().positive().optional()
 });
-var ObservedFailureKindSchema = import_zod8.z.enum([
+var ObservedFailureKindSchema = import_zod9.z.enum([
   "error-rate",
   "connection-refused",
   "deadline-exceeded",
@@ -1438,25 +1543,25 @@ var ObservedFailureKindSchema = import_zod8.z.enum([
   "unavailable",
   "server-error"
 ]);
-var ObservedFailingDivergenceSchema = import_zod8.z.object({
-  type: import_zod8.z.literal("observed-failing"),
+var ObservedFailingDivergenceSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("observed-failing"),
   ...commonFields,
   failureKind: ObservedFailureKindSchema,
   provenance: ProvenanceSchema,
   // Edge locus (the observed dependency edge whose calls predominantly fail).
   edgeType: EdgeTypeSchema.optional(),
   observed: GraphEdgeSchema.optional(),
-  spanCount: import_zod8.z.number().int().nonnegative().optional(),
-  errorCount: import_zod8.z.number().int().nonnegative().optional(),
-  errorRate: import_zod8.z.number().min(0).max(1).optional(),
+  spanCount: import_zod9.z.number().int().nonnegative().optional(),
+  errorCount: import_zod9.z.number().int().nonnegative().optional(),
+  errorRate: import_zod9.z.number().min(0).max(1).optional(),
   // Incident locus (the declared external call whose incident shows a failure).
-  location: import_zod8.z.string().optional(),
-  incidentId: import_zod8.z.string().optional(),
-  errorMessage: import_zod8.z.string().optional(),
-  incidentCount: import_zod8.z.number().int().positive().optional(),
-  httpStatusCode: import_zod8.z.number().int().optional()
+  location: import_zod9.z.string().optional(),
+  incidentId: import_zod9.z.string().optional(),
+  errorMessage: import_zod9.z.string().optional(),
+  incidentCount: import_zod9.z.number().int().positive().optional(),
+  httpStatusCode: import_zod9.z.number().int().optional()
 });
-var DivergenceSchema = import_zod8.z.discriminatedUnion("type", [
+var DivergenceSchema = import_zod9.z.discriminatedUnion("type", [
   MissingObservedDivergenceSchema,
   MissingExtractedDivergenceSchema,
   VersionMismatchDivergenceSchema,
@@ -1465,14 +1570,14 @@ var DivergenceSchema = import_zod8.z.discriminatedUnion("type", [
   ObservedSymbolMismatchDivergenceSchema,
   ObservedFailingDivergenceSchema
 ]);
-var DivergenceResultSchema = import_zod8.z.object({
-  divergences: import_zod8.z.array(DivergenceSchema),
-  totalAffected: import_zod8.z.number().int().nonnegative(),
+var DivergenceResultSchema = import_zod9.z.object({
+  divergences: import_zod9.z.array(DivergenceSchema),
+  totalAffected: import_zod9.z.number().int().nonnegative(),
   // ISO8601 timestamp the result was computed at. Each call re-derives from
   // the live graph — there is no persisted divergence history.
-  computedAt: import_zod8.z.string().datetime()
+  computedAt: import_zod9.z.string().datetime()
 });
-var DivergenceTypeSchema = import_zod8.z.enum([
+var DivergenceTypeSchema = import_zod9.z.enum([
   "missing-observed",
   "missing-extracted",
   "version-mismatch",
@@ -1489,6 +1594,10 @@ var MCP_TOOL_NAMES = [
   "get_dependencies",
   "get_observed_dependencies",
   "get_incident_history",
+  // One self-sufficient work order per incident (ADR-221): the incident fused
+  // with its root-cause chain, blast radius, governing policies, and node
+  // divergence, each claim provenance-stamped.
+  "get_incident_card",
   "semantic_search",
   "get_graph_diff",
   "get_recent_stale_edges",
@@ -1510,117 +1619,117 @@ var MCP_TOOL_NAMES = [
 ];
 
 // src/responses.ts
-var import_zod9 = require("zod");
-var listEnvelope = (itemSchema) => import_zod9.z.object({
-  count: import_zod9.z.number().int().nonnegative(),
-  total: import_zod9.z.number().int().nonnegative(),
-  events: import_zod9.z.array(itemSchema)
+var import_zod10 = require("zod");
+var listEnvelope = (itemSchema) => import_zod10.z.object({
+  count: import_zod10.z.number().int().nonnegative(),
+  total: import_zod10.z.number().int().nonnegative(),
+  events: import_zod10.z.array(itemSchema)
 });
 var IncidentsResponseSchema = listEnvelope(ErrorEventSchema);
 var StaleEventsResponseSchema = listEnvelope(StaleEventSchema);
-var LogsResponseSchema = import_zod9.z.object({
-  count: import_zod9.z.number().int().nonnegative(),
-  total: import_zod9.z.number().int().nonnegative(),
-  logs: import_zod9.z.array(LogEntrySchema)
+var LogsResponseSchema = import_zod10.z.object({
+  count: import_zod10.z.number().int().nonnegative(),
+  total: import_zod10.z.number().int().nonnegative(),
+  logs: import_zod10.z.array(LogEntrySchema)
 });
-var PoliciesViolationsResponseSchema = import_zod9.z.object({
-  violations: import_zod9.z.array(PolicyViolationSchema)
+var PoliciesViolationsResponseSchema = import_zod10.z.object({
+  violations: import_zod10.z.array(PolicyViolationSchema)
 });
-var GraphNodeResponseSchema = import_zod9.z.object({
+var GraphNodeResponseSchema = import_zod10.z.object({
   node: GraphNodeSchema
 });
-var GraphEdgesResponseSchema = import_zod9.z.object({
-  inbound: import_zod9.z.array(GraphEdgeSchema),
-  outbound: import_zod9.z.array(GraphEdgeSchema)
+var GraphEdgesResponseSchema = import_zod10.z.object({
+  inbound: import_zod10.z.array(GraphEdgeSchema),
+  outbound: import_zod10.z.array(GraphEdgeSchema)
 });
-var ExtractionCoverageSchema = import_zod9.z.object({
-  skippedFiles: import_zod9.z.number().int().nonnegative(),
-  byProducer: import_zod9.z.record(import_zod9.z.number().int().nonnegative()),
+var ExtractionCoverageSchema = import_zod10.z.object({
+  skippedFiles: import_zod10.z.number().int().nonnegative(),
+  byProducer: import_zod10.z.record(import_zod10.z.number().int().nonnegative()),
   // Up to a bounded sample of the files that failed to parse this pass.
-  files: import_zod9.z.array(import_zod9.z.string()),
-  updatedAt: import_zod9.z.string()
+  files: import_zod10.z.array(import_zod10.z.string()),
+  updatedAt: import_zod10.z.string()
 });
-var HealthResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.boolean(),
-  project: import_zod9.z.string(),
-  uptimeMs: import_zod9.z.number().int().nonnegative(),
+var HealthResponseSchema = import_zod10.z.object({
+  ok: import_zod10.z.boolean(),
+  project: import_zod10.z.string(),
+  uptimeMs: import_zod10.z.number().int().nonnegative(),
   // Present when the most recent extraction pass recorded its coverage (#883).
   coverage: ExtractionCoverageSchema.optional()
 }).passthrough();
-var DaemonHealthResponseSchema = import_zod9.z.object({
-  ok: import_zod9.z.boolean(),
-  uptimeMs: import_zod9.z.number().int().nonnegative(),
-  projects: import_zod9.z.array(
-    import_zod9.z.object({
-      name: import_zod9.z.string(),
-      nodeCount: import_zod9.z.number().int().nonnegative(),
-      edgeCount: import_zod9.z.number().int().nonnegative()
+var DaemonHealthResponseSchema = import_zod10.z.object({
+  ok: import_zod10.z.boolean(),
+  uptimeMs: import_zod10.z.number().int().nonnegative(),
+  projects: import_zod10.z.array(
+    import_zod10.z.object({
+      name: import_zod10.z.string(),
+      nodeCount: import_zod10.z.number().int().nonnegative(),
+      edgeCount: import_zod10.z.number().int().nonnegative()
     }).passthrough()
   )
 }).passthrough();
 var ProjectListEntrySchema = RegistryEntrySchema.extend({
-  hostedHere: import_zod9.z.boolean()
+  hostedHere: import_zod10.z.boolean()
 });
-var ProjectServedBySchema = import_zod9.z.object({
-  path: import_zod9.z.string(),
-  restPort: import_zod9.z.number().int(),
-  live: import_zod9.z.boolean()
+var ProjectServedBySchema = import_zod10.z.object({
+  path: import_zod10.z.string(),
+  restPort: import_zod10.z.number().int(),
+  live: import_zod10.z.boolean()
 });
-var SingleProjectResponseSchema = import_zod9.z.object({
+var SingleProjectResponseSchema = import_zod10.z.object({
   project: ProjectListEntrySchema,
   // Present only when this daemon does not host the project but another daemon
   // on the machine does — names where it actually lives (#884).
   servedBy: ProjectServedBySchema.optional()
 });
-var ConnectorPollStateSchema = import_zod9.z.enum(["idle", "healthy", "error", "stale"]);
-var ConnectorStatusSchema = import_zod9.z.object({
+var ConnectorPollStateSchema = import_zod10.z.enum(["idle", "healthy", "error", "stale"]);
+var ConnectorStatusSchema = import_zod10.z.object({
   state: ConnectorPollStateSchema,
-  lastPollAt: import_zod9.z.string().nullable(),
-  lastOutcome: import_zod9.z.enum(["ok", "error"]).nullable(),
-  lastError: import_zod9.z.string().nullable(),
-  signalsLastPoll: import_zod9.z.number().int().nonnegative()
-});
-var ConnectorStatusEntrySchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  provider: import_zod9.z.string(),
-  credentialRef: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string())]),
+  lastPollAt: import_zod10.z.string().nullable(),
+  lastOutcome: import_zod10.z.enum(["ok", "error"]).nullable(),
+  lastError: import_zod10.z.string().nullable(),
+  signalsLastPoll: import_zod10.z.number().int().nonnegative()
+});
+var ConnectorStatusEntrySchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  provider: import_zod10.z.string(),
+  credentialRef: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.record(import_zod10.z.string(), import_zod10.z.string())]),
   status: ConnectorStatusSchema
 });
-var ConnectorsStatusResponseSchema = import_zod9.z.object({
-  connectors: import_zod9.z.array(ConnectorStatusEntrySchema)
-});
-var SearchMatchSchema = import_zod9.z.object({ score: import_zod9.z.number() }).passthrough();
-var SearchResponseSchema = import_zod9.z.object({
-  query: import_zod9.z.string(),
-  provider: import_zod9.z.string(),
-  matches: import_zod9.z.array(SearchMatchSchema)
-});
-var SerializedGraphSchema = import_zod9.z.object({
-  nodes: import_zod9.z.array(GraphNodeSchema),
-  edges: import_zod9.z.array(GraphEdgeSchema)
-});
-var GraphDiffResultSchema = import_zod9.z.object({
-  base: import_zod9.z.object({ exportedAt: import_zod9.z.string().optional() }),
-  current: import_zod9.z.object({ exportedAt: import_zod9.z.string() }),
-  added: import_zod9.z.object({
-    nodes: import_zod9.z.array(GraphNodeSchema),
-    edges: import_zod9.z.array(GraphEdgeSchema)
+var ConnectorsStatusResponseSchema = import_zod10.z.object({
+  connectors: import_zod10.z.array(ConnectorStatusEntrySchema)
+});
+var SearchMatchSchema = import_zod10.z.object({ score: import_zod10.z.number() }).passthrough();
+var SearchResponseSchema = import_zod10.z.object({
+  query: import_zod10.z.string(),
+  provider: import_zod10.z.string(),
+  matches: import_zod10.z.array(SearchMatchSchema)
+});
+var SerializedGraphSchema = import_zod10.z.object({
+  nodes: import_zod10.z.array(GraphNodeSchema),
+  edges: import_zod10.z.array(GraphEdgeSchema)
+});
+var GraphDiffResultSchema = import_zod10.z.object({
+  base: import_zod10.z.object({ exportedAt: import_zod10.z.string().optional() }),
+  current: import_zod10.z.object({ exportedAt: import_zod10.z.string() }),
+  added: import_zod10.z.object({
+    nodes: import_zod10.z.array(GraphNodeSchema),
+    edges: import_zod10.z.array(GraphEdgeSchema)
   }),
-  removed: import_zod9.z.object({
-    nodes: import_zod9.z.array(GraphNodeSchema),
-    edges: import_zod9.z.array(GraphEdgeSchema)
+  removed: import_zod10.z.object({
+    nodes: import_zod10.z.array(GraphNodeSchema),
+    edges: import_zod10.z.array(GraphEdgeSchema)
   }),
-  changed: import_zod9.z.object({
-    nodes: import_zod9.z.array(
-      import_zod9.z.object({
-        id: import_zod9.z.string(),
+  changed: import_zod10.z.object({
+    nodes: import_zod10.z.array(
+      import_zod10.z.object({
+        id: import_zod10.z.string(),
         before: GraphNodeSchema,
         after: GraphNodeSchema
       })
     ),
-    edges: import_zod9.z.array(
-      import_zod9.z.object({
-        id: import_zod9.z.string(),
+    edges: import_zod10.z.array(
+      import_zod10.z.object({
+        id: import_zod10.z.string(),
         before: GraphEdgeSchema,
         after: GraphEdgeSchema
       })
@@ -1742,6 +1851,15 @@ function passesExtractedFloor(confidence) {
   HealthResponseSchema,
   HostMismatchDivergenceSchema,
   HypotheticalActionSchema,
+  IncidentBlastRadiusSchema,
+  IncidentCardSchema,
+  IncidentChainHopSchema,
+  IncidentDivergenceSchema,
+  IncidentEventPayloadSchema,
+  IncidentKindSchema,
+  IncidentLocusSchema,
+  IncidentPolicySchema,
+  IncidentRootCauseSchema,
   IncidentsResponseSchema,
   InfraNodeSchema,
   LatencyMsSchema,
@@ -1810,6 +1928,7 @@ function passesExtractedFloor(confidence) {
   frontierId,
   graphqlOperationId,
   grpcMethodId,
+  incidentKindOf,
   inferredEdgeId,
   infraId,
   localDatabaseId,