tsunami-memory 1.0.0

package/src/storm/confidence.ts

@@ -0,0 +1,88 @@
+import type { TsunamiStormPressure, TsunamiStormReadiness, TsunamiStormBoundary, TsunamiStormHorizon, TsunamiStormCenterStormMode, TsunamiStormConfidence } from './types';
+
+export function buildStormConfidence(input: {
+  stormPressure?: TsunamiStormPressure;
+  stormReadiness?: TsunamiStormReadiness;
+  stormBoundary?: TsunamiStormBoundary;
+  stormHorizon?: TsunamiStormHorizon;
+  stormMode?: TsunamiStormCenterStormMode;
+}): TsunamiStormConfidence | undefined {
+  const pressure = input.stormPressure;
+  const readiness = input.stormReadiness;
+  const boundary = input.stormBoundary;
+  const horizon = input.stormHorizon;
+  const mode = input.stormMode;
+  if (!pressure && !readiness && !boundary && !horizon && !mode) return undefined;
+
+  let score = 0.18;
+  const reasons: string[] = [];
+
+  if (readiness?.level === 'fortified') {
+    score += 0.32;
+    reasons.push('fortified support');
+  } else if (readiness?.level === 'ready') {
+    score += 0.22;
+    reasons.push('ready support');
+  } else if (readiness?.level === 'partial') {
+    score += 0.08;
+    reasons.push('partial support');
+  } else if (readiness?.level === 'weak') {
+    score -= 0.08;
+    reasons.push('weak support');
+  }
+
+  if (boundary?.mode === 'sealed') {
+    score += 0.16;
+    reasons.push('sealed boundary');
+  } else if (boundary?.mode === 'guarded') {
+    score += 0.08;
+    reasons.push('guarded boundary');
+  } else if (boundary?.mode === 'permeable') {
+    score -= 0.06;
+    reasons.push('permeable boundary');
+  } else if (boundary?.mode === 'spilling') {
+    score -= 0.18;
+    reasons.push('spilling boundary');
+  }
+
+  if (pressure?.level === 'calm') {
+    score += 0.12;
+    reasons.push('calm pressure');
+  } else if (pressure?.level === 'steady') {
+    score += 0.06;
+    reasons.push('steady pressure');
+  } else if (pressure?.level === 'rising') {
+    score -= 0.08;
+    reasons.push('rising pressure');
+  } else if (pressure?.level === 'critical') {
+    score -= 0.18;
+    reasons.push('critical pressure');
+  }
+
+  if (mode?.mixed) {
+    score -= 0.06;
+    reasons.push('mixed sea-state');
+  } else if (mode) {
+    score += 0.04;
+    reasons.push('coherent sea-state');
+  }
+
+  if (horizon?.label === 'multi_step') {
+    score += 0.1;
+    reasons.push('multi-step horizon');
+  } else if (horizon?.label === 'two_step') {
+    score += 0.05;
+    reasons.push('two-step horizon');
+  } else if (horizon?.label === 'single_step') {
+    score -= 0.04;
+    reasons.push('single-step horizon');
+  }
+
+  const normalized = Math.max(0, Math.min(1, Number(score.toFixed(2))));
+  const level = normalized >= 0.74 ? 'high' : normalized >= 0.54 ? 'confident' : normalized >= 0.32 ? 'guarded' : 'low';
+  return {
+    level,
+    score: normalized,
+    reason: reasons.slice(0, 3).join(' · ') || 'confidence still settling',
+  };
+}

package/src/storm/coverage.ts

