create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/lib/review-repo-registry.js

@@ -10,6 +10,7 @@ const path = require('path');
 const os = require('os');
 const fs = require('fs');
 const { admitReviewRepo, defaultAdmissionEnv } = require('./review-repo-admission');
+const { getDefaultWatchClient } = require('./watch-worker-client');
 
 const DEFAULT_CONCURRENCY = 4;
 
@@ -582,9 +583,11 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
 
   // --- WP-2: status_key cache + git-dir watcher + numstat-only-when-dirty -----------------
   // Injectable seams (tests-integration/review-registry-watch.test.js uses fake timers, not
-  // sleeps): opts.watch defaults to fs.watch, opts.setIntervalFn to setInterval,
+  // sleeps): opts.watch defaults to the process-wide watch client (WP-3 §5 D-4 / §9 S-6 — the
+  // git-dir watches churn with ephemeral land-* worktrees, so their open/close must not block the
+  // main loop on libuv's FSEvents semaphore), opts.setIntervalFn to setInterval,
   // opts.setTimeoutFn to setTimeout. `now` is already injectable (constructor arg).
-  const watchFn = typeof opts.watch === 'function' ? opts.watch : fs.watch;
+  const watchFn = typeof opts.watch === 'function' ? opts.watch : getDefaultWatchClient().watch;
   const setIntervalFn = typeof opts.setIntervalFn === 'function' ? opts.setIntervalFn : setInterval;
   const clearIntervalFn = typeof opts.clearIntervalFn === 'function' ? opts.clearIntervalFn : clearInterval;
   const setTimeoutFn = typeof opts.setTimeoutFn === 'function' ? opts.setTimeoutFn : setTimeout;
@@ -593,7 +596,16 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
   const watchDebounceMs = Math.max(0, Number(opts.watchDebounceMs) || 500);
 
   const watchedDirs = new Map(); // dir -> { watcher, repoPaths: Set<path> }
-  const watchDebounceTimers = new Map(); // path -> timer
+  // D-3 (WP-2): ONE pending set + ONE debounce timer + at most ONE watch pass in flight.
+  // A single fs.watch event on a commonDir shared by a whole repo's linked worktrees fans out
+  // to every path registered under that dir (see _watchDir below) — a per-path debounce timer
+  // made that N separate refresh() passes, each fanning out its own _mapBounded(4) statusV2
+  // spawns at once (observed 2026-10-30: ~428 spawns in one second, 8 bursts in 15 min, which
+  // starved the serial git lane). Signalled paths now accumulate here and are drained by
+  // exactly one bounded pass.
+  let watchPending = new Set(); // paths signalled since the last pass started
+  let watchTimer = null;
+  let watchPassRunning = null; // Promise | null
   const warnedWatchDirs = new Set(); // report a broken fs.watch dir once, not on every discover/sweep pass
 
   // status_key = `${indexMtimeMs}:${indexSize}:${HEADcontent}:${refsDirMtimeMs}:
@@ -642,17 +654,31 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
     return `${indexMtimeMs}:${indexSize}:${headContent}:${refsDirMtimeMs}:${fetchHeadMtimeMs}:${packedRefsMtimeMs}:${origHeadMtimeMs}`;
   }
 
