pi-mega-compact 0.20.8 → 0.20.10

package/extensions/dashboard-client/src/tabs/VectorCortexShardsCard.tsx

@@ -0,0 +1,89 @@
+/**
+ * VectorCortexShardsCard.tsx — VC4A dual-tier shard aggregate + VC4C
+ * reconstruction-fidelity cards.
+ *
+ * Extracted verbatim from VectorCortexTab.tsx (delegate-shell + sibling-card
+ * pattern already used by VectorCortexRenderCard / VectorCortexRestoreCard) so
+ * the tab stays well under the 400-line extension soft limit as later sprints
+ * add cards. Both are reader-only count/byte aggregates — no payload.
+ */
+import type React from "react";
+import type {
+	VectorCortexReconstructView,
+	VectorCortexShardsView,
+} from "../api/vector-cortex";
+import { Card, CardContent, CardHeader, CardTitle } from "../components/ui/card";
+import { Badge } from "../components/ui/badge";
+import { Metric } from "./VectorCortexMetric";
+
+/** Reader-only dual-tier shard aggregate (VC4A). */
+export function VectorCortexShardsCard({ view }: { view: VectorCortexShardsView | null }): React.ReactElement {
+	return (
+		<Card>
+			<CardHeader>
+				<div className="flex items-center justify-between">
+					<CardTitle>Dual-Tier Shards (VC4A)</CardTitle>
+					{view?.enabled ? (
+						<Badge variant="success">ACTIVE</Badge>
+					) : (
+						<Badge variant="danger">OFF</Badge>
+					)}
+				</div>
+			</CardHeader>
+			<CardContent>
+				{!view?.enabled ? (
+					<div className="vc-empty">Dual-tier shards disabled (VC4A off).</div>
+				) : (
+					<>
+						<div className="grid grid-cols-2 gap-4 md:grid-cols-4">
+							<Metric label="Semantic shards" value={String(view.semanticCount)} />
+							<Metric label="Exact shards" value={String(view.exactCount)} />
+							<Metric label="Byte total" value={String(view.byteTotal)} />
+							<Metric label="Protected bytes" value={String(view.protectedByteTotal)} />
+						</div>
+						<div className="mt-3 text-xs text-muted-foreground">
+							Reader-only count/byte aggregate; staged in-memory this sprint.
+						</div>
+					</>
+				)}
+			</CardContent>
+		</Card>
+	);
+}
+
+/** Reader-only reconstruction-fidelity aggregate (VC4C). */
+export function VectorCortexReconstructCard({ view }: { view: VectorCortexReconstructView | null }): React.ReactElement {
+	return (
+		<Card>
+			<CardHeader>
+				<div className="flex items-center justify-between">
+					<CardTitle>Reconstruction Fidelity (VC4C)</CardTitle>
+					{view?.enabled ? (
+						<Badge variant="success">ACTIVE</Badge>
+					) : (
+						<Badge variant="danger">OFF</Badge>
+					)}
+				</div>
+			</CardHeader>
+			<CardContent>
+				{!view?.enabled ? (
+					<div className="vc-empty">Reconstruction fidelity disabled (VC4C off).</div>
+				) : (
+					<>
+						<div className="grid grid-cols-2 gap-4 md:grid-cols-4">
+							<Metric label="Closure attempts" value={String(view.closureAttempts)} />
+							<Metric label="Closure rejections" value={String(view.closureRejections)} />
+							<Metric label="Validated" value={String(view.validatedCount)} />
+							<Metric label="Invalidated" value={String(view.invalidatedCount)} />
+							<Metric label="Span total" value={String(view.spanTotal)} />
+							<Metric label="Byte total" value={String(view.byteTotal)} />
+						</div>
+						<div className="mt-3 text-xs text-muted-foreground">
+							Reader-only closure/validation aggregate; staged in-memory this sprint.
+						</div>
+					</>
+				)}
+			</CardContent>
+		</Card>
+	);
+}

package/extensions/dashboard-client/src/tabs/VectorCortexTab.tsx

