@nathapp/nax 0.22.1 → 0.22.3

package/nax/status.json

@@ -1,27 +1,28 @@
 {
   "version": 1,
   "run": {
-    "id": "run-2026-03-05T02-37-04-540Z",
-    "feature": "nax-compliance",
-    "startedAt": "2026-03-05T02:37:04.540Z",
-    "status": "stalled",
+    "id": "run-2026-03-07T06-14-21-018Z",
+    "feature": "status-file-consolidation",
+    "startedAt": "2026-03-07T06:14:21.018Z",
+    "status": "completed",
     "dryRun": false,
-    "pid": 814245
+    "pid": 217461
   },
   "progress": {
-    "total": 1,
-    "passed": 0,
-    "failed": 1,
+    "total": 4,
+    "passed": 4,
+    "failed": 0,
     "paused": 0,
     "blocked": 0,
     "pending": 0
   },
   "cost": {
     "spent": 0,
-    "limit": 8
+    "limit": 3
   },
   "current": null,
-  "iterations": 3,
-  "updatedAt": "2026-03-05T02:38:46.469Z",
-  "durationMs": 101929
+  "iterations": 0,
+  "updatedAt": "2026-03-07T06:19:54.528Z",
+  "durationMs": 1000,
+  "lastHeartbeat": "2026-03-07T06:19:34.987Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.22.1",
+  "version": "0.22.3",
   "description": "AI Coding Agent Orchestrator \u2014 loops until done",
   "type": "module",
   "bin": {

package/src/execution/crash-recovery.ts

@@ -147,6 +147,12 @@ export function installCrashHandlers(ctx: CrashRecoveryContext): () => void {
 
   // Signal handler
   const handleSignal = async (signal: NodeJS.Signals) => {
+    // Hard deadline: force exit if any async operation hangs (FIX-H5)
+    const hardDeadline = setTimeout(() => {
+      process.exit(128 + getSignalNumber(signal));
+    }, 10_000);
+    if (hardDeadline.unref) hardDeadline.unref();
+
     logger?.error("crash-recovery", `Received ${signal}, shutting down...`, { signal });
 
     // Kill all spawned agent processes
@@ -166,6 +172,7 @@ export function installCrashHandlers(ctx: CrashRecoveryContext): () => void {
     // Stop heartbeat
     stopHeartbeat();
 
+    clearTimeout(hardDeadline);
     // Exit cleanly
     process.exit(128 + getSignalNumber(signal));
   };

package/src/execution/lifecycle/run-setup.ts

@@ -26,7 +26,7 @@ import type { PluginRegistry } from "../../plugins/registry";
 import type { PRD } from "../../prd";
 import { loadPRD } from "../../prd";
 import { installCrashHandlers } from "../crash-recovery";
-import { acquireLock, hookCtx } from "../helpers";
+import { acquireLock, hookCtx, releaseLock } from "../helpers";
 import { PidRegistry } from "../pid-registry";
 import { StatusWriter } from "../status-writer";
 
@@ -37,7 +37,7 @@ export interface RunSetupOptions {
   hooks: LoadedHooksConfig;
   feature: string;
   dryRun: boolean;
-  statusFile?: string;
+  statusFile: string;
   logFilePath?: string;
   runId: string;
   startedAt: string;
@@ -157,48 +157,56 @@ export async function setupRun(options: RunSetupOptions): Promise<RunSetupResult
     throw new LockAcquisitionError(workdir);
   }
 
-  // Load plugins (before try block so it's accessible in finally)
-  const globalPluginsDir = path.join(os.homedir(), ".nax", "plugins");
-  const projectPluginsDir = path.join(workdir, "nax", "plugins");
-  const configPlugins = config.plugins || [];
-  const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir);
-
-  // Log plugins loaded
-  logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
-    plugins: pluginRegistry.plugins.map((p) => ({ name: p.name, version: p.version, provides: p.provides })),
-  });
+  // Everything after lock acquisition is wrapped in try-catch to ensure
+  // the lock is released if any setup step fails (FIX-H16)
+  try {
+    // Load plugins (before try block so it's accessible in finally)
+    const globalPluginsDir = path.join(os.homedir(), ".nax", "plugins");
+    const projectPluginsDir = path.join(workdir, "nax", "plugins");
+    const configPlugins = config.plugins || [];
+    const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir);
+
+    // Log plugins loaded
+    logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
+      plugins: pluginRegistry.plugins.map((p) => ({ name: p.name, version: p.version, provides: p.provides })),
+    });
 
