Pivot to text-first column-stack workspace + merge-with-review across AI artifacts

Workspace
- Pivot from "set of open panes" to a Finder-style miller column stack:
  TopBar / LeftSidebar / [section → entity → entity ...] / pinned text editor.
  openPanesStore is now an ordered Column[] with pushFrom / closeFrom /
  setStack; only one top-level section is rooted at a time.
- New entity column panes: Term, Block, Association, Constraint,
  Requirement, Finding. Click-through navigation truncates deeper
  columns automatically.
- LeftSidebar surfaces a pending-count chip per section (single-glance
  navigation cue) and spins its analyze ↻ via SVG Spinner whenever the
  LLM is working — including server-initiated runs caught by the runs
  poll, not just user-triggered ones.

Analyze pipeline + persistence
- Unified `concepts` pass (taxonomy + glossary in one LLM call) replaces
  the two-pass setup. Server still accepts ?section=taxonomy|glossary
  and normalizes them for back-compat.
- model / requirements / detection (assumptions, risks, inconsistencies)
  + cross-layer validation rules (X1–X4: stale term link, unlinked
  formalism, undefined linked term, prose-only term).
- Persistence: NarrativeDocument, ModelSnapshot, ChangelogEntry,
  TaxonomyTerm, RequirementEntry, Finding, AnalysisRun. Re-runs MERGE
  instead of replace: gentle update on existing items, suggested on new,
  deprecated on missing — same idiom for every artifact kind. User pins
  preserve "kept" decisions across re-analyses.
- Migrations: pivot_text_first, add_requirement_linked_term,
  term_review_state, review_state_for_reqs_and_findings,
  add_term_definition_pinned.

Concept ↔ ontology integration
- linkedTermId on Block / Association / Constraint / Requirement.
  PromoteToolbar lets the user formalize a concept inline: + Block /
  + Association / + Constraint / + Requirement, all routed through
  applyOps so undo/redo and SSE work for free.
- decideElement op for in-canvas keep/discard on review-pending model
  elements.

User-authored definitions
- TermColumn definition is click-to-edit. Save (Cmd-Enter / blur),
  Cancel (Esc), Reset to AI suggestion when pinned.
- definitionPinned flag on TaxonomyTerm: future Analyze runs leave the
  user's text alone. setTermDefinition repo function + POST
  /api/projects/[id]/terms/[termId]/definition endpoint.
- mergeTaxonomySuggestion + applyGlossaryDefinitions both pin-aware.

UX/UI
- StatusChip: single component for all state idioms (suggested,
  deprecated, accepted, dismissed, resolved, severity, validation code,
  confidence, warn). Replaces 5+ ad-hoc badge classes.
- PaneControls (PaneViewTabs + PaneFilterChip): separates view-mode
  toggles from filter chips so toggling Pending no longer flips you off
  the current view.
- PaneEmpty: unified empty-state with title + hint + action.
- PaneDrawer: collapsible groups for Pending / Discarded review; cards
  group as Kept (top) → Pending (bottom drawer) → Discarded (Findings
  only, hidden when empty). Restore action recovers dismissed/resolved
  findings.
- ConceptCard unifies Tree and A–Z views in Concepts; only Tree parents
  carry the chevron (no empty placeholder offset).
- Type + spacing tokens (--text-xs..xl, --space-1..6, --lh-tight/ui/
  prose, --radius-*) replace every ad-hoc value.
- Buttons standardized to body sans 500 (was a mishmash of mono / display).
- Card shells unified across Concepts / Requirements / Findings.

Cleanup
- Removed: LeftRail, FindingsPanel, IssuesPanel, SocratesDock,
  ProposalCard, SlashMenu, SlashExtension, slashSuggestion,
  CanvasHeader, TaxonomyPane, GlossaryPane, TermDetail (popover; now
  TermColumn).
- Section ids in openPanesStore: dropped taxonomy/glossary, added
  concepts. localStorage migration runs on hydrate.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

apps/web/app/api/projects/[projectId]/findings/[findingId]/decision/route.ts

