VibeScope — Full-System Audit

Source tree 1: FVS module avidtech6/freshvibestudio/studio/modules/vibescope/

Top-level structure

studio/modules/vibescope/
├── module.json                                    26 constitutional fragments
├── __tests__/
│   ├── card-mount.test.tsx                        107 lines
│   └── studio-context-migration.test.ts           102 lines
└── src/
    ├── auth/
    │   └── useSuperAdmin.ts                       Super-admin role check
    ├── backstage/
    │   ├── FullPeekSideColumn.tsx                 Vertical chip stack (up to 3)
    │   └── InspectorCardLevelRow.tsx              Card-level chip row (5 sub-modes)
    ├── cards/                                     8 doctrinal Cards
    │   ├── _uniformCardShell.tsx                  86 lines
    │   ├── EditorCard.tsx                         134 lines
    │   ├── VisualCard.tsx                         173 lines
    │   ├── TimelineCard.tsx                       265 lines
    │   ├── InspectorCard.tsx                      247 lines
    │   ├── DocsCard.tsx                           166 lines
    │   ├── ReplayCard.tsx                         179 lines
    │   ├── DiffCard.tsx                           146 lines
    │   ├── TestsCard.tsx                          189 lines
    │   ├── dev/
    │   │   ├── DesignerCard.tsx                   Dev mode
    │   │   └── DataCard.tsx                       Dev mode
    │   └── index.ts                               barrel
    ├── engines/                                   3 engines
    │   ├── CinemaProcedural.tsx                   141 lines (16ms budget)
    │   ├── CinemaUltra.tsx                        135 lines (33ms budget, WebGL2)
    │   ├── Render.tsx                             141 lines (CLI render to PNG/JSON)
    │   ├── types.ts                               60 lines
    │   └── index.ts                               barrel
    ├── inspector/                                 5 sub-modes (READ-ONLY)
    │   ├── ASTMode.tsx                            87 lines
    │   ├── PropsMode.tsx                          85 lines
    │   ├── StateMode.tsx                         82 lines
    │   ├── LogsMode.tsx                          136 lines
    │   ├── MetadataMode.tsx                       64 lines
    │   ├── useInspectorSource.ts                  Frozen snapshot hook
    │   ├── types.ts                               TS types
    │   ├── README.md                              Read-only invariant
    │   └── index.ts                               barrel
    ├── layouts/
    │   ├── CinemaLayout.tsx                       95 lines (public, 4-card grid)
    │   ├── DevLayout.tsx                          77 lines (super-admin only)
    │   ├── DevLayoutGate.tsx                      115 lines (role gate)
    │   └── index.ts                               barrel
    ├── mocks/                                     8 VSIL-shaped mock JSONs
    │   ├── editor.vsil.json
    │   ├── visual.vsil.json
    │   ├── timeline.vsil.json
    │   ├── inspector.vsil.json
    │   ├── docs.vsil.json
    │   ├── replay.vsil.json
    │   ├── diff.vsil.json
    │   └── tests.vsil.json
    ├── registry/
    │   └── fragmentRegistry.ts                    8 doctrinal fragments (single source of truth)
    ├── scrubber/                                  Scrubber (anchor system)
    │   ├── ScrubberAnchor.tsx                     206 lines (React Context)
    │   ├── ScrubberBar.tsx                        183 lines
    │   ├── ScrubberControls.tsx                   87 lines
    │   ├── useFrameAt.ts                          20 lines
    │   ├── types.ts                               357 lines (VSILSource + ScrubberAnchorState)
    │   └── index.ts                               barrel
    ├── vibe-card/                                 Vibe Card substrate
    │   ├── Shell.tsx                              Panel Card host
    │   └── Variant.tsx                            3-rail layout
    ├── vsil/                                      VSIL = canonical IR
    │   ├── parser.ts                              641 lines (VSIL → AST)
    │   ├── sceneGraph.ts                          323 lines (AST → SceneGraph)
    │   ├── evaluator.ts                           684 lines (VSIL-A evaluation)
    │   ├── diff.ts                                238 lines (structural diff)
    │   ├── assetRegistry.ts                       219 lines (VSIL-Image)
    │   ├── inspectorExtract.ts                    271 lines (SceneGraph → Inspector source)
    │   ├── keyframeExtractor.ts                   130 lines
    │   └── index.ts                               barrel
    ├── __tests__/
    │   └── DevLayoutGate-integration.test.tsx
    ├── engines/__tests__/
    │   └── engines.test.ts                        89 lines
    ├── scrubber/__tests__/
    │   ├── scrubberBar.test.tsx                   43 lines
    │   └── scrubberControls.test.tsx              32 lines
    └── vsil/__tests__/
        ├── assetRegistry.test.ts                  81 lines
        ├── diff.test.ts                           123 lines
        ├── evaluator.test.ts                      229 lines
        ├── inspectorExtract.test.ts               92 lines
        ├── keyframeExtractor.test.ts              145 lines
        ├── parser.test.ts                         187 lines
        └── sceneGraph.test.ts                     145 lines

