wogiflow 2.26.2 → 2.29.0

package/scripts/flow-ac-scope-preservation.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+/**
+ * AC Scope-Preservation Checklist (wf-fe8ef64d / B1).
+ *
+ * Extends the existing Item Reconciliation Gate (scripts/flow-story-gates.js):
+ *   - Reconciliation verifies items → criteria at CREATION time only.
+ *   - Scope-preservation snapshots the originally-stated ACs at creation,
+ *     then re-verifies at task CLOSE time that none were silently dropped,
+ *     merged, or reshaped during implementation.
+ *
+ * Data at rest:
+ *   .workflow/state/ac-snapshots/<taskId>.json
+ *
+ * Consumer wiring:
+ *   - scripts/flow-story.js calls snapshotCriteria() after generating the
+ *     acceptance criteria list.
+ *   - scripts/flow-bug.js does the same.
+ *   - scripts/flow-done.js calls verifyScopePreservation() as a quality gate
+ *     before moving a task to completed.
+ *
+ * Story: wf-fe8ef64d (B1)
+ * Epic: wf-34290000
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { PATHS } = require('./flow-paths');
+const { fileExists, safeJsonParse } = require('./flow-io');
+
+const SNAPSHOT_DIR = path.join(PATHS.state, 'ac-snapshots');
+
+function _ensureDir() {
+  if (!fs.existsSync(SNAPSHOT_DIR)) {
+    fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+  }
+}
+
+function _snapshotPath(taskId) {
+  if (!/^wf-[a-f0-9]{8}(-\d{2})?$/i.test(String(taskId || ''))) {
+    throw new TypeError(`invalid taskId: ${taskId}`);
+  }
+  return path.join(SNAPSHOT_DIR, `${taskId}.json`);
+}
+
+/**
+ * Persist the original acceptance criteria as a baseline for close-time verification.
+ * Idempotent: a second call for the same taskId with unchanged content is a no-op.
+ *
+ * @param {string} taskId
+ * @param {string[]} criteria - array of criterion strings
+ * @param {object} [meta] - optional metadata (title, createdAt, rawInput)
+ * @returns {{ok: boolean, path?: string, skipped?: boolean, reason?: string}}
+ */
+function snapshotCriteria(taskId, criteria, meta = {}) {
+  if (!Array.isArray(criteria) || criteria.length === 0) {
+    return { ok: false, reason: 'criteria must be a non-empty array' };
+  }
+  _ensureDir();
+  const p = _snapshotPath(taskId);
+  const payload = {
+    taskId,
+    snapshotAt: new Date().toISOString(),
+    criteria: criteria.map((c, i) => ({ id: `ac-${i + 1}`, text: String(c).trim() })),
+    meta,
+  };
+  // Idempotency: if an existing snapshot has the same texts in the same order, skip.
+  if (fileExists(p)) {
+    const prev = safeJsonParse(p, null);
+    if (prev && Array.isArray(prev.criteria) && prev.criteria.length === payload.criteria.length) {
+      const same = prev.criteria.every((c, i) => c.text === payload.criteria[i].text);
+      if (same) return { ok: true, path: p, skipped: true, reason: 'identical snapshot exists' };
+    }
+  }
+  fs.writeFileSync(p, JSON.stringify(payload, null, 2));
+  return { ok: true, path: p };
+}
+
+/**
+ * Load a prior snapshot.
+ * @param {string} taskId
+ * @returns {object|null}
+ */
+function loadSnapshot(taskId) {
+  const p = _snapshotPath(taskId);
+  if (!fileExists(p)) return null;
+  return safeJsonParse(p, null);
+}
+
+/**
+ * Token-overlap coverage check. Reuses the heuristic from flow-story-gates.js
+ * but returns a per-criterion verdict instead of a single boolean.
+ *
+ * @param {string} original - original criterion text
+ * @param {string[]} current - current criterion texts
+ * @returns {{ status: 'preserved'|'modified'|'dropped', matchIdx: number, overlap: number }}
+ */
+function _matchCriterion(original, current) {
+  const STOPWORDS = new Set([
+    'with', 'from', 'that', 'this', 'have', 'make', 'been', 'were', 'their',
+    'they', 'them', 'will', 'should', 'would', 'could', 'there', 'into',
+    'when', 'then', 'than', 'which', 'what', 'your', 'given',
+    // User-story boilerplate — every criterion contains these, so they dilute signal
+    'user', 'users', 'admin', 'admins', 'administrator', 'administrators',
+    'able', 'must', 'shall', 'action',
+  ]);
+  const tokenize = (s) => new Set(
+    String(s).toLowerCase().match(/\b[a-z]{4,}\b/g)?.filter((w) => !STOPWORDS.has(w)) || []
+  );
+  const origTokens = tokenize(original);
+  if (origTokens.size === 0) return { status: 'dropped', matchIdx: -1, overlap: 0 };
+
+  let best = { idx: -1, overlap: 0 };
+  current.forEach((c, idx) => {
+    const ct = tokenize(c);
+    let overlap = 0;
+    for (const t of origTokens) {
+      if (ct.has(t)) overlap++;
+    }
+    if (overlap > best.overlap) best = { idx, overlap };
+  });
+
+  const orig = origTokens.size;
+  if (best.overlap === 0) return { status: 'dropped', matchIdx: -1, overlap: 0 };
+
+  // Strong match: ≥ 75% overlap AND ≥ 2 absolute tokens (or ≥ orig when orig < 2) → preserved.
+  // Weak match: any non-zero overlap that didn't reach the strong bar → modified.
+  // Rationale: uploading a photo vs. deleting a photo share "profile|photo" at 67%,
+  // but the verb difference makes it a distinct criterion — flag as modified for review.
+  const ratio = best.overlap / orig;
+  const minAbsolute = Math.min(2, orig);
+  const preserved = ratio >= 0.75 && best.overlap >= minAbsolute;
+  return {
+    status: preserved ? 'preserved' : 'modified',
+    matchIdx: best.idx,
+    overlap: best.overlap,
+  };
+}
+
+/**
+ * Verify scope preservation by comparing current criteria to the original snapshot.
+ *
+ * @param {string} taskId
+ * @param {string[]} currentCriteria
+ * @returns {{ok: boolean, reason?: string, preserved: Array, modified: Array, dropped: Array, added: Array}}
+ */
+function verifyScopePreservation(taskId, currentCriteria) {
+  const snap = loadSnapshot(taskId);
+  if (!snap) return { ok: false, reason: `no snapshot for ${taskId}`, preserved: [], modified: [], dropped: [], added: [] };
+  if (!Array.isArray(currentCriteria)) {
+    return { ok: false, reason: 'currentCriteria must be an array', preserved: [], modified: [], dropped: [], added: [] };
+  }
+
+  const preserved = [];
+  const modified = [];
+  const dropped = [];
+  const matchedCurrentIdxs = new Set();
+
+  for (const orig of snap.criteria) {
+    const m = _matchCriterion(orig.text, currentCriteria);
+    if (m.status === 'preserved') {
+      preserved.push({ id: orig.id, text: orig.text, currentIdx: m.matchIdx });
+      matchedCurrentIdxs.add(m.matchIdx);
+    } else if (m.status === 'modified') {
+      modified.push({ id: orig.id, text: orig.text, currentIdx: m.matchIdx, currentText: currentCriteria[m.matchIdx], overlap: m.overlap });
+      matchedCurrentIdxs.add(m.matchIdx);
+    } else {
+      dropped.push({ id: orig.id, text: orig.text });
+    }
+  }
+
+  const added = currentCriteria
+    .map((text, idx) => ({ idx, text }))
+    .filter(({ idx }) => !matchedCurrentIdxs.has(idx))
+    .map(({ text }) => ({ text }));
+
+  // Detect collapse-merges: when two originals matched the same current index,
+  // the second original is effectively dropped (merged into the first).
+  const currentIdxCounts = {};
+  for (const p of preserved) currentIdxCounts[p.currentIdx] = (currentIdxCounts[p.currentIdx] || 0) + 1;
+  for (const m of modified) currentIdxCounts[m.currentIdx] = (currentIdxCounts[m.currentIdx] || 0) + 1;
+  const collapseDetected = Object.values(currentIdxCounts).some((n) => n > 1);
+
+  return {
+    ok: dropped.length === 0 && !collapseDetected,
+    collapseDetected,
+    preserved,
+    modified,
+    dropped,
+    added,
+  };
+}
+
+/**
+ * Format verification result as a human-readable checklist.
+ * @param {object} result - from verifyScopePreservation
+ * @param {string} [taskId]
+ * @returns {string}
+ */
+function formatChecklist(result, taskId = '') {
+  const lines = [];
+  lines.push(`━━━ AC Scope-Preservation Checklist${taskId ? ' — ' + taskId : ''} ━━━`);
+  for (const p of result.preserved) lines.push(`  ✓ ${p.id}: ${p.text.slice(0, 80)}`);
+  for (const m of result.modified) lines.push(`  ~ ${m.id}: ${m.text.slice(0, 80)}\n      → became: ${String(m.currentText).slice(0, 80)}`);
+  for (const d of result.dropped) lines.push(`  ✗ ${d.id}: ${d.text.slice(0, 80)}  [DROPPED — violates anti-deferral]`);
+  for (const a of result.added) lines.push(`  + new: ${String(a.text).slice(0, 80)}`);
+  lines.push(result.ok ? '  Status: OK — no criteria dropped' : `  Status: BLOCKED — ${result.dropped.length} criterion/criteria dropped`);
+  return lines.join('\n');
+}
+
+module.exports = {
+  snapshotCriteria,
+  loadSnapshot,
+  verifyScopePreservation,
+  formatChecklist,
+  SNAPSHOT_DIR,
+};
+
+// CLI
+if (require.main === module) {
+  const cmd = process.argv[2];
+  if (cmd === 'snapshot') {
+    const taskId = process.argv[3];
+    const criteria = process.argv.slice(4);
+    console.log(JSON.stringify(snapshotCriteria(taskId, criteria), null, 2));
+  } else if (cmd === 'verify') {
+    const taskId = process.argv[3];
+    const criteria = process.argv.slice(4);
+    const r = verifyScopePreservation(taskId, criteria);
+    console.log(formatChecklist(r, taskId));
+    process.exit(r.ok ? 0 : 1);
+  } else {
+    console.error('usage: flow-ac-scope-preservation snapshot <taskId> <criterion...>');
+    console.error('       flow-ac-scope-preservation verify <taskId> <criterion...>');
+    process.exit(2);
+  }
+}

