wogiflow 2.26.2 → 2.29.0

package/scripts/flow-standards-gate.js

@@ -23,7 +23,7 @@ const {
   runStandardsCheck,
   formatStandardsResults,
   collectReuseCandidates,
-  TASK_CHECK_MAP
+  _TASK_CHECK_MAP
 } = require('./flow-standards-checker');
 
 // Gate telemetry — records every invocation for self-assessment.

package/scripts/flow-statusline-setup.js

@@ -42,6 +42,11 @@ const FORMATS = {
     name: 'Detailed',
     description: 'Full info including skill and worktree',
     format: '{{#if workspace.git_worktree}}[WT] {{/if}}{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}% used{{#if skill}} | {{skill}}{{/if}}'
+  },
+  advanced: {
+    name: 'Advanced',
+    description: 'Detailed + effort level and thinking state (Claude Code 2.1.119+)',
+    format: '{{#if workspace.git_worktree}}[WT] {{/if}}{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}%{{#if effort.level}} | {{effort.level}}{{/if}}{{#if thinking.enabled}} | thinking{{/if}}{{#if skill}} | {{skill}}{{/if}}'
   }
 };
 
@@ -157,7 +162,7 @@ async function interactiveSetup() {
   showCurrentConfig();
   showFormats();
 
-  const format = await question(`\nChoose format (minimal/compact/standard/detailed) [standard]: `);
+  const format = await question(`\nChoose format (minimal/compact/standard/detailed/advanced) [standard]: `);
   const selectedFormat = format.trim() || 'standard';
 
   if (!FORMATS[selectedFormat]) {
@@ -226,6 +231,7 @@ Formats:
   compact   - Task ID + model + context %
   standard  - Task ID + model + labeled context (recommended)
   detailed  - Worktree + task + model + context % + skill
+  advanced  - Detailed + effort level + thinking state (Claude Code 2.1.119+)
 
 Refresh interval (Claude Code 2.1.97+):
   Re-runs the status line every N seconds so live values like task ID,
@@ -281,7 +287,7 @@ Examples:
   if (formatIndex >= 0) {
     const format = args[formatIndex + 1];
     if (!format || !FORMATS[format]) {
-      errorMsg('Invalid format. Use: minimal, compact, standard, or detailed');
+      errorMsg('Invalid format. Use: minimal, compact, standard, detailed, or advanced');
       process.exit(1);
     }
 

package/scripts/flow-step-changelog.js

@@ -26,7 +26,7 @@ const CHANGELOG_PATH = path.join(PATHS.root, 'CHANGELOG.md');
  * @returns {object} - { passed: boolean, message: string, entry?: string }
  */
 async function run(options = {}) {
-  const { taskId, taskTitle, taskType, files = [], mode, stepConfig = {} } = options;
+  const { taskId, taskTitle, taskType, files = [], mode, _stepConfig = {} } = options;
 
   // Determine changelog category
   const category = getChangelogCategory(taskType, taskTitle, files);
@@ -133,7 +133,7 @@ function getChangelogCategory(taskType, taskTitle, _files) {
 /**
  * Generate a changelog entry
  */
-function generateEntry(taskId, taskTitle, _category, files) {
+function generateEntry(taskId, taskTitle, _category, _files) {
   // Clean up title
   let entry = taskTitle || 'Update';
 

package/scripts/flow-step-coverage.js

@@ -31,7 +31,7 @@ const COVERAGE_PATHS = [
  * @returns {object} - { passed: boolean, message: string, coverage?: object }
  */
 async function run(options = {}) {
-  const { files = [], stepConfig = {}, mode } = options;
+  const { files = [], stepConfig = {}, _mode } = options;
   const minCoverage = stepConfig.minCoverage || 80;
   const checkFiles = stepConfig.checkModifiedOnly ?? true;
 

package/scripts/flow-step-knowledge.js

@@ -26,7 +26,7 @@ const KNOWLEDGE_DIR = path.join(PATHS.root, '.claude', 'docs', 'knowledge-base')
  * @returns {object} - { passed: boolean, message: string, suggestion?: string }
  */
 async function run(options = {}) {
-  const { taskId, taskTitle, files = [], mode, stepConfig = {}, learnings } = options;
+  const { _taskId, taskTitle, files = [], mode, _stepConfig = {}, learnings } = options;
 
   // Ensure knowledge base directory exists
   if (!fs.existsSync(KNOWLEDGE_DIR)) {

package/scripts/flow-step-regression.js

@@ -21,7 +21,7 @@ const { PATHS } = require('./flow-utils');
  * @returns {object} - { passed: boolean, message: string, details?: object }
  */
 async function run(options = {}) {
-  const { stepConfig = {}, mode } = options;
+  const { stepConfig = {}, _mode } = options;
   const sampleSize = stepConfig.sampleSize || 3;
 
   try {

package/scripts/flow-step-simplifier.js

@@ -308,7 +308,7 @@ function findDuplicationPatterns(content, fileName) {
   }
 
   // Report lines that appear 3+ times
-  for (const [pattern, lineNumbers] of Object.entries(patterns)) {
+  for (const [_pattern, lineNumbers] of Object.entries(patterns)) {
     if (lineNumbers.length >= 3) {
       suggestions.push({
         file: fileName,

package/scripts/flow-task-analyzer.js

@@ -355,7 +355,7 @@ function determineCapabilities(text, complexity) {
  * @returns {Object} Token estimates
  */
 function estimateTaskTokens(analysis) {
-  const { complexity, domains, languages } = analysis;
+  const { complexity, domains, _languages } = analysis;
 
   const multiplier = TOKEN_FACTORS.COMPLEXITY_MULTIPLIER[complexity.level];
   const baseInput = TOKEN_FACTORS.BASE_INPUT;

package/scripts/flow-task-classifier.js

@@ -176,7 +176,7 @@ function classifyTask(taskDescription, affectedFiles = [], _options = {}) {
     .sort((a, b) => b[1] - a[1]);
 
   const [topType, topScore] = sortedTypes[0];
-  const [secondType, secondScore] = sortedTypes[1] || ['none', 0];
+  const [_secondType, secondScore] = sortedTypes[1] || ['none', 0];
 
   // Calculate confidence
   let confidence = 'high';

package/scripts/flow-task-enforcer.js

@@ -752,7 +752,7 @@ function getLoopStats() {
  */
 function verifyCriterion(criterion, context = {}) {
   const { execSync, execFileSync } = require('node:child_process');
-  const { changedFiles = [], testResults = null, lintResults = null } = context;
+  const { _changedFiles = [], testResults = null, lintResults = null } = context;
   const _config = getConfig();
   const taskConfig = getTaskConfig();
   const desc = criterion.description;

package/scripts/flow-template-extractor.js

@@ -461,7 +461,7 @@ function getIndent(line) {
 async function extractTemplates(projectRoot, options = {}) {
   const {
     types = Object.keys(FILE_TYPES),
-    outputDir = path.join(projectRoot, '.workflow', 'templates', 'extracted')
+    _outputDir = path.join(projectRoot, '.workflow', 'templates', 'extracted')
   } = options;
 
   const startTime = Date.now();

package/scripts/flow-trap-zone.js

@@ -264,7 +264,7 @@ function parseTypeScript(file) {
     /(?:^|\n)\s*(?:export\s+)?(interface|class|type)\s+([A-Z]\w*)\b\s*(?:extends[^{]*|implements[^{]*|<[^>]*>\s*)?(?:=\s*)?(\{)/g;
   let m;
   while ((m = headerRegex.exec(content)) !== null) {
-    const [, kind, name, openBrace] = m;
+    const [, kind, name, _openBrace] = m;
     const bodyStart = m.index + m[0].length;
     const body = extractBalancedBlock(content, bodyStart - 1); // include the opening brace
     if (!body) continue;

package/scripts/flow-utils.js

@@ -262,6 +262,10 @@ function isValidWogiId(id) {
   if (/^wf-rv-[a-f0-9]{8}$/i.test(id)) return true;
   // Epic, feature, plan IDs
   if (/^(ep|ft|pl)-[a-f0-9]{8}$/i.test(id)) return true;
+  // Slug format: wf-<alphanum>[<alphanum or hyphen>]*<alphanum>, 5-64 chars.
+  // For manager-dispatched descriptive IDs. Path-safe (no dots/separators).
+  // Keep this in sync with validateTaskId() 'slug' branch in flow-id.js.
+  if (/^wf-[a-z0-9][a-z0-9-]{0,60}[a-z0-9]$/i.test(id)) return true;
   // Legacy format
   if (/^(TASK|BUG)-\d{3,}$/i.test(id)) return true;
   return false;

package/scripts/flow-worker-question-classifier.js

@@ -142,6 +142,36 @@ Examples:
 - "Task complete. Next: wf-abc12345 — starting now." → {"isUserQuestion": false, "confidence": 95, "reason": "action statement, no question"}`;
 }
 
+/**
+ * Build the main-mode classifier prompt. Used by the task-boundary-reset path
+ * in solo/main-mode sessions to detect when the AI forgot to call `flow ask`
+ * before ending a turn with a user-facing question. A YES classification
+ * auto-writes the pending-question marker and defers the restart.
+ *
+ * Same shape as buildClassifierPrompt — only the contextual framing differs.
+ */
+function buildMainModePrompt(lastMessage) {
+  return `You classify whether an AI assistant's final message to a SOLO (non-workspace) session ends by asking the USER a question that expects a user response.
+
+Context: in solo mode the session has a task-boundary session-restart feature. Before the restart fires, this classifier checks whether the AI is waiting on a user answer. If YES, the restart is deferred so the user's next reply lands in the same session context. The safety net exists because the AI should have called \`flow ask\` manually but sometimes forgets.
+
+Your job: classify YES only when the AI's final message contains an OPEN question the AI is waiting on the user to answer. Classify NO for rhetorical questions the AI answers itself, narrative descriptions, "here are your options" menus with the AI continuing after, or questions that have an accompanying decision.
+
+[MESSAGE_START]
+${String(lastMessage || '').slice(0, MAX_MESSAGE_CHARS)}
+[MESSAGE_END]
+
+Return JSON only, no prose, no markdown fences:
+{"isUserQuestion": true|false, "confidence": 0-100, "reason": "one short sentence"}
+
+Examples:
+- "Confirm this approach, or want a different split?" → {"isUserQuestion": true, "confidence": 95, "reason": "open confirm/alternate awaiting user"}
+- "Option 1 (rule only) or option 2 (classifier)?" → {"isUserQuestion": true, "confidence": 95, "reason": "binary choice awaiting user"}
+- "Did the tests pass? Yes, all 12 passed." → {"isUserQuestion": false, "confidence": 90, "reason": "rhetorical, answered inline"}
+- "Task complete. Moving to next task now." → {"isUserQuestion": false, "confidence": 95, "reason": "action statement, no question"}
+- "Implementation done — committing and pushing." → {"isUserQuestion": false, "confidence": 95, "reason": "action statement, no question"}`;
+}
+
 /**
  * Guard parsed JSON response against prototype pollution. Mirrors
  * flow-conclusion-classifier.hasDangerousKeys.
@@ -157,10 +187,11 @@ function hasDangerousKeys(value) {
 }
 
 /**
- * Classify the worker's last assistant message.
+ * Classify the assistant's last message in either worker or main mode.
  *
  * @param {Object} opts
  * @param {string} opts.transcriptPath - Absolute path to session JSONL transcript
+ * @param {'worker'|'main'} [opts.mode='worker'] - Which prompt framing to use
  * @param {number} [opts.minConfidence] - Confidence threshold (default 70)
  * @param {string} [opts.model] - Model override (default haiku)
  * @returns {Promise<{
@@ -168,10 +199,13 @@ function hasDangerousKeys(value) {
  *   isUserQuestion?: boolean,
  *   confidence?: number,
  *   reason?: string,
- *   lastMessage?: string
+ *   lastMessage?: string,
+ *   blocked?: boolean,
+ *   minConfidence?: number
  * }>}
  */
-async function classifyWorkerQuestion(opts = {}) {
+async function classifyQuestion(opts = {}) {
+  const mode = opts.mode === 'main' ? 'main' : 'worker';
   const minConfidence = Number.isFinite(opts.minConfidence) ? opts.minConfidence : DEFAULT_MIN_CONFIDENCE;
   const model = opts.model || DEFAULT_MODEL;
 
@@ -195,15 +229,19 @@ async function classifyWorkerQuestion(opts = {}) {
     return { classified: false, reason: 'no-model-caller' };
   }
 
+  const prompt = mode === 'main'
+    ? buildMainModePrompt(lastMessage)
+    : buildClassifierPrompt(lastMessage);
+
   let result;
   try {
-    result = await callModel(model, buildClassifierPrompt(lastMessage), {
+    result = await callModel(model, prompt, {
       temperature: TEMPERATURE,
       maxTokens: MAX_TOKENS
     });
   } catch (err) {
     if (process.env.DEBUG) {
-      console.error(`[worker-question-classifier] model call failed: ${err.message}`);
+      console.error(`[question-classifier:${mode}] model call failed: ${err.message}`);
     }
     return { classified: false, reason: 'model-error' };
   }
@@ -245,11 +283,19 @@ async function classifyWorkerQuestion(opts = {}) {
   };
 }
 
+// Preserve the original worker-mode export name for zero signature break.
+// New callers should prefer classifyQuestion({ mode }) directly.
+async function classifyWorkerQuestion(opts = {}) {
+  return classifyQuestion({ ...opts, mode: 'worker' });
+}
+
 module.exports = {
+  classifyQuestion,
   classifyWorkerQuestion,
   extractLastAssistantMessage,
   extractAssistantText,
   buildClassifierPrompt,
+  buildMainModePrompt,
   hasDangerousKeys,
   DEFAULT_MIN_CONFIDENCE,
   DEFAULT_MODEL

package/scripts/flow-workspace-migrate-ipc.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Workspace — IPC Migration / Re-Index (wf-3635574e / G3, AC4)
+ *
+ * One-shot + idempotent script that rebuilds the per-worker SQLite IPC index
+ * (under `.workspace/state/ipc/<repoName>/{inbound,outbound}.db`) from the
+ * authoritative JSON sources:
+ *
+ *   - `.workspace/messages/msg-*.json` (message bus)
+ *   - `.workspace/state/dispatched-tasks.json` (ring buffer — optional)
+ *
+ * Routing per message `from`/`to`:
+ *   from == 'manager'         → <to>/inbound.db
+ *   to   == 'manager'         → <from>/outbound.db
+ *   to   == 'all'             → <from>/outbound.db (broadcast)
+ *   worker → worker           → <to>/inbound.db (manager-brokered semantics)
+ *
+ * Idempotent: UPSERT on message id. Re-running scans all JSON again and
+ * re-writes, which is safe — consumed_at is preserved via COALESCE in the
+ * UPSERT path (see workspace-ipc-sqlite.js).
+ *
+ * Usage:
+ *   node scripts/flow-workspace-migrate-ipc.js <workspaceRoot> [--quiet]
+ *   node scripts/flow-workspace-migrate-ipc.js --help
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const ipc = require('../lib/workspace-ipc-sqlite');
+
+const USAGE = `Usage: flow-workspace-migrate-ipc.js <workspaceRoot> [--quiet]
+
+Rebuilds the SQLite IPC index from existing JSON message bus + dispatch
+tracking files. Safe to run repeatedly; does not delete JSON files.
+
+Options:
+  --quiet    Suppress per-file log output.
+  --help     Show this help.
+`;
+
+function log(quiet, ...args) {
+  if (!quiet) console.log(...args);
+}
+
+function parseArgs(argv) {
+  const args = { workspaceRoot: null, quiet: false, help: false };
+  for (const a of argv.slice(2)) {
+    if (a === '--help' || a === '-h') { args.help = true; continue; }
+    if (a === '--quiet' || a === '-q') { args.quiet = true; continue; }
+    if (!args.workspaceRoot) { args.workspaceRoot = a; continue; }
+  }
+  return args;
+}
+
+function safeReadJson(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch (_err) {
+    return null;
+  }
+}
+
+/**
+ * Decide which repo's DB and which direction an existing JSON message belongs to.
+ */
+function routeMessage(msg) {
+  const from = typeof msg.from === 'string' ? msg.from : '';
+  const to = typeof msg.to === 'string' ? msg.to : '';
+
+  if (from === 'manager' && to && to !== 'all' && to !== 'manager') {
+    return { repoName: to, direction: 'inbound' };
+  }
+  if (to === 'manager' && from) {
+    return { repoName: from, direction: 'outbound' };
+  }
+  if (to === 'all' && from && from !== 'manager') {
+    return { repoName: from, direction: 'outbound' };
+  }
+  if (from && to && from !== to) {
+    return { repoName: to, direction: 'inbound' };
+  }
+  return null;
+}
+
+function inferConsumedAt(msg) {
+  if (typeof msg.consumed_at === 'string') return msg.consumed_at;
+  if (typeof msg.consumedAt === 'string') return msg.consumedAt;
+  if (msg.status && msg.status !== 'pending') {
+    return msg.updatedAt || msg.resolvedAt || null;
+  }
+  return null;
+}
+
+async function migrateMessages(workspaceRoot, quiet) {
+  const messagesDir = path.join(workspaceRoot, '.workspace', 'messages');
+  if (!fs.existsSync(messagesDir)) {
+    log(quiet, `[migrate-ipc] No messages dir at ${messagesDir} — skipping.`);
+    return { scanned: 0, indexed: 0, skipped: 0 };
+  }
+
+  const files = fs.readdirSync(messagesDir).filter(f => f.endsWith('.json'));
+  let indexed = 0;
+  let skipped = 0;
+
+  for (const file of files) {
+    const filePath = path.join(messagesDir, file);
+    const msg = safeReadJson(filePath);
+    if (!msg || !msg.id) { skipped++; continue; }
+
+    const route = routeMessage(msg);
+    if (!route) { skipped++; continue; }
+
+    const kind = typeof msg.type === 'string' ? msg.type : 'unknown';
+    const ok = await ipc.indexMessage(workspaceRoot, route.repoName, route.direction, {
+      id: msg.id,
+      kind,
+      payload: msg,
+      createdAt: msg.timestamp || new Date().toISOString(),
+      consumedAt: inferConsumedAt(msg)
+    });
+
+    if (ok) {
+      indexed++;
+      log(quiet, `[migrate-ipc] indexed ${msg.id} → ${route.repoName}/${route.direction}.db (${kind})`);
+    } else {
+      skipped++;
+    }
+  }
+
+  return { scanned: files.length, indexed, skipped };
+}
+
+async function migrateDispatches(workspaceRoot, quiet) {
+  const dispatchPath = path.join(workspaceRoot, '.workspace', 'state', 'dispatched-tasks.json');
+  if (!fs.existsSync(dispatchPath)) {
+    log(quiet, `[migrate-ipc] No dispatched-tasks.json — skipping dispatch index.`);
+    return { scanned: 0, indexed: 0, skipped: 0 };
+  }
+
+  const state = safeReadJson(dispatchPath);
+  if (!state || !Array.isArray(state.dispatches)) {
+    return { scanned: 0, indexed: 0, skipped: 0 };
+  }
+
+  let indexed = 0;
+  let skipped = 0;
+
+  for (const rec of state.dispatches) {
+    if (!rec || !rec.taskId || !rec.repoName) { skipped++; continue; }
+
+    // Synthesize a stable message id from taskId + dispatchedAt.
+    const id = `disp-${rec.taskId}-${Date.parse(rec.dispatchedAt || '') || 0}`.substring(0, 80);
+
+    const ok = await ipc.indexMessage(workspaceRoot, rec.repoName, 'inbound', {
+      id,
+      kind: 'task-dispatch',
+      payload: rec,
+      createdAt: rec.dispatchedAt || new Date().toISOString(),
+      consumedAt: rec.reconciledAt || (rec.status && rec.status !== 'pending' ? new Date().toISOString() : null)
+    });
+
+    if (ok) indexed++;
+    else skipped++;
+  }
+
+  return { scanned: state.dispatches.length, indexed, skipped };
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) { console.log(USAGE); process.exit(0); }
+
+  const workspaceRoot = args.workspaceRoot
+    || process.env.WOGI_WORKSPACE_ROOT
+    || process.cwd();
+
+  if (!fs.existsSync(workspaceRoot)) {
+    console.error(`[migrate-ipc] Workspace root does not exist: ${workspaceRoot}`);
+    process.exit(2);
+  }
+
+  if (!(await ipc.isAvailable())) {
+    console.error(`[migrate-ipc] SQLite (sql.js) unavailable: ${ipc.unavailableReason()}`);
+    console.error(`[migrate-ipc] AC5 fallback active — JSON message bus will continue to serve reads/writes.`);
+    console.error(`[migrate-ipc] No migration performed.`);
+    process.exit(3);
+  }
+
+  log(args.quiet, `[migrate-ipc] workspaceRoot: ${workspaceRoot}`);
+  log(args.quiet, `[migrate-ipc] SQLite ready.`);
+
+  const msgRes = await migrateMessages(workspaceRoot, args.quiet);
+  log(args.quiet, `[migrate-ipc] messages: scanned=${msgRes.scanned} indexed=${msgRes.indexed} skipped=${msgRes.skipped}`);
+
+  const dispRes = await migrateDispatches(workspaceRoot, args.quiet);
+  log(args.quiet, `[migrate-ipc] dispatches: scanned=${dispRes.scanned} indexed=${dispRes.indexed} skipped=${dispRes.skipped}`);
+
+  await ipc.closeAll();
+
+  const repos = ipc.listIndexedRepos(workspaceRoot);
+  log(args.quiet, `[migrate-ipc] indexed repos: ${repos.join(', ') || '(none)'}`);
+  log(args.quiet, `[migrate-ipc] done.`);
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error('[migrate-ipc] FAILED:', err && err.stack ? err.stack : err);
+    process.exit(1);
+  });
+}
+
+module.exports = { routeMessage, migrateMessages, migrateDispatches };