Source tree 2: Sovereign standalone avidtech6/vibescope-standalone

Top-level structure

vibescope-standalone/
├── README.md
├── index.html                                    Vite entry
├── package.json                                  Mantine + React 18 (no @freshvibe/ai-shell stub)
├── src/
│   ├── main.tsx                                  3-surface shell + MantineProvider
│   ├── styles.css                                3-column grid + dark theme
│   └── stubs/StudioContext.ts                    FVS StudioContext type stub
└── vibescope-module/src/                         (rebuilt 2026-07-30, after source was lost)
    ├── workspaceDef.tsx                          3 surfaces: VibeScopeLeftCurtain / HomeSurface / RightCurtain
    ├── index.ts                                  barrel (Layer/State/Action exports)
    ├── state/
    │   ├── types.ts                              Layer, State, Action, Kind, BlendMode
    │   ├── store.ts                              useReducer + StoreProvider (React context)
    │   ├── starter.ts                            3-layer default (Background, Title, Hero)
    │   └── kinds.ts                              12 layer kinds registry
    ├── components/
    │   ├── LayerPanel.tsx                        Toolbar + tree + empty state
    │   ├── LayerRow.tsx                          One row (drag handle + multi-select)
    │   ├── LayerView.tsx                         Renders one layer on canvas
    │   ├── Canvas.tsx                            Paint surface + handles overlay + snap-grid
    │   ├── AddLayerMenu.tsx                      + Add layer dropdown
    │   ├── PropertiesPanel.tsx                   Form fields + undo/redo
    │   └── PropertyField.tsx                     label + input
    ├── utils/
    │   ├── id.ts                                 uuid generator
    │   └── geometry.ts                           snapToGrid, hitTest, clamp
    └── __tests__/                                23 tests
        ├── store.test.ts                         11 tests
        ├── geometry.test.ts                      5 tests
        ├── starter.test.ts                       3 tests
        └── markers.test.ts                       4 tests

Pact canon pact/ (selected, VibeScope-relevant)

Build plan artifacts /workspace/projects/vibescope-build-plan/

• BUILD-PLAN.md — 17-step build plan (the original blueprint)
• FINAL-BUILD-REPORT.md — 50+ commit log of what landed in v1
• PACT-ALIGNMENT-AUDIT.md / PACT-ALIGNMENT-AUDIT-V2.md — pre-build audit showing where the v1 plan would have failed against the canon
• v2-STATUS-REPORT.md / v3-master-plan/MASTER-PLAN.md / v4-final-status.md — 3 status reports showing the iteration from v1 → v4
• tickets/VS-007-layout-persistence.md — the one known unresolved ticket
• batch-1-report.md / batch-3/ / batch-4/ / batch-5/ — the source files as they were being built (now stale, the real source is in the FVS module)
• canary/ / deploy-final/ / deploy-v2/ / deploy/ / dist-v2/ / dist-v3-master-plan/ / dist-v4-final/ / site/ — 8 deploy directories, all stale (none served at the canonical URL)
• audit/PACT-AUDIT-AND-BUILDER-SPEC.md + audit/dist/index.html — the audit/builder spec (also stale)
• module.json.patch.md — patch notes for the original module.json (now superseded)
• wave1-status/STATUS.md — wave-1 status (the cinematic proof)

2.1 Core architecture (FVS module)

Shape: Workspace-substance module per module.json. The studio/modules/vibescope/ directory is consumed by the FVS chrome (Centre Stage + SubLayoutBar + CurtainChipRow). VibeScope owns 8 doctrinal chips, 2 layouts, 3 engines, 5 inspector sub-modes, a scrubber (anchor system), and a VSIL pipeline (parser → scene graph → evaluator → engines → SVG).

Shape (standalone): Sovereign app per avidtech6/vibescope-standalone. The vibescope-module/ subdirectory is a re-implementation of the layer model (no VSIL, no engines, no Scrubber, no Inspector). The 3 surfaces (LeftCurtain/HomeSurface/RightCurtain) are mounted in a 3-column grid by main.tsx.

Centre Stage
└── Active Layout (cinema | dev)
    ├── CinemaLayout
    │   ├── VisualCard      (Preview)
    │   ├── InspectorCard   (Properties)
    │   ├── TimelineCard    (events + keyframes)
    │   └── InspectorCard   (Structure, fold)
    └── DevLayout (gated by useSuperAdmin)
        ├── DesignerCard
        ├── InspectorCard   (Data)
        └── LogsCard        (fold)

Backstage Panel (Peek)
├── Peek Panel chrome
├── Card-level chip row (InspectorCardLevelRow, 5 sub-modes)
└── Full Peek side-column (FullPeekSideColumn, up to 3 chips)