package/scripts/flow-auto-review-worker.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Auto-Review Worker (detached child invoked by lib/worktree-review.js).
+ *
+ * Responsibilities:
+ *   1. Create an isolated worktree via flow-worktree.createWorktree.
+ *   2. Invoke the runReview() core on the worktree (heuristic reviewer).
+ *   3. Discard the worktree.
+ *
+ * Exit code is always 0 — findings are communicated via
+ * `.workflow/state/auto-review-findings.json`, not via exit status. The
+ * parent process has already unref()'d this child; nothing is watching stderr.
+ */
+
+const { runReview, writeFindings } = require('../lib/worktree-review');
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      out[key] = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true;
+    }
+  }
+  return out;
+}
+
+(async () => {
+  const args = parseArgs(process.argv.slice(2));
+  const taskId = args.task;
+  const repoRoot = args.repoRoot || process.cwd();
+
+  if (!taskId) {
+    process.exit(0);
+  }
+
+  let worktree = null;
+  try {
+    const { createWorktree, discardWorktree } = require('./flow-worktree');
+    worktree = await createWorktree({
+      taskId: `review-${taskId}`,
+      baseBranch: args.baseBranch || undefined,
+      repoRoot,
+    });
+
+    // Use the base branch for diff so the reviewer sees the task's changes.
+    const baseBranch = worktree.baseBranch || 'HEAD~1';
+    await runReview({
+      taskId,
+      worktreePath: worktree.path,
+      baseBranch,
+    });
+
+    try { await discardWorktree(worktree, { force: true }); } catch (_err) { /* noop */ }
+  } catch (err) {
+    writeFindings({
+      taskId,
+      status: 'error',
+      startedAt: new Date().toISOString(),
+      completedAt: new Date().toISOString(),
+      findings: [],
+      error: String(err.message || err),
+    });
+    if (worktree) {
+      try {
+        const { discardWorktree } = require('./flow-worktree');
+        await discardWorktree(worktree, { force: true });
+      } catch (_err) { /* noop */ }
+    }
+  }
+  // Normal exit.
+})();

