pi-mega-compact 0.20.2 → 0.20.4

package/src/vector-cortex/prompt-dag/_acceptance-planner.ts

@@ -0,0 +1,188 @@
+/**
+ * prompt-dag/_acceptance-planner.ts — declarative candidate-set materialization
+ * + scenario driver for VC5A planner acceptance rows.
+ *
+ * Turns named candidate-set scenarios into real `PlanCandidate[]` values and
+ * drives them through the REAL portfolio planner (planPortfolio). The
+ * `mandatoryTokenEstimate` is the VC4C content-only figure = sum of mandatory
+ * content tokens (zero-framing fixtures pin this exactly).
+ */
+import assert from "node:assert/strict";
+import {
+  planPortfolio,
+  planManifestDigest,
+  validatePlanManifest,
+} from "../planner/portfolio.js";
+import { DEFAULT_FRAMING } from "../planner/types.js";
+import type { FramingProfile, PlanCandidate } from "../planner/types.js";
+import type { PlnFixture } from "./_acceptance-fixture.js";
+import { shuffle } from "./_acceptance-shuffle.js";
+
+export function materializeCandidates(name: string): PlanCandidate[] {
+  const sets: Record<string, PlanCandidate[]> = {
+    // m1=10, m2=20 mandatory → 30 content tokens (zero-framing fixtures pin this).
+    "mandatory-only": [
+      { nodeId: "m1", tokenEstimate: 10, utility: 100, sourceSeq: 1n, mandatory: true },
+      { nodeId: "m2", tokenEstimate: 20, utility: 200, sourceSeq: 2n, mandatory: true },
+    ],
+    // Two mandatory nodes totalling 101 content tokens → over budget at 100.
+    "mandatory-101": [
+      { nodeId: "m1", tokenEstimate: 50, utility: 100, sourceSeq: 1n, mandatory: true },
+      { nodeId: "m2", tokenEstimate: 51, utility: 200, sourceSeq: 2n, mandatory: true },
+    ],
+    // Optional candidates: hi=10t/20u (ratio 2.0), mid=10t/10u (ratio 1.0), lo=10t/5u.
+    ratio: [
+      { nodeId: "hi", tokenEstimate: 10, utility: 20, sourceSeq: 1n, mandatory: false },
+      { nodeId: "mid", tokenEstimate: 10, utility: 10, sourceSeq: 2n, mandatory: false },
+      { nodeId: "lo", tokenEstimate: 10, utility: 5, sourceSeq: 3n, mandatory: false },
+    ],
+    // Equal ratios (1.0) → source seq tie-break (early=seq1 wins).
+    "tie-seq": [
+      { nodeId: "early", tokenEstimate: 10, utility: 10, sourceSeq: 1n, mandatory: false },
+      { nodeId: "late", tokenEstimate: 10, utility: 10, sourceSeq: 2n, mandatory: false },
+    ],
+    // Equal ratios AND equal source seq → lower ID bytes wins.
+    "tie-id": [
+      { nodeId: "bbb", tokenEstimate: 10, utility: 10, sourceSeq: 1n, mandatory: false },
+      { nodeId: "aaa", tokenEstimate: 10, utility: 10, sourceSeq: 1n, mandatory: false },
+    ],
+    // One indivisible optional node of 10t/10u: 0/1 means it is taken whole.
+    indivisible: [
+      { nodeId: "one", tokenEstimate: 10, utility: 10, sourceSeq: 1n, mandatory: false },
+    ],
+    // A zero-utility optional node must be omitted.
+    "zero-utility": [
+      { nodeId: "zero", tokenEstimate: 5, utility: 0, sourceSeq: 1n, mandatory: false },
+    ],
+    // An optional node incompatible with a mandatory node is omitted (the planner
+    // enforces `incompatiblePairs`; here `bad` is mutually exclusive with `m1`).
+    incompatible: [
+      { nodeId: "m1", tokenEstimate: 10, utility: 100, sourceSeq: 1n, mandatory: true },
+      { nodeId: "bad", tokenEstimate: 5, utility: 50, sourceSeq: 2n, mandatory: false },
+    ],
+    // Mixed: 2 mandatory + optional candidates exercising closure + selection.
+    mixed: [
+      { nodeId: "m1", tokenEstimate: 10, utility: 100, sourceSeq: 1n, mandatory: true },
+      { nodeId: "m2", tokenEstimate: 20, utility: 200, sourceSeq: 2n, mandatory: true },
+      { nodeId: "opt", tokenEstimate: 30, utility: 90, sourceSeq: 3n, mandatory: false },
+    ],
+  };
+  const set = sets[name];
+  assert.ok(set, `candidate-set materializer missing for "${name}"`);
+  return set;
+}
+
+function framing(zero?: boolean): FramingProfile {
+  return zero ? { perNode: 0, overhead: 0 } : DEFAULT_FRAMING;
+}
+
+export interface PlnResult {
+  ok: boolean;
+  code?: string;
+  selected?: string[];
+  tokenTotal?: number;
+  firstSelected?: string;
+  mandatoryPreserved?: boolean;
+  demotesToC?: boolean;
+  omittedOverBudget?: boolean;
+  omittedZeroUtility?: boolean;
+  omittedIncompatible?: boolean;
+  noPartialSelection?: boolean;
+  withinBudget?: boolean;
+  planIsClosed?: boolean;
+  permutationInvariant?: boolean;
+  manifestStable?: boolean;
+}
+
+/**
+ * Drive a planner fixture scenario through the REAL portfolio planner. The
+ * `mandatoryTokenEstimate` is the VC4C CONTENT-ONLY figure = sum of mandatory
+ * content tokens (zero-framing fixtures make that the exact candidate sum).
+ */
+export function runPlannerScenario(fx: PlnFixture): PlnResult {
+  const { candidates: setName, tokenBudget, zeroFraming, permute, mutateTokensAfterPlan } = fx.input;
+  const cands = materializeCandidates(setName);
+
+  // VC4C content-only mandatory estimate = sum of mandatory content tokens.
+  const mandatoryTokenEstimate = cands
+    .filter((c) => c.mandatory)
+    .reduce((s, c) => s + c.tokenEstimate, 0);
+
+  const dagDigest = "deadbeef".repeat(8);
+  // The `incompatible` set wires an explicit mutual-exclusion pair (bad ⊥ m1) so
+  // the planner's incompatibility gate is exercised end-to-end.
+  const incompatiblePairs =
+    setName === "incompatible" ? ([["bad", "m1"]] as [string, string][]) : undefined;
+  const input = {
+    dagDigest,
+    candidates: permute ? shuffle([...cands]) : cands,
+    mandatoryTokenEstimate,
+    tokenBudget,
+    dependencyHighWater: 100n,
+    framing: framing(zeroFraming),
+    ...(incompatiblePairs ? { incompatiblePairs } : {}),
+  };
+
+  const res = planPortfolio(input);
+
+  if (fx.expected.permutationInvariant) {
+    const a = planPortfolio(input);
+    const b = planPortfolio({ ...input, candidates: shuffle([...cands]) });
+    const ids = (ok: typeof a): string[] => (ok.ok ? [...ok.plan.selectedNodeIds] : []);
+    return { ok: true, permutationInvariant: JSON.stringify(ids(a)) === JSON.stringify(ids(b)) };
+  }
+
+  if (!res.ok) {
+    // Over-budget failure: mandatory set preserved intact, demotes to C.
+    const mandatoryIds = cands.filter((c) => c.mandatory).map((c) => c.nodeId).sort();
+    const preserved = res.mandatory.slice().sort().join(",") === mandatoryIds.join(",");
+    return {
+      ok: false,
+      code: res.code,
+      mandatoryPreserved: preserved,
+      demotesToC: res.code === "MANDATORY_CLOSURE_OVER_BUDGET",
+    };
+  }
+
+  // ── Accepted-plan assertions ──
+  const plan = res.plan;
+  const selected = [...plan.selectedNodeIds];
+  const out: PlnResult = { ok: true, selected, tokenTotal: plan.tokenTotal };
+  if (fx.expected.firstSelected !== undefined) out.firstSelected = selected[0];
+  if (fx.expected.withinBudget) out.withinBudget = plan.tokenTotal <= tokenBudget;
+  if (fx.expected.noPartialSelection) {
+    out.noPartialSelection = cands.every(
+      (c) => !c.mandatory || selected.includes(c.nodeId),
+    );
+  }
+  if (fx.expected.planIsClosed) {
+    const mandatoryIds = cands.filter((c) => c.mandatory).map((c) => c.nodeId).sort();
+    out.planIsClosed = mandatoryIds.every((id) => selected.includes(id));
+  }
+  if (fx.expected.omittedOverBudget) {
+    const omit = plan.omissions.some((o) => o.reason === "over-budget");
+    out.omittedOverBudget = omit;
+  }
+  if (fx.expected.omittedZeroUtility) {
+    out.omittedZeroUtility = plan.omissions.some((o) => o.reason === "zero-utility");
+  }
+  if (fx.expected.omittedIncompatible) {
+    out.omittedIncompatible = plan.omissions.some((o) => o.reason === "incompatible");
+  }
+
+  // Manifest identity: a post-plan token mutation must fail revalidation.
+  if (mutateTokensAfterPlan) {
+    const pinned = planManifestDigest(plan, cands);
+    const mutated = cands.map((c, i) => (i === 0 ? { ...c, tokenEstimate: c.tokenEstimate + 1 } : c));
+    const check = validatePlanManifest(plan, mutated, pinned);
+    out.ok = check.ok; // false → plan rejected, never reaches provider
+    out.code = check.ok ? undefined : check.code;
+    return out;
+  }
+  if (fx.expected.manifestStable) {
+    const pinned = planManifestDigest(plan, cands);
+    const check = validatePlanManifest(plan, cands, pinned);
+    out.manifestStable = check.ok;
+  }
+  return out;
+}