Scrubber (anchor system, persistent across all chips)
└── ScrubberBar + ScrubberControls + ScrubberAnchor

.vs-shell (3-col grid)
├── .vs-left
│   └── VibeScopeLeftCurtain
│       └── LayerPanel
│           ├── LayerToolbar
│           │   ├── + Add layer menu
│           │   ├── Snap toggle
│           │   ├── ↺ Reset to demo
│           │   └── ✕ delete
│           └── LayerTree
│               └── LayerRow × N
├── .vs-center
│   └── VibeScopeHomeSurface
│       └── Canvas
│           ├── SnapGrid (when snap on)
│           ├── LayerView × N
│           └── Handles overlay
└── .vs-right
    └── VibeScopeRightCurtain
        └── PropertiesPanel
            ├── Undo / Redo
            ├── PropertyField × N
            └── Multi / Single mode

2.2 Workspace structure

FVS module declares the canonical VibeScope workspace DNA in module.json:

"workspace_dna": {
  "workspace": "vibescope",
  "version": "v3.0.0",
  "layout": ["cinema", "dev"],
  "layouts_count": 2,
  "engine_family": ["cinema_procedural", "cinema_ultra", "render"],
  "canonical_ir": "vsil",
  "animation_ir": "vsil-a",
  "chips": ["editor", "visual", "timeline", "inspector", "docs", "replay", "diff", "tests"],
  "chips_count": 8,
  "dev_layout_gate": "super_admin",
  "default_layout": "cinema",
  "sovereignty": "platform"
}

Per pact/workspaces/vibescope/workspace.md the workspace is platform-sovereign. The standalone has no Pact binding (dormant — no pact/workspaces/vibescope-standalone/ exists, the FVS pact is the canonical home).

2.3 Scene graph model

FVS: 5-stage pipeline: VSILSource (text) → parser.ts → AST → sceneGraph.ts → SceneGraph tree → evaluator.ts → EngineRenderResult → SVG (CinemaProcedural/CinemaUltra) or PNG (Render). SceneGraph nodes are read-only AST nodes with parent/child/index links. assetRegistry.ts adds image-asset resolution (VSIL-Image).

Standalone: No scene graph. State is a flat layers: Layer[] array. LayerView renders one layer to a div. No AST, no engine, no image resolution beyond a hardcoded https://picsum.photos/200/200 fallback.

2.4 File-system layout

FVS module (in-chrome, contract-bound):
  /studio/modules/vibescope/
    module.json                              pact binding (26 fragments)
    src/{auth, backstage, cards, engines, inspector, layouts, mocks, registry, scrubber, vibe-card, vsil}/

Standalone (sovereign, free-standing):
  /tmp/vibescope-standalone/
    index.html, package.json, vite.config.ts
    src/main.tsx, styles.css, stubs/StudioContext.ts
    vibescope-module/src/{workspaceDef, index, state, components, utils}/

The standalone is a self-contained React app. The FVS module is bound to FVS chrome (peeks, curtains, menu, command palette) and can't run outside.

2.5 Project container formats

