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

package/src/bot/slash-commands.ts

@@ -21,10 +21,40 @@ export interface SlashCommand {
 export const SLASH_COMMANDS: SlashCommand[] = [
   {
     name: '/help',
-    description: 'Show available commands',
+    description: 'Show available commands and capabilities',
     handler: async (ctx) => {
-      ctx.out('\n  Available commands:\n');
+      // Check if this is a new project (no workflows)
+      let hasWorkflows = false;
+      try {
+        const fsMod = await import('node:fs');
+        const pathMod = await import('node:path');
+        const srcDir = pathMod.join(ctx.projectDir, 'src');
+        if (fsMod.existsSync(srcDir)) {
+          const files = fsMod.readdirSync(srcDir, { recursive: true }) as string[];
+          hasWorkflows = files.some(f => f.endsWith('.ts'));
+        }
+      } catch { /* scan failed */ }
+
+      ctx.out(`\n  ${c.bold('Weaver Assistant')}\n`);
+      ctx.out(`  Tell me what to build, fix, or explore. I use tools to do the work.\n\n`);
+
+      if (!hasWorkflows) {
+        ctx.out(`  ${c.bold('Getting Started:')}\n`);
+        ctx.out(`    ${c.cyan('1.')} "create a hello world workflow"\n`);
+        ctx.out(`    ${c.cyan('2.')} "create a data pipeline that reads an API and transforms the result"\n`);
+        ctx.out(`    ${c.cyan('3.')} "what is Flow Weaver and how does it work?"\n\n`);
+      }
+
+      ctx.out(`  ${c.bold('Capabilities:')}\n`);
+      ctx.out(`    Workflows    Create, validate, compile, diagram, describe, and modify\n`);
+      ctx.out(`    Bots         Spawn background workers that execute tasks autonomously\n`);
+      ctx.out(`    Code         Read, write, and patch files in your project\n`);
+      ctx.out(`    Health       Track project health, insights, cost, and trust level\n`);
+      ctx.out(`    Evolution    Propose and apply genesis improvements to bot workflows\n`);
+      ctx.out(`    Shell        Run commands, check TypeScript, run tests\n\n`);
+      ctx.out(`  ${c.bold('Commands:')}\n`);
       for (const cmd of SLASH_COMMANDS) {
+        if (cmd.name === '/help') continue;
         ctx.out(`    ${c.cyan(cmd.name.padEnd(12))} ${c.dim(cmd.description)}\n`);
       }
       ctx.out('\n');
@@ -36,7 +66,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
     handler: async (ctx) => {
       const bots = await ctx.executor('bot_list', {});
       const summary = await ctx.executor('conversation_summary', {});
-      ctx.out(`\n  ${bots.result}\n  ${summary.result}\n\n`);
+      ctx.out(`\n  Bots:\n  ${bots.result}\n\n  Conversation:\n  ${summary.result}\n\n`);
     },
   },
   {
@@ -53,6 +83,7 @@ export const SLASH_COMMANDS: SlashCommand[] = [
     handler: async (ctx) => {
       process.stderr.write('\x1b[2J\x1b[H');
       ctx.onClear?.();
+      ctx.out(`  ${c.dim('Screen cleared. New conversation started.')}\n\n`);
     },
   },
   {
@@ -85,6 +116,22 @@ export const SLASH_COMMANDS: SlashCommand[] = [
       ctx.onVerbose?.();
     },
   },
+  {
+    name: '/insights',
+    description: 'Show project insights and recommendations',
+    handler: async (ctx: SlashContext) => {
+      const result = await ctx.executor('project_insights', {});
+      ctx.out(`\n${result.result}\n\n`);
+    },
+  },
+  {
+    name: '/health',
+    description: 'Show project health summary',
+    handler: async (ctx: SlashContext) => {
+      const result = await ctx.executor('project_health', {});
+      ctx.out(`\n${result.result}\n\n`);
+    },
+  },
   {
     name: '/history',
     description: 'Show conversation history summary',
@@ -93,6 +140,67 @@ export const SLASH_COMMANDS: SlashCommand[] = [
       ctx.out(`\n  ${result.result}\n\n`);
     },
   },
+  {
+    name: '/improve',
+    description: 'Show status of the current or last improve run',
+    handler: async (ctx) => {
+      try {
+        const fsMod = await import('node:fs');
+        const pathMod = await import('node:path');
+        const osMod = await import('node:os');
+        const summaryDir = pathMod.join(osMod.homedir(), '.weaver', 'improve');
+        if (!fsMod.existsSync(summaryDir)) {
+          ctx.out(`\n  No improve runs found. Start one with: weaver improve\n\n`);
+          return;
+        }
+        const files = fsMod.readdirSync(summaryDir).filter((f: string) => f.endsWith('.json')).sort().reverse();
+        if (files.length === 0) {
+          ctx.out(`\n  No improve runs found.\n\n`);
+          return;
+        }
+        const latest = JSON.parse(fsMod.readFileSync(pathMod.join(summaryDir, files[0]!), 'utf-8'));
+        const duration = Math.round((new Date(latest.finishedAt).getTime() - new Date(latest.startedAt).getTime()) / 1000);
+
+        ctx.out(`\n  Improve Run (${latest.reason})\n`);
+        ctx.out(`  Branch: ${latest.branch}\n`);
+        ctx.out(`  Duration: ${duration}s\n`);
+        ctx.out(`  Successes: ${latest.successes}  Failures: ${latest.failures}  Skips: ${latest.skips}  Blocked: ${latest.blocked}\n\n`);
+        for (const cy of latest.cycles) {
+          const icon = cy.outcome === 'success' ? '✓' : cy.outcome === 'failure' ? '✗' : '○';
+          ctx.out(`  ${icon} Cycle ${cy.cycle}: [${cy.outcome}] ${cy.description.slice(0, 70)}\n`);
+        }
+
+        // Check if a run is currently active
+        try {
+          const { execFileSync } = await import('node:child_process');
+          const worktrees = execFileSync('git', ['worktree', 'list'], { encoding: 'utf-8', cwd: ctx.projectDir });
+          if (worktrees.includes('weaver-improve')) {
+            ctx.out(`\n  LIVE: improve worktree active — run is in progress\n`);
+          }
+        } catch { /* git not available */ }
+
+        ctx.out('\n');
+      } catch (err) {
+        ctx.out(`\n  Error reading improve status: ${err instanceof Error ? err.message : err}\n\n`);
+      }
+    },
+  },
+  {
+    name: '/genesis',
+    description: 'Propose a workflow evolution based on project insights',
+    handler: async (ctx: SlashContext) => {
+      const result = await ctx.executor('genesis_propose', {});
+      ctx.out(`\n${result.result}\n\n`);
+    },
+  },
+  {
+    name: '/trust',
+    description: 'Show current trust level and factors',
+    handler: async (ctx: SlashContext) => {
+      const result = await ctx.executor('project_health', {});
+      ctx.out(`\n${result.result}\n\n`);
+    },
+  },
 ];
 
 export function getSlashCompletions(partial: string): string[] {

package/src/bot/steering-engine.ts

@@ -0,0 +1,233 @@
+/**
+ * Steering Engine — time-based and event-based nudges that guide the
+ * assistant's behavior during long-running operations.
+ *
+ * Steers are injected into the system prompt when conditions are met.
+ * They're guidance, not hard stops (except urgent + "STOP" which triggers hasHardStop).
+ */
+
+export interface TimeTrigger {
+  type: 'time';
+  afterMs: number;
+}
+
+export interface EventTrigger {
+  type: 'event';
+  event: string;
+  count?: number; // default 1
+}
+
+export interface Steer {
+  id: string;
+  trigger: TimeTrigger | EventTrigger;
+  message: string;
+  intensity: 'gentle' | 'firm' | 'urgent';
+  once: boolean;
+}
+
+const INTENSITY_PREFIX: Record<string, string> = {
+  gentle: '[CONTEXT NOTE]',
+  firm: '[STEER]',
+  urgent: '[URGENT STEER]',
+};
+
+export class SteeringEngine {
+  private readonly steers: Steer[];
+  private startTime: number;
+  private eventCounts = new Map<string, number>();
+  private firedOnce = new Set<string>();
+  private pendingMessages: string[] = [];
+  private hardStopTriggered = false;
+  // Track last event count when an event steer fired (for once: false repeat logic)
+  private eventSteerLastFired = new Map<string, number>();
+
+  constructor(steers: Steer[]) {
+    this.steers = steers;
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Check all steers and return the highest-priority triggered message,
+   * or null if nothing fired.
+   */
+  check(): string | null {
+    const triggered: string[] = [];
+    const elapsed = Date.now() - this.startTime;
+
+    for (const steer of this.steers) {
+      if (steer.once && this.firedOnce.has(steer.id)) continue;
+
+      let shouldFire = false;
+
+      if (steer.trigger.type === 'time') {
+        shouldFire = elapsed >= steer.trigger.afterMs;
+      } else if (steer.trigger.type === 'event') {
+        const count = this.eventCounts.get(steer.trigger.event) ?? 0;
+        const threshold = steer.trigger.count ?? 1;
+
+        if (steer.once) {
+          shouldFire = count >= threshold;
+        } else {
+          // For repeat steers, fire every time we cross another threshold
+          const lastFired = this.eventSteerLastFired.get(steer.id) ?? 0;
+          shouldFire = count >= threshold && count > lastFired;
+          if (shouldFire) {
+            this.eventSteerLastFired.set(steer.id, count);
+          }
+        }
+      }
+
+      if (shouldFire) {
+        const prefix = INTENSITY_PREFIX[steer.intensity] ?? '[STEER]';
+        const formatted = `${prefix} ${steer.message}`;
+        triggered.push(formatted);
+
+        if (steer.once) this.firedOnce.add(steer.id);
+
+        if (steer.intensity === 'urgent' && steer.message.includes('STOP')) {
+          this.hardStopTriggered = true;
+        }
+      }
+    }
+
+    if (triggered.length === 0) return null;
+
+    // Add each triggered message individually to pending
+    this.pendingMessages.push(...triggered);
+
+    // Return combined for inline use
+    return triggered.join('\n\n');
+  }
+
+  /**
+   * Record an event occurrence. May trigger event-based steers on next check().
+   */
+  recordEvent(event: string): void {
+    this.eventCounts.set(event, (this.eventCounts.get(event) ?? 0) + 1);
+  }
+
+  /**
+   * Get all pending messages since last call and clear the queue.
+   */
+  getPendingMessages(): string[] {
+    const msgs = [...this.pendingMessages];
+    this.pendingMessages = [];
+    return msgs;
+  }
+
+  /**
+   * Reset all state for a new cycle. Restarts the timer.
+   */
+  reset(): void {
+    this.startTime = Date.now();
+    this.eventCounts.clear();
+    this.firedOnce.clear();
+    this.pendingMessages = [];
+    this.hardStopTriggered = false;
+    this.eventSteerLastFired.clear();
+  }
+
+  /**
+   * Returns true if an urgent steer with "STOP" in the message has fired.
+   */
+  hasHardStop(): boolean {
+    return this.hardStopTriggered;
+  }
+}
+
+/**
+ * Default steers that ship with every assistant session.
+ */
+export const DEFAULT_STEERS: Steer[] = [
+  {
+    id: 'direction-check',
+    trigger: { type: 'time', afterMs: 300_000 },
+    message: "You've been working for 5 minutes. Take a step back — are you sure this is the right approach? If not, pivot now.",
+    intensity: 'gentle',
+    once: true,
+  },
+  {
+    id: 'wrap-up',
+    trigger: { type: 'time', afterMs: 1_200_000 },
+    message: '20 minutes in. Focus on finishing your current change. If tests pass, commit. If not, fix only what\'s broken.',
+    intensity: 'firm',
+    once: true,
+  },
+  {
+    id: 'final-warning',
+    trigger: { type: 'time', afterMs: 2_700_000 },
+    message: "45 minutes. Commit what works now. Revert anything that doesn't pass tests. Time is almost up.",
+    intensity: 'urgent',
+    once: true,
+  },
+  {
+    id: 'hard-stop',
+    trigger: { type: 'time', afterMs: 3_600_000 },
+    message: 'STOP. 60 minutes reached. Commit passing work or revert everything.',
+    intensity: 'urgent',
+    once: true,
+  },
+  {
+    id: 'repeated-errors',
+    trigger: { type: 'event', event: 'tool_error', count: 3 },
+    message: "You've hit 3 tool errors. Stop and reconsider your approach. Read the error messages carefully.",
+    intensity: 'firm',
+    once: false,
+  },
+  {
+    id: 'test-failure-reflect',
+    trigger: { type: 'event', event: 'test_fail' },
+    message: "Tests failed. Don't just retry — think about WHY they failed. Read the error output carefully before making changes.",
+    intensity: 'gentle',
+    once: false,
+  },
+  {
+    id: 'write-blocked',
+    trigger: { type: 'event', event: 'file_write_blocked', count: 2 },
+    message: "File writes are being blocked. You're probably using the wrong path. Use paths relative to the project directory, not absolute paths.",
+    intensity: 'firm',
+    once: true,
+  },
+];
+
+/**
+ * Additional steers for the improve loop.
+ */
+export const IMPROVE_STEERS: Steer[] = [
+  {
+    id: 'improve-focus',
+    trigger: { type: 'time', afterMs: 120_000 },
+    message: "2 minutes in. If you haven't started writing code yet, you're over-analyzing. Pick the simplest fix and start writing.",
+    intensity: 'gentle',
+    once: true,
+  },
+  {
+    id: 'improve-commit-ready',
+    trigger: { type: 'event', event: 'test_pass' },
+    message: 'Tests pass. Commit your changes now unless you have a specific reason to keep going.',
+    intensity: 'firm',
+    once: false,
+  },
+];
+
+/**
+ * Load steers from .weaver-steers.json, merged with defaults.
+ */
+export function loadSteers(projectDir: string, extras: Steer[] = []): Steer[] {
+  const base = [...DEFAULT_STEERS, ...extras];
+
+  try {
+    const fs = require('node:fs') as typeof import('node:fs');
+    const path = require('node:path') as typeof import('node:path');
+    const configPath = path.join(projectDir, '.weaver-steers.json');
+    if (fs.existsSync(configPath)) {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      const userSteers: Steer[] = config.steers ?? [];
+      // User steers override defaults by ID
+      const userIds = new Set(userSteers.map(s => s.id));
+      return [...base.filter(s => !userIds.has(s.id)), ...userSteers];
+    }
+  } catch { /* config not available */ }
+
+  return base;
+}

package/src/bot/step-executor.ts

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
 import { runCommand } from '@synergenius/flow-weaver';
+import { BLOCKED_SHELL_PATTERNS } from './safety.js';
 
 // ---------------------------------------------------------------------------
 // Safety thresholds
@@ -25,21 +26,8 @@ const MAX_READ_SIZE = 1_048_576;
 /** Maximum files returned by list-files. */
 const MAX_LIST_FILES = 1000;
 
-/** Shell commands that are NEVER allowed (destructive operations). */
-const BLOCKED_SHELL_PATTERNS = [
-  /\brm\s+(-[a-z]*r|-[a-z]*f)[a-z]*\s/i,  // rm with -r or -f flags
-  /\bgit\s+push\b/i,              // git push (no remote ops)
-  /\bgit\s+reset\s+--hard\b/i,    // git reset --hard
-  /\bnpm\s+publish\b/i,           // npm publish
-  /\bcurl\b.*\|\s*(sh|bash)\b/i,  // curl | sh/bash
-  /\bwget\b.*\|\s*(sh|bash)\b/i,  // wget | sh/bash
-  /\bsudo\b/i,                    // sudo
-  /\bchmod\s+777\b/i,             // chmod 777
-  /\bkill\s+-9\b/i,               // kill -9
-  /\bmkfs\b/i,                    // format disk
-  /\bdd\s+if=/i,                  // dd (disk destroyer)
-  />\s*\/dev\/sd/i,               // write to raw disk
-];
+// Shell blocklist imported from safety.ts — single source of truth.
+// Do NOT add patterns here; add them in safety.ts instead.
 
 /** Track files written in this process to enforce the per-plan cap. */
 let filesWrittenThisPlan = 0;
@@ -55,11 +43,37 @@ export function resetPlanFileCounter(): void {
 
 function assertSafePath(filePath: string, projectDir: string): void {
   const resolved = path.resolve(projectDir, filePath);
-  if (!resolved.startsWith(path.resolve(projectDir))) {
+  const resolvedBase = path.resolve(projectDir);
+  if (!resolved.startsWith(resolvedBase + path.sep) && resolved !== resolvedBase) {
     throw new Error(
       `Path traversal blocked: "${filePath}" resolves outside project directory.`,
     );
   }
+
+  // Symlink protection: resolve real paths for any existing segments.
+  // Walk up from the resolved path to find the deepest existing ancestor,
+  // then verify its real path is still inside the project directory.
+  let checkPath = resolved;
+  while (!fs.existsSync(checkPath) && checkPath !== resolvedBase) {
+    checkPath = path.dirname(checkPath);
+  }
+  if (fs.existsSync(checkPath)) {
+    try {
+      const realPath = fs.realpathSync(checkPath);
+      const realBase = fs.realpathSync(resolvedBase);
+      if (!realPath.startsWith(realBase + path.sep) && realPath !== realBase) {
+        throw new Error(
+          `Path traversal blocked: "${filePath}" resolves outside project directory via symlink.`,
+        );
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.includes('Path traversal')) throw err;
+      // If realpath fails (broken symlink etc), block it
+      throw new Error(
+        `Path traversal blocked: "${filePath}" could not verify path safety.`,
+      );
+    }
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -222,6 +236,21 @@ export async function executeStep(
         };
       }
 
+      // Shrink guard: block patches that would reduce file size by >50%
+      const originalSize = fileSize;
+      const newSize = Buffer.byteLength(content, 'utf-8');
+      if (originalSize > SHRINK_GUARD_MIN_SIZE && newSize < originalSize * MAX_SHRINK_RATIO) {
+        const shrinkPct = Math.round((1 - newSize / originalSize) * 100);
+        return {
+          file: filePath,
+          blocked: true,
+          blockReason:
+            `Refusing to patch ${path.basename(filePath)}: result (${newSize}B) ` +
+            `is ${shrinkPct}% smaller than original (${originalSize}B). ` +
+            `This looks like accidental content removal. Review patches carefully.`,
+        };
+      }
+
       fs.writeFileSync(filePath, content, 'utf-8');
       filesWrittenThisPlan++;
 
@@ -242,16 +271,21 @@ export async function executeStep(
       if (!fs.existsSync(filePath)) {
         return { output: `File not found: ${file}` };
       }
-      if (fs.statSync(filePath).isDirectory()) {
-        const entries = fs.readdirSync(filePath, { encoding: 'utf-8' });
-        return { output: `"${file}" is a directory. Contents:\n${entries.join('\n')}` };
-      }
-      const fileSize = fs.statSync(filePath).size;
-      if (fileSize > MAX_READ_SIZE) {
-        return { output: `File too large to read (${fileSize} bytes, max ${MAX_READ_SIZE}). Use run-shell with head/tail instead.` };
+      try {
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+          const entries = fs.readdirSync(filePath, { encoding: 'utf-8' });
+          return { output: `"${file}" is a directory. Contents:\n${entries.join('\n')}` };
+        }
+        if (stat.size > MAX_READ_SIZE) {
+          return { output: `File too large to read (${stat.size} bytes, max ${MAX_READ_SIZE}). Use run-shell with head/tail instead.` };
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return { file: filePath, output: content };
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: `Error reading file "${file}": ${msg}` };
       }
-      const content = fs.readFileSync(filePath, 'utf-8');
-      return { file: filePath, output: content };
     }
 
     // -----------------------------------------------------------------
@@ -302,7 +336,13 @@ export async function executeStep(
         return { output: `Directory not found: ${dir}` };
       }
 
-      const entries = fs.readdirSync(targetDir, { recursive: true, encoding: 'utf-8' }) as string[];
+      let entries: string[];
+      try {
+        entries = fs.readdirSync(targetDir, { recursive: true, encoding: 'utf-8' }) as string[];
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { output: `Error listing directory "${dir}": ${msg}` };
+      }
       let files = entries
         .filter(e => {
           if (e.includes('node_modules') || e.includes('.git')) return false;

package/src/bot/system-prompt.ts

@@ -224,8 +224,9 @@ export async function buildSystemPrompt(): Promise<string> {
       docMeta.VALIDATION_CODES ?? [],
       docMeta.CLI_COMMANDS ?? [],
     );
-  } catch {
+  } catch (err) {
     // Fallback if doc-metadata not available (e.g., older flow-weaver version)
+    console.warn('Failed to load doc-metadata for system prompt; using empty fallback:', err);
     cachedPrompt = buildPromptFromMetadata([], [], [], [], []);
   }
 
@@ -292,7 +293,9 @@ Be concise in your text responses — let tool results speak.`;
         const plan = fs.readFileSync(planPath, 'utf-8').trim();
         prompt += '\n\n## Project Plan & Vision\n\nIMPORTANT: All work MUST align with this plan. If a task contradicts the plan, skip it and explain why.\n\n' + plan;
       }
-    } catch { /* plan file not available */ }
+    } catch (err) {
+      console.warn('Failed to load project plan file:', err);
+    }
   }
 
   if (contextBundle) {

package/src/bot/task-queue.ts

@@ -14,6 +14,8 @@ export interface QueuedTask {
   priority: number;
   addedAt: number;
   status: 'pending' | 'running' | 'completed' | 'no-op' | 'failed' | 'cancelled';
+  /** PID of the process running this task (set when status becomes 'running'). */
+  runnerId?: number;
   /** Error reason (set on failure) */
   failureReason?: string;
 }
@@ -57,7 +59,7 @@ export class TaskQueue {
       // Queue size cap
       const pendingCount = existing.filter(t => t.status === 'pending').length;
       if (pendingCount >= MAX_PENDING) {
-        throw new Error(`Queue full (${MAX_PENDING} pending tasks). Clear or process existing tasks first.`);
+        throw new Error(`Queue full (${MAX_PENDING} pending tasks). Use queue_retry to resume failed tasks, or queue_list to review.`);
       }
 
       const entry: QueuedTask = {
@@ -105,7 +107,15 @@ export class TaskQueue {
   }
 
   async markRunning(id: string): Promise<void> {
-    await this.updateStatus(id, 'running');
+    return withFileLock(this.filePath, () => {
+      const tasks = this.readAll();
+      const task = tasks.find(t => t.id === id);
+      if (task) {
+        task.status = 'running';
+        task.runnerId = process.pid;
+        this.writeAll(tasks);
+      }
+    });
   }
 
   async markComplete(id: string): Promise<void> {
@@ -158,14 +168,22 @@ export class TaskQueue {
     });
   }
 
-  /** Reset orphaned "running" tasks to pending (crash recovery). */
+  /** Reset orphaned "running" tasks to pending (crash recovery).
+   *  Only resets tasks whose runner PID is no longer alive. */
   async recoverOrphans(): Promise<number> {
     return withFileLock(this.filePath, () => {
       const tasks = this.readAll();
       let count = 0;
       for (const t of tasks) {
         if (t.status === 'running') {
+          // Check if the runner process is still alive
+          if (t.runnerId != null) {
+            let alive = false;
+            try { process.kill(t.runnerId, 0); alive = true; } catch { /* process gone */ }
+            if (alive) continue; // skip — process is still working on this task
+          }
           t.status = 'pending';
+          t.runnerId = undefined;
           count++;
         }
       }
@@ -193,9 +211,27 @@ export class TaskQueue {
     return records;
   }
 
+  /** Atomically claim the next pending task: selects highest-priority and marks it running in one lock. */
+  async claimNext(): Promise<QueuedTask | null> {
+    return withFileLock(this.filePath, () => {
+      const tasks = this.readAll();
+      const pending = tasks.filter(t => t.status === 'pending');
+      pending.sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
+      const chosen = pending[0];
+      if (!chosen) return null;
+      chosen.status = 'running';
+      chosen.runnerId = process.pid;
+      this.writeAll(tasks);
+      return chosen;
+    });
+  }
+
   private writeAll(tasks: QueuedTask[]): void {
     const dir = path.dirname(this.filePath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(this.filePath, tasks.map(t => JSON.stringify(t)).join('\n') + (tasks.length > 0 ? '\n' : ''), 'utf-8');
+    // Atomic write: write to temp file then rename to avoid partial reads on crash
+    const tmpPath = this.filePath + '.tmp.' + process.pid;
+    fs.writeFileSync(tmpPath, tasks.map(t => JSON.stringify(t)).join('\n') + (tasks.length > 0 ? '\n' : ''), 'utf-8');
+    fs.renameSync(tmpPath, this.filePath);
   }
 }