tsunami-memory 1.0.0

package/src/storm/saturation.ts

@@ -0,0 +1,45 @@
+import type { TsunamiStormSelection, TsunamiStormSaturation } from './types';
+
+export function buildStormSaturation(input: {
+  stormSelection?: TsunamiStormSelection;
+  selectedSignals: number;
+  totalSignals: number;
+  selectedEvidence: number;
+  totalEvidence: number;
+  selectedRelations: number;
+  totalRelations: number;
+}): TsunamiStormSaturation | undefined {
+  const selection = input.stormSelection;
+  if (!selection) return undefined;
+
+  const signalHitLimit =
+    input.totalSignals > input.selectedSignals
+    && input.selectedSignals >= selection.signalLimit;
+  const evidenceHitLimit =
+    input.totalEvidence > input.selectedEvidence
+    && input.selectedEvidence >= selection.evidenceLimit;
+  const relationHitLimit =
+    input.totalRelations > input.selectedRelations
+    && input.selectedRelations >= selection.relationLimit;
+
+  const hitLanes: Array<'signals' | 'evidence' | 'relations'> = [];
+  if (signalHitLimit) hitLanes.push('signals');
+  if (evidenceHitLimit) hitLanes.push('evidence');
+  if (relationHitLimit) hitLanes.push('relations');
+
+  const level: TsunamiStormSaturation['level'] =
+    hitLanes.length >= 2 ? 'saturated' : hitLanes.length === 1 ? 'near_limit' : 'clear';
+  const reason =
+    hitLanes.length > 0
+      ? `${hitLanes.join(', ')} lane${hitLanes.length > 1 ? 's' : ''} hit the current storm caps while more support stayed outside the center`
+      : 'selected storm surface still fits within current storm caps';
+
+  return {
+    level,
+    signalHitLimit,
+    evidenceHitLimit,
+    relationHitLimit,
+    hitLanes,
+    reason,
+  };
+}

package/src/storm/selection.ts

@@ -0,0 +1,49 @@
+import type { TsunamiStormBudget, TsunamiStormBoundary, TsunamiStormGate, TsunamiStormHorizon, TsunamiStormSelection } from './types';
+
+export function buildStormSelection(input: {
+  stormBudget?: TsunamiStormBudget;
+  stormBoundary?: TsunamiStormBoundary;
+  stormGate?: TsunamiStormGate;
+  stormHorizon?: TsunamiStormHorizon;
+}): TsunamiStormSelection | undefined {
+  const budget = input.stormBudget;
+  const boundary = input.stormBoundary;
+  const gate = input.stormGate;
+  const horizon = input.stormHorizon;
+  if (!budget && !boundary && !gate && !horizon) return undefined;
+
+  if (budget?.mode === 'frozen' || gate?.verdict === 'hold') {
+    return {
+      profile: 'frozen',
+      signalLimit: 3,
+      evidenceLimit: 1,
+      relationLimit: 4,
+      reason: budget?.reason || gate?.reason || 'hold the storm to the minimum observable surface while support stabilizes',
+    };
+  }
+  if (budget?.mode === 'minimal' || boundary?.mode === 'spilling' || boundary?.mode === 'permeable') {
+    return {
+      profile: 'tight',
+      signalLimit: 3,
+      evidenceLimit: 2,
+      relationLimit: 6,
+      reason: budget?.reason || boundary?.reason || 'keep the storm tightly sampled while widening support carefully',
+    };
+  }
+  if (budget?.mode === 'open' || gate?.verdict === 'expand' || (horizon?.steps || 0) >= 3) {
+    return {
+      profile: 'broad',
+      signalLimit: 6,
+      evidenceLimit: 5,
+      relationLimit: 14,
+      reason: budget?.reason || gate?.reason || horizon?.reason || 'support is strong enough to gather a wider storm surface',
+    };
+  }
+  return {
+    profile: 'focused',
+    signalLimit: 4,
+    evidenceLimit: 3,
+    relationLimit: 10,
+    reason: budget?.reason || 'hold a focused storm surface around the mainline while keeping enough support visible',
+  };
+}

