wogiflow 2.16.0 → 2.17.0

package/.workflow/templates/claude-md.hbs

@@ -274,6 +274,7 @@ When creating tasks programmatically, always call `generateTaskId(title)` — ne
 2. Registry maps (app-map, function-map, api-map, schema-map, service-map) are **auto-updated** by the `registryUpdate` quality gate — it runs `flow registry-manager scan` on all active registries
 3. Run quality gates (lint, typecheck, test)
 4. Provide completion report
+5. **If you have a follow-up question for the user** (e.g., "task done — should I also update X?"), run `flow ask "<your question>"` BEFORE the turn ends. This defers the task-boundary session restart (if enabled via `taskBoundaryReset.enabled`) so your question doesn't get orphaned when claude restarts. The user's response automatically clears the deferral.
 
 ## Auto-Validation (CRITICAL)
 

package/lib/workspace.js

@@ -18,6 +18,44 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+/**
+ * wf-f747f993 — resolve the claude-spawning command for workspace sessions.
+ *
+ * Policy (from spec wf-f747f993 S2):
+ *   - Worker sessions: prefer `wogi-claude` (the wogiflow restart wrapper)
+ *     when the wrapper file exists at its known package location. If
+ *     taskBoundaryReset.enabled is false (the default), the wrapper still
+ *     loops cleanly with no behavior change. If true, workers benefit from
+ *     per-task context resets.
+ *   - Manager sessions: always use `claude` directly. The manager coordinates
+ *     workers; restart-looping the manager would orchestrate-storm the whole
+ *     workspace.
+ *   - Fallback: if the wrapper file isn't found (unusual install), fall back
+ *     to `claude` silently.
+ *
+ * Detection: we resolve the wrapper by its location relative to this file
+ * (`__dirname/wogi-claude`) rather than `command -v` / PATH lookup, because
+ * workspace commands may execute without `node_modules/.bin` on PATH.
+ *
+ * @param {'manager'|'worker'} role
+ * @param {string} flags - the CLI flags to append
+ * @returns {string} the full shell command to exec
+ */
+function resolveClaudeSpawnCommand(role, flags) {
+  if (role === 'manager') {
+    return `claude ${flags}`;
+  }
+  // Worker — wrapper is shipped at lib/wogi-claude alongside this file
+  const wrapperPath = path.join(__dirname, 'wogi-claude');
+  try {
+    if (fs.existsSync(wrapperPath)) {
+      // Quote the path in case of spaces, use absolute path so it works regardless of PATH
+      return `"${wrapperPath}" ${flags}`;
+    }
+  } catch (_err) { /* fall through */ }
+  return `claude ${flags}`;
+}
+
 // ============================================================
 // Constants
 // ============================================================
