@synergenius/flow-weaver-pack-weaver 0.9.7 → 0.9.9

package/src/bot/conversation-store.ts

@@ -49,8 +49,8 @@ export class ConversationStore {
     fs.mkdirSync(this.baseDir, { recursive: true });
   }
 
-  create(projectDir: string): ConversationRecord {
-    const id = crypto.randomUUID().slice(0, 8);
+  async create(projectDir: string): Promise<ConversationRecord> {
+    const id = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
     const now = Date.now();
     const record: ConversationRecord = {
       id,
@@ -67,10 +67,12 @@ export class ConversationStore {
     const convDir = path.join(this.baseDir, id);
     fs.mkdirSync(convDir, { recursive: true });
 
-    // Add to index (sync write — no lock needed for create, index is new or we're the only writer)
-    const index = this.readIndex();
-    index.unshift(record);
-    this.writeIndexUnsafe(index);
+    // Add to index under file lock for concurrent safety
+    await withFileLock(this.indexPath, () => {
+      const index = this.readIndex();
+      index.unshift(record);
+      this.writeIndexAtomic(index);
+    });
 
     return record;
   }
@@ -89,11 +91,13 @@ export class ConversationStore {
     return index.length > 0 ? index[0] : null;
   }
 
-  delete(id: string): void {
-    // Remove from index (sync — delete doesn't need lock)
-    const index = this.readIndex();
-    const filtered = index.filter(c => c.id !== id);
-    this.writeIndexUnsafe(filtered);
+  async delete(id: string): Promise<void> {
+    // Remove from index under file lock for concurrent safety
+    await withFileLock(this.indexPath, () => {
+      const index = this.readIndex();
+      const filtered = index.filter(c => c.id !== id);
+      this.writeIndexAtomic(filtered);
+    });
 
     // Remove files
     const convDir = path.join(this.baseDir, id);
@@ -108,6 +112,7 @@ export class ConversationStore {
 
     const content = fs.readFileSync(msgPath, 'utf-8');
     const messages: AgentMessage[] = [];
+    let corruptCount = 0;
 
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
@@ -121,33 +126,43 @@ export class ConversationStore {
         if (stored.toolCallId) msg.toolCallId = stored.toolCallId;
         messages.push(msg);
       } catch {
-        // Skip corrupt lines
+        corruptCount++;
       }
     }
 
+    if (corruptCount > 0) {
+      console.warn(`  (Warning: skipped ${corruptCount} corrupt message(s) in conversation ${id})`);
+    }
+
     return messages;
   }
 
-  appendMessages(id: string, messages: AgentMessage[]): void {
-    if (messages.length === 0) return;
+  appendMessages(id: string, messages: AgentMessage[]): boolean {
+    if (messages.length === 0) return true;
 
-    const convDir = path.join(this.baseDir, id);
-    fs.mkdirSync(convDir, { recursive: true });
-    const msgPath = path.join(convDir, 'messages.ndjson');
-
-    const lines = messages.map(m => {
-      const stored: StoredMessage = {
-        role: m.role,
-        content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-        timestamp: Date.now(),
-        tokens: Math.ceil((typeof m.content === 'string' ? m.content.length : JSON.stringify(m.content).length) / CHARS_PER_TOKEN),
-      };
-      if (m.toolCalls) stored.toolCalls = m.toolCalls;
-      if (m.toolCallId) stored.toolCallId = m.toolCallId;
-      return JSON.stringify(stored);
-    });
+    try {
+      const convDir = path.join(this.baseDir, id);
+      fs.mkdirSync(convDir, { recursive: true });
+      const msgPath = path.join(convDir, 'messages.ndjson');
+
+      const lines = messages.map(m => {
+        const stored: StoredMessage = {
+          role: m.role,
+          content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+          timestamp: Date.now(),
+          tokens: Math.ceil((typeof m.content === 'string' ? m.content.length : JSON.stringify(m.content).length) / CHARS_PER_TOKEN),
+        };
+        if (m.toolCalls) stored.toolCalls = m.toolCalls;
+        if (m.toolCallId) stored.toolCallId = m.toolCallId;
+        return JSON.stringify(stored);
+      });
 
-    fs.appendFileSync(msgPath, lines.join('\n') + '\n');
+      fs.appendFileSync(msgPath, lines.join('\n') + '\n');
+      return true;
+    } catch (err) {
+      process.stderr.write(`[weaver] failed to persist ${messages.length} message(s) for conversation ${id}: ${err instanceof Error ? err.message : err}\n`);
+      return false;
+    }
   }
 
   async updateAfterTurn(id: string, newMessages: AgentMessage[], tokensUsed: number): Promise<void> {
@@ -167,12 +182,16 @@ export class ConversationStore {
         index.unshift(record);
       }
 
-      // Cap index size
+      // Cap index size — clean up evicted conversation directories
       if (index.length > MAX_INDEX_SIZE) {
-        index.splice(MAX_INDEX_SIZE);
+        const evicted = index.splice(MAX_INDEX_SIZE);
+        for (const conv of evicted) {
+          const convDir = path.join(this.baseDir, conv.id);
+          try { fs.rmSync(convDir, { recursive: true, force: true }); } catch { /* best effort */ }
+        }
       }
 
-      this.writeIndexUnsafe(index);
+      this.writeIndexAtomic(index);
     });
   }
 
@@ -214,7 +233,7 @@ export class ConversationStore {
       const record = index.find(c => c.id === id);
       if (record) {
         record.title = title.slice(0, 80).replace(/\n/g, ' ').trim();
-        this.writeIndexUnsafe(index);
+        this.writeIndexAtomic(index);
       }
     });
   }
@@ -225,7 +244,7 @@ export class ConversationStore {
       const record = index.find(c => c.id === id);
       if (record && !record.botIds.includes(botId)) {
         record.botIds.push(botId);
-        this.writeIndexUnsafe(index);
+        this.writeIndexAtomic(index);
       }
     });
   }