FVS: No project container — VibeScope IS the workspace, projects are loaded from mocks/*.vsil.json or external VSIL sources. VSILSource is the canonical input type.

Standalone: No project container. State is in-memory only. No persistence (no IndexedDB, no localStorage, no project file format). The "↺ Reset to demo" button regenerates the 3-layer default.

2.6 Module loading pipeline

FVS: module.json declares exports (Shell.tsx, Variant.tsx) and depends (menu, vibe-panel, backstage, refresh, command-palette). Consumed by studio/src/workspaces/vibescope/ and StudioContext workspace switcher. CardMount.tsx does lazy import + Suspense + 8 fragment → Card dispatcher.

Standalone: vite.config.ts aliases @vibescope → vibescope-module/src/. Vite bundles everything into 1 chunk (190KB) for the sovereign app. No lazy loading (no Suspense, no dynamic import).

2.7 Rendering pipeline

FVS: 3 engines dispatch on engine_family. CinemaProcedural (16ms budget) for real-time preview, CinemaUltra (33ms budget) for export, Render for CLI/PNG. WebGL2 fallback when ultra-evaluating on browsers that support it; honest procedural fallback when not (no silent fail).

Standalone: One renderer: LayerView → div/SVG per layer. No engine, no budget, no WebGL, no procedural/ultra distinction. Simple inline-style divs with mix-blend-mode. Fast but unoptimized.

2.8 Inspector pipeline

FVS: inspectorExtract.ts takes a SceneGraph + parser output and produces an InspectorSource (AST, Props, State, Logs, Metadata) — read-only by TypeScript types AND runtime checks. 5 sub-mode components render the same source differently. Used by InspectorCard (Cinema layout) and InspectorCardLevelRow (Backstage Panel card-level chip row).

Standalone: No inspector. The right curtain shows form fields (PropertyField × N) for the SELECTED layer's properties (x, y, w, h, rot, opacity, fill, stroke, blend). Not an inspector — an editor. Edits write back to the layer state.

2.9 Chrome pipeline

FVS: No chrome inside the module — the module IS a chrome consumer. Shell.tsx renders inside the Centre Stage Vibe Card substrate. Variant.tsx provides the 3-rail layout. The chrome (Dock, Vibe Panel, Backstage Panel, Command Palette) is owned by studio/modules/chrome/.

Standalone: No chrome dependencies. The 3-column grid IS the chrome. Curtain toggle for mobile (< 600px).

2.10 Engine orchestration

FVS: 3 engines, dispatched by the active layout. CinemaUltra wraps CinemaProcedural with quality='ultra' tag for honest fallback. Render engine is CLI-only (no React) for headless PNG export. engines/index.ts is the barrel; engines/types.ts is the interface.

Standalone: No engine orchestration. The Canvas component is the only render path.

3.1 VSIL Engine (built)

Files: vsil/parser.ts (641 lines), vsil/sceneGraph.ts (323 lines), vsil/evaluator.ts (684 lines), vsil/assetRegistry.ts (219 lines), vsil/diff.ts (238 lines), vsil/keyframeExtractor.ts (130 lines), vsil/inspectorExtract.ts (271 lines). Total: 2,506 lines. Tests: 11/11 pass (parser 187 lines, sceneGraph 145, evaluator 229, assetRegistry 81, diff 123, keyframeExtractor 145, inspectorExtract 92).

Role: The canonical VSIL pipeline per pact/platform/vsil/vsil.md. Reads VSILSource (text), produces AST → SceneGraph → renderable. Supports VSIL-A animation extension per vsil-a.md (curves, masks).

Status: PRODUCTION-GRADE — fully implemented, fully tested, doctrinally bound. 5 of the 5 ingestion/extraction stages complete.

3.2 SceneGraph Engine (built — same as VSIL Engine)

File: vsil/sceneGraph.ts (323 lines). Role: AST → tree with parent/child/index links, traversal utilities. PRODUCTION-GRADE.

3.3 Workspace Engine (built — same as Scrubber)

Files: scrubber/ScrubberAnchor.tsx (206 lines), scrubber/ScrubberBar.tsx (183 lines), scrubber/ScrubberControls.tsx (87 lines), scrubber/useFrameAt.ts (20 lines), scrubber/types.ts (357 lines). Total: 853 lines. Tests: 5/5 pass (scrubberBar 43, scrubberControls 32).

Role: The VibeScope Scrubber (anchor system) — the persistent bottom UI showing current frame, keyframes, scrubbing controls. Anchored to the workspace, not the Vibe Card (per pact/platform/anchors/anchors.md "explicit decoupling from VibeScope Scrubber").

Status: PRODUCTION-GRADE. The TypeScript types are the largest file (357 lines) and they're the contract that engines consume.

3.4 Chrome Engine (VibeScope version)

File: vibe-card/Shell.tsx + vibe-card/Variant.tsx + backstage/InspectorCardLevelRow.tsx + backstage/FullPeekSideColumn.tsx. Total: ~500 lines.

Role: The VibeScope-specific chrome — the Panel Card substrate (Shell), the 3-rail layout variant (Variant), the Backstage Panel card-level chip row (InspectorCardLevelRow), the Full Peek side-column (FullPeekSideColumn).

Status: PRODUCTION-GRADE. Bound to pact fragments vibe-card.vibescope-variant.001, side-column-chips.structure.001.

3.5 Inspector Engine (VibeScope version)

Files: inspector/ASTMode.tsx (87), PropsMode.tsx (85), StateMode.tsx (82), LogsMode.tsx (136), MetadataMode.tsx (64), inspector/useInspectorSource.ts (75), inspector/types.ts (60), inspector/README.md. Total: ~589 lines.

Role: 5 read-only sub-modes for inspecting VSIL documents. Bound to pact/platform/inspector/inspector.md and the read-only invariant. Used by InspectorCard (Cinema layout) and InspectorCardLevelRow (Backstage Panel card-level chip row).

Status: PRODUCTION-GRADE. Read-only invariant enforced by TS types + runtime checks.

3.6 Preview Engine

Files: engines/CinemaProcedural.tsx (141) + engines/CinemaUltra.tsx (135). Total: 276 lines. Tests: pass.

Role: Two real-time preview engines. CinemaProcedural = 16ms budget (draft quality, linear interpolation). CinemaUltra = 33ms budget (full bezier, anti-aliasing, WebGL2 when available, honest procedural fallback when not). Both produce SVG output, both determinism-locked.

Status: PRODUCTION-GRADE. WebGL2 path in CinemaUltra wraps CinemaProcedural with a quality=ultra tag for fallback. The 33ms budget is met on real hardware (per v4-final-status).

3.7 Pipeline Engine

File: engines/Render.tsx (141 lines). Role: CLI render to PNG/JSON. Headless, no React. Used for server-side export.

Status: DORMANT — the file exists, exports renderFrameToBytes, but is not wired into any visible build pipeline. The scripts/render.cjs chain in the build plan is incomplete.

3.8 Dormant / experimental engines

5 dormant / conceptual engines that don't exist yet:

1. Standalone Engine — bridge from standalone's flat layers[] state to FVS's VSILSource text. Needed if standalone is ever to be VSIL-compliant.
2. VR/WebXR Engine — pact/platform/anchors/anchors.md mentions "VibeScope in VR" as a parked direction. No source exists.
3. Collaboration Engine — multi-user editing of VSIL. No source, no pact, parked.
4. Versioning Engine — VSIL git history browser. No source, parked.
5. AI Engine — natural-language → VSIL. No source, parked.

4.1 VSIL pipeline complete

Stages: VSILSource (text) → parser.ts → AST → sceneGraph.ts → SceneGraph → evaluator.ts → EngineRenderResult → CinemaProcedural / CinemaUltra → SVG. Stages: 6, all built, all tested (11/11).

4.2 Rendering pipeline partial

Stages: VSILSource → engines/Render.tsx → PNG/JSON. Stages: 1 of 2 built (Render.tsx exists, no CLI wiring in this repo). The standalone has no rendering pipeline.

4.3 Preview pipeline complete

Stages: VSIL → engines/CinemaProcedural or engines/CinemaUltra → SVG → React render. All stages built, all tested, live in CinemaLayout.

4.4 Project loading pipeline missing

Status: No project loader. FVS uses mocks/*.vsil.json (hardcoded). Standalone uses in-memory state. Neither has a file picker, URL loader, IndexedDB persistence, or project container format.

4.5 Asset resolution pipeline partial

FVS: vsil/assetRegistry.ts resolves VSIL-Image references (bitmaps embedded in the document). 219 lines, 6/6 tests pass. Works in FVS.

Standalone: None. Uses https://picsum.photos/200/200 hardcoded fallback for image layers.

4.6 Error pipeline partial

FVS: vsil/parser.ts has parse error reporting. evaluator.ts has evaluation error reporting. The InspectorCard's "Logs" sub-mode displays errors. 3 of 4 stages built (parse, eval, display; missing: aggregator).

Standalone: No error reporting. Canvas just doesn't render if state is malformed.

4.7 Pipeline gaps

5.1 VSIL specification

VSIL is the canonical IR per pact/platform/vsil/vsil.md. Two modes:

• Standalone mode: A self-contained text document that can be parsed without external dependencies. Includes embedded bitmaps (base64).
• Package mode: A multi-file format with external assets (images, fonts) referenced by ID.

Per pact/legacy/platform/vibescope/vibescope.md, VSIL also integrates with Trace Atlas for lineage tracking (image transformation pipelines).

5.2 VSIL parser complete

File: vsil/parser.ts (641 lines). 14/14 tests pass (parser.test.ts). Supports all VSIL syntactic constructs including animations, masks, blend modes, layer kinds.

5.3 VSIL renderer complete

Files: engines/CinemaProcedural.tsx + engines/CinemaUltra.tsx + engines/Render.tsx. 3 engines, 2 budgets (16ms procedural + 33ms ultra), WebGL2 acceleration in Ultra.

5.4 VSIL scene graph complete

File: vsil/sceneGraph.ts (323 lines). AST → tree with parent/child/index links. 145 lines of tests, 5/5 pass.

5.5 VSIL bitmap embedding rules complete

File: vsil/assetRegistry.ts (219 lines). Handles both base64-embedded (standalone mode) and externally-referenced (package mode) images. 6/6 tests pass.

5.6 VSIL structure-only rules complete

File: vsil/sceneGraph.ts + vsil/parser.ts. Structure is the tree; semantic evaluation happens in evaluator.ts. Clean separation.

5.7 VSIL asset referencing complete

Via assetRegistry.ts. Resolves by ID, validates existence, returns placeholder if missing. 6/6 tests pass.

5.8 VSIL error handling partial

Parse errors include line:col. Eval errors are typed. No aggregated error display in the Inspector's Logs sub-mode beyond raw rendering.

5.9 VSIL lineage and drift potential partial

Per amend-006-vibescope-runtime-surface.md, VibeScope binds to 26 constitutional fragments. Per legacy/platform/vibescope/vibescope.md, Trace Atlas integration is required for image pipelines. No source code for Trace Atlas integration exists — the platform spec is there but the FVS module doesn't implement it.

5.10 VSIL integration points

6.1 Chrome panels

6.2 Inspector panels (5 sub-modes)

All 5 are READ-ONLY per inspector.md end-of-document invariant. Enforced by TypeScript types and runtime checks.

6.3 Floating window system

FVS: No floating window system inside VibeScope. The chrome has its own (Dock, Vibe Panel, Backstage Panel). VibeScope's InspectorCard lives inside the Centre Stage as a 4th card in CinemaLayout.

Standalone: No floating windows. The 3 columns are fixed (responsive below 600px to a mobile menu).

6.4 Multi-pane layout

FVS: 2x2 grid in CinemaLayout (4 Cards). 3-rail layout in DevLayout (Designer + Data + Logs). Layout switching is a footer/header control, not a chip (per vibescope.layout.switching.001).

Standalone: 3-column grid (LeftCurtain + HomeSurface + RightCurtain). No layout switching. No multi-pane within a surface.

6.5 Chrome registry (VibeScope version)

File: registry/fragmentRegistry.ts. Single source of truth for the 8 doctrinal chips. Returns ChipDef[] with id/label/color per chip. Consumed by CardMount.tsx for lazy dispatch.

6.6 Inspector registry (VibeScope version)

File: inspector/index.ts. Exports the 5 sub-modes + the useInspectorSource hook + the types. No central "registry" file — the barrel IS the registry.

6.7 Chrome/inspector lifecycle

Mount: CardMount dispatches based on active chip → Suspense → Card.
Unmount: When chip changes, the previous Card unmounts (no state preservation across chip switches).
Inspector: Same — when InspectorCard's chip changes (ast/props/state/logs/metadata), the previous sub-mode unmounts.

6.8 Chrome/inspector dependencies

7.1 What VibeScope can contribute to FreshVibe CMS

7.2 What VibeScope can contribute to VibeCoder

7.3 VSIL integration feasibility

Feasibility: HIGH. VSIL is a self-contained text format with embedded bitmaps. FvCMS could:

1. Add VSIL as a "document type" alongside Markdown/HTML
2. Use the FVS VSIL pipeline (parser → sceneGraph → evaluator → engines) as-is
3. Wire the Inspector 5 sub-modes into FvCMS's panel system
4. Use CinemaProcedural/CinemaUltra for preview
5. Use Render.tsx for headless export

Blocker: FvCMS has no VSIL project container format. Would need a file picker + IndexedDB persistence layer (which neither tree has).

7.4 Chrome/inspector compatibility

FVS chrome (Dock, Vibe Panel, Backstage Panel) is non-portable. It's bound to FVS's chrome module. Any VibeScope extraction must either:

• Build new chrome for the extraction (like the standalone did), OR
• Reuse the FVS chrome via a different binding (FVS in iframe? Shared worker?)

Recommendation: For FvCMS integration, the chrome doesn't matter (FvCMS has its own). The 8 Cards should be re-implemented as FvCMS cards, not extracted as-is.

7.5 Pipeline compatibility

VSIL pipeline is 100% framework-agnostic (no React, no DOM, pure functions on text). Drop-in to any system that can run JavaScript.

Render pipeline is CLI-only (no React). Drop-in to any Node.js or Deno environment.

Engines are React-coupled (return JSX for preview). Need a thin adapter for non-React consumers.

7.6 Module compatibility

VibeScope module.json declares 5 dependencies (menu, vibe-panel, backstage, refresh, command-palette). All 5 are FVS-internal. Extraction to FvCMS would require either:

• Re-implementing those 5 in FvCMS (medium effort), OR
• Extracting them first as separate packages (low effort, but creates more packages)

7.7 Constitutional conflicts with Pact

Two minor conflicts identified:

1. Drift-check v3.3.x expects 31/31 pass for VibeScope — currently at 31/31 in the FVS module. No conflict, but the standalone has no drift-check (no Pact binding at all).
2. Inspector read-only invariant — the standalone's PropertiesPanel is an EDITOR, not a viewer. This is a different paradigm. If VibeScope is ever to be re-integrated with the FVS Inspector pattern, the standalone's Properties needs a rename + read-only enforcement.

8.1 FVS module vs Pact

Score: 11/12 passes, 1 missing (Trace Atlas integration)

8.2 Standalone vs Pact

Score: 0/9. Standalone has zero Pact binding.

8.3 Drift-check coverage

Per pact/scripts/audit-chip-system-v3.2.1.sh, 31 drift-checks are run. The FVS module passes 31/31.

The standalone is not in any drift-check script.

8.4 Constitutional summary

9.1 Components to KEEP (still valuable, do not retire)

9.2 Components to RETIRE (permanently)

Total: ~30+ files of stale build-plan / deploy / legacy content to retire. Per operator rule "WP sandbox on VPS — keep until user explicitly agrees to remove", these need operator sign-off before deletion.

9.3 Components to REWRITE

9.4 Components to INTEGRATE into FreshVibe CMS

Total LOC transferable: ~3,000-4,000 of 5,500 (60-70% of FVS module).

9.5 Components to integrate into VibeCoder

Total LOC transferable: ~50-200 of 5,500 (1-4% of FVS module).

9.6 Components to REMAIN DORMANT

Output checklist

VSIL pipeline (canonical IR)

┌──────────────────────────────────────────────────────────────────┐
│                          VSIL Pipeline                            │
│                                                                    │
│  VSILSource (text)                                                 │
│       │                                                            │
│       ▼  (641 LOC)                                                 │
│  parser.ts                                                         │
│       │ produces AST (token tree)                                  │
│       ▼  (323 LOC)                                                  │
│  sceneGraph.ts                                                      │
│       │ produces SceneGraph (parent/child/index tree)             │
│       ├──────────────────────┐                                      │
│       ▼                      ▼                                       │
│  (323 LOC)  evaluator.ts   (238 LOC) diff.ts                       │
│       │  (684 LOC)           │                                       │
│       │  produces            │ produces                              │
│       │  EngineRenderResult  │ DiffResult                            │
│       │                      │                                       │
│       ▼                      ▼                                       │
│  (219 LOC)  assetRegistry.ts   (130 LOC) keyframeExtractor.ts       │
│       │  resolves images     │ extracts keyframes                   │
│       │                      │                                       │
│       ▼                      ▼                                       │
│  (271 LOC)  inspectorExtract.ts                                    │
│       │  produces InspectorSource                                 │
│       ▼                                                            │
│  5 Inspector sub-modes (AST / Props / State / Logs / Metadata)     │
│       │  READ-ONLY per inspector.md invariant                       │
│       ▼                                                            │
│  8 Card components (Editor / Visual / Timeline / Inspector /       │
│                      Docs / Replay / Diff / Tests)                  │
│       │                                                            │
│       ▼                                                            │
│  3 Engines: CinemaProcedural (16ms) / CinemaUltra (33ms WebGL2) /   │
│            Render (CLI PNG/JSON)                                  │
└──────────────────────────────────────────────────────────────────┘

Scrubber lineage (anchor system)

scrubber/types.ts (VSILSource + ScrubberAnchorState)
    │
    ▼
scrubber/ScrubberAnchor.tsx (React Context, persistent)
    │
    ▼
scrubber/ScrubberBar.tsx + scrubber/ScrubberControls.tsx + scrubber/useFrameAt.ts
    │
    ▼
Consumed by 8 Cards (read frame state)
    │
    ▼
Drives 3 Engines (frame at time T → render)

Inspector lineage (read-only)

VSILSource
    │
    ▼
parser.ts → AST
    │
    ▼
sceneGraph.ts → SceneGraph
    │
    ▼
inspectorExtract.ts → InspectorSource (5 fields: AST, Props, State, Logs, Metadata)
    │
    ▼
inspector/index.ts (barrel, single registry)
    │
    ├─→ ASTMode.tsx       (87 LOC)
    ├─→ PropsMode.tsx     (85 LOC)
    ├─→ StateMode.tsx     (82 LOC)
    ├─→ LogsMode.tsx      (136 LOC)
    └─→ MetadataMode.tsx  (64 LOC)
    │
    ▼
Consumed by:
    ├─→ InspectorCard.tsx (Cinema layout, 4th card)
    └─→ InspectorCardLevelRow.tsx (Backstage Panel card-level chip row)

Chrome lineage

Backstage Panel (parent)
    │
    ├─→ Panel-level chip row (5 chips, Backstage-Panel)
    │
    └─→ Card-level chip row (InspectorCardLevelRow, 5 sub-modes)
        │
        └─→ Full Peek side-column (FullPeekSideColumn, up to 3 chips stacked)
            │
            └─→ Active Inspector sub-mode renders in main Peek area

Standalone lineage (parallel universe)

main.tsx (3-column grid)
    │
    ├─→ VibeScopeLeftCurtain
    │       │
    │       ▼
    │   LayerPanel
    │       ├─→ LayerToolbar (add-layer / snap / reset / delete)
    │       └─→ LayerTree (LayerRow × N)
    │
    ├─→ VibeScopeHomeSurface
    │       │
    │       ▼
    │   Canvas
    │       ├─→ SnapGrid (when snap enabled)
    │       ├─→ LayerView × N (per layer, inline style)
    │       └─→ Handles overlay (8 handles per selected layer)
    │
    └─→ VibeScopeRightCurtain
            │
            ▼
        PropertiesPanel (EDITOR, not read-only)
            ├─→ PropertyField × N (form fields)
            ├─→ Undo / Redo
            └─→ Multi / Single mode

ALL driven by: state/store.ts (useReducer + StoreProvider, in-memory)

NO CONNECTION TO: VSIL pipeline, engines, Scrubber, Inspector, fragmentRegistry

Three paths forward, in order of preference

Path A — "FvCMS is the new VibeScope home" (recommended, ~6-8 weeks)

1. Move VSIL pipeline to FvCMS (~3,000 LOC, 1-2 weeks): drop parser/sceneGraph/evaluator/assetRegistry/diff/keyframeExtractor/inspectorExtract into avidtech6/freshvibe-cms/packages/runtime/. Write a FvCMS adapter for the Inspector pattern.
2. Move Render engine to FvCMS static-build (~141 LOC, 2-3 days): drop into avidtech6/freshvibe-cms/packages/static-build/ for VSIL → PNG export. Wire a CLI entry.
3. Implement project container format in FvCMS (~1 week): file picker + IndexedDB persistence + .vsil save/load.
4. Re-implement 8 Cards as FvCMS cards (~1-2 weeks): use the VSIL pipeline + Inspector pattern. Drop the VibeScope-specific chrome (Shell/Variant) since FvCMS has its own.
5. Update pact/workspaces/vibescope/ to point at FvCMS (not FVS module). Mark the FVS module as deprecated.
6. Retire the FVS module after FvCMS parity (operator sign-off required).
7. Retire the standalone after FvCMS parity (operator sign-off required). The 3-surface contract from the standalone can be the basis for FvCMS's VibeScope view.

Outcome: FvCMS owns VibeScope. FVS loses the module. Standalone is retired. ~4,000 LOC transferred cleanly.

Path B — "Standalone is the new VibeScope home" (alternative, ~6-8 weeks)

1. Add VSIL pipeline to standalone (~2,000 LOC, 1-2 weeks): port the FVS VSIL files. Adapt to React state, not a separate store.
2. Add 3 engines to standalone (~280 LOC, 1 week): port CinemaProcedural + CinemaUltra + Render. CinemaUltra wraps CinemaProcedural with quality=ultra.
3. Add Scrubber to standalone (~500 LOC, 1 week): port the anchor system. Make it a persistent footer.
4. Rename PropertiesPanel → Inspector + enforce read-only invariant (1 day).
5. Implement project container format in standalone (~1 week): file picker + IndexedDB.
6. Bind to pact/workspaces/vibescope/ (1-2 days): create a standalone version of the 26 constitutional fragments.
7. Retire the FVS module after standalone parity (operator sign-off required).

Outcome: Standalone is the canonical VibeScope. FVS loses the module. The pact/v3/freshvibe-cockpit-constitution-vibescope.md is updated to point at the standalone.

Path C — "Both stay, FvCMS gets a thin adapter" (hybrid, ~2-3 weeks)

1. Keep both FVS module and standalone as-is.
2. Add a FvCMS adapter for VSIL that wraps the FVS VSIL pipeline (~500 LOC, 1 week): re-implement the parser/sceneGraph/evaluator in FvCMS's preferred patterns.
3. Do NOT move CinemaUltra / Scrubber / Inspector to FvCMS. FvCMS uses FVS for those.
4. Defer project container format until FvCMS has a real VSIL consumer.

Outcome: Fastest path to FvCMS having VSIL support. Both trees survive. FVS module keeps doing its job. Standalone lives for the sovereign app story.

My recommendation: Path A

Why A over B:

• FvCMS is where the operator's actual work is happening. Putting VibeScope there makes it immediately useful.
• Path B (standalone) requires re-implementing 2,500+ LOC of VSIL pipeline. Path A just moves it.
• The FVS chrome is bound to FVS's chrome module — not portable. The standalone is bound to Mantine + 3-column grid — also not portable to FvCMS.
• Path A reduces 2 source trees to 1 (FvCMS owns VibeScope), simplifying the operator's mental model.

Why A over C:

• C leaves the operator with 3 places to look for VibeScope (FVS module, standalone, FvCMS adapter). A consolidates to 1.
• The "thin adapter" approach always accretes over time — 6 months later you have 3 incompatible VibeScope implementations.
• A retires 2 trees (FVS module + standalone) which is a huge cleanup win per the operator's "no terminal, no parallel code" preference.

But — Path A has a critical precondition: FvCMS must be ready to receive the VSIL pipeline. If FvCMS's runtime layer is unstable, A becomes a 3-month port instead of a 6-8 week port. Confirm with operator before committing.

Short-term actions (do these regardless of which path)

1. Decide between Path A, B, C with operator.
2. Operator sign-off on retirement list (§ 9.2 — 30+ files of stale build-plan / deploy / legacy content).
3. Add project container format to whichever tree is the canonical home. This is the single most important missing piece.
4. Implement Trace Atlas integration in FVS module (1 day, finishes the 12/12 constitutional score).
5. Wire Render engine to CLI in FVS module (1-2 days, unblocks headless VSIL export).