-  // Log run start
-  const routingMode = config.routing.llm?.mode ?? "hybrid";
-  logger?.info("run.start", `Starting feature: ${feature}`, {
-    runId,
-    feature,
-    workdir,
-    dryRun,
-    routingMode,
-  });
+    // Log run start
+    const routingMode = config.routing.llm?.mode ?? "hybrid";
+    logger?.info("run.start", `Starting feature: ${feature}`, {
+      runId,
+      feature,
+      workdir,
+      dryRun,
+      routingMode,
+    });
 
-  // Fire on-start hook
-  await fireHook(hooks, "on-start", hookCtx(feature), workdir);
+    // Fire on-start hook
+    await fireHook(hooks, "on-start", hookCtx(feature), workdir);
 
-  // Initialize run: check agent, reconcile state, validate limits
-  const { initializeRun } = await import("./run-initialization");
-  const initResult = await initializeRun({
-    config,
-    prdPath,
-    workdir,
-    dryRun,
-  });
-  prd = initResult.prd;
-  const counts = initResult.storyCounts;
+    // Initialize run: check agent, reconcile state, validate limits
+    const { initializeRun } = await import("./run-initialization");
+    const initResult = await initializeRun({
+      config,
+      prdPath,
+      workdir,
+      dryRun,
+    });
+    prd = initResult.prd;
+    const counts = initResult.storyCounts;
 
-  return {
-    statusWriter,
-    pidRegistry,
-    cleanupCrashHandlers,
-    pluginRegistry,
-    prd,
-    storyCounts: counts,
-    interactionChain,
-  };
+    return {
+      statusWriter,
+      pidRegistry,
+      cleanupCrashHandlers,
+      pluginRegistry,
+      prd,
+      storyCounts: counts,
+      interactionChain,
+    };
+  } catch (error) {
+    // Release lock before re-throwing so the directory isn't permanently locked
+    await releaseLock(workdir);
+    throw error;
+  }
 }

package/src/execution/lock.ts

