pi-mega-compact 0.20.61 → 0.20.63

package/src/vector-cortex/reconstruct/_acceptance-helpers.ts

@@ -6,6 +6,9 @@
  * the tests/ 600-line hard limit. Turns the declarative conformance fixtures
  * (graph/shard names) into real `ClosureGraph` / `DecodedShard` values and
  * drives them through the REAL reconstruct logic — no mocks, no stubs.
+ *
+ * Graph materializations live in _acceptance-graphs.ts (delegate-shell split
+ * per CLAUDE.md §6 — this file exceeded the 300-line soft limit).
  */
 import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -14,14 +17,13 @@ import assert from "node:assert/strict";
 
 import { closeSelection, isFixedPoint, closeExactOnly } from "./closure.js";
 import type { DecodedShard } from "./assemble.js";
-import { validateAndAssemble } from "./validate.js";
-import type {
-  ClosureEdge,
-  ClosureGraph,
-  ClosureNode,
-  ClosureResult,
-} from "./types.js";
-import type { ShardRange } from "../shards/types.js";
+import { PLACEHOLDER_DIGEST, validateAndAssemble } from "./validate.js";
+import type { ClosureResult, ClosureGraph } from "./types.js";
+
+// Delegate-shell re-exports — graph/span/node/edge + materializeGraph live in
+// the sibling impl file so this file stays under the 300-line soft limit.
+export { node, span, edge, materializeGraph } from "./_acceptance-graphs.js";
+import { span, materializeGraph } from "./_acceptance-graphs.js";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -111,194 +113,9 @@ export function withFlagsOn(fn: () => void): () => void {
   };
 }
 