package/src/vector-cortex/prompt-dag/_acceptance-shuffle.ts

@@ -0,0 +1,26 @@
+/**
+ * prompt-dag/_acceptance-shuffle.ts — small deterministic helpers shared by the
+ * VC5A acceptance DAG/planner materializers.
+ */
+
+/** Array element equality (length + pairwise). */
+export function eq(a: readonly string[], b: readonly string[]): boolean {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+
+/**
+ * Fisher–Yates with a FIXED seed so permutation tests are reproducible across
+ * runs and machines (no Math.random in tests).
+ */
+export function shuffle<T>(arr: T[]): T[] {
+  const a = [...arr];
+  let seed = 0x9e3779b9;
+  for (let i = a.length - 1; i > 0; i--) {
+    seed = (seed * 1664525 + 1013904223) >>> 0;
+    const j = seed % (i + 1);
+    const t = a[i]!;
+    a[i] = a[j]!;
+    a[j] = t;
+  }
+  return a;
+}

package/src/vector-cortex/prompt-dag/builder.ts

@@ -0,0 +1,189 @@
+/**
+ * vector-cortex/prompt-dag/builder.ts — single-session PromptDagV1 construction
+ * (VC5A, task 2).
+ *
+ * The builder is the STRUCTURAL gate: it rejects a graph that could never be
+ * planned safely, before any ordering or selection is attempted. Rejections are
+ * hard and total (the sprint bar: "cycles/incompatibilities rejected 100%"):
+ *
+ *   - `DAG_MIXED_SESSION`        — a span whose sessionId differs from the DAG's.
+ *                                  Cross-session evidence MUST be a synthetic
+ *                                  node citing a separately validated manifest,
+ *                                  never a foreign span (CONTRACTS §PromptDagV1).
+ *   - `DAG_DUPLICATE_ID`         — two nodes sharing an id.
+ *   - `DAG_MISSING_ENDPOINT`     — an edge naming an absent node.
+ *   - `DAG_INVALID_SPAN`         — reversed/negative range, or a synthetic node
+ *                                  carrying a span (synthetics have no source
+ *                                  position by definition).
+ *   - `DAG_SPAN_DIGEST_CONFLICT` — two overlapping spans pinning DIFFERENT
+ *                                  digests for the same bytes: a corrupted or
+ *                                  forged source claim, not a legal overlap.
+ *   - `DAG_UNKNOWN_INCOMPATIBLE` — `incompatibleWith` naming an absent node.
+ *   - `DAG_TOOL_PAIR_SPLIT`      — a tool-pair edge whose endpoints are not both
+ *                                  present (PREVENT-PI-002).
+ *
+ * Cycle and reversed-`precedes` detection belong to the VALIDATOR, which owns
+ * the topological order; the builder only guarantees the graph is structurally
+ * well-formed and single-session.
+ *
+ * Determinism: nodes and edges are emitted in a canonical sorted order so the
+ * same inputs always produce byte-identical DAG bytes, whatever order the caller
+ * supplied them in. Pure: no storage, no console, no network (PREVENT-PI-004).
+ */
+
+import type {
+  DagEdge,
+  DagFailureCode,
+  DagNode,
+  DagSpan,
+  PromptDagV1,
+} from "./types.js";
+
+/** Bytewise string comparison — the universal deterministic tie-break. */
+function byBytes(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * Canonical node order: source position first (`startSeq`, then `startByte`),
+ * synthetics last (they have no span), then `syntheticOrdinal`, then id bytes.
+ * This mirrors the validator's queue key so the emitted DAG and its topological
+ * order agree on what "earlier" means.
+ */
+export function compareNodes(a: DagNode, b: DagNode): number {
+  const aSeq = a.span?.startSeq;
+  const bSeq = b.span?.startSeq;
+  if (aSeq !== undefined && bSeq !== undefined) {
+    if (aSeq !== bSeq) return aSeq < bSeq ? -1 : 1;
+  } else if (aSeq !== undefined) {
+    return -1; // spanned nodes precede synthetics
+  } else if (bSeq !== undefined) {
+    return 1;
+  }
+  // Contract key: (startSeq, syntheticOrdinal, id bytes) — byte offset is NOT a
+  // tie-break, so the emitted DAG and its topological order agree exactly.
+  const aOrd = a.syntheticOrdinal ?? 0;
+  const bOrd = b.syntheticOrdinal ?? 0;
+  if (aOrd !== bOrd) return aOrd < bOrd ? -1 : 1;
+  return byBytes(a.id, b.id);
+}
+
+/** Canonical edge order: from, then to, then kind — a total order. */
+export function compareEdges(a: DagEdge, b: DagEdge): number {
+  const f = byBytes(a.from, b.from);
+  if (f !== 0) return f;
+  const t = byBytes(a.to, b.to);
+  if (t !== 0) return t;
+  return byBytes(a.kind, b.kind);
+}
+
+/** Whether two half-open byte ranges in the same session intersect. */
+function spansOverlap(a: DagSpan, b: DagSpan): boolean {
+  if (a.sessionId !== b.sessionId) return false;
+  return a.startByte < b.endByte && b.startByte < a.endByte;
+}
+
+/** A span is well-formed when both its seq and byte ranges are non-decreasing. */
+function spanIsValid(span: DagSpan): boolean {
+  if (span.startSeq > span.endSeq) return false;
+  if (span.startByte < 0 || span.endByte < 0) return false;
+  return span.startByte <= span.endByte;
+}
+
+/** Push a failure code once (codes are a SET, reported in discovery order). */
+function pushCode(codes: DagFailureCode[], code: DagFailureCode): void {
+  if (!codes.includes(code)) codes.push(code);
+}
+
+/** The inputs a DAG is built from. */
+export interface DagBuildInput {
+  readonly sessionId: string;
+  /** The durable contiguous authority high-water this DAG is built against. */
+  readonly sourceHighWater: bigint;
+  readonly nodes: readonly DagNode[];
+  readonly edges: readonly DagEdge[];
+}
+
+/** Build outcome: the canonical DAG, or the exact structural failure codes. */
+export type DagBuildResult =
+  | { readonly ok: true; readonly dag: PromptDagV1 }
+  | { readonly ok: false; readonly codes: readonly DagFailureCode[] };
+
+/**
+ * Build a canonical single-session `PromptDagV1`, or reject with the exact
+ * structural failure codes (task 2).
+ *
+ * Every check runs before returning so a caller sees ALL structural problems at
+ * once rather than fixing them one round-trip at a time; the codes array is
+ * deduplicated and ordered by discovery.
+ */
+export function buildPromptDag(input: DagBuildInput): DagBuildResult {
+  const codes: DagFailureCode[] = [];
+
+  // ── Node identity + span validity + single-session enforcement ─────────────
+  const byId = new Map<string, DagNode>();
+  for (const n of input.nodes) {
+    if (byId.has(n.id)) pushCode(codes, "DAG_DUPLICATE_ID");
+    else byId.set(n.id, n);
+
+    if (n.kind === "synthetic") {
+      // A synthetic node has no source position by definition; carrying a span
+      // would make its ordering ambiguous against real source nodes.
+      if (n.span !== undefined) pushCode(codes, "DAG_INVALID_SPAN");
+      continue;
+    }
+    if (n.span === undefined) continue; // a spanless non-synthetic orders last
+    if (!spanIsValid(n.span)) pushCode(codes, "DAG_INVALID_SPAN");
+    // Single-session: cross-session evidence must be a synthetic citation.
+    if (n.span.sessionId !== input.sessionId) pushCode(codes, "DAG_MIXED_SESSION");
+  }
+
+  // ── Overlapping spans must agree on the digest of the shared bytes ─────────
+  const spanned = input.nodes.filter(
+    (n): n is DagNode & { span: DagSpan } => n.span !== undefined,
+  );
+  for (let i = 0; i < spanned.length; i++) {
+    for (let j = i + 1; j < spanned.length; j++) {
+      const a = spanned[i]!;
+      const b = spanned[j]!;
+      if (!spansOverlap(a.span, b.span)) continue;
+      if (a.span.digest !== b.span.digest) {
+        pushCode(codes, "DAG_SPAN_DIGEST_CONFLICT");
+      }
+    }
+  }
+
+  // ── Incompatibility targets must exist ────────────────────────────────────
+  for (const n of input.nodes) {
+    for (const other of n.incompatibleWith) {
+      if (!byId.has(other)) pushCode(codes, "DAG_UNKNOWN_INCOMPATIBLE");
+    }
+  }
+
+  // ── Edge endpoints must exist; tool pairs must be whole ───────────────────
+  for (const e of input.edges) {
+    const hasFrom = byId.has(e.from);
+    const hasTo = byId.has(e.to);
+    if (!hasFrom || !hasTo) {
+      pushCode(codes, "DAG_MISSING_ENDPOINT");
+      // A tool pair missing an endpoint is ALSO a split pair (PREVENT-PI-002):
+      // the atomic unit cannot be represented, let alone selected whole.
+      if (e.kind === "tool-pair") pushCode(codes, "DAG_TOOL_PAIR_SPLIT");
+    }
+  }
+
+  if (codes.length > 0) return { ok: false, codes };
+
+  const nodes = [...input.nodes].sort(compareNodes);
+  const edges = [...input.edges].sort(compareEdges);
+  return {
+    ok: true,
+    dag: {
+      schema: "prompt-dag-v1",
+      sessionId: input.sessionId,
+      sourceHighWater: input.sourceHighWater,
+      nodes,
+      edges,
+    },
+  };
+}

package/src/vector-cortex/prompt-dag/types.ts

@@ -0,0 +1,151 @@
+/**
+ * vector-cortex/prompt-dag/types.ts — the exact single-session `PromptDagV1`
+ * schema (VC5A, task 1).
+ *
+ * A PromptDagV1 is the STRUCTURE a plan is selected over: nodes are prompt
+ * candidates (events, exact spans, semantic renderings, synthetic citations) and
+ * edges are the ordering/atomicity/exclusivity constraints among them. It is
+ * strictly SINGLE-SESSION (CONTRACTS §PromptDagV1): every node span MUST carry
+ * `dag.sessionId`; cross-session evidence is represented by a SYNTHETIC node
+ * whose payload cites a separately validated source manifest, never by a foreign
+ * span.
+ *
+ * Ordering is a total order by construction so the same DAG always yields the
+ * same Kahn sequence:
+ *
+ *   - event/exact/semantic nodes order by their source span (`startSeq`, then
+ *     `startByte`);
+ *   - synthetic nodes have NO span and sort after every prerequisite, then by
+ *     `syntheticOrdinal`, then by node-ID bytes;
+ *   - the zero-indegree queue key is `(span.startSeq ?? MAX, syntheticOrdinal ??
+ *     0, id bytes)` — never object/map iteration order.
+ *
+ * Pure types + registered conformance IDs: no storage, no console, no network
+ * (PREVENT-PI-004 / PREVENT-011).
+ */
+
+/**
+ * A half-open source span. `startSeq`/`endSeq` are INCLUSIVE event sequence
+ * numbers; `startByte`/`endByte` are HALF-OPEN byte offsets (CONTRACTS
+ * §PromptDagV1). `digest` is the pinned `sha256:<hex>` of the covered bytes —
+ * the builder rejects two overlapping spans whose digests disagree, since that
+ * is a corrupted or forged source claim rather than a legitimate overlap.
+ */
+export interface DagSpan {
+  readonly sessionId: string;
+  readonly startSeq: bigint;
+  readonly endSeq: bigint;
+  readonly startByte: number;
+  readonly endByte: number;
+  /** Pinned digest of the covered bytes, `sha256:` prefixed. */
+  readonly digest: `sha256:${string}`;
+}
+
+/**
+ * The kind of a DAG node.
+ *
+ *   - `event`     — a whole source event record;
+ *   - `exact`     — authoritative source bytes (verbatim, never paraphrased);
+ *   - `semantic`  — a derived rendering that NEVER claims to recover exact text;
+ *   - `synthetic` — no source span (a citation/summary); orders after its
+ *                   prerequisites by `syntheticOrdinal` then ID bytes.
+ */
+export type DagNodeKind = "event" | "exact" | "semantic" | "synthetic";
+
+/**
+ * One prompt-DAG node. `span` is present for every non-synthetic kind and absent
+ * for `synthetic`. `incompatibleWith` lists node IDs that may NOT be selected
+ * together with this node (a mutual-exclusion constraint the planner enforces —
+ * distinct from a `contradicts` EDGE, which is a source-level disagreement).
+ */
+export interface DagNode {
+  readonly id: string;
+  readonly kind: DagNodeKind;
+  /** Source span; absent (and required to be absent) for `synthetic`. */
+  readonly span?: DagSpan;
+  /** Tie-break ordinal for synthetic nodes, which have no span. */
+  readonly syntheticOrdinal?: number;
+  /** Digest of this node's payload (identity for the manifest digest). */
+  readonly payloadDigest: string;
+  /** Node IDs that must never be co-selected with this node. */
+  readonly incompatibleWith: readonly string[];
+}
+
+/**
+ * A directed DAG edge, pointing prerequisite/earlier **from → dependent/later
+ * to** (CONTRACTS §PromptDagV1).
+ *
+ *   - `precedes`    — pure ordering; `from` must appear before `to`;
+ *   - `depends`     — `to` requires `from` (closure pulls `from` in);
+ *   - `tool-pair`   — an atomic tool call/result pair, never split
+ *                     (PREVENT-PI-002);
+ *   - `contradicts` — mutually exclusive source claims.
+ */
+export type DagEdgeKind = "precedes" | "depends" | "tool-pair" | "contradicts";
+
+/** A directed prompt-DAG edge (`from` is the prerequisite/earlier endpoint). */
+export interface DagEdge {
+  readonly from: string;
+  readonly to: string;
+  readonly kind: DagEdgeKind;
+}
+
+/**
+ * The single-session prompt DAG. `sourceHighWater` is the durable contiguous
+ * authority high-water this DAG was built against — a derived structure may
+ * never claim evidence beyond it (TRIAD_RESILIENCE: derived frontier cannot
+ * exceed durable authority high-water).
+ */
+export interface PromptDagV1 {
+  readonly schema: "prompt-dag-v1";
+  readonly sessionId: string;
+  readonly sourceHighWater: bigint;
+  readonly nodes: readonly DagNode[];
+  readonly edges: readonly DagEdge[];
+}
+
+/**
+ * DAG build/validation failure codes. Every code is a HARD rejection: a DAG that
+ * produces any of these never reaches the planner (cycles/incompatibilities are
+ * rejected 100%, per the sprint acceptance bar).
+ */
+export type DagFailureCode =
+  /** A node span's `sessionId` differs from `dag.sessionId` (single-session). */
+  | "DAG_MIXED_SESSION"
+  /** Two nodes share an ID. */
+  | "DAG_DUPLICATE_ID"
+  /** An edge names a node ID absent from the graph. */
+  | "DAG_MISSING_ENDPOINT"
+  /** A span is malformed (reversed/negative range) or a synthetic node has one. */
+  | "DAG_INVALID_SPAN"
+  /** Two spans overlap but pin DIFFERENT digests for the shared bytes. */
+  | "DAG_SPAN_DIGEST_CONFLICT"
+  /** A `precedes` edge points backward against source order. */
+  | "DAG_REVERSED_PRECEDES"
+  /** The dependency/ordering graph contains a cycle. */
+  | "DAG_CYCLE"
+  /** A tool-pair edge's endpoints are not both present/whole. */
+  | "DAG_TOOL_PAIR_SPLIT"
+  /** A node declares `incompatibleWith` naming a node absent from the graph. */
+  | "DAG_UNKNOWN_INCOMPATIBLE";
+
+/**
+ * The validator verdict. `ok:true` carries the STABLE Kahn topological order —
+ * the single authoritative sequence downstream consumers (VC5B) replay.
+ */
+export type DagValidation =
+  | { readonly ok: true; readonly order: readonly string[] }
+  | { readonly ok: false; readonly codes: readonly DagFailureCode[] };
+
+/**
+ * Registered DAG conformance ID range (DAG-001..030). The acceptance aggregator
+ * reads these rows from the v2 manifest and asserts each returns its manifest
+ * `ok`/`code`.
+ */
+export const DAG_IDS: readonly string[] = Array.from(
+  { length: 30 },
+  (_v, i) => `DAG-${String(i + 1).padStart(3, "0")}`,
+);
+
+/** Named VC5A DAG conformance assertion (the sprint's headline DAG row). */
+export const DAG_NAMED_IDS = ["DAG-CYCLE-001"] as const;

package/extensions/dashboard-client/dist/assets/VectorCortexTab-B3yisAyB.js

@@ -1,2 +0,0 @@
-import{r as o,j as e,B as c}from"./index-CFLekP12.js";import{C as i,a as x,b as h,c as u}from"./card-BT3Z5dDg.js";async function B(){const s=await fetch("/api/vector-cortex/evaluation");if(!s.ok)throw new Error(`vector-cortex evaluation: ${s.status}`);return s.json()}async function S(){const s=await fetch("/api/vector-cortex/health");if(!s.ok)throw new Error(`vector-cortex health: ${s.status}`);return s.json()}async function D(){const s=await fetch("/api/vector-cortex/topology");if(!s.ok)throw new Error(`vector-cortex topology: ${s.status}`);return s.json()}async function O(){const s=await fetch("/api/vector-cortex/query");if(!s.ok)throw new Error(`vector-cortex query: ${s.status}`);return s.json()}async function L(){const s=await fetch("/api/vector-cortex/shards");if(!s.ok)throw new Error(`vector-cortex shards: ${s.status}`);return s.json()}async function H(){const s=await fetch("/api/vector-cortex/reconstruct");if(!s.ok)throw new Error(`vector-cortex reconstruct: ${s.status}`);return s.json()}async function q(s="default"){const n=await fetch(`/api/vector-cortex/ledger?session=${encodeURIComponent(s)}`);if(!n.ok)throw new Error(`vector-cortex ledger: ${n.status}`);return n.json()}async function P(s){const n=await fetch("/api/vector-cortex/breakers/reset",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({subsystem:s})});if(!n.ok)throw new Error(`vector-cortex reset: ${n.status}`);return n.json()}function p({mode:s,count:n}){return e.jsxs("div",{className:"flex items-center justify-between border-b border-border/50 py-1 text-sm",children:[e.jsxs("span",{className:"text-muted-foreground",children:["Mode ",s]}),e.jsx("span",{className:"font-mono",children:n})]})}function r({label:s,value:n}){return e.jsxs("div",{children:[e.jsx("div",{className:"text-xs text-muted-foreground",children:s}),e.jsx("div",{className:"font-mono text-sm",children:n})]})}function G(){const[s,n]=o.useState(null),[b,E]=o.useState(null),[V,F]=o.useState(!0),[a,y]=o.useState(null),[N,C]=o.useState(null),[m,$]=o.useState(null),[l,R]=o.useState(null),[v,k]=o.useState(null),[j,T]=o.useState(null),[d,M]=o.useState(null),f=o.useCallback(()=>{B().then(n).catch(t=>E(t instanceof Error?t.message:String(t))).finally(()=>F(!1)),S().then(y).catch(()=>{}),q().then($).catch(()=>{}),D().then(R).catch(()=>{}),O().then(k).catch(()=>{}),L().then(T).catch(()=>{}),H().then(M).catch(()=>{})},[]);o.useEffect(()=>{f();const t=setInterval(f,5e3);return()=>clearInterval(t)},[f]);const A=()=>{P("provider").then(t=>(C(`Breaker "${t.subsystem}" ${t.state}; evidence retained: ${t.failures} failures / ${t.attempts} attempts`),S())).then(y).catch(t=>C(t instanceof Error?t.message:String(t)))};if(V&&!s)return e.jsx("div",{className:"vc-loading",children:"Loading vector-cortex evaluation…"});if(b&&!s)return e.jsxs("div",{className:"vc-error",children:["Error: ",b]});if(!s)return e.jsx("div",{className:"vc-empty",children:"No evaluation data available."});const w=Math.max(1,...s.histogram.cells,s.histogram.overflow);return e.jsxs("div",{className:"flex flex-col gap-4",children:[e.jsxs("div",{className:"flex items-center gap-2",children:[e.jsx("h2",{className:"text-lg font-semibold",children:"Vector Cortex Evaluation"}),s.enabled?e.jsx(c,{variant:"warning",children:"OBSERVER PENDING (A)"}):e.jsx(c,{variant:"danger",children:"MODE C (OFF)"})]}),e.jsxs("div",{className:"grid grid-cols-1 gap-4 md:grid-cols-3",children:[e.jsxs(i,{children:[e.jsx(x,{children:e.jsx(h,{children:"Samples"})}),e.jsxs(u,{children:[e.jsx("div",{className:"text-3xl font-bold",children:s.samples}),e.jsxs("div",{className:"mt-2 flex flex-col",children:[e.jsx(p,{mode:"A",count:s.byMode.A}),e.jsx(p,{mode:"B",count:s.byMode.B}),e.jsx(p,{mode:"C",count:s.byMode.C})]})]})]}),e.jsxs(i,{className:"md:col-span-2",children:[e.jsx(x,{children:e.jsx(h,{children:"Latency Histogram (ms, inclusive edges)"})}),e.jsxs(u,{children:[e.jsxs("div",{className:"flex items-end gap-2",style:{height:160},children:[s.histogram.edges.map((t,g)=>{const I=s.histogram.cells[g]/w*140;return e.jsxs("div",{className:"flex flex-1 flex-col items-center gap-1",children:[e.jsx("span",{className:"text-xs text-muted-foreground",children:s.histogram.cells[g]}),e.jsx("div",{className:"w-full rounded-t",style:{height:Math.max(2,I),background:"#6366f1"}}),e.jsxs("span",{className:"text-[10px] text-muted-foreground",children:["≤",t]})]},t)}),e.jsxs("div",{className:"flex flex-1 flex-col items-center gap-1",children:[e.jsx("span",{className:"text-xs text-muted-foreground",children:s.histogram.overflow}),e.jsx("div",{className:"w-full rounded-t",style:{height:Math.max(2,s.histogram.overflow/w*140),background:"#f87171"}}),e.jsx("span",{className:"text-[10px] text-muted-foreground",children:">250"})]})]}),e.jsxs("div",{className:"mt-1 text-xs text-muted-foreground",children:["Total: ",s.histogram.total," · Rejects: ",s.rejects.length]})]})]})]}),e.jsxs(i,{children:[e.jsx(x,{children:e.jsxs("div",{className:"flex items-center justify-between",children:[e.jsx(h,{children:"Live Safety Envelope (VC0C)"}),e.jsxs("div",{className:"flex items-center gap-2",children:[a?.stateSource==="ephemeral"&&e.jsx(c,{variant:"outline",children:"EPHEMERAL (non-live)"}),e.jsx("button",{onClick:A,disabled:!a?.enabled,className:"rounded border border-border px-2 py-1 text-xs disabled:opacity-50",children:"Reset Cooldown"})]})]})}),e.jsxs(u,{children:[N&&e.jsx("div",{className:"mb-2 text-xs text-muted-foreground",children:N}),a?e.jsxs("div",{className:"grid grid-cols-2 gap-4 md:grid-cols-4",children:[e.jsx(r,{label:"State",value:a.state}),e.jsx(r,{label:"Mode",value:a.mode}),e.jsx(r,{label:"Window",value:`${a.windowMs}ms`}),e.jsx(r,{label:"Probes",value:String(a.probeCount)}),e.jsx(r,{label:"Backoff",value:`${a.backoffDelayMs}ms`}),e.jsx(r,{label:"Failures",value:`${a.failures}/${a.attempts}`}),e.jsx(r,{label:"Frontier",value:a.stateSource==="ephemeral"?"non-live":a.frontierFrozen?"FROZEN":"LIVE"}),e.jsx(r,{label:"Spool lag",value:String(a.spoolLag)}),e.jsx(r,{label:"Encoder mode",value:a.encoderMode}),e.jsx(r,{label:"Encoder asset",value:a.encoderAssetDigest?a.encoderAssetDigest.slice(0,12):"none"})]}):e.jsx("div",{className:"vc-empty",children:"Health unavailable (VC0C off)."})]})]}),e.jsxs(i,{children:[e.jsx(x,{children:e.jsxs("div",{className:"flex items-center justify-between",children:[e.jsx(h,{children:"Derived Cortex Store (VC3A)"}),l?.enabled?e.jsx(c,{variant:"success",children:"ACTIVE"}):e.jsx(c,{variant:"danger",children:"OFF"})]})}),e.jsx(u,{children:l?.enabled?e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"grid grid-cols-2 gap-4 md:grid-cols-3",children:[e.jsx(r,{label:"Generation",value:l.generationId??"—"}),e.jsx(r,{label:"Ordinal",value:l.ordinal??"—"}),e.jsx(r,{label:"Records",value:String(l.recordCount)}),e.jsx(r,{label:"Frontier (HW)",value:l.sourceHighWater}),e.jsx(r,{label:"Root digest",value:l.rootDigest?l.rootDigest.slice(0,16):"—"}),l.nodes!==void 0&&e.jsxs(e.Fragment,{children:[e.jsx(r,{label:"Nodes",value:String(l.nodes?.length??0)}),e.jsx(r,{label:"Edges",value:String(l.edges?.length??0)}),e.jsx(r,{label:"Graph digest",value:l.generationDigest?l.generationDigest.slice(0,16):"—"})]})]}),l.nodes!==void 0&&(l.edges?.length??0)>0&&e.jsxs("div",{className:"mt-4 max-h-56 overflow-y-auto",children:[e.jsx("div",{className:"mb-1 text-xs font-medium text-muted-foreground",children:"Topology edges (VC3B)"}),e.jsxs("table",{className:"w-full text-left text-xs",children:[e.jsx("thead",{children:e.jsxs("tr",{className:"border-b border-border/50 text-muted-foreground",children:[e.jsx("th",{className:"py-1 pr-2",children:"source"}),e.jsx("th",{className:"py-1 pr-2",children:"target"}),e.jsx("th",{className:"py-1 pr-2",children:"head"}),e.jsx("th",{className:"py-1 pr-2",children:"dir"}),e.jsx("th",{className:"py-1",children:"score"})]})}),e.jsx("tbody",{children:l.edges?.map((t,g)=>e.jsxs("tr",{className:"border-b border-border/30",children:[e.jsx("td",{className:"py-1 pr-2 font-mono",children:t.source}),e.jsx("td",{className:"py-1 pr-2 font-mono",children:t.target}),e.jsx("td",{className:"py-1 pr-2 font-mono",children:t.head}),e.jsx("td",{className:"py-1 pr-2",children:t.direction}),e.jsx("td",{className:"py-1 font-mono",children:t.score})]},`${t.source}-${t.target}-${t.head}-${g}`))})]})]})]}):e.jsx("div",{className:"vc-empty",children:"Cortex store disabled (VC3A off)."})})]}),e.jsxs(i,{children:[e.jsx(x,{children:e.jsxs("div",{className:"flex items-center justify-between",children:[e.jsx(h,{children:"Topology Query Diagnostics (VC3C)"}),v?.enabled?e.jsx(c,{variant:"success",children:"ACTIVE"}):e.jsx(c,{variant:"danger",children:"OFF"})]})}),e.jsx(u,{children:v?.enabled?e.jsx("div",{className:"grid grid-cols-2 gap-4 md:grid-cols-3",children:e.jsx(r,{label:"Router version",value:String(v.routerVersion)})}):e.jsx("div",{className:"vc-empty",children:"Query diagnostics unavailable (VC3C off)."})})]}),e.jsxs(i,{children:[e.jsx(x,{children:e.jsxs("div",{className:"flex items-center justify-between",children:[e.jsx(h,{children:"Dual-Tier Shards (VC4A)"}),j?.enabled?e.jsx(c,{variant:"success",children:"ACTIVE"}):e.jsx(c,{variant:"danger",children:"OFF"})]})}),e.jsx(u,{children:j?.enabled?e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"grid grid-cols-2 gap-4 md:grid-cols-4",children:[e.jsx(r,{label:"Semantic shards",value:String(j.semanticCount)}),e.jsx(r,{label:"Exact shards",value:String(j.exactCount)}),e.jsx(r,{label:"Byte total",value:String(j.byteTotal)}),e.jsx(r,{label:"Protected bytes",value:String(j.protectedByteTotal)})]}),e.jsx("div",{className:"mt-3 text-xs text-muted-foreground",children:"Reader-only count/byte aggregate; staged in-memory this sprint."})]}):e.jsx("div",{className:"vc-empty",children:"Dual-tier shards disabled (VC4A off)."})})]}),e.jsxs(i,{children:[e.jsx(x,{children:e.jsxs("div",{className:"flex items-center justify-between",children:[e.jsx(h,{children:"Reconstruction Fidelity (VC4C)"}),d?.enabled?e.jsx(c,{variant:"success",children:"ACTIVE"}):e.jsx(c,{variant:"danger",children:"OFF"})]})}),e.jsx(u,{children:d?.enabled?e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"grid grid-cols-2 gap-4 md:grid-cols-4",children:[e.jsx(r,{label:"Closure attempts",value:String(d.closureAttempts)}),e.jsx(r,{label:"Closure rejections",value:String(d.closureRejections)}),e.jsx(r,{label:"Validated",value:String(d.validatedCount)}),e.jsx(r,{label:"Invalidated",value:String(d.invalidatedCount)}),e.jsx(r,{label:"Span total",value:String(d.spanTotal)}),e.jsx(r,{label:"Byte total",value:String(d.byteTotal)})]}),e.jsx("div",{className:"mt-3 text-xs text-muted-foreground",children:"Reader-only closure/validation aggregate; staged in-memory this sprint."})]}):e.jsx("div",{className:"vc-empty",children:"Reconstruction fidelity disabled (VC4C off)."})})]}),e.jsxs(i,{children:[e.jsx(x,{children:e.jsxs("div",{className:"flex items-center justify-between",children:[e.jsx(h,{children:"Occurrence Ledger (VC1B)"}),m?.enabled?e.jsx(c,{variant:"success",children:"ACTIVE"}):e.jsx(c,{variant:"danger",children:"OFF"})]})}),e.jsx(u,{children:m?.enabled?e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"mb-3 grid grid-cols-2 gap-4 md:grid-cols-3",children:[e.jsx(r,{label:"Session",value:m.session}),e.jsx(r,{label:"High-water",value:m.highWater}),e.jsx(r,{label:"Occurrences",value:String(m.count)})]}),m.occurrences.length===0?e.jsx("div",{className:"vc-empty",children:"No occurrences recorded."}):e.jsx("div",{className:"max-h-64 overflow-y-auto",children:e.jsxs("table",{className:"w-full text-left text-xs",children:[e.jsx("thead",{children:e.jsxs("tr",{className:"border-b border-border/50 text-muted-foreground",children:[e.jsx("th",{className:"py-1 pr-2",children:"seq"}),e.jsx("th",{className:"py-1 pr-2",children:"eventId"}),e.jsx("th",{className:"py-1 pr-2",children:"kind"}),e.jsx("th",{className:"py-1 pr-2",children:"toolCall"}),e.jsx("th",{className:"py-1",children:"digest"})]})}),e.jsx("tbody",{children:m.occurrences.map(t=>e.jsxs("tr",{className:"border-b border-border/30",children:[e.jsx("td",{className:"py-1 pr-2 font-mono",children:t.seq}),e.jsx("td",{className:"py-1 pr-2 font-mono",children:t.eventId}),e.jsx("td",{className:"py-1 pr-2",children:t.kind}),e.jsx("td",{className:"py-1 pr-2 font-mono",children:t.toolCallId??"—"}),e.jsx("td",{className:"max-w-[180px] truncate font-mono text-muted-foreground",children:t.digest})]},`${t.seq}-${t.eventId}`))})]})})]}):e.jsx("div",{className:"vc-empty",children:"Ledger disabled (VC1B off)."})})]})]})}export{G as default};
-//# sourceMappingURL=VectorCortexTab-B3yisAyB.js.map