@@ -0,0 +1,44 @@
+import type { TsunamiStormSelection, TsunamiStormCoverage } from './types';
+
+export function buildStormCoverage(input: {
+  stormSelection?: TsunamiStormSelection;
+  selectedSignals: number;
+  totalSignals: number;
+  selectedEvidence: number;
+  totalEvidence: number;
+  selectedRelations: number;
+  totalRelations: number;
+}): TsunamiStormCoverage | undefined {
+  const totals = [
+    input.totalSignals,
+    input.totalEvidence,
+    input.totalRelations,
+  ];
+  if (!totals.some((value) => value > 0)) return undefined;
+
+  const signalRatio = input.totalSignals > 0 ? input.selectedSignals / input.totalSignals : 1;
+  const evidenceRatio = input.totalEvidence > 0 ? input.selectedEvidence / input.totalEvidence : 1;
+  const relationRatio = input.totalRelations > 0 ? input.selectedRelations / input.totalRelations : 1;
+  const score = Number(((signalRatio + evidenceRatio + relationRatio) / 3).toFixed(2));
+  const mode = score >= 0.95 ? 'full' : score >= 0.72 ? 'broad' : score >= 0.45 ? 'focused' : 'narrow';
+
+  const weakest =
+    signalRatio <= evidenceRatio && signalRatio <= relationRatio ? 'signal lane'
+      : evidenceRatio <= relationRatio ? 'evidence lane'
+        : 'relation lane';
+  const reason = input.stormSelection
+    ? `${input.stormSelection.profile} selection currently covers ${weakest} most narrowly`
+    : `current storm coverage is most limited by the ${weakest}`;
+
+  return {
+    mode,
+    score,
+    selectedSignals: input.selectedSignals,
+    totalSignals: input.totalSignals,
+    selectedEvidence: input.selectedEvidence,
+    totalEvidence: input.totalEvidence,
+    selectedRelations: input.selectedRelations,
+    totalRelations: input.totalRelations,
+    reason,
+  };
+}

package/src/storm/directive.ts

@@ -0,0 +1,94 @@
+import type { TsunamiStormPressure, TsunamiStormCenterStormMode, TsunamiStormDirective, TsunamiStormAction } from './types';
+
+export function buildStormDirective(input: {
+  stormPressure?: TsunamiStormPressure;
+  stormMode?: TsunamiStormCenterStormMode;
+  topRepair?: TsunamiStormCenter['topRepair'];
+  topIssue?: TsunamiStormCenter['topIssue'];
+  focus: TsunamiStormCenter['focus'];
+}): TsunamiStormDirective | undefined {
+  const pressure = input.stormPressure;
+  const mode = input.stormMode;
+  if ((pressure?.level === 'critical' || pressure?.level === 'rising') && input.topRepair) {
+    return {
+      label: pressure.level === 'critical' ? 'stabilize-now' : 'stabilize-repair',
+      lane: pressure.level === 'critical' ? 'stabilize' : 'repair',
+      reason: `${pressure.level} pressure + ${input.topRepair.priority || 'repair'} ${input.topRepair.title}`.trim(),
+    };
+  }
+  if ((pressure?.level === 'rising' || pressure?.level === 'critical') && input.topIssue && !input.topRepair) {
+    return {
+      label: 'diagnose-drift',
+      lane: 'diagnose',
+      reason: `${pressure.level} pressure + issue ${input.topIssue.code}`.trim(),
+    };
+  }
+  if (mode?.dominantKind === 'anchor' || mode?.dominantKind === 'evidence') {
+    return {
+      label: 'consolidate-context',
+      lane: 'consolidate',
+      reason: `${mode.label} requires clearer anchors and evidence`.trim(),
+    };
+  }
+  if (mode?.dominantKind === 'issue') {
+    return {
+      label: 'diagnose-thread',
+      lane: 'diagnose',
+      reason: `${mode.label} suggests drift diagnosis before forward motion`.trim(),
+    };
+  }
+  if (mode?.dominantKind === 'repair') {
+    return {
+      label: 'apply-repair',
+      lane: 'repair',
+      reason: `${mode.label} suggests closing the top repair path first`.trim(),
+    };
+  }
+  return {
+    label: 'advance-mainline',
+    lane: 'advance',
+    reason: input.focus.nextStep || input.focus.summary || 'mainline is ready to advance',
+  };
+}
+export function buildStormAction(input: {
+  stormDirective?: TsunamiStormDirective;
+  topRepair?: TsunamiStormCenter['topRepair'];
+  topIssue?: TsunamiStormCenter['topIssue'];
+  focus: TsunamiStormCenter['focus'];
+}): TsunamiStormAction | undefined {
+  const directive = input.stormDirective;
+  if (!directive) return undefined;
+  if (directive.lane === 'stabilize' && input.topRepair) {
+    return {
+      label: 'close top repair before expanding scope',
+      target: input.topRepair.title,
+      reason: directive.reason,
+    };
+  }
+  if (directive.lane === 'repair' && input.topRepair) {
+    return {
+      label: 'apply the priority repair path',
+      target: input.topRepair.title,
+      reason: directive.reason,
+    };
+  }
+  if (directive.lane === 'diagnose' && input.topIssue) {
+    return {
+      label: 'diagnose the dominant drift before coding forward',
+      target: input.topIssue.detail || input.topIssue.code,
+      reason: directive.reason,
+    };
+  }
+  if (directive.lane === 'consolidate') {
+    return {
+      label: 'refresh anchors and evidence around the mainline',
+      target: input.focus.title,
+      reason: directive.reason,
+    };
+  }
+  return {
+    label: input.focus.nextStep || 'advance the mainline carefully',
+    target: input.focus.title,
+    reason: directive.reason,
+  };
+}

