omni-pi 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.12.0 - 2026-04-27
+
+### Security and robustness
+
+- Sanitized untrusted text before it reaches brain prompts and `DECISIONS.md`
+- Sanitized generated `SKILL.md` files and fixed `Set` mutation in loop
+- Added atomic writes for `.omni/` and `.pi/` state files
+- Hardened version parsing in the self-updater
+
+### Bug fixes
+
+- Fixed `isRequestRelated` to actually use the overlap ratio for planning continuity
+- Fixed repo-map indexing, fingerprints, and dirty-path tracking
+- Fixed backtick code span tracking in the task table parser
+- Fixed prerelease ordering so pre-releases sort below their matching release in the updater
+- Used `os.homedir()` for reliable home directory resolution in the updater
+- Cached package version at module load to avoid repeated filesystem reads in the header
+
+### Dependencies
+
+- Upgraded `@mariozechner/pi-coding-agent` to `0.70.2`
+- Upgraded `@anthropic-ai/claude-agent-sdk` to `0.2.119`
+- Upgraded `@juanibiapina/pi-powerbar` to `0.9.1`
+- Upgraded `pi-interview` to `0.8.6`
+- Upgraded `pi-prompt-template-model` to `0.9.1`
+- Upgraded `glimpseui` to `0.8.0`
+- Upgraded `@biomejs/biome` to `2.4.13`
+- Upgraded `typescript` to `6.0.3`
+- Upgraded `vitest` to `4.1.5`
+- Upgraded `@types/node` to `25.6.0`
+
+### Housekeeping
+
+- Hoisted control-char regexes and applied Biome formatting
+- Included tests in `tsc` check and added launcher type declarations
+- Added `tsbuildinfo` and coverage artifacts to `.gitignore`
+- Enforced commit-after-every-task rule in `AGENTS.md`
+
 ## 0.11.0 - 2026-04-24
 
 ### Removed

package/bin/omni.d.ts

@@ -0,0 +1,22 @@
+export function getOmniPackageDir(): string;
+export function resolvePiCliPath(): string;
+export function buildOmniEnvironment(
+  baseEnv?: NodeJS.ProcessEnv,
+): NodeJS.ProcessEnv;
+export function ensureQuietStartupDefault(baseEnv?: NodeJS.ProcessEnv): void;
+export function buildPiProcessSpec(
+  argv?: string[],
+  baseEnv?: NodeJS.ProcessEnv,
+): {
+  command: string;
+  args: string[];
+  env: NodeJS.ProcessEnv;
+};
+export function runOmni(
+  argv?: string[],
+  options?: { cwd?: string; env?: NodeJS.ProcessEnv },
+): Promise<number>;
+export function isOmniEntrypointInvocation(
+  argvPath?: string,
+  moduleUrl?: string,
+): boolean;

package/bin/omni.js

@@ -1,11 +1,45 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+function writeFileAtomicSync(filePath, content) {
+  const tempPath = `${filePath}.${randomBytes(6).toString("hex")}.tmp`;
+  let mode;
+  try {
+    mode = statSync(filePath).mode & 0o777;
+  } catch {
+    // New file: keep Node's default creation mode.
+  }
+  try {
+    writeFileSync(tempPath, content, "utf8");
+    if (mode !== undefined) {
+      chmodSync(tempPath, mode);
+    }
+    renameSync(tempPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+      // temp may not exist
+    }
+    throw error;
+  }
+}
+
 export function getOmniPackageDir() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 }
@@ -22,8 +56,12 @@ export function resolvePiCliPath() {
 }
 
 export function buildOmniEnvironment(baseEnv = process.env) {
+  // Pi has its own update prompt; Omni-Pi runs its own (registerUpdater).
+  // Suppress Pi's check at the launcher boundary so the Omni updater is
+  // the only one that surfaces upgrade prompts.
   return {
     ...baseEnv,
+    PI_SKIP_VERSION_CHECK: "1",
   };
 }
 
