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/lib/llm/analyze/requirements.ts

@@ -0,0 +1,104 @@
+// Analyze pass: extract requirements from prose with traceability hints.
+
+import "server-only";
+import { defaultGateway, chatJSON, type Message } from "../gateway";
+import { loadPrompt } from "../prompts";
+import type { DetectedRequirement } from "../../db/repo";
+
+const reqsJsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["requirements"],
+  properties: {
+    requirements: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["tag", "text"],
+        properties: {
+          tag: { type: "string", minLength: 1 },
+          text: { type: "string", minLength: 1 },
+          tracedToLabels: { type: "array", items: { type: "string" } },
+          /// Optional concept the requirement is conceptually "about." Lets the
+          /// requirement render a back-link to the term in TermDetail even when
+          /// the term has no formalized block yet.
+          linkedTermLabel: { type: "string" },
+        },
+      },
+    },
+  },
+} as const;
+
+export interface RequirementsResult {
+  reqs: DetectedRequirement[];
+  inputTokens: number;
+  outputTokens: number;
+  provider: string;
+  model: string;
+}
+
+export async function analyzeRequirements(
+  documentText: string,
+  terms: Array<{ id: string; label: string; linkedBlockId: string | null }>
+): Promise<RequirementsResult> {
+  const prompt = loadPrompt("socrates/analyze-requirements.md");
+  const gateway = defaultGateway();
+  const userPayload =
+    `Document:\n\n${documentText}\n\n---\n\n` +
+    `Available term labels:\n${JSON.stringify(terms.map(t => t.label))}`;
+
+  const messages: Message[] = [
+    { role: "system", content: prompt },
+    { role: "user", content: userPayload },
+  ];
+
+  const { value, result } = await chatJSON<{
+    requirements?: Array<{
+      tag?: string;
+      text?: string;
+      tracedToLabels?: string[];
+      linkedTermLabel?: string;
+    }>;
+  }>(gateway, messages, {
+    temperature: 0.2,
+    maxTokens: 1500,
+    jsonSchema: { name: "requirements", schema: reqsJsonSchema as Record<string, unknown> },
+    jsonObjectMode: true,
+    maxRepairs: 2,
+  });
+
+  // Map term labels → block ids via the term-to-block links + label → termId.
+  const labelToBlock = new Map<string, string>();
+  const labelToTermId = new Map<string, string>();
+  for (const t of terms) {
+    if (t.linkedBlockId) labelToBlock.set(t.label.toLowerCase(), t.linkedBlockId);
+    labelToTermId.set(t.label.toLowerCase(), t.id);
+  }
+
+  const reqs: DetectedRequirement[] = [];
+  for (const r of value?.requirements ?? []) {
+    const tag = (r.tag ?? "").trim();
+    const text = (r.text ?? "").trim();
+    if (!tag || !text) continue;
+    const blockIds = (r.tracedToLabels ?? [])
+      .map(l => labelToBlock.get(l.toLowerCase()))
+      .filter((id): id is string => Boolean(id));
+    const linkedTermId = r.linkedTermLabel ? labelToTermId.get(r.linkedTermLabel.toLowerCase()) : undefined;
+    reqs.push({
+      tag,
+      text,
+      tracedToIds: blockIds,
+      unsupported: blockIds.length === 0,
+      linkedTermId: linkedTermId ?? null,
+    });
+  }
+
+  return {
+    reqs,
+    inputTokens: result.inputTokens,
+    outputTokens: result.outputTokens,
+    provider: gateway.provider,
+    model: gateway.model,
+  };
+}