wogiflow 2.26.1 → 2.29.0

package/lib/wogi-claude-expect.exp

@@ -8,25 +8,75 @@
 #   - The CLI is launched with --dangerously-load-development-channels
 #
 # There's no Claude Code setting that persists an "accepted" state
-# (verified via decompiled source 2026-04-17). So we intercept the dialog
-# at the wrapper level: spawn claude in an expect-managed PTY, watch for
-# the dialog title text, send Enter to accept the already-highlighted
-# "I am using this for local development" option, then hand off control
-# to the user via `interact`.
+# (verified via decompiled source 2026-04-17) and no --accept-dev-channels
+# flag exists in `claude --help`.
+#
+# v2.22.x implementation (DEPRECATED): `-re "Loading development channels"`
+# matched per-chunk output. Ink paints the dialog in fragmented writes
+# 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 (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.
+#
+# 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...]
 #
 # Disable at runtime: set WOGI_NO_EXPECT=1. The wrapper then execs claude
-# directly and the user sees the dialog as before (manual single-click).
+# directly and the user sees the dialog as before.
 
 set timeout 30
-
-# Allow WOGI_EXPECT_TIMEOUT override (rarely needed)
 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
 
@@ -40,34 +90,88 @@ set claude_bin [lindex $argv 0]
 set claude_args [lrange $argv 1 end]
 
 # Spawn claude in a pseudo-TTY so its Ink UI renders normally.
-# eval is needed because claude_args is a list and spawn expects a
-# flattened command line.
-eval spawn $claude_bin $claude_args
+# Use {*} list-splice rather than `eval spawn` — `eval` reparses its
+# 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)"
 
-# Watch for the DevChannels dialog title, then press Enter to accept
-# the default-highlighted "I am using this for local development" option.
-#
-# On timeout or EOF: fall through to `interact`. If the dialog appears
-# AFTER our timeout window, the user can still answer it manually —
-# same failure mode as running claude directly.
-expect {
-    -re "Loading development channels" {
-        # Let Ink finish rendering the dialog before sending Enter.
-        # Without this, the select-input component may not have bound
-        # its keyboard listener yet and the keystroke is dropped.
-        after 250
-        send "\r"
+# ============================================================================
+# 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)
+
+            # 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} {
+                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
+                }
+            }
+        }
+        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.
-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"
+        }
+    }
+}
 
-# After claude exits, let the bash wrapper decide whether to restart.
-# Pass through claude's exit status (expect sets it in $expect_out(-code)
-# after `interact`, but a plain exit is sufficient since the wrapper
-# only cares about the restart flag file, not exit code).
+# Pass claude's exit status — wrapper cares about the restart flag file,
+# not exit code, so a plain exit suffices.
 exit

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 {