-// ── Declarative graph materialization ───────────────────────────────────────
-
-export function node(id: string, kind: ClosureNode["kind"], opts: Partial<ClosureNode> = {}): ClosureNode {
-  return { id, kind, tokenEstimate: opts.tokenEstimate ?? 10, anchor: opts.anchor, resolvedAtMs: opts.resolvedAtMs, span: opts.span };
-}
-export function span(sessionId: string, seqStart: bigint, byteStart: number, len: number): ShardRange {
-  return { sessionId, seqStart, seqEnd: seqStart, byteStart, byteEnd: byteStart + len };
-}
-export function edge(from: string, to: string, kind: ClosureEdge["kind"]): ClosureEdge {
-  return { from, to, kind };
-}
-
-/** Materialize a named graph into a real ClosureGraph. */
-export function materializeGraph(name: string): ClosureGraph {
-  const cases: Record<string, ClosureGraph> = {
-    chain: {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("b", "event"), node("c", "event")],
-      edges: [edge("b", "a", "depends"), edge("c", "b", "depends")],
-    },
-    diamond: {
-      sessionId: "s",
-      nodes: [node("top", "event"), node("l", "event"), node("r", "event"), node("bottom", "event")],
-      edges: [edge("l", "top", "depends"), edge("r", "top", "depends"), edge("bottom", "l", "depends"), edge("bottom", "r", "depends")],
-    },
-    cycle: {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("b", "event"), node("c", "event")],
-      edges: [edge("b", "a", "depends"), edge("c", "b", "depends"), edge("a", "c", "depends")],
-    },
-    selfloop: {
-      sessionId: "s",
-      nodes: [node("a", "event")],
-      edges: [edge("a", "a", "depends")],
-    },
-    parallel: {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("b", "event"), node("x", "event"), node("y", "event")],
-      edges: [edge("b", "a", "depends"), edge("y", "x", "depends")],
-    },
-    prereq: {
-      sessionId: "s",
-      nodes: [node("dependent", "event"), node("prereq", "event")],
-      edges: [edge("prereq", "dependent", "depends")],
-    },
-    leaf: {
-      sessionId: "s",
-      nodes: [node("only", "event")],
-      edges: [],
-    },
-    scrambled: {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("m", "event"), node("z", "event")],
-      edges: [edge("m", "a", "depends"), edge("z", "m", "depends")],
-    },
-    "dangling-edge": {
-      sessionId: "s",
-      nodes: [node("a", "event")],
-      edges: [edge("a", "ghost", "depends")],
-    },
-    toolpair: {
-      sessionId: "s",
-      nodes: [node("toolcall", "event"), node("toolresult", "event")],
-      edges: [edge("toolcall", "toolresult", "tool-pair")],
-    },
-    anchored: {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("anchor", "event", { anchor: true })],
-      edges: [edge("a", "anchor", "depends")],
-    },
-    "anchor-deps": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("anchor", "event", { anchor: true }), node("anchordep", "event", { anchor: true })],
-      edges: [edge("anchor", "a", "depends"), edge("anchordep", "anchor", "depends")],
-    },
-    "toolpair-transitive": {
-      sessionId: "s",
-      nodes: [node("toolcall", "event"), node("toolresult", "event"), node("shareddep", "event")],
-      edges: [edge("toolcall", "toolresult", "tool-pair"), edge("shareddep", "toolcall", "depends"), edge("shareddep", "toolresult", "depends")],
-    },
-    "two-pairs": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("b", "event"), node("c", "event"), node("d", "event")],
-      edges: [edge("a", "b", "tool-pair"), edge("c", "d", "tool-pair")],
-    },
-    "anchor-pair": {
-      sessionId: "s",
-      nodes: [node("toolcall", "event"), node("toolresult", "event"), node("anchor", "event", { anchor: true })],
-      edges: [edge("toolcall", "toolresult", "tool-pair"), edge("anchor", "toolcall", "depends")],
-    },
-    chain8: {
-      sessionId: "s",
-      nodes: [0, 1, 2, 3, 4, 5, 6, 7, 8].map((i) => node(`n${i}`, "event")),
-      edges: [0, 1, 2, 3, 4, 5, 6, 7].map((i) => edge(`n${i + 1}`, `n${i}`, "depends")),
-    },
-    "pair-dep": {
-      sessionId: "s",
-      nodes: [node("toolcall", "event"), node("toolresult", "event"), node("common", "event")],
-      edges: [edge("toolcall", "toolresult", "tool-pair"), edge("common", "toolcall", "depends"), edge("common", "toolresult", "depends")],
-    },
-    overlap: {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("b", "event"), node("c", "event"), node("d", "event")],
-      edges: [edge("a", "c", "depends"), edge("b", "c", "depends"), edge("b", "d", "depends")],
-    },
-    "contra-explicit": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("loser", "exact", { resolvedAtMs: 100n }), node("winner", "exact", { resolvedAtMs: 200n })],
-      edges: [edge("loser", "winner", "contradicts"), edge("loser", "a", "depends"), edge("winner", "loser", "depends")],
-      resolutions: [{ loserId: "loser", winnerId: "winner" }],
-    },
-    "contra-later": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("early", "exact", { resolvedAtMs: 100n }), node("late", "exact", { resolvedAtMs: 200n })],
-      edges: [edge("early", "late", "contradicts"), edge("early", "a", "depends"), edge("late", "early", "depends")],
-    },
-    "contra-tie": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("x", "exact", { resolvedAtMs: 100n }), node("y", "exact", { resolvedAtMs: 100n })],
-      edges: [edge("x", "y", "contradicts"), edge("x", "a", "depends"), edge("y", "x", "depends")],
-    },
-    "contra-non-exact": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("x", "semantic", { resolvedAtMs: 100n }), node("y", "semantic", { resolvedAtMs: 200n })],
-      edges: [edge("x", "y", "contradicts"), edge("x", "a", "depends"), edge("y", "x", "depends")],
-    },
-    "contra-unselected": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("x", "exact", { resolvedAtMs: 100n }), node("y", "exact", { resolvedAtMs: 200n })],
-      edges: [edge("x", "y", "contradicts"), edge("a", "x", "depends")],
-    },
-    "contra-semantic": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("x", "semantic", { resolvedAtMs: 100n }), node("y", "exact", { resolvedAtMs: 200n })],
-      edges: [edge("x", "y", "contradicts"), edge("x", "a", "depends"), edge("y", "x", "depends")],
-    },
-    "contra-deps": {
-      sessionId: "s",
-      nodes: [node("a", "event"), node("early", "exact", { resolvedAtMs: 100n }), node("late", "exact", { resolvedAtMs: 200n }), node("dep", "event")],
-      edges: [edge("early", "late", "contradicts"), edge("early", "a", "depends"), edge("dep", "early", "depends"), edge("late", "early", "depends")],
-    },
-    tokened: {
-      sessionId: "s",
-      nodes: [node("a", "event", { tokenEstimate: 10 }), node("b", "event", { tokenEstimate: 10 }), node("c", "event", { tokenEstimate: 10 })],
-      edges: [edge("b", "a", "depends"), edge("c", "b", "depends")],
-    },
-    ordered: {
-      sessionId: "s",
-      nodes: [node("a", "semantic", { span: span("s", 1n, 0, 6) }), node("b", "exact", { span: span("s", 1n, 6, 6) }), node("c", "exact", { span: span("s", 1n, 12, 6) })],
-      edges: [edge("b", "a", "depends"), edge("c", "b", "depends")],
-    },
-    "scrambled-spans": {
-      sessionId: "s",
-      nodes: [node("c", "exact", { span: span("s", 1n, 12, 6) }), node("a", "semantic", { span: span("s", 1n, 0, 6) }), node("b", "exact", { span: span("s", 1n, 6, 6) })],
-      edges: [],
-    },
-    protected: {
-      sessionId: "s",
-      nodes: [node("a", "exact", { span: span("s", 1n, 0, 6) }), node("b", "exact", { span: span("s", 1n, 6, 6) })],
-      edges: [edge("b", "a", "depends")],
-    },
-    empty: { sessionId: "s", nodes: [], edges: [] },
-    reverse: {
-      sessionId: "s",
-      nodes: [node("c", "exact", { span: span("s", 1n, 12, 6) }), node("b", "exact", { span: span("s", 1n, 6, 6) }), node("a", "semantic", { span: span("s", 1n, 0, 6) })],
-      edges: [],
-    },
-    adjacent: {
-      sessionId: "s",
-      nodes: [node("a", "exact", { span: span("s", 1n, 0, 7) }), node("b", "exact", { span: span("s", 1n, 7, 14) })],
-      edges: [edge("b", "a", "depends")],
-    },
-    single: { sessionId: "s", nodes: [node("a", "exact", { span: span("s", 1n, 0, 6) })], edges: [] },
-    mixed: {
-      sessionId: "s",
-      nodes: [node("a", "exact", { span: span("s", 1n, 0, 6) }), node("b", "exact", { span: span("s", 1n, 6, 6) }), node("c", "semantic", { span: span("s", 1n, 12, 6) })],
-      edges: [edge("b", "a", "depends"), edge("c", "b", "depends")],
-    },
-  };
-  const g = cases[name];
-  assert.ok(g, `graph materializer missing for "${name}"`);
-  return g;
-}
-
-/**
- * Materialize the decoded shards for a named shard set. `digestOverride` lets a
- * caller pin a REAL per-shard digest (otherwise "0" = unset, and the validator
- * only enforces the post-assembly concatenation digest).
+/** Materialize the decoded shards for a named shard set. `digestOverride` lets a
+ * caller pin a REAL per-shard digest (otherwise PLACEHOLDER_DIGEST = unset, and
+ * the validator only enforces the post-assembly concatenation digest).
  */
 export function materializeShards(
   name: string,
@@ -339,7 +156,7 @@ export function materializeShards(
       range: n.span ?? span("s", 1n, 0, d.text.length),
       bytes: bytes(d.text),
       source: d.source,
-      digest: digestOverride ?? "0",
+      digest: digestOverride ?? PLACEHOLDER_DIGEST,
       protectedSpan: d.protected ?? false,
     });
   }