package/src/storm/gate.ts

@@ -0,0 +1,43 @@
+import type { TsunamiStormPressure, TsunamiStormReadiness, TsunamiStormConfidence, TsunamiStormBoundary, TsunamiStormHorizon, TsunamiStormGate } from './types';
+
+export function buildStormGate(input: {
+  stormPressure?: TsunamiStormPressure;
+  stormReadiness?: TsunamiStormReadiness;
+  stormConfidence?: TsunamiStormConfidence;
+  stormBoundary?: TsunamiStormBoundary;
+  stormHorizon?: TsunamiStormHorizon;
+}): TsunamiStormGate | undefined {
+  const pressure = input.stormPressure;
+  const readiness = input.stormReadiness;
+  const confidence = input.stormConfidence;
+  const boundary = input.stormBoundary;
+  const horizon = input.stormHorizon;
+  if (!pressure && !readiness && !confidence && !boundary && !horizon) return undefined;
+
+  if (pressure?.level === 'critical' || boundary?.mode === 'spilling' || confidence?.level === 'low') {
+    return {
+      verdict: 'hold',
+      allowForward: false,
+      reason: `hold the line until pressure/boundary/confidence stabilizes (${pressure?.level || boundary?.mode || confidence?.level || 'unknown'})`,
+    };
+  }
+  if (boundary?.expand || readiness?.level === 'partial' || readiness?.level === 'weak') {
+    return {
+      verdict: 'guarded',
+      allowForward: false,
+      reason: `keep execution guarded while support is still ${readiness?.level || 'thin'} and the storm may need wider support`,
+    };
+  }
+  if ((confidence?.level === 'high' || confidence?.level === 'confident') && boundary?.mode === 'sealed' && (horizon?.steps || 0) >= 3) {
+    return {
+      verdict: 'expand',
+      allowForward: true,
+      reason: `guidance is ${confidence?.level || 'strong'} with a sealed boundary and long horizon, so we can advance confidently`,
+    };
+  }
+  return {
+    verdict: 'proceed',
+    allowForward: true,
+    reason: `guidance is stable enough to move forward, but keep the mainline under watch`,
+  };
+}

package/src/storm/helpers.ts

