wogiflow 2.26.2 → 2.29.0

package/lib/wogi-claude-expect.exp

@@ -16,22 +16,38 @@
 # interleaved with ANSI color codes, so the literal phrase rarely arrived
 # in a single buffer and the regex missed. Workers deadlocked.
 #
-# v2.26.2 rewrite (this file) solves it with three properties:
-#   1. Rolling buffer — accumulate every chunk into one growing string,
-#      match against the whole buffer on each iteration, not per-chunk.
-#   2. ANSI strip — remove CSI / OSC escape sequences before matching,
-#      so the color-interleaved Ink output normalizes to plain text.
-#   3. Bounded elapsed-time window — stop accumulating after
-#      WOGI_EXPECT_TIMEOUT seconds (default 30). Without this, a very
-#      chatty claude startup with no dialog would keep exp_continue'ing
-#      forever until the per-iteration timeout.
+# v2.26.2 rewrite (DEPRECATED): rolling buffer + ANSI strip + timed window.
+# Fixed the per-chunk brittleness but introduced a WORSE bug: the
+# `expect { -re ".+" {...} }` watch-loop OWNS stdin while it runs. If the
+# dialog title text didn't match (e.g., Ink rendered differently in a new
+# Claude Code version, terminal line-wrapped mid-phrase, or the user's
+# terminal injected extra escape sequences), user keystrokes during the
+# 30-second watch window were captured by expect and NEVER forwarded to
+# claude. The dialog appeared frozen — Enter did nothing, letters went to
+# expect's buffer and were echoed to stray terminal positions. Reported
+# 2026-04-22.
 #
-# NO BLIND FALLBACK. If the window elapses without matching, we hand off
-# to interact unchanged. Sending a speculative \r to claude in server:
-# mode mid-startup is not safe (server-mode input handling is not a
-# standard REPL and could corrupt the handshake). Miss = same failure
-# mode as running claude without this wrapper. Worker retries via
-# wogi-claude's restart loop.
+# v2.26.3 (this file) solves both failure modes by using expect's
+# `interact -o` pattern instead of watch-then-handoff:
+#
+#   1. `interact` starts immediately after spawn. From second zero, user
+#      stdin is forwarded to claude — ZERO stdin capture.
+#   2. The `-o -re <pattern>` trigger watches CHILD output for the dialog
+#      phrase while stdin flows freely. When matched, we inject \r to
+#      accept the default-highlighted "I am using this for local
+#      development" option.
+#   3. Graceful fallback: if the pattern never matches (new CC dialog
+#      text, terminal weirdness), the user simply sees the dialog and
+#      presses 1+Enter themselves. No 30-second stdin black hole. Worst
+#      case = same as running claude without this wrapper. Best case =
+#      zero-click dismiss.
+#   4. A `_wogi_dismissed` flag prevents re-firing Enter if the phrase
+#      reappears later in chat output (paranoid safety).
+#
+# Pattern tolerance: `Loading.{0,20}development.{0,20}channels` matches
+# the phrase with up to 20 arbitrary bytes between each word, covering
+# ANSI color codes Ink inserts mid-rendering without requiring explicit
+# ANSI stripping (interact doesn't natively support it).
 #
 # Usage (invoked from lib/wogi-claude):
 #   expect wogi-claude-expect.exp /absolute/path/to/claude [args...]
@@ -44,6 +60,23 @@ if {[info exists env(WOGI_EXPECT_TIMEOUT)]} {
     set timeout $env(WOGI_EXPECT_TIMEOUT)
 }
 
+# wf-8294d960: env-guarded boot-latency instrumentation. No effect unless
+# WOGI_DEBUG_BOOT=1. Timestamps print to stderr so users can capture with 2>&1.
+set _wogi_boot_debug 0
+if {[info exists env(WOGI_DEBUG_BOOT)] && $env(WOGI_DEBUG_BOOT) eq "1"} {
+    set _wogi_boot_debug 1
+}
+set _wogi_boot_t0 [clock milliseconds]
+proc _wogi_boot_mark {label} {
+    global _wogi_boot_debug _wogi_boot_t0
+    if {$_wogi_boot_debug} {
+        set ms [expr {[clock milliseconds] - $_wogi_boot_t0}]
+        puts stderr [format "\[boot-latency\] +%6dms expect:%s" $ms $label]
+    }
+}
+
+_wogi_boot_mark "expect script start"
+
 # Mirror claude's output to the user's terminal during dialog watch
 log_user 1
 