@@ -238,17 +257,43 @@ export class ConversationStore {
       return JSON.parse(fs.readFileSync(this.indexPath, 'utf-8'));
     } catch (err) {
       if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] conversation index parse failed: ${err}\n`);
-      return [];
+      // Try backup
+      return this.readBackupIndex();
     }
   }
 
-  private async writeIndex(index: ConversationRecord[]): Promise<void> {
-    await withFileLock(this.indexPath, () => {
-      this.writeIndexUnsafe(index);
-    });
+  private readBackupIndex(): ConversationRecord[] {
+    const backupPath = this.indexPath + '.bak';
+    if (!fs.existsSync(backupPath)) return [];
+    try {
+      const data = JSON.parse(fs.readFileSync(backupPath, 'utf-8'));
+      // Restore backup to main index
+      try { this.writeIndexAtomic(data); } catch { /* best effort */ }
+      return data;
+    } catch (err) {
+      if (process.env.WEAVER_VERBOSE) process.stderr.write(`[weaver] conversation backup parse failed: ${err}\n`);
+      return [];
+    }
   }
 
-  private writeIndexUnsafe(index: ConversationRecord[]): void {
-    fs.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+  /** Atomic write: serialize to temp file, backup existing, rename into place. */
+  private writeIndexAtomic(index: ConversationRecord[]): void {
+    const tmpPath = this.indexPath + `.tmp.${process.pid}`;
+    const backupPath = this.indexPath + '.bak';
+    const content = JSON.stringify(index, null, 2);
+
+    // Write to temp file first
+    fs.writeFileSync(tmpPath, content);
+
+    // Backup current index if it exists
+    if (fs.existsSync(this.indexPath)) {
+      try { fs.copyFileSync(this.indexPath, backupPath); } catch { /* best effort */ }
+    }
+
+    // Atomic rename
+    fs.renameSync(tmpPath, this.indexPath);
+
+    // Always update backup after successful write
+    try { fs.copyFileSync(this.indexPath, backupPath); } catch { /* best effort */ }
   }
 }

package/src/bot/cost-store.ts

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import type { CostRecord, CostSummary } from './types.js';
 import { parseNdjson } from './safe-json.js';
+import { withFileLock } from './file-lock.js';
 
 const MAX_ENTRIES = 10_000;
 const CAP_CHECK_INTERVAL = 100;
@@ -11,6 +12,7 @@ export class CostStore {
   private readonly dir: string;
   private readonly filePath: string;
   private appendCount = 0;
+  private pendingCap: Promise<void> | null = null;
 
   constructor(dir?: string) {
     this.dir = dir ?? process.env.WEAVER_DATA_DIR ?? path.join(os.homedir(), '.weaver');
@@ -22,10 +24,15 @@ export class CostStore {
     fs.appendFileSync(this.filePath, JSON.stringify(record) + '\n', 'utf-8');
     this.appendCount++;
     if (this.appendCount % CAP_CHECK_INTERVAL === 0) {
-      this.enforceCap();
+      this.pendingCap = this.enforceCap().catch(() => {}).finally(() => { this.pendingCap = null; });
     }
   }
 
+  /** Wait for any in-flight cap enforcement to finish (used in tests). */
+  async waitForPendingCap(): Promise<void> {
+    if (this.pendingCap) await this.pendingCap;
+  }
+
   query(filters?: { since?: number; model?: string }): CostRecord[] {
     if (!fs.existsSync(this.filePath)) return [];
 
@@ -75,17 +82,21 @@ export class CostStore {
     return summary;
   }
 
-  private enforceCap(): void {
+  private async enforceCap(): Promise<void> {
     if (!fs.existsSync(this.filePath)) return;
 
-    const content = fs.readFileSync(this.filePath, 'utf-8');
-    const lines = content.split('\n').filter((l) => l.trim().length > 0);
+    await withFileLock(this.filePath, () => {
+      if (!fs.existsSync(this.filePath)) return;
+
+      const content = fs.readFileSync(this.filePath, 'utf-8');
+      const lines = content.split('\n').filter((l) => l.trim().length > 0);
 
-    if (lines.length <= MAX_ENTRIES) return;
+      if (lines.length <= MAX_ENTRIES) return;
 
-    const kept = lines.slice(lines.length - MAX_ENTRIES);
-    const tmpPath = this.filePath + '.tmp';
-    fs.writeFileSync(tmpPath, kept.join('\n') + '\n', 'utf-8');
-    fs.renameSync(tmpPath, this.filePath);
+      const kept = lines.slice(lines.length - MAX_ENTRIES);
+      const tmpPath = this.filePath + '.tmp';
+      fs.writeFileSync(tmpPath, kept.join('\n') + '\n', 'utf-8');
+      fs.renameSync(tmpPath, this.filePath);
+    });
   }
 }

package/src/bot/cost-tracker.ts

@@ -33,7 +33,19 @@ export class CostTracker {
   }
 
   static estimateCost(model: string, usage: TokenUsage): number {
-    const pricing = MODEL_PRICING[model];
+    let pricing = MODEL_PRICING[model];
+    if (!pricing) {
+      // Fallback: prefix match for model variants with date suffixes
+      // e.g., 'claude-sonnet-4-6-20260301' matches 'claude-sonnet-4-6'
+      // Use longest matching prefix to avoid ambiguity.
+      let bestKey = '';
+      for (const key of Object.keys(MODEL_PRICING)) {
+        if (model.startsWith(key) && key.length > bestKey.length) {
+          bestKey = key;
+        }
+      }
+      if (bestKey) pricing = MODEL_PRICING[bestKey];
+    }
     if (!pricing) return 0;
 
     return (

package/src/bot/cron-parser.ts

@@ -38,6 +38,7 @@ function parseField(token: string, min: number, max: number): CronField {
         end = max;
       } else if (rangeStr!.includes('-')) {
         [start, end] = rangeStr!.split('-').map(Number) as [number, number];
+        if (isNaN(start) || isNaN(end)) throw new Error(`Invalid range in "${part}"`);
       } else {
         start = parseInt(rangeStr!, 10);
         end = max;

package/src/bot/cron-scheduler.ts

@@ -15,6 +15,7 @@ export class CronScheduler extends EventEmitter {
   }
 
   start(): void {
+    this.stop();
     this.stopped = false;
     this.scheduleNext();
   }

package/src/bot/device-connection.ts

@@ -0,0 +1,102 @@
+/**
+ * Device Connection — Weaver-specific handlers for the core DeviceConnection.
+ *
+ * The transport (WebSocket, heartbeat, reconnect) lives in @synergenius/flow-weaver/agent.
+ * This module registers handlers for file operations, health, insights, improve status.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+// Re-export the core DeviceConnection for convenience
+export { DeviceConnection } from '@synergenius/flow-weaver/agent';
+export type { DeviceConnectionOptions, DeviceInfo, DeviceEvent } from '@synergenius/flow-weaver/agent';
+
+/**
+ * Register weaver-specific request handlers on a DeviceConnection.
+ */
+export function registerWeaverHandlers(
+  conn: import('@synergenius/flow-weaver/agent').DeviceConnection,
+  projectDir: string,
+): void {
+  // Advertise weaver capabilities
+  conn.addCapability('file_read');
+  conn.addCapability('file_list');
+  conn.addCapability('health');
+  conn.addCapability('insights');
+  conn.addCapability('improve');
+  conn.addCapability('assistant');
+
+  // File read
+  conn.onRequest('file:read', async (_method, params) => {
+    const filePath = path.resolve(projectDir, String(params.path ?? ''));
+    if (!filePath.startsWith(projectDir)) throw new Error('Path outside project directory');
+    if (!fs.existsSync(filePath)) throw new Error('File not found');
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory()) {
+      return { type: 'directory', entries: fs.readdirSync(filePath) };
+    }
+    if (stat.size > 1_048_576) throw new Error('File too large (>1MB)');
+    return { type: 'file', content: fs.readFileSync(filePath, 'utf-8') };
+  });
+
+  // File list
+  conn.onRequest('file:list', async (_method, params) => {
+    const dirPath = path.resolve(projectDir, String(params.path ?? '.'));
+    if (!dirPath.startsWith(projectDir)) throw new Error('Path outside project directory');
+    if (!fs.existsSync(dirPath)) throw new Error('Directory not found');
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    return entries
+      .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules' && e.name !== 'dist')
+      .map(e => ({
+        name: e.name,
+        type: e.isDirectory() ? 'directory' : 'file',
+        path: path.relative(projectDir, path.join(dirPath, e.name)),
+      }));
+  });
+
+  // Project health
+  conn.onRequest('health', async () => {
+    try {
+      const { ProjectModelStore } = await import('./project-model.js');
+      const pms = new ProjectModelStore(projectDir);
+      const model = await pms.getOrBuild();
+      return { health: model.health, trust: model.trust, cost: model.cost, bots: model.bots };
+    } catch {
+      return { error: 'Project model not available' };
+    }
+  });
+
+  // Insights
+  conn.onRequest('insights', async () => {
+    try {
+      const { ProjectModelStore } = await import('./project-model.js');
+      const { InsightEngine } = await import('./insight-engine.js');
+      const model = await new ProjectModelStore(projectDir).getOrBuild();
+      return new InsightEngine().analyze(model);
+    } catch {
+      return [];
+    }
+  });
+
+  // Improve status
+  conn.onRequest('improve:status', async () => {
+    try {
+      const summaryDir = path.join(os.homedir(), '.weaver', 'improve');
+      if (!fs.existsSync(summaryDir)) return { running: false, lastRun: null };
+      const files = fs.readdirSync(summaryDir).filter(f => f.endsWith('.json')).sort().reverse();
+      if (files.length === 0) return { running: false, lastRun: null };
+      const latest = JSON.parse(fs.readFileSync(path.join(summaryDir, files[0]!), 'utf-8'));
+      let running = false;
+      try {
+        const { execFileSync } = await import('node:child_process');
+        const worktrees = execFileSync('git', ['worktree', 'list'], { encoding: 'utf-8', cwd: projectDir });
+        running = worktrees.includes('weaver-improve');
+      } catch { /* git not available */ }
+      return { running, lastRun: latest };
+    } catch {
+      return { running: false, lastRun: null };
+    }
+  });
+}

package/src/bot/error-classifier.ts

@@ -16,7 +16,12 @@ const PATTERNS: Array<{ pattern: RegExp; isTransient: boolean; guidance: string;
   { pattern: /EPIPE|ENOTFOUND/i, isTransient: true, guidance: 'Network error.', category: 'network' },
   { pattern: /401|authentication|invalid.*key/i, isTransient: false, guidance: 'Authentication failed. Check API key or run "weaver init".', category: 'auth' },
   { pattern: /403|forbidden/i, isTransient: false, guidance: 'Access denied. API key may lack permissions.', category: 'auth' },
+  { pattern: /400|bad request/i, isTransient: false, guidance: 'Bad request (400). Check input payload or parameters.', category: 'parse' },
+  { pattern: /404|not found/i, isTransient: false, guidance: 'Resource not found (404). Check URL or resource ID.', category: 'network' },
+  { pattern: /408|request timeout/i, isTransient: true, guidance: 'Request timeout (408). Will auto-retry.', category: 'timeout' },
+  { pattern: /422|unprocessable/i, isTransient: false, guidance: 'Unprocessable entity (422). Input is well-formed but semantically invalid.', category: 'parse' },
   { pattern: /429|rate.?limit|too many requests/i, isTransient: true, guidance: 'Rate limited. Wait a few minutes or reduce --parallel.', category: 'rate-limit' },
+  { pattern: /500|internal server error/i, isTransient: true, guidance: 'Internal server error (500). Will auto-retry.', category: 'network' },
   { pattern: /502|bad gateway/i, isTransient: true, guidance: 'Server error (502). Will auto-retry.', category: 'network' },
   { pattern: /503|service unavailable|overloaded/i, isTransient: true, guidance: 'Service overloaded. Will auto-retry.', category: 'network' },
   { pattern: /504|gateway timeout/i, isTransient: true, guidance: 'Gateway timeout (504). Will auto-retry.', category: 'timeout' },

package/src/bot/file-lock.ts

@@ -58,8 +58,18 @@ export async function withFileLock<T>(
           continue;
         }
       } catch {
-        // Can't read lock info, try to clean up
-        try { fs.rmSync(lockDir, { recursive: true }); } catch { /* ignore */ }
+        // Can't read lock info — lock holder may still be writing it.
+        // Only clean up if the lock directory itself is stale.
+        try {
+          const stat = fs.statSync(lockDir);
+          if (Date.now() - stat.mtimeMs > staleMs) {
+            try { fs.rmSync(lockDir, { recursive: true }); } catch { /* ignore */ }
+          }
+        } catch { /* lockDir gone, will retry */ }
+
+        if (attempt < retries) {
+          await new Promise(r => setTimeout(r, retryWait));
+        }
         continue;
       }
 

package/src/bot/file-watcher.ts

@@ -25,6 +25,7 @@ export class FileWatcher extends EventEmitter {
   }
 
   start(): void {
+    this.stop();
     this.stopped = false;
     this.lastMtime = this.getMtime();
     this.attachFsWatch();

package/src/bot/genesis-prompt-context.ts

@@ -133,3 +133,64 @@ export async function getWorkflowDescription(filePath: string): Promise<string>
     return '(workflow description unavailable)';
   }
 }
+
+/**
+ * Builds intelligence context from the project model for Genesis proposals.
+ * Includes health scores, insights, operation effectiveness, and user preferences.
+ */
+export async function getGenesisInsightContext(projectDir: string): Promise<string> {
+  try {
+    const { ProjectModelStore } = await import('./project-model.js');
+    const pms = new ProjectModelStore(projectDir);
+    const model = await pms.getOrBuild();
+
+    const lines: string[] = ['## Project Intelligence', ''];
+    lines.push(`Health: ${model.health.overall}/100`);
+    lines.push(`Trust Phase: ${model.trust.phase}`);
+    lines.push('');
+
+    // Top failure patterns as genesis candidates
+    const candidates = model.failurePatterns
+      .filter(f => !f.transient && f.occurrences >= 3)
+      .slice(0, 3);
+    if (candidates.length > 0) {
+      lines.push('### Top Issues (Genesis Candidates)');
+      for (const c of candidates) {
+        lines.push(`- [${c.occurrences}x] ${c.pattern} (${c.category})`);
+      }
+      lines.push('');
+    }
+
+    // Operation effectiveness
+    const ops = Object.entries(model.evolution.byOperationType);
+    if (ops.length > 0) {
+      lines.push('### Operation Effectiveness');
+      for (const [op, stats] of ops) {
+        lines.push(`- ${op}: ${Math.round(stats.effectiveness * 100)}% effective (${stats.applied}/${stats.proposed})`);
+      }
+      lines.push('');
+    }
+
+    // User preferences
+    if (model.userPreferences.autoApprovePatterns.length > 0) {
+      lines.push(`Auto-approve patterns: ${model.userPreferences.autoApprovePatterns.join(', ')}`);
+    }
+    if (model.userPreferences.neverApprovePatterns.length > 0) {
+      lines.push(`Never-approve patterns: ${model.userPreferences.neverApprovePatterns.join(', ')}`);
+    }
+
+    // Bot performance
+    const weakBots = model.bots.filter(b => b.successRate < 0.5 && b.totalTasksRun > 3);
+    if (weakBots.length > 0) {
+      lines.push('');
+      lines.push('### Underperforming Bots');
+      for (const b of weakBots) {
+        lines.push(`- ${b.name}: ${Math.round(b.successRate * 100)}% success (${b.totalTasksRun} tasks)`);
+      }
+    }
+
+    return lines.join('\n');
+  } catch {
+    return '';
+  }
+}

package/src/bot/genesis-store.ts

@@ -33,9 +33,13 @@ export class GenesisStore {
       fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
       return { ...DEFAULT_CONFIG };
     }
-    const content = fs.readFileSync(configPath, 'utf-8');
-    const raw = jsonParseOr(content, {} as Record<string, unknown>, 'genesis config');
-    return { ...DEFAULT_CONFIG, ...raw };
+    try {
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const raw = jsonParseOr(content, {} as Record<string, unknown>, 'genesis config');
+      return { ...DEFAULT_CONFIG, ...raw };
+    } catch {
+      return { ...DEFAULT_CONFIG };
+    }
   }
 
   saveConfig(config: GenesisConfig): void {
@@ -45,18 +49,26 @@ export class GenesisStore {
 
   loadHistory(): GenesisHistory {
     const historyPath = path.join(this.genesisDir, 'history.json');
+    const fallback: GenesisHistory = { configHash: '', cycles: [] };
     if (!fs.existsSync(historyPath)) {
-      return { configHash: '', cycles: [] };
+      return fallback;
+    }
+    try {
+      const content = fs.readFileSync(historyPath, 'utf-8');
+      const parsed = jsonParseOr<GenesisHistory>(content, null as unknown as GenesisHistory, 'genesis history');
+      if (parsed && Array.isArray(parsed.cycles)) return parsed;
+      // Primary file corrupt — try backup
+      return this.readJsonBackup<GenesisHistory>(historyPath, fallback);
+    } catch {
+      return this.readJsonBackup<GenesisHistory>(historyPath, fallback);
     }
-    const content = fs.readFileSync(historyPath, 'utf-8');
-    return jsonParseOr<GenesisHistory>(content, { configHash: '', cycles: [] }, 'genesis history');
   }
 
   appendCycle(cycle: GenesisCycleRecord): void {
     const history = this.loadHistory();
     history.cycles.push(cycle);
     this.ensureDirs();
-    fs.writeFileSync(path.join(this.genesisDir, 'history.json'), JSON.stringify(history, null, 2), 'utf-8');
+    this.writeJsonAtomic(path.join(this.genesisDir, 'history.json'), history);
   }
 
   saveSnapshot(cycleId: string, content: string): string {
@@ -82,8 +94,12 @@ export class GenesisStore {
   getLastFingerprint(): GenesisFingerprint | null {
     const fpPath = path.join(this.genesisDir, 'fingerprint.json');
     if (!fs.existsSync(fpPath)) return null;
-    const content = fs.readFileSync(fpPath, 'utf-8');
-    return jsonParseOr<GenesisFingerprint | null>(content, null, 'genesis fingerprint');
+    try {
+      const content = fs.readFileSync(fpPath, 'utf-8');
+      return jsonParseOr<GenesisFingerprint | null>(content, null, 'genesis fingerprint');
+    } catch {
+      return null;
+    }
   }
 
   getRecentOutcomes(count: number): string[] {
@@ -142,19 +158,21 @@ export class GenesisStore {
   loadSelfHistory(): GenesisSelfMigrationRecord[] {
     const histPath = path.join(this.genesisDir, 'self-history.json');
     if (!fs.existsSync(histPath)) return [];
-    const content = fs.readFileSync(histPath, 'utf-8');
-    return jsonParseOr<GenesisSelfMigrationRecord[]>(content, [], 'genesis self-history');
+    try {
+      const content = fs.readFileSync(histPath, 'utf-8');
+      const parsed = jsonParseOr<GenesisSelfMigrationRecord[]>(content, null as unknown as GenesisSelfMigrationRecord[], 'genesis self-history');
+      if (Array.isArray(parsed)) return parsed;
+      return this.readJsonBackup<GenesisSelfMigrationRecord[]>(histPath, []);
+    } catch {
+      return this.readJsonBackup<GenesisSelfMigrationRecord[]>(histPath, []);
+    }
   }
 
   appendSelfMigration(record: GenesisSelfMigrationRecord): void {
     const records = this.loadSelfHistory();
     records.push(record);
     this.ensureDirs();
-    fs.writeFileSync(
-      path.join(this.genesisDir, 'self-history.json'),
-      JSON.stringify(records, null, 2),
-      'utf-8',
-    );
+    this.writeJsonAtomic(path.join(this.genesisDir, 'self-history.json'), records);
   }
 
   getSelfFailureCount(): number {
@@ -167,6 +185,40 @@ export class GenesisStore {
     return count;
   }
 
+  /** Atomic write: serialize to temp file, backup existing, rename into place. */
+  private writeJsonAtomic(filePath: string, data: unknown): void {
+    const tmpPath = filePath + `.tmp.${process.pid}`;
+    const backupPath = filePath + '.bak';
+    const content = JSON.stringify(data, null, 2);
+
+    fs.writeFileSync(tmpPath, content, 'utf-8');
+
+    // Backup current file before overwriting
+    if (fs.existsSync(filePath)) {
+      try { fs.copyFileSync(filePath, backupPath); } catch { /* best effort */ }
+    }
+
+    fs.renameSync(tmpPath, filePath);
+
+    // Update backup after successful write
+    try { fs.copyFileSync(filePath, backupPath); } catch { /* best effort */ }
+  }
+
+  /** Read from .bak file when primary is corrupt. */
+  private readJsonBackup<T>(filePath: string, fallback: T): T {
+    const backupPath = filePath + '.bak';
+    if (!fs.existsSync(backupPath)) return fallback;
+    try {
+      const content = fs.readFileSync(backupPath, 'utf-8');
+      const data = JSON.parse(content) as T;
+      // Restore backup to primary
+      try { this.writeJsonAtomic(filePath, data); } catch { /* best effort */ }
+      return data;
+    } catch {
+      return fallback;
+    }
+  }
+
   static hashFile(filePath: string): string {
     const content = fs.readFileSync(filePath);
     return crypto.createHash('sha256').update(content).digest('hex');