@@ -18,6 +18,8 @@ import {
 	fetchVectorCortexRender,
 	fetchVectorCortexRollout,
 	fetchVectorCortexClosureProof,
+	fetchVectorCortexRestore,
+	fetchVectorCortexRepair,
 	fetchVectorCortexShards,
 	fetchVectorCortexTopology,
 	resetVectorCortexBreaker,
@@ -30,6 +32,8 @@ import {
 	type VectorCortexRenderView,
 	type VectorCortexRolloutView,
 	type VectorCortexClosureProofView,
+	type VectorCortexRestoreView,
+	type VectorCortexRepairView,
 	type VectorCortexShardsView,
 	type VectorCortexTopologyView,
 } from "../api/vector-cortex";
@@ -39,6 +43,12 @@ import { Metric } from "./VectorCortexMetric";
 import { VectorCortexRenderCard } from "./VectorCortexRenderCard";
 import { VectorCortexRolloutCard } from "./VectorCortexRolloutCard";
 import { VectorCortexClosureCard } from "./VectorCortexClosureCard";
+import { VectorCortexRestoreCard } from "./VectorCortexRestoreCard";
+import { VectorCortexRepairCard } from "./VectorCortexRepairCard";
+import {
+	VectorCortexShardsCard,
+	VectorCortexReconstructCard,
+} from "./VectorCortexShardsCard";
 import { VectorCortexPlansCard } from "./VectorCortexPlansCard";
 import { VectorCortexTopologyCard } from "./VectorCortexTopologyCard";
 import { VectorCortexLedgerCard } from "./VectorCortexLedgerCard";
@@ -67,6 +77,8 @@ export default function VectorCortexTab(): React.ReactElement {
 	const [render, setRender] = useState<VectorCortexRenderView | null>(null);
 	const [rollout, setRollout] = useState<VectorCortexRolloutView | null>(null);
 	const [closureProof, setClosureProof] = useState<VectorCortexClosureProofView | null>(null);
+	const [restore, setRestore] = useState<VectorCortexRestoreView | null>(null);
+	const [repair, setRepair] = useState<VectorCortexRepairView | null>(null);
 
 	const poll = useCallback(() => {
 		fetchVectorCortexEvaluation()
@@ -105,6 +117,12 @@ export default function VectorCortexTab(): React.ReactElement {
 		fetchVectorCortexClosureProof().then(setClosureProof).catch(() => {
 			/* closure-optimization card is best-effort (VC6A) */
 		});
+		fetchVectorCortexRestore().then(setRestore).catch(() => {
+			/* exact-source-restoration card is best-effort (VC6B) */
+		});
+		fetchVectorCortexRepair().then(setRepair).catch(() => {
+			/* self-healing derived-state card is best-effort (VC6C) */
+		});
 	}, []);
 
 	useEffect(() => {
@@ -256,70 +274,14 @@ export default function VectorCortexTab(): React.ReactElement {
 				</CardContent>
 			</Card>
 			<VectorCortexTopologyCard topology={topology} query={query} />
-			<Card>
-				<CardHeader>
-					<div className="flex items-center justify-between">
-						<CardTitle>Dual-Tier Shards (VC4A)</CardTitle>
-						{shards?.enabled ? (
-							<Badge variant="success">ACTIVE</Badge>
-						) : (
-							<Badge variant="danger">OFF</Badge>
-						)}
-				</div>
-				</CardHeader>
-				<CardContent>
-					{!shards?.enabled ? (
-						<div className="vc-empty">Dual-tier shards disabled (VC4A off).</div>
-					) : (
-						<>
-							<div className="grid grid-cols-2 gap-4 md:grid-cols-4">
-								<Metric label="Semantic shards" value={String(shards.semanticCount)} />
-								<Metric label="Exact shards" value={String(shards.exactCount)} />
-								<Metric label="Byte total" value={String(shards.byteTotal)} />
-								<Metric label="Protected bytes" value={String(shards.protectedByteTotal)} />
-							</div>
-							<div className="mt-3 text-xs text-muted-foreground">
-								Reader-only count/byte aggregate; staged in-memory this sprint.
-							</div>
-						</>
-					)}
-				</CardContent>
-			</Card>
-			<Card>
-				<CardHeader>
-					<div className="flex items-center justify-between">
-						<CardTitle>Reconstruction Fidelity (VC4C)</CardTitle>
-						{reconstruct?.enabled ? (
-							<Badge variant="success">ACTIVE</Badge>
-						) : (
-							<Badge variant="danger">OFF</Badge>
-						)}
-					</div>
-				</CardHeader>
-				<CardContent>
-					{!reconstruct?.enabled ? (
-						<div className="vc-empty">Reconstruction fidelity disabled (VC4C off).</div>
-					) : (
-						<>
-							<div className="grid grid-cols-2 gap-4 md:grid-cols-4">
-								<Metric label="Closure attempts" value={String(reconstruct.closureAttempts)} />
-								<Metric label="Closure rejections" value={String(reconstruct.closureRejections)} />
-								<Metric label="Validated" value={String(reconstruct.validatedCount)} />
-								<Metric label="Invalidated" value={String(reconstruct.invalidatedCount)} />
-								<Metric label="Span total" value={String(reconstruct.spanTotal)} />
-								<Metric label="Byte total" value={String(reconstruct.byteTotal)} />
-							</div>
-							<div className="mt-3 text-xs text-muted-foreground">
-								Reader-only closure/validation aggregate; staged in-memory this sprint.
-							</div>
-						</>
-					)}
-				</CardContent>
-			</Card>
+			<VectorCortexShardsCard view={shards} />
+			<VectorCortexReconstructCard view={reconstruct} />
 			<VectorCortexPlansCard view={plans} />
 			<VectorCortexRenderCard view={render} />
 			<VectorCortexRolloutCard view={rollout} />
 			<VectorCortexClosureCard view={closureProof} />
+			<VectorCortexRestoreCard view={restore} />
+			<VectorCortexRepairCard view={repair} />
 			<VectorCortexLedgerCard ledger={ledger} />
 		</div>
 	);

package/extensions/dashboard-client/src/types/vector-cortex.ts

@@ -209,6 +209,39 @@ export interface VectorCortexRolloutView {
   updatedAt: string;
 }
 
+/**
+ * Reader-only exact-source-restoration view (VC6B). Counts + HEAL_RESTORE_*
+ * codes only — there is no payload endpoint, so no restored bytes, span ids,
+ * node ids, or ledger text ever reach the client.
+ */
+export interface VectorCortexRestoreView {
+  enabled: boolean;
+  mode: "A" | "B" | "C";
+  restoreAttempts: number;
+  restoredCount: number;
+  missingCount: number;
+  digestRejections: number;
+  lastRejection: string | null;
+  updatedAt: string;
+}
+
+/**
+ * Reader-only self-healing derived-state view (VC6C). Counts + HEAL_REPAIR_*
+ * codes only — there is no payload endpoint, so no subsystem source bytes, gap
+ * ranges, high-water marks, root digests, or ledger text ever reach the client.
+ */
+export interface VectorCortexRepairView {
+  enabled: boolean;
+  mode: "A" | "B" | "C";
+  repairAttempts: number;
+  repairsPlanned: number;
+  pointersSwitched: number;
+  backoffs: number;
+  lastBackoffMs: number | null;
+  lastFailure: string | null;
+  updatedAt: string;
+}
+
 /** Reader-only closure-optimization diagnostics view (VC6A). Aggregate only. */
 export interface VectorCortexClosureProofView {
   enabled: boolean;

package/extensions/dashboard-server/api-contracts/vector-cortex-heal.ts

@@ -41,3 +41,71 @@ export interface VectorCortexClosureProofView {
   /** ISO timestamp of the snapshot. */
   readonly updatedAt: string;
 }
+
+/**
+ * Reader-only exact-source-restoration diagnostics view for
+ * GET /api/vector-cortex/restore (VC6B).
+ *
+ * COUNTS + ERROR CODES ONLY. There is NO payload endpoint for restoration, ever:
+ * this view deliberately carries no restored bytes, span ids, node ids, byte
+ * ranges, shard identifiers, or ledger text (SECURITY_PRIVACY — the exact ledger
+ * is never rendered through a diagnostic surface). Only the restore counters and
+ * the last HEAL_RESTORE_* failure code are exposed; the per-span detail lives in
+ * the structured event log, not the dashboard.
+ */
+export interface VectorCortexRestoreView {
+  /** Whether the VC6B exact-source-restoration flag is enabled. */
+  readonly enabled: boolean;
+  /** Runtime triad mode: "A" exact shard, "B" ledger range scan, "C" loss disclosed. */
+  readonly mode: "A" | "B" | "C";
+  /** Total restore attempts observed (event counter). */
+  readonly restoreAttempts: number;
+  /** Spans restored with a verified SHA-256 digest (event counter). */
+  readonly restoredCount: number;
+  /** Spans with no exact source available (HEAL_RESTORE_SOURCE_MISSING). */
+  readonly missingCount: number;
+  /** Restores rejected by digest verification (HEAL_RESTORE_DIGEST_MISMATCH). */
+  readonly digestRejections: number;
+  /** Last rejection reason (a HEAL_RESTORE_* code), or null if none yet. */
+  readonly lastRejection: string | null;
+  /** ISO timestamp of the snapshot. */
+  readonly updatedAt: string;
+}
+
+/**
+ * Reader-only self-healing derived-state diagnostics view for
+ * GET /api/vector-cortex/repair (VC6C).
+ *
+ * COUNTS + ERROR CODES ONLY. Like the restore view, this surface deliberately
+ * carries no payload: no subsystem source bytes, no rebuilt derived rows, no
+ * subsystem names paired with their gap ranges, no high-water values, no root
+ * digests, and no ledger text (SECURITY_PRIVACY — a diagnostic surface never
+ * renders the authority's contents). Only the controller's rebuild counters,
+ * the backoff schedule's observable timing, and the last HEAL_REPAIR_* failure
+ * code are exposed; the per-subsystem gap detail lives in the structured event
+ * log, not the dashboard.
+ */
+export interface VectorCortexRepairView {
+  /** Whether the VC6C self-healing derived-controller flag is enabled. */
+  readonly enabled: boolean;
+  /**
+   * Runtime triad mode: "A" targeted single-subsystem rebuild, "B" full
+   * deterministic rebuild (ambiguous gap), "C" derived state disabled (both
+   * rebuild paths failed, or the controller is not running at all).
+   */
+  readonly mode: "A" | "B" | "C";
+  /** Total rebuild attempts started by the controller (event counter). */
+  readonly repairAttempts: number;
+  /** Rebuilds planned after gap detection, before rate limiting (counter). */
+  readonly repairsPlanned: number;
+  /** Rebuilds that reached a verified atomic pointer switch (counter). */
+  readonly pointersSwitched: number;
+  /** Attempts deferred by the rate limiter / exponential backoff (counter). */
+  readonly backoffs: number;
+  /** Most recent deterministic backoff delay in ms, or null if none yet. */
+  readonly lastBackoffMs: number | null;
+  /** Last failure reason (a HEAL_REPAIR_* code), or null if none yet. */
+  readonly lastFailure: string | null;
+  /** ISO timestamp of the snapshot. */
+  readonly updatedAt: string;
+}

package/extensions/dashboard-server/api-contracts/vector-cortex.ts

@@ -374,4 +374,8 @@ export interface VectorCortexLedgerView {
   readonly updatedAt: string;
 }
 
-export type { VectorCortexClosureProofView } from "./vector-cortex-heal.js";
+export type {
+  VectorCortexClosureProofView,
+  VectorCortexRestoreView,
+  VectorCortexRepairView,
+} from "./vector-cortex-heal.js";

package/extensions/dashboard-server/route-dispatch.ts

@@ -55,7 +55,11 @@ import {
 	handleVectorCortexRender,
 	handleVectorCortexRollout,
 	handleVectorCortexClosureProof,
+	handleVectorCortexRestore,
 } from "./routes.js";
+// VC6C repair lives in its own module (routes-vector-cortex-repair.ts) so the
+// heal route file stays well under the 400-line extension soft limit.
+import { handleVectorCortexRepair } from "./routes-vector-cortex-repair.js";
 
 /**
  * Dispatch a request through every registered route handler.
@@ -108,5 +112,7 @@ export function dispatchRoutes(
 	if (handleVectorCortexRender(req, res, ctx)) return true;
 	if (handleVectorCortexRollout(req, res, ctx)) return true;
 	if (handleVectorCortexClosureProof(req, res, ctx)) return true;
+	if (handleVectorCortexRestore(req, res, ctx)) return true;
+	if (handleVectorCortexRepair(req, res, ctx)) return true;
 	return false;
 }

package/extensions/dashboard-server/routes-rag-settings-vector-cortex.ts

@@ -144,5 +144,17 @@ export const VECTOR_CORTEX_SETTINGS: SettingGroup = {
 			"Advanced closure optimization: deterministically reduces the already-mandatory VC4C closure by transitive reduction over depends edges, emitting a ClosureProofV2 receipt per closure and a verifier that replays reductions against the conservative oracle (HEAL_PROOF_SET_MISMATCH on selected-set divergence). Protected edges (tool-pair / anchor / contradiction / sole-dependency) are never removed. The optimized selected set is byte-identical to the conservative closure. OFF = byte-identical predecessor (VC5C); arithmetic runs, only the reporter + dashboard seam is suppressed.",
 			true,
 		),
+		boolDirect(
+			"MEGACOMPACT_VC6B",
+			"VC6B Exact Source Restoration",
+			"Exact source restoration: restores the original bytes of closure spans ONLY from an exact shard (mode A) or a verified ledger range scan (mode B) — never inferred, reconstructed, or paraphrased from embeddings or semantic text. Requests are hard-bounded at 64 spans / 4MiB (HEAL_RESTORE_LIMIT); every span's SHA-256 is recomputed and bytes are inserted only after all requested span metadata validates, so a single bad span fails the whole request closed (HEAL_RESTORE_DIGEST_MISMATCH, HEAL_RESTORE_RANGE_MISMATCH). When no exact source exists (HEAL_RESTORE_SOURCE_MISSING) the old context is omitted and the loss is disclosed (mode C) rather than filled in. OFF = byte-identical predecessor (VC6A).",
+			true,
+		),
+		boolDirect(
+			"MEGACOMPACT_VC6C",
+			"VC6C Self-Healing Derived State",
+			"Self-healing derived-state controller: detects gaps between each derived subsystem's high-water mark and the durable authority high-water, then rebuilds derived state by copy -> root-digest verification -> atomic pointer switch, so a partially rebuilt subsystem is never made visible. A targeted single-subsystem rebuild is mode A; an ambiguous gap escalates to a full deterministic rebuild (mode B); if both rebuild paths fail the derived state is disabled rather than served stale (mode C). Rebuilds are rate-limited to one per subsystem per 5 minutes with deterministic exponential backoff, so a persistently failing subsystem cannot spin. OFF = byte-identical predecessor (VC6B); no controller runs, so the dashboard reports mode C.",
+			true,
+		),
 	],
 };

package/extensions/dashboard-server/routes-vector-cortex-heal.ts

@@ -1,6 +1,6 @@
 /**
- * dashboard-server/routes-vector-cortex-heal.ts — VC6A closure-optimization
- * dashboard route.
+ * dashboard-server/routes-vector-cortex-heal.ts — VC6A closure-optimization and
+ * VC6B exact-source-restoration dashboard routes.
  *
  * Reader-only GET /api/vector-cortex/closure-proof returning aggregate-only
  * closure diagnostics: whether the flag is enabled, the runtime triad mode, and
@@ -12,15 +12,22 @@
  * (the conservative VC4C closure, no reduction) — that is exactly the spec's
  * fallback rule — so `mode:"B"` + `enabled:false` is the byte-stable OFF view.
  *
+ * Reader-only GET /api/vector-cortex/restore (VC6B) returns restore COUNTS and
+ * HEAL_RESTORE_* error codes only. There is NO payload endpoint for restoration,
+ * ever — no restored bytes, span ids, node ids, byte ranges, or ledger text.
+ *
  * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
  * `any`), reader-only aggregate (counts + mode only).
  */
 
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteContext } from "./routes-core.js";
-import { VC6A_ENABLED } from "../../src/config.js";
+import { VC6A_ENABLED, VC6B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
-import type { VectorCortexClosureProofView } from "./api-contracts/vector-cortex.js";
+import type {
+  VectorCortexClosureProofView,
+  VectorCortexRestoreView,
+} from "./api-contracts/vector-cortex.js";
 
 /** Reader-only GET /api/vector-cortex/closure-proof (VC6A). */
 export function handleVectorCortexClosureProof(
@@ -54,3 +61,43 @@ export function handleVectorCortexClosureProof(
   sendJson(res, 200, body);
   return true;
 }
+
+/**
+ * Reader-only GET /api/vector-cortex/restore (VC6B).
+ *
+ * Counts and HEAL_RESTORE_* codes only — this is a static reader-only aggregate
+ * seam (same shape as the VC6A handler): there is no payload endpoint and never
+ * will be, so no restored bytes/span ids/node ids/ledger text can leak here.
+ */
+export function handleVectorCortexRestore(
+  req: IncomingMessage,
+  res: ServerResponse,
+  _ctx: RouteContext,
+): boolean {
+  const url = req.url ?? "";
+  const path = url.split("?")[0] ?? url;
+  if (path !== "/api/vector-cortex/restore") return false;
+  if (req.method !== "GET") {
+    sendJson(res, 405, { error: "method_not_allowed" });
+    return true;
+  }
+
+  const enabled = VC6B_ENABLED();
+  // Flag-off routes to mode C: with VC6B off there is no exact-restoration path
+  // at all, so the honest OFF view is the disclose-loss mode (old context is
+  // omitted rather than inferred) — mirroring how VC6A's OFF view reports the
+  // conservative fallback it actually takes.
+  const mode: "A" | "B" | "C" = enabled ? "A" : "C";
+  const body: VectorCortexRestoreView = {
+    enabled,
+    mode,
+    restoreAttempts: 0,
+    restoredCount: 0,
+    missingCount: 0,
+    digestRejections: 0,
+    lastRejection: null,
+    updatedAt: new Date().toISOString(),
+  };
+  sendJson(res, 200, body);
+  return true;
+}

package/extensions/dashboard-server/routes-vector-cortex-repair.ts

@@ -0,0 +1,72 @@
+/**
+ * dashboard-server/routes-vector-cortex-repair.ts — VC6C self-healing
+ * derived-state dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/repair returning the self-healing
+ * controller's aggregate diagnostics: whether the flag is enabled, the runtime
+ * triad mode, cumulative rebuild/pointer-switch/backoff counters, the last
+ * deterministic backoff delay, and the last HEAL_REPAIR_* failure code.
+ *
+ * COUNTS + ERROR CODES ONLY. NEVER exposes subsystem source bytes, rebuilt
+ * derived rows, per-subsystem gap ranges, high-water marks, root digests, or
+ * ledger text (reader-only, SECURITY_PRIVACY — the per-subsystem gap detail
+ * lives in the structured event log, not the dashboard). There is no mutation
+ * seam here either: rebuilds are driven by the controller's own gap detection,
+ * never by a dashboard request, so non-GET is rejected outright.
+ *
+ * Split into its own file (rather than grown into routes-vector-cortex-heal.ts)
+ * to keep every extensions/ file well under the 400-line soft-as-hard limit.
+ *
+ * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
+ * `any`), reader-only aggregate (counts + codes only).
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import { VC6C_ENABLED } from "../../src/config.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+import type { VectorCortexRepairView } from "./api-contracts/vector-cortex.js";
+
+/**
+ * Reader-only GET /api/vector-cortex/repair (VC6C).
+ *
+ * Counts and HEAL_REPAIR_* codes only — this is a static reader-only aggregate
+ * seam (same shape as the VC6A/VC6B handlers): there is no payload endpoint and
+ * never will be, so no subsystem bytes, gap ranges, high-water marks, or root
+ * digests can leak here.
+ */
+export function handleVectorCortexRepair(
+  req: IncomingMessage,
+  res: ServerResponse,
+  _ctx: RouteContext,
+): boolean {
+  const url = req.url ?? "";
+  const path = url.split("?")[0] ?? url;
+  if (path !== "/api/vector-cortex/repair") return false;
+  if (req.method !== "GET") {
+    sendJson(res, 405, { error: "method_not_allowed" });
+    return true;
+  }
+
+  const enabled = VC6C_ENABLED();
+  // Flag-off routes to mode C: with VC6C off no self-healing controller runs at
+  // all, so neither the targeted rebuild (mode A) nor the full deterministic
+  // rebuild (mode B) path is available. Mode C is exactly the spec's "derived
+  // state disabled" outcome — the honest OFF view is that derived state is not
+  // being healed, rather than implying a rebuild path that is not wired.
+  // Mirrors how VC6B's OFF view reports the disclose-loss mode it actually takes.
+  const mode: "A" | "B" | "C" = enabled ? "A" : "C";
+  const body: VectorCortexRepairView = {
+    enabled,
+    mode,
+    repairAttempts: 0,
+    repairsPlanned: 0,
+    pointersSwitched: 0,
+    backoffs: 0,
+    lastBackoffMs: null,
+    lastFailure: null,
+    updatedAt: new Date().toISOString(),
+  };
+  sendJson(res, 200, body);
+  return true;
+}

package/extensions/dashboard-server/routes-vector-cortex.ts

@@ -9,6 +9,8 @@
  *   VC0C health/reset-> routes-vector-cortex-health.ts(GET  /health, POST /breakers/reset)
  *   VC1B ledger      -> routes-vector-cortex-ledger.ts (GET  /ledger)
  *   VC3A topology    -> routes-vector-cortex-topology.ts(GET /topology)
+ *   VC6A closure     -> routes-vector-cortex-heal.ts   (GET  /closure-proof)
+ *   VC6B restore     -> routes-vector-cortex-heal.ts   (GET  /restore)
  *
  * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
  * `any`), reader-only aggregates (never payloads/prompts/ledger text).
@@ -25,4 +27,7 @@ export { handleVectorCortexReconstruct } from "./routes-vector-cortex-reconstruc
 export { handleVectorCortexPlans } from "./routes-vector-cortex-plans.js";
 export { handleVectorCortexRender } from "./routes-vector-cortex-render.js";
 export { handleVectorCortexRollout } from "./routes-vector-cortex-rollout.js";
-export { handleVectorCortexClosureProof } from "./routes-vector-cortex-heal.js";
+export {
+	handleVectorCortexClosureProof,
+	handleVectorCortexRestore,
+} from "./routes-vector-cortex-heal.js";

package/extensions/dashboard-server/routes.ts

@@ -54,4 +54,5 @@ export {
 	handleVectorCortexRender,
 	handleVectorCortexRollout,
 	handleVectorCortexClosureProof,
+	handleVectorCortexRestore,
 } from "./routes-vector-cortex.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.8",
+  "version": "0.20.10",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",

package/src/config/vector-cortex.ts

@@ -227,6 +227,37 @@ export const VC5C_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC5C");
  */
 export const VC6A_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC6A");
 
+/**
+ * VC6B — exact source restoration. Default ON. `MEGACOMPACT_VC6B=0` disables and
+ * is byte-identical to the predecessor (VC6A): the `restoreSources` /
+ * `verifyRestored` arithmetic STILL RUNS (it is PURE — an exact-source read plus
+ * a SHA-256 comparison, with no clock, storage, or network), but the
+ * `vector_cortex_source_restored` / `vector_cortex_restore_digest_rejected`
+ * events are never emitted and the dashboard restoration diagnostics seam is
+ * suppressed. Flag OFF gates the reporter + dashboard seam, never the
+ * restore/verify arithmetic, so flag-off outbound/predecessor golden bytes match
+ * exactly. This flag MUST also be a dashboard SETTINGS toggle (visible in config
+ * UI, never in EXCLUDED_SETTINGS), mirroring VC4A/VC4B/VC4C/VC5A/VC5B/VC5C/VC6A.
+ */
+export const VC6B_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC6B");
+
+/**
+ * VC6C — self-healing derived controller. Default ON. `MEGACOMPACT_VC6C=0`
+ * disables and is byte-identical to the predecessor (VC6B): the `detectGaps` /
+ * `planRebuild` / `rebuildGeneration` / `switchPointer` arithmetic STILL RUNS (it
+ * is PURE — a high-water comparison plus a SHA-256 root-digest check, with an
+ * INJECTED clock and no storage or network), but the
+ * `vector_cortex_repair_planned` / `vector_cortex_repair_pointer_switched` /
+ * `vector_cortex_repair_backoff` events are never emitted and the dashboard
+ * repair diagnostics seam is suppressed. Flag OFF gates the reporter + dashboard
+ * seam, never the gap-detection/rebuild arithmetic (in particular, an unverified
+ * pointer switch stays refused with the flag off), so flag-off
+ * outbound/predecessor golden bytes match exactly. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A/VC4B/VC4C/VC5A/VC5B/VC5C/VC6A/VC6B.
+ */
+export const VC6C_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC6C");
+
 // ---------------------------------------------------------------------------
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker).
 // Rolled numbers for one 60s window; VC0C consumes these at its breaker seam.

package/src/config.ts

@@ -170,6 +170,8 @@ export {
   VC5B_ENABLED,
   VC5C_ENABLED,
   VC6A_ENABLED,
+  VC6B_ENABLED,
+  VC6C_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,