package/src/vector-cortex/reconstruct/validate.ts

@@ -25,6 +25,14 @@
 
 import { createHash } from "node:crypto";
 import { assembleSourceOrder, type DecodedShard } from "./assemble.js";
+
+// Explicit placeholder marker for an absent per-shard digest. A shard produced
+// without a per-shard digest skips the per-shard check and is covered only by
+// the post-assembly concatenation digest. This is an EXPLICIT, named sentinel —
+// never a bare "0" scattered at call sites — so it cannot be mistaken for a
+// real 64-hex digest and silently bypass verification.
+// guardrails-allow PREVENT-VERIFICATION-BYPASS-001: explicit named placeholder marker
+export const PLACEHOLDER_DIGEST = "0";
 import type {
   ClosureEdge,
   ClosureGraph,
@@ -62,10 +70,10 @@ function sha256HexSync(bytes: Uint8Array): string {
 /** Verify each decoded shard's bytes hash to its declared digest (REC_DIGEST_MISMATCH). */
 function findDigestMismatch(shards: readonly DecodedShard[]): ReconstructionFailureCode | null {
   for (const s of shards) {
-    // A pinned digest of "0" is a placeholder: the source tier did not compute a
-    // per-shard digest, so the only guarantee is the post-assembly concatenation
-    // digest. Any other digest is a real pin that must match exactly.
-    if (s.digest === "0") continue;
+    // A pinned placeholder digest (PLACEHOLDER_DIGEST) means the source tier did
+    // not compute a per-shard digest, so the only guarantee is the post-assembly
+    // concatenation digest. Any other digest is a real pin that must match exactly.
+    if (s.digest === PLACEHOLDER_DIGEST) continue;
     const computed = sha256HexSync(s.bytes);
     if (computed !== s.digest) return "REC_DIGEST_MISMATCH";
   }

package/src/vector-cortex/residual/fixture-payload.ts

@@ -27,6 +27,8 @@ export interface PayloadDescriptor {
 function lcgBytes(length: number, seed: number): Uint8Array {
   const out = new Uint8Array(length);
   let state = seed >>> 0;
+  // guardrails-allow PREVENT-STUB-001: VC4B (deterministic generative filler; permanent fixture determinism, not a runtime stub)
+  // guardrails-allow PREVENT-MOCK-001: VC4B deterministic synthetic payload bytes, fixture-only; same descriptor always yields identical bytes (accuracy floor acknowledged)
   for (let i = 0; i < length; i++) {
     state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
     out[i] = (state >>> 24) & 0xff;

package/src/vector-cortex/setup-cortex-blockers-compute.ts

@@ -68,11 +68,13 @@ export interface SetupCortexBlockerV1 {
 }
 
 /**
- * The four blockers VC9A reports. Enumerates the vc2-model-prep §6 items that
- * remain per the 2026-08-05 research. The opset re-export blocker (formerly
- * §6 #2) is NOT listed: onnx-community exports are opset 21, so it is removed.
- * This is the canonical BASE (all `status:"open"`); `computeSetupCortexBlockers`
- * derives the live list from it. Flag-off consumes this array verbatim.
+ * The six blockers VC9A reports. Enumerates the vc2-model-prep §6 items that
+ * remain per the 2026-08-05 research (HG-6/HG-7 registered by CONFORM-HYGIENE
+ * as the two manifest items that lacked HG ids). The opset re-export blocker
+ * (formerly §6 #2) is NOT listed: onnx-community exports are opset 21, so it is
+ * removed. This is the canonical BASE (all `status:"open"`);
+ * `computeSetupCortexBlockers` derives the live list from it. Flag-off consumes
+ * this array verbatim.
  */
 export const SETUP_CORTEX_BLOCKERS: readonly SetupCortexBlockerV1[] = [
   {
@@ -108,6 +110,22 @@ export const SETUP_CORTEX_BLOCKERS: readonly SetupCortexBlockerV1[] = [
     resolution:
       "149.2 MiB vs 150 MiB cap with run-to-run variance 119-149 MiB; considers capping mode A at 384 tokens or using the marginal-footprint accounting runtime.ts already implements.",
   },
+  {
+    id: "HG-6",
+    title: "4 threads mandatory for 512-token p95",
+    severity: "medium",
+    status: "open",
+    resolution:
+      "per vc2-model-prep §6 row 6: 2 threads → 44.3 ms (fails); low-core platforms may not qualify for mode A.",
+  },
+  {
+    id: "HG-7",
+    title: "Model card / dataset manifest / calibration",
+    severity: "blocker",
+    status: "open",
+    resolution:
+      "per vc2-model-prep §6 row 7: `model-card.json` comparison, `training/vector-cortex/dataset-manifest.json`, and frozen VC2C calibration thresholds all still required by spec.",
+  },
 ];
 
 /** Look up one blocker by id; undefined when unknown (defensive). */
@@ -192,7 +210,11 @@ export type SetupCortexActionKind = "fetch-model" | "bench" | "verify-asset";
  */
 const ACTION_GATE_CANDIDATES: Readonly<Record<SetupCortexActionKind, readonly string[]>> = {
   "fetch-model": ["HG-1", "HG-3"],
-  bench: ["HG-1", "HG-3"],
+  // HG-6 (4-threads-mandatory) is a bench-time gate; it is declared as a bench
+  // candidate but is medium severity, so `setupCortexActionBlockers` (which only
+  // surfaces blocker-severity open ids) never returns it — inert intent, no
+  // behavior change. HG-7 is training work (no action in this set).
+  bench: ["HG-1", "HG-3", "HG-6"],
   "verify-asset": [],
 };
 

package/extensions/dashboard-client/dist/assets/MetricsTab-wCxVpHlC.js

@@ -1,2 +0,0 @@
-import{j as r}from"./index-Bq2n15a4.js";import{M as t}from"./MetricsCards-IZaCOOXU.js";import"./card-DxZRNC4E.js";import"./generateCategoricalChart-Dj-DYUgL.js";import"./BarChart-DaoONT_V.js";import"./AreaChart-B1PoTqKJ.js";function e(){return r.jsx(t,{})}export{e as default};
-//# sourceMappingURL=MetricsTab-wCxVpHlC.js.map

package/extensions/dashboard-client/dist/assets/TurnsTab-CosKNvMp.js

@@ -1,2 +0,0 @@
-import{j as r}from"./index-Bq2n15a4.js";import{T as o}from"./TurnMemoryView-BZo09Jri.js";import"./card-DxZRNC4E.js";import"./button-C9qrZYdn.js";function e(){return r.jsx(o,{})}export{e as default};
-//# sourceMappingURL=TurnsTab-CosKNvMp.js.map