tenbo-dashboard 0.5.0 → 0.7.0

package/src/api/lib/validator.duplicateIds.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { validate } from './validator';
+import type { TenboState, Item } from '../../types';
+
+const baseItem = (over: Partial<Item> = {}): Item => ({
+  id: 'ed-001',
+  title: 't',
+  layer: 'l',
+  status: 'later',
+  description: 'a roadmap item used for duplicate-id tests now',
+  ...over,
+});
+
+function stateWithScopeItems(items: Item[], archived: Item[] = []): TenboState {
+  return {
+    scopes: [{
+      id: 'e',
+      path: '.',
+      description: 'editor scope description here for tests',
+      layers: [{ id: 'l', name: 'L', description: 'a small layer for testing now', files: ['x'] } as any],
+      items,
+      archivedItems: archived,
+    }],
+    crossCutting: [],
+    narratives: { 'e/l': '# L' },
+  } as any;
+}
+
+const dupErrors = (state: TenboState) =>
+  validate(state).errors.filter((e) => /^duplicate item id/.test(e.message)).map((e) => e.message);
+
+describe('validator — duplicate item ids', () => {
+  it('emits no duplicate-id error when every id appears once', () => {
+    const state = stateWithScopeItems([
+      baseItem({ id: 'ed-001' }),
+      baseItem({ id: 'ed-002' }),
+      baseItem({ id: 'ed-003' }),
+    ]);
+    expect(dupErrors(state)).toEqual([]);
+  });
+
+  it('errors when two active items share an id', () => {
+    const state = stateWithScopeItems([
+      baseItem({ id: 'ed-001' }),
+      baseItem({ id: 'ed-001', title: 'dup' }),
+    ]);
+    const msgs = dupErrors(state);
+    expect(msgs.length).toBe(1);
+    expect(msgs[0]).toMatch(/duplicate item id "ed-001"/);
+    expect(msgs[0]).toMatch(/active/);
+  });
+
+  it('errors when an id appears once in active and once in archive', () => {
+    const state = stateWithScopeItems(
+      [baseItem({ id: 'ed-001' })],
+      [baseItem({ id: 'ed-001', status: 'done' })],
+    );
+    const msgs = dupErrors(state);
+    expect(msgs.length).toBe(1);
+    expect(msgs[0]).toMatch(/active/);
+    expect(msgs[0]).toMatch(/archive/);
+  });
+
+  it('errors when an id appears in cross-cutting and a scope', () => {
+    const state: TenboState = {
+      ...stateWithScopeItems([baseItem({ id: 'x-001' })]),
+      crossCuttingRoadmap: [
+        { id: 'x-001', title: 'cross', status: 'now', description: 'a cross-cutting item', layers: [] } as any,
+      ],
+    };
+    const msgs = dupErrors(state);
+    expect(msgs.length).toBe(1);
+    expect(msgs[0]).toMatch(/cross-cutting/);
+  });
+
+  it('emits one error per duplicated id, not one per duplicate occurrence', () => {
+    const state = stateWithScopeItems([
+      baseItem({ id: 'ed-001' }),
+      baseItem({ id: 'ed-001' }),
+      baseItem({ id: 'ed-002' }),
+      baseItem({ id: 'ed-002' }),
+      baseItem({ id: 'ed-003' }),
+    ]);
+    const msgs = dupErrors(state);
+    expect(msgs.length).toBe(2);
+    expect(msgs.some((m) => m.includes('ed-001'))).toBe(true);
+    expect(msgs.some((m) => m.includes('ed-002'))).toBe(true);
+  });
+});