package/src/storm/signals.ts

@@ -0,0 +1,105 @@
+// Storm center — signal analysis
+import { clampEnergy, safeTrim, buildProjectNode, buildTaskThreadNode, buildHandoffNode, buildAnchorNode, buildRecoveryNode } from './helpers';
+import type { StormCurrentKind, TsunamiStormCenterCurrent, TsunamiStormCenterCurrentMix, TsunamiStormCenter } from './types';
+
+export function buildCurrents(input: {
+  thread: ProjectTaskThread | null;
+  handoff: ProjectHandoffRecord | null;
+  anchors: TsunamiStormCenter['anchors'];
+  recovery: DurableRecoveryRecord | null;
+  evidence: TsunamiStormCenter['evidence'];
+  issues: TsunamiStormCenter['issues'];
+  repairSuggestions: TsunamiStormCenter['repairSuggestions'];
+  signalLimit: number;
+  fallbackMainlineTitle?: string;
+  fallbackMainlineSummary?: string;
+}): TsunamiStormCenterCurrent[] {
+  const currents: TsunamiStormCenterCurrent[] = [];
+  if (input.thread) {
+    currents.push({
+      kind: 'primary_thread',
+      label: input.thread.title,
+      node: buildTaskThreadNode(input.thread.id),
+      energy: clampEnergy(input.thread.status === 'doing' ? 1 : input.thread.status === 'blocked' ? 0.82 : 0.74),
+      detail: safeTrim(input.thread.summary || input.thread.nextStep, 140),
+    });
+  }
+  if (!input.thread && !input.handoff && input.fallbackMainlineTitle) {
+    currents.push({
+      kind: 'primary_thread',
+      label: input.fallbackMainlineTitle,
+      energy: 0.66,
+      detail: safeTrim(input.fallbackMainlineSummary, 140),
+    });
+  }
+  if (input.handoff) {
+    currents.push({
+      kind: 'handoff',
+      label: input.handoff.task,
+      node: buildHandoffNode(input.handoff.id),
+      energy: clampEnergy(input.handoff.progressStatus === 'doing' ? 0.94 : 0.8),
+      detail: safeTrim(input.handoff.nextStep || input.handoff.summary, 140),
+    });
+  }
+  if (input.anchors[0]) {
+    const anchor = input.anchors[0];
+    currents.push({
+      kind: 'anchor',
+      label: anchor.title,
+      node: buildAnchorNode(anchor.pageId),
+      energy: clampEnergy(0.7 + Math.min(0.25, anchor.confidence * 0.2)),
+      detail: safeTrim(anchor.summary, 140),
+    });
+  }
+  if (input.recovery) {
+    currents.push({
+      kind: 'recovery',
+      label: input.recovery.recoveryId,
+      node: buildRecoveryNode(input.recovery.recoveryId),
+      energy: clampEnergy(0.62 + Math.min(0.25, Number(input.recovery.lineageDepth ?? 0) * 0.06)),
+      detail: safeTrim(input.recovery.note || input.recovery.source, 140),
+    });
+  }
+  for (const suggestion of input.repairSuggestions.slice(0, input.signalLimit)) {
+    currents.push({
+      kind: 'repair',
+      label: suggestion.title,
+      energy: clampEnergy(suggestion.priority === 'P0' ? 0.88 : suggestion.priority === 'P1' ? 0.76 : 0.62),
+      detail: safeTrim(suggestion.detail, 140),
+    });
+  }
+  for (const issue of input.issues.slice(0, input.signalLimit)) {
+    currents.push({
+      kind: 'issue',
+      label: issue.code,
+      energy: clampEnergy(issue.severity === 'high' ? 0.84 : issue.severity === 'medium' ? 0.68 : 0.52),
+      detail: safeTrim(issue.detail, 140),
+    });
+  }
+  for (const snippet of input.evidence.slice(0, input.signalLimit)) {
+    currents.push({
+      kind: 'evidence',
+      label: snippet.title,
+      energy: 0.58,
+      detail: safeTrim(snippet.quote, 140),
+    });
+  }
+  return currents.sort((a, b) => b.energy - a.energy || a.kind.localeCompare(b.kind));
+}
+export function buildCurrentMix(currents: TsunamiStormCenterCurrent[]): TsunamiStormCenterCurrentMix[] {
+  const kindMap = new Map<StormCurrentKind, { energy: number; count: number }>();
+  for (const current of currents) {
+    const entry = kindMap.get(current.kind) ?? { energy: 0, count: 0 };
+    entry.energy += current.energy;
+    entry.count += 1;
+    kindMap.set(current.kind, entry);
+  }
+  return Array.from(kindMap.entries())
+    .map(([kind, entry]) => ({
+      kind,
+      energy: Number(entry.energy.toFixed(2)),
+      count: entry.count,
+    }))
+    .sort((a, b) => b.energy - a.energy || b.count - a.count || a.kind.localeCompare(b.kind))
+    .slice(0, 4);
+}