+  // D-3 (WP-2): every signalled path joins ONE shared pending set behind ONE debounce timer.
+  // A path arriving while the timer is armed, or while a pass is already draining the set,
+  // just joins whichever of the two comes next — never a second timer, never a second pass.
   function _scheduleWatchRefresh(repoPath) {
     if (closed) return; // F5: don't arm a new debounce timer after close()
-    if (watchDebounceTimers.has(repoPath)) return; // storm coalesces into the one pending refresh
-    const timer = setTimeoutFn(() => {
-      watchDebounceTimers.delete(repoPath);
-      refresh({ project: repoPath, reason: 'watch' }).catch((error) => {
-        console.warn('[review-registry] watch refresh failed:', error && error.message || error);
+    watchPending.add(repoPath);
+    if (watchTimer || watchPassRunning) return; // joins the armed timer or the next pass
+    watchTimer = setTimeoutFn(_runWatchPass, watchDebounceMs);
+    if (watchTimer && typeof watchTimer.unref === 'function') watchTimer.unref();
+  }
+
+  async function _runWatchPass() {
+    watchTimer = null;
+    const projects = [...watchPending];
+    watchPending = new Set();
+    watchPassRunning = refresh({ projects, reason: 'watch' })
+      .catch((error) => console.warn('[review-registry] watch refresh failed:', error && error.message || error))
+      .finally(() => {
+        watchPassRunning = null;
+        // A path signalled WHILE this pass ran is served by exactly one follow-up pass. Re-arm
+        // through the SAME debounce path (not a direct _runWatchPass() call) so the follow-up
+        // still honours `closed` and still coalesces any events that land while it waits. No
+        // recursion: this only ever schedules, it never runs the pass itself.
+        if (watchPending.size && !closed) _scheduleWatchRefresh([...watchPending][0]);
       });
-    }, watchDebounceMs);
-    if (timer && typeof timer.unref === 'function') timer.unref();
-    watchDebounceTimers.set(repoPath, timer);
   }
 
   function _watchDir(dir, repoPath) {
@@ -679,7 +705,10 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
         try { next.watcher.close(); } catch { /* expected: an errored FSWatcher may throw on close */ }
         if (!warnedWatchDirs.has(dir)) {
           warnedWatchDirs.add(dir);
-          console.warn('[review-registry] watch error', dir, error && error.code);
+          // WP-3 §9 S-6: a missing/unwatchable dir now arrives HERE, not as the sync throw the
+          // catch below still guards — same once-per-dir report, under the old sync-catch text.
+          const label = error && error.syncAttach ? '[review-registry] watch failed' : '[review-registry] watch error';
+          console.warn(label, dir, error && error.code);
         }
       });
     } catch (error) {
@@ -740,8 +769,9 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
         watchedDirs.delete(dir);
       }
     }
-    const timer = watchDebounceTimers.get(repoPath);
-    if (timer) { clearTimeoutFn(timer); watchDebounceTimers.delete(repoPath); }
+    // D-3: there is no per-path timer to clear any more — just drop the path from the one
+    // shared pending set so a not-yet-fired pass doesn't refresh a row that is gone.
+    watchPending.delete(repoPath);
   }
 
   for (const [p, row] of mirror) _watchRepo(p, row);
@@ -879,13 +909,19 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
     return best;
   }
 