package/src/api/lib/validator.goalRef.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { validate } from './validator';
+import type { TenboState, Item } from '../../types';
+
+function stateWithItems(items: Item[]): TenboState {
+  return {
+    scopes: [{
+      id: 'e',
+      path: '.',
+      description: 'editor scope description here for tests',
+      layers: [{ id: 'l', name: 'L', description: 'a small layer for testing now', files: ['x'] } as any],
+      items,
+    }],
+    crossCutting: [],
+    narratives: { 'e/l': '# L' },
+  } as any;
+}
+
+const baseItem = (over: Partial<Item> = {}): Item => ({
+  id: 'ed-001',
+  title: 't',
+  layer: 'l',
+  status: 'now',
+  description: 'a roadmap item used for goal_ref tests now',
+  done_when: ['it works'],
+  ...over,
+});
+
+const warningsFor = (state: TenboState, id: string) =>
+  validate(state).warnings.filter((w) => w.itemId === id).map((w) => w.message);
+
+describe('validator — goal_ref shape (sk-025)', () => {
+  it('warns when goal_ref is missing on an active item', () => {
+    const state = stateWithItems([baseItem()]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('has no goal_ref'))).toBe(true);
+  });
+
+  it('does not warn when goal_ref is missing on a done or dropped item', () => {
+    for (const status of ['done', 'dropped'] as const) {
+      const state = stateWithItems([baseItem({ status })]);
+      const msgs = warningsFor(state, 'ed-001');
+      expect(msgs.some((m) => m.includes('has no goal_ref'))).toBe(false);
+    }
+  });
+
+  it('does not warn when goal_ref is a non-empty string array', () => {
+    const state = stateWithItems([baseItem({ goal_ref: ['g1', 'g3'] })]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('goal_ref'))).toBe(false);
+  });
+
+  it('does not warn when goal_ref is the literal "exploratory"', () => {
+    const state = stateWithItems([baseItem({ goal_ref: 'exploratory' })]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('goal_ref'))).toBe(false);
+  });
+
+  it('warns when goal_ref is an empty array', () => {
+    const state = stateWithItems([baseItem({ goal_ref: [] })]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('empty array'))).toBe(true);
+  });
+
+  it('warns when goal_ref is a malformed value (string other than "exploratory")', () => {
+    const state = stateWithItems([baseItem({ goal_ref: 'g1' as any })]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('must be a string array or the literal "exploratory"'))).toBe(true);
+  });
+
+  it('warns when goal_ref array contains a non-string entry', () => {
+    const state = stateWithItems([baseItem({ goal_ref: [1 as any, 'g2'] as any })]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('must be a string array'))).toBe(true);
+  });
+});

package/src/api/lib/validator.preflightViolations.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { validate } from './validator';
+import type { TenboState, Item } from '../../types';
+
+function stateWithItems(items: Item[]): TenboState {
+  return {
+    scopes: [{
+      id: 'e',
+      path: '.',
+      description: 'editor scope description here for tests',
+      layers: [{ id: 'l', name: 'L', description: 'a small layer for testing now', files: ['x'] } as any],
+      items,
+    }],
+    crossCutting: [],
+    narratives: { 'e/l': '# L' },
+  } as any;
+}
+
+const baseItem = (over: Partial<Item> = {}): Item => ({
+  id: 'ed-001',
+  title: 't',
+  layer: 'l',
+  status: 'now',
+  description: 'a roadmap item used for preflight tests now',
+  done_when: ['it works'],
+  goal_ref: ['g1'],
+  ...over,
+});
+
+const warningsFor = (state: TenboState, id: string) =>
+  validate(state).warnings.filter((w) => w.itemId === id).map((w) => w.message);
+
+describe('validator — preflight_violations (sk-029)', () => {
+  it('does not warn when item has no preflight_violations', () => {
+    const state = stateWithItems([baseItem()]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('pre-flight violation'))).toBe(false);
+  });
+
+  it('warns when an active item has an accepted pre-flight violation', () => {
+    const state = stateWithItems([baseItem({
+      preflight_violations: [{
+        check: 'ui-components anti-responsibility: no direct fs writes',
+        outcome: 'violation',
+        decision: 'accept-with-violation',
+        rationale: 'one-off debug helper',
+      }],
+    })]);
+    const msgs = warningsFor(state, 'ed-001');
+    expect(msgs.some((m) => m.includes('accepted 1 pre-flight violation'))).toBe(true);
+  });
+
+  it('does not warn for done or dropped items even with accepted violations', () => {
+    for (const status of ['done', 'dropped'] as const) {
+      const state = stateWithItems([baseItem({
+        status,
+        preflight_violations: [{
+          check: 'ui-components anti-responsibility: no direct fs writes',
+          outcome: 'violation',
+          decision: 'accept-with-violation',
+        }],
+      })]);
+      const msgs = warningsFor(state, 'ed-001');
+      expect(msgs.some((m) => m.includes('pre-flight violation'))).toBe(false);
+    }
+  });
+});

package/src/api/lib/validator.relationships.test.ts

