@snapback/cli 1.6.0 → 3.0.0

package/dist/chunk-O7HMAZ7L.js

@@ -0,0 +1,3497 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { LearningApiSchema } from './chunk-CBGOC6RV.js';
+import { __name } from './chunk-7ADPL4Q3.js';
+import { existsSync, readFileSync } from 'fs';
+import * as os from 'os';
+import { homedir } from 'os';
+import * as path from 'path';
+import { join } from 'path';
+import * as net from 'net';
+import { z } from 'zod';
+import pRetry from 'p-retry';
+
+process.env.SNAPBACK_CLI='true';
+
+// ../../packages/contracts/dist/local-service/protocol.js
+var ProtocolErrorCode;
+(function(ProtocolErrorCode2) {
+  ProtocolErrorCode2[ProtocolErrorCode2["ParseError"] = -32700] = "ParseError";
+  ProtocolErrorCode2[ProtocolErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
+  ProtocolErrorCode2[ProtocolErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
+  ProtocolErrorCode2[ProtocolErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
+  ProtocolErrorCode2[ProtocolErrorCode2["InternalError"] = -32603] = "InternalError";
+  ProtocolErrorCode2[ProtocolErrorCode2["ServerError"] = -32e3] = "ServerError";
+  ProtocolErrorCode2[ProtocolErrorCode2["NotInitialized"] = -32001] = "NotInitialized";
+  ProtocolErrorCode2[ProtocolErrorCode2["AlreadyInitialized"] = -32002] = "AlreadyInitialized";
+  ProtocolErrorCode2[ProtocolErrorCode2["ShuttingDown"] = -32003] = "ShuttingDown";
+  ProtocolErrorCode2[ProtocolErrorCode2["NotAuthenticated"] = 1e3] = "NotAuthenticated";
+  ProtocolErrorCode2[ProtocolErrorCode2["TierRequired"] = 1001] = "TierRequired";
+  ProtocolErrorCode2[ProtocolErrorCode2["ApiUnavailable"] = 1002] = "ApiUnavailable";
+  ProtocolErrorCode2[ProtocolErrorCode2["QuotaExceeded"] = 1003] = "QuotaExceeded";
+  ProtocolErrorCode2[ProtocolErrorCode2["WorkspaceNotFound"] = 1500] = "WorkspaceNotFound";
+  ProtocolErrorCode2[ProtocolErrorCode2["WorkspaceAlreadyExists"] = 1501] = "WorkspaceAlreadyExists";
+  ProtocolErrorCode2[ProtocolErrorCode2["SessionNotFound"] = 2e3] = "SessionNotFound";
+  ProtocolErrorCode2[ProtocolErrorCode2["SessionEnded"] = 2001] = "SessionEnded";
+  ProtocolErrorCode2[ProtocolErrorCode2["SnapshotNotFound"] = 3e3] = "SnapshotNotFound";
+  ProtocolErrorCode2[ProtocolErrorCode2["ContentHashMismatch"] = 3001] = "ContentHashMismatch";
+  ProtocolErrorCode2[ProtocolErrorCode2["RestoreFailed"] = 3002] = "RestoreFailed";
+  ProtocolErrorCode2[ProtocolErrorCode2["FileNotFound"] = 4e3] = "FileNotFound";
+  ProtocolErrorCode2[ProtocolErrorCode2["FileAccessDenied"] = 4001] = "FileAccessDenied";
+  ProtocolErrorCode2[ProtocolErrorCode2["InvalidPath"] = 4002] = "InvalidPath";
+  ProtocolErrorCode2[ProtocolErrorCode2["LearningNotFound"] = 5e3] = "LearningNotFound";
+  ProtocolErrorCode2[ProtocolErrorCode2["LearningEvaluationFailed"] = 5001] = "LearningEvaluationFailed";
+  ProtocolErrorCode2[ProtocolErrorCode2["SyncUnavailable"] = 6e3] = "SyncUnavailable";
+  ProtocolErrorCode2[ProtocolErrorCode2["SyncAuthRequired"] = 6001] = "SyncAuthRequired";
+  ProtocolErrorCode2[ProtocolErrorCode2["ValidationTimeout"] = 7e3] = "ValidationTimeout";
+  ProtocolErrorCode2[ProtocolErrorCode2["IntelligenceUnavailable"] = 8e3] = "IntelligenceUnavailable";
+  ProtocolErrorCode2[ProtocolErrorCode2["PatternNotFound"] = 8001] = "PatternNotFound";
+})(ProtocolErrorCode || (ProtocolErrorCode = {}));
+({
+  [ProtocolErrorCode.ParseError]: "Invalid JSON",
+  [ProtocolErrorCode.InvalidRequest]: "Invalid JSON-RPC request",
+  [ProtocolErrorCode.MethodNotFound]: "Method does not exist",
+  [ProtocolErrorCode.InvalidParams]: "Invalid method parameters",
+  [ProtocolErrorCode.InternalError]: "Internal service error",
+  [ProtocolErrorCode.ServerError]: "Server error",
+  [ProtocolErrorCode.NotInitialized]: "Client must call initialize before other methods",
+  [ProtocolErrorCode.AlreadyInitialized]: "Client has already called initialize",
+  [ProtocolErrorCode.ShuttingDown]: "Service is shutting down",
+  [ProtocolErrorCode.NotAuthenticated]: "Authentication required for this method",
+  [ProtocolErrorCode.TierRequired]: "PRO tier required for this method",
+  [ProtocolErrorCode.ApiUnavailable]: "Cannot reach api.snapback.dev",
+  [ProtocolErrorCode.QuotaExceeded]: "Storage or API quota exceeded",
+  [ProtocolErrorCode.SessionNotFound]: "Session does not exist",
+  [ProtocolErrorCode.SessionEnded]: "Session has already ended",
+  [ProtocolErrorCode.SnapshotNotFound]: "Snapshot does not exist",
+  [ProtocolErrorCode.ContentHashMismatch]: "Content integrity check failed",
+  [ProtocolErrorCode.RestoreFailed]: "Could not write restored file",
+  [ProtocolErrorCode.FileNotFound]: "File does not exist",
+  [ProtocolErrorCode.FileAccessDenied]: "Cannot read/write file",
+  [ProtocolErrorCode.InvalidPath]: "Path is outside allowed directories",
+  [ProtocolErrorCode.WorkspaceNotFound]: "Workspace not found or not initialized",
+  [ProtocolErrorCode.WorkspaceAlreadyExists]: "Workspace already exists",
+  [ProtocolErrorCode.LearningNotFound]: "Learning not found",
+  [ProtocolErrorCode.LearningEvaluationFailed]: "Learning evaluation failed",
+  [ProtocolErrorCode.SyncUnavailable]: "Sync worker not available",
+  [ProtocolErrorCode.SyncAuthRequired]: "Sync authentication required",
+  [ProtocolErrorCode.ValidationTimeout]: "Validation timed out",
+  [ProtocolErrorCode.IntelligenceUnavailable]: "Intelligence service not available",
+  [ProtocolErrorCode.PatternNotFound]: "Pattern not found"
+});
+z.string().regex(/^\d+\.\d+\.\d+$/);
+var SnapshotTrigger = z.enum([
+  "save",
+  "ai_burst",
+  "manual",
+  "timer",
+  "pre_restore",
+  "external"
+]);
+var ProtectionLevel = z.enum([
+  "watch",
+  "warn",
+  "block"
+]);
+var RiskLevel = z.enum([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+var SessionState = z.enum([
+  "active",
+  "idle",
+  "ended"
+]);
+z.enum([
+  "free",
+  "pro",
+  "enterprise"
+]);
+var LearningType = z.enum([
+  "pattern",
+  "pitfall",
+  "efficiency",
+  "discovery",
+  "workflow"
+]);
+var TaskIntent = z.enum([
+  "implement",
+  "debug",
+  "refactor",
+  "review",
+  "explore"
+]);
+var MemoryEntryType = z.enum([
+  "learning",
+  "pattern",
+  "violation",
+  "context",
+  "task",
+  "session"
+]);
+var WarningSeverity = z.enum([
+  "info",
+  "warning",
+  "error"
+]);
+var CoChangeRelationship = z.enum([
+  "import_dependency",
+  "test_coverage",
+  "config_pair",
+  "co_change_historical",
+  "type_definition"
+]).or(z.string());
+var ClientType = z.enum([
+  "vscode",
+  "mcp-stdio",
+  "mcp-remote",
+  "cli",
+  "api",
+  "unknown"
+]);
+var TimingSpan = z.object({
+  /** Name of the span (e.g., "ipc_receive", "service_dispatch", "decision") */
+  name: z.string(),
+  /** Start time in milliseconds relative to request start */
+  startMs: z.number(),
+  /** End time in milliseconds relative to request start */
+  endMs: z.number()
+});
+var SavePathMetrics = z.object({
+  /** Unique identifier for this request */
+  requestId: z.string(),
+  /** Total time from request receive to response send */
+  totalMs: z.number(),
+  /** Breakdown of time spent in each phase */
+  spans: z.array(TimingSpan),
+  /** Whether a snapshot was actually created */
+  snapshotCreated: z.boolean()
+});
+var ShouldCreateReason = z.enum([
+  "no_previous",
+  "hash_changed",
+  "time_threshold",
+  "size_threshold",
+  "no_change",
+  "cooldown"
+]);
+var FileConflict = z.object({
+  /** The OTHER session ID involved in the conflict */
+  sessionId: z.string(),
+  /** Client type of the other session */
+  clientType: z.enum([
+    "vscode",
+    "mcp-stdio",
+    "mcp-remote",
+    "cli",
+    "api",
+    "unknown"
+  ]),
+  /** Overlapping file paths */
+  files: z.array(z.string()),
+  /** When the conflict was detected */
+  detectedAt: z.number(),
+  /** Severity level */
+  severity: z.enum([
+    "info",
+    "warn"
+  ])
+});
+z.object({
+  /** Unique session identifier (UUID v4) */
+  id: z.string().uuid(),
+  /** Absolute path to the workspace root */
+  workspacePath: z.string(),
+  /** ISO 8601 timestamp when session started */
+  startedAt: z.string().datetime(),
+  /** ISO 8601 timestamp of last activity */
+  lastActivityAt: z.string().datetime(),
+  /** Current session state */
+  state: SessionState,
+  /** Session metadata */
+  metadata: z.object({
+    /** AI tools detected during this session */
+    aiToolsDetected: z.array(z.string()),
+    /** Highest risk level seen in this session */
+    highestRiskLevel: RiskLevel,
+    /** Count of snapshots by trigger type */
+    triggerCounts: z.record(z.string(), z.number())
+  }),
+  // === Phase 1 Additions ===
+  /** Client ID that owns this session (populated from ClientRegistry) */
+  clientId: z.string().optional(),
+  /** Client type (vscode, mcp-stdio, mcp-remote, cli, api, unknown) */
+  clientType: z.enum([
+    "vscode",
+    "mcp-stdio",
+    "mcp-remote",
+    "cli",
+    "api",
+    "unknown"
+  ]).optional(),
+  /** Unix ms timestamp when session ended (null if active) */
+  endedAt: z.number().nullable().optional(),
+  /** Snapshot IDs created during this session */
+  snapshotIds: z.array(z.string()).optional(),
+  /** Learning IDs captured during this session */
+  learningIds: z.array(z.string()).optional(),
+  /** Coherence score computed at session end */
+  coherenceScore: z.enum([
+    "high",
+    "medium",
+    "low",
+    "scattered"
+  ]).nullable().optional(),
+  /** Maximum risk score observed during session */
+  riskPeakScore: z.number().nullable().optional(),
+  /** Other active sessions on same workspace */
+  concurrentSessionIds: z.array(z.string()).optional(),
+  /** Cross-session file overlap detections */
+  fileConflicts: z.array(FileConflict).optional(),
+  /** Files touched during this session */
+  touchedFiles: z.array(z.string()).optional()
+});
+var Snapshot = z.object({
+  /** Unique snapshot identifier (UUID v4) */
+  id: z.string().uuid(),
+  /** Session that created this snapshot */
+  sessionId: z.string().uuid(),
+  /** Absolute path to the file */
+  filePath: z.string(),
+  /** Path relative to workspace root */
+  relativePath: z.string(),
+  /** Content hash (SHA-256, prefixed with "sha256:") */
+  contentHash: z.string().startsWith("sha256:"),
+  /** What triggered this snapshot */
+  trigger: SnapshotTrigger,
+  /** ISO 8601 timestamp when snapshot was created */
+  createdAt: z.string().datetime(),
+  /** Snapshot metadata */
+  metadata: z.object({
+    /** File size in bytes */
+    fileSize: z.number().int().nonnegative(),
+    /** Number of lines in the file */
+    lineCount: z.number().int().nonnegative(),
+    /** Programming language (optional) */
+    language: z.string().optional(),
+    /** AI tool that was active (if detected) */
+    aiToolDetected: z.string().optional(),
+    /** Confidence score for AI detection (0-1) */
+    aiConfidence: z.number().min(0).max(1).optional(),
+    /** Risk level assessment (optional) */
+    riskLevel: RiskLevel.optional()
+  })
+});
+z.object({
+  /** Determined protection level */
+  level: ProtectionLevel,
+  /** Whether this was automatically determined */
+  automatic: z.boolean(),
+  /** Source of the decision */
+  source: z.enum([
+    "auto",
+    "user",
+    "config",
+    "default"
+  ]),
+  /** Confidence in the decision (0-1) */
+  confidence: z.number().min(0).max(1)
+});
+z.object({
+  /** Factor name/description */
+  name: z.string(),
+  /** Factor score (0-1, higher = more protection needed) */
+  score: z.number().min(0).max(1),
+  /** Factor weight in overall decision (0-1) */
+  weight: z.number().min(0).max(1),
+  /** Additional details (optional) */
+  details: z.string().optional()
+});
+z.object({
+  /** Type of detection signal */
+  type: z.enum([
+    "pattern",
+    "timing",
+    "volume",
+    "style"
+  ]),
+  /** Human-readable description */
+  description: z.string(),
+  /** Signal strength (0-1, higher = stronger evidence) */
+  strength: z.number().min(0).max(1)
+});
+z.object({
+  /** Risk category */
+  category: z.enum([
+    "security",
+    "stability",
+    "data",
+    "infrastructure"
+  ]),
+  /** Human-readable description */
+  description: z.string(),
+  /** Severity level */
+  severity: z.enum([
+    "low",
+    "medium",
+    "high"
+  ]),
+  /** Location in code (optional) */
+  location: z.object({
+    /** Starting line number (1-indexed) */
+    startLine: z.number().int().positive(),
+    /** Ending line number (1-indexed) */
+    endLine: z.number().int().positive()
+  }).optional()
+});
+z.object({
+  /** Overall risk score: 0-100 */
+  score: z.number().int().min(0).max(100),
+  /** Risk level classification (reuses existing RiskLevel from local-service) */
+  level: RiskLevel,
+  /** All identified risk factors */
+  factors: z.array(z.object({
+    /** Factor name */
+    name: z.string(),
+    /** Score contribution: -100 to 100 */
+    score: z.number().min(-100).max(100),
+    /** Human-readable description */
+    description: z.string(),
+    /** Source system */
+    source: z.enum([
+      "github",
+      "context7",
+      "sentry",
+      "local",
+      "ai_detection"
+    ]),
+    /** Optional mitigation suggestion */
+    suggestion: z.string().optional()
+  })),
+  /** Recommended action */
+  recommendation: z.enum([
+    "proceed",
+    "warn",
+    "block"
+  ]),
+  /** Confidence in assessment: 0-100 */
+  confidence: z.number().int().min(0).max(100),
+  /** Human-readable explanation */
+  explanation: z.string()
+});
+z.discriminatedUnion("detected", [
+  z.object({
+    detected: z.literal(false),
+    /** Detection confidence: 0-1 (confidence that no AI was involved) */
+    confidence: z.number().min(0).max(1),
+    /** Detection signals evaluated */
+    signals: z.array(z.object({
+      type: z.enum([
+        "pattern",
+        "timing",
+        "volume",
+        "style"
+      ]),
+      description: z.string(),
+      strength: z.number().min(0).max(1)
+    }))
+  }),
+  z.object({
+    detected: z.literal(true),
+    /** Detected AI tool name */
+    toolName: z.string(),
+    /** Detection confidence: 0-1 */
+    confidence: z.number().min(0).max(1),
+    /** Detection signals that contributed to the result */
+    signals: z.array(z.object({
+      type: z.enum([
+        "pattern",
+        "timing",
+        "volume",
+        "style"
+      ]),
+      description: z.string(),
+      strength: z.number().min(0).max(1)
+    }))
+  })
+]);
+z.object({
+  /** Relative file path */
+  filePath: z.string(),
+  /** Fragility score: 0-1 (1 = very fragile) */
+  fragilityScore: z.number().min(0).max(1),
+  /** Severity classification */
+  severity: z.enum([
+    "moderate",
+    "high",
+    "critical"
+  ]),
+  /** Why this file is fragile */
+  reason: z.string(),
+  /** Suggested action */
+  suggestion: z.string(),
+  /** Number of rollbacks in recent history */
+  rollbackCount: z.number().int().nonnegative(),
+  /** Number of AI-triggered modifications */
+  aiChurnCount: z.number().int().nonnegative(),
+  /** Blast radius (number of dependent files) */
+  blastRadius: z.number().int().nonnegative().optional(),
+  /** Last modified timestamp (ISO 8601) */
+  lastModified: z.string().datetime().optional()
+});
+z.object({
+  /** Primary file path */
+  fileA: z.string(),
+  /** Co-changed file path */
+  fileB: z.string(),
+  /** Co-occurrence frequency: 0-1 (1 = always changed together) */
+  frequency: z.number().min(0).max(1),
+  /** Number of times these files were changed together */
+  occurrences: z.number().int().positive(),
+  /** Relationship type — extensible union */
+  relationship: CoChangeRelationship,
+  /** Human-readable description of why they co-change */
+  reason: z.string(),
+  /** When this pattern was last observed (ISO 8601) */
+  lastObserved: z.string().datetime()
+});
+z.object({
+  /** Relative file path */
+  path: z.string().min(1),
+  /** Composite fragility score: 0-100 (100 = most fragile) */
+  compositeScore: z.number().min(0).max(100),
+  /** Weighted churn rate contribution */
+  churnScore: z.number().min(0),
+  /** Weighted dependency count contribution */
+  blastRadiusScore: z.number().min(0),
+  /** How often restores involve this file */
+  rollbackScore: z.number().min(0),
+  /** Files that import this file */
+  dependentCount: z.number().int().nonnegative(),
+  /** Ranking: 1 = most fragile */
+  rank: z.number().int().positive()
+});
+z.object({
+  /** Primary file path */
+  fileA: z.string().min(1),
+  /** Co-changed file path */
+  fileB: z.string().min(1),
+  /** Co-occurrence frequency: 0-1 (1 = always changed together) */
+  frequency: z.number().min(0).max(1),
+  /** Number of times these files were changed together */
+  occurrences: z.number().int().positive(),
+  /** Relationship type — extensible string */
+  relationship: z.string().min(1),
+  /** Human-readable description of why they co-change */
+  reason: z.string().min(1),
+  /** When this pattern was last observed (epoch timestamp) */
+  lastObserved: z.number().int().positive()
+});
+var RiskFactorStorageSchema = z.object({
+  /** Pillar source */
+  source: z.enum([
+    "git-risk",
+    "rollback-patterns",
+    "fatigue",
+    "annotations",
+    "poisoning",
+    "history",
+    "structural",
+    "co-change"
+  ]),
+  /** Risk score contribution */
+  score: z.number(),
+  /** Human-readable description */
+  description: z.string().min(1),
+  /** Severity level */
+  severity: z.enum([
+    "info",
+    "warning",
+    "critical"
+  ]),
+  /** Additional metadata */
+  meta: z.record(z.unknown()).optional()
+});
+z.object({
+  /** Overall risk score (1.0 = neutral, higher = riskier) */
+  riskScore: z.number().min(0),
+  /** Action recommendation */
+  action: z.enum([
+    "PROCEED",
+    "PROCEED_WITH_SNAPSHOT",
+    "WARN",
+    "BLOCK"
+  ]),
+  /** All contributing factors */
+  factors: z.array(RiskFactorStorageSchema),
+  /** Whether write is allowed */
+  allowed: z.boolean(),
+  /** Human-readable recommendation */
+  recommendation: z.string().min(1),
+  /** Alternative actions if blocked */
+  alternativeActions: z.array(z.object({
+    tool: z.string(),
+    description: z.string(),
+    params: z.record(z.unknown()).optional()
+  })).optional(),
+  /** Assessment timestamp (epoch) */
+  timestamp: z.number().int().positive(),
+  /** Correlation ID for tracing */
+  correlationId: z.string().optional()
+});
+z.object({
+  /** Total learnings captured for this workspace */
+  learningsCount: z.number().int().nonnegative(),
+  /** Total patterns detected */
+  patternsCount: z.number().int().nonnegative(),
+  /** Number of fragile files identified */
+  fragileFilesCount: z.number().int().nonnegative(),
+  /** Number of co-change relationships detected */
+  coChangePatternsCount: z.number().int().nonnegative(),
+  /** Total sessions recorded (cumulative) */
+  totalSessions: z.number().int().nonnegative(),
+  /** Total lines analyzed (cumulative — retained for Pioneer Program) */
+  linesAnalyzed: z.number().int().nonnegative(),
+  /** Total snapshots created (cumulative) */
+  totalSnapshots: z.number().int().nonnegative(),
+  /** Total restores performed (cumulative) */
+  totalRestores: z.number().int().nonnegative(),
+  // ── Time-windowed counters (v2 — meaningful recency) ──
+  /** Snapshots created in the last 24 hours */
+  snapshotsToday: z.number().int().nonnegative(),
+  /** Snapshots created in the last 7 days */
+  snapshotsThisWeek: z.number().int().nonnegative(),
+  /** Lines analyzed in the last 24 hours */
+  linesAnalyzedToday: z.number().int().nonnegative(),
+  /** Restores performed in the last 7 days */
+  restoresThisWeek: z.number().int().nonnegative(),
+  /** Patterns detected in the last 7 days */
+  patternsThisWeek: z.number().int().nonnegative(),
+  // ── Health summary ──
+  /** Workspace health score: 0-100 */
+  healthScore: z.number().int().min(0).max(100),
+  /** Health trajectory */
+  healthTrajectory: z.enum([
+    "improving",
+    "stable",
+    "declining"
+  ])
+});
+z.object({
+  /** Warning code (e.g., 'FRAGILE_FILE', 'LOOP_DETECTED') */
+  code: z.string(),
+  /** Severity level (ordered: info < warning < error) */
+  level: WarningSeverity,
+  /** Human-readable message */
+  message: z.string(),
+  /** Affected file (optional) */
+  file: z.string().optional(),
+  /** Suggested action */
+  suggestion: z.string().optional()
+});
+z.object({
+  /** Coherence score: 0-100 (100 = highly focused session) */
+  score: z.number().int().min(0).max(100),
+  /** Assessment */
+  assessment: z.enum([
+    "focused",
+    "moderate",
+    "scattered",
+    "chaotic"
+  ]),
+  /** Number of distinct file clusters in the session */
+  clusterCount: z.number().int().nonnegative(),
+  /** Primary focus area (most-edited directory or module) */
+  primaryFocus: z.string().nullable(),
+  /** Files that seem unrelated to the main session focus */
+  outlierFiles: z.array(z.string())
+});
+var SnapshotAIAttribution = z.discriminatedUnion("detected", [
+  z.object({
+    detected: z.literal(false)
+  }),
+  z.object({
+    detected: z.literal(true),
+    toolName: z.string(),
+    confidence: z.number().min(0).max(1)
+  })
+]);
+Snapshot.extend({
+  /** Risk assessment at time of creation */
+  risk: z.object({
+    score: z.number().int().min(0).max(100),
+    level: RiskLevel
+  }).optional(),
+  /** AI tool attribution (absent = not checked, present = checked) */
+  aiAttribution: SnapshotAIAttribution.optional(),
+  /** Session cluster ID (for grouping in timeline) */
+  sessionClusterId: z.string().uuid().nullable(),
+  /** Whether this snapshot has been restored */
+  wasRestored: z.boolean()
+});
+var WorkspaceBase = z.object({
+  /** Absolute path to workspace root */
+  workspace: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** Skip baseline computation (faster, less complete) */
+  skipBaseline: z.boolean().optional(),
+  /** Skip learning seeding */
+  skipLearnings: z.boolean().optional(),
+  /** Force re-seed learnings even if already seeded */
+  forceSeedLearnings: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** Optional path to global knowledge DB (defaults to ~/.snapback/knowledge.db) */
+  globalDbPath: z.string().optional()
+});
+var GuardStatus = z.enum([
+  "pass",
+  "warn",
+  "fail"
+]);
+var GuardFile = z.object({
+  /** Absolute or workspace-relative path to the flagged file */
+  path: z.string().min(1),
+  /** Line number where the issue was found (optional) */
+  line: z.number().int().positive().optional(),
+  /** Human-readable description of the issue */
+  message: z.string().min(1)
+});
+var GuardResult = z.object({
+  /** Guard name (e.g., "console-logs", "test-pollution") */
+  guard: z.string().min(1),
+  /** Execution status */
+  status: GuardStatus,
+  /** Files flagged by this guard (empty array if status is "pass") */
+  files: z.array(GuardFile).default([]),
+  /** Execution duration in milliseconds */
+  durationMs: z.number().nonnegative()
+});
+z.object({
+  /** Results from all guards in the run */
+  guards: z.array(GuardResult).default([]),
+  /** Unix timestamp (ms) when this run completed */
+  timestamp: z.number().nonnegative(),
+  /** Age of cached results in milliseconds (Date.now() - timestamp) */
+  staleMs: z.number().nonnegative(),
+  /** Profile used for this run ("fast" or "full") */
+  profile: z.enum([
+    "fast",
+    "full"
+  ]),
+  /** Whether a background refresh is in progress */
+  refreshing: z.boolean()
+});
+WorkspaceBase.extend({
+  /** Guard profile to run (optional, defaults to "fast") */
+  profile: z.enum([
+    "fast",
+    "full"
+  ]).optional().default("fast")
+});
+z.object({
+  /** Guards that changed status since last run */
+  changed: z.array(GuardResult),
+  /** Current state of all guards */
+  current: z.array(GuardResult),
+  /** Unix timestamp (ms) when the change was detected */
+  timestamp: z.number().nonnegative()
+});
+z.object({
+  /** Protocol version the client supports */
+  protocolVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+  /** Client type identifying the connecting surface */
+  clientType: ClientType.optional().default("unknown"),
+  /** Client version (semantic versioning) */
+  clientVersion: z.string().optional().default("0.0.0"),
+  /** Client identification (legacy field, kept for backward compatibility) */
+  clientInfo: z.object({
+    /** Client name (e.g., "vscode-extension", "cli") */
+    name: z.string().min(1).max(100),
+    /** Client version (semantic versioning) */
+    version: z.string()
+  }).optional(),
+  /** Client capabilities (optional) */
+  capabilities: z.object({
+    /** Client accepts server-sent notifications */
+    notifications: z.boolean().default(true),
+    /** Client can handle base64-encoded binary content */
+    binaryContent: z.boolean().default(false)
+  }).optional()
+});
+z.object({
+  /** Include detailed health information */
+  verbose: z.boolean().optional()
+});
+z.object({
+  /** Filter by workspace path (optional) */
+  workspacePath: z.string().optional()
+});
+z.object({
+  /** Absolute path to workspace root */
+  workspacePath: z.string().min(1),
+  /** Additional session metadata (optional) */
+  metadata: z.object({
+    /** Editor name (e.g., "Visual Studio Code") */
+    editorName: z.string().optional(),
+    /** Editor version */
+    editorVersion: z.string().optional()
+  }).optional()
+});
+z.object({
+  /** Session to end (defaults to current session if omitted) */
+  sessionId: z.string().uuid().optional(),
+  /** Reason for ending session */
+  reason: z.enum([
+    "user",
+    "idle",
+    "workspace_closed"
+  ]).optional()
+});
+z.object({
+  /** Filter by workspace path (optional) */
+  workspacePath: z.string().optional(),
+  /** Maximum number of sessions to return */
+  limit: z.number().int().min(1).max(100).default(20),
+  /** Pagination cursor (session ID to start after) */
+  before: z.string().uuid().optional(),
+  /** Include ended sessions in results */
+  includeEnded: z.boolean().default(true)
+});
+WorkspaceBase.extend({
+  /** Task description */
+  task: z.string().min(1),
+  /** Files involved in this task */
+  files: z.array(z.string()).optional(),
+  /** Keywords for context matching */
+  keywords: z.array(z.string()).optional()
+});
+WorkspaceBase.extend({
+  /**
+   * Free-text outcome description — what was accomplished, what remains, decisions made.
+   * Becomes the opening context for the next session briefing.
+   * Do NOT constrain to an enum: the MCP tool description promises free-text paragraphs.
+   */
+  outcome: z.string().min(1).max(2e3).optional(),
+  /** Additional notes */
+  notes: z.string().optional(),
+  /** Create a snapshot on end */
+  createSnapshot: z.boolean().optional(),
+  /** Learning IDs to accept */
+  acceptLearnings: z.array(z.number()).optional()
+});
+WorkspaceBase.extend({
+  /** Files to review */
+  files: z.array(z.string()).optional(),
+  /** Include commit message suggestion */
+  includeCommitMessage: z.boolean().optional(),
+  /** Skip pattern checking */
+  skipPatterns: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** Include diff in results */
+  includeDiff: z.boolean().optional(),
+  /** Filter to specific files */
+  filterFiles: z.array(z.string()).optional(),
+  /** Include AI attribution info */
+  includeAIAttribution: z.boolean().default(true)
+});
+z.object({
+  /** Filter by workspace path */
+  workspace: z.string().optional(),
+  /** Pagination cursor (session ID) */
+  cursor: z.string().optional(),
+  /** Max number of sessions to return (default 20) */
+  limit: z.number().optional()
+});
+z.object({
+  /** Pulse level based on file count thresholds */
+  pulse: z.enum([
+    "resting",
+    "elevated",
+    "racing",
+    "critical"
+  ]),
+  /** Pressure: ratio of unprotected changes (0-100) */
+  pressure: z.number().min(0).max(100),
+  /** Trajectory based on pressure level */
+  trajectory: z.enum([
+    "stable",
+    "increasing",
+    "decreasing"
+  ]),
+  /** Whether a snapshot is recommended */
+  snapshotRecommended: z.boolean(),
+  /** Files modified during session */
+  filesModified: z.number(),
+  /** Snapshots created during session */
+  snapshotsCreated: z.number(),
+  /** Learnings captured during session */
+  learningsCaptured: z.number()
+});
+z.object({
+  /** Absolute path to the file */
+  filePath: z.string().min(1),
+  /** File content to snapshot */
+  content: z.string(),
+  /** What triggered this snapshot */
+  trigger: SnapshotTrigger,
+  /** Additional snapshot metadata (optional) */
+  metadata: z.object({
+    /** AI tool that was active */
+    aiToolDetected: z.string().optional(),
+    /** Confidence score for AI detection (0-1) */
+    aiConfidence: z.number().min(0).max(1).optional(),
+    /** Risk level assessment */
+    riskLevel: RiskLevel.optional(),
+    /** Custom tags for organization */
+    customTags: z.array(z.string()).optional()
+  }).optional()
+});
+z.object({
+  /** Absolute path to the file being saved */
+  filePath: z.string().min(1),
+  /** SHA-256 hash of the file content (optional, for deduplication) */
+  contentHash: z.string().optional(),
+  /** Last modification timestamp in milliseconds */
+  lastModified: z.number().optional(),
+  /** File size in bytes */
+  byteSize: z.number().optional()
+});
+z.object({
+  /** Whether a snapshot should be created */
+  shouldCreate: z.boolean(),
+  /** Reason for the decision */
+  reason: ShouldCreateReason,
+  /** Optional timing metrics for performance analysis */
+  metrics: SavePathMetrics.optional()
+});
+z.object({
+  /** Snapshot ID to retrieve */
+  snapshotId: z.string().uuid(),
+  /** Include full content in response (expensive) */
+  includeContent: z.boolean().default(false)
+});
+var SnapshotListParams = z.object({
+  /** Filter by session ID (optional) */
+  sessionId: z.string().uuid().optional(),
+  /** Filter by file path (optional) */
+  filePath: z.string().optional(),
+  /** Filter by trigger types (optional) */
+  trigger: z.array(SnapshotTrigger).optional(),
+  /** Filter by created after timestamp (ISO 8601) */
+  since: z.string().datetime().optional(),
+  /** Filter by created before timestamp (ISO 8601) */
+  until: z.string().datetime().optional(),
+  /** Maximum number of snapshots to return */
+  limit: z.number().int().min(1).max(200).default(50),
+  /** Pagination cursor (opaque string) */
+  cursor: z.string().optional(),
+  /** Sort field */
+  orderBy: z.enum([
+    "createdAt",
+    "filePath"
+  ]).default("createdAt"),
+  /** Sort direction */
+  orderDir: z.enum([
+    "asc",
+    "desc"
+  ]).default("desc")
+});
+z.object({
+  /** Snapshot ID to restore */
+  snapshotId: z.string().uuid(),
+  /** Target path (defaults to original path if omitted) */
+  targetPath: z.string().optional(),
+  /** Create backup snapshot before restoring */
+  createBackup: z.boolean().default(true),
+  /** Preview restore without writing (dry run) */
+  dryRun: z.boolean().default(false)
+});
+z.object({
+  /** Base snapshot ID for comparison */
+  baseSnapshotId: z.string().uuid(),
+  /** Snapshot to compare against (defaults to current file if omitted) */
+  compareSnapshotId: z.string().uuid().optional(),
+  /** Number of context lines around changes */
+  contextLines: z.number().int().min(0).max(10).default(3),
+  /** Diff output format */
+  format: z.enum([
+    "unified",
+    "split"
+  ]).default("unified")
+});
+z.object({
+  /** Specific snapshot IDs to delete (optional) */
+  snapshotIds: z.array(z.string().uuid()).optional(),
+  /** Delete all snapshots older than timestamp (ISO 8601) (optional) */
+  olderThan: z.string().datetime().optional(),
+  /** Delete all snapshots in session (optional) */
+  sessionId: z.string().uuid().optional(),
+  /** Preview deletion without removing (dry run) */
+  dryRun: z.boolean().default(false)
+});
+WorkspaceBase.extend({
+  /** Files to snapshot (relative paths) */
+  files: z.array(z.string().min(1)).min(1),
+  /** Reason for snapshot */
+  reason: z.string().optional(),
+  /** Snapshot trigger */
+  trigger: z.enum([
+    "manual",
+    "mcp",
+    "ai_assist",
+    "session_end"
+  ]).optional()
+});
+WorkspaceBase.extend({
+  /** Delete snapshots older than N days */
+  olderThanDays: z.number().int().positive().optional(),
+  /** Keep protected snapshots */
+  keepProtected: z.boolean().default(true)
+});
+WorkspaceBase.extend({
+  /** Snapshot ID */
+  snapshotId: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** Snapshot ID */
+  snapshotId: z.string().min(1),
+  /** New name */
+  newName: z.string().min(1)
+});
+SnapshotListParams.extend({
+  /** Include risk assessment per snapshot */
+  includeRisk: z.boolean().default(true),
+  /** Include AI attribution per snapshot */
+  includeAttribution: z.boolean().default(true),
+  /** Group by session cluster */
+  groupBySessions: z.boolean().default(false)
+});
+z.object({
+  /** File path to evaluate */
+  filePath: z.string().min(1),
+  /** Current file content (optional, reads from disk if omitted) */
+  content: z.string().optional(),
+  /** Additional context for evaluation (optional) */
+  context: z.object({
+    /** Number of recent changes to the file */
+    recentChanges: z.number().int().nonnegative().optional(),
+    /** Milliseconds since last save */
+    timeSinceLastSave: z.number().int().nonnegative().optional(),
+    /** Whether an AI tool is currently active */
+    aiToolActive: z.boolean().optional()
+  }).optional()
+});
+z.object({
+  /** File paths to get protection levels for */
+  filePaths: z.array(z.string().min(1)).min(1).max(100)
+});
+z.object({
+  /** File path to set protection for */
+  filePath: z.string().min(1),
+  /** Protection level to set ("auto" to reset to automatic) */
+  level: z.enum([
+    "watch",
+    "warn",
+    "block",
+    "auto"
+  ]),
+  /** Scope of the protection rule */
+  scope: z.enum([
+    "file",
+    "directory",
+    "pattern"
+  ]).default("file"),
+  /** Pattern for pattern-based rules (glob syntax) (optional) */
+  pattern: z.string().optional()
+});
+WorkspaceBase.extend({
+  /** File path */
+  filePath: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** File path */
+  filePath: z.string().min(1),
+  /** Protection level */
+  level: ProtectionLevel,
+  /** Reason for setting level */
+  reason: z.string().optional()
+});
+WorkspaceBase.extend({
+  /** Filter by level */
+  level: ProtectionLevel.optional(),
+  /** Max results */
+  limit: z.number().int().min(1).max(500).optional()
+});
+z.object({
+  /** File path being checked */
+  filePath: z.string().min(1),
+  /** Current file content */
+  content: z.string(),
+  /** Previous content for comparison (optional) */
+  previousContent: z.string().optional(),
+  /** Additional metadata (optional) */
+  metadata: z.object({
+    /** Editor information string */
+    editorInfo: z.string().optional(),
+    /** Timestamp in milliseconds since epoch */
+    timestamp: z.number().int().positive().optional()
+  }).optional()
+});
+z.object({
+  /** Unified diff string to analyze */
+  diff: z.string(),
+  /** Context about the change */
+  context: z.object({
+    /** File path being changed */
+    filePath: z.string(),
+    /** Programming language (optional) */
+    language: z.string().optional(),
+    /** Project type (e.g., "web", "mobile", "backend") (optional) */
+    projectType: z.string().optional()
+  })
+});
+z.object({
+  /** Snapshot IDs to analyze for grouping */
+  snapshotIds: z.array(z.string().uuid()).min(1)
+});
+z.object({
+  /** Sync direction */
+  direction: z.enum([
+    "push",
+    "pull",
+    "both"
+  ]).default("both"),
+  /** Specific snapshot IDs to sync (optional, syncs all if omitted) */
+  snapshotIds: z.array(z.string().uuid()).optional()
+});
+WorkspaceBase.extend({
+  /** Learning type */
+  type: LearningType,
+  /** Trigger condition */
+  trigger: z.string().min(1),
+  /** Action to take */
+  action: z.string().min(1),
+  /** Source of the learning */
+  source: z.string().optional()
+});
+WorkspaceBase.extend({
+  /** Keywords to search */
+  keywords: z.array(z.string()).min(1),
+  /** Max results */
+  limit: z.number().int().min(1).max(100).optional()
+});
+WorkspaceBase.extend({
+  /** Max results */
+  limit: z.number().int().min(1).max(200).optional()
+});
+WorkspaceBase.extend({
+  /** Command being evaluated */
+  commandName: z.string().min(1),
+  /** Command arguments */
+  args: z.record(z.unknown()).optional(),
+  /** Files or paths involved */
+  filesOrPaths: z.array(z.string()).optional(),
+  /** Intent of the command */
+  intent: z.enum([
+    "implement",
+    "debug",
+    "refactor",
+    "review"
+  ]).optional(),
+  /** Learning mode */
+  mode: z.enum([
+    "observe",
+    "warn",
+    "apply-safe",
+    "apply-all",
+    "off"
+  ]).optional()
+});
+WorkspaceBase.extend({
+  /** Session ID */
+  sessionId: z.string().min(1),
+  /** Learning IDs to associate */
+  learningIds: z.array(z.string())
+});
+WorkspaceBase.extend({
+  /** GC operation */
+  operation: z.enum([
+    "archive",
+    "delete",
+    "all"
+  ]).optional(),
+  /** Dry run (audit only) */
+  dryRun: z.boolean().default(true)
+});
+WorkspaceBase.extend({
+  /** Optional auth token for platform sync */
+  authToken: z.string().optional()
+});
+WorkspaceBase.extend({
+  /** Task description */
+  task: z.string().min(1),
+  /** Files involved */
+  files: z.array(z.string()).optional(),
+  /** Keywords for context matching */
+  keywords: z.array(z.string()).optional()
+});
+WorkspaceBase.extend({
+  /** Code to check */
+  code: z.string(),
+  /** File path */
+  filePath: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** Single file */
+  file: z.string().optional(),
+  /** Multiple files */
+  files: z.array(z.string()).optional(),
+  /** Run tests */
+  runTests: z.boolean().optional(),
+  /** Skip TypeScript check */
+  skipTypeScript: z.boolean().optional(),
+  /** Skip tests */
+  skipTests: z.boolean().optional(),
+  /** Skip lint */
+  skipLint: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** Code to validate */
+  code: z.string(),
+  /** File path */
+  filePath: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** Violation type */
+  type: z.string().min(1),
+  /** File where violation occurred */
+  file: z.string().min(1),
+  /** What happened */
+  whatHappened: z.string().min(1),
+  /** Why it happened */
+  whyItHappened: z.string().min(1),
+  /** How to prevent it */
+  prevention: z.string().min(1)
+});
+z.object({
+  /** Absolute path to check */
+  path: z.string().min(1),
+  /** Absolute workspace root to check against */
+  workspace: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** Glob patterns to watch */
+  patterns: z.array(z.string()).optional()
+});
+WorkspaceBase.extend({
+  /** File that changed */
+  file: z.string().min(1),
+  /** Timestamp of change */
+  timestamp: z.number().int().positive()
+});
+WorkspaceBase.extend({
+  /** Snapshot ID */
+  id: z.string().min(1),
+  /** File path */
+  filePath: z.string().optional(),
+  /** Trigger type */
+  trigger: z.enum([
+    "manual",
+    "auto",
+    "ai-detection"
+  ]).optional(),
+  /** Source surface */
+  source: z.enum([
+    "mcp",
+    "cli",
+    "extension"
+  ]).optional()
+});
+WorkspaceBase.extend({
+  /** File path */
+  path: z.string().min(1),
+  /** Lines changed */
+  linesChanged: z.number().int().nonnegative().optional(),
+  /** AI-attributed change */
+  aiAttributed: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** Pattern content */
+  content: z.string().min(1),
+  /** Knowledge domain */
+  domain: z.enum([
+    "architecture",
+    "testing",
+    "documentation",
+    "performance",
+    "security",
+    "workflow",
+    "tooling"
+  ]).optional(),
+  /** Pattern type */
+  type: z.enum([
+    "pattern",
+    "anti-pattern",
+    "best-practice",
+    "constraint",
+    "heuristic"
+  ]).optional(),
+  /** Severity */
+  severity: z.enum([
+    "info",
+    "warning",
+    "error"
+  ]).optional(),
+  /** Related pattern IDs */
+  relatedTo: z.array(z.string()).optional(),
+  /** Gap Fields: Outcome type for dashboard tracking (prevented/recovered/monitored) */
+  outcome: z.enum([
+    "prevented",
+    "recovered",
+    "monitored"
+  ]).optional(),
+  /** Gap Fields: File categories involved (for risksPreventedContext) */
+  fileCategories: z.array(z.string()).optional(),
+  /** Gap Fields: Blast radius count for the decision */
+  blastRadius: z.number().int().nonnegative().optional(),
+  /** Gap Fields: File path for the event */
+  filePath: z.string().optional(),
+  /** Gap Fields: AI tool detected (cursor/copilot/claude) */
+  aiTool: z.enum([
+    "cursor",
+    "copilot",
+    "claude"
+  ]).optional(),
+  /** Gap Fields: Risk level (high/medium/low) */
+  risk: z.enum([
+    "high",
+    "medium",
+    "low"
+  ]).optional()
+});
+WorkspaceBase.extend({
+  /** Pattern ID or Decision ID */
+  patternId: z.string().min(1),
+  /**
+   * Outcome type
+   * - resolved/regressed/ignored: Original pattern outcomes
+   * - prevented/recovered/monitored: Gap Fields dashboard outcomes
+   */
+  outcome: z.enum([
+    "resolved",
+    "regressed",
+    "ignored",
+    "prevented",
+    "recovered",
+    "monitored"
+  ]),
+  /** Notes */
+  notes: z.string().optional(),
+  /** Gap Fields: Whether decision was reverted within 5min (for accuracy calc) */
+  revertedWithin5Min: z.boolean().optional(),
+  /** Gap Fields: File categories involved */
+  fileCategories: z.array(z.string()).optional()
+});
+WorkspaceBase.extend({
+  /** Unique decision ID */
+  decisionId: z.string().min(1),
+  /** Decision outcome */
+  outcome: z.enum([
+    "prevented",
+    "recovered",
+    "monitored",
+    "reverted"
+  ]),
+  /** Whether the decision was reverted within 5 minutes */
+  revertedWithin5Min: z.boolean().optional(),
+  /** File categories involved in the decision */
+  fileCategories: z.array(z.string()).optional(),
+  /** Human-readable action taken */
+  action: z.string().optional(),
+  /** Notes */
+  notes: z.string().optional()
+});
+WorkspaceBase.extend({
+  /** Minimum fragility score to include (0-1) */
+  minScore: z.number().min(0).max(1).default(0.5),
+  /** Maximum results */
+  limit: z.number().int().min(1).max(50).default(20)
+});
+WorkspaceBase.extend({
+  /** Minimum co-occurrence frequency to include (0-1) */
+  minFrequency: z.number().min(0).max(1).default(0.5),
+  /** Filter to patterns involving this file */
+  filePath: z.string().optional(),
+  /** Maximum results */
+  limit: z.number().int().min(1).max(50).default(20)
+});
+WorkspaceBase.extend({
+  /** Filter by minimum severity (uses WARNING_SEVERITY_ORDER for comparison) */
+  minLevel: WarningSeverity.default("info"),
+  /** Maximum results */
+  limit: z.number().int().min(1).max(20).default(10)
+});
+WorkspaceBase.extend({
+  /** Days to look back (default: 7) */
+  days: z.number().int().min(1).max(30).default(7)
+});
+WorkspaceBase.extend({
+  /** Weeks to look back (default: 8) */
+  weeks: z.number().int().min(1).max(12).default(8)
+});
+var GitRiskFactor = z.object({
+  /** Unique identifier for this risk factor */
+  id: z.string(),
+  /** Human-readable label */
+  label: z.string(),
+  /** Contribution to risk multiplier (additive) */
+  contribution: z.number(),
+  /** Severity level */
+  severity: z.enum([
+    "info",
+    "warning",
+    "critical"
+  ])
+});
+z.object({
+  /** Multiplicative factor applied to base risk score (1.0 = neutral) */
+  multiplier: z.number(),
+  /** Contributing factors that built up the multiplier */
+  factors: z.array(GitRiskFactor),
+  /** Whether git context was available */
+  hasGitContext: z.boolean(),
+  /** Timestamp of evaluation for caching */
+  evaluatedAt: z.number()
+});
+z.object({
+  /** Workspace path to evaluate */
+  workspace: z.string()
+});
+z.object({
+  /** AI tool that was active when rollback happened */
+  tool: z.string(),
+  /** File extension involved */
+  fileExt: z.string(),
+  /** Number of lines in the rolled-back change */
+  linesChanged: z.number(),
+  /** Programming language */
+  language: z.string(),
+  /** File category classification */
+  fileCategory: z.enum([
+    "config",
+    "code",
+    "test",
+    "docs",
+    "build",
+    "other"
+  ]),
+  /** Was it a multi-file change? */
+  fileCount: z.number(),
+  /** Time of day bucket (0-23) for fatigue correlation */
+  hourBucket: z.number().int().min(0).max(23),
+  /** Session duration at rollback time (minutes) */
+  sessionMinutes: z.number(),
+  /** Workspace where rollback occurred */
+  workspace: z.string(),
+  /** Timestamp of rollback */
+  timestamp: z.number()
+});
+z.object({
+  /** Confidence that this matches a known failure pattern (0-1) */
+  confidence: z.number().min(0).max(1),
+  /** Human-readable warning message */
+  message: z.string(),
+  /** Number of similar rollbacks in the cluster */
+  clusterSize: z.number(),
+  /** Dominant factors in the cluster */
+  dominantFactors: z.array(z.string()),
+  /** Risk boost to apply (additive) */
+  riskBoost: z.number()
+});
+z.object({
+  /** Workspace where rollback occurred */
+  workspace: z.string(),
+  /** AI tool that was active */
+  tool: z.string(),
+  /** File extension */
+  fileExt: z.string(),
+  /** Lines changed */
+  linesChanged: z.number(),
+  /** Programming language */
+  language: z.string(),
+  /** File category */
+  fileCategory: z.enum([
+    "config",
+    "code",
+    "test",
+    "docs",
+    "build",
+    "other"
+  ]),
+  /** File count */
+  fileCount: z.number(),
+  /** Session duration in minutes */
+  sessionMinutes: z.number()
+});
+z.object({
+  /** Workspace to check */
+  workspace: z.string(),
+  /** AI tool making the change */
+  tool: z.string(),
+  /** File extension */
+  fileExt: z.string(),
+  /** Lines being changed */
+  linesChanged: z.number(),
+  /** Programming language */
+  language: z.string(),
+  /** File category */
+  fileCategory: z.enum([
+    "config",
+    "code",
+    "test",
+    "docs",
+    "build",
+    "other"
+  ]),
+  /** File count in change */
+  fileCount: z.number(),
+  /** Current session duration */
+  sessionMinutes: z.number()
+});
+z.object({
+  /** Workspace to get stats for */
+  workspace: z.string()
+});
+z.object({
+  /** Total rollbacks recorded */
+  totalRollbacks: z.number(),
+  /** Number of distinct clusters */
+  clusters: z.number(),
+  /** Size of largest cluster */
+  largestCluster: z.number()
+});
+z.object({
+  /** Additive risk boost (0.0 - 0.5) */
+  riskBoost: z.number().min(0).max(0.5),
+  /** Human-readable fatigue level */
+  level: z.enum([
+    "rested",
+    "normal",
+    "elevated",
+    "fatigued"
+  ]),
+  /** Ratio of rapid accepts in the window (0-1) */
+  rapidAcceptRatio: z.number().min(0).max(1),
+  /** Current accept velocity (accepts per minute) */
+  velocityPerMinute: z.number(),
+  /** Session duration contributing to assessment */
+  sessionMinutes: z.number(),
+  /** Contributing factors to the assessment */
+  factors: z.array(z.string())
+});
+z.object({
+  /** Workspace to assess */
+  workspace: z.string()
+});
+var AnnotationTag = z.enum([
+  "good_state",
+  "before_refactor",
+  "it_broke_here",
+  "uncertain",
+  "ai_diverged",
+  "manual_recovery",
+  "shipped"
+]);
+z.object({
+  /** Snapshot hash (content-addressable ID) */
+  snapshotHash: z.string(),
+  /** Annotation tag */
+  tag: AnnotationTag,
+  /** Optional freeform note (max 280 chars) */
+  note: z.string().max(280).optional(),
+  /** Active AI tool at time of annotation */
+  aiTool: z.string().optional(),
+  /** Files in the snapshot */
+  fileCount: z.number(),
+  /** Risk score at time of annotation */
+  riskScore: z.number().optional(),
+  /** Timestamp */
+  timestamp: z.number(),
+  /** Workspace */
+  workspace: z.string()
+});
+z.object({
+  /** Snapshot hash to annotate */
+  snapshotHash: z.string(),
+  /** Annotation tag */
+  tag: AnnotationTag,
+  /** Optional note */
+  note: z.string().max(280).optional(),
+  /** AI tool active */
+  aiTool: z.string().optional(),
+  /** File count */
+  fileCount: z.number(),
+  /** Risk score at time */
+  riskScore: z.number().optional(),
+  /** Workspace */
+  workspace: z.string()
+});
+z.object({
+  /** Whether annotation was recorded */
+  recorded: z.boolean(),
+  /** Risk signal from the annotation */
+  riskSignal: z.object({
+    direction: z.enum([
+      "increase",
+      "decrease",
+      "neutral"
+    ]),
+    magnitude: z.number()
+  })
+});
+z.object({
+  /** Workspace to query */
+  workspace: z.string(),
+  /** Filter by timestamp (ms since epoch) */
+  since: z.number().optional(),
+  /** Filter by tags */
+  tags: z.array(AnnotationTag).optional(),
+  /** Limit number of results */
+  limit: z.number().optional()
+});
+z.object({
+  /** Workspace to get calibration for */
+  workspace: z.string()
+});
+z.object({
+  /** Net risk adjustment from historical annotations */
+  netAdjustment: z.number().min(-0.5).max(0.5),
+  /** Number of annotations considered */
+  annotationCount: z.number(),
+  /** Breakdown by tag */
+  breakdown: z.record(AnnotationTag, z.number())
+});
+z.object({
+  /** Whether poisoning was detected */
+  isPoisoned: z.boolean(),
+  /** How many times this pattern has been rejected */
+  occurrences: z.number(),
+  /** How many distinct sessions it appeared in */
+  distinctSessions: z.number(),
+  /** Risk boost to apply if poisoned */
+  riskBoost: z.number(),
+  /** Human-readable warning */
+  warning: z.string().optional(),
+  /** Structural fingerprint (for debugging) */
+  fingerprint: z.string().optional()
+});
+z.object({
+  /** Workspace to check */
+  workspace: z.string(),
+  /** Unified diff of proposed change */
+  diff: z.string()
+});
+z.object({
+  /** Workspace where rejection occurred */
+  workspace: z.string(),
+  /** Diff that was rejected */
+  diff: z.string(),
+  /** Session ID */
+  sessionId: z.string(),
+  /** AI tool involved */
+  tool: z.string().optional(),
+  /** File extension */
+  fileExt: z.string().optional()
+});
+z.object({
+  /** Workspace to get stats for */
+  workspace: z.string()
+});
+z.object({
+  /** Number of patterns being tracked */
+  trackedPatterns: z.number(),
+  /** Number of poisoned patterns (>= threshold) */
+  poisonedPatterns: z.number(),
+  /** Top tools involved in poisoning */
+  topTools: z.array(z.string())
+});
+var SafeToWriteAction = z.enum([
+  "PROCEED",
+  "PROCEED_WITH_SNAPSHOT",
+  "WARN",
+  "BLOCK"
+]);
+var SafeToWriteFactor = z.object({
+  /** Source of the factor (which pillar) */
+  source: z.string(),
+  /** Score contribution */
+  score: z.number(),
+  /** Description of the factor */
+  description: z.string()
+});
+var AlternativeAction = z.object({
+  /** Tool to use instead */
+  tool: z.string(),
+  /** Description of what to do */
+  description: z.string(),
+  /** Optional parameters for the tool */
+  params: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+  /** Whether the write is allowed */
+  allowed: z.boolean(),
+  /** Action to take */
+  action: SafeToWriteAction,
+  /** Composite risk score (capped at 2.5) */
+  riskScore: z.number(),
+  /** Contributing factors from all pillars */
+  factors: z.array(SafeToWriteFactor),
+  /** Human-readable recommendation */
+  recommendation: z.string(),
+  /** Snapshot hash if auto-created */
+  snapshotHash: z.string().optional(),
+  /** Whether the operation can be retried */
+  retryable: z.boolean(),
+  /** Alternative actions to take instead */
+  alternativeActions: z.array(AlternativeAction)
+});
+z.object({
+  /** Workspace path */
+  workspace: z.string(),
+  /** File path being written */
+  filePath: z.string(),
+  /** Proposed diff */
+  proposedDiff: z.string(),
+  /** AI tool making the change */
+  tool: z.string().optional(),
+  /** Intent of the change */
+  intent: z.string().optional()
+});
+WorkspaceBase.extend({
+  /** Compare against this commit (default HEAD~10) */
+  since: z.string().optional(),
+  /** Force full re-fit */
+  full: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** File path to score */
+  filePath: z.string().min(1)
+});
+WorkspaceBase.extend({
+  /** Quick mode (git + AST only) */
+  quick: z.boolean().optional()
+});
+z.object({});
+z.object({});
+z.object({});
+z.object({});
+z.object({
+  /** Absolute path to workspace root */
+  workspace: z.string().min(1),
+  /** Component type */
+  type: z.enum([
+    "mcp-stdio",
+    "mcp-http"
+  ]),
+  /** Process ID of the component */
+  pid: z.number().int().positive(),
+  /** Restart strategy */
+  restartStrategy: z.enum([
+    "one-for-one",
+    "one-for-all"
+  ]).default("one-for-one")
+});
+z.object({
+  /** Process ID of the component */
+  pid: z.number().int().positive()
+});
+z.object({
+  /** Include verbose details */
+  verbose: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** Entry type */
+  type: MemoryEntryType,
+  /** Entry data */
+  data: z.record(z.unknown()),
+  /** TTL in days (0 = permanent) */
+  ttlDays: z.number().int().min(0).default(0)
+});
+WorkspaceBase.extend({
+  /** Entry IDs to retrieve */
+  ids: z.array(z.string().min(1)).min(1)
+});
+WorkspaceBase.extend({
+  /** Filter by type */
+  type: MemoryEntryType.optional(),
+  /** Keywords to match */
+  keywords: z.array(z.string()).optional(),
+  /** Minimum relevance score (0-1) */
+  minRelevance: z.number().min(0).max(1).default(0.3),
+  /** Maximum results */
+  limit: z.number().int().min(1).max(100).default(50),
+  /** Created after timestamp */
+  since: z.number().optional()
+});
+WorkspaceBase.extend({
+  /** Preview only (don't modify) */
+  dryRun: z.boolean().default(false)
+});
+WorkspaceBase.extend({
+  /** Task summary/description */
+  task: z.string().min(1),
+  /** Files involved in the task */
+  files: z.array(z.string()).optional(),
+  /** Keywords for context matching */
+  keywords: z.array(z.string()).optional(),
+  /** Task intent classification */
+  intent: TaskIntent.optional()
+});
+WorkspaceBase.extend({
+  /** Progress message */
+  message: z.string().min(1),
+  /** Files modified in this progress */
+  filesModified: z.array(z.string()).optional(),
+  /** Partial completion percentage */
+  completionPercent: z.number().min(0).max(100).optional()
+});
+WorkspaceBase.extend({
+  /**
+   * Free-text outcome. Do NOT constrain to enum — snap_end promises free-text paragraphs.
+   */
+  outcome: z.string().min(1).max(2e3),
+  /** Outcome notes */
+  notes: z.string().optional(),
+  /** Learnings captured during task */
+  learnings: z.array(z.string()).optional()
+});
+WorkspaceBase.extend({
+  /** Optional: specific component ID to assess */
+  targetComponentId: z.string().optional(),
+  /** Optional: minimum test coverage threshold (0.0-1.0) */
+  minTestCoverage: z.number().min(0).max(1).optional(),
+  /** Optional: maximum dependency count threshold */
+  maxDependencyCount: z.number().int().positive().optional(),
+  /** Optional: minimum confidence threshold (0.0-1.0) */
+  minConfidence: z.number().min(0).max(1).optional()
+});
+WorkspaceBase.extend({
+  /** Include all candidates in report (not just recommendations) */
+  includeAllCandidates: z.boolean().optional()
+});
+WorkspaceBase.extend({
+  /** Maximum number of recommendations to return */
+  limit: z.number().int().positive().optional(),
+  /** Minimum priority level to include */
+  minPriority: z.enum([
+    "critical",
+    "high",
+    "medium",
+    "low"
+  ]).optional()
+});
+WorkspaceBase.extend({
+  /** Component ID to analyze */
+  componentId: z.string()
+});
+WorkspaceBase.extend({
+  /** Component ID to set gate for */
+  componentId: z.string(),
+  /** Gate to set */
+  gate: z.enum([
+    "migrationPlan",
+    "rollbackStrategy",
+    "ownerAssigned",
+    "stakeholderSignoff"
+  ]),
+  /** Gate status */
+  status: z.enum([
+    "pass",
+    "fail",
+    "warn",
+    "pending"
+  ])
+});
+WorkspaceBase.extend({
+  /** Component ID to get gates for */
+  componentId: z.string()
+});
+WorkspaceBase.extend({
+  /** Filter by actions */
+  actions: z.array(z.enum([
+    "refactor-now",
+    "schedule",
+    "defer",
+    "monitor",
+    "reject"
+  ])).optional(),
+  /** Filter by priorities */
+  priorities: z.array(z.enum([
+    "critical",
+    "high",
+    "medium",
+    "low"
+  ])).optional(),
+  /** Minimum confidence threshold */
+  minConfidence: z.number().min(0).max(1).optional()
+});
+z.object({
+  /** Workspace root path */
+  workspace: z.string().min(1).describe("Workspace root path"),
+  /** Force refresh cache */
+  force: z.boolean().optional().default(false).describe("Force refresh cache")
+});
+z.object({
+  /** Workspace root path */
+  workspace: z.string().min(1).describe("Workspace root path")
+});
+z.object({});
+var AITool = z.enum([
+  "cursor",
+  "claude-code",
+  "copilot",
+  "windsurf",
+  "cline",
+  "universal"
+]);
+var FileAccessRule = z.object({
+  pattern: z.string(),
+  permission: z.enum([
+    "allow",
+    "deny",
+    "caution"
+  ]),
+  source: z.string()
+});
+z.object({
+  // Identity
+  tool: AITool,
+  filePath: z.string(),
+  fileName: z.string(),
+  lastModifiedAt: z.number(),
+  rawContent: z.string(),
+  // Extracted intelligence
+  protectedFiles: z.array(z.string()),
+  focusedDomains: z.array(z.string()),
+  explicitInstructions: z.array(z.string()),
+  toolPermissions: z.array(z.string()),
+  workflowConstraints: z.array(z.string()),
+  fileAccessRules: z.array(FileAccessRule),
+  behaviorRules: z.array(z.string()),
+  // Computed
+  snapbackInstructionsPresent: z.boolean(),
+  snapbackSectionHash: z.string().nullable()
+});
+z.object({
+  id: z.string(),
+  conflictType: z.enum([
+    "file-access",
+    "workflow",
+    "behavior",
+    "scope-overlap",
+    "coverage-gap"
+  ]),
+  tools: z.array(AITool),
+  files: z.array(z.string()),
+  description: z.string(),
+  severity: z.enum([
+    "info",
+    "warn",
+    "error"
+  ]),
+  recommendation: z.string(),
+  detectedAt: z.number()
+});
+z.object({
+  fileName: z.string().optional(),
+  pattern: z.string().optional(),
+  tool: AITool,
+  priority: z.number().default(0)
+});
+z.object({
+  filePath: z.string(),
+  tool: AITool,
+  exists: z.boolean(),
+  lastModified: z.number().nullable()
+});
+var FileRecord = z.object({
+  path: z.string(),
+  category: z.enum([
+    "config",
+    "source",
+    "test",
+    "build",
+    "docs",
+    "other"
+  ]),
+  domain: z.string(),
+  sizeBytes: z.number(),
+  lineCount: z.number(),
+  extension: z.string()
+});
+var ChurnRecord = z.object({
+  filePath: z.string(),
+  changes30d: z.number(),
+  changes90d: z.number(),
+  lastChangedAt: z.number(),
+  uniqueAuthors: z.number()
+});
+var CoChangeCluster = z.object({
+  files: z.array(z.string()),
+  coOccurrenceRate: z.number().min(0).max(1),
+  sampleSize: z.number()
+});
+var FragileFileRecord = z.object({
+  path: z.string(),
+  compositeScore: z.number().min(0).max(100),
+  churnScore: z.number(),
+  blastRadiusScore: z.number(),
+  rollbackScore: z.number(),
+  dependentCount: z.number(),
+  rank: z.number()
+});
+var DomainHealthScore = z.object({
+  domain: z.string(),
+  score: z.number().min(0).max(100),
+  fileCount: z.number(),
+  avgChurn: z.number(),
+  fragileFileCount: z.number(),
+  trend: z.enum([
+    "improving",
+    "stable",
+    "degrading",
+    "unknown"
+  ]),
+  trendComputedAt: z.number().nullable()
+});
+var BaselineNarrative = z.object({
+  domainSummaries: z.record(z.string()),
+  topRisks: z.array(z.object({
+    file: z.string(),
+    reason: z.string(),
+    severity: z.enum([
+      "high",
+      "medium"
+    ])
+  })),
+  agentContextTemplate: z.string()
+});
+var DependencyGraph = z.object({
+  nodes: z.array(z.string()),
+  edges: z.array(z.object({
+    from: z.string(),
+    to: z.string()
+  })),
+  blastRadii: z.record(z.number())
+});
+var BaselineRecord = z.object({
+  workspacePath: z.string(),
+  computedAt: z.number(),
+  version: z.string(),
+  // Tier 1: Structural
+  fileInventory: z.array(FileRecord),
+  domainMap: z.record(z.array(z.string())),
+  totalFiles: z.number(),
+  totalLines: z.number(),
+  // Tier 2: Historical
+  churnRates: z.record(ChurnRecord),
+  coChangeClusters: z.array(CoChangeCluster),
+  rollbackHotspots: z.array(z.string()),
+  // Tier 3: Computed scores
+  fragileFiles: z.array(FragileFileRecord),
+  domainHealthScores: z.array(DomainHealthScore),
+  overallHealthScore: z.number().min(0).max(100),
+  // Dependency graph
+  dependencyGraph: DependencyGraph,
+  // AI config files (imported from ai-config.ts for enhanced types)
+  aiConfigFiles: z.array(z.any()),
+  aiConfigConflicts: z.array(z.any()),
+  // AI synthesis
+  narrative: BaselineNarrative.nullable(),
+  narrativeComputedAt: z.number().nullable()
+});
+var BaselineStatus = z.enum([
+  "ready",
+  "stale",
+  "computing",
+  "not_computed"
+]);
+z.object({
+  status: BaselineStatus,
+  progress: z.number().min(0).max(100),
+  stage: z.string().optional(),
+  error: z.string().optional()
+});
+z.object({
+  workspace: z.string()
+});
+z.object({
+  workspace: z.string()
+});
+z.object({
+  workspace: z.string()
+});
+z.object({
+  workspace: z.string()
+});
+z.object({
+  workspace: z.string(),
+  record: BaselineRecord
+});
+var SessionContextResult = z.object({
+  /** Fragile files within scope of current task */
+  fragileFilesInScope: z.array(z.object({
+    path: z.string(),
+    fragility: z.number(),
+    reason: z.string().optional()
+  })),
+  /** Co-change patterns within scope */
+  coChangePatternsInScope: z.array(z.object({
+    source: z.string(),
+    target: z.string(),
+    confidence: z.number()
+  })),
+  /** Warning about concurrent sessions */
+  concurrentSessionWarning: z.object({
+    sessionId: z.string(),
+    workspacePath: z.string(),
+    touchedFiles: z.array(z.string())
+  }).nullable()
+});
+z.object({
+  /** Session ID (primary identifier) */
+  id: z.string(),
+  /** Task ID (alias for extension compatibility) */
+  taskId: z.string().optional(),
+  /** Workspace path */
+  workspacePath: z.string(),
+  /** Session start timestamp (ISO string) */
+  startedAt: z.string(),
+  /** Current session state */
+  state: z.enum([
+    "active",
+    "ended"
+  ]),
+  /** Session metadata */
+  metadata: z.object({
+    task: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
+    aiToolsDetected: z.array(z.string()).optional(),
+    highestRiskLevel: z.enum([
+      "low",
+      "medium",
+      "high"
+    ]).optional()
+  }),
+  /** Files touched in this session */
+  touchedFiles: z.array(z.string()).optional(),
+  /** Baseline context enrichment */
+  context: SessionContextResult.nullable(),
+  /** Learnings loaded for this session (from enrichment) */
+  learnings: z.array(z.object({
+    id: z.string().optional(),
+    type: z.string().optional(),
+    trigger: z.string(),
+    action: z.string(),
+    relevanceScore: z.number().optional()
+  })).optional()
+});
+z.object({
+  /** Whether the session was ended successfully */
+  success: z.boolean(),
+  /** Session ID that was ended */
+  sessionId: z.string().optional(),
+  /** Coherence score (0-1) */
+  coherenceScore: z.number().min(0).max(1).optional(),
+  /** Session duration in milliseconds */
+  duration: z.number().optional(),
+  /** Number of files modified */
+  filesModified: z.number().optional(),
+  /** Number of learnings captured */
+  learningsCaptured: z.number().optional(),
+  /** Number of snapshots created */
+  snapshotsCreated: z.number().optional()
+});
+var SessionSummarySchema = z.object({
+  sessionId: z.string(),
+  workspace: z.string(),
+  startedAt: z.number(),
+  endedAt: z.number().nullable(),
+  duration: z.number(),
+  filesModified: z.number(),
+  snapshotsCreated: z.number(),
+  restoresTriggered: z.number(),
+  aiEditsDetected: z.number(),
+  protectionLevel: z.enum([
+    "standard",
+    "heightened",
+    "maximum"
+  ])
+});
+var SessionPatternSchema = z.object({
+  type: z.enum([
+    "co-change",
+    "fragile-file",
+    "temporal",
+    "behavioral"
+  ]),
+  description: z.string(),
+  confidence: z.number().min(0).max(1),
+  filesInvolved: z.array(z.string()),
+  promotedToHot: z.boolean()
+});
+var SessionLearningsSchema = z.object({
+  patterns: z.array(SessionPatternSchema),
+  totalNew: z.number(),
+  totalPromoted: z.number(),
+  totalPruned: z.number()
+});
+var PitfallWarningSchema = z.object({
+  trigger: z.string(),
+  risk: z.string(),
+  outcome: z.enum([
+    "heeded",
+    "dismissed",
+    "auto-resolved"
+  ]),
+  filesInvolved: z.array(z.string()),
+  timestamp: z.number()
+});
+var PitfallsAvoidedSchema = z.object({
+  warnings: z.array(PitfallWarningSchema),
+  estimatedTimeSaved: z.number()
+});
+var IntelligenceMetricsSchema = z.object({
+  tokenSavingsEstimate: z.number(),
+  coherenceScore: z.number().min(0).max(100),
+  contextReusageRate: z.number().min(0).max(1),
+  intelligenceEventsTotal: z.number()
+});
+var TimelineEventSchema = z.object({
+  timestamp: z.number(),
+  type: z.enum([
+    "session-start",
+    "session-end",
+    "snapshot-created",
+    "snapshot-restored",
+    "learning-added",
+    "learning-promoted",
+    "warning-fired",
+    "ai-edit-detected",
+    "protection-changed",
+    "fragile-detected",
+    "risk-spike"
+  ]),
+  summary: z.string(),
+  detail: z.string().optional(),
+  filesInvolved: z.array(z.string()).optional(),
+  severity: z.enum([
+    "info",
+    "warning",
+    "critical"
+  ]).optional()
+});
+var CeremonyPayloadSchema = z.object({
+  summary: SessionSummarySchema,
+  learnings: SessionLearningsSchema,
+  pitfalls: PitfallsAvoidedSchema,
+  metrics: IntelligenceMetricsSchema,
+  timeline: z.array(TimelineEventSchema)
+}).superRefine((payload, ctx) => {
+  const sessionStart = payload.summary.startedAt;
+  const sessionEnd = payload.summary.endedAt ?? Date.now();
+  for (const event of payload.timeline) {
+    if (event.timestamp < sessionStart) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Timeline event ${event.type} has timestamp before session start`,
+        path: [
+          "timeline"
+        ]
+      });
+    }
+    if (event.timestamp > sessionEnd) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Timeline event ${event.type} has timestamp after session end`,
+        path: [
+          "timeline"
+        ]
+      });
+    }
+  }
+  const patternCount = payload.learnings.patterns.length;
+  const totalLearnings = payload.learnings.totalNew + payload.learnings.totalPromoted;
+  if (patternCount > 0 && totalLearnings === 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Learnings has patterns but totalNew + totalPromoted is 0",
+      path: [
+        "learnings"
+      ]
+    });
+  }
+  if (payload.metrics.coherenceScore > 100) {
+    ctx.addIssue({
+      code: "custom",
+      message: "coherenceScore must be between 0-100",
+      path: [
+        "metrics",
+        "coherenceScore"
+      ]
+    });
+  }
+  if (payload.summary.filesModified > 10 && payload.metrics.intelligenceEventsTotal < 5) {
+    ctx.addIssue({
+      code: "custom",
+      message: "High file modification count with low intelligence events - possible under-instrumentation",
+      path: [
+        "metrics"
+      ]
+    });
+  }
+});
+var CoherenceScoreSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("numeric"),
+    value: z.number().min(0).max(1)
+  }),
+  z.object({
+    type: z.literal("categorical"),
+    level: z.enum([
+      "high",
+      "medium",
+      "low",
+      "scattered"
+    ]),
+    /** Optional numeric approximation for analytics */
+    approximateValue: z.number().min(0).max(1).optional()
+  })
+]);
+z.object({
+  /** Session ID */
+  sessionId: z.string(),
+  /** Files modified during session */
+  filesModified: z.number(),
+  /** Snapshots created during session */
+  snapshotsCreated: z.number(),
+  /** Learnings captured during session */
+  learningsCaptured: z.number(),
+  /** Pitfalls avoided (proactive warnings heeded) */
+  pitfallsAvoided: z.number().optional(),
+  /** Estimated token savings */
+  tokensSaved: z.number().optional(),
+  /** Coherence score - discriminated union for type-safe handling */
+  coherenceScore: CoherenceScoreSchema.optional(),
+  /** Key insights from the session */
+  insights: z.array(z.string()).optional(),
+  /** Items to carry forward to next session */
+  carryForward: z.array(z.string()).optional(),
+  /** Commit message suggestion */
+  commitMessage: z.string().optional(),
+  /** Full ceremony payload (March 18 spec) */
+  ceremony: CeremonyPayloadSchema.optional(),
+  /** Top learnings from ceremony */
+  topLearnings: z.array(z.object({
+    content: z.string(),
+    captureMethod: z.string(),
+    confidence: z.number()
+  })).optional(),
+  /** Duration in ms */
+  duration: z.number().optional()
+});
+z.object({
+  /** Whether there's an active session */
+  active: z.boolean(),
+  /** Current session ID if active */
+  id: z.string().optional(),
+  /** Task ID if active */
+  taskId: z.string().optional(),
+  /** Task description */
+  task: z.string().optional(),
+  /** Session start timestamp */
+  startedAt: z.string().optional(),
+  /** Files modified count */
+  filesModified: z.number().optional(),
+  /** Snapshot count */
+  snapshotCount: z.number().optional()
+});
+z.object({
+  /** Whether the learning was added successfully */
+  success: z.boolean(),
+  /** Learning ID */
+  id: z.string(),
+  /** Tier assigned (hot, warm, cold) */
+  tier: z.enum([
+    "hot",
+    "warm",
+    "cold"
+  ]),
+  /** Whether this is a new learning vs update */
+  isNew: z.boolean().optional()
+});
+var LearningSearchEntry = z.object({
+  /** Learning ID */
+  id: z.string(),
+  /** Learning type */
+  type: z.string().optional(),
+  /** Trigger condition */
+  trigger: z.string(),
+  /** Action to take */
+  action: z.string(),
+  /** Relevance score (0-1) */
+  relevanceScore: z.number().min(0).max(1).optional(),
+  /** Source of the learning */
+  source: z.string().optional(),
+  /** Tier of the learning */
+  tier: z.enum([
+    "hot",
+    "warm",
+    "cold"
+  ]).optional()
+});
+z.object({
+  /** Search results */
+  results: z.array(LearningSearchEntry),
+  /** Total matching learnings */
+  total: z.number().optional(),
+  /** Query that was searched */
+  query: z.string().optional()
+});
+var FragileFileEntry = z.object({
+  /** File path */
+  path: z.string(),
+  /** Fragility score (0-1) */
+  fragility: z.number().min(0).max(1),
+  /** Reason for fragility */
+  reason: z.string().optional()
+});
+var CoChangeEntry = z.object({
+  /** Source file */
+  source: z.string(),
+  /** Target file (changes when source changes) */
+  target: z.string(),
+  /** Confidence score (0-1) */
+  confidence: z.number().min(0).max(1)
+});
+z.object({
+  /** Elevated, deduplicated learnings (LearningApi format) */
+  learnings: z.array(LearningApiSchema),
+  /** Fragile files in scope */
+  fragileFiles: z.array(FragileFileEntry).optional(),
+  /** Co-change patterns */
+  coChanges: z.array(CoChangeEntry).optional(),
+  /** Files that were queried */
+  files: z.array(z.string()),
+  /** Compiled wire format context (for LLM consumption) */
+  compiled: z.string(),
+  /** Token estimate for compiled context */
+  compiledTokens: z.number(),
+  /** Estimated tokens saved vs natural language */
+  tokensSaved: z.number(),
+  /** Metadata about what's included */
+  metadata: z.object({
+    /** Number of learnings included */
+    learningCount: z.number().optional(),
+    /** Number of fragile files included */
+    fragileFileCount: z.number().optional(),
+    /** Number of co-change patterns included */
+    coChangePatternCount: z.number().optional(),
+    /** Estimated token count */
+    tokenCount: z.number().optional(),
+    /** Whether context was loaded from cache */
+    fromCache: z.boolean().optional()
+  }).optional()
+});
+z.object({
+  /** Composite risk score */
+  score: z.number(),
+  /** Action recommendation */
+  action: z.enum([
+    "PROCEED",
+    "PROCEED_WITH_SNAPSHOT",
+    "WARN",
+    "BLOCK"
+  ]),
+  /** Risk level classification */
+  level: z.enum([
+    "L",
+    "M",
+    "H"
+  ]),
+  /** Contributing factors from all pillars */
+  factors: z.array(z.object({
+    source: z.string(),
+    score: z.number(),
+    description: z.string()
+  })),
+  /** Git risk pillar data */
+  gitRisk: z.object({
+    multiplier: z.number(),
+    uncommittedChanges: z.boolean().optional(),
+    detachedHead: z.boolean().optional(),
+    onMainBranch: z.boolean().optional()
+  }).optional(),
+  /** Fatigue pillar data */
+  fatigue: z.object({
+    level: z.enum([
+      "rested",
+      "normal",
+      "elevated",
+      "fatigued"
+    ]),
+    riskBoost: z.number()
+  }).optional(),
+  /** Rollback warning from pillar 2 */
+  rollbackWarning: z.object({
+    confidence: z.number(),
+    message: z.string(),
+    riskBoost: z.number()
+  }).optional(),
+  /** Poisoning detection from pillar 5 */
+  poisoning: z.object({
+    detected: z.boolean(),
+    files: z.array(z.string()).optional(),
+    riskBoost: z.number().optional()
+  }).optional(),
+  /** Per-file risk breakdown */
+  fileRisks: z.record(z.string(), z.object({
+    fragility: z.number(),
+    rollbackCount: z.number().optional(),
+    reason: z.string().optional()
+  })).optional(),
+  /** Co-change alerts */
+  coChanges: z.array(z.object({
+    source: z.string(),
+    target: z.string(),
+    confidence: z.number()
+  })).optional()
+});
+({
+  "health/ping": z.object({}),
+  // Sync namespace (original local-service style)
+  "sync/status": z.object({}),
+  // DORA metrics namespace (routed through daemon)
+  "dora/record-snapshot": z.object({
+    workspace: z.string(),
+    event: z.object({
+      snapshotId: z.string(),
+      timestamp: z.number(),
+      timeSinceLastChange: z.number(),
+      isRecoveryTriggered: z.boolean(),
+      trigger: z.enum([
+        "manual",
+        "auto",
+        "ai-detected",
+        "recovery"
+      ])
+    })
+  }),
+  "dora/record-recovery": z.object({
+    workspace: z.string(),
+    event: z.object({
+      snapshotId: z.string(),
+      requestTime: z.number(),
+      completionTime: z.number(),
+      success: z.boolean(),
+      filesRestored: z.number(),
+      failureReason: z.string().optional()
+    })
+  }),
+  "dora/get-metrics": z.object({
+    workspace: z.string()
+  }),
+  "dora/get-trends": z.object({
+    workspace: z.string()
+  }),
+  // CTI: Codebase Topology Intelligence namespace (Phase A)
+  "topology/scan": z.object({
+    workspace: z.string(),
+    force: z.boolean().optional().default(false)
+  }),
+  "topology/status": z.object({
+    workspace: z.string()
+  }),
+  "topology/query": z.object({
+    workspace: z.string(),
+    task: z.string().min(1, "task description required for topology query"),
+    max_files: z.number().int().positive().optional().default(15),
+    include_deviations: z.boolean().optional().default(true),
+    include_behavioral: z.boolean().optional().default(true)
+  }),
+  // Provenance namespace (AI attribution via daemon session data)
+  "provenance/query": z.object({
+    workspaceRoot: z.string(),
+    files: z.array(z.string())
+  })
+});
+var __defProp = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+var JsonRpcClientError = class extends Error {
+  static {
+    __name(this, "JsonRpcClientError");
+  }
+  static {
+    __name2(this, "JsonRpcClientError");
+  }
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.name = "JsonRpcClientError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var ConnectionTimeoutError = class extends Error {
+  static {
+    __name(this, "ConnectionTimeoutError");
+  }
+  static {
+    __name2(this, "ConnectionTimeoutError");
+  }
+  constructor(message = "Connection timeout") {
+    super(message);
+    this.name = "ConnectionTimeoutError";
+  }
+};
+var RequestTimeoutError = class extends Error {
+  static {
+    __name(this, "RequestTimeoutError");
+  }
+  static {
+    __name2(this, "RequestTimeoutError");
+  }
+  requestId;
+  constructor(message = "Request timeout", requestId) {
+    super(message), this.requestId = requestId;
+    this.name = "RequestTimeoutError";
+  }
+};
+function getDefaultSocketPath() {
+  const platform2 = os.platform();
+  if (platform2 === "win32") {
+    return "\\\\.\\pipe\\snapback-service";
+  }
+  const homeDir = os.homedir();
+  return path.join(homeDir, ".snapback", "service.sock");
+}
+__name(getDefaultSocketPath, "getDefaultSocketPath");
+__name2(getDefaultSocketPath, "getDefaultSocketPath");
+var IpcConnection = class {
+  static {
+    __name(this, "IpcConnection");
+  }
+  static {
+    __name2(this, "IpcConnection");
+  }
+  socket = null;
+  buffer = "";
+  listeners = {};
+  socketPath;
+  timeout;
+  constructor(options = {}) {
+    this.socketPath = options.socketPath ?? getDefaultSocketPath();
+    this.timeout = options.timeout ?? 5e3;
+  }
+  /**
+  * Connect to the IPC socket
+  *
+  * Fixed race conditions:
+  * - Uses settled flag to prevent timeout firing after successful connect
+  * - Destroys socket on error to prevent orphaned handles
+  * - Cleanup function ensures timeout is always cleared
+  */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const socket = net.createConnection({
+        path: this.socketPath
+      });
+      let timeoutId = null;
+      let settled = false;
+      const cleanup = /* @__PURE__ */ __name2(() => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      }, "cleanup");
+      if (this.timeout > 0) {
+        timeoutId = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          socket.destroy();
+          reject(new ConnectionTimeoutError(`Connection timeout after ${this.timeout}ms`));
+        }, this.timeout);
+        timeoutId.unref();
+      }
+      socket.once("connect", () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        this.socket = socket;
+        this.setupSocketHandlers();
+        resolve();
+      });
+      socket.once("error", (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        socket.destroy();
+        reject(error);
+      });
+    });
+  }
+  /**
+  * Set up socket event handlers
+  *
+  * IMPORTANT: Removes old listeners before adding new ones to prevent
+  * memory leak on reconnect. Without this, each reconnect would add
+  * duplicate handlers that never get garbage collected.
+  */
+  setupSocketHandlers() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.removeAllListeners("data");
+    this.socket.removeAllListeners("close");
+    this.socket.removeAllListeners("error");
+    this.socket.on("data", (chunk) => {
+      this.buffer += chunk.toString("utf8");
+      this.processBuffer();
+    });
+    this.socket.on("close", (hadError) => {
+      const error = hadError ? new Error("Socket closed with error") : void 0;
+      this.emit("close", error);
+      this.socket = null;
+      this.buffer = "";
+    });
+    this.socket.on("error", (error) => {
+      this.emit("error", error);
+      this.buffer = "";
+    });
+  }
+  /**
+  * Process incoming data buffer (newline-delimited JSON)
+  */
+  processBuffer() {
+    let newlineIndex;
+    while ((newlineIndex = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, newlineIndex);
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      if (line.trim().length === 0) {
+        continue;
+      }
+      try {
+        const message = JSON.parse(line);
+        this.emit("message", message);
+      } catch (error) {
+        this.emit("error", new Error(`Failed to parse JSON-RPC message: ${error.message}`));
+      }
+    }
+  }
+  /**
+  * Send a JSON-RPC request
+  *
+  * TOCTOU Fix: Captures socket reference at start to prevent race condition
+  * where socket becomes null between the check and the write.
+  */
+  async send(request) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed) {
+      throw new Error("Socket not connected");
+    }
+    return new Promise((resolve, reject) => {
+      const data = `${JSON.stringify(request)}
+`;
+      socket.write(data, "utf8", (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+  * Close the connection
+  *
+  * Proper cleanup:
+  * - Removes all listeners to prevent memory leaks
+  * - Calls end() for graceful close
+  * - Calls destroy() to ensure immediate cleanup
+  * - Resets buffer to prevent stale data on reconnect
+  */
+  close() {
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.end();
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.buffer = "";
+  }
+  /**
+  * Check if connected
+  */
+  isConnected() {
+    return this.socket !== null && !this.socket.destroyed;
+  }
+  /**
+  * Register event listener
+  */
+  on(event, handler) {
+    this.listeners[event] = handler;
+  }
+  /**
+  * Remove event listener
+  */
+  off(event) {
+    delete this.listeners[event];
+  }
+  /**
+  * Emit event
+  */
+  emit(event, ...args) {
+    const handler = this.listeners[event];
+    if (handler) {
+      handler(...args);
+    }
+  }
+};
+var ReconnectManager = class {
+  static {
+    __name(this, "ReconnectManager");
+  }
+  static {
+    __name2(this, "ReconnectManager");
+  }
+  isReconnecting = false;
+  abortController = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      maxAttempts: options.maxAttempts ?? 5,
+      initialDelay: options.initialDelay ?? 1e3,
+      maxDelay: options.maxDelay ?? 3e4,
+      backoffMultiplier: options.backoffMultiplier ?? 2
+    };
+  }
+  /**
+  * Start reconnection process
+  */
+  async start(connectFn, onAttempt, onFailed) {
+    if (this.isReconnecting) {
+      return;
+    }
+    this.isReconnecting = true;
+    this.abortController = new AbortController();
+    const pRetryOptions = {
+      retries: this.options.maxAttempts,
+      factor: this.options.backoffMultiplier,
+      minTimeout: this.options.initialDelay,
+      maxTimeout: this.options.maxDelay,
+      randomize: false,
+      signal: this.abortController.signal,
+      onFailedAttempt: /* @__PURE__ */ __name2((error) => {
+        if (onAttempt) {
+          onAttempt(error.attemptNumber, this.options.maxAttempts);
+        }
+      }, "onFailedAttempt")
+    };
+    try {
+      await pRetry(connectFn, pRetryOptions);
+      this.reset();
+    } catch (error) {
+      this.reset();
+      if (onFailed) {
+        onFailed();
+      }
+      throw error;
+    }
+  }
+  /**
+  * Stop reconnection process
+  */
+  stop() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.reset();
+  }
+  /**
+  * Reset reconnection state
+  */
+  reset() {
+    this.isReconnecting = false;
+  }
+  /**
+  * Check if currently reconnecting
+  */
+  isActive() {
+    return this.isReconnecting;
+  }
+  /**
+  * Get current attempt number (not tracked in p-retry wrapper)
+  * @deprecated p-retry handles attempt tracking internally
+  */
+  getCurrentAttempt() {
+    return this.isReconnecting ? 1 : 0;
+  }
+};
+function createContextMethods(call) {
+  return {
+    get: /* @__PURE__ */ __name2((params) => call("context/get", params), "get"),
+    validate: /* @__PURE__ */ __name2((params) => call("context/validate", params), "validate"),
+    checkPatterns: /* @__PURE__ */ __name2((params) => call("context/check-patterns", params), "checkPatterns")
+  };
+}
+__name(createContextMethods, "createContextMethods");
+__name2(createContextMethods, "createContextMethods");
+function createDaemonMethods(call) {
+  return {
+    ping: /* @__PURE__ */ __name2(() => call("daemon/ping"), "ping"),
+    status: /* @__PURE__ */ __name2(() => call("daemon/status"), "status"),
+    shutdown: /* @__PURE__ */ __name2(() => call("daemon/shutdown"), "shutdown"),
+    reload: /* @__PURE__ */ __name2(() => call("daemon/reload"), "reload")
+  };
+}
+__name(createDaemonMethods, "createDaemonMethods");
+__name2(createDaemonMethods, "createDaemonMethods");
+function createDetectionMethods(call) {
+  return {
+    check: /* @__PURE__ */ __name2((params) => call("detection/check", params), "check")
+  };
+}
+__name(createDetectionMethods, "createDetectionMethods");
+__name2(createDetectionMethods, "createDetectionMethods");
+function createHealthMethods(call) {
+  return {
+    check: /* @__PURE__ */ __name2((params) => call("health/check", params), "check"),
+    ping: /* @__PURE__ */ __name2(() => call("health/ping"), "ping")
+  };
+}
+__name(createHealthMethods, "createHealthMethods");
+__name2(createHealthMethods, "createHealthMethods");
+function createIntelligenceMethods(call) {
+  return {
+    capture: /* @__PURE__ */ __name2((params) => call("intelligence/capture", params), "capture"),
+    outcome: /* @__PURE__ */ __name2((params) => call("intelligence/outcome", params), "outcome")
+  };
+}
+__name(createIntelligenceMethods, "createIntelligenceMethods");
+__name2(createIntelligenceMethods, "createIntelligenceMethods");
+function createLearningMethods(call) {
+  return {
+    add: /* @__PURE__ */ __name2((params) => call("learning/add", params), "add"),
+    search: /* @__PURE__ */ __name2((params) => call("learning/search", params), "search"),
+    list: /* @__PURE__ */ __name2((params) => call("learning/list", params), "list"),
+    prune: /* @__PURE__ */ __name2((params) => call("learning/prune", params), "prune"),
+    evaluate: /* @__PURE__ */ __name2((params) => call("learning/evaluate", params), "evaluate"),
+    updateSession: /* @__PURE__ */ __name2((params) => call("learning/update-session", params), "updateSession"),
+    gc: /* @__PURE__ */ __name2((params) => call("learning/gc", params), "gc"),
+    seed: /* @__PURE__ */ __name2((params) => call("learning/seed", params), "seed"),
+    consolidate: /* @__PURE__ */ __name2((params) => call("learning/consolidate", params), "consolidate")
+  };
+}
+__name(createLearningMethods, "createLearningMethods");
+__name2(createLearningMethods, "createLearningMethods");
+function createMCPMethods(call) {
+  return {
+    snapshotCreated: /* @__PURE__ */ __name2((params) => call("mcp/snapshot-created", params), "snapshotCreated"),
+    fileModified: /* @__PURE__ */ __name2((params) => call("mcp/file-modified", params), "fileModified")
+  };
+}
+__name(createMCPMethods, "createMCPMethods");
+__name2(createMCPMethods, "createMCPMethods");
+function createMomentumMethods(call) {
+  return {
+    refresh: /* @__PURE__ */ __name2((params) => call("momentum/refresh", params), "refresh"),
+    score: /* @__PURE__ */ __name2((params) => call("momentum/score", params), "score"),
+    sync: /* @__PURE__ */ __name2((params) => call("momentum/sync", params), "sync"),
+    status: /* @__PURE__ */ __name2((params) => call("momentum/status", params), "status")
+  };
+}
+__name(createMomentumMethods, "createMomentumMethods");
+__name2(createMomentumMethods, "createMomentumMethods");
+function createProtectionMethods(call) {
+  return {
+    evaluate: /* @__PURE__ */ __name2((params) => call("protection/evaluate", params), "evaluate"),
+    levels: /* @__PURE__ */ __name2((params) => call("protection/levels", params), "levels"),
+    set: /* @__PURE__ */ __name2((params) => call("protection/set", params), "set"),
+    listDaemon: /* @__PURE__ */ __name2((params) => call("protection/list-daemon", params), "listDaemon")
+  };
+}
+__name(createProtectionMethods, "createProtectionMethods");
+__name2(createProtectionMethods, "createProtectionMethods");
+function createSessionMethods(call) {
+  return {
+    current: /* @__PURE__ */ __name2((params) => call("session/current", params), "current"),
+    start: /* @__PURE__ */ __name2((params) => call("session/start", params), "start"),
+    begin: /* @__PURE__ */ __name2((params) => call("session/begin", params), "begin"),
+    end: /* @__PURE__ */ __name2((params) => call("session/end", params), "end"),
+    list: /* @__PURE__ */ __name2((params) => call("session/list", params), "list"),
+    vitals: /* @__PURE__ */ __name2((params) => call("session/vitals", params), "vitals")
+  };
+}
+__name(createSessionMethods, "createSessionMethods");
+__name2(createSessionMethods, "createSessionMethods");
+function createSnapshotMethods(call) {
+  return {
+    create: /* @__PURE__ */ __name2((params) => call("snapshot/create", params), "create"),
+    get: /* @__PURE__ */ __name2((params) => call("snapshot/get", params), "get"),
+    list: /* @__PURE__ */ __name2((params) => call("snapshot/list", params), "list"),
+    restore: /* @__PURE__ */ __name2((params) => call("snapshot/restore", params), "restore"),
+    diff: /* @__PURE__ */ __name2((params) => call("snapshot/diff", params), "diff"),
+    delete: /* @__PURE__ */ __name2((params) => call("snapshot/delete", params), "delete")
+  };
+}
+__name(createSnapshotMethods, "createSnapshotMethods");
+__name2(createSnapshotMethods, "createSnapshotMethods");
+function createSupervisorMethods(call) {
+  return {
+    register: /* @__PURE__ */ __name2((params) => call("supervisor/register", params), "register"),
+    heartbeat: /* @__PURE__ */ __name2((params) => call("supervisor/heartbeat", params), "heartbeat"),
+    systemHealth: /* @__PURE__ */ __name2((params) => call("system/health", params), "systemHealth")
+  };
+}
+__name(createSupervisorMethods, "createSupervisorMethods");
+__name2(createSupervisorMethods, "createSupervisorMethods");
+function createSyncMethods(call) {
+  return {
+    status: /* @__PURE__ */ __name2((params) => call("sync/status-daemon", params), "status"),
+    force: /* @__PURE__ */ __name2((params) => call("sync/force", params), "force"),
+    stop: /* @__PURE__ */ __name2((params) => call("sync/stop", params), "stop"),
+    start: /* @__PURE__ */ __name2((params) => call("sync/start", params), "start"),
+    queue: /* @__PURE__ */ __name2((params) => call("sync/queue", params), "queue")
+  };
+}
+__name(createSyncMethods, "createSyncMethods");
+__name2(createSyncMethods, "createSyncMethods");
+function createValidationMethods(call) {
+  return {
+    quick: /* @__PURE__ */ __name2((params) => call("validate/quick", params), "quick"),
+    comprehensive: /* @__PURE__ */ __name2((params) => call("validate/comprehensive", params), "comprehensive")
+  };
+}
+__name(createValidationMethods, "createValidationMethods");
+__name2(createValidationMethods, "createValidationMethods");
+function createViolationMethods(call) {
+  return {
+    report: /* @__PURE__ */ __name2((params) => call("violation/report", params), "report"),
+    list: /* @__PURE__ */ __name2((params) => call("violation/list", params), "list")
+  };
+}
+__name(createViolationMethods, "createViolationMethods");
+__name2(createViolationMethods, "createViolationMethods");
+function createWatchMethods(call) {
+  return {
+    subscribe: /* @__PURE__ */ __name2((params) => call("watch/subscribe", params), "subscribe"),
+    unsubscribe: /* @__PURE__ */ __name2((params) => call("watch/unsubscribe", params), "unsubscribe"),
+    fileChanged: /* @__PURE__ */ __name2((params) => call("watch/file-changed", params), "fileChanged")
+  };
+}
+__name(createWatchMethods, "createWatchMethods");
+__name2(createWatchMethods, "createWatchMethods");
+function createWorkspaceMethods(call) {
+  return {
+    analyze: /* @__PURE__ */ __name2((params) => call("workspace/analyze", params), "analyze"),
+    status: /* @__PURE__ */ __name2((params) => call("workspace/status", params), "status")
+  };
+}
+__name(createWorkspaceMethods, "createWorkspaceMethods");
+__name2(createWorkspaceMethods, "createWorkspaceMethods");
+var SnapBackLocalClient = class {
+  static {
+    __name(this, "SnapBackLocalClient");
+  }
+  static {
+    __name2(this, "SnapBackLocalClient");
+  }
+  connection;
+  reconnectManager;
+  state = "disconnected";
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  eventHandlers = {};
+  options;
+  /** Stored params from the last initialize() call — replayed after auto-reconnect */
+  initializeParams = null;
+  // Method namespaces - original
+  health;
+  session;
+  snapshot;
+  protection;
+  detection;
+  // Method namespaces - new domains
+  learning;
+  context;
+  validation;
+  violation;
+  sync;
+  intelligence;
+  momentum;
+  watch;
+  mcp;
+  supervisor;
+  daemon;
+  workspace;
+  constructor(options = {}) {
+    this.options = {
+      socketPath: options.socketPath ?? getDefaultSocketPath(),
+      timeout: options.timeout ?? 3e4,
+      autoReconnect: options.autoReconnect ?? true,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 5,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectDelay: options.maxReconnectDelay ?? 3e4
+    };
+    this.connection = new IpcConnection({
+      socketPath: this.options.socketPath,
+      timeout: 5e3
+    });
+    this.reconnectManager = new ReconnectManager({
+      maxAttempts: this.options.maxReconnectAttempts,
+      initialDelay: this.options.reconnectDelay,
+      maxDelay: this.options.maxReconnectDelay
+    });
+    const callFn = this.call.bind(this);
+    this.health = createHealthMethods(callFn);
+    this.session = createSessionMethods(callFn);
+    this.snapshot = createSnapshotMethods(callFn);
+    this.protection = createProtectionMethods(callFn);
+    this.detection = createDetectionMethods(callFn);
+    this.learning = createLearningMethods(callFn);
+    this.context = createContextMethods(callFn);
+    this.validation = createValidationMethods(callFn);
+    this.violation = createViolationMethods(callFn);
+    this.sync = createSyncMethods(callFn);
+    this.intelligence = createIntelligenceMethods(callFn);
+    this.momentum = createMomentumMethods(callFn);
+    this.watch = createWatchMethods(callFn);
+    this.mcp = createMCPMethods(callFn);
+    this.supervisor = createSupervisorMethods(callFn);
+    this.daemon = createDaemonMethods(callFn);
+    this.workspace = createWorkspaceMethods(callFn);
+    this.setupConnectionHandlers();
+  }
+  /**
+  * Set up IPC connection event handlers
+  */
+  setupConnectionHandlers() {
+    this.connection.on("message", (message) => {
+      if ("method" in message && !("id" in message)) {
+        const notification = message;
+        this.emit("notification", notification.method, notification.params);
+        return;
+      }
+      const response = message;
+      if (response.id === null) {
+        this.emit("error", new Error("Received error response with null id"));
+        return;
+      }
+      const pending = this.pending.get(response.id);
+      if (!pending) {
+        this.emit("error", new Error(`Received response for unknown request ID: ${response.id}`));
+        return;
+      }
+      clearTimeout(pending.timeout);
+      this.pending.delete(response.id);
+      if ("error" in response) {
+        const error = new JsonRpcClientError(response.error.message, response.error.code, response.error.data);
+        pending.reject(error);
+        return;
+      }
+      pending.resolve(response.result);
+    });
+    this.connection.on("close", (error) => {
+      this.setState("disconnected");
+      this.emit("disconnected", error);
+      for (const [, pending] of this.pending.entries()) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error("Connection closed"));
+      }
+      this.pending.clear();
+      if (this.options.autoReconnect && !this.reconnectManager.isActive()) {
+        this.attemptReconnect();
+      }
+    });
+    this.connection.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  /**
+  * Attempt to reconnect
+  */
+  async attemptReconnect() {
+    this.setState("reconnecting");
+    try {
+      await this.reconnectManager.start(async () => {
+        await this.connection.connect();
+        if (this.initializeParams) {
+          await this.initialize(this.initializeParams);
+        }
+        this.setState("connected");
+        this.emit("connected");
+      }, (attempt, maxAttempts) => {
+        this.emit("reconnecting", attempt, maxAttempts);
+      }, () => {
+        this.emit("reconnectFailed");
+      });
+    } catch (error) {
+      this.setState("disconnected");
+      this.emit("error", error);
+    }
+  }
+  /**
+  * Connect to the local service
+  */
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.setState("connecting");
+    try {
+      await this.connection.connect();
+      this.setState("connected");
+      this.emit("connected");
+    } catch (error) {
+      this.setState("disconnected");
+      throw error;
+    }
+  }
+  /**
+  * Close the connection
+  */
+  close() {
+    this.reconnectManager.stop();
+    this.connection.close();
+    this.setState("closed");
+    for (const [, pending] of this.pending.entries()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Client closed"));
+    }
+    this.pending.clear();
+  }
+  /**
+  * Make a JSON-RPC method call
+  */
+  async call(method, params) {
+    if (!this.connection.isConnected()) {
+      throw new Error("Not connected to service");
+    }
+    const id = this.nextId++;
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new RequestTimeoutError(`Request timeout after ${this.options.timeout}ms`, id));
+      }, this.options.timeout);
+      this.pending.set(id, {
+        resolve,
+        reject,
+        timeout
+      });
+      this.connection.send(request).catch((error) => {
+        clearTimeout(timeout);
+        this.pending.delete(id);
+        reject(error);
+      });
+    });
+  }
+  /**
+  * Initialize the client connection
+  *
+  * Must be called before any other method calls.
+  * Params are stored and automatically replayed after auto-reconnect.
+  */
+  async initialize(params) {
+    this.initializeParams = params;
+    return this.call("initialize", params);
+  }
+  /**
+  * Get current connection state
+  */
+  getState() {
+    return this.state;
+  }
+  /**
+  * Check if connected
+  */
+  isConnected() {
+    return this.state === "connected";
+  }
+  /**
+  * Register event listener
+  */
+  on(event, handler) {
+    this.eventHandlers[event] = handler;
+  }
+  /**
+  * Remove event listener
+  */
+  off(event) {
+    delete this.eventHandlers[event];
+  }
+  /**
+  * Set connection state and emit event
+  */
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.emit("stateChange", state);
+    }
+  }
+  /**
+  * Emit event to registered handlers
+  */
+  emit(event, ...args) {
+    const handler = this.eventHandlers[event];
+    if (handler) {
+      handler(...args);
+    }
+  }
+};
+
+// src/daemon/local-service-adapter.ts
+function getServicePidPath() {
+  return join(homedir(), ".snapback", "service.pid");
+}
+__name(getServicePidPath, "getServicePidPath");
+function getServiceSocketPath() {
+  return join(homedir(), ".snapback", "service.sock");
+}
+__name(getServiceSocketPath, "getServiceSocketPath");
+function isServiceRunning() {
+  const pidPath = getServicePidPath();
+  if (!existsSync(pidPath)) {
+    return false;
+  }
+  try {
+    const pid = Number.parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+    if (Number.isNaN(pid)) {
+      return false;
+    }
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isServiceRunning, "isServiceRunning");
+function readServicePid() {
+  const pidPath = getServicePidPath();
+  try {
+    const content = readFileSync(pidPath, "utf-8").trim();
+    const pid = Number.parseInt(content, 10);
+    return Number.isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+__name(readServicePid, "readServicePid");
+function createServiceClient() {
+  return new SnapBackLocalClient({
+    timeout: 3e4,
+    autoReconnect: false
+  });
+}
+__name(createServiceClient, "createServiceClient");
+async function connectServiceClient(client) {
+  await client.connect();
+  await client.initialize({
+    protocolVersion: "1.0.0",
+    clientInfo: {
+      name: "snapback-cli",
+      version: "1.0.0"
+    },
+    capabilities: {
+      notifications: false
+    }
+  });
+}
+__name(connectServiceClient, "connectServiceClient");
+async function pruneLearningsViaDaemon(workspaceRoot, client) {
+  try {
+    const result = await client.call("learning/prune", {
+      workspace: workspaceRoot
+    });
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(pruneLearningsViaDaemon, "pruneLearningsViaDaemon");
+async function gcLearningsViaDaemon(workspaceRoot, client, options) {
+  try {
+    const result = await client.call("learning/gc", {
+      workspace: workspaceRoot,
+      operation: options?.operation ?? "all",
+      dryRun: options?.dryRun ?? true
+    });
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(gcLearningsViaDaemon, "gcLearningsViaDaemon");
+async function listLearningsViaDaemon(workspaceRoot, client, limit) {
+  try {
+    const result = await client.call("learning/list", {
+      workspace: workspaceRoot,
+      limit: limit ?? 50
+    });
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(listLearningsViaDaemon, "listLearningsViaDaemon");
+async function searchLearningsViaDaemon(workspaceRoot, client, keywords, limit) {
+  try {
+    const result = await client.call("learning/search", {
+      workspace: workspaceRoot,
+      keywords,
+      limit: limit ?? 10
+    });
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(searchLearningsViaDaemon, "searchLearningsViaDaemon");
+async function createSessionViaDaemon(client, params) {
+  try {
+    const result = await client.call("session/begin", {
+      name: params?.name,
+      workspacePath: params?.workspacePath,
+      metadata: params?.metadata
+    });
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(createSessionViaDaemon, "createSessionViaDaemon");
+async function endSessionViaDaemon(client, sessionId) {
+  try {
+    await client.call("session/end-daemon", {
+      sessionId
+    });
+    return {
+      success: true
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(endSessionViaDaemon, "endSessionViaDaemon");
+async function getSessionStatusViaDaemon(client, sessionId) {
+  try {
+    const result = await client.call("session/status", {
+      sessionId
+    });
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(getSessionStatusViaDaemon, "getSessionStatusViaDaemon");
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days}d ${hours % 24}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+__name(formatDuration, "formatDuration");
+function formatBytes(bytes) {
+  const units = [
+    "B",
+    "KB",
+    "MB",
+    "GB"
+  ];
+  let unitIndex = 0;
+  let value = bytes;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(1)}${units[unitIndex]}`;
+}
+__name(formatBytes, "formatBytes");
+function getLogPath() {
+  return join(homedir(), ".snapback", "daemon", "daemon.log");
+}
+__name(getLogPath, "getLogPath");
+var DAEMON_GENERATION = 2;
+function getDaemonVersion() {
+  return {
+    generation: DAEMON_GENERATION,
+    version: "2.0.0"
+  };
+}
+__name(getDaemonVersion, "getDaemonVersion");
+
+export { DAEMON_GENERATION, SnapBackLocalClient, connectServiceClient, createServiceClient, createSessionViaDaemon, endSessionViaDaemon, formatBytes, formatDuration, gcLearningsViaDaemon, getDaemonVersion, getLogPath, getServicePidPath, getServiceSocketPath, getSessionStatusViaDaemon, isServiceRunning, listLearningsViaDaemon, pruneLearningsViaDaemon, readServicePid, searchLearningsViaDaemon };