@@ -61,78 +94,82 @@ set claude_args [lrange $argv 1 end]
 # arguments as Tcl script, which lets an argument containing bracket syntax
 # (e.g. `[exec attacker-cmd]`) escape to command execution. The splice form
 # expands the list without reparsing.
+_wogi_boot_mark "before spawn"
 spawn $claude_bin {*}$claude_args
+_wogi_boot_mark "after spawn (pid=$spawn_id)"
 
-# --- Dialog dismissal watch ---
-#
-# dialog_buf accumulates raw stdout chunks. After each chunk we strip ANSI
-# escapes into `plain` and substring-search for the dialog title text. If
-# found, we send Enter (accepts the default-highlighted "I am using this
-# for local development" option). Otherwise we exp_continue until either
-# the total elapsed time exceeds $timeout or EOF.
-set dialog_buf ""
-set start_ts [clock seconds]
+# ============================================================================
+# Test-mode branch (WOGI_EXPECT_NO_INTERACT=1): use the v2.26.2 expect +
+# rolling-buffer + ANSI-strip approach, followed by `expect eof`. Behavioural
+# tests can observe the child receiving our \r keystroke via a fake claude
+# that reads stdin and logs; interact would require a real TTY and CI stdin
+# pipes break it. Production users MUST NOT set this env var.
+# ============================================================================
+if {[info exists env(WOGI_EXPECT_NO_INTERACT)] && $env(WOGI_EXPECT_NO_INTERACT) eq "1"} {
+    set dialog_buf ""
+    set start_ts [clock seconds]
 
-expect {
-    -re "(.+)" {
-        append dialog_buf $expect_out(1,string)
+    expect {
+        -re "(.+)" {
+            append dialog_buf $expect_out(1,string)
 
-        # Strip ANSI CSI sequences (colors, cursor moves): ESC [ ... letter
-        regsub -all {\x1b\[[0-9;?]*[a-zA-Z]} $dialog_buf "" plain
-        # Strip 8-bit CSI form (0x9B byte instead of ESC [), same terminator
-        regsub -all {\x9b[0-9;?]*[a-zA-Z]} $plain "" plain
-        # Strip OSC sequences (titles, hyperlinks): ESC ] ... BEL
-        regsub -all {\x1b\][^\x07]*\x07} $plain "" plain
-        # Strip ISO 2022 charset-selection sequences: ESC ( B, ESC ) 0, etc.
-        regsub -all {\x1b[\(\)\*\+\-\.\/][\x20-\x7e]} $plain "" plain
-        # Strip bare ESC that didn't belong to a recognized sequence
-        regsub -all {\x1b} $plain "" plain
+            # Strip ANSI CSI sequences (colors, cursor moves): ESC [ ... letter
+            regsub -all {\x1b\[[0-9;?]*[a-zA-Z]} $dialog_buf "" plain
+            # Strip 8-bit CSI form (0x9B byte instead of ESC [), same terminator
+            regsub -all {\x9b[0-9;?]*[a-zA-Z]} $plain "" plain
+            # Strip OSC sequences (titles, hyperlinks): ESC ] ... BEL
+            regsub -all {\x1b\][^\x07]*\x07} $plain "" plain
+            # Strip ISO 2022 charset-selection sequences: ESC ( B, ESC ) 0, etc.
+            regsub -all {\x1b[\(\)\*\+\-\.\/][\x20-\x7e]} $plain "" plain
+            # Strip bare ESC that didn't belong to a recognized sequence
+            regsub -all {\x1b} $plain "" plain
 
-        if {[string first "Loading development channels" $plain] >= 0} {
-            # Let Ink finish rendering the select-input component before
-            # sending Enter — without this the keystroke can land before
-            # the keyboard listener binds and gets dropped.
-            after 250
-            send "\r"
-            # Fall through to interact — dialog is dismissed, user drives
-            # from here.
-        } else {
-            # Bound total accumulation by elapsed wall-clock time so we
-            # don't exp_continue forever on a chatty startup with no
-            # dialog.
-            set elapsed [expr {[clock seconds] - $start_ts}]
-            if {$elapsed < $timeout} {
-                # Cap buffer at 64KB to prevent runaway memory on a very
-                # long startup that never shows the dialog. Keep the tail
-                # half so any late-arriving title text still matches.
-                if {[string length $dialog_buf] > 65536} {
-                    set dialog_buf [string range $dialog_buf 32768 end]
+            if {[string first "Loading development channels" $plain] >= 0} {
+                after 250
+                send "\r"
+            } else {
+                set elapsed [expr {[clock seconds] - $start_ts}]
+                if {$elapsed < $timeout} {
+                    if {[string length $dialog_buf] > 65536} {
+                        set dialog_buf [string range $dialog_buf 32768 end]
+                    }
+                    exp_continue
                 }
-                exp_continue
             }
-            # Elapsed >= timeout: fall through to interact without
-            # dismissing. Same failure mode as running claude without
-            # this wrapper.
         }
+        timeout { }
+        eof { exit }
     }
-    timeout { }
-    eof { exit }
+    expect eof
+    exit
 }
 
-# Hand off: user's keystrokes flow to claude, claude's output flows to
-# the user's terminal. interact blocks until claude exits.
-#
-# Test hook: set WOGI_EXPECT_NO_INTERACT=1 to substitute `expect eof`.
-# `interact` requires a real TTY on stdin; under node:test / CI with
-# pipe-backed stdin it closes the PTY before our sent \r flushes to the
-# child. The test harness sets this env var so the behavioral tests (dialog
-# dismissal, ANSI fragmentation) can actually observe the child receiving
-# the keystroke. Production callers MUST NOT set this — users need
-# interact to drive claude after the dialog dismisses.
-if {[info exists env(WOGI_EXPECT_NO_INTERACT)] && $env(WOGI_EXPECT_NO_INTERACT) eq "1"} {
-    expect eof
-} else {
-    interact
+# ============================================================================
+# Production branch: interact with output trigger. Stdin flows to claude
+# from second zero — user keystrokes are NEVER captured by expect. When the
+# dialog phrase appears in child output, we inject Enter. Graceful fallback
+# on mismatch: user sees the dialog, presses 1+Enter themselves, no harm.
+# ============================================================================
+set _wogi_dismissed 0
+
+_wogi_boot_mark "entering interact"
+interact {
+    -o
+    -re "Loading.{0,20}development.{0,20}channels" {
+        global _wogi_dismissed
+        if {!$_wogi_dismissed} {
+            set _wogi_dismissed 1
+            _wogi_boot_mark "dialog pattern matched"
+            # Let Ink finish rendering the SelectInput component and bind its
+            # keyboard listener before injecting Enter. 500ms is generous —
+            # typical Ink reconciliation is <50ms but cold startups can be
+            # slower. If this fires before the listener binds, the user's
+            # own Enter keystroke (which we no longer capture) still works.
+            after 500
+            _wogi_boot_mark "auto-Enter injected (after 500ms wait)"
+            send "\r"
+        }
+    }
 }
 
 # Pass claude's exit status — wrapper cares about the restart flag file,

package/lib/workspace-channel-server.js

@@ -272,6 +272,25 @@ function handleRequest(msg) {
           const msgPath = require('node:path').join(messagesDir, `${msgId}.json`);
           fs.writeFileSync(msgPath, JSON.stringify(msgObj, null, 2));
 
+          // wf-3635574e / G3: populate the SQLite IPC index (best effort).
+          // JSON above remains authoritative. Index enables atomic consume
+          // for hot-path readers. AC5 fallback: silent if sql.js unavailable.
+          (async () => {
+            try {
+              const ipc = require('./workspace-ipc-sqlite');
+              if (!(await ipc.isAvailable())) return;
+              const route = ipc.routeMessageForIndex(msgObj);
+              if (!route) return;
+              await ipc.indexMessage(WORKSPACE_ROOT, route.repoName, route.direction, {
+                id: msgObj.id,
+                kind: msgObj.type,
+                payload: msgObj,
+                createdAt: msgObj.timestamp,
+                consumedAt: null
+              });
+            } catch (_err) { /* best effort */ }
+          })();
+
           // Also POST to manager's channel port for real-time notification
           const managerPort = process.env.WOGI_MANAGER_PORT;
           if (managerPort) {

package/lib/workspace-contracts.js

@@ -696,7 +696,7 @@ function checkTypeSyncCompliance(workspaceRoot, manifest) {
   try {
     const config = safeReadJson(configPath);
 
-    for (const [name, memberConfig] of Object.entries(config.members || {})) {
+    for (const [name, _memberConfig] of Object.entries(config.members || {})) {
       const member = manifest.members?.[name];
       if (!member || member.role === 'provider') continue; // Only check consumers
 

package/lib/workspace-dispatch-tracking.js

@@ -163,6 +163,144 @@ function getOverdueDispatches(workspaceRoot, now) {
   });
 }
 
+// ============================================================
+// SQLite Index (wf-3635574e / G3, Path B)
+// ============================================================
+// JSON ring buffer above remains authoritative. The async helpers below
+// use the SQLite IPC index for atomic queries at scale. Falls back
+// transparently to the JSON path if sql.js is unavailable (AC5).
+
+/**
+ * Record a dispatch and also index it in the worker's inbound SQLite DB.
+ * Preserves the sync recordDispatch path for existing callers; new callers
+ * that want the SQLite index entry call this async variant.
+ *
+ * @returns {Promise<{record: Object, indexed: boolean}>}
+ */
+async function recordDispatchIndexed(workspaceRoot, params) {
+  const record = recordDispatch(workspaceRoot, params);
+  let indexed = false;
+  try {
+    const ipc = require('./workspace-ipc-sqlite');
+    if (await ipc.isAvailable()) {
+      const id = `disp-${record.taskId}-${Date.parse(record.dispatchedAt) || 0}`.substring(0, 80);
+      indexed = await ipc.indexMessage(workspaceRoot, record.repoName, 'inbound', {
+        id,
+        kind: 'task-dispatch',
+        payload: record,
+        createdAt: record.dispatchedAt,
+        consumedAt: null
+      });
+    }
+  } catch (_err) { /* AC5 fallback */ }
+  return { record, indexed };
+}
+
+/**
+ * Return overdue dispatches by querying the SQLite index across all known
+ * workers. Falls back to the sync JSON ring buffer if SQLite is unavailable.
+ *
+ * Overdue = inbound row with consumed_at NULL and created_at older than
+ * expectedDurationMs (read from payload).
+ */
+async function getOverdueDispatchesIndexed(workspaceRoot, now) {
+  const ts = Number.isFinite(now) ? now : Date.now();
+  try {
+    const ipc = require('./workspace-ipc-sqlite');
+    if (!(await ipc.isAvailable())) {
+      return getOverdueDispatches(workspaceRoot, ts);
+    }
+    const repos = ipc.listIndexedRepos(workspaceRoot);
+    const overdue = [];
+    for (const repo of repos) {
+      const rows = await ipc.listUnconsumed(workspaceRoot, repo, 'inbound', { kind: 'task-dispatch' });
+      for (const r of rows) {
+        const p = r.payload || {};
+        const deadline = Date.parse(p.expectedDeadline || '');
+        if (Number.isFinite(deadline) && deadline < ts && p.status === 'pending') {
+          overdue.push(p);
+        }
+      }
+    }
+    return overdue;
+  } catch (_err) {
+    return getOverdueDispatches(workspaceRoot, ts);
+  }
+}
+
+/**
+ * Attach a completion summary to the most recent dispatch record for a task
+ * (Story B / wf-ab59f0e4). Sets status to 'completed-with-summary' so the
+ * silent-halt detector skips it. The summary itself is stored on the
+ * record under .completionSummary; the manager surfaces unseen summaries
+ * via readPendingCompletionSummaries().
+ *
+ * Single-writer invariant: this function MUST be called only by the
+ * manager process (workers POST the message via channel-dispatch; the
+ * manager's HTTP server invokes this).
+ *
+ * @param {string} workspaceRoot
+ * @param {string} taskId
+ * @param {Object} summary - validated payload from flow-workspace-summary
+ * @param {string} [workerId] - falls back to summary.workerId or the
+ *   matched record's repoName
+ * @returns {Object|null} updated record, or null if no matching dispatch
+ */
+function attachCompletionSummary(workspaceRoot, taskId, summary, workerId) {
+  if (!summary || typeof summary !== 'object') {
+    throw new Error('attachCompletionSummary: summary must be an object');
+  }
+  const state = loadState(workspaceRoot);
+  for (let i = state.dispatches.length - 1; i >= 0; i--) {
+    const r = state.dispatches[i];
+    if (r && r.taskId === taskId && r.status === 'pending') {
+      r.status = 'completed-with-summary';
+      r.reconciledAt = new Date().toISOString();
+      r.completionSummary = {
+        ...summary,
+        workerId: workerId || summary.workerId || r.repoName || null,
+        receivedAt: r.reconciledAt,
+        seenByManager: false
+      };
+      saveState(workspaceRoot, state);
+      return r;
+    }
+  }
+  return null;
+}
+
+/**
+ * Return completion summaries that the manager has not yet surfaced to the
+ * user. Caller (UserPromptSubmit hook) should mark them seen via
+ * markCompletionSummariesSeen() after rendering.
+ */
+function readPendingCompletionSummaries(workspaceRoot) {
+  const state = loadState(workspaceRoot);
+  const out = [];
+  for (const r of state.dispatches) {
+    if (r && r.completionSummary && r.completionSummary.seenByManager === false) {
+      out.push({ taskId: r.taskId, repoName: r.repoName, summary: r.completionSummary });
+    }
+  }
+  return out;
+}
+
+function markCompletionSummariesSeen(workspaceRoot, taskIds) {
+  if (!Array.isArray(taskIds) || taskIds.length === 0) return 0;
+  const set = new Set(taskIds);
+  const state = loadState(workspaceRoot);
+  let n = 0;
+  for (const r of state.dispatches) {
+    if (r && r.completionSummary && set.has(r.taskId) && r.completionSummary.seenByManager === false) {
+      r.completionSummary.seenByManager = true;
+      r.completionSummary.seenAt = new Date().toISOString();
+      n++;
+    }
+  }
+  if (n > 0) saveState(workspaceRoot, state);
+  return n;
+}
+
 module.exports = {
   DEFAULT_DURATION_MS,
   MAX_ACTIVE,
@@ -170,6 +308,12 @@ module.exports = {
   reconcileDispatch,
   readDispatches,
   getOverdueDispatches,
+  attachCompletionSummary,
+  readPendingCompletionSummaries,
+  markCompletionSummariesSeen,
+  // wf-3635574e SQLite-backed variants (async, opt-in):
+  recordDispatchIndexed,
+  getOverdueDispatchesIndexed,
   stateFilePath,
   archiveFilePath
 };

package/lib/workspace-gates.js

@@ -470,7 +470,7 @@ function broadcastPostChange(workspaceRoot, fromRepo, context, options = {}) {
  * @param {Object} taskMeta
  * @returns {{ passed: boolean, message: string, severity: string }}
  */
-function gateDeploymentReadiness(workspaceRoot, _context, taskMeta) {
+function gateDeploymentReadiness(workspaceRoot, _context, _taskMeta) {
   const { execFileSync } = require('node:child_process');
 
   try {