@@ -29,7 +29,13 @@ const baseItem = (over: Partial<Item> = {}): Item => ({
 const errMsgsFor = (state: TenboState, id: string) =>
   validate(state).errors.filter((e) => e.itemId === id).map((e) => e.message);
 const warnMsgsFor = (state: TenboState, id: string) =>
-  validate(state).warnings.filter((e) => e.itemId === id).map((e) => e.message);
+  validate(state).warnings
+    .filter((e) => e.itemId === id)
+    .map((e) => e.message)
+    // Exclude goal_ref warnings — sk-025 added a missing-goal_ref warning that
+    // fires on every active item without one. Tests in this file predate
+    // goal_ref and assert "no warnings" for unrelated relationship cases.
+    .filter((m) => !m.includes('goal_ref'));
 
 describe('validator — relationships', () => {
   it('accepts well-formed spawned_from + related with no errors or warnings', () => {

package/src/api/lib/validator.specLinks.test.ts

@@ -28,7 +28,11 @@ const baseItem = (over: Partial<Item> = {}): Item => ({
 });
 
 const warnMsgsFor = (state: TenboState, id: string) =>
-  validate(state).warnings.filter((w) => w.itemId === id).map((w) => w.message);
+  validate(state).warnings
+    .filter((w) => w.itemId === id)
+    .map((w) => w.message)
+    // Exclude goal_ref warnings (sk-025) — orthogonal to spec-link tests.
+    .filter((m) => !m.includes('goal_ref'));
 
 describe('validator — spec links (Phase 6)', () => {
   it('warns when a .tenbo/specs/ link points to a missing file', () => {

package/src/api/lib/validator.ts

@@ -30,6 +30,39 @@ export function validate(state: TenboState): ValidateResult {
   }
   for (const item of state.crossCuttingRoadmap ?? []) allItemIds.add(item.id);
 
+  // Duplicate-ID detection (sk-031). Walks active + archived + cross-cutting
+  // items, recording every (id → location) occurrence. An ID appearing more
+  // than once anywhere in the workspace is a hard data-integrity error: it
+  // breaks relationship validation, history (active vs archive), and item
+  // identity. Emits one error per duplicated ID listing all locations.
+  const idOccurrences = new Map<string, string[]>();
+  const recordOccurrence = (id: string, where: string) => {
+    if (!id || typeof id !== 'string') return;
+    const arr = idOccurrences.get(id) ?? [];
+    arr.push(where);
+    idOccurrences.set(id, arr);
+  };
+  for (const scope of state.scopes) {
+    for (const item of scope.items) {
+      recordOccurrence(item.id, `scopes/${scope.id}/roadmap.yaml (active)`);
+    }
+    for (const item of scope.archivedItems ?? []) {
+      recordOccurrence(item.id, `scopes/${scope.id}/roadmap-archive.yaml`);
+    }
+  }
+  for (const item of state.crossCuttingRoadmap ?? []) {
+    recordOccurrence(item.id, `.tenbo/roadmap.yaml (cross-cutting)`);
+  }
+  for (const [id, locs] of idOccurrences) {
+    if (locs.length > 1) {
+      errors.push({
+        level: 'error',
+        message: `duplicate item id "${id}" — appears in ${locs.join(' and ')}`,
+        itemId: id,
+      });
+    }
+  }
+
   const validateSupersededBy = (item: Item, scopeId?: string) => {
     if (item.superseded_by === undefined) return;
     const sb = item.superseded_by;
@@ -191,16 +224,12 @@ export function validate(state: TenboState): ValidateResult {
       }
     }
 
-    // Item rules
-    const seenIds = new Set<string>();
+    // Item rules. Note: cross-scope/active+archive duplicate-id detection runs
+    // once at the top of validate() (sk-031) — no per-scope seenIds needed.
     for (const item of scope.items) {
       if (!/^[a-z]{1,5}-\d{3,}$/.test(item.id)) {
         errors.push({ level: 'error', message: `item "${item.id}" has invalid id format (expected <prefix>-NNN, e.g. ed-001 or x-001)`, scope: scope.id, itemId: item.id });
       }
-      if (seenIds.has(item.id)) {
-        errors.push({ level: 'error', message: `duplicate item id "${item.id}"`, scope: scope.id, itemId: item.id });
-      }
-      seenIds.add(item.id);
       // Status is optional when phases are present (it's derived via roll-up).
       // Only validate when explicitly set.
       const hasPhases = Array.isArray(item.phases) && item.phases.length > 0;
@@ -277,6 +306,91 @@ export function validate(state: TenboState): ValidateResult {
         }
       }
 
+      // Goal-ref shape validation (sk-025). Optional field; warn (do not error)
+      // when missing or malformed. Shape-check only — does NOT cross-reference
+      // against `overview.md` Product goals (deferred per sk-022 risks).
+      // Skip the missing-warning for done/dropped items: no value in nagging
+      // about completed work.
+      if (item.goal_ref === undefined) {
+        if (item.status !== 'done' && item.status !== 'dropped') {
+          warnings.push({
+            level: 'warning',
+            message: `item ${item.id} has no goal_ref — backfill with cited goals or "exploratory"`,
+            scope: scope.id,
+            itemId: item.id,
+          });
+        }
+      } else if (item.goal_ref === 'exploratory') {
+        // Valid literal — no warning.
+      } else if (Array.isArray(item.goal_ref)) {
+        if (item.goal_ref.length === 0) {
+          warnings.push({
+            level: 'warning',
+            message: `item ${item.id}.goal_ref is an empty array — use "exploratory" if no goals identified, or remove the field`,
+            scope: scope.id,
+            itemId: item.id,
+          });
+        } else {
+          for (const ref of item.goal_ref) {
+            if (typeof ref !== 'string') {
+              warnings.push({
+                level: 'warning',
+                message: `item ${item.id}.goal_ref must be a string array or the literal "exploratory" — got: ${typeof ref} entry`,
+                scope: scope.id,
+                itemId: item.id,
+              });
+              break;
+            }
+          }
+        }
+      } else {
+        warnings.push({
+          level: 'warning',
+          message: `item ${item.id}.goal_ref must be a string array or the literal "exploratory" — got: ${typeof item.goal_ref}`,
+          scope: scope.id,
+          itemId: item.id,
+        });
+      }
+
+      // Pre-flight violations (sk-029). Optional field; surface as a health
+      // observation (warning) when an item carries any accept-with-violation
+      // entry. Skip done/dropped items — no value nagging completed work.
+      // Shape-check only: validate array shape and enum values; don't
+      // cross-validate `check` strings against any taxonomy.
+      if (item.preflight_violations !== undefined) {
+        if (!Array.isArray(item.preflight_violations)) {
+          errors.push({ level: 'error', message: `item "${item.id}" preflight_violations must be a list`, scope: scope.id, itemId: item.id });
+        } else {
+          const VALID_OUTCOMES = new Set(['violation', 'threshold-cross', 'dependency-direction']);
+          const VALID_DECISIONS = new Set(['accept-with-violation', 'scope-adjusted', 'deferred']);
+          let acceptedCount = 0;
+          for (const entry of item.preflight_violations) {
+            if (!entry || typeof entry !== 'object') {
+              errors.push({ level: 'error', message: `item "${item.id}" preflight_violations entry is not an object`, scope: scope.id, itemId: item.id });
+              continue;
+            }
+            if (typeof (entry as any).check !== 'string' || (entry as any).check.trim() === '') {
+              errors.push({ level: 'error', message: `item "${item.id}" preflight_violations entry missing string "check"`, scope: scope.id, itemId: item.id });
+            }
+            if (!VALID_OUTCOMES.has((entry as any).outcome)) {
+              errors.push({ level: 'error', message: `item "${item.id}" preflight_violations entry has invalid outcome "${(entry as any).outcome}"`, scope: scope.id, itemId: item.id });
+            }
+            if (!VALID_DECISIONS.has((entry as any).decision)) {
+              errors.push({ level: 'error', message: `item "${item.id}" preflight_violations entry has invalid decision "${(entry as any).decision}"`, scope: scope.id, itemId: item.id });
+            }
+            if ((entry as any).decision === 'accept-with-violation') acceptedCount++;
+          }
+          if (acceptedCount > 0 && item.status !== 'done' && item.status !== 'dropped') {
+            warnings.push({
+              level: 'warning',
+              message: `item ${item.id} has accepted ${acceptedCount} pre-flight violation(s) — review at next audit`,
+              scope: scope.id,
+              itemId: item.id,
+            });
+          }
+        }
+      }
+
       // Phase schema validation (Phase 3 of x-001).
       if (item.phases !== undefined) {
         if (!Array.isArray(item.phases)) {
@@ -324,6 +438,48 @@ export function validate(state: TenboState): ValidateResult {
     }
   }
 
+  // Decision records (sk-020). Validate frontmatter shape on every file under
+  // `.tenbo/decisions/`. Additive: state.decisions is undefined when the
+  // directory does not exist, so existing repos without decisions/ stay quiet.
+  if (state.decisions) {
+    const VALID_DECISION_STATUSES = new Set(['accepted', 'superseded']);
+    const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+    const decisions = state.decisions;
+    for (const slug of Object.keys(decisions)) {
+      const rec = decisions[slug];
+      const fm = rec.frontmatter ?? {};
+      const where = rec.path;
+      // Required fields → errors.
+      for (const field of ['id', 'date', 'status', 'title'] as const) {
+        const v = fm[field];
+        if (v === undefined || v === null || (typeof v === 'string' && v.trim() === '')) {
+          errors.push({ level: 'error', message: `decision ${where} is missing required frontmatter field "${field}"` });
+        }
+      }
+      if (typeof fm.status === 'string' && !VALID_DECISION_STATUSES.has(fm.status)) {
+        errors.push({ level: 'error', message: `decision ${where} has invalid status "${fm.status}" (expected accepted|superseded)` });
+      }
+      if (fm.date !== undefined && typeof fm.date === 'string' && fm.date.trim() !== '' && !ISO_DATE_RE.test(fm.date.trim())) {
+        warnings.push({ level: 'warning', message: `decision ${where} date "${fm.date}" is not YYYY-MM-DD` });
+      }
+      if (fm.status === 'superseded') {
+        const sb = fm.superseded_by;
+        if (typeof sb !== 'string' || sb.trim() === '') {
+          errors.push({ level: 'error', message: `decision ${where} has status:superseded but no superseded_by` });
+        } else if (!state.decisions[sb]) {
+          errors.push({ level: 'error', message: `decision ${where} superseded_by "${sb}" does not match a sibling decision file` });
+        } else if (sb === slug) {
+          errors.push({ level: 'error', message: `decision ${where} superseded_by cannot reference itself` });
+        }
+      } else if (fm.superseded_by !== undefined && fm.status !== 'superseded') {
+        warnings.push({ level: 'warning', message: `decision ${where} has superseded_by but status is "${fm.status ?? 'unset'}"` });
+      }
+      if (fm.related_items !== undefined && !Array.isArray(fm.related_items)) {
+        warnings.push({ level: 'warning', message: `decision ${where} related_items should be a list` });
+      }
+    }
+  }
+
   const allRefs = new Set(state.scopes.flatMap(s => s.layers.map(l => `${s.id}:${l.id}`)));
   for (const item of state.crossCuttingRoadmap ?? []) {
     const refs = [...(item.layers ?? []), ...(item.affects ?? [])];

package/src/api/routes/watch.ts

@@ -40,6 +40,8 @@ const IGNORE_GLOBS = [
   '**/*.swx',     // vim
   '**/*~',        // many editors' backup
   '**/4913',      // vim's pre-write probe
+  '**/*.tmp',     // simple atomic-rename staging
+  '**/*.tmp.*',   // tenboFs.ts atomic writes use `<file>.tmp.<PID>.<ts>` suffix
   '**/.DS_Store', // macOS
   '**/.git/**',
   '**/node_modules/**',

package/src/hooks/useApiPatch.ts

@@ -3,7 +3,8 @@ import type { Item } from '../types';
 import { tenboApi } from '../api/client';
 
 export function useApiPatch() {
-  return useCallback((scopeId: string, itemId: string, patch: Partial<Item>) => {
-    return tenboApi.patchItem(scopeId, itemId, patch);
+  return useCallback(async (scopeId: string, itemId: string, patch: Partial<Item>): Promise<Item> => {
+    const { item } = await tenboApi.patchItem(scopeId, itemId, patch);
+    return item;
   }, []);
 }

package/src/router/routes.ts

@@ -2,7 +2,7 @@ export type WorkspaceTab = typeof WORKSPACE_TABS[number];
 export type LayerTab = typeof LAYER_TABS[number];
 export type Mode = 'docs' | 'roadmap' | 'health';
 
-const WORKSPACE_TABS = ['overview', 'principles', 'glossary'] as const;
+const WORKSPACE_TABS = ['overview', 'principles', 'glossary', 'decisions'] as const;
 const LAYER_TABS = ['overview', 'purpose', 'files', 'docs'] as const;
 
 export type Route =

package/src/types.ts

@@ -55,6 +55,15 @@ export interface Item {
   risks?: string[];
   type?: 'feature' | 'bug' | 'refactor' | 'spike';
   priority?: Priority;
+  /**
+   * Goals this item advances. Either a list of goal IDs (e.g. ["g1", "g3"])
+   * matching IDs declared in `overview.md` Product goals section, or the
+   * literal string "exploratory" for items captured without a clear goal
+   * connection. Items lacking goal_ref entirely produce a validator warning
+   * (not an error) — they're surfaced for backfill but don't block anything.
+   * See sk-022 for context.
+   */
+  goal_ref?: string[] | 'exploratory';
   /** Optional multi-phase progress. When present, item-level `status` is derived. */
   phases?: Phase[];
   /**
@@ -84,6 +93,18 @@ export interface Item {
    * refactor, bug} lacks this field.
    */
   doc_update?: string;
+  /**
+   * Pre-flight violations recorded at capture time when the user accepted an
+   * item despite a flagged violation. Each entry: which check fired, what the
+   * outcome was, what the user decided, and their rationale. Empty / undefined
+   * when item passed pre-flight cleanly. See sk-029.
+   */
+  preflight_violations?: Array<{
+    check: string;            // e.g. "ui-components anti-responsibility: no direct fs writes"
+    outcome: 'violation' | 'threshold-cross' | 'dependency-direction';
+    decision: 'accept-with-violation' | 'scope-adjusted' | 'deferred';
+    rationale?: string;
+  }>;
 }
 
 export interface Layer {
@@ -161,6 +182,11 @@ export interface TenboState {
    * resolve to a real file. Absent when `.tenbo/specs/` does not exist.
    */
   specFiles?: Set<string>;
+  /**
+   * Decision records loaded from `.tenbo/decisions/`. Absent if the directory
+   * does not exist. Keyed by slug for `superseded_by` resolution.
+   */
+  decisions?: Record<string, DecisionRecord>;
 }
 
 export type ValidateLevel = 'error' | 'warning';
@@ -200,6 +226,30 @@ export interface WorkspaceContent {
   observationsMtime: number | null;
 }
 
+/**
+ * Project-level decision record loaded from `.tenbo/decisions/<slug>.md`.
+ * Only created when a future audit would re-suggest the same thing without
+ * the rationale. See `skill/templates/decision.md.tmpl` for the shape.
+ */
+export interface DecisionRecord {
+  /** repo-relative path, e.g. `.tenbo/decisions/foo.md` */
+  path: string;
+  /** filename slug without extension */
+  slug: string;
+  /** parsed frontmatter — values may be missing on malformed files */
+  frontmatter: {
+    id?: string;
+    date?: string;
+    status?: 'accepted' | 'superseded' | string;
+    title?: string;
+    related_items?: string[];
+    superseded_by?: string;
+    [k: string]: unknown;
+  };
+  /** body content after frontmatter (markdown) */
+  body: string;
+}
+
 export interface LayerContent {
   scope: string;
   layer: string;

package/src/ui/WorkspacePage/WorkspacePage.tsx

@@ -3,14 +3,16 @@ import type { TenboState } from '../../types';
 import { OverviewTab } from './tabs/OverviewTab';
 import { PrinciplesTab } from './tabs/PrinciplesTab';
 import { GlossaryTab } from './tabs/GlossaryTab';
+import { DecisionsTab } from './tabs/DecisionsTab';
 import styles from './WorkspacePage.module.css';
 
-const TABS: WorkspaceTab[] = ['overview', 'principles', 'glossary'];
+const TABS: WorkspaceTab[] = ['overview', 'principles', 'glossary', 'decisions'];
 
 const TAB_LABELS: Record<WorkspaceTab, string> = {
   'overview': 'Project overview',
   'principles': 'Principles',
   'glossary': 'Glossary',
+  'decisions': 'Decisions',
 };
 
 export function WorkspacePage(props: { tab: WorkspaceTab; navigate: (r: Route) => void; state: TenboState }) {
@@ -30,6 +32,7 @@ export function WorkspacePage(props: { tab: WorkspaceTab; navigate: (r: Route) =
         {props.tab === 'overview' && <OverviewTab state={props.state} navigate={props.navigate} />}
         {props.tab === 'principles' && <PrinciplesTab state={props.state} />}
         {props.tab === 'glossary' && <GlossaryTab state={props.state} />}
+        {props.tab === 'decisions' && <DecisionsTab state={props.state} />}
       </div>
     </div>
   );