-  async function refresh({ project, force, reason, workTree } = {}) {
+  async function refresh({ project, projects, force, reason, workTree } = {}) {
     // R5: a refresh() called AFTER close() must not start new fan-out work — mirror/db access
     // below assumes the registry is still live.
     if (closed) return { changed: [], reason: 'closed', matched: false, matchedKey: null };
+    // D-3 (WP-2): the `projects` array form is what ONE coalesced watch pass drains — every
+    // signalled path resolved to its mirror key, deduped (two session cwds under the same
+    // toplevel collapse to one target). `project` (single) and the no-arg form are unchanged.
+    const isProjectsForm = Array.isArray(projects);
     const matchedKey = project ? _resolveMirrorKey(project) : null;
-    const targets = project ? (matchedKey ? [matchedKey] : []) : [...mirror.keys()];
-    const matched = project ? !!matchedKey : true;
+    const targets = isProjectsForm
+      ? [...new Set(projects.map((p) => _resolveMirrorKey(p)).filter(Boolean))]
+      : project ? (matchedKey ? [matchedKey] : []) : [...mirror.keys()];
+    const matched = isProjectsForm ? true : (project ? !!matchedKey : true);
     // F7: broadcasting `targets` on every tick — including a 30s/60s sweep tick where
     // nothing's status_key actually changed — made the client refetch its whole snapshot
     // every 30s per live cwd for free. Broadcast only the paths that ACTUALLY got a new
@@ -973,8 +1009,11 @@ function createReviewRepoRegistry({ db, gitRead, sessionFeed, readSources, broad
       try { entry.watcher && entry.watcher.close(); } catch { /* expected: watcher may already be closed/broken */ }
     }
     watchedDirs.clear();
-    for (const timer of watchDebounceTimers.values()) clearTimeoutFn(timer);
-    watchDebounceTimers.clear();
+    // D-3: the one shared watch timer is cleared and the pending set emptied, so no coalesced
+    // pass can be armed after close(). An already-running pass keeps going (its `.finally`
+    // re-arm is gated on `closed`); nothing new is scheduled.
+    if (watchTimer) { clearTimeoutFn(watchTimer); watchTimer = null; }
+    watchPending = new Set();
     if (sweepTimer) { clearIntervalFn(sweepTimer); sweepTimer = null; }
   }
 

package/template/coding-task-manager/lib/root-delivery-runtime.js

@@ -16,9 +16,9 @@ const retiredJobs = new WeakSet();
 const retiredTargets = new WeakSet();
 const PREFLIGHT = new Set([
   'session_not_live', 'session_input_in_flight', 'session_resume_not_ready',
-  'session_waiting_for_approval', 'command_deferred_until_idle',
+  'session_waiting_for_approval', 'command_deferred_until_idle', 'dsh_turn_in_flight',
 ]);
-const TRANSIENT = new Set(['session_input_in_flight', 'session_resume_not_ready', 'command_deferred_until_idle']);
+const TRANSIENT = new Set(['session_input_in_flight', 'session_resume_not_ready', 'command_deferred_until_idle', 'dsh_turn_in_flight']);
 
 function unavailable(code = 'root_job_unavailable', retryable = false) {
   return Object.freeze({ ok: false, error: code, code, retryable });

package/template/coding-task-manager/lib/root-prompt-flow.js

@@ -17,7 +17,7 @@ const TERMINAL_STATUSES = new Set([
   'sent', 'accepted_by_terminal', 'durable_user_message_seen', 'response_started', 'queued_by_agent',
 ]);
 const PREFLIGHT_RETRYABLE = new Set([
-  'session_input_in_flight', 'session_resume_not_ready', 'command_deferred_until_idle',
+  'session_input_in_flight', 'session_resume_not_ready', 'command_deferred_until_idle', 'dsh_turn_in_flight',
 ]);
 const PREFLIGHT_USER_ACTION = new Set(['session_not_live', 'session_waiting_for_approval']);
 // WP-0 (queue-delivery-recovery): one wording per recovery action, so the persisted

package/template/coding-task-manager/lib/runtime-contract.js

@@ -2,7 +2,9 @@
 
 const crypto = require('crypto');
 
-const ADAPTERS = new Set(['claude', 'codex', 'opencode', 'gemini', 'walle', 'cursor', 'shell', 'unknown']);
+// WP-2 (S-6): 'dsh' (DeepSeek Harness) is a first-class adapter id — without it
+// normalizeAdapter() would collapse every dsh runtime event to 'unknown'.
+const ADAPTERS = new Set(['claude', 'codex', 'opencode', 'gemini', 'walle', 'cursor', 'dsh', 'shell', 'unknown']);
 const THREAD_STATUSES = new Set(['running', 'waiting_input', 'idle', 'failed', 'closed']);
 const TURN_STATUSES = new Set(['open', 'streaming', 'waiting_input', 'closed', 'cancelled', 'failed']);
 const INPUT_MODES = new Set(['inline', 'mailbox', 'steer']);

package/template/coding-task-manager/lib/schema-indexes.js

@@ -59,6 +59,7 @@ const REQUIRED_INDEXES = [
   { name: "idx_code_reviews_artifact", table: "code_reviews", sql: "CREATE INDEX idx_code_reviews_artifact ON code_reviews(review_type, artifact_path)" },
   { name: "idx_code_reviews_project", table: "code_reviews", sql: "CREATE INDEX idx_code_reviews_project ON code_reviews(project_path)" },
   { name: "idx_code_reviews_session", table: "code_reviews", sql: "CREATE INDEX idx_code_reviews_session ON code_reviews(session_id)" },
+  { name: "idx_conv_item_clock_origin", table: "conversation_item_clock", sql: "CREATE INDEX idx_conv_item_clock_origin ON conversation_item_clock(origin_instance_id, origin_seq)" },
   { name: "idx_conversation_cutover_v2_lease", table: "conversation_session_cutover_v2", sql: "CREATE INDEX idx_conversation_cutover_v2_lease ON conversation_session_cutover_v2(lease_expires_at_ms,session_id)" },
   { name: "idx_conversation_cutover_v2_work", table: "conversation_session_cutover_v2", sql: "CREATE INDEX idx_conversation_cutover_v2_work ON conversation_session_cutover_v2(state,next_retry_at_ms,updated_at_ms,session_id)" },
   { name: "idx_conversation_import_stage_v2_order", table: "conversation_import_stage_v2", sql: "CREATE INDEX idx_conversation_import_stage_v2_order ON conversation_import_stage_v2(session_id,import_generation,position_key,stable_key)" },