@@ -1609,7 +1647,9 @@ function startWorkerSession(cwd) {
       };
 
       try {
-        execSync('claude --dangerously-skip-permissions --dangerously-load-development-channels server:wogi-workspace-channel', {
+        // Manager uses claude directly — see resolveClaudeSpawnCommand + wf-f747f993 S2.
+        const managerCmd = resolveClaudeSpawnCommand('manager', '--dangerously-skip-permissions --dangerously-load-development-channels server:wogi-workspace-channel');
+        execSync(managerCmd, {
           cwd,
           env,
           stdio: 'inherit'
@@ -1671,8 +1711,11 @@ function startWorkerSession(cwd) {
   // Launch Claude Code with experimental channel support enabled.
   // The --dangerously-load-development-channels flag makes Claude Code
   // surface notifications/claude/channel from the MCP server as prompts.
+  // Worker uses the wogi-claude wrapper when available (wf-f747f993) so
+  // task-boundary session restart works for workers if opted-in via config.
   try {
-    execSync('claude --dangerously-skip-permissions --dangerously-load-development-channels server:wogi-workspace-channel', {
+    const workerCmd = resolveClaudeSpawnCommand('worker', '--dangerously-skip-permissions --dangerously-load-development-channels server:wogi-workspace-channel');
+    execSync(workerCmd, {
       cwd,
       env,
       stdio: 'inherit'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow

@@ -516,6 +516,9 @@ case "${1:-}" in
     correct)
         node "$SCRIPT_DIR/flow-correct.js" "${@:2}"
         ;;
+    ask)
+        node "$SCRIPT_DIR/flow-ask.js" "${@:2}"
+        ;;
     aggregate)
         node "$SCRIPT_DIR/flow-aggregate.js" "${@:2}"
         ;;

package/scripts/flow-ask.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - `flow ask` CLI
+ *
+ * Mark that the AI has a pending question for the user. Suppresses the
+ * task-boundary session restart (wf-39e9dc09) until the user responds — so
+ * the AI can complete a task AND ask a follow-up without losing the question
+ * across the restart boundary.
+ *
+ * Usage:
+ *   flow ask "<question text>"
+ *
+ * Behavior:
+ *   Writes `.workflow/state/pending-question.json` with the question + timestamp.
+ *   The Stop hook's restart logic checks this file — if present, restart is deferred.
+ *   UserPromptSubmit clears the file when the user responds.
+ *
+ * When to call:
+ *   Any time the AI asks the user a question during or after a task. Especially
+ *   safe to call even when unsure — worst case, it just delays a restart by one
+ *   turn. Under-calling is the risk (orphaned question after restart).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { PATHS } = require('./flow-utils');
+
+const PENDING_QUESTION_FILE = 'pending-question.json';
+
+function getPendingQuestionPath() {
+  return path.join(PATHS.state, PENDING_QUESTION_FILE);
+}
+
+/**
+ * Write the pending-question marker.
+ *
+ * @param {string} question — question text (1-1000 chars)
+ * @returns {{ marked: boolean, path?: string, reason?: string }}
+ */
+function markQuestionPending(question) {
+  if (typeof question !== 'string' || question.trim().length === 0) {
+    return { marked: false, reason: 'empty-question' };
+  }
+  const trimmed = question.trim().slice(0, 1000);
+  try {
+    const p = getPendingQuestionPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({
+      version: 1,
+      question: trimmed,
+      askedAt: new Date().toISOString()
+    }, null, 2));
+    return { marked: true, path: p };
+  } catch (err) {
+    return { marked: false, reason: `write-failed: ${err.message}` };
+  }
+}
+
+/**
+ * Clear the pending-question marker (called from UserPromptSubmit).
+ *
+ * @returns {{ cleared: boolean, wasPresent: boolean }}
+ */
+function clearPendingQuestion() {
+  const p = getPendingQuestionPath();
+  if (!fs.existsSync(p)) return { cleared: true, wasPresent: false };
+  try {
+    fs.unlinkSync(p);
+    return { cleared: true, wasPresent: true };
+  } catch (err) {
+    return { cleared: false, wasPresent: true };
+  }
+}
+
+/**
+ * Check whether a pending-question marker exists.
+ *
+ * @returns {boolean}
+ */
+function hasPendingQuestion() {
+  try { return fs.existsSync(getPendingQuestionPath()); } catch (_e) { return false; }
+}
+
+module.exports = {
+  markQuestionPending,
+  clearPendingQuestion,
+  hasPendingQuestion,
+  getPendingQuestionPath
+};
+
+// CLI entry
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log('Usage: flow ask "<question text>"');
+    console.log('Marks a pending question; the restart mechanism will defer until');
+    console.log('the user responds (UserPromptSubmit clears the flag).');
+    process.exit(args.length === 0 ? 2 : 0);
+  }
+  if (args[0] === '--clear') {
+    const r = clearPendingQuestion();
+    console.log(JSON.stringify(r));
+    process.exit(0);
+  }
+  if (args[0] === '--check') {
+    console.log(JSON.stringify({ hasPendingQuestion: hasPendingQuestion() }));
+    process.exit(0);
+  }
+  const question = args.join(' ');
+  const r = markQuestionPending(question);
+  if (r.marked) {
+    console.log(`Pending question marked. Restart deferred until you respond.`);
+    console.log(`  File: ${r.path}`);
+    process.exit(0);
+  } else {
+    console.error(`Failed to mark: ${r.reason}`);
+    process.exit(1);
+  }
+}

package/scripts/flow-config-defaults.js

@@ -850,6 +850,16 @@ const CONFIG_DEFAULTS = {
     respectDependencies: true
   },
 
+  // --- Session Hydration (wf-729ab5c0) ---
+  // Controls how much session-episodic content (request-log entries, recent
+  // activity) gets injected into SessionStart's additionalContext. Rule-class
+  // files (decisions.md, app-map, etc.) are NOT affected — rules don't expire.
+  sessionHydration: {
+    _comment: 'Recency-based filter for SessionStart episodic-content injection. Complements wf-39e9dc09 task-boundary restart.',
+    recencyWindowHours: 48,
+    _comment_recencyWindowHours: 'Session-episodic entries older than this are excluded from hydration (still on disk, loadable via Read/Grep on demand). 0 = disable time filter (count-based limits still apply).'
+  },
+
   // --- Task-Boundary Session Restart (wf-39e9dc09) ---
   // EXPERIMENTAL, OPT-IN. When enabled AND the `wogi-claude` wrapper is running,
   // TaskCompleted triggers a clean restart of the Claude Code process so each

package/scripts/flow-constants.js

@@ -144,7 +144,9 @@ const KNOWN_CONFIG_KEYS = [
   // v2.0.0+ compat shim output keys
   'proactiveCompaction', 'communitySync',
   // Task-boundary session restart (wf-39e9dc09) — opt-in, experimental
-  'taskBoundaryReset'
+  'taskBoundaryReset',
+  // Session hydration recency filter (wf-729ab5c0)
+  'sessionHydration'
 ];
 
 module.exports = {

package/scripts/hooks/core/session-context.js

@@ -398,11 +398,33 @@ function getKeyDecisions(maxEntries = 5) {
  * @param {number} maxEntries - Max entries to return
  * @returns {Array} Recent activity
  */
+/**
+ * Get recency cutoff Date from config (wf-729ab5c0).
+ *
+ * Returns a Date object representing the boundary: entries with dates BEFORE
+ * this are considered "stale" for session-episodic hydration. Returns null
+ * when time filtering is disabled (recencyWindowHours <= 0).
+ *
+ * @returns {Date|null}
+ */
+function getRecencyCutoff() {
+  try {
+    const config = getConfig();
+    const hours = config.sessionHydration?.recencyWindowHours;
+    if (typeof hours !== 'number' || hours <= 0) return null;
+    return new Date(Date.now() - hours * 3600 * 1000);
+  } catch (_err) {
+    return null; // Safe degrade: no time filter if config read fails
+  }
+}
+
 function getRecentActivity(maxEntries = 3) {
   if (!fs.existsSync(PATHS.requestLog)) {
     return [];
   }
 
+  const recencyCutoff = getRecencyCutoff();
+
   try {
     // Wrap in try-catch per security-patterns.md Rule #1
     // Race conditions/permission changes can cause fs.readFileSync to fail even after existsSync
@@ -433,6 +455,18 @@ function getRecentActivity(maxEntries = 3) {
       if (!headerMatch) continue;
 
       const id = `R-${headerMatch[1]}`;
+      const dateStr = headerMatch[2];
+
+      // wf-729ab5c0 — recency filter.
+      // If a cutoff is configured AND this entry's date is parseable AND it
+      // predates the cutoff, skip it. If the date is unparseable, INCLUDE the
+      // entry (safe default: don't drop content we can't classify).
+      if (recencyCutoff) {
+        const entryDate = new Date(dateStr);
+        if (!isNaN(entryDate.getTime()) && entryDate < recencyCutoff) {
+          continue;
+        }
+      }
 
       // Extract request line
       // Length-capped capture to prevent ReDoS on crafted single-line entries
@@ -1108,6 +1142,7 @@ module.exports = {
   getPendingTaskSummary,
   getKeyDecisions,
   getRecentActivity,
+  getRecencyCutoff,
   getSessionState,
   gatherSessionContext,
   formatContextForInjection

package/scripts/hooks/core/task-boundary-reset.js

@@ -136,6 +136,16 @@ function consumeAndTriggerRestart() {
     return { triggered: false, reason: 'no-pending-marker' };
   }
 
+  // Defer restart when the AI has a pending question for the user
+  // (wf-729ab5c0 follow-up / pending-question safety).
+  // The marker STAYS — we'll try again next Stop hook after user responds.
+  try {
+    const { hasPendingQuestion } = require('../../flow-ask');
+    if (hasPendingQuestion()) {
+      return { triggered: false, reason: 'pending-question-deferred' };
+    }
+  } catch (_err) { /* flow-ask may not be present in older installs; degrade open */ }
+
   const pre = checkPreconditions();
   if (!pre.ready) {
     if (process.env.DEBUG) {

package/scripts/hooks/entry/claude-code/user-prompt-submit.js

@@ -27,6 +27,18 @@ runHook('UserPromptSubmit', async ({ input, parsedInput }) => {
   const prompt = parsedInput.prompt;
   const source = parsedInput.source;
 
+  // wf-729ab5c0 follow-up — clear pending-question marker on user response.
+  // This unblocks a deferred task-boundary restart. The AI may have asked a
+  // question via `flow ask "..."` after task completion; user's response
+  // releases the deferral, and the next Stop hook will fire the restart.
+  try {
+    const { clearPendingQuestion } = require('../../../flow-ask');
+    const r = clearPendingQuestion();
+    if (r.wasPresent && process.env.DEBUG) {
+      console.error(`[UserPromptSubmit] Cleared pending-question marker — restart deferral released`);
+    }
+  } catch (_err) { /* non-fatal */ }
+
   // v4.1: Detect skill commands that need execution tracking
   if (typeof prompt === 'string') {
     const skillMatch = prompt.match(/^\/(wogi-bulk|wogi-start)\b/i);