@@ -56,10 +94,9 @@ export function ensureQuietStartupDefault(baseEnv = process.env) {
       typeof parsed === "object" &&
       parsed.quietStartup === undefined
     ) {
-      writeFileSync(
+      writeFileAtomicSync(
         settingsFile,
         `${JSON.stringify({ ...parsed, quietStartup: true }, null, 2)}\n`,
-        "utf8",
       );
     }
   } catch (error) {
@@ -73,10 +110,9 @@ export function ensureQuietStartupDefault(baseEnv = process.env) {
     }
 
     mkdirSync(agentDir, { recursive: true });
-    writeFileSync(
+    writeFileAtomicSync(
       settingsFile,
       `${JSON.stringify({ quietStartup: true }, null, 2)}\n`,
-      "utf8",
     );
   }
 }
@@ -96,7 +132,7 @@ export async function runOmni(argv = process.argv.slice(2), options = {}) {
   ensureQuietStartupDefault(options.env);
   const spec = buildPiProcessSpec(argv, options.env);
 
-  await new Promise((resolve, reject) => {
+  return await new Promise((resolve, reject) => {
     const child = spawn(spec.command, spec.args, {
       cwd: options.cwd ?? process.cwd(),
       env: spec.env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-pi",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Single-agent Pi package that interviews the user, documents the spec, and implements work in bounded slices.",
   "type": "module",
   "license": "MIT",
@@ -51,10 +51,10 @@
     "prepublishOnly": "npm run verify"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.9",
-    "@types/node": "^24.12.0",
-    "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "@biomejs/biome": "2.4.13",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "pi": {
     "extensions": [
@@ -79,14 +79,14 @@
     ]
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.84",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.119",
     "@juanibiapina/pi-extension-settings": "^0.6.1",
-    "@juanibiapina/pi-powerbar": "^0.8.0",
-    "@mariozechner/pi-coding-agent": "^0.70.0",
-    "glimpseui": "^0.7.0",
+    "@juanibiapina/pi-powerbar": "^0.9.1",
+    "@mariozechner/pi-coding-agent": "^0.70.2",
+    "glimpseui": "^0.8.0",
     "pi-diff-review": "file:./vendor/pi-diff-review",
-    "pi-interview": "^0.6.2",
-    "pi-prompt-template-model": "^0.8.2",
+    "pi-interview": "^0.8.6",
+    "pi-prompt-template-model": "^0.9.1",
     "pi-web-access": "^0.10.6",
     "zod": "^4.3.6"
   },

package/src/atomic.ts

@@ -0,0 +1,94 @@
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import {
+  chmod,
+  mkdir,
+  rename,
+  stat,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+
+// Atomic write helpers. Writes to a sibling temp file in the same
+// directory, then renames over the destination. POSIX rename(2) is
+// atomic when the source and destination are on the same filesystem,
+// so a reader (or a concurrent writer) never observes a partially
+// written state file. On Windows the rename is also atomic when the
+// destination exists.
+//
+// The temp suffix includes a random nonce so two concurrent writers
+// to the same path don't collide on their temp files.
+
+function tempPathFor(filePath: string): string {
+  return `${filePath}.${randomBytes(6).toString("hex")}.tmp`;
+}
+
+async function existingMode(filePath: string): Promise<number | undefined> {
+  try {
+    return (await stat(filePath)).mode & 0o777;
+  } catch {
+    return undefined;
+  }
+}
+
+function existingModeSync(filePath: string): number | undefined {
+  try {
+    return statSync(filePath).mode & 0o777;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function writeFileAtomic(
+  filePath: string,
+  content: string | Uint8Array,
+): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tempPath = tempPathFor(filePath);
+  const mode = await existingMode(filePath);
+  try {
+    await writeFile(tempPath, content, "utf8");
+    if (mode !== undefined) {
+      await chmod(tempPath, mode);
+    }
+    await rename(tempPath, filePath);
+  } catch (error) {
+    // Best-effort cleanup of the orphaned temp file; ignore failure
+    // since the original error is what matters.
+    try {
+      await unlink(tempPath);
+    } catch {
+      /* temp may not exist */
+    }
+    throw error;
+  }
+}
+
+export function writeFileAtomicSync(
+  filePath: string,
+  content: string | Uint8Array,
+): void {
+  const tempPath = tempPathFor(filePath);
+  const mode = existingModeSync(filePath);
+  try {
+    writeFileSync(tempPath, content, "utf8");
+    if (mode !== undefined) {
+      chmodSync(tempPath, mode);
+    }
+    renameSync(tempPath, filePath);
+  } catch (error) {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+      /* temp may not exist */
+    }
+    throw error;
+  }
+}

package/src/config.ts

@@ -1,6 +1,7 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
 
+import { writeFileAtomic } from "./atomic.js";
 import type { OmniConfig } from "./contracts.js";
 import { AVAILABLE_MODELS } from "./providers.js";
 
@@ -84,7 +85,7 @@ export async function writeConfig(
 ): Promise<void> {
   const configPath = path.join(rootDir, CONFIG_PATH);
   await mkdir(path.dirname(configPath), { recursive: true });
-  await writeFile(configPath, renderConfigContent(config), "utf8");
+  await writeFileAtomic(configPath, renderConfigContent(config));
 }
 
 export async function updateModelConfig(

package/src/header.ts

@@ -40,7 +40,7 @@ export function centerIn(text: string, width: number): string {
   return " ".repeat(pad) + text;
 }
 
-function readVersion(): string {
+function loadVersion(): string {
   try {
     const pkgPath = path.resolve(
       path.dirname(fileURLToPath(import.meta.url)),
@@ -56,16 +56,19 @@ function readVersion(): string {
   }
 }
 
+// Read once at module load — package.json doesn't change while the
+// process is running, so re-parsing on every render is wasted work.
+const VERSION = loadVersion();
+
 export function pickWelcome(): string {
   return WELCOME_MESSAGES[Math.floor(Math.random() * WELCOME_MESSAGES.length)];
 }
 
 export function renderHeader(theme: Theme): Text {
-  const version = readVersion();
   const welcome = pickWelcome();
 
   const logo = ASCII_LOGO.map((line) => brand(line)).join("\n");
-  const subtitleText = `— P I  v${version} —`;
+  const subtitleText = `— P I  v${VERSION} —`;
   const subtitle = theme.fg("muted", centerIn(subtitleText, LOGO_WIDTH));
   const taglineText = "plan · build · verify";
   const tagline = theme.fg("muted", centerIn(taglineText, LOGO_WIDTH));

package/src/planning.ts

@@ -162,6 +162,9 @@ function buildBootstrapTasks(repoSignals: RepoSignals): TaskBrief[] {
   return tasks;
 }
 
+const RELATION_OVERLAP_THRESHOLD = 0.34;
+const RELATION_SMALL_SET_LIMIT = 3;
+
 const RELATION_STOPWORDS = new Set([
   "a",
   "an",
@@ -245,13 +248,20 @@ export function isRequestRelated(
   const overlap = [...currentTokens].filter((token) =>
     previousTokens.has(token),
   );
-  if (overlap.length >= 1) {
-    return true;
+  if (overlap.length === 0) {
+    return false;
   }
 
-  return (
-    overlap.length / Math.min(previousTokens.size, currentTokens.size) >= 0.34
-  );
+  // Compare against the smaller token set: short follow-up summaries
+  // ("auth bug fix") have very few tokens, so even one match is meaningful
+  // there. With more text on either side, demand a real overlap ratio so a
+  // single incidental shared word ("users", "config") doesn't keep an
+  // unrelated plan alive.
+  const smaller = Math.min(previousTokens.size, currentTokens.size);
+  if (smaller <= RELATION_SMALL_SET_LIMIT) {
+    return true;
+  }
+  return overlap.length / smaller >= RELATION_OVERLAP_THRESHOLD;
 }
 
 export function createInitialSpec(

package/src/plans.ts

@@ -1,6 +1,7 @@
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, unlink } from "node:fs/promises";
 import path from "node:path";
 
+import { writeFileAtomic } from "./atomic.js";
 import type { PlanEntry, PlanStatus } from "./contracts.js";
 import { OMNI_DIR } from "./contracts.js";
 
@@ -109,7 +110,7 @@ async function writeIndex(
   entries: PlanEntry[],
 ): Promise<void> {
   await ensurePlansDir(rootDir);
-  await writeFile(indexPath(rootDir), renderIndex(entries), "utf8");
+  await writeFileAtomic(indexPath(rootDir), renderIndex(entries));
 }
 
 export async function createPlan(
@@ -123,10 +124,9 @@ export async function createPlan(
   const entry: PlanEntry = { id, title, status: "active", createdAt };
 
   await ensurePlansDir(rootDir);
-  await writeFile(
+  await writeFileAtomic(
     planFilePath(rootDir, id),
     renderPlanFile(entry, description, tasks),
-    "utf8",
   );
 
   const entries = await readPlanIndex(rootDir);
@@ -157,7 +157,7 @@ export async function updatePlanStatus(
     const filePath = planFilePath(rootDir, planId);
     const content = await readFile(filePath, "utf8");
     const updated = content.replace(/^Status:\s*.+$/mu, `Status: ${status}`);
-    await writeFile(filePath, updated, "utf8");
+    await writeFileAtomic(filePath, updated);
   } catch {
     // file may have been cleaned up already
   }
@@ -198,13 +198,12 @@ export async function appendProgress(
 
   try {
     const content = await readFile(filePath, "utf8");
-    await writeFile(filePath, `${content.trimEnd()}\n${bullet}\n`, "utf8");
+    await writeFileAtomic(filePath, `${content.trimEnd()}\n${bullet}\n`);
   } catch {
     await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(
+    await writeFileAtomic(
       filePath,
       `# Progress\n\nOngoing log of project progress.\n\n${bullet}\n`,
-      "utf8",
     );
   }
 }

package/src/prompt-template-sync.ts

@@ -1,13 +1,9 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+import { writeFileAtomicSync } from "./atomic.js";
+
 const MANAGED_PROMPT_FILES = ["commit.md", "push.md"] as const;
 const MANAGED_SUBDIR = "omni-pi";
 const LEGACY_MANAGED_SUBDIRS = ["zz-omni-pi"] as const;
@@ -55,7 +51,7 @@ export function ensureBundledPromptTemplates(
       continue;
     }
 
-    writeFileSync(targetPath, nextContent, "utf8");
+    writeFileAtomicSync(targetPath, nextContent);
     written.push(targetPath);
   }
 

package/src/repo-map-contracts.ts

@@ -2,7 +2,7 @@ import path from "node:path";
 
 export const REPO_MAP_DIR = path.join(".pi", "repo-map");
 export const REPO_MAP_STATE_FILE = path.join(REPO_MAP_DIR, "state.json");
-export const REPO_MAP_SCHEMA_VERSION = 1;
+export const REPO_MAP_SCHEMA_VERSION = 2;
 
 export type RepoMapParserStatus =
   | "indexed"
@@ -32,13 +32,17 @@ export interface RepoMapImport {
   resolvedPath?: string;
 }
 
+export type RepoMapFingerprint =
+  | { kind: "hash"; value: string }
+  | { kind: "stat"; value: string };
+
 export interface RepoMapFileRecord {
   path: string;
   language: string;
   parserStatus: RepoMapParserStatus;
   size: number;
   mtimeMs: number;
-  fingerprint: string;
+  fingerprint: RepoMapFingerprint;
   indexedAt: string;
   firstIndexedAt: string;
   symbols: RepoMapSymbol[];
@@ -71,7 +75,7 @@ export interface RepoMapSignal {
 
 export interface RepoMapSessionState {
   signals: RepoMapSignal[];
-  dirtyPaths: Set<string>;
+  dirtyPaths: Map<string, number>;
 }
 
 export interface RepoMapRenderOptions {

package/src/repo-map-index.ts

@@ -108,7 +108,9 @@ function isIgnored(
       return false;
     }
     if (rule.pattern.includes("/")) {
-      const target = rule.anchored ? normalized : normalized;
+      // Both anchored and non-anchored rules match against the full
+      // normalized path; anchoring is expressed in the regex / string
+      // comparison shape below, not in the target.
       if (rule.pattern.includes("*")) {
         const escaped = rule.pattern
           .replace(/[.+^${}()|[\]\\]/gu, "\\$&")
@@ -116,13 +118,14 @@ function isIgnored(
         const regex = rule.anchored
           ? new RegExp(`^${escaped}(?:/.*)?$`, "u")
           : new RegExp(`(?:^|/)${escaped}(?:/.*)?$`, "u");
-        return regex.test(target);
+        return regex.test(normalized);
       }
       return rule.anchored
-        ? target === rule.pattern || target.startsWith(`${rule.pattern}/`)
-        : target === rule.pattern ||
-            target.includes(`/${rule.pattern}`) ||
-            target.startsWith(`${rule.pattern}/`);
+        ? normalized === rule.pattern ||
+            normalized.startsWith(`${rule.pattern}/`)
+        : normalized === rule.pattern ||
+            normalized.includes(`/${rule.pattern}`) ||
+            normalized.startsWith(`${rule.pattern}/`);
     }
     return segments.some((segment) =>
       matchSingleSegment(rule.pattern, segment),
@@ -264,8 +267,12 @@ function parseModuleFile(
   }
 
   const imports: RepoMapImport[] = [];
+  // Use [^;]*? rather than [\s\S]*? so a missing `from` on one statement
+  // can't lazily expand into the next one and merge two imports into a
+  // single match. Multi-line imports are still allowed because they don't
+  // contain semicolons until the terminating one.
   const importRegex =
-    /^(?:import\s+[\s\S]*?\s+from\s+|export\s+[\s\S]*?\s+from\s+)["']([^"']+)["'];?/gmu;
+    /^(?:import\s+[^;]*?\s+from\s+|export\s+[^;]*?\s+from\s+)["']([^"']+)["'];?/gmu;
   for (const match of content.matchAll(importRegex)) {
     const specifier = match[1]?.trim();
     if (!specifier) continue;
@@ -354,7 +361,7 @@ export async function indexRepoMapFile(
     parserStatus: parsed.parserStatus,
     size: stats.size,
     mtimeMs: stats.mtimeMs,
-    fingerprint: hashContent(content),
+    fingerprint: { kind: "hash", value: hashContent(content) },
     indexedAt: now,
     firstIndexedAt: previous?.firstIndexedAt ?? now,
     symbols: parsed.symbols,
@@ -384,6 +391,34 @@ function rebuildIncomingPaths(files: Record<string, RepoMapFileRecord>): void {
   }
 }
 
+const STAT_CONCURRENCY = 32;
+
+async function statInPool(
+  rootDir: string,
+  filePaths: readonly string[],
+): Promise<Map<string, { size: number; mtimeMs: number } | null>> {
+  const results = new Map<string, { size: number; mtimeMs: number } | null>();
+  let cursor = 0;
+
+  async function worker(): Promise<void> {
+    while (cursor < filePaths.length) {
+      const index = cursor;
+      cursor += 1;
+      const filePath = filePaths[index];
+      try {
+        const stats = await stat(path.join(rootDir, filePath));
+        results.set(filePath, { size: stats.size, mtimeMs: stats.mtimeMs });
+      } catch {
+        results.set(filePath, null);
+      }
+    }
+  }
+
+  const workerCount = Math.min(STAT_CONCURRENCY, filePaths.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+
 export async function refreshRepoMapState(
   rootDir: string,
   dirtyPaths: Iterable<string> = [],
@@ -395,11 +430,32 @@ export async function refreshRepoMapState(
   const nextFiles: Record<string, RepoMapFileRecord> = {};
   const indexedPaths: string[] = [];
   const reusedPaths: string[] = [];
+  const statResults = await statInPool(rootDir, discovered);
 
   for (const filePath of discovered) {
     const previousRecord = previous.files[filePath];
-    const absolutePath = path.join(rootDir, filePath);
-    const stats = await stat(absolutePath);
+    let stats = statResults.get(filePath);
+    if (!stats) {
+      // File disappeared between discovery and stat — treat as removed.
+      continue;
+    }
+    if (
+      previousRecord &&
+      previous.schemaVersion === REPO_MAP_SCHEMA_VERSION &&
+      !dirtySet.has(filePath) &&
+      previousRecord.mtimeMs === stats.mtimeMs &&
+      previousRecord.size === stats.size
+    ) {
+      try {
+        // The pooled stat pass is intentionally early for throughput. Re-stat
+        // cache-hit candidates immediately before reuse so edits that land
+        // during the pool window don't keep stale repo-map records alive.
+        const freshStats = await stat(path.join(rootDir, filePath));
+        stats = { size: freshStats.size, mtimeMs: freshStats.mtimeMs };
+      } catch {
+        continue;
+      }
+    }
     const unchanged =
       previousRecord &&
       previousRecord.mtimeMs === stats.mtimeMs &&
@@ -433,7 +489,10 @@ export async function refreshRepoMapState(
         parserStatus: "parse-fallback",
         size: stats.size,
         mtimeMs: stats.mtimeMs,
-        fingerprint: `${stats.size}:${stats.mtimeMs}`,
+        fingerprint: {
+          kind: "stat",
+          value: `${stats.size}:${stats.mtimeMs}`,
+        },
         indexedAt: new Date().toISOString(),
         firstIndexedAt:
           previousRecord?.firstIndexedAt ?? new Date().toISOString(),

package/src/repo-map-runtime.ts

@@ -20,7 +20,7 @@ const sessionState = new Map<string, RepoMapSessionState>();
 function getSessionState(rootDir: string): RepoMapSessionState {
   let state = sessionState.get(rootDir);
   if (!state) {
-    state = { signals: [], dirtyPaths: new Set<string>() };
+    state = { signals: [], dirtyPaths: new Map<string, number>() };
     sessionState.set(rootDir, state);
   }
   return state;
@@ -40,7 +40,10 @@ export function recordRepoMapSignal(
   state.signals.unshift({ type, path: normalized, timestamp: Date.now() });
   state.signals = state.signals.slice(0, SESSION_RETENTION);
   if (type === "edit" || type === "write") {
-    state.dirtyPaths.add(normalized);
+    state.dirtyPaths.set(
+      normalized,
+      (state.dirtyPaths.get(normalized) ?? 0) + 1,
+    );
   }
 }
 
@@ -49,11 +52,17 @@ export function warmRepoMap(rootDir: string): Promise<RepoMapRefreshResult> {
   if (existing) {
     return existing;
   }
-  const task = refreshRepoMapState(
-    rootDir,
-    getSessionState(rootDir).dirtyPaths,
-  ).finally(() => {
-    getSessionState(rootDir).dirtyPaths.clear();
+  // Snapshot dirty paths up front. New edits arriving during the refresh
+  // stay in the live Set so they kick off the next refresh — without the
+  // snapshot, .finally().clear() would also drop those concurrent edits.
+  const snapshot = new Map(getSessionState(rootDir).dirtyPaths);
+  const task = refreshRepoMapState(rootDir, snapshot.keys()).finally(() => {
+    const live = getSessionState(rootDir).dirtyPaths;
+    for (const [dirty, generation] of snapshot) {
+      if (live.get(dirty) === generation) {
+        live.delete(dirty);
+      }
+    }
     warmups.delete(rootDir);
   });
   warmups.set(rootDir, task);