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

package/dist/index.js

@@ -778,6 +778,101 @@ var AskResultSchema = z5.object({
   provenance: z5.array(ProvenanceSchema)
 });
 
+// src/incident-card.ts
+import { z as z6 } from "zod";
+var IncidentKindSchema = z6.enum([
+  "exception",
+  "5xx",
+  "4xx-burst",
+  "status-error",
+  "connector"
+]);
+var IncidentChainHopSchema = z6.object({
+  node: z6.string(),
+  // 'service' | 'file' | 'symbol' | 'table' | 'column' | … — the node's own grain.
+  grain: z6.string(),
+  // The edge INTO this hop from the previous one, when cheaply known.
+  edgeType: z6.string().optional(),
+  provenance: ProvenanceSchema,
+  carriesSignal: z6.boolean().optional()
+});
+var IncidentLocusSchema = z6.object({
+  file: z6.string(),
+  lineStart: z6.number().int().optional(),
+  lineEnd: z6.number().int().optional(),
+  symbol: z6.string().optional(),
+  service: z6.string().optional(),
+  provenance: ProvenanceSchema
+});
+var IncidentRootCauseSchema = z6.object({
+  node: z6.string(),
+  classification: z6.string().optional(),
+  reason: z6.string(),
+  confidence: z6.number().min(0).max(1),
+  fix: z6.string().nullable().optional(),
+  chain: z6.array(IncidentChainHopSchema)
+});
+var IncidentBlastRadiusSchema = z6.object({
+  totalAffected: z6.number().int().nonnegative(),
+  nearest: z6.array(
+    z6.object({
+      node: z6.string(),
+      distance: z6.number().int().nonnegative(),
+      provenance: ProvenanceSchema
+    })
+  )
+});
+var IncidentPolicySchema = z6.object({
+  policyName: z6.string(),
+  severity: z6.string(),
+  message: z6.string().optional()
+});
+var IncidentDivergenceSchema = z6.object({
+  type: z6.string(),
+  summary: z6.string()
+});
+var IncidentCardSchema = z6.object({
+  kind: z6.literal("incident"),
+  id: z6.string(),
+  // ISO8601 — the incident's own time.
+  at: z6.string(),
+  incidentKind: IncidentKindSchema,
+  service: z6.string(),
+  affectedNode: z6.string(),
+  message: z6.string(),
+  exceptionType: z6.string().optional(),
+  httpStatusCode: z6.number().int().optional(),
+  // Coalesced burst size (ErrorEvent.incidentCount).
+  count: z6.number().int().positive().optional(),
+  window: z6.object({ first: z6.string(), last: z6.string() }).optional(),
+  traceId: z6.string().optional(),
+  spanId: z6.string().optional(),
+  locus: IncidentLocusSchema.nullable(),
+  rootCause: IncidentRootCauseSchema.nullable(),
+  blastRadius: IncidentBlastRadiusSchema.optional(),
+  policies: z6.array(IncidentPolicySchema).optional(),
+  divergence: z6.array(IncidentDivergenceSchema).optional(),
+  // The rendered one-line sentence — a human/loose-LLM read over the structured
+  // body, never the wire format.
+  headline: z6.string()
+});
+var IncidentEventPayloadSchema = z6.object({
+  incidentId: z6.string(),
+  affectedNode: z6.string(),
+  service: z6.string(),
+  incidentKind: IncidentKindSchema,
+  at: z6.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:";
@@ -990,11 +1085,11 @@ var PROV_RANK = Object.freeze({
 });
 
 // src/policy.ts
-import { z as z6 } from "zod";
-var PolicySeveritySchema = z6.enum(["info", "warning", "error", "critical"]);
-var PolicyActionSchema = z6.enum(["log", "alert", "block"]);
-var StructuralRuleSchema = z6.object({
-  type: z6.literal("structural"),
+import { z as z7 } from "zod";
+var PolicySeveritySchema = z7.enum(["info", "warning", "error", "critical"]);
+var PolicyActionSchema = z7.enum(["log", "alert", "block"]);
+var StructuralRuleSchema = z7.object({
+  type: z7.literal("structural"),
   // Node type the rule applies to. Every node of this type must satisfy the
   // edge requirement below.
   fromNodeType: NodeTypeSchema,
@@ -1003,61 +1098,61 @@ var StructuralRuleSchema = z6.object({
   // Required target node type at the other end of the edge.
   toNodeType: NodeTypeSchema
 });
-var CompatibilityRuleSchema = z6.object({
-  type: z6.literal("compatibility"),
+var CompatibilityRuleSchema = z7.object({
+  type: z7.literal("compatibility"),
   // Optional kind narrowing. When omitted, all four compat shapes
   // (driver-engine, node-engine, package-conflict, deprecated-api) run.
-  kind: z6.enum(["driver-engine", "node-engine", "package-conflict", "deprecated-api"]).optional()
+  kind: z7.enum(["driver-engine", "node-engine", "package-conflict", "deprecated-api"]).optional()
 });
-var ProvenanceRuleSchema = z6.object({
-  type: z6.literal("provenance"),
+var ProvenanceRuleSchema = z7.object({
+  type: z7.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: z6.string().optional(),
+  targetNodeId: z7.string().optional(),
   // Required provenance (single value or one-of). The audit fails if the
   // observed edge's provenance is not in this set.
-  required: z6.union([ProvenanceSchema, z6.array(ProvenanceSchema).min(1)])
+  required: z7.union([ProvenanceSchema, z7.array(ProvenanceSchema).min(1)])
 });
-var OwnershipRuleSchema = z6.object({
-  type: z6.literal("ownership"),
+var OwnershipRuleSchema = z7.object({
+  type: z7.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: z6.string().default("owner")
+  field: z7.string().default("owner")
 });
-var BlastRadiusRuleSchema = z6.object({
-  type: z6.literal("blast-radius"),
+var BlastRadiusRuleSchema = z7.object({
+  type: z7.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: z6.number().int().positive(),
+  maxAffected: z7.number().int().positive(),
   // Depth to evaluate against. Defaults to the contract's blast-radius
   // default (10) when omitted.
-  depth: z6.number().int().positive().optional()
+  depth: z7.number().int().positive().optional()
 });
-var FieldGuardRuleSchema = z6.object({
-  type: z6.literal("field-guard"),
+var FieldGuardRuleSchema = z7.object({
+  type: z7.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: z6.string().optional(),
+  nodeKind: z7.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: z6.enum(["client-written-columns"]),
+  subjectSet: z7.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: z6.string()
+  guardSet: z7.string()
 });
-var PolicyRuleSchema = z6.discriminatedUnion("type", [
+var PolicyRuleSchema = z7.discriminatedUnion("type", [
   StructuralRuleSchema,
   CompatibilityRuleSchema,
   ProvenanceRuleSchema,
@@ -1065,26 +1160,26 @@ var PolicyRuleSchema = z6.discriminatedUnion("type", [
   BlastRadiusRuleSchema,
   FieldGuardRuleSchema
 ]);
-var PolicySchema = z6.object({
+var PolicySchema = z7.object({
   // Unique within the file. Duplicates fail PolicyFileSchema.parse.
-  id: z6.string().min(1),
-  name: z6.string().min(1),
-  description: z6.string().optional(),
+  id: z7.string().min(1),
+  name: z7.string().min(1),
+  description: z7.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 = z6.object({
-  version: z6.literal(1),
-  policies: z6.array(PolicySchema)
+var PolicyFileSchema = z7.object({
+  version: z7.literal(1),
+  policies: z7.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: z6.ZodIssueCode.custom,
+        code: z7.ZodIssueCode.custom,
         path: ["policies", i, "id"],
         message: `duplicate policy id "${p.id}"`
       });
@@ -1092,173 +1187,173 @@ var PolicyFileSchema = z6.object({
     seen.add(p.id);
   }
 });
-var HypotheticalActionSchema = z6.discriminatedUnion("kind", [
-  z6.object({
-    kind: z6.literal("promote-frontier"),
+var HypotheticalActionSchema = z7.discriminatedUnion("kind", [
+  z7.object({
+    kind: z7.literal("promote-frontier"),
     // The FrontierNode id that would be promoted.
-    frontierId: z6.string().min(1)
+    frontierId: z7.string().min(1)
   }),
-  z6.object({
-    kind: z6.literal("add-edge"),
-    source: z6.string().min(1),
-    target: z6.string().min(1),
+  z7.object({
+    kind: z7.literal("add-edge"),
+    source: z7.string().min(1),
+    target: z7.string().min(1),
     edgeType: EdgeTypeSchema,
     provenance: ProvenanceSchema
   })
 ]);
-var PoliciesCheckBodySchema = z6.object({
+var PoliciesCheckBodySchema = z7.object({
   hypotheticalAction: HypotheticalActionSchema.optional()
 });
-var CheckPoliciesScopeSchema = z6.union([
-  z6.enum(["all", "unresolved"]),
-  z6.object({ policyId: z6.string().min(1) })
+var CheckPoliciesScopeSchema = z7.union([
+  z7.enum(["all", "unresolved"]),
+  z7.object({ policyId: z7.string().min(1) })
 ]);
-var ApplicablePolicySchema = z6.object({
-  policyId: z6.string().min(1),
-  policyName: z6.string().min(1),
-  description: z6.string().optional(),
+var ApplicablePolicySchema = z7.object({
+  policyId: z7.string().min(1),
+  policyName: z7.string().min(1),
+  description: z7.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: z6.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
-  match: z6.enum(["subject", "region"]),
+  ruleType: z7.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
+  match: z7.enum(["subject", "region"]),
   // Human-readable reason the policy applies here — rides into agent context.
-  reason: z6.string().min(1)
+  reason: z7.string().min(1)
 });
-var ApplicablePoliciesResponseSchema = z6.object({
-  node: z6.string().min(1),
-  applicable: z6.array(ApplicablePolicySchema)
+var ApplicablePoliciesResponseSchema = z7.object({
+  node: z7.string().min(1),
+  applicable: z7.array(ApplicablePolicySchema)
 });
-var PolicyViolationSchema = z6.object({
+var PolicyViolationSchema = z7.object({
   // ${policy.id}:${violation-context}. The violation-context is shape-
   // specific (e.g. nodeId for structural; edgeId for provenance).
-  id: z6.string().min(1),
-  policyId: z6.string().min(1),
-  policyName: z6.string().min(1),
+  id: z7.string().min(1),
+  policyId: z7.string().min(1),
+  policyName: z7.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: z6.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
-  subject: z6.object({
-    nodeId: z6.string().optional(),
-    edgeId: z6.string().optional(),
-    path: z6.array(z6.string()).optional()
+  ruleType: z7.enum(["structural", "compatibility", "provenance", "ownership", "blast-radius", "field-guard"]),
+  subject: z7.object({
+    nodeId: z7.string().optional(),
+    edgeId: z7.string().optional(),
+    path: z7.array(z7.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: z6.string().min(1),
-  observedAt: z6.string().datetime()
+  message: z7.string().min(1),
+  observedAt: z7.string().datetime()
 });
 
 // src/registry.ts
-import { z as z7 } from "zod";
-var RegistryStatusSchema = z7.enum(["active", "paused", "broken"]);
-var RegistryEntrySchema = z7.object({
+import { z as z8 } from "zod";
+var RegistryStatusSchema = z8.enum(["active", "paused", "broken"]);
+var RegistryEntrySchema = z8.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: z7.string().min(1),
+  name: z8.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: z7.string().min(1),
+  path: z8.string().min(1),
   // ISO8601, set at first registration.
-  registeredAt: z7.string(),
+  registeredAt: z8.string(),
   // ISO8601, updated whenever the daemon successfully sees the project.
   // Optional because a freshly-registered project hasn't been seen yet.
-  lastSeenAt: z7.string().optional(),
+  lastSeenAt: z8.string().optional(),
   // Languages detected at `init` time. Free-form strings keyed off the
   // installer modules — `'javascript'`, `'python'`, …
-  languages: z7.array(z7.string()),
+  languages: z8.array(z8.string()),
   status: RegistryStatusSchema
 });
-var RegistryFileSchema = z7.object({
-  version: z7.literal(1),
-  projects: z7.array(RegistryEntrySchema)
+var RegistryFileSchema = z8.object({
+  version: z8.literal(1),
+  projects: z8.array(RegistryEntrySchema)
 });
 var EMPTY_REGISTRY = { version: 1, projects: [] };
 
 // src/divergence.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var commonFields = {
-  source: z8.string(),
-  target: z8.string(),
-  confidence: z8.number().min(0).max(1),
-  reason: z8.string(),
-  recommendation: z8.string()
+  source: z9.string(),
+  target: z9.string(),
+  confidence: z9.number().min(0).max(1),
+  reason: z9.string(),
+  recommendation: z9.string()
 };
-var MissingObservedDivergenceSchema = z8.object({
-  type: z8.literal("missing-observed"),
+var MissingObservedDivergenceSchema = z9.object({
+  type: z9.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: z8.string().optional(),
-  column: z8.string().optional()
+  table: z9.string().optional(),
+  column: z9.string().optional()
 });
-var MissingExtractedDivergenceSchema = z8.object({
-  type: z8.literal("missing-extracted"),
+var MissingExtractedDivergenceSchema = z9.object({
+  type: z9.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: z8.string().optional(),
-  column: z8.string().optional()
+  table: z9.string().optional(),
+  column: z9.string().optional()
 });
-var CompatibilityVerdictSchema = z8.enum(["incompatible", "deprecated", "unknown"]);
-var VersionMismatchDivergenceSchema = z8.object({
-  type: z8.literal("version-mismatch"),
+var CompatibilityVerdictSchema = z9.enum(["incompatible", "deprecated", "unknown"]);
+var VersionMismatchDivergenceSchema = z9.object({
+  type: z9.literal("version-mismatch"),
   ...commonFields,
-  extractedVersion: z8.string(),
-  observedVersion: z8.string(),
+  extractedVersion: z9.string(),
+  observedVersion: z9.string(),
   compatibility: CompatibilityVerdictSchema
 });
-var HostMismatchDivergenceSchema = z8.object({
-  type: z8.literal("host-mismatch"),
+var HostMismatchDivergenceSchema = z9.object({
+  type: z9.literal("host-mismatch"),
   ...commonFields,
-  extractedHost: z8.string(),
-  observedHost: z8.string()
-});
-var CompatRuleRefSchema = z8.object({
-  kind: z8.string(),
-  reason: z8.string(),
-  package: z8.string().optional(),
-  driver: z8.string().optional(),
-  engine: z8.string().optional()
-});
-var CompatViolationDivergenceSchema = z8.object({
-  type: z8.literal("compat-violation"),
+  extractedHost: z9.string(),
+  observedHost: z9.string()
+});
+var CompatRuleRefSchema = z9.object({
+  kind: z9.string(),
+  reason: z9.string(),
+  package: z9.string().optional(),
+  driver: z9.string().optional(),
+  engine: z9.string().optional()
+});
+var CompatViolationDivergenceSchema = z9.object({
+  type: z9.literal("compat-violation"),
   ...commonFields,
   rule: CompatRuleRefSchema,
   observed: GraphEdgeSchema
 });
-var SymbolMismatchKindSchema = z8.enum([
+var SymbolMismatchKindSchema = z9.enum([
   "missing-attribute",
   "missing-field",
   "missing-property",
   "missing-column",
   "undefined-method"
 ]);
-var ObservedSymbolMismatchDivergenceSchema = z8.object({
-  type: z8.literal("observed-symbol-mismatch"),
+var ObservedSymbolMismatchDivergenceSchema = z9.object({
+  type: z9.literal("observed-symbol-mismatch"),
   ...commonFields,
   mismatchKind: SymbolMismatchKindSchema,
-  symbol: z8.string().optional(),
-  location: z8.string().optional(),
+  symbol: z9.string().optional(),
+  location: z9.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: z8.string().optional(),
-  errorMessage: z8.string(),
+  incidentId: z9.string().optional(),
+  errorMessage: z9.string(),
   // How many recorded incidents share this (node, member, mismatch) — the
   // failure has usually fired more than once.
-  incidentCount: z8.number().int().positive().optional()
+  incidentCount: z9.number().int().positive().optional()
 });
-var ObservedFailureKindSchema = z8.enum([
+var ObservedFailureKindSchema = z9.enum([
   "error-rate",
   "connection-refused",
   "deadline-exceeded",
@@ -1266,25 +1361,25 @@ var ObservedFailureKindSchema = z8.enum([
   "unavailable",
   "server-error"
 ]);
-var ObservedFailingDivergenceSchema = z8.object({
-  type: z8.literal("observed-failing"),
+var ObservedFailingDivergenceSchema = z9.object({
+  type: z9.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: z8.number().int().nonnegative().optional(),
-  errorCount: z8.number().int().nonnegative().optional(),
-  errorRate: z8.number().min(0).max(1).optional(),
+  spanCount: z9.number().int().nonnegative().optional(),
+  errorCount: z9.number().int().nonnegative().optional(),
+  errorRate: z9.number().min(0).max(1).optional(),
   // Incident locus (the declared external call whose incident shows a failure).
-  location: z8.string().optional(),
-  incidentId: z8.string().optional(),
-  errorMessage: z8.string().optional(),
-  incidentCount: z8.number().int().positive().optional(),
-  httpStatusCode: z8.number().int().optional()
+  location: z9.string().optional(),
+  incidentId: z9.string().optional(),
+  errorMessage: z9.string().optional(),
+  incidentCount: z9.number().int().positive().optional(),
+  httpStatusCode: z9.number().int().optional()
 });
-var DivergenceSchema = z8.discriminatedUnion("type", [
+var DivergenceSchema = z9.discriminatedUnion("type", [
   MissingObservedDivergenceSchema,
   MissingExtractedDivergenceSchema,
   VersionMismatchDivergenceSchema,
@@ -1293,14 +1388,14 @@ var DivergenceSchema = z8.discriminatedUnion("type", [
   ObservedSymbolMismatchDivergenceSchema,
   ObservedFailingDivergenceSchema
 ]);
-var DivergenceResultSchema = z8.object({
-  divergences: z8.array(DivergenceSchema),
-  totalAffected: z8.number().int().nonnegative(),
+var DivergenceResultSchema = z9.object({
+  divergences: z9.array(DivergenceSchema),
+  totalAffected: z9.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: z8.string().datetime()
+  computedAt: z9.string().datetime()
 });
-var DivergenceTypeSchema = z8.enum([
+var DivergenceTypeSchema = z9.enum([
   "missing-observed",
   "missing-extracted",
   "version-mismatch",
@@ -1317,6 +1412,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",
@@ -1338,117 +1437,117 @@ var MCP_TOOL_NAMES = [
 ];
 
 // src/responses.ts
-import { z as z9 } from "zod";
-var listEnvelope = (itemSchema) => z9.object({
-  count: z9.number().int().nonnegative(),
-  total: z9.number().int().nonnegative(),
-  events: z9.array(itemSchema)
+import { z as z10 } from "zod";
+var listEnvelope = (itemSchema) => z10.object({
+  count: z10.number().int().nonnegative(),
+  total: z10.number().int().nonnegative(),
+  events: z10.array(itemSchema)
 });
 var IncidentsResponseSchema = listEnvelope(ErrorEventSchema);
 var StaleEventsResponseSchema = listEnvelope(StaleEventSchema);
-var LogsResponseSchema = z9.object({
-  count: z9.number().int().nonnegative(),
-  total: z9.number().int().nonnegative(),
-  logs: z9.array(LogEntrySchema)
+var LogsResponseSchema = z10.object({
+  count: z10.number().int().nonnegative(),
+  total: z10.number().int().nonnegative(),
+  logs: z10.array(LogEntrySchema)
 });
-var PoliciesViolationsResponseSchema = z9.object({
-  violations: z9.array(PolicyViolationSchema)
+var PoliciesViolationsResponseSchema = z10.object({
+  violations: z10.array(PolicyViolationSchema)
 });
-var GraphNodeResponseSchema = z9.object({
+var GraphNodeResponseSchema = z10.object({
   node: GraphNodeSchema
 });
-var GraphEdgesResponseSchema = z9.object({
-  inbound: z9.array(GraphEdgeSchema),
-  outbound: z9.array(GraphEdgeSchema)
+var GraphEdgesResponseSchema = z10.object({
+  inbound: z10.array(GraphEdgeSchema),
+  outbound: z10.array(GraphEdgeSchema)
 });
-var ExtractionCoverageSchema = z9.object({
-  skippedFiles: z9.number().int().nonnegative(),
-  byProducer: z9.record(z9.number().int().nonnegative()),
+var ExtractionCoverageSchema = z10.object({
+  skippedFiles: z10.number().int().nonnegative(),
+  byProducer: z10.record(z10.number().int().nonnegative()),
   // Up to a bounded sample of the files that failed to parse this pass.
-  files: z9.array(z9.string()),
-  updatedAt: z9.string()
+  files: z10.array(z10.string()),
+  updatedAt: z10.string()
 });
-var HealthResponseSchema = z9.object({
-  ok: z9.boolean(),
-  project: z9.string(),
-  uptimeMs: z9.number().int().nonnegative(),
+var HealthResponseSchema = z10.object({
+  ok: z10.boolean(),
+  project: z10.string(),
+  uptimeMs: z10.number().int().nonnegative(),
   // Present when the most recent extraction pass recorded its coverage (#883).
   coverage: ExtractionCoverageSchema.optional()
 }).passthrough();
-var DaemonHealthResponseSchema = z9.object({
-  ok: z9.boolean(),
-  uptimeMs: z9.number().int().nonnegative(),
-  projects: z9.array(
-    z9.object({
-      name: z9.string(),
-      nodeCount: z9.number().int().nonnegative(),
-      edgeCount: z9.number().int().nonnegative()
+var DaemonHealthResponseSchema = z10.object({
+  ok: z10.boolean(),
+  uptimeMs: z10.number().int().nonnegative(),
+  projects: z10.array(
+    z10.object({
+      name: z10.string(),
+      nodeCount: z10.number().int().nonnegative(),
+      edgeCount: z10.number().int().nonnegative()
     }).passthrough()
   )
 }).passthrough();
 var ProjectListEntrySchema = RegistryEntrySchema.extend({
-  hostedHere: z9.boolean()
+  hostedHere: z10.boolean()
 });
-var ProjectServedBySchema = z9.object({
-  path: z9.string(),
-  restPort: z9.number().int(),
-  live: z9.boolean()
+var ProjectServedBySchema = z10.object({
+  path: z10.string(),
+  restPort: z10.number().int(),
+  live: z10.boolean()
 });
-var SingleProjectResponseSchema = z9.object({
+var SingleProjectResponseSchema = z10.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 = z9.enum(["idle", "healthy", "error", "stale"]);
-var ConnectorStatusSchema = z9.object({
+var ConnectorPollStateSchema = z10.enum(["idle", "healthy", "error", "stale"]);
+var ConnectorStatusSchema = z10.object({
   state: ConnectorPollStateSchema,
-  lastPollAt: z9.string().nullable(),
-  lastOutcome: z9.enum(["ok", "error"]).nullable(),
-  lastError: z9.string().nullable(),
-  signalsLastPoll: z9.number().int().nonnegative()
-});
-var ConnectorStatusEntrySchema = z9.object({
-  id: z9.string(),
-  provider: z9.string(),
-  credentialRef: z9.union([z9.string(), z9.record(z9.string(), z9.string())]),
+  lastPollAt: z10.string().nullable(),
+  lastOutcome: z10.enum(["ok", "error"]).nullable(),
+  lastError: z10.string().nullable(),
+  signalsLastPoll: z10.number().int().nonnegative()
+});
+var ConnectorStatusEntrySchema = z10.object({
+  id: z10.string(),
+  provider: z10.string(),
+  credentialRef: z10.union([z10.string(), z10.record(z10.string(), z10.string())]),
   status: ConnectorStatusSchema
 });
-var ConnectorsStatusResponseSchema = z9.object({
-  connectors: z9.array(ConnectorStatusEntrySchema)
-});
-var SearchMatchSchema = z9.object({ score: z9.number() }).passthrough();
-var SearchResponseSchema = z9.object({
-  query: z9.string(),
-  provider: z9.string(),
-  matches: z9.array(SearchMatchSchema)
-});
-var SerializedGraphSchema = z9.object({
-  nodes: z9.array(GraphNodeSchema),
-  edges: z9.array(GraphEdgeSchema)
-});
-var GraphDiffResultSchema = z9.object({
-  base: z9.object({ exportedAt: z9.string().optional() }),
-  current: z9.object({ exportedAt: z9.string() }),
-  added: z9.object({
-    nodes: z9.array(GraphNodeSchema),
-    edges: z9.array(GraphEdgeSchema)
+var ConnectorsStatusResponseSchema = z10.object({
+  connectors: z10.array(ConnectorStatusEntrySchema)
+});
+var SearchMatchSchema = z10.object({ score: z10.number() }).passthrough();
+var SearchResponseSchema = z10.object({
+  query: z10.string(),
+  provider: z10.string(),
+  matches: z10.array(SearchMatchSchema)
+});
+var SerializedGraphSchema = z10.object({
+  nodes: z10.array(GraphNodeSchema),
+  edges: z10.array(GraphEdgeSchema)
+});
+var GraphDiffResultSchema = z10.object({
+  base: z10.object({ exportedAt: z10.string().optional() }),
+  current: z10.object({ exportedAt: z10.string() }),
+  added: z10.object({
+    nodes: z10.array(GraphNodeSchema),
+    edges: z10.array(GraphEdgeSchema)
   }),
-  removed: z9.object({
-    nodes: z9.array(GraphNodeSchema),
-    edges: z9.array(GraphEdgeSchema)
+  removed: z10.object({
+    nodes: z10.array(GraphNodeSchema),
+    edges: z10.array(GraphEdgeSchema)
   }),
-  changed: z9.object({
-    nodes: z9.array(
-      z9.object({
-        id: z9.string(),
+  changed: z10.object({
+    nodes: z10.array(
+      z10.object({
+        id: z10.string(),
         before: GraphNodeSchema,
         after: GraphNodeSchema
       })
     ),
-    edges: z9.array(
-      z9.object({
-        id: z9.string(),
+    edges: z10.array(
+      z10.object({
+        id: z10.string(),
         before: GraphEdgeSchema,
         after: GraphEdgeSchema
       })
@@ -1569,6 +1668,15 @@ export {
   HealthResponseSchema,
   HostMismatchDivergenceSchema,
   HypotheticalActionSchema,
+  IncidentBlastRadiusSchema,
+  IncidentCardSchema,
+  IncidentChainHopSchema,
+  IncidentDivergenceSchema,
+  IncidentEventPayloadSchema,
+  IncidentKindSchema,
+  IncidentLocusSchema,
+  IncidentPolicySchema,
+  IncidentRootCauseSchema,
   IncidentsResponseSchema,
   InfraNodeSchema,
   LatencyMsSchema,
@@ -1637,6 +1745,7 @@ export {
   frontierId,
   graphqlOperationId,
   grpcMethodId,
+  incidentKindOf,
   inferredEdgeId,
   infraId,
   localDatabaseId,