package/scripts/flow-auto-review.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Wogi Flow — Auto-Review CLI (wf-8d635d0e / E1)
+ *
+ * Usage:
+ *   flow-auto-review.js start  --task <id> [--repoRoot <path>]
+ *   flow-auto-review.js status --task <id>
+ *   flow-auto-review.js await  --task <id> [--timeoutMs 90000]
+ */
+
+const { startReview, readFindings, awaitFindings, DEFAULT_TIMEOUT_MS } = require('../lib/worktree-review');
+const { getConfig } = require('./flow-utils');
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const key = a.slice(2);
+      out[key] = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : true;
+    }
+  }
+  return out;
+}
+
+function autoReviewEnabled() {
+  try {
+    const cfg = getConfig();
+    return cfg?.autoReview?.enabled === true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+function getTimeoutMs() {
+  try {
+    const cfg = getConfig();
+    const v = cfg?.autoReview?.timeoutMs;
+    return typeof v === 'number' && v > 0 ? v : DEFAULT_TIMEOUT_MS;
+  } catch (_err) {
+    return DEFAULT_TIMEOUT_MS;
+  }
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const args = parseArgs(rest);
+
+  if (!command) {
+    console.error('Usage: flow-auto-review.js <start|status|await> --task <id> [opts]');
+    process.exit(1);
+  }
+
+  if (command === 'start') {
+    if (!autoReviewEnabled()) {
+      // Silent no-op when disabled — matches flow-phase.js convention.
+      process.exit(0);
+    }
+    const taskId = args.task;
+    if (!taskId) {
+      console.error('flow-auto-review start requires --task <id>');
+      process.exit(1);
+    }
+    const repoRoot = args.repoRoot || process.cwd();
+    const handle = startReview({ taskId, repoRoot });
+    console.log(JSON.stringify({ ok: true, ...handle }));
+    return;
+  }
+
+  if (command === 'status') {
+    const taskId = args.task;
+    if (!taskId) {
+      console.error('flow-auto-review status requires --task <id>');
+      process.exit(1);
+    }
+    const rec = readFindings(taskId);
+    console.log(JSON.stringify(rec || { taskId, status: 'none' }, null, 2));
+    return;
+  }
+
+  if (command === 'await') {
+    const taskId = args.task;
+    if (!taskId) {
+      console.error('flow-auto-review await requires --task <id>');
+      process.exit(1);
+    }
+    const timeoutMs = args.timeoutMs ? parseInt(args.timeoutMs, 10) : getTimeoutMs();
+    const rec = await awaitFindings(taskId, timeoutMs);
+    console.log(JSON.stringify(rec, null, 2));
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${command}`);
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error(String(err.message || err));
+  process.exit(1);
+});

package/scripts/flow-autonomous-detector.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Autonomous-Mode Trigger Detector (Story C / wf-d712002e)
+ *
+ * Decides whether a user message activates autonomous walk-away mode.
+ *
+ * Strategy:
+ *   1. Phrase-match (fast, deterministic, free).
+ *   2. Optional Haiku classifier fallback for novel phrasings.
+ *   3. Fail-closed: classifier failure → NOT autonomous (interactive is the
+ *      safer default; users can re-trigger explicitly).
+ *
+ * Programmatic:
+ *   const d = require('./flow-autonomous-detector');
+ *   const r = d.detect(userMessage);              // { autonomous, trigger, source }
+ *   const r = await d.detectAsync(userMessage);   // includes classifier fallback
+ */
+
+const TRIGGER_PHRASES = [
+  'go until you finish',
+  'go until done',
+  'go until complete',
+  'work on all these',
+  'work through all of these',
+  'run this epic autonomously',
+  'run this autonomously',
+  "don't bother me, just do it",
+  "don't bother me",
+  'walk-away mode',
+  'walk away mode',
+  'autonomous mode',
+  'go ahead until done',
+  'just keep going until you finish',
+  'finish all of them',
+  'do them all without asking'
+];
+
+const STOP_PHRASES = [
+  'stop',
+  'pause',
+  'hold on',
+  'wait',
+  'cancel autonomous',
+  'exit autonomous',
+  'leave autonomous mode'
+];
+
+function normalize(s) {
+  return String(s || '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+function detect(message) {
+  const text = normalize(message);
+  if (!text) return { autonomous: false, source: 'empty' };
+
+  for (const phrase of TRIGGER_PHRASES) {
+    if (text.includes(phrase)) {
+      return { autonomous: true, trigger: phrase, source: 'phrase-match' };
+    }
+  }
+
+  return { autonomous: false, source: 'no-match' };
+}
+
+function detectStop(message) {
+  const text = normalize(message);
+  if (!text) return false;
+  return STOP_PHRASES.some(p => text === p || text.startsWith(p + ' ') || text.endsWith(' ' + p));
+}
+
+/**
+ * Async variant with optional Haiku classifier fallback.
+ * Caller injects the classifier (function returning {autonomous: boolean, confidence: number}).
+ * Fail-closed on any error.
+ */
+async function detectAsync(message, { aiClassifier = null, minConfidence = 0.7 } = {}) {
+  const fast = detect(message);
+  if (fast.autonomous) return fast;
+
+  if (typeof aiClassifier !== 'function') return fast;
+
+  try {
+    const result = await aiClassifier(message);
+    if (
+      result &&
+      typeof result === 'object' &&
+      result.autonomous === true &&
+      typeof result.confidence === 'number' &&
+      result.confidence >= minConfidence
+    ) {
+      return { autonomous: true, trigger: 'classifier-match', source: 'classifier', confidence: result.confidence };
+    }
+    return { autonomous: false, source: 'classifier-no-match' };
+  } catch (err) {
+    return { autonomous: false, source: 'classifier-error', error: err && err.message };
+  }
+}
+
+module.exports = {
+  TRIGGER_PHRASES,
+  STOP_PHRASES,
+  detect,
+  detectAsync,
+  detectStop,
+  normalize
+};
+
+if (require.main === module) {
+  const [,, ...rest] = process.argv;
+  const msg = rest.join(' ');
+  if (!msg) {
+    console.log('Usage: flow-autonomous-detector <message>');
+    process.exit(1);
+  }
+  const r = detect(msg);
+  console.log(JSON.stringify(r, null, 2));
+}

package/scripts/flow-autonomous-mode.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Autonomous Walk-Away Mode Orchestrator (Story C / wf-d712002e)
+ *
+ * Thin composition layer that ties together:
+ *   - flow-autonomous-detector  (NL trigger detection)
+ *   - flow-session-state         (disk-canonical activation flag)
+ *   - flow-question-queue        (queued questions + skipped tasks)
+ *   - flow-completion-summary    (terminal + JSON output)
+ *
+ * Responsibilities live in the underlying modules — this file only
+ * wires them. Hot-path hooks (PreToolUse) should NOT import this file;
+ * they should read the cache directly via flow-session-state.
+ *
+ * Programmatic:
+ *   const am = require('./flow-autonomous-mode');
+ *   const r = am.maybeActivateFromMessage(userMessage);
+ *   if (am.shouldDeactivate(userMessage)) am.finalize({ endReason: 'user-interrupt' });
+ *   am.finalize({ endReason: 'queue-drained' });
+ */
+
+const detector = require('./flow-autonomous-detector');
+const sessionState = require('./flow-session-state');
+const queue = require('./flow-question-queue');
+const completionSummary = require('./flow-completion-summary');
+
+/**
+ * Inspect a user message and activate autonomous mode if it matches a
+ * trigger phrase. No-op when already active. Returns the activation record
+ * (or `null` when no trigger).
+ */
+function maybeActivateFromMessage(message) {
+  if (sessionState.isAutonomousActive()) return sessionState.getAutonomousMode();
+  const r = detector.detect(message);
+  if (!r.autonomous) return null;
+  return sessionState.activateAutonomousMode({ trigger: r.trigger });
+}
+
+/**
+ * Check whether a user message should deactivate the active run
+ * (stop/pause/cancel etc.). Returns false when no autonomous run is
+ * active, regardless of message content.
+ */
+function shouldDeactivate(message) {
+  if (!sessionState.isAutonomousActive()) return false;
+  return detector.detectStop(message);
+}
+
+/**
+ * Render the completion summary, persist the JSON payload, then clear
+ * autonomous-mode state (cache + disk). The queue itself is preserved so
+ * the user can resolve queued questions in a later session — only the
+ * autonomous flag is cleared.
+ *
+ * @param {object} input
+ * @param {string} input.endReason - queue-drained | user-interrupt | fatal-error
+ * @param {Array} [input.completed]
+ */
+function finalize({ endReason = 'queue-drained', completed = [] } = {}) {
+  const mode = sessionState.getAutonomousMode();
+  const queueData = queue.loadQueue();
+  const startedAt = mode?.activatedAt || new Date().toISOString();
+  const adv = mode?.adversaryInvocations || { used: 0 };
+  const cap = sessionState.getAutonomousConfig().maxAdversaryInvocations;
+  const result = completionSummary.renderSummary({
+    runId: mode?.runId || `auto-finalize-${Date.now().toString(36)}`,
+    startedAt,
+    trigger: mode?.trigger || 'unspecified',
+    completed,
+    queuedQuestions: queueData.questions.filter(q => !q.answered),
+    skippedTasks: queueData.skippedTasks,
+    adversaryInvocations: { used: adv.used || 0, cap, breakdown: adv.breakdown || {} },
+    endReason
+  });
+
+  // Story B / wf-ab59f0e4: when the worker finalizes an autonomous run in
+  // workspace worker mode, post the COMPLETION-SUMMARY message to the
+  // manager channel. Best-effort — the run already finalized locally; if
+  // the manager is unreachable, the summary file on disk is still
+  // recoverable and the worker can be re-dispatched later.
+  if (process.env.WOGI_WORKSPACE_ROOT && process.env.WOGI_REPO_NAME && process.env.WOGI_REPO_NAME !== 'manager') {
+    try {
+      postSummaryToManager(result.payload);
+      result.posted = true;
+    } catch (err) {
+      result.posted = false;
+      result.postError = err.message;
+    }
+  }
+
+  if (mode) sessionState.deactivateAutonomousMode();
+  return result;
+}
+
+/**
+ * POST one or more COMPLETION-SUMMARY lines to the manager's channel-dispatch
+ * HTTP bus. Synchronous + best-effort — finalize() must not throw if the
+ * manager is unreachable.
+ */
+function postSummaryToManager(payload) {
+  const { execFileSync } = require('node:child_process');
+  const ws = require('./flow-workspace-summary');
+  const taskId = payload.completed?.[0]?.taskId || 'unknown';
+  const enriched = { ...payload, workerId: process.env.WOGI_REPO_NAME };
+  const lines = ws.encodeMessage(enriched);
+  const port = process.env.WOGI_MANAGER_PORT || '8800';
+  const repo = process.env.WOGI_REPO_NAME;
+  for (const line of lines) {
+    execFileSync('curl', [
+      '-s', '-X', 'POST',
+      `http://127.0.0.1:${port}`,
+      '-H', `X-Wogi-From: ${repo}`,
+      '-H', `X-Wogi-TaskId: ${taskId}`,
+      '--data-binary', line
+    ], { stdio: 'ignore', timeout: 5000 });
+  }
+}
+
+module.exports = {
+  maybeActivateFromMessage,
+  shouldDeactivate,
+  finalize
+};
+
+if (require.main === module) {
+  const [,, cmd, ...rest] = process.argv;
+  switch (cmd) {
+    case 'activate': {
+      const msg = rest.join(' ');
+      const r = maybeActivateFromMessage(msg);
+      console.log(JSON.stringify(r, null, 2));
+      break;
+    }
+    case 'finalize': {
+      const r = finalize({ endReason: rest[0] || 'queue-drained' });
+      console.log(r.terminal);
+      if (r.jsonPath) console.log(`\nJSON written: ${r.jsonPath}`);
+      break;
+    }
+    case 'status': {
+      const mode = sessionState.getAutonomousMode();
+      console.log(JSON.stringify({
+        active: sessionState.isAutonomousActive(),
+        mode,
+        config: sessionState.getAutonomousConfig()
+      }, null, 2));
+      break;
+    }
+    default:
+      console.log('Usage: flow-autonomous-mode <activate "<msg>"|finalize <reason>|status>');
+  }
+}

package/scripts/flow-best-of-n.js

@@ -19,7 +19,7 @@ const {
   getConfig,
   PATHS: _PATHS,
   readJson: _readJson,
-  validateTaskId
+  _validateTaskId
 } = require('./flow-utils');
 const { analyzeComplexity } = require('./flow-task-analyzer');