Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
feat(studio): rebuild the interface over DemoSource, add the baseline comparison
FABIOTESS2244a1283d82
diff --git a/studio/src-tauri/sidecars/agent/baseline.test.ts b/studio/src-tauri/sidecars/agent/baseline.test.tsnew file mode 100644index 00000000..41af0456--- /dev/null+++ b/studio/src-tauri/sidecars/agent/baseline.test.ts@@ -0,0 +1,99 @@+import { describe, it, expect } from 'vitest';+import { terms, chunkDocument, chunkCorpus, topChunks, citedDocs, baselineAnswer } from './baseline.js';++describe('terms', () => {+ it('drops stopwords and short words, keeps discriminating ones', () => {+ expect(terms('Does this profile conform to the W3C DCAT vocabulary standard?')).toEqual(+ expect.arrayContaining(['profile', 'conform', 'vocabulary', 'standard']),+ );+ expect(terms('Does this profile conform to the W3C DCAT vocabulary standard?')).not.toContain('this');+ });+});++describe('chunkDocument', () => {+ it('splits prose on blank lines', () => {+ const chunks = chunkDocument('doc-a', 'first paragraph here\n\nsecond paragraph here\n\nthird one');+ expect(chunks).toHaveLength(3);+ expect(chunks[0]).toMatchObject({ doc: 'doc-a', idx: 0, text: 'first paragraph here' });+ });++ it('falls back to fixed-size line blocks for text with no paragraph breaks', () => {+ const lines = Array.from({ length: 60 }, (_, i) => `line ${i}`).join('\n');+ const chunks = chunkDocument('doc-b', lines);+ expect(chunks.length).toBe(3); // 60 lines / 25 per block, rounded up+ expect(chunks.every(c => c.doc === 'doc-b')).toBe(true);+ });+});++describe('chunkCorpus', () => {+ it('chunks every document and tags each chunk with its own doc id', () => {+ const chunks = chunkCorpus({+ 'doc-a': 'alpha\n\nbeta\n\ngamma',+ 'doc-b': 'delta\n\nepsilon\n\nzeta',+ });+ expect(chunks.map(c => c.doc).sort()).toEqual(['doc-a', 'doc-a', 'doc-a', 'doc-b', 'doc-b', 'doc-b']);+ });+});++describe('topChunks', () => {+ const chunks = [+ { doc: 'a', idx: 0, text: 'DCAT-US 3.0 is a profile of the DCAT vocabulary.' },+ { doc: 'b', idx: 0, text: 'This document describes an unrelated catalog schema.' },+ { doc: 'c', idx: 0, text: 'DCAT vocabulary terms appear here, DCAT again, and DCAT once more.' },+ ];++ it('ranks chunks by keyword occurrence, highest first', () => {+ const top = topChunks(chunks, 'what does the DCAT vocabulary cover?', 3);+ expect(top[0].doc).toBe('c'); // most occurrences of "vocabulary"/"dcat"+ });++ it('drops chunks that score zero rather than padding the context', () => {+ const top = topChunks(chunks, 'xyzzy plugh', 3);+ expect(top).toHaveLength(0);+ });++ it('respects the k limit', () => {+ const top = topChunks(chunks, 'DCAT vocabulary profile document catalog', 1);+ expect(top).toHaveLength(1);+ });+});++describe('citedDocs', () => {+ it('prefers documents actually named in the answer over the retrieved list', () => {+ const cited = citedDocs('The profile is defined in profile-readme.', ['profile-readme', 'other-doc'], [+ 'other-doc',+ ]);+ expect(cited).toEqual(['profile-readme']);+ });++ it('falls back to the retrieved list when the answer names nothing', () => {+ const cited = citedDocs('No document is named here.', ['profile-readme', 'other-doc'], ['other-doc']);+ expect(cited).toEqual(['other-doc']);+ });+});++describe('baselineAnswer', () => {+ it('retrieves, prompts with only the top chunks, and cites what the answer names', async () => {+ const chunks = [+ { doc: 'profile-readme', idx: 0, text: 'DCAT-US is an implementation of the W3C DCAT standard.' },+ { doc: 'unrelated', idx: 0, text: 'Nothing to do with the question at all.' },+ ];+ let promptSeen = '';+ const answerOnce = async (prompt: string) => {+ promptSeen = prompt;+ return 'Yes, per profile-readme it claims DCAT conformance.';+ };++ const result = await baselineAnswer(+ 'does the profile conform to DCAT?',+ chunks,+ ['profile-readme', 'unrelated'],+ answerOnce,+ );++ expect(promptSeen).toContain('profile-readme');+ expect(promptSeen).not.toContain('unrelated');+ expect(result.citations).toEqual(['profile-readme']);+ expect(result.answer).toContain('DCAT conformance');+ });+});diff --git a/studio/src-tauri/sidecars/agent/baseline.ts b/studio/src-tauri/sidecars/agent/baseline.tsnew file mode 100644index 00000000..928f2432--- /dev/null+++ b/studio/src-tauri/sidecars/agent/baseline.ts@@ -0,0 +1,148 @@+/**+ * Plain baseline: chunk retrieval over raw corpus text, no ontology at all.+ *+ * graphrag.ts answers a question by traversing the derived knowledge graph+ * from the entities the question names. This module answers the SAME+ * question a different way: split every document into paragraph-sized+ * chunks, score each chunk by how many question terms it contains, and hand+ * the top few to the model with no structure at all. It is the "just embed+ * the documents and retrieve" approach the demonstration compares against.+ *+ * This is a TypeScript port of demo/build_compare.py's `baseline_answer` /+ * `load_chunks`, kept in the sidecar so a live session can run the same+ * comparison the offline pipeline precomputed. It deliberately does not+ * decide whether the baseline or the grounded answer is "right": that+ * judgment is a human read over both transcripts (see build_compare.py's+ * module docstring), and nothing here manufactures it. Callers that want the+ * comparison surface, not just this one side of it, combine this module's+ * output with graphrag.ts's own, and leave the verdict to a person.+ */++const STOP = new Set(+ ('the a an of to in for is are be and or that this with by on at as it its what which who whom ' ++ 'why how when where does do did can could would should may might will shall about any all some ' ++ 'there their they them we our you your i me my show tell give list find explain').split(' '),+);++/** Terms worth scoring on: long enough to be discriminating, not stopwords. */+export function terms(question: string): string[] {+ const words = question.toLowerCase().match(/[a-z0-9][a-z0-9\-_]{2,}/g) ?? [];+ const uniq = [...new Set(words.filter(w => !STOP.has(w) && w.length >= 4))];+ return uniq.slice(0, 8);+}++export interface DocChunk {+ doc: string;+ idx: number;+ text: string;+}++/**+ * Split one document's raw text into chunks with no notion of section or+ * ontology. Prose is split on blank lines; anything without enough blank+ * lines to paragraph on (JSON, Turtle) falls back to fixed-size line blocks.+ * This is deliberately cruder than chunker.py's semantic chunking: the point+ * of the baseline is to be what a generic "split and embed" pipeline does,+ * not the best possible retrieval this codebase can build.+ */+export function chunkDocument(docId: string, text: string): DocChunk[] {+ let paragraphs = text+ .split(/\n\s*\n/)+ .map(p => p.trim())+ .filter(Boolean);+ if (paragraphs.length < 3) {+ const lines = text.split('\n').filter(l => l.trim());+ paragraphs = [];+ for (let i = 0; i < lines.length; i += 25) {+ paragraphs.push(lines.slice(i, i + 25).join('\n'));+ }+ }+ return paragraphs.map((p, idx) => ({ doc: docId, idx, text: p }));+}++/** Chunk every document in a corpus keyed by document id. */+export function chunkCorpus(docs: Record<string, string>): DocChunk[] {+ const out: DocChunk[] = [];+ for (const [docId, text] of Object.entries(docs)) {+ out.push(...chunkDocument(docId, text));+ }+ return out;+}++/**+ * Score every chunk by raw term-occurrence count and return the top `k`.+ * Chunks that score zero are dropped entirely rather than padding the+ * context with irrelevant text, mirroring the Python baseline exactly.+ */+export function topChunks(chunks: DocChunk[], question: string, k = 6): DocChunk[] {+ const qterms = terms(question);+ const scored: Array<{ score: number; chunk: DocChunk }> = [];+ for (const chunk of chunks) {+ const low = chunk.text.toLowerCase();+ let score = 0;+ for (const t of qterms) {+ let from = 0;+ for (;;) {+ const at = low.indexOf(t, from);+ if (at === -1) break;+ score += 1;+ from = at + t.length;+ }+ }+ if (score > 0) scored.push({ score, chunk });+ }+ scored.sort((a, b) => b.score - a.score);+ return scored.slice(0, k).map(s => s.chunk);+}++/** Render retrieved chunks into a labelled context block for the prompt. */+export function renderChunks(chunks: DocChunk[]): string {+ return chunks.map(c => `[${c.doc}#${c.idx}]\n${c.text.slice(0, 1200)}`).join('\n\n');+}++/**+ * The documents an answer actually cited: scanned against every corpus+ * document id, not only the ones retrieval happened to surface. A model+ * naming a document it saw in its context gets credit for that regardless of+ * which fixed list built the context; falling back to `retrieved` only fires+ * when the answer names none of them at all (a prompt-following failure, not+ * evidence of zero grounding). Mirrors build_compare.py's `cited_docs`.+ */+export function citedDocs(answer: string, allDocIds: string[], retrieved: string[]): string[] {+ const named = allDocIds.filter(d => answer.includes(d)).sort();+ return named.length > 0 ? named : [...new Set(retrieved)].sort();+}++export interface BaselineResult {+ answer: string;+ citations: string[];+}++const BASELINE_PROMPT = (context: string, question: string) =>+ 'You are answering a question using ONLY the document excerpts below, retrieved by plain ' ++ 'keyword matching (no ontology, no knowledge graph). Each excerpt is tagged with the document ' ++ `id it came from.\n\nEXCERPTS:\n${context || '(no excerpt matched)'}\n\nQUESTION: ${question}\n\n` ++ 'Answer in 2-5 sentences. Every factual claim you make must be traceable to the excerpts above; ' ++ 'when you use one, name the document id in parentheses. If the excerpts do not contain enough ' ++ 'to answer, say so plainly rather than guessing.';++/**+ * Answer a question from plain keyword-chunk retrieval, no ontology.+ *+ * `answerOnce` is injected rather than called on a module-level provider so+ * this stays testable with a fake, the same way the rest of this sidecar's+ * modules take a McpClient or Provider as a parameter instead of reaching+ * for a global.+ */+export async function baselineAnswer(+ question: string,+ chunks: DocChunk[],+ allDocIds: string[],+ answerOnce: (prompt: string) => Promise<string>,+ k = 6,+): Promise<BaselineResult> {+ const top = topChunks(chunks, question, k);+ const retrievedDocs = [...new Set(top.map(c => c.doc))].sort();+ const answer = (await answerOnce(BASELINE_PROMPT(renderChunks(top), question))).trim();+ return { answer, citations: citedDocs(answer, allDocIds, retrievedDocs) };+}diff --git a/studio/src/App.tsx b/studio/src/App.tsxindex b29e3bfd..f36736a6 100644--- a/studio/src/App.tsx+++ b/studio/src/App.tsx@@ -1,8 +1,12 @@-import { Layout } from './components/Layout';-import './App.css';+import { AppShell } from './AppShell';+// The old Layout component talked to the engine directly (Graph3D issued+// its own SPARQL, the toolbar called mcp-client straight) and only ever+// worked in the desktop build. AppShell replaces it: components take data+// and callbacks as props and read through the DemoSource abstraction, so+// the same tree renders here and in the static web build (see main.tsx).function App() {- return <Layout />;+ return <AppShell />;}export default App;diff --git a/studio/src/AppShell.tsx b/studio/src/AppShell.tsxnew file mode 100644index 00000000..145358e4--- /dev/null+++ b/studio/src/AppShell.tsx@@ -0,0 +1,215 @@+import { useEffect, useState, useCallback, lazy, Suspense } from 'react'+import { useDemoStore } from './state/demo-store'+import { CorpusPanel } from './components/CorpusPanel'+import { FindingsPanel } from './components/FindingsPanel'+import { ResolutionPanel } from './components/ResolutionPanel'+import { ComparePanel } from './components/ComparePanel'+import { Graph3D } from './components/Graph3D'+import { chooseSourceKind } from './lib/source-factory'+import { getCompareSource, type CompareResult } from './lib/compare-source'+import './App.css'++// Desktop-only chrome (chat over the agent sidecar, engine status, save/open,+// the 2D tree, inspector, lineage) is dynamically imported so none of the+// Tauri-coupled hooks it pulls in ever execute in the replay bundle: a+// static `import` at the top of this file would still bundle and evaluate+// that module's side effects (event listeners registered at module scope)+// even inside an `if (isLive)` branch, since ES module evaluation happens at+// import time, not at render time.+const LiveChrome = lazy(() => import('./components/LiveChrome').then((m) => ({ default: m.LiveChrome })))++const isLive =+ chooseSourceKind(import.meta.env as unknown as Record<string, string | undefined>) === 'live'++type Tab = 'findings' | 'corpus' | 'compare'++/**+ * The tabbed sidebar: findings + resolution, corpus, and the grounded-vs-+ * baseline comparison. This is the one demonstration surface both build+ * targets render identically, so it is composed once here and used both as+ * the whole sidebar in the replay build and as an additional panel inside+ * LiveChrome in the desktop build, never reimplemented twice.+ */+function DemoPanels() {+ const documents = useDemoStore((s) => s.documents)+ const documentsError = useDemoStore((s) => s.documentsError)+ const findings = useDemoStore((s) => s.findings)+ const selectedFinding = useDemoStore((s) => s.selectedFinding)+ const ledger = useDemoStore((s) => s.ledger)+ const select = useDemoStore((s) => s.select)+ const resolve = useDemoStore((s) => s.resolve)+ // Surfaced here too, not only in ReplayBody's header: DemoPanels is also+ // embedded inside LiveChrome, which has no header banner of its own, and+ // a rejected resolve() (see live-source.ts: no engine tool resolves a+ // finding by id yet) must not fail silently there.+ const error = useDemoStore((s) => s.error)++ const [tab, setTab] = useState<Tab>('findings')+ const [compareResult, setCompareResult] = useState<CompareResult | null>(null)+ const [comparePending, setComparePending] = useState(false)+ const [compareQuestions, setCompareQuestions] = useState<string[]>([])++ // The scripted question list for the compare picker. CompareSource has no+ // "list questions" method by design (see compare-source.ts: it answers+ // one question at a time), so this reads the same precomputed bundle+ // replay mode's CompareSource reads internally, purely to populate the+ // picker. Live mode has no scripted set (getCompareSource() throws+ // there), so the picker stays empty and the panel explains why on ask.+ useEffect(() => {+ let cancelled = false+ if (!isLive) {+ fetch('./precomputed/bundle.json')+ .then((r) => r.json())+ .then((bundle: { compare?: Record<string, unknown> }) => {+ if (cancelled) return+ if (bundle.compare && typeof bundle.compare === 'object') {+ setCompareQuestions(Object.keys(bundle.compare))+ }+ })+ .catch(() => {})+ }+ return () => {+ cancelled = true+ }+ }, [])++ const handleAsk = useCallback(async (q: string) => {+ setComparePending(true)+ try {+ const src = await getCompareSource()+ const result = await src.compare(q)+ setCompareResult(result)+ } catch (e) {+ setCompareResult({+ question: q,+ grounded: { answer: e instanceof Error ? e.message : String(e), citations: [] },+ baseline: { answer: '', citations: [] },+ divergence: null,+ })+ } finally {+ setComparePending(false)+ }+ }, [])++ const selected = findings.find((f) => f.id === selectedFinding) ?? null++ return (+ <div className="flex flex-col h-full overflow-hidden">+ <div className="flex border-b text-xs shrink-0" style={{ borderColor: 'var(--border)' }}>+ {(['findings', 'corpus', 'compare'] as Tab[]).map((t) => (+ <button+ key={t}+ onClick={() => setTab(t)}+ className="flex-1 px-2 py-2 capitalize"+ style={{+ background: tab === t ? 'var(--bg-panel)' : 'transparent',+ color: tab === t ? 'var(--accent)' : 'var(--text-secondary)',+ }}+ >+ {t}+ </button>+ ))}+ </div>++ {error && (+ <div className="text-xs p-2" style={{ color: 'var(--error)', background: 'var(--bg-panel)' }}>+ {error}+ </div>+ )}++ <div className="flex-1 overflow-hidden flex flex-col">+ {tab === 'findings' && (+ <div className="flex-1 flex flex-col overflow-hidden">+ <div className="flex-1 overflow-y-auto">+ <FindingsPanel findings={findings} selected={selectedFinding} onSelect={select} />+ </div>+ <div className="h-72 border-t overflow-hidden" style={{ borderColor: 'var(--border)' }}>+ <ResolutionPanel finding={selected} ledger={ledger} onResolve={resolve} />+ </div>+ </div>+ )}+ {tab === 'corpus' && (+ <CorpusPanel documents={documents} error={documentsError} onOpen={() => {}} />+ )}+ {tab === 'compare' && (+ <ComparePanel+ result={compareResult}+ onAsk={handleAsk}+ questions={compareQuestions}+ pending={comparePending}+ />+ )}+ </div>+ </div>+ )+}++/** The replay build's whole shell: the 3D graph plus the shared demo panels. */+function ReplayBody() {+ const graph = useDemoStore((s) => s.graph)+ const error = useDemoStore((s) => s.error)+ const loading = useDemoStore((s) => s.loading)++ return (+ <div className="h-screen flex flex-col" style={{ background: 'var(--bg-primary)' }}>+ <div+ className="h-10 flex items-center px-4 border-b gap-3"+ style={{ borderColor: 'var(--border)', background: 'var(--bg-secondary)' }}+ >+ <span className="text-sm font-semibold" style={{ color: 'var(--accent)' }}>+ Open Ontologies+ </span>+ <span className="text-xs" style={{ color: 'var(--text-secondary)' }}>+ Offline replay: no engine, no model, no network+ </span>+ {loading && (+ <span className="text-xs" style={{ color: 'var(--text-secondary)' }}>+ Loading…+ </span>+ )}+ {error && (+ <span className="text-xs ml-auto" style={{ color: 'var(--error)' }}>+ {error}+ </span>+ )}+ </div>+ <div className="flex-1 flex overflow-hidden">+ <div className="flex-1 relative">+ <Graph3D graph={graph} onNodeSelect={() => {}} />+ </div>+ <div+ className="w-96 border-l flex flex-col"+ style={{ borderColor: 'var(--border)', background: 'var(--bg-secondary)' }}+ >+ <DemoPanels />+ </div>+ </div>+ </div>+ )+}++/**+ * The single entry point for the whole studio interface. Both build targets+ * mount this and nothing else: it decides which chrome to add around the+ * shared demonstration body (Graph3D + DemoPanels), and every component+ * beneath it takes data and callbacks as props rather than reaching for a+ * source directly, so the same tree renders live against the engine and+ * offline from the precomputed artifacts.+ */+export function AppShell() {+ const load = useDemoStore((s) => s.load)++ useEffect(() => {+ load()+ }, [load])++ if (!isLive) return <ReplayBody />++ return (+ <Suspense fallback={<ReplayBody />}>+ <LiveChrome>+ <DemoPanels />+ </LiveChrome>+ </Suspense>+ )+}diff --git a/studio/src/PublicDemo.tsx b/studio/src/PublicDemo.tsxdeleted file mode 100644index 0d1faea4..00000000--- a/studio/src/PublicDemo.tsx+++ /dev/null@@ -1,117 +0,0 @@-import { useEffect, useState } from 'react'-import type { Contradiction, DemoSource, Document, GraphView } from './lib/demo-source'-import { getDemoSource } from './lib/source-factory'-import './App.css'--/**- * The static web build's entry surface. Task 12 wires the full desktop- * Layout (TreeView, Graph3D, ChatPanel, ...) to DemoSource; until then this- * is the minimal proof that the construction site in source-factory.ts- * actually works end to end: no engine, no Tauri, no network, and the- * corpus, graph and findings still render from the committed artifacts.- */-export function PublicDemo() {- const [source, setSource] = useState<DemoSource | null>(null)- const [corpus, setCorpus] = useState<Document[] | null>(null)- const [graph, setGraph] = useState<GraphView | null>(null)- const [findings, setFindings] = useState<Contradiction[] | null>(null)- const [error, setError] = useState<string | null>(null)-- useEffect(() => {- let cancelled = false- getDemoSource()- .then(async (src) => {- if (cancelled) return- setSource(src)- const [c, g, f] = await Promise.all([src.corpus(), src.graph(), src.findings()])- if (cancelled) return- setCorpus(c)- setGraph(g)- setFindings(f)- })- .catch((e) => {- if (!cancelled) setError(e instanceof Error ? e.message : String(e))- })- return () => {- cancelled = true- }- }, [])-- if (error) {- return (- <div className="p-8" style={{ color: 'var(--error)' }}>- <h1 className="text-lg font-semibold mb-2">Could not load the demonstration</h1>- <p>{error}</p>- </div>- )- }-- return (- <div className="min-h-screen p-8 mx-auto" style={{ maxWidth: 960, color: 'var(--text-primary)' }}>- <header className="mb-8">- <h1 className="text-xl font-semibold" style={{ color: 'var(--accent)' }}>- Open Ontologies — offline demonstration- </h1>- <p className="text-sm mt-1" style={{ color: 'var(--text-secondary)' }}>- Replayed entirely from committed artifacts. No engine, no model, no network call.- </p>- </header>-- <section className="mb-8">- <h2 className="text-sm font-semibold uppercase tracking-wide mb-3" style={{ color: 'var(--text-secondary)' }}>- Corpus {corpus ? `(${corpus.length} documents)` : ''}- </h2>- {!corpus && <p style={{ color: 'var(--text-secondary)' }}>Loading…</p>}- <ul className="space-y-1 text-sm">- {corpus?.map((doc) => (- <li key={doc.id} className="px-3 py-1.5 rounded" style={{ background: 'var(--bg-panel)' }}>- {doc.title}- </li>- ))}- </ul>- </section>-- <section className="mb-8">- <h2 className="text-sm font-semibold uppercase tracking-wide mb-3" style={{ color: 'var(--text-secondary)' }}>- Graph- </h2>- {!graph && <p style={{ color: 'var(--text-secondary)' }}>Loading…</p>}- {graph && (- <p className="text-sm" style={{ color: 'var(--text-primary)' }}>- {graph.classes.length} classes, {graph.properties.length} properties, {graph.edges.length} edges- </p>- )}- </section>-- <section>- <h2 className="text-sm font-semibold uppercase tracking-wide mb-3" style={{ color: 'var(--text-secondary)' }}>- Findings {findings ? `(${findings.length})` : ''}- </h2>- {!findings && <p style={{ color: 'var(--text-secondary)' }}>Loading…</p>}- <ul className="space-y-3 text-sm">- {findings?.map((f) => (- <li key={f.id} className="px-3 py-2 rounded" style={{ background: 'var(--bg-panel)' }}>- <div className="font-medium" style={{ color: 'var(--accent)' }}>- {f.subject} <span style={{ color: 'var(--text-secondary)' }}>[{f.kind}]</span>- </div>- <ul className="mt-1 space-y-0.5">- {f.claims.map((c, i) => (- <li key={i} style={{ color: 'var(--text-secondary)' }}>- <span style={{ color: 'var(--text-primary)' }}>{c.document}</span> {c.predicate}: {c.object}- </li>- ))}- </ul>- </li>- ))}- </ul>- </section>-- {source && (- <p className="mt-8 text-xs" style={{ color: 'var(--text-secondary)' }}>- Source ready. The full desktop application (open-ontologies studio) adds live graph- exploration and chat over a running engine.- </p>- )}- </div>- )-}diff --git a/studio/src/components/ComparePanel.tsx b/studio/src/components/ComparePanel.tsxnew file mode 100644index 00000000..453e5930--- /dev/null+++ b/studio/src/components/ComparePanel.tsx@@ -0,0 +1,98 @@+import type { CompareResult } from '../lib/compare-source'++export interface ComparePanelProps {+ result: CompareResult | null+ onAsk: (q: string) => void+ // The scripted question set, in the exact order the comparison data+ // carries them. Rendered as-is: no reordering, no filtering, and no+ // indication of which side "won" on any question. One of the five has the+ // grounded answer wrong and the plain baseline right, and it must render+ // exactly like every other row, in its own place in this order.+ questions?: string[]+ pending?: boolean+}++/**+ * The same question answered twice, side by side: once grounded in the+ * ontology with citations into the corpus, once by a plain keyword-chunk+ * baseline. The divergence note sits between the two columns. Imports no+ * source; whether a question is scripted, and which side is right, comes+ * entirely from `result`.+ */+export function ComparePanel({ result, onAsk, questions = [], pending }: ComparePanelProps) {+ return (+ <div className="flex flex-col h-full overflow-y-auto">+ {questions.length > 0 && (+ <div className="p-3 border-b flex flex-col gap-1" style={{ borderColor: 'var(--border)' }}>+ <span className="text-xs font-semibold uppercase tracking-wide" style={{ color: 'var(--text-secondary)' }}>+ Scripted questions+ </span>+ {questions.map((q) => (+ <button+ key={q}+ onClick={() => onAsk(q)}+ className="text-left text-xs px-2 py-1.5 rounded"+ style={{+ background: result?.question === q ? 'var(--bg-panel)' : 'transparent',+ color: 'var(--text-primary)',+ }}+ >+ {q}+ </button>+ ))}+ </div>+ )}++ <div className="p-3 flex-1">+ {pending && (+ <p className="text-sm" style={{ color: 'var(--text-secondary)' }}>+ Running both answers…+ </p>+ )}+ {!pending && !result && (+ <p className="text-sm" style={{ color: 'var(--text-secondary)' }}>+ Pick a question above to compare a grounded answer against a plain baseline.+ </p>+ )}+ {!pending && result && (+ <div className="space-y-3">+ <div className="text-sm font-medium" style={{ color: 'var(--text-primary)' }}>+ {result.question}+ </div>++ <div className="grid grid-cols-2 gap-3">+ <AnswerColumn label="Grounded (ontology)" answer={result.grounded} />+ <AnswerColumn label="Baseline (plain retrieval)" answer={result.baseline} />+ </div>++ <div className="text-xs p-2 rounded" style={{ background: 'var(--bg-panel)', color: 'var(--text-secondary)' }}>+ {result.divergence ?? 'No divergence recorded: this question was not in the scripted set.'}+ </div>+ </div>+ )}+ </div>+ </div>+ )+}++function AnswerColumn({ label, answer }: { label: string; answer: { answer: string; citations: string[] } }) {+ return (+ <div className="p-2 rounded" style={{ background: 'var(--bg-panel)' }}>+ <div className="text-xs font-semibold mb-1" style={{ color: 'var(--accent)' }}>+ {label}+ </div>+ <p className="text-xs whitespace-pre-wrap" style={{ color: 'var(--text-primary)' }}>+ {answer.answer || '(no answer)'}+ </p>+ {answer.citations.length > 0 && (+ <ul className="mt-2 space-y-0.5 text-xs">+ {answer.citations.map((c) => (+ <li key={c} style={{ color: 'var(--text-secondary)' }}>+ · {c}+ </li>+ ))}+ </ul>+ )}+ </div>+ )+}diff --git a/studio/src/components/CorpusPanel.tsx b/studio/src/components/CorpusPanel.tsxnew file mode 100644index 00000000..3bb9c73a--- /dev/null+++ b/studio/src/components/CorpusPanel.tsx@@ -0,0 +1,75 @@+import type { Document } from '../lib/demo-source'++// The precomputed corpus documents carry more than demo-source.ts's Document+// type declares (file, source_url, sha256, retrieved, from+// demo/corpus/dcat-us/MANIFEST.json), and not every source populates+// `title`. Read the extra fields defensively rather than widening the shared+// type, since nothing else in the app needs them.+interface ManifestFields {+ file?: string+ source_url?: string+ sha256?: string+ retrieved?: string+}++export interface CorpusPanelProps {+ documents: Document[]+ // Set when the source has no honest way to list documents (live mode+ // today: no tool or Tauri command returns document text). Rendered as an+ // explanation rather than left to read as "this corpus is empty".+ error?: string | null+ onOpen: (id: string) => void+}++function provenanceTitle(doc: Document & ManifestFields): string {+ const parts: string[] = []+ if (doc.source_url) parts.push(`source: ${doc.source_url}`)+ if (doc.retrieved) parts.push(`retrieved: ${doc.retrieved}`)+ if (doc.sha256) parts.push(`sha256: ${doc.sha256}`)+ return parts.length > 0 ? parts.join('\n') : `${doc.id} (no provenance recorded)`+}++/**+ * One row per corpus document: id, title, and the MANIFEST.json provenance+ * (source URL, retrieval date, checksum) surfaced as a hover tooltip rather+ * than cluttering the row. Takes data and a callback only, and imports no+ * source.+ */+export function CorpusPanel({ documents, error, onOpen }: CorpusPanelProps) {+ if (error) {+ return (+ <p className="p-4 text-sm" style={{ color: 'var(--text-secondary)' }}>+ {error}+ </p>+ )+ }+ if (documents.length === 0) {+ return (+ <p className="p-4 text-sm" style={{ color: 'var(--text-secondary)' }}>+ No documents in this corpus.+ </p>+ )+ }+ return (+ <ul className="divide-y overflow-y-auto" style={{ borderColor: 'var(--border)' }}>+ {documents.map((doc) => {+ const d = doc as Document & ManifestFields+ const title = d.title || d.file || d.id+ return (+ <li+ key={d.id}+ onClick={() => onOpen(d.id)}+ title={provenanceTitle(d)}+ className="cursor-pointer px-3 py-2 text-sm"+ style={{ color: 'var(--text-primary)' }}+ >+ <span className="font-mono text-xs mr-2" style={{ color: 'var(--text-secondary)' }}>+ {d.id}+ </span>+ {title}+ </li>+ )+ })}+ </ul>+ )+}diff --git a/studio/src/components/FindingsPanel.tsx b/studio/src/components/FindingsPanel.tsxnew file mode 100644index 00000000..0ccd286a--- /dev/null+++ b/studio/src/components/FindingsPanel.tsx@@ -0,0 +1,63 @@+import type { Contradiction } from '../lib/demo-source'++export interface FindingsPanelProps {+ findings: Contradiction[]+ selected: string | null+ onSelect: (id: string) => void+}++const KIND_LABEL: Record<Contradiction['kind'], string> = {+ conformance: 'conformance',+ 'provenance-split': 'provenance split',+ disjointness: 'disjointness',+ typing: 'typing',+}++/**+ * Lists findings and cites the documents behind each one. Naming the+ * documents on every finding is the whole point of the panel: a count+ * without citations is not evidence. Takes data and a callback only, and+ * imports no source, so it renders identically whether the findings came+ * from a live SHACL run or the precomputed replay bundle.+ */+export function FindingsPanel({ findings, selected, onSelect }: FindingsPanelProps) {+ if (findings.length === 0) {+ return (+ <p className="p-4 text-sm" style={{ color: 'var(--text-secondary)' }}>+ No findings in this corpus.+ </p>+ )+ }+ return (+ <ul className="divide-y overflow-y-auto" style={{ borderColor: 'var(--border)' }}>+ {findings.map((f) => (+ <li+ key={f.id}+ onClick={() => onSelect(f.id)}+ className="cursor-pointer p-3"+ style={{+ borderColor: 'var(--border)',+ background: selected === f.id ? 'var(--bg-panel)' : 'transparent',+ }}+ >+ <div className="font-mono text-xs break-all" style={{ color: 'var(--text-primary)' }}>+ {f.subject}+ </div>+ <div className="text-xs mt-0.5" style={{ color: 'var(--accent)' }}>+ {KIND_LABEL[f.kind] ?? f.kind}+ </div>+ <ul className="mt-2 space-y-1 text-xs">+ {f.claims.map((c, i) => (+ <li key={i} style={{ color: 'var(--text-secondary)' }}>+ <span className="font-semibold" style={{ color: 'var(--text-primary)' }}>+ {c.document}+ </span>{' '}+ {c.predicate}: {c.object}+ </li>+ ))}+ </ul>+ </li>+ ))}+ </ul>+ )+}diff --git a/studio/src/components/Graph3D.tsx b/studio/src/components/Graph3D.tsxindex 00fffcc0..70a27460 100644--- a/studio/src/components/Graph3D.tsx+++ b/studio/src/components/Graph3D.tsx@@ -1,59 +1,57 @@import { useEffect, useRef, useState } from 'react';import ForceGraph3D from 'react-force-graph-3d';-import * as mcp from '../lib/mcp-client';+import type { GraphView } from '../lib/demo-source';/**- * 3D view of the knowledge graph: classes and individuals as nodes, subclass- * and property edges as links. Same store, same queries, different geometry.- * The 2D tree stays the analytical view; this one is spatial: clusters and- * hubs are visible at a glance, and the partition sits apart from the- * document plumbing.+ * 3D view of the knowledge graph: classes as nodes, subclass edges as+ * links. Same shape, same layout, different geometry from the 2D tree.+ *+ * This used to issue its own SPARQL (a document-and-entity provenance+ * projection) straight at the engine. That made it unusable in the replay+ * build, where there is no engine to query. It now takes `graph` as a prop+ * instead: the class/subclass queries this rendered live now live in+ * live-source.ts, behind the same DemoSource interface the replay build+ * satisfies from committed artifacts. Rendering, camera behaviour and+ * interaction handling are unchanged; only where the data comes from is.*/-interface GNode { id: string; name: string; group: string; val: number; }-interface GLink { source: string; target: string; kind: string; }+interface GNode { id: string; name: string; val: number; }+interface GLink { source: string; target: string; }-const COLORS: Record<string, string> = {- Document: '#89b4fa',- Individual: '#fab387',- conflict: '#f38ba8',-};+const NODE_COLOR = '#89b4fa';+const LINK_COLOR = '#45475a';function short(iri: string): string {const h = iri.lastIndexOf('#');return h >= 0 ? iri.slice(h + 1) : iri.slice(iri.lastIndexOf('/') + 1);}-const strip = (v: string) =>- v.startsWith('<') ? v.slice(1, -1) : v.replace(/^"(.*)"(@[\w-]+)?(\^\^.*)?$/, '$1');--async function rows(q: string): Promise<Array<Record<string, string>>> {- try {- const raw = await mcp.sparqlQuery(q);- return (JSON.parse(raw).results ?? []).map((r: Record<string, string>) => {- const o: Record<string, string> = {};- for (const [k, v] of Object.entries(r)) o[k] = strip(String(v));- return o;- });- } catch { return []; }+function toGraphData(graph: GraphView): { nodes: GNode[]; links: GLink[] } {+ const nodes = graph.classes.map((c) => ({ id: c.iri, name: c.label || short(c.iri), val: 3 }));+ const known = new Set(nodes.map((n) => n.id));+ const links = graph.edges+ .filter((e) => known.has(e.source) && known.has(e.target))+ .map((e) => ({ source: e.source, target: e.target }));+ return { nodes, links };}-export function Graph3D({ onNodeSelect }: {+export function Graph3D({ graph, onNodeSelect }: {+ graph: GraphView;onNodeSelect: (n: { id: string; label: string; uri: string } | null) => void;}) {- const [data, setData] = useState<{ nodes: GNode[]; links: GLink[] }>({ nodes: [], links: [] });+ const data = toGraphData(graph);const fgRef = useRef<{ d3Force: (name: string) => { distance?: (d: (l: GLink) => number) => void; strength?: (v: number) => void } | undefined; zoomToFit: (ms: number, px: number) => void } | null>(null);const framed = useRef(false);useEffect(() => {- // Pull the constellation together: short leashes on provenance edges,- // stronger mutual repulsion only at close range.const fg = fgRef.current;if (!fg || data.nodes.length === 0) return;framed.current = false;- fg.d3Force('link')?.distance?.((l: GLink) => (l.kind === 'cooc' ? 55 : l.kind === 'rel' ? 18 : 26));+ fg.d3Force('link')?.distance?.(() => 26);fg.d3Force('charge')?.strength?.(-35);- }, [data]);+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, [graph]);+const holder = useRef<HTMLDivElement>(null);const [size, setSize] = useState({ w: 800, h: 600 });@@ -65,131 +63,6 @@ export function Graph3D({ onNodeSelect }: {return () => ro.disconnect();}, []);- const load = async () => {- // The projection that answers "how does information interrelate between- // documents": documents as hubs, entities as the bridges between them.- // An entity shared by many documents pulls them together spatially; the- // contradiction sits visibly between the documents that disagree.- const P = 'PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> PREFIX owl: <http://www.w3.org/2002/07/owl#> PREFIX prov: <http://www.w3.org/ns/prov#>';- const prov = await rows(`${P} SELECT ?e ?d ?dl ?el WHERE { ?e prov:wasDerivedFrom ?d . ?d rdfs:label ?dl . OPTIONAL { ?e rdfs:label ?el } } LIMIT 2000`);- const conflicts = await rows(`${P} SELECT DISTINCT ?s WHERE { ?s a ?a, ?b . FILTER(STR(?a) < STR(?b)) { ?a owl:disjointWith ?b } UNION { ?b owl:disjointWith ?a } }`);- const rel = await rows(`${P} SELECT ?s ?o WHERE { ?s ?p ?o . ?o prov:wasDerivedFrom ?x . ?s prov:wasDerivedFrom ?y . FILTER(?p != prov:wasDerivedFrom && isIRI(?o)) } LIMIT 1500`);-- const conflicted = new Set(conflicts.map(r => r.s));- const nodes = new Map<string, GNode>();- const links: GLink[] = [];- const seen = new Set<string>();- const docsOf = new Map<string, number>();-- // No provenance in the store: fall back to an ontology projection so the- // view works on any loaded graph. Documents-and-entities is the richer- // picture, but it needs `?entity prov:wasDerivedFrom ?document` triples- // (see examples/document-privacy/provenance.py).- if (prov.length === 0) {- const classes = await rows(`${P} SELECT ?c ?l WHERE { { ?c a owl:Class } UNION { ?c rdfs:subClassOf ?x } OPTIONAL { ?c rdfs:label ?l } FILTER(!isBlank(?c)) } LIMIT 300`);- const subs = await rows(`${P} SELECT ?a ?b WHERE { ?a rdfs:subClassOf ?b . FILTER(!isBlank(?a) && !isBlank(?b)) }`);- const inds = await rows(`${P} SELECT ?i ?t ?l WHERE { ?i a ?t . ?t a owl:Class . OPTIONAL { ?i rdfs:label ?l } FILTER(!isBlank(?i)) } LIMIT 300`);- for (const r of classes) {- if (r.c) nodes.set(r.c, { id: r.c, name: r.l || short(r.c), group: 'Document', val: 3 });- }- for (const r of subs) {- if (nodes.has(r.a) && nodes.has(r.b)) links.push({ source: r.a, target: r.b, kind: 'rel' });- }- for (const r of inds) {- if (!r.i || !nodes.has(r.t)) continue;- if (!nodes.has(r.i)) {- nodes.set(r.i, {- id: r.i, name: r.l || short(r.i),- group: conflicted.has(r.i) ? 'conflict' : 'Individual', val: 1,- });- }- links.push({ source: r.i, target: r.t, kind: conflicted.has(r.i) ? 'conflictProv' : 'prov' });- }- setData({ nodes: [...nodes.values()], links });- return;- }-- for (const r of prov) {- if (!r.e || !r.d) continue;- if (!nodes.has(r.d)) nodes.set(r.d, { id: r.d, name: r.dl || short(r.d), group: 'Document', val: 6 });- if (!nodes.has(r.e)) {- nodes.set(r.e, {- id: r.e, name: r.el || short(r.e),- group: conflicted.has(r.e) ? 'conflict' : 'Individual', val: 1,- });- }- const k = r.e + '|' + r.d;- if (!seen.has(k)) {- seen.add(k);- links.push({ source: r.e, target: r.d, kind: conflicted.has(r.e) ? 'conflictProv' : 'prov' });- docsOf.set(r.e, (docsOf.get(r.e) ?? 0) + 1);- }- }- // entity-to-entity relationships, so structure inside a document shows too- for (const r of rel) {- if (nodes.has(r.s) && nodes.has(r.o) && r.s !== r.o) {- const k = 'rel|' + r.s + '|' + r.o;- if (!seen.has(k)) { seen.add(k); links.push({ source: r.s, target: r.o, kind: 'rel' }); }- }- }- for (const n of nodes.values()) {- if (n.group !== 'Document') n.val = Math.max(1, Math.min(9, (docsOf.get(n.id) ?? 1) * 1.6));- }-- // Prune for shape: sections and hundreds of one-document leaves turn the- // layout into spray. Shared entities, conflicted entities and anything in- // a relationship stay; singletons are sampled.- const inRel = new Set<string>();- for (const l of links) if (l.kind === 'rel') { inRel.add(l.source); inRel.add(l.target); }- let singletons = 0;- const keep = new Set<string>();- for (const n of nodes.values()) {- const sid = short(n.id);- if (n.group === 'Document') { keep.add(n.id); continue; }- if (sid.startsWith('SEC_') || sid.startsWith('CLAIM_')) continue;- const shared = (docsOf.get(n.id) ?? 0) >= 2;- if (n.group === 'conflict' || shared || inRel.has(n.id)) { keep.add(n.id); continue; }- if (singletons < 40) { keep.add(n.id); singletons += 1; }- }- let keptLinks = links.filter(l => keep.has(l.source) && keep.has(l.target));-- // One organism, not islands: documents that assert the same entities get- // a co-occurrence edge weighted by how much they share. This is the- // GraphRAG shape, and the edge is real: "these documents talk about the- // same things".- const docEnts = new Map<string, Set<string>>();- for (const l of keptLinks) {- if (l.kind === 'prov' || l.kind === 'conflictProv') {- if (!docEnts.has(l.target)) docEnts.set(l.target, new Set());- docEnts.get(l.target)!.add(l.source);- }- }- const docIds = [...docEnts.keys()];- for (let a = 0; a < docIds.length; a++) {- for (let b = a + 1; b < docIds.length; b++) {- const ea = docEnts.get(docIds[a])!, eb = docEnts.get(docIds[b])!;- let sharedN = 0;- for (const e of ea) if (eb.has(e)) sharedN += 1;- if (sharedN > 0) keptLinks.push({ source: docIds[a], target: docIds[b], kind: 'cooc' });- }- }- setData({ nodes: [...nodes.values()].filter(n => keep.has(n.id)), links: keptLinks });- };-- useEffect(() => {- load();- const w = window as unknown as { __refreshGraph?: () => void };- const prev = w.__refreshGraph;- w.__refreshGraph = () => { prev?.(); load(); };- const onRefresh = () => load();- window.addEventListener('lineage-refresh', onRefresh);- return () => {- window.removeEventListener('lineage-refresh', onRefresh);- w.__refreshGraph = prev;- };- // eslint-disable-next-line react-hooks/exhaustive-deps- }, []);-return (<div ref={holder} className="absolute inset-0" style={{ background: '#11111b' }}>{data.nodes.length === 0 ? (@@ -208,12 +81,12 @@ export function Graph3D({ onNodeSelect }: {graphData={data}backgroundColor="#11111b"nodeLabel={(n) => `<div style="font-family:sans-serif;font-size:12px">${(n as GNode).name}</div>`}- nodeColor={(n) => COLORS[(n as GNode).group] ?? '#a6adc8'}+ nodeColor={() => NODE_COLOR}nodeVal={(n) => (n as GNode).val}nodeOpacity={0.9}- linkColor={(l) => (l as GLink).kind === 'conflictProv' ? '#f38ba8' : (l as GLink).kind === 'rel' ? '#a6e3a1' : (l as GLink).kind === 'cooc' ? '#313244' : '#45475a'}+ linkColor={() => LINK_COLOR}linkOpacity={0.4}- linkWidth={(l) => (l as GLink).kind === 'conflictProv' ? 2 : (l as GLink).kind === 'cooc' ? 0.4 : (l as GLink).kind === 'rel' ? 0.6 : 0.9}+ linkWidth={0.9}onNodeClick={(n) => {const g = n as GNode;onNodeSelect({ id: short(g.id), label: g.name, uri: g.id });diff --git a/studio/src/components/Layout.tsx b/studio/src/components/LiveChrome.tsxsimilarity index 75%rename from studio/src/components/Layout.tsxrename to studio/src/components/LiveChrome.tsxindex 1b37f384..97ea4ae4 100644--- a/studio/src/components/Layout.tsx+++ b/studio/src/components/LiveChrome.tsx@@ -1,5 +1,6 @@import { useState, useEffect, useRef } from 'react';import { useEngine } from '../hooks/useEngine';+import { useDemoStore } from '../state/demo-store';import { TreeView } from './TreeView';import { Graph3D } from './Graph3D';import { ChatPanel } from './ChatPanel';@@ -7,14 +8,25 @@ import { PropertyInspector } from './PropertyInspector';import { LineagePanel } from './LineagePanel';import * as mcp from '../lib/mcp-client';-type ViewMode = 'tree';--export function Layout() {+/**+ * Desktop-only chrome: everything here needs a running engine and a live+ * agent sidecar, neither of which exists in the static web build. AppShell+ * lazy-loads this only when the source kind is "live", so none of it (or+ * the Tauri-coupled hooks it pulls in, useEngine and useChat via ChatPanel)+ * is ever evaluated in the replay bundle.+ *+ * The demonstration surfaces themselves (corpus, findings, resolution,+ * compare, the 3D graph) are NOT reimplemented here: this wraps them, it+ * does not duplicate them. AppShell renders that shared body and passes it+ * in as `children`; this component adds the ontology-authoring chrome+ * around it (chat, save/open, inspector, lineage, the 2D tree view) that+ * has no offline equivalent.+ */+export function LiveChrome({ children }: { children: React.ReactNode }) {const [showChat, setShowChat] = useState(true);const [graphMode, setGraphMode] = useState<'2d' | '3d'>('2d');const [showInspector, setShowInspector] = useState(false);const [showLineage, setShowLineage] = useState(false);- const [_viewMode, _setViewMode] = useState<ViewMode>('tree');const [selectedNode, setSelectedNode] = useState<{ id: string; label: string; uri: string } | null>(null);const [projectName, setProjectName] = useState('studio-live');const [savingAs, setSavingAs] = useState(false);@@ -22,17 +34,36 @@ export function Layout() {const [saveMsg, setSaveMsg] = useState<string | null>(null);const saveInputRef = useRef<HTMLInputElement>(null);const { status, stats, connect } = useEngine();+ const graph = useDemoStore((s) => s.graph);+ const refreshGraph = useDemoStore((s) => s.refreshGraph);useEffect(() => {connect();}, [connect]);- // Auto-show inspector when a node is selected+ // Chat-driven ontology mutations (onto_load, onto_apply, ...) happen over+ // the agent sidecar, entirely outside the demo-store. Graph3D no longer+ // queries the engine itself, so it needs telling when something changed.+ // useChat.ts and PropertyInspector already call window.__refreshGraph+ // after a mutation; this keeps that same contract rather than inventing+ // a second one, and now points it at the store instead of a component's+ // own local reload.+ useEffect(() => {+ const w = window as unknown as { __refreshGraph?: () => void };+ const prev = w.__refreshGraph;+ w.__refreshGraph = () => { prev?.(); refreshGraph(); };+ const onLineageRefresh = () => refreshGraph();+ window.addEventListener('lineage-refresh', onLineageRefresh);+ return () => {+ window.removeEventListener('lineage-refresh', onLineageRefresh);+ w.__refreshGraph = prev;+ };+ }, [refreshGraph]);+useEffect(() => {if (selectedNode) setShowInspector(true);}, [selectedNode]);- // Global keyboard shortcutsuseEffect(() => {const handler = (e: KeyboardEvent) => {if ((e.metaKey || e.ctrlKey) && e.key === 'j') {@@ -50,6 +81,7 @@ export function Layout() {};window.addEventListener('keydown', handler);return () => window.removeEventListener('keydown', handler);+ // eslint-disable-next-line react-hooks/exhaustive-deps}, [projectName]);function openSaveAs() {@@ -75,14 +107,12 @@ export function Layout() {return (<div className="h-screen flex flex-col" style={{ background: 'var(--bg-primary)' }}>- {/* Toolbar */}<div className="h-10 flex items-center px-4 border-b gap-3"style={{ borderColor: 'var(--border)', background: 'var(--bg-secondary)' }}><span className="text-sm font-semibold shrink-0" style={{ color: 'var(--accent)' }}>Open Ontologies</span>- {/* Project name / save-as input */}{savingAs ? (<div className="flex items-center gap-1"><input@@ -103,7 +133,7 @@ export function Layout() {style={{ background: 'var(--accent)', color: 'var(--bg-primary)' }}>Save</button><button onClick={() => setSavingAs(false)}className="text-xs px-2 py-0.5 rounded"- style={{ background: 'var(--bg-panel)', color: 'var(--text-secondary)' }}>✕</button>+ style={{ background: 'var(--bg-panel)', color: 'var(--text-secondary)' }}>✕</button></div>) : (<button@@ -112,7 +142,6 @@ export function Layout() {style={{ background: 'var(--bg-panel)', color: 'var(--text-secondary)', border: '1px solid var(--border)' }}title="Save as… (⌘S)">- <span>💾</span><span style={{ color: 'var(--text-primary)' }}>{projectName}.ttl</span></button>)}@@ -122,7 +151,6 @@ export function Layout() {)}<div className="ml-auto flex gap-2">- {/* View mode toggle */}<div className="w-px mx-1" style={{ background: 'var(--border)' }} /><div className="flex items-center rounded text-xs overflow-hidden"style={{ border: '1px solid var(--border)' }}>@@ -156,30 +184,20 @@ export function Layout() {</div></div>- {/* Main area */}<div className="flex-1 flex overflow-hidden">- {/* Graph canvas */}<div className="flex-1 relative">{graphMode === '2d'? <TreeView onNodeSelect={setSelectedNode} />- : <Graph3D onNodeSelect={setSelectedNode} />}+ : <Graph3D graph={graph} onNodeSelect={setSelectedNode} />}</div>- {/* Inspector panel */}{showInspector && (<div className="w-72 border-l overflow-hidden"style={{ borderColor: 'var(--border)', background: 'var(--bg-panel)' }}>- <PropertyInspector- node={selectedNode}- onGraphChanged={() => {- const refresh = (window as unknown as Record<string, () => void>).__refreshGraph;- if (refresh) refresh();- }}- />+ <PropertyInspector node={selectedNode} onGraphChanged={refreshGraph} /></div>)}- {/* Lineage panel */}{showLineage && (<div className="w-72 border-l flex flex-col overflow-hidden"style={{ borderColor: 'var(--border)', background: 'var(--bg-panel)' }}>@@ -187,7 +205,13 @@ export function Layout() {</div>)}- {/* Chat panel */}+ {/* The shared demonstration body (corpus / findings / resolution /+ compare), the same tree the replay build renders. */}+ <div className="w-96 border-l overflow-hidden flex flex-col"+ style={{ borderColor: 'var(--border)', background: 'var(--bg-secondary)' }}>+ {children}+ </div>+{showChat && (<div className="w-96 border-l flex flex-col"style={{ borderColor: 'var(--border)', background: 'var(--bg-secondary)' }}>@@ -196,7 +220,6 @@ export function Layout() {)}</div>- {/* Status bar */}<div className="h-6 flex items-center px-4 text-xs border-t gap-4"style={{ borderColor: 'var(--border)', background: 'var(--bg-secondary)',color: 'var(--text-secondary)' }}>@@ -210,7 +233,6 @@ export function Layout() {<span>{stats.triples} triples | {stats.classes} classes | {stats.properties} properties</span>)}</div>-</div>);}diff --git a/studio/src/components/ResolutionPanel.tsx b/studio/src/components/ResolutionPanel.tsxnew file mode 100644index 00000000..279347ab--- /dev/null+++ b/studio/src/components/ResolutionPanel.tsx@@ -0,0 +1,84 @@+import type { Contradiction, Decision } from '../lib/demo-source'++export interface ResolutionPanelProps {+ finding: Contradiction | null+ ledger: { id: string; decision: Decision }[]+ onResolve: (id: string, decision: Decision) => void+}++/**+ * The selected finding's claims, with accept/reject controls, and the+ * ledger of decisions made so far. Takes data and a callback only, and+ * imports no source: whether a decision actually persists anywhere (it+ * does not in live mode today, see live-source.ts's resolve()) is the+ * store's problem, surfaced through `error`, not this panel's.+ */+export function ResolutionPanel({ finding, ledger, onResolve }: ResolutionPanelProps) {+ return (+ <div className="flex flex-col h-full overflow-y-auto">+ <div className="p-3">+ {!finding ? (+ <p className="text-sm" style={{ color: 'var(--text-secondary)' }}>+ Select a finding to review its claims.+ </p>+ ) : (+ <>+ <div className="font-mono text-xs break-all mb-2" style={{ color: 'var(--text-primary)' }}>+ {finding.subject}+ </div>+ <ul className="space-y-2 text-xs">+ {finding.claims.map((c, i) => (+ <li key={i} className="p-2 rounded" style={{ background: 'var(--bg-panel)' }}>+ <div style={{ color: 'var(--accent)' }}>{c.document}</div>+ <div style={{ color: 'var(--text-secondary)' }}>+ {c.predicate}: <span style={{ color: 'var(--text-primary)' }}>{c.object}</span>+ </div>+ </li>+ ))}+ </ul>+ <div className="flex gap-2 mt-3">+ <button+ onClick={() => onResolve(finding.id, { kind: 'accept' })}+ className="text-xs px-3 py-1.5 rounded font-medium"+ style={{ background: 'var(--success)', color: 'var(--bg-primary)' }}+ >+ Accept+ </button>+ <button+ onClick={() => onResolve(finding.id, { kind: 'reject' })}+ className="text-xs px-3 py-1.5 rounded font-medium"+ style={{ background: 'var(--error)', color: 'var(--bg-primary)' }}+ >+ Reject+ </button>+ </div>+ </>+ )}+ </div>++ <div className="mt-auto border-t p-3" style={{ borderColor: 'var(--border)' }}>+ <div className="text-xs font-semibold uppercase tracking-wide mb-2" style={{ color: 'var(--text-secondary)' }}>+ Ledger {ledger.length > 0 ? `(${ledger.length})` : ''}+ </div>+ {ledger.length === 0 ? (+ <p className="text-xs" style={{ color: 'var(--text-secondary)' }}>+ No decisions recorded yet.+ </p>+ ) : (+ <ol className="space-y-1 text-xs">+ {ledger.map((entry, i) => (+ <li key={i} style={{ color: 'var(--text-secondary)' }}>+ <span className="font-mono">{entry.id}</span>{' '}+ <span+ style={{ color: entry.decision.kind === 'accept' ? 'var(--success)' : 'var(--error)' }}+ >+ {entry.decision.kind}+ </span>+ </li>+ ))}+ </ol>+ )}+ </div>+ </div>+ )+}diff --git a/studio/src/lib/__tests__/compare-source.test.ts b/studio/src/lib/__tests__/compare-source.test.tsnew file mode 100644index 00000000..b83d94ce--- /dev/null+++ b/studio/src/lib/__tests__/compare-source.test.ts@@ -0,0 +1,57 @@+import { describe, it, expect } from 'vitest'+import { createReplayCompareSource, compareFixturesFromBundle } from '../compare-source'++const fixture = {+ 'does this profile implement W3C DCAT?': {+ question: 'does this profile implement W3C DCAT?',+ grounded: {+ answer: 'No. The published examples expand to 76 triples and no DCAT predicates.',+ citations: ['examples.json', 'w3c-dcat-conformance.md'],+ },+ baseline: {+ answer: 'Yes. The README states it is an implementation of the W3C DCAT standard.',+ citations: ['profile-readme.md'],+ },+ divergence: 'The baseline repeats the claim. The grounded answer checks it against the artifacts.',+ },+}++describe('ReplayCompareSource', () => {+ it('returns both answers with their citations', async () => {+ const src = createReplayCompareSource(fixture)+ const r = await src.compare('does this profile implement W3C DCAT?')+ expect(r.grounded.citations).toContain('examples.json')+ expect(r.baseline.citations).toEqual(['profile-readme.md'])+ expect(r.divergence).not.toBeNull()+ })++ it('reports an unscripted question rather than fabricating a comparison', async () => {+ const src = createReplayCompareSource(fixture)+ const r = await src.compare('something nobody scripted')+ expect(r.divergence).toBeNull()+ expect(r.grounded.answer).toMatch(/not scripted|offline replay/i)+ })+})++describe('compareFixturesFromBundle', () => {+ // bundle.json carries a fifth top-level key, "compare", that+ // ReplayFixtures (demo-source.ts / replay-source.ts) only tolerates+ // through an index signature rather than naming. This is the one place+ // that reaches into it, so the reconciliation is regression-tested+ // directly rather than only exercised indirectly through a fetch.+ it('extracts the compare key from a bundle carrying the other four DemoSource keys too', () => {+ const bundle = {+ corpus: [{ id: 'doc-1', title: 'doc-1', text: 'irrelevant to this test' }],+ graph: { classes: [], properties: [], edges: [] },+ findings: [],+ chat: {},+ compare: fixture,+ }+ expect(compareFixturesFromBundle(bundle)).toBe(fixture)+ })++ it('throws rather than silently returning an empty comparison set when the key is missing', () => {+ const bundle = { corpus: [], graph: { classes: [], properties: [], edges: [] }, findings: [], chat: {} }+ expect(() => compareFixturesFromBundle(bundle)).toThrow(/compare/)+ })+})diff --git a/studio/src/lib/compare-source.ts b/studio/src/lib/compare-source.tsnew file mode 100644index 00000000..88abf60c--- /dev/null+++ b/studio/src/lib/compare-source.ts@@ -0,0 +1,83 @@+import { chooseSourceKind } from './source-factory'++// Deliberately a separate interface from DemoSource (see demo-source.ts).+// Tasks 9 through 11 stay untouched, and the comparison is an optional demo+// surface layered on top rather than a fifth core method.+export interface CompareResult {+ question: string+ grounded: { answer: string; citations: string[] }+ baseline: { answer: string; citations: string[] }+ divergence: string | null+}++export interface CompareSource {+ compare(question: string): Promise<CompareResult>+}++export type CompareFixtures = Record<string, CompareResult>++export function createReplayCompareSource(fixtures: CompareFixtures): CompareSource {+ return {+ async compare(question: string): Promise<CompareResult> {+ const hit = fixtures[question] ?? fixtures[question.trim().toLowerCase()]+ if (hit) return hit+ return {+ question,+ grounded: {+ answer: 'This question is not scripted in the offline replay.',+ citations: [],+ },+ baseline: { answer: '', citations: [] },+ divergence: null,+ }+ },+ }+}++// The precomputed bundle (demo/precomputed/bundle.json) carries a fifth+// top-level key, "compare", alongside the four ReplayFixtures declares+// (corpus, graph, findings, chat). ReplayFixtures tolerates that with an+// index signature rather than naming it, precisely so CompareSource stays+// out of DemoSource's shape. This function is the one place that reaches+// into the extra key, so every other module can go on treating+// ReplayFixtures as a four-key type.+export function compareFixturesFromBundle(bundle: Record<string, unknown>): CompareFixtures {+ const raw = bundle.compare+ if (!raw || typeof raw !== 'object') {+ throw new Error(+ 'The precomputed bundle has no "compare" key (or it is not an object); the ' ++ 'baseline comparison cannot be shown.',+ )+ }+ return raw as CompareFixtures+}++// The single construction site for CompareSource, mirroring+// getDemoSource() in source-factory.ts. In replay mode it reads the same+// bundle.json DemoSource does and pulls the "compare" key out of it via+// compareFixturesFromBundle. In live mode there is no honest+// implementation yet: the divergence judgment between the grounded and+// baseline answers is a human read over both transcripts (see+// demo/build_compare.py's module docstring), not something a running+// session can compute for an arbitrary question, so this says that plainly+// instead of inventing a verdict.+export async function getCompareSource(): Promise<CompareSource> {+ if (chooseSourceKind(import.meta.env as unknown as Record<string, string | undefined>) === 'replay') {+ const response = await fetch('./precomputed/bundle.json')+ if (!response.ok) {+ throw new Error(`Could not load the precomputed demonstration: ${response.status}`)+ }+ const bundle = (await response.json()) as Record<string, unknown>+ return createReplayCompareSource(compareFixturesFromBundle(bundle))+ }+ return {+ async compare(question: string): Promise<CompareResult> {+ throw new Error(+ `No live comparison is implemented for "${question}". The grounded-vs-baseline ` ++ 'divergence is a human judgment made once over a fixed question set (see ' ++ 'demo/build_compare.py), not something a live session computes on demand. Run ' ++ 'the offline replay (npm run build:web) to see the precomputed comparison.',+ )+ },+ }+}diff --git a/studio/src/main.tsx b/studio/src/main.tsxindex 14972374..58bbbbce 100644--- a/studio/src/main.tsx+++ b/studio/src/main.tsx@@ -1,17 +1,14 @@import React from "react";import ReactDOM from "react-dom/client";import App from "./App";-import { PublicDemo } from "./PublicDemo";-import { chooseSourceKind } from "./lib/source-factory";--// The static web build (npm run build:web) sets VITE_DEMO_MODE=replay. The-// desktop Tauri shell never sets it, so it always gets the full App, which-// talks to the bundled engine. This is the same construction site-// getDemoSource() reads; here it picks the surface, there it picks the data.-const isReplay = chooseSourceKind(import.meta.env as unknown as Record<string, string | undefined>) === "replay";+// AppShell (mounted by App) is the single shell for both build targets: it+// reads DemoSource through the demo-store and picks its own chrome based on+// the same VITE_DEMO_MODE construction site source-factory.ts uses to pick+// live vs. replay data. There is no longer a second, parallel shell here for+// the static web build to fall back to.ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(<React.StrictMode>- {isReplay ? <PublicDemo /> : <App />}+ <App /></React.StrictMode>,);diff --git a/studio/src/state/__tests__/demo-store.test.ts b/studio/src/state/__tests__/demo-store.test.tsnew file mode 100644index 00000000..640fe5e2--- /dev/null+++ b/studio/src/state/__tests__/demo-store.test.ts@@ -0,0 +1,164 @@+import { describe, it, expect, vi, beforeEach } from 'vitest'+import type { DemoSource } from '../../lib/demo-source'++const getDemoSource = vi.fn<() => Promise<DemoSource>>()+vi.mock('../../lib/source-factory', () => ({ getDemoSource: () => getDemoSource() }))++// Imported after the mock so the store's own `import { getDemoSource } from+// '../lib/source-factory'` resolves to the mocked function above.+const { useDemoStore } = await import('../demo-store')++function fakeSource(overrides: Partial<DemoSource> = {}): DemoSource {+ return {+ corpus: vi.fn(async () => [{ id: 'doc-1', title: 'doc-1', text: 'hello' }]),+ graph: vi.fn(async () => ({ classes: [{ iri: 'ex:Dataset' }], properties: [], edges: [] })),+ findings: vi.fn(async () => [+ { id: 'f1', subject: 'ex:s', kind: 'conformance' as const, claims: [] },+ ]),+ resolve: vi.fn(async () => {}),+ ask: vi.fn(async function* () {+ yield { type: 'text' as const, value: 'an answer' }+ }),+ ...overrides,+ }+}++const RESET = useDemoStore.getState()++beforeEach(() => {+ useDemoStore.setState(RESET, true)+ getDemoSource.mockReset()+})++describe('useDemoStore.load', () => {+ it('populates graph, findings and documents from the source', async () => {+ getDemoSource.mockResolvedValue(fakeSource())+ await useDemoStore.getState().load()+ const s = useDemoStore.getState()+ expect(s.graph.classes).toHaveLength(1)+ expect(s.findings).toHaveLength(1)+ expect(s.documents).toEqual([{ id: 'doc-1', title: 'doc-1', text: 'hello' }])+ expect(s.documentsError).toBeNull()+ expect(s.error).toBeNull()+ expect(s.loading).toBe(false)+ })++ it('surfaces an error and never masks it with empty data when graph/findings fail', async () => {+ getDemoSource.mockResolvedValue({+ ...fakeSource(),+ graph: vi.fn(async () => {+ throw new Error('engine not listening')+ }),+ })+ await useDemoStore.getState().load()+ const s = useDemoStore.getState()+ expect(s.error).toMatch(/engine not listening/)+ expect(s.loading).toBe(false)+ })++ // The behaviour this test protects: live-source.ts's corpus() throws+ // (no tool returns document text in live mode), and that must degrade+ // only the corpus panel, not the whole shell.+ it('keeps graph and findings even when corpus() has no honest implementation', async () => {+ getDemoSource.mockResolvedValue({+ ...fakeSource(),+ corpus: vi.fn(async () => {+ throw new Error('no tool or Tauri command returns document text')+ }),+ })+ await useDemoStore.getState().load()+ const s = useDemoStore.getState()+ expect(s.graph.classes).toHaveLength(1)+ expect(s.findings).toHaveLength(1)+ expect(s.error).toBeNull()+ expect(s.documents).toEqual([])+ expect(s.documentsError).toMatch(/document text/)+ })+})++describe('useDemoStore.refreshGraph', () => {+ it('re-fetches only the graph, leaving findings and documents alone', async () => {+ useDemoStore.setState({ findings: [{ id: 'kept', subject: 's', kind: 'conformance', claims: [] }] })+ getDemoSource.mockResolvedValue(+ fakeSource({ graph: vi.fn(async () => ({ classes: [{ iri: 'ex:New' }], properties: [], edges: [] })) }),+ )+ await useDemoStore.getState().refreshGraph()+ const s = useDemoStore.getState()+ expect(s.graph.classes).toEqual([{ iri: 'ex:New' }])+ expect(s.findings).toEqual([{ id: 'kept', subject: 's', kind: 'conformance', claims: [] }])+ })+})++describe('useDemoStore.select', () => {+ it('sets and clears the selected finding', () => {+ useDemoStore.getState().select('f1')+ expect(useDemoStore.getState().selectedFinding).toBe('f1')+ useDemoStore.getState().select(null)+ expect(useDemoStore.getState().selectedFinding).toBeNull()+ })+})++describe('useDemoStore.resolve', () => {+ it('appends to the ledger on success', async () => {+ const source = fakeSource()+ getDemoSource.mockResolvedValue(source)+ await useDemoStore.getState().resolve('f1', { kind: 'accept' })+ expect(useDemoStore.getState().ledger).toEqual([{ id: 'f1', decision: { kind: 'accept' } }])+ expect(source.resolve).toHaveBeenCalledWith('f1', { kind: 'accept' })+ })++ it('surfaces an error and does not touch the ledger on failure', async () => {+ getDemoSource.mockResolvedValue({+ ...fakeSource(),+ resolve: vi.fn(async () => {+ throw new Error('no engine tool resolves a finding by id')+ }),+ })+ await useDemoStore.getState().resolve('f1', { kind: 'accept' })+ const s = useDemoStore.getState()+ expect(s.ledger).toEqual([])+ expect(s.error).toMatch(/no engine tool/)+ })+})++describe('useDemoStore.ask', () => {+ it('appends streamed chunks to the chat log', async () => {+ getDemoSource.mockResolvedValue(fakeSource())+ await useDemoStore.getState().ask('what disagrees?')+ const s = useDemoStore.getState()+ expect(s.chat).toEqual([{ type: 'text', value: 'an answer' }])+ expect(s.chatPending).toBe(false)+ })++ // A distinct chunk TYPE, not wording, is what tells an unscripted answer+ // apart from a real one; the store must pass that through untouched.+ it('preserves the unscripted chunk type rather than collapsing it into text', async () => {+ getDemoSource.mockResolvedValue(+ fakeSource({+ ask: vi.fn(async function* () {+ yield {+ type: 'unscripted' as const,+ value: 'This is the offline replay of the demonstration.',+ }+ }),+ }),+ )+ await useDemoStore.getState().ask('something nobody scripted')+ expect(useDemoStore.getState().chat).toEqual([+ { type: 'unscripted', value: 'This is the offline replay of the demonstration.' },+ ])+ })++ it('surfaces an error rather than leaving chatPending stuck', async () => {+ getDemoSource.mockResolvedValue({+ ...fakeSource(),+ ask: vi.fn(() => {+ throw new Error('chat does not run through DemoSource in live mode')+ }),+ })+ await useDemoStore.getState().ask('anything')+ const s = useDemoStore.getState()+ expect(s.chatPending).toBe(false)+ expect(s.error).toMatch(/agent sidecar|live mode/i)+ })+})diff --git a/studio/src/state/demo-store.ts b/studio/src/state/demo-store.tsnew file mode 100644index 00000000..5d28e57e--- /dev/null+++ b/studio/src/state/demo-store.ts@@ -0,0 +1,116 @@+import { create } from 'zustand'+import type { Chunk, Contradiction, Decision, Document, GraphView } from '../lib/demo-source'+import { getDemoSource } from '../lib/source-factory'++interface DemoState {+ documents: Document[]+ // corpus() has no honest implementation in live mode today (see+ // live-source.ts: no tool or Tauri command returns document text), and+ // that must not read the same as "this corpus has zero documents". Kept+ // separate from `error` so a dead corpus panel never masks a working+ // graph and findings panel underneath it.+ documentsError: string | null+ graph: GraphView+ findings: Contradiction[]+ selectedFinding: string | null+ ledger: { id: string; decision: Decision }[]+ chat: Chunk[]+ chatPending: boolean+ error: string | null+ loading: boolean+ load: () => Promise<void>+ // Re-fetches only the graph. Chat-driven ontology mutations in the live+ // desktop app (onto_load, onto_apply, onto_reason, ...) happen outside+ // this store, over the agent sidecar; LiveChrome calls this afterwards so+ // Graph3D, which now reads graph state instead of querying the engine+ // itself, still updates.+ refreshGraph: () => Promise<void>+ select: (id: string | null) => void+ resolve: (id: string, decision: Decision) => Promise<void>+ ask: (question: string) => Promise<void>+}++const EMPTY_GRAPH: GraphView = { classes: [], properties: [], edges: [] }++// The only module in the frontend that touches a DemoSource. Components+// take data and callbacks as props, so the same tree renders live against+// the engine and offline from the precomputed artifacts.+export const useDemoStore = create<DemoState>((set, get) => ({+ documents: [],+ documentsError: null,+ graph: EMPTY_GRAPH,+ findings: [],+ selectedFinding: null,+ ledger: [],+ chat: [],+ chatPending: false,+ error: null,+ loading: false,++ async load() {+ set({ loading: true, error: null })+ try {+ const source = await getDemoSource()++ // graph() and findings() are honestly implemented in both live and+ // replay mode, so a failure here is a real error (engine down,+ // session lost) and is surfaced as one.+ const [graph, findings] = await Promise.all([source.graph(), source.findings()])+ set({ graph, findings, loading: false })+ } catch (e) {+ // Surfaced, never swallowed. An empty graph and a dead engine must not look alike.+ set({ error: e instanceof Error ? e.message : String(e), loading: false })+ return+ }++ // corpus() is fetched separately and after the above, on purpose: today+ // it throws in live mode (no tool reaches document text there), and+ // that must degrade the corpus panel alone, not take the graph and+ // findings panels down with it.+ try {+ const source = await getDemoSource()+ const documents = await source.corpus()+ set({ documents, documentsError: null })+ } catch (e) {+ set({ documents: [], documentsError: e instanceof Error ? e.message : String(e) })+ }+ },++ async refreshGraph() {+ try {+ const source = await getDemoSource()+ const graph = await source.graph()+ set({ graph })+ } catch (e) {+ set({ error: e instanceof Error ? e.message : String(e) })+ }+ },++ select(id) {+ set({ selectedFinding: id })+ },++ async resolve(id, decision) {+ try {+ const source = await getDemoSource()+ await source.resolve(id, decision)+ set({ ledger: [...get().ledger, { id, decision }] })+ } catch (e) {+ set({ error: e instanceof Error ? e.message : String(e) })+ }+ },++ async ask(question) {+ set({ chatPending: true })+ try {+ const source = await getDemoSource()+ const chunks: Chunk[] = []+ for await (const chunk of source.ask(question)) {+ chunks.push(chunk)+ }+ set({ chat: [...get().chat, ...chunks], chatPending: false })+ } catch (e) {+ set({ error: e instanceof Error ? e.message : String(e), chatPending: false })+ }+ },+}))