package/src/storm/types.ts

@@ -0,0 +1,216 @@
+// Storm center — type definitions
+import type { ProjectHandoffRecord, ProjectTaskThread } from '../core/project_state';
+import type { DurableRecoveryRecord } from '../runtime/checkpoints/durable_recovery';
+import type { TsunamiRuntimeGraphSyncSummary } from '../tsunami_runtime_graph_sync';
+
+export type BuildStormCenterOpts = {
+  projectDir?: string;
+  query?: string;
+  sessionId?: string;
+  refreshGraph?: boolean;
+  evidenceLimit?: number;
+  signalLimit?: number;
+  relationLimit?: number;
+};
+
+type StormCurrentKind =
+  | 'primary_thread'
+  | 'handoff'
+  | 'anchor'
+  | 'recovery'
+  | 'repair'
+  | 'issue'
+  | 'evidence';
+
+export type TsunamiStormCenterCurrent = {
+  kind: StormCurrentKind;
+  label: string;
+  node?: string;
+  energy: number;
+  detail?: string;
+};
+
+export type TsunamiStormCenterCurrentMix = {
+  kind: StormCurrentKind;
+  energy: number;
+  count: number;
+};
+
+export type TsunamiStormCenterStormMode = {
+  label: string;
+  dominantKind: StormCurrentKind;
+  dominance: number;
+  mixed: boolean;
+};
+
+export type TsunamiStormPressure = {
+  level: 'calm' | 'steady' | 'rising' | 'critical';
+  score: number;
+  reasons: string[];
+};
+
+export type TsunamiStormDirective = {
+  label: string;
+  lane: 'stabilize' | 'repair' | 'diagnose' | 'consolidate' | 'advance';
+  reason: string;
+};
+
+export type TsunamiStormAction = {
+  label: string;
+  target?: string;
+  reason: string;
+};
+
+export type TsunamiStormReadiness = {
+  level: 'weak' | 'partial' | 'ready' | 'fortified';
+  score: number;
+  gaps: string[];
+};
+
+export type TsunamiStormBoundary = {
+  mode: 'sealed' | 'guarded' | 'permeable' | 'spilling';
+  expand: boolean;
+  reason: string;
+};
+
+export type TsunamiStormHorizon = {
+  label: 'single_step' | 'short_run' | 'two_step' | 'multi_step';
+  steps: number;
+  reason: string;
+};
+
+export type TsunamiStormConfidence = {
+  level: 'low' | 'guarded' | 'confident' | 'high';
+  score: number;
+  reason: string;
+};
+
+export type TsunamiStormGate = {
+  verdict: 'hold' | 'guarded' | 'proceed' | 'expand';
+  allowForward: boolean;
+  reason: string;
+};
+
+export type TsunamiStormBudget = {
+  mode: 'frozen' | 'minimal' | 'guided' | 'open';
+  steps: number;
+  reason: string;
+};
+
+export type TsunamiStormSelection = {
+  profile: 'frozen' | 'tight' | 'focused' | 'broad';
+  signalLimit: number;
+  evidenceLimit: number;
+  relationLimit: number;
+  reason: string;
+};
+
+export type TsunamiStormCoverage = {
+  mode: 'narrow' | 'focused' | 'broad' | 'full';
+  score: number;
+  selectedSignals: number;
+  totalSignals: number;
+  selectedEvidence: number;
+  totalEvidence: number;
+  selectedRelations: number;
+  totalRelations: number;
+  reason: string;
+};
+
+export type TsunamiStormSaturation = {
+  level: 'clear' | 'near_limit' | 'saturated';
+  signalHitLimit: boolean;
+  evidenceHitLimit: boolean;
+  relationHitLimit: boolean;
+  hitLanes: Array<'signals' | 'evidence' | 'relations'>;
+  reason: string;
+};
+
+export type TsunamiStormIntake = {
+  mode: 'hold' | 'rebalance' | 'widen' | 'steady';
+  target: 'signals' | 'evidence' | 'relations' | 'balanced';
+  nextSignalLimit: number;
+  nextEvidenceLimit: number;
+  nextRelationLimit: number;
+  reason: string;
+};
+
+export type TsunamiStormCenter = {
+  projectDir: string;
+  projectNode: string;
+  query: string;
+  focusQuery: string;
+  refreshedGraph: boolean;
+  syncSummary?: TsunamiRuntimeGraphSyncSummary | null;
+  focus: {
+    title: string;
+    status?: string;
+    summary?: string;
+    nextStep?: string;
+    featureId?: string;
+  };
+  flow: {
+    basin: string;
+    current: string;
+    confidence: number;
+  };
+  supportingBasins: Array<{
+    basin: string;
+    energy: number;
+    drivers: string[];
+  }>;
+  thread: ProjectTaskThread | null;
+  handoff: ProjectHandoffRecord | null;
+  recovery: DurableRecoveryRecord | null;
+  anchors: Array<{
+    pageId: string;
+    title: string;
+    summary: string;
+    confidence: number;
+    tags: string[];
+  }>;
+  evidence: ReturnType<typeof queryProjectWiki>['evidence'];
+  graph: {
+    project: Record<string, unknown>[];
+    thread: Record<string, unknown>[];
+    handoff: Record<string, unknown>[];
+    anchor: Record<string, unknown>[];
+    recovery: Record<string, unknown>[];
+  };
+  issues: ReturnType<typeof auditMemoryFabric>['issues'];
+  repairSuggestions: ReturnType<typeof auditMemoryFabric>['repairSuggestions'];
+  currents: TsunamiStormCenterCurrent[];
+  currentMix: TsunamiStormCenterCurrentMix[];
+  stormMode?: TsunamiStormCenterStormMode;
+  stormPressure?: TsunamiStormPressure;
+  stormDirective?: TsunamiStormDirective;
+  stormAction?: TsunamiStormAction;
+  stormReadiness?: TsunamiStormReadiness;
+  stormBoundary?: TsunamiStormBoundary;
+  stormHorizon?: TsunamiStormHorizon;
+  stormConfidence?: TsunamiStormConfidence;
+  stormGate?: TsunamiStormGate;
+  stormBudget?: TsunamiStormBudget;
+  stormSelection?: TsunamiStormSelection;
+  stormCoverage?: TsunamiStormCoverage;
+  stormSaturation?: TsunamiStormSaturation;
+  stormIntake?: TsunamiStormIntake;
+  topRepair?: {
+    title: string;
+    priority?: string;
+    detail?: string;
+  };
+  topIssue?: {
+    code: string;
+    severity?: string;
+    detail?: string;
+  };
+  metrics: {
+    issueCount: number;
+    repairCount: number;
+    evidenceCount: number;
+    anchorCount: number;
+    graphEdges: number;
+    recoveryDepth: number;
+  };
+};