@pellux/goodvibes-tui 0.20.2 → 0.21.0

package/src/tools/wrfc-agent-guard.ts

@@ -40,8 +40,30 @@ type AgentTaskArgs = {
   readonly [key: string]: unknown;
 };
 
+// ---------------------------------------------------------------------------
+// Guard trace
+// ---------------------------------------------------------------------------
+
+/**
+ * Emitted whenever the guard changes the effective routing decision:
+ *   - 'spawn-forced-wrfc'      — implementation-like spawn promoted to WRFC
+ *   - 'spawn-suppressed-wrfc'  — spawn judged read-only; WRFC suppressed
+ *   - 'batch-collapsed-to-wrfc'— batch-spawn collapsed into a single WRFC owner chain
+ */
+export type WrfcGuardTraceKind =
+  | 'spawn-forced-wrfc'
+  | 'spawn-suppressed-wrfc'
+  | 'batch-collapsed-to-wrfc';
+
+export type WrfcGuardTrace = {
+  readonly kind: WrfcGuardTraceKind;
+  readonly reason: string;
+  readonly task: string;
+};
+
 type WrfcAgentToolGuardOptions = {
   readonly getLastUserMessage?: () => string | null;
+  readonly onTrace?: (trace: WrfcGuardTrace) => void;
 };
 
 export function installWrfcAgentToolGuard(registry: ToolRegistry, options: WrfcAgentToolGuardOptions = {}): void {
@@ -68,8 +90,15 @@ export function validateWrfcAgentToolInvocation(args: AgentToolArgs): string | n
 
 export function normalizeWrfcAgentToolInvocation(args: AgentToolArgs, options: WrfcAgentToolGuardOptions = {}): AgentToolArgs {
   const lastUserMessage = cleanText(options.getLastUserMessage?.() ?? null);
+  const trace = options.onTrace;
   if (args.mode === 'spawn') {
     if (shouldRouteSpawnToWrfc(args)) {
+      const reason = resolveSpawnWrfcReason(args);
+      trace?.({
+        kind: 'spawn-forced-wrfc',
+        reason,
+        task: cleanText(args.task) || '(no task)',
+      });
       const normalized: AgentToolArgs = {
         ...args,
         task: selectAuthoritativeTask(args.task, lastUserMessage),
@@ -78,12 +107,22 @@ export function normalizeWrfcAgentToolInvocation(args: AgentToolArgs, options: W
       };
       return cleanText(args.template) ? normalized : { ...normalized, template: 'engineer' };
     }
+    trace?.({
+      kind: 'spawn-suppressed-wrfc',
+      reason: isReadOnlyTask(cleanText(args.task)) ? 'task judged read-only' : 'no implementation signal detected',
+      task: cleanText(args.task) || '(no task)',
+    });
     return { ...args, reviewMode: 'none', dangerously_disable_wrfc: true };
   }
 
   if (args.mode !== 'batch-spawn') return args;
   const tasks = Array.isArray(args.tasks) ? args.tasks.filter(isRecord) : [];
   if (shouldCollapseBatchToAuthoritativeWrfc(args, tasks) && lastUserMessage) {
+    trace?.({
+      kind: 'batch-collapsed-to-wrfc',
+      reason: `WRFC: collapsed ${tasks.length}-agent batch into one reviewed chain`,
+      task: lastUserMessage,
+    });
     return buildAuthoritativeWrfcSpawn(args, tasks, lastUserMessage);
   }
   const wrfcTasks = tasks.filter((task) => isExplicitWrfcTask(task, args));
@@ -190,17 +229,39 @@ function isRootReviewRoleTask(task: AgentTaskArgs): boolean {
     || /\b(?:test|tests|testing|review|reviews|reviewing|verify|verifies|verifying|verification|validate|validates|validating|validation|qa)\s+(?:the|this|that|implementation|solution|feature|deliverable|code|changes|work|output|result|patch|diff)\b/i.test(text);
 }
 
+function resolveSpawnWrfcReason(args: AgentTaskArgs): string {
+  if (containsWrfcSignal(args.task)) return 'task contains explicit WRFC signal';
+  if (args.reviewMode === 'wrfc') return 'reviewMode explicitly set to wrfc';
+  if (isRootReviewRoleTask(args)) return 'task identified as root review-role (reviewer/tester/verifier)';
+  return 'task judged implementation-like';
+}
+
 function isImplementationLikeTask(task: AgentTaskArgs): boolean {
   const text = cleanText(task.task);
   if (!text) return false;
-  return /\b(?:build|implement|create|add|write|fix|repair|update|refactor|change|modify|deliver|make|patch)\b/i.test(text)
+  // Broad verb set: explicit action words + short imperative phrasings like
+  // "make the button blue", "wire up X", "connect X", "rename X", "move X"
+  return /\b(?:build|implement|create|add|write|fix|repair|update|refactor|change|modify|deliver|make|patch|wire|connect|rename|move|delete|remove|migrate|configure|set\s+up|set\s+the|turn\s+on|turn\s+off|enable|disable|initialize|init|register|replace|swap|convert|transform|extend|integrate|embed|inject|port|rewrite|restructure)\b/i.test(text)
     && !isReadOnlyTask(text);
 }
 
 function isReadOnlyTask(text: string): boolean {
+  // Branch A: explicit do-not-write guards
   if (/\bdo\s+not\s+(?:write|edit|modify|change|create)\b|\bread[-\s]*only\b|\bwithout\s+(?:writing|editing|modifying|changing|creating)\b/i.test(text)) return true;
-  return /^\s*(?:inspect|research|read|find|list|summarize|analy[sz]e|explain)\b/i.test(text)
-    && !/\b(?:build|implement|create|add|write|fix|repair|update|refactor|change|modify|deliver|make|patch)\b/i.test(text);
+  // Branch B: task leads with an analysis/reporting verb — treat it as read-only regardless
+  // of any action verbs that appear later in the sentence. A task that LEADS with
+  // "report", "investigate", "describe", "audit", etc. is describing or evaluating an
+  // action, not performing it. Examples that must NOT reach WRFC:
+  //   "report on how to migrate the auth module"
+  //   "investigate what to remove"
+  //   "document how we would convert X to Y"
+  //   "describe the steps to disable telemetry"
+  //   "audit which modules to delete"
+  //   "evaluate whether to migrate"
+  // The negative-lookahead is intentionally absent: the leading verb is authoritative.
+  // Note: 'review' is intentionally excluded — tasks leading with 'review' are caught
+  // by isRootReviewRoleTask() and routed to a WRFC chain as a reviewer role.
+  return /^\s*(?:inspect|research|read|find|list|summarize|analy[sz]e|explain|report|investigate|document|describe|audit|evaluate|assess|check|compare|tell|show)\b/i.test(text);
 }
 
 function selectAuthoritativeTask(candidate: unknown, lastUserMessage: string): string {

package/src/utils/format-elapsed.ts

@@ -0,0 +1,30 @@
+/**
+ * Format elapsed time (in milliseconds) as a compact human-readable string.
+ *
+ * Ranges:
+ *   < 1 second  → "0.Xs"   (one decimal, e.g. "0.4s")
+ *   1-59s       → "Xs"     (e.g. "3s", "59s")
+ *   1m-59m59s   → "Xm YYs" (e.g. "1m04s", "59m59s")
+ *   ≥ 1 hour    → "Xh YYm" (e.g. "1h02m")
+ *
+ * Used by the thinking indicator and live tool timer.
+ */
+export function formatElapsed(ms: number): string {
+  if (ms < 0) ms = 0;
+  if (ms < 1000) {
+    // Truncate (not round) to one decimal so 999ms stays "0.9s" not "1.0s".
+    return `${(Math.floor(ms / 100) / 10).toFixed(1)}s`;
+  }
+  const totalSecs = Math.floor(ms / 1000);
+  if (totalSecs < 60) {
+    return `${totalSecs}s`;
+  }
+  const totalMins = Math.floor(totalSecs / 60);
+  if (totalMins < 60) {
+    const remSecs = totalSecs % 60;
+    return `${totalMins}m${String(remSecs).padStart(2, '0')}s`;
+  }
+  const hours = Math.floor(totalMins / 60);
+  const remMins = totalMins % 60;
+  return `${hours}h${String(remMins).padStart(2, '0')}m`;
+}

package/src/utils/terminal-width.ts

@@ -1,9 +1,54 @@
+/**
+ * Strip ANSI SGR/CSI escape sequences and OSC-8 hyperlink sequences
+ * from a string so that only visible characters remain for width measurement.
+ *
+ * Covers:
+ *   - CSI sequences: ESC [ ... <final byte 0x40-0x7E>  (includes SGR \x1b[...m)
+ *   - OSC sequences: ESC ] ... ST  where ST is ESC\\ or BEL (0x07)
+ *   - Simple ESC followed by a single non-bracket/non-] character (e.g. ESC c)
+ */
+function stripAnsi(text: string): string {
+  let result = '';
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '\x1b') {
+      const next = text[i + 1];
+      if (next === '[') {
+        // CSI: skip until final byte (0x40-0x7E)
+        i += 2;
+        while (i < text.length) {
+          const c = text.charCodeAt(i);
+          i++;
+          if (c >= 0x40 && c <= 0x7e) break;
+        }
+      } else if (next === ']') {
+        // OSC: skip until ST (ESC\\ or BEL)
+        i += 2;
+        while (i < text.length) {
+          if (text[i] === '\x07') { i++; break; }
+          if (text[i] === '\x1b' && text[i + 1] === '\\') { i += 2; break; }
+          i++;
+        }
+      } else {
+        // Simple two-byte escape (ESC + one char)
+        i += next !== undefined ? 2 : 1;
+      }
+    } else {
+      result += text[i];
+      i++;
+    }
+  }
+  return result;
+}
+
 /**
  * Calculates the visual width of a string in the terminal.
  * Handles CJK characters, emoji (including ZWJ sequences), and
  * variation selectors correctly as double-width.
+ * ANSI escape sequences (SGR/CSI/OSC-8) are stripped before measurement.
  */
 export function getDisplayWidth(text: string): number {
+  text = stripAnsi(text);
   let width = 0;
   let i = 0;
   while (i < text.length) {

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.20.2';
+let _version = '0.21.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

package/src/work-plans/work-plan-store.ts

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { atomicWriteFileSync } from '@/config/atomic-write.ts';
+import { join } from 'node:path';
 
 export const WORK_PLAN_STATUSES = [
   'pending',
@@ -331,10 +332,7 @@ export class WorkPlanStore {
   }
 
   private writePlan(plan: WorkPlan): void {
-    mkdirSync(dirname(this.filePath), { recursive: true });
-    const tmp = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmp, `${JSON.stringify(plan, null, 2)}\n`, { mode: 0o600 });
-    renameSync(tmp, this.filePath);
+    atomicWriteFileSync(this.filePath, `${JSON.stringify(plan, null, 2)}\n`, { mkdirp: true });
   }
 
   private resolveItem(plan: WorkPlan, idOrPrefix: string): WorkPlanItem {