@@ -49,22 +49,38 @@ export async function acquireLock(workdir: string): Promise<boolean> {
     if (exists) {
       // Read lock data
       const lockContent = await lockFile.text();
-      const lockData = JSON.parse(lockContent);
-      const lockPid = lockData.pid;
-
-      // Check if the process is still alive
-      if (isProcessAlive(lockPid)) {
-        // Process is alive, lock is valid
-        return false;
+      let lockData: { pid: number };
+      try {
+        lockData = JSON.parse(lockContent);
+      } catch {
+        // Corrupt/unparseable lock file — treat as stale and delete
+        const logger = getSafeLogger();
+        logger?.warn("execution", "Corrupt lock file detected, removing", {
+          lockPath,
+        });
+        const fs = await import("node:fs/promises");
+        await fs.unlink(lockPath).catch(() => {});
+        // Fall through to create a new lock
+        lockData = undefined as unknown as { pid: number };
       }
 
-      // Process is dead, remove stale lock
-      const logger = getSafeLogger();
-      logger?.warn("execution", "Removing stale lock", {
-        pid: lockPid,
-      });
-      const fs = await import("node:fs/promises");
-      await fs.unlink(lockPath).catch(() => {});
+      if (lockData) {
+        const lockPid = lockData.pid;
+
+        // Check if the process is still alive
+        if (isProcessAlive(lockPid)) {
+          // Process is alive, lock is valid
+          return false;
+        }
+
+        // Process is dead, remove stale lock
+        const logger = getSafeLogger();
+        logger?.warn("execution", "Removing stale lock", {
+          pid: lockPid,
+        });
+        const fs = await import("node:fs/promises");
+        await fs.unlink(lockPath).catch(() => {});
+      }
     }
 
     // Create lock file atomically using exclusive create (O_CREAT | O_EXCL)

package/src/execution/parallel.ts

@@ -180,8 +180,7 @@ async function executeParallelBatch(
   }
 
   // Execute stories in parallel with concurrency limit
-  const executing: Promise<void>[] = [];
-  let activeCount = 0;
+  const executing = new Set<Promise<void>>();
 
   for (const { story, worktreePath } of worktreeSetup) {
     const routing = routeTask(story.title, story.description, story.acceptanceCriteria, story.tags, config);
@@ -205,19 +204,13 @@ async function executeParallelBatch(
         }
       })
       .finally(() => {
-        activeCount--;
-        // BUG-4 fix: Remove completed promise from executing array
-        const index = executing.indexOf(executePromise);
-        if (index > -1) {
-          executing.splice(index, 1);
-        }
+        executing.delete(executePromise);
       });
 
-    executing.push(executePromise);
-    activeCount++;
+    executing.add(executePromise);
 
     // Wait if we've hit the concurrency limit
-    if (activeCount >= maxConcurrency) {
+    if (executing.size >= maxConcurrency) {
       await Promise.race(executing);
     }
   }

package/src/execution/pipeline-result-handler.ts

@@ -148,7 +148,7 @@ export async function handlePipelineFailure(
       });
 
       if (ctx.story.attempts !== undefined && ctx.story.attempts >= ctx.config.execution.rectification.maxRetries) {
-        pipelineEventBus.emit({
+        await pipelineEventBus.emitAsync({
           type: "human-review:requested",
           storyId: ctx.story.id,
           reason: pipelineResult.reason || "Max retries exceeded",

package/src/execution/runner.ts

@@ -47,8 +47,8 @@ export interface RunOptions {
   parallel?: number;
   /** Optional event emitter for TUI integration */
   eventEmitter?: PipelineEventEmitter;
-  /** Path to write a machine-readable JSON status file. Omit to skip writing. */
-  statusFile?: string;
+  /** Path to write a machine-readable JSON status file */
+  statusFile: string;
   /** Path to JSONL log file (for crash recovery) */
   logFilePath?: string;
   /** Formatter verbosity mode for headless stdout (default: "normal") */
@@ -99,6 +99,9 @@ export async function run(options: RunOptions): Promise<RunResult> {
 
   const logger = getSafeLogger();
 
+  // Declare prd before crash handler setup to avoid TDZ if SIGTERM arrives during setupRun
+  let prd: Awaited<ReturnType<typeof import("./lifecycle/run-setup").setupRun>>["prd"] | undefined;
+
   // ── Execute initial setup phase ──────────────────────────────────────────────
   const { setupRun } = await import("./lifecycle/run-setup");
   const setupResult = await setupRun({
@@ -120,7 +123,7 @@ export async function run(options: RunOptions): Promise<RunResult> {
     getIterations: () => iterations,
     // BUG-017: Pass getters for run.complete event on SIGTERM
     getStoriesCompleted: () => storiesCompleted,
-    getTotalStories: () => countStories(prd).total,
+    getTotalStories: () => (prd ? countStories(prd).total : 0),
   });
 
   const {
@@ -131,7 +134,7 @@ export async function run(options: RunOptions): Promise<RunResult> {
     storyCounts: counts,
     interactionChain,
   } = setupResult;
-  let prd = setupResult.prd;
+  prd = setupResult.prd;
 
   try {
     // ── Output run header in headless mode ─────────────────────────────────

package/src/execution/status-writer.ts

@@ -50,7 +50,7 @@ export interface StatusWriterContext {
  *   await sw.update(totalCost, iterations);
  */
 export class StatusWriter {
-  private readonly statusFile: string | undefined;
+  private readonly statusFile: string;
   private readonly costLimit: number | null;
   private readonly ctx: StatusWriterContext;
 
@@ -60,7 +60,7 @@ export class StatusWriter {
   private _currentStory: RunStateSnapshot["currentStory"] = null;
   private _consecutiveWriteFailures = 0; // BUG-2: Track consecutive write failures
 
-  constructor(statusFile: string | undefined, config: NaxConfig, ctx: StatusWriterContext) {
+  constructor(statusFile: string, config: NaxConfig, ctx: StatusWriterContext) {
     this.statusFile = statusFile;
     this.costLimit = config.execution.costLimit === Number.POSITIVE_INFINITY ? null : config.execution.costLimit;
     this.ctx = ctx;
@@ -107,7 +107,7 @@ export class StatusWriter {
   /**
    * Write the current status to disk (atomic via .tmp + rename).
    *
-   * No-ops if statusFile was not provided or _prd has not been set.
+   * No-ops if _prd has not been set.
    * On failure, logs a warning/error and increments the BUG-2 failure counter.
    * Counter resets to 0 on next successful write.
    *
@@ -116,7 +116,7 @@ export class StatusWriter {
    * @param overrides  - Optional partial snapshot overrides (spread last)
    */
   async update(totalCost: number, iterations: number, overrides: Partial<RunStateSnapshot> = {}): Promise<void> {
-    if (!this.statusFile || !this._prd) return;
+    if (!this._prd) return;
     const safeLogger = getSafeLogger();
     try {
       const base = this.getSnapshot(totalCost, iterations);

package/src/pipeline/stages/acceptance.ts

@@ -133,9 +133,11 @@ export const acceptanceStage: PipelineStage = {
       stderr: "pipe",
     });
 
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
 
     // Combine stdout and stderr for parsing
     const output = `${stdout}\n${stderr}`;

package/src/pipeline/stages/autofix.ts

@@ -113,9 +113,11 @@ interface CommandResult {
 async function runCommand(cmd: string, cwd: string): Promise<CommandResult> {
   const parts = cmd.split(/\s+/);
   const proc = Bun.spawn(parts, { cwd, stdout: "pipe", stderr: "pipe" });
-  const exitCode = await proc.exited;
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
   return { exitCode, output: `${stdout}\n${stderr}` };
 }
 

package/src/routing/strategies/llm.ts

@@ -98,6 +98,8 @@ async function callLlmOnce(modelTier: string, prompt: string, config: NaxConfig,
       reject(new Error(`LLM call timeout after ${timeoutMs}ms`));
     }, timeoutMs);
   });
+  // Prevent unhandled rejection if timer fires between race resolution and clearTimeout
+  timeoutPromise.catch(() => {});
 
   const outputPromise = (async () => {
     const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
@@ -116,17 +118,16 @@ async function callLlmOnce(modelTier: string, prompt: string, config: NaxConfig,
     return result;
   } catch (err) {
     clearTimeout(timeoutId);
-    try {
-      proc.stdout.cancel();
-    } catch {
-      // ignore cancel errors
-    }
-    try {
-      proc.stderr.cancel();
-    } catch {
-      // ignore cancel errors
-    }
+    // Silence the floating outputPromise BEFORE killing the process.
+    // proc.kill() causes piped streams to error → Response.text() rejects →
+    // outputPromise rejects. The .catch() must be attached first to prevent
+    // an unhandled rejection that crashes nax via crash-recovery.
+    outputPromise.catch(() => {});
     proc.kill();
+    // DO NOT call proc.stdout.cancel() / proc.stderr.cancel() here.
+    // The streams are locked by Response.text() readers. Per Web Streams spec,
+    // cancel() on a locked stream returns a rejected Promise (not a sync throw),
+    // which becomes an unhandled rejection. Let proc.kill() handle cleanup.
     throw err;
   }
 }

package/src/verification/executor.ts

@@ -34,8 +34,16 @@ async function drainWithDeadline(proc: Subprocess, deadlineMs: number): Promise<
     if (o !== EMPTY) out += o;
     if (e !== EMPTY) out += (out ? "\n" : "") + e;
   } catch (error) {
-    // Streams may already be destroyed - this is expected after kill
-    // No logger available in this utility function context
+    // Expected: streams destroyed after kill (e.g. TypeError from closed ReadableStream)
+    const isExpectedStreamError =
+      error instanceof TypeError ||
+      (error instanceof Error && /abort|cancel|close|destroy|locked/i.test(error.message));
+    if (!isExpectedStreamError) {
+      const { getSafeLogger } = await import("../logger");
+      getSafeLogger()?.debug("executor", "Unexpected error draining process output", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
   }
   return out;
 }
@@ -93,15 +101,19 @@ export async function executeWithTimeout(
   const timeoutMs = timeoutSeconds * 1000;
 
   let timedOut = false;
+  const timer = { id: undefined as ReturnType<typeof setTimeout> | undefined };
 
-  const timeoutPromise = (async () => {
-    await Bun.sleep(timeoutMs);
-    timedOut = true;
-  })();
+  const timeoutPromise = new Promise<void>((resolve) => {
+    timer.id = setTimeout(() => {
+      timedOut = true;
+      resolve();
+    }, timeoutMs);
+  });
 
   const processPromise = proc.exited;
 
   const raceResult = await Promise.race([processPromise, timeoutPromise]);
+  clearTimeout(timer.id);
 
   if (timedOut) {
     const pid = proc.pid;

package/test/helpers/helpers.test.ts

@@ -283,9 +283,9 @@ describe("acquireLock and releaseLock", () => {
     // Create invalid JSON lock file
     await Bun.write(lockPath, "not valid json");
 
-    // Should fail to acquire but not crash
+    // Should treat corrupt lock as stale and acquire successfully
     const acquired = await acquireLock(testDir);
-    expect(acquired).toBe(false);
+    expect(acquired).toBe(true);
   });
 
   test("handles release when lock file doesn't exist", async () => {

package/test/integration/execution/status-file-integration.test.ts

@@ -3,12 +3,11 @@
  * Integration Tests: Status File — runner + CLI (T2)
  *
  * Verifies:
- * - RunOptions.statusFile?: string exists
- * - Status file written at all 4 write points (dry-run path)
- * - Status file NOT written when statusFile omitted
+ * - RunOptions.statusFile: string is required
+ * - Status file always written at all 4 write points (dry-run path)
  * - Valid JSON at each stage, NaxStatusFile schema correct
  * - completed status, progress counts, null current at end
- * - --status-file CLI option wiring (type-level)
+ * - CLI automatically computes statusFile to <workdir>/nax/status.json
  */
 
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
@@ -53,13 +52,13 @@ class MockAgentAdapter implements AgentAdapter {
     return [this.binary];
   }
   async run(_o: AgentRunOptions): Promise<AgentResult> {
-    return { success: true, exitCode: 0, output: "", durationMs: 10, estimatedCost: 0 };
+    return { success: true, exitCode: 0, output: "", durationMs: 10, estimatedCost: 0, rateLimited: false };
   }
   async plan(_o: PlanOptions): Promise<PlanResult> {
-    return { specContent: "# Feature\n", success: true };
+    return { specContent: "# Feature\n" };
   }
   async decompose(_o: DecomposeOptions): Promise<DecomposeResult> {
-    return { stories: [], success: true };
+    return { stories: [] };
   }
 }
 
@@ -143,7 +142,7 @@ async function runWithStatus(feature: string, storyCount = 1, extraOpts: Partial
 // RunOptions type-level checks
 // ============================================================================
 describe("RunOptions.statusFile", () => {
-  it("is optional (can be omitted)", () => {
+  it("is required", () => {
     const opts: RunOptions = {
       prdPath: "/tmp/prd.json",
       workdir: "/tmp",
@@ -151,52 +150,25 @@ describe("RunOptions.statusFile", () => {
       hooks: { hooks: {} },
       feature: "test",
       dryRun: true,
+      statusFile: "/tmp/nax/status.json",
     };
-    expect(opts.statusFile).toBeUndefined();
-  });
-
-  it("accepts a string value", () => {
-    const opts: RunOptions = {
-      prdPath: "/tmp/prd.json",
-      workdir: "/tmp",
-      config: createTestConfig(),
-      hooks: { hooks: {} },
-      feature: "test",
-      dryRun: true,
-      statusFile: "/tmp/nax-status.json",
-    };
-    expect(opts.statusFile).toBe("/tmp/nax-status.json");
+    expect(opts.statusFile).toBe("/tmp/nax/status.json");
   });
 });
 
 // ============================================================================
-// No status file when option omitted (regression test)
+// Status file is always written when provided
 // ============================================================================
-describe("status file not written when omitted", () => {
+describe("status file always written when provided", () => {
   let tmpDir: string;
   afterEach(async () => {
     if (tmpDir) await fs.rm(tmpDir, { recursive: true, force: true });
   });
 
-  it("does not create any .json file in tmpDir", async () => {
-    const setup = await setupDir("no-sf", 1);
+  it("writes status file to provided path during dry-run", async () => {
+    const { setup, statusFilePath } = await runWithStatus("sf-always-written", 1);
     tmpDir = setup.tmpDir;
-    const before = await fs.readdir(setup.tmpDir);
-
-    await run({
-      prdPath: setup.prdPath,
-      workdir: setup.tmpDir,
-      config: createTestConfig(),
-      hooks: { hooks: {} },
-      feature: "no-sf",
-      featureDir: setup.featureDir,
-      dryRun: true, // no statusFile
-      skipPrecheck: true,
-    });
-
-    const after = await fs.readdir(setup.tmpDir);
-    const newJson = after.filter((f) => f.endsWith(".json") && !before.includes(f));
-    expect(newJson).toHaveLength(0);
+    expect(nodeFs.existsSync(statusFilePath)).toBe(true);
   });
 });
 
@@ -299,28 +271,19 @@ describe("status file written during dry-run", () => {
 });
 
 // ============================================================================
-// CLI --status-file wiring (type check only)
+// CLI status file wiring (type check only)
 // ============================================================================
-describe("CLI --status-file wiring", () => {
-  it("RunOptions.statusFile is passed through correctly", () => {
-    const withFile: RunOptions = {
-      prdPath: "/tmp/prd.json",
-      workdir: "/tmp",
-      config: createTestConfig(),
-      hooks: { hooks: {} },
-      feature: "test",
-      dryRun: false,
-      statusFile: "/tmp/status.json",
-    };
-    const withoutFile: RunOptions = {
+describe("CLI auto-computed status file", () => {
+  it("RunOptions.statusFile is required and always provided", () => {
+    const opts: RunOptions = {
       prdPath: "/tmp/prd.json",
       workdir: "/tmp",
       config: createTestConfig(),
       hooks: { hooks: {} },
       feature: "test",
       dryRun: false,
+      statusFile: "/tmp/nax/status.json",
     };
-    expect(withFile.statusFile).toBe("/tmp/status.json");
-    expect(withoutFile.statusFile).toBeUndefined();
+    expect(opts.statusFile).toBe("/tmp/nax/status.json");
   });
 });

package/test/integration/execution/status-writer.test.ts

@@ -77,14 +77,10 @@ function makeCtx(overrides: Partial<StatusWriterContext> = {}): StatusWriterCont
 // ============================================================================
 
 describe("StatusWriter construction", () => {
-  test("constructs without error when statusFile is defined", () => {
+  test("constructs without error with statusFile path", () => {
     expect(() => new StatusWriter("/tmp/status.json", makeConfig(), makeCtx())).not.toThrow();
   });
 
-  test("constructs without error when statusFile is undefined (no-op mode)", () => {
-    expect(() => new StatusWriter(undefined, makeConfig(), makeCtx())).not.toThrow();
-  });
-
   test("costLimit Infinity → stored as null in snapshot", async () => {
     const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
     const path = join(dir, "status.json");
@@ -214,13 +210,6 @@ describe("StatusWriter.getSnapshot", () => {
 // ============================================================================
 
 describe("StatusWriter.update no-op guards", () => {
-  test("no-op when statusFile is undefined (even with prd set)", async () => {
-    const sw = new StatusWriter(undefined, makeConfig(), makeCtx());
-    sw.setPrd(makePrd());
-    // Should not throw
-    await expect(sw.update(0, 0)).resolves.toBeUndefined();
-  });
-
   test("no-op when prd not yet set", async () => {
     const dir = await mkdtemp(join(tmpdir(), "sw-test-"));
     const path = join(dir, "status.json");