@@ -0,0 +1,51 @@
+// Per-finding keep/discard/resolve/restore decision.
+//
+// Body: { decision: "keep" | "discard" | "resolve" | "restore" }
+//   keep    → status="accepted" (visible). If was "deprecated", also pinned.
+//   discard → status="dismissed". Persists; future detections skip it.
+//   resolve → status="resolved". Like discard but signals "I fixed it."
+//   restore → status="accepted", pinned cleared. Recovers a dismissed/
+//             resolved finding from the Discarded drawer.
+
+import { NextResponse } from "next/server";
+import {
+  setFindingDecision,
+  restoreFinding,
+  type FindingDecision,
+} from "../../../../../../../lib/db/repo";
+
+interface RouteContext {
+  params: Promise<{ projectId: string; findingId: string }>;
+}
+
+export async function POST(req: Request, ctx: RouteContext) {
+  const { findingId } = await ctx.params;
+  let body: { decision?: string };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "invalid json body" }, { status: 400 });
+  }
+  const decision = body.decision;
+  if (
+    decision !== "keep" &&
+    decision !== "discard" &&
+    decision !== "resolve" &&
+    decision !== "restore"
+  ) {
+    return NextResponse.json(
+      { error: "decision must be 'keep', 'discard', 'resolve', or 'restore'" },
+      { status: 400 }
+    );
+  }
+  try {
+    const finding =
+      decision === "restore"
+        ? await restoreFinding(findingId)
+        : await setFindingDecision(findingId, decision as FindingDecision);
+    return NextResponse.json({ finding });
+  } catch (err) {
+    console.error("[finding/decision] failed:", err);
+    return NextResponse.json({ error: (err as Error).message }, { status: 500 });
+  }
+}

apps/web/app/api/projects/[projectId]/findings/[findingId]/socrates/route.ts

@@ -0,0 +1,81 @@
+// Per-finding contextual Socrates thread.
+// GET → loads existing messages.
+// POST → sends a user turn; if the thread is empty, primes it with the
+//        finding text so Socrates' opening turn engages with the finding.
+
+import { NextResponse } from "next/server";
+import { prisma } from "../../../../../../../lib/db/client";
+import { loadProject } from "../../../../../../../lib/db/repo";
+import { validate } from "../../../../../../../lib/sysml/validate";
+import {
+  getOrCreateAnchoredThread,
+  listAnchoredThreadMessages,
+  sendUserTurn,
+} from "../../../../../../../lib/llm/socrates";
+
+interface RouteContext {
+  params: Promise<{ projectId: string; findingId: string }>;
+}
+
+export async function GET(_req: Request, ctx: RouteContext) {
+  const { projectId, findingId } = await ctx.params;
+  const finding = await prisma.finding.findUnique({ where: { id: findingId } });
+  if (!finding || finding.projectId !== projectId) {
+    return NextResponse.json({ error: "finding not found" }, { status: 404 });
+  }
+  const threadId = await getOrCreateAnchoredThread(projectId, `finding:${findingId}`, finding.text);
+  const messages = await listAnchoredThreadMessages(threadId);
+  return NextResponse.json({ threadId, finding: { id: finding.id, text: finding.text, kind: finding.kind }, messages });
+}
+
+export async function POST(req: Request, ctx: RouteContext) {
+  const { projectId, findingId } = await ctx.params;
+  let body: { text?: string } = {};
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
+  }
+
+  const finding = await prisma.finding.findUnique({ where: { id: findingId } });
+  if (!finding || finding.projectId !== projectId) {
+    return NextResponse.json({ error: "finding not found" }, { status: 404 });
+  }
+
+  const threadId = await getOrCreateAnchoredThread(projectId, `finding:${findingId}`, finding.text);
+
+  // If the thread is empty, prime with the finding text as the opening user
+  // turn so Socrates engages with the right thing.
+  const existing = await listAnchoredThreadMessages(threadId);
+  let userText = (body.text ?? "").trim();
+  if (existing.length === 0 && !userText) {
+    userText = `Discuss this ${finding.kind}: "${finding.text}"`;
+  }
+
+  const { model } = await loadProject(projectId);
+  const issues = validate(model);
+
+  const result = await sendUserTurn({ threadId, model, issues, userText });
+  return NextResponse.json({ threadId, ...result });
+}
+
+export async function PATCH(req: Request, ctx: RouteContext) {
+  // Resolve / dismiss the finding from the contextual thread.
+  const { projectId, findingId } = await ctx.params;
+  let body: { status?: string } = {};
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
+  }
+  const status = body.status;
+  if (status !== "resolved" && status !== "dismissed" && status !== "open") {
+    return NextResponse.json({ error: "invalid status" }, { status: 400 });
+  }
+  const finding = await prisma.finding.findUnique({ where: { id: findingId } });
+  if (!finding || finding.projectId !== projectId) {
+    return NextResponse.json({ error: "finding not found" }, { status: 404 });
+  }
+  await prisma.finding.update({ where: { id: findingId }, data: { status } });
+  return NextResponse.json({ ok: true, status });
+}