@@ -0,0 +1,172 @@
+// Storm center — utility functions
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { listProjectWikiPages } from '../core/project_state';
+import type { ProjectHandoffRecord, ProjectTaskThread } from '../core/project_state';
+import type { DurableRecoveryRecord } from '../runtime/checkpoints/durable_recovery';
+import type { TsunamiStormCenterCurrent } from './types';
+
+const TSUNAMI_STORM_RETRY_DELAYS_MS = [8, 18, 36] as const;
+
+export function buildProjectNode(projectDir: string): string {
+  return `project:${basename(projectDir) || projectDir}`;
+}
+export function buildTaskThreadNode(threadId: string): string {
+  return `task_thread:${threadId}`;
+}
+export function buildHandoffNode(handoffId: string): string {
+  return `handoff:${handoffId}`;
+}
+export function buildAnchorNode(pageId: string): string {
+  return `recovery_anchor:${pageId}`;
+}
+export function buildRecoveryNode(recoveryId: string): string {
+  return `recovery_record:${recoveryId}`;
+}
+export function clampEnergy(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, Number(value.toFixed(2))));
+}
+export function safeTrim(value: string | undefined, max = 160): string {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, max)}...` : text;
+}
+export function blockForRetry(ms: number) {
+  const delay = Math.max(0, Math.floor(ms));
+  if (!delay) return;
+  try {
+    const shared = new SharedArrayBuffer(4);
+    Atomics.wait(new Int32Array(shared), 0, 0, delay);
+  } catch {
+    const end = Date.now() + delay;
+    while (Date.now() < end) {
+      // Busy wait fallback for runtimes where Atomics.wait is unavailable.
+    }
+  }
+}
+export function isTsunamiStormRetryableError(error: unknown): boolean {
+  const message = String((error as any)?.message || error || '').toLowerCase();
+  if (!message) return false;
+  return message.includes('database is locked')
+    || message.includes('sqlite_busy')
+    || message.includes('sql_busy')
+    || message.includes('busy timeout');
+}
+export function withTsunamiStormRetry<T>(runner: () => T): T {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= TSUNAMI_STORM_RETRY_DELAYS_MS.length; attempt += 1) {
+    try {
+      return runner();
+    } catch (error) {
+      lastError = error;
+      if (!isTsunamiStormRetryableError(error) || attempt >= TSUNAMI_STORM_RETRY_DELAYS_MS.length) {
+        throw error;
+      }
+      blockForRetry(TSUNAMI_STORM_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError || 'unknown storm retry failure'));
+}
+export function pickFocusQuery(input: {
+  query?: string;
+  thread: ProjectTaskThread | null;
+  handoff: ProjectHandoffRecord | null;
+  activeFeatureTitle?: string;
+}): string {
+  const direct = String(input.query ?? '').trim();
+  if (direct) return direct;
+  return (
+    input.thread?.title
+    || input.handoff?.task
+    || input.activeFeatureTitle
+    || 'current mainline'
+  );
+}
+export function tokenizeStormSupportQuery(query: string): string[] {
+  return String(query || '')
+    .toLowerCase()
+    .split(/[\s,，。;；:：|/\\()\[\]{}"']+/)
+    .map((item) => item.trim())
+    .filter((item) => item.length >= 2);
+}
+export function pickFallbackDocSnippet(content: string, query: string, max = 180): string {
+  const lines = String(content || '')
+    .split('\n')
+    .map((line) => line.replace(/\s+/g, ' ').trim())
+    .filter(Boolean)
+    .filter((line) => !/^#+\s*/.test(line));
+  if (!lines.length) return '';
+  const tokens = tokenizeStormSupportQuery(query);
+  if (tokens.length > 0) {
+    const matched = lines.find((line) => tokens.some((token) => line.toLowerCase().includes(token)));
+    if (matched) return safeTrim(matched, max);
+  }
+  return safeTrim(lines.find((line) => line.length >= 20) || lines[0], max);
+}
+export function buildFallbackDocStormSupport(projectDir: string, focusQuery: string, limit = 2): TsunamiFallbackDocSupport {
+  const candidates = [
+    join(projectDir, 'README.md'),
+    join(projectDir, 'CHANGELOG.md'),
+    join(projectDir, 'README.md'),
+  ];
+  const anchors: TsunamiStormCenter['anchors'] = [];
+  const evidence: TsunamiStormCenter['evidence'] = [];
+  let mainlineTitle: string | undefined;
+  let mainlineSummary: string | undefined;
+
+  for (const filePath of candidates) {
+    if (!existsSync(filePath)) continue;
+    let content = '';
+    try {
+      content = readFileSync(filePath, 'utf8');
+    } catch (error: any) {
+      console.warn(`[TSUNAMI] failed to read fallback storm support doc ${filePath}:`, error?.message ?? error);
+      continue;
+    }
+    const snippet = pickFallbackDocSnippet(content, focusQuery);
+    if (!snippet) continue;
+    const label = basename(filePath);
+    if (!mainlineTitle) {
+      mainlineTitle = `Project Mainline / ${label}`;
+      mainlineSummary = snippet;
+    }
+    if (anchors.length < 1 && label === 'README.md') {
+      anchors.push({
+        pageId: `storm-fallback-anchor:${label}`,
+        title: `Fallback Anchor / ${label}`,
+        summary: snippet,
+        confidence: 0.54,
+        tags: ['storm-fallback', 'project-doc'],
+      });
+    }
+    if (evidence.length < limit) {
+      evidence.push({
+        snippetId: `storm-fallback-evidence:${label}:${evidence.length + 1}`,
+        pageId: `storm-fallback-doc:${label}`,
+        title: `Fallback Evidence / ${label}`,
+        sourcePath: filePath,
+        sourceRef: `file:${label}`,
+        quote: snippet,
+        tags: ['storm-fallback', 'project-doc'],
+      });
+    }
+  }
+
+  return {
+    anchors,
+    evidence,
+    mainlineTitle,
+    mainlineSummary,
+  };
+}
+export function readAnchorCandidates(projectDir: string, featureId?: string, limit = 3) {
+  const pages = listProjectWikiPages(projectDir, 12)
+    .filter((page) => page.title.startsWith('Recovery Anchor /') || page.tags.includes('recovery-anchor'))
+    .filter((page) => {
+      if (!featureId) return true;
+      return page.sourceRefs.some((ref) => ref.toLowerCase() === `feature_id:${featureId.toLowerCase()}`);
+    })
+    .sort((a, b) => b.updatedAt - a.updatedAt);
+  return pages.slice(0, limit);
+}

package/src/storm/horizon.ts

@@ -0,0 +1,52 @@
+import type { TsunamiStormPressure, TsunamiStormReadiness, TsunamiStormBoundary, TsunamiStormCenterStormMode, TsunamiStormHorizon } from './types';
+
+export function buildStormHorizon(input: {
+  stormPressure?: TsunamiStormPressure;
+  stormReadiness?: TsunamiStormReadiness;
+  stormBoundary?: TsunamiStormBoundary;
+  stormMode?: TsunamiStormCenterStormMode;
+  topRepair?: TsunamiStormCenter['topRepair'];
+  topIssue?: TsunamiStormCenter['topIssue'];
+}): TsunamiStormHorizon | undefined {
+  const pressure = input.stormPressure;
+  const readiness = input.stormReadiness;
+  const boundary = input.stormBoundary;
+  const mode = input.stormMode;
+  if (!pressure && !readiness && !boundary && !mode) return undefined;
+
+  if (pressure?.level === 'critical' || boundary?.mode === 'spilling') {
+    return {
+      label: 'single_step',
+      steps: 1,
+      reason: `pressure ${pressure?.level || 'critical'} and boundary ${boundary?.mode || 'open'} mean we should only plan the next safe move`,
+    };
+  }
+  if (boundary?.expand || readiness?.level === 'weak' || readiness?.level === 'partial') {
+    return {
+      label: 'short_run',
+      steps: 1,
+      reason: `support is still ${readiness?.level || 'thin'}, so gather anchors/evidence before planning beyond the immediate step`,
+    };
+  }
+  if (readiness?.level === 'fortified' && boundary?.mode === 'sealed' && !mode?.mixed && (pressure?.level === 'calm' || pressure?.level === 'steady')) {
+    return {
+      label: 'multi_step',
+      steps: 3,
+      reason: `support is fortified, boundary is sealed, and pressure is ${pressure?.level || 'calm'}, so the storm can safely see several steps ahead`,
+    };
+  }
+  if (readiness?.level === 'ready' || boundary?.mode === 'guarded') {
+    return {
+      label: 'two_step',
+      steps: 2,
+      reason: `support is stable enough for the next two moves, but we should keep the mainline under watch`,
+    };
+  }
+  return {
+    label: 'short_run',
+    steps: 1,
+    reason: input.topRepair || input.topIssue
+      ? 'active repair/drift pressure suggests holding planning to the immediate correction window'
+      : 'storm support is still settling, so keep the planning window short',
+  };
+}

package/src/storm/intake.ts

@@ -0,0 +1,80 @@
+import type { TsunamiStormSelection, TsunamiStormCoverage, TsunamiStormSaturation, TsunamiStormBudget, TsunamiStormGate, TsunamiStormIntake } from './types';
+
+export function buildStormIntake(input: {
+  stormSelection?: TsunamiStormSelection;
+  stormCoverage?: TsunamiStormCoverage;
+  stormSaturation?: TsunamiStormSaturation;
+  stormBudget?: TsunamiStormBudget;
+  stormGate?: TsunamiStormGate;
+}): TsunamiStormIntake | undefined {
+  const selection = input.stormSelection;
+  const coverage = input.stormCoverage;
+  const saturation = input.stormSaturation;
+  const budget = input.stormBudget;
+  const gate = input.stormGate;
+  if (!selection && !coverage && !saturation && !budget && !gate) return undefined;
+
+  const nextSignalLimit = Math.max(1, selection?.signalLimit ?? 3);
+  const nextEvidenceLimit = Math.max(1, selection?.evidenceLimit ?? 2);
+  const nextRelationLimit = Math.max(1, selection?.relationLimit ?? 6);
+
+  if (gate?.verdict === 'hold' || budget?.mode === 'frozen') {
+    return {
+      mode: 'hold',
+      target: 'balanced',
+      nextSignalLimit,
+      nextEvidenceLimit,
+      nextRelationLimit,
+      reason: budget?.reason || gate?.reason || 'hold the intake steady until the storm is safe to widen again',
+    };
+  }
+
+  if (saturation && saturation.hitLanes.length > 0) {
+    const target: TsunamiStormIntake['target'] =
+      saturation.hitLanes.length > 1 ? 'balanced' : saturation.hitLanes[0];
+    const bump = saturation.level === 'saturated' ? 2 : 1;
+    return {
+      mode: saturation.level === 'saturated' ? 'widen' : 'rebalance',
+      target,
+      nextSignalLimit: target === 'signals' || target === 'balanced' ? nextSignalLimit + bump : nextSignalLimit,
+      nextEvidenceLimit: target === 'evidence' || target === 'balanced' ? nextEvidenceLimit + bump : nextEvidenceLimit,
+      nextRelationLimit:
+        target === 'relations'
+        ? nextRelationLimit + bump * 2
+        : target === 'balanced'
+          ? nextRelationLimit + bump
+          : nextRelationLimit,
+      reason: saturation.reason,
+    };
+  }
+
+  const signalRatio = coverage && coverage.totalSignals > 0 ? coverage.selectedSignals / coverage.totalSignals : 1;
+  const evidenceRatio = coverage && coverage.totalEvidence > 0 ? coverage.selectedEvidence / coverage.totalEvidence : 1;
+  const relationRatio = coverage && coverage.totalRelations > 0 ? coverage.selectedRelations / coverage.totalRelations : 1;
+
+  let target: TsunamiStormIntake['target'] = 'balanced';
+  if (signalRatio <= evidenceRatio && signalRatio <= relationRatio) target = 'signals';
+  else if (evidenceRatio <= relationRatio) target = 'evidence';
+  else target = 'relations';
+
+  if ((coverage?.score ?? 1) >= 0.9) {
+    return {
+      mode: 'steady',
+      target: 'balanced',
+      nextSignalLimit,
+      nextEvidenceLimit,
+      nextRelationLimit,
+      reason: 'coverage is already strong enough, so keep the intake steady around the current storm surface',
+    };
+  }
+
+  const bump = coverage && coverage.score < 0.45 ? 2 : 1;
+  return {
+    mode: coverage && coverage.score < 0.6 ? 'widen' : 'rebalance',
+    target,
+    nextSignalLimit: target === 'signals' ? nextSignalLimit + bump : nextSignalLimit,
+    nextEvidenceLimit: target === 'evidence' ? nextEvidenceLimit + bump : nextEvidenceLimit,
+    nextRelationLimit: target === 'relations' ? nextRelationLimit + bump * 2 : nextRelationLimit,
+    reason: coverage?.reason || `${selection?.profile || 'current'} intake should rebalance toward ${target}`,
+  };
+}

package/src/storm/mode.ts

@@ -0,0 +1,21 @@
+import type { TsunamiStormCenterCurrentMix, TsunamiStormCenterStormMode } from './types';
+
+export function buildStormMode(currentMix: TsunamiStormCenterCurrentMix[]): TsunamiStormCenterStormMode | undefined {
+  if (!currentMix.length) return undefined;
+  const dominant = currentMix[0];
+  const totalEnergy = currentMix.reduce((sum, item) => sum + item.energy, 0);
+  const dominance = totalEnergy > 0 ? Number((dominant.energy / totalEnergy).toFixed(2)) : 0;
+  const mixed = dominance < 0.56;
+  const base = dominant.kind === 'primary_thread' ? 'thread' : dominant.kind;
+  const label = mixed
+    ? `mixed-${base}`
+    : (dominant.kind === 'repair' || dominant.kind === 'issue' || dominant.kind === 'evidence'
+      ? `${base}-heavy`
+      : `${base}-led`);
+  return {
+    label,
+    dominantKind: dominant.kind,
+    dominance,
+    mixed,
+  };
+}

package/src/storm/pressure.ts

@@ -0,0 +1,56 @@
+import type { TsunamiStormCenterCurrentMix, TsunamiStormCenterStormMode, TsunamiStormPressure } from './types';
+
+export function buildStormPressure(input: {
+  currentMix: TsunamiStormCenterCurrentMix[];
+  stormMode?: TsunamiStormCenterStormMode;
+  issues: TsunamiStormCenter['issues'];
+  repairSuggestions: TsunamiStormCenter['repairSuggestions'];
+  anchors: TsunamiStormCenter['anchors'];
+  evidence: TsunamiStormCenter['evidence'];
+  recovery: DurableRecoveryRecord | null;
+}): TsunamiStormPressure | undefined {
+  if (!input.currentMix.length) return undefined;
+  const reasons: string[] = [];
+  let score = 0.12;
+  const dominant = input.currentMix[0];
+  score += Math.min(0.24, dominant.energy * 0.16);
+  reasons.push(`dominant:${dominant.kind}`);
+  const highIssues = input.issues.filter((issue) => issue.severity === 'high').length;
+  const mediumIssues = input.issues.filter((issue) => issue.severity === 'medium').length;
+  if (highIssues > 0) {
+    score += Math.min(0.24, highIssues * 0.12);
+    reasons.push(`high_issue:${highIssues}`);
+  } else if (mediumIssues > 0) {
+    score += Math.min(0.16, mediumIssues * 0.08);
+    reasons.push(`medium_issue:${mediumIssues}`);
+  }
+  const p0Repairs = input.repairSuggestions.filter((item) => item.priority === 'P0').length;
+  const p1Repairs = input.repairSuggestions.filter((item) => item.priority === 'P1').length;
+  if (p0Repairs > 0) {
+    score += Math.min(0.22, p0Repairs * 0.11);
+    reasons.push(`p0_repair:${p0Repairs}`);
+  } else if (p1Repairs > 0) {
+    score += Math.min(0.14, p1Repairs * 0.07);
+    reasons.push(`p1_repair:${p1Repairs}`);
+  }
+  if (input.stormMode?.mixed) {
+    score += 0.08;
+    reasons.push('mixed');
+  }
+  if (input.recovery && Number(input.recovery.lineageDepth ?? 0) > 0) {
+    score += Math.min(0.12, Number(input.recovery.lineageDepth ?? 0) * 0.03);
+    reasons.push(`recovery_depth:${Number(input.recovery.lineageDepth ?? 0)}`);
+  }
+  const stabilizer = Math.min(0.12, input.anchors.length * 0.03 + input.evidence.length * 0.015);
+  if (stabilizer > 0) {
+    score -= stabilizer;
+    reasons.push(`stabilizer:${stabilizer.toFixed(2)}`);
+  }
+  const normalized = Math.max(0, Math.min(1, Number(score.toFixed(2))));
+  const level = normalized >= 0.74 ? 'critical' : normalized >= 0.52 ? 'rising' : normalized >= 0.28 ? 'steady' : 'calm';
+  return {
+    level,
+    score: normalized,
+    reasons: reasons.slice(0, 5),
+  };
+}

package/src/storm/readiness.ts

@@ -0,0 +1,29 @@
+import type { TsunamiStormReadiness } from './types';
+
+export function buildStormReadiness(input: {
+  hasMainline: boolean;
+  anchors: TsunamiStormCenter['anchors'];
+  evidence: TsunamiStormCenter['evidence'];
+  recovery: DurableRecoveryRecord | null;
+  graphEdges: number;
+}): TsunamiStormReadiness {
+  let score = 0;
+  const gaps: string[] = [];
+  if (input.hasMainline) score += 0.24;
+  else gaps.push('mainline');
+  if (input.anchors.length > 0) score += Math.min(0.24, 0.14 + input.anchors.length * 0.05);
+  else gaps.push('anchor');
+  if (input.evidence.length > 0) score += Math.min(0.18, 0.1 + input.evidence.length * 0.03);
+  else gaps.push('evidence');
+  if (input.recovery) score += 0.12;
+  else gaps.push('recovery');
+  if (input.graphEdges >= 4) score += 0.14;
+  else gaps.push('graph');
+  const normalized = Math.max(0, Math.min(1, Number(score.toFixed(2))));
+  const level = normalized >= 0.82 ? 'fortified' : normalized >= 0.58 ? 'ready' : normalized >= 0.32 ? 'partial' : 'weak';
+  return {
+    level,
+    score: normalized,
+    gaps: gaps.slice(0, 4),
+  };
+}