wogiflow 2.26.2 → 2.29.0

package/scripts/flow-config-defaults.js

@@ -165,7 +165,9 @@ const CONFIG_DEFAULTS = {
   projectName: '',
   cli: {
     type: 'claude-code',
-    autoSync: { enabled: false }
+    autoSync: { enabled: false },
+    generateAgentsMd: true,
+    _comment_generateAgentsMd: 'A1 (wf-a346c915): emit AGENTS.md (cross-tool standard used by Codex/Cline/Crush/Aider) alongside CLAUDE.md with identical content. CLAUDE.md remains canonical for drift detection. Set to false to skip AGENTS.md.'
   },
   scripts: { lint: null, typecheck: null, test: null, build: null, fix: null, coverage: null },
 
@@ -415,8 +417,19 @@ const CONFIG_DEFAULTS = {
       enabled: true,
       minConfidence: 70,
       model: 'anthropic:claude-3-5-haiku-latest'
+    },
+    _comment_toolFirstTurnGate: 'v2.27.0+ (epic wf-34290000, G1+G4+G6): In worker mode, blocks end-of-turn when the current turn (after UserPromptSubmit) had zero tool calls (silent-halt) or — in strict mode — began with a text block before any tool call (text-before-tool-call). Pure-text worker responses are invisible to the user (manager terminal only) and disqualify the three-state end-of-turn contract. Fail-open on transcript/parse/config errors. Set strict:false to allow narrate-then-act patterns (still blocks zero-tool-call turns).',
+    toolFirstTurnGate: {
+      enabled: true,
+      strict: true
     }
   },
+  _comment_mainModeQuestionClassifier: 'When true, task-boundary-reset runs a Haiku classifier on the final assistant message in main/solo mode before firing the restart. If the message ends by asking the user a question (detected semantically) AND pending-question.json is absent, the classifier auto-writes the marker and defers the restart — preventing the orphaned-question bug when the AI forgot to call `flow ask` manually. Mirrors workspace.aiWorkerQuestionClassifier. Fail-open: no ANTHROPIC_API_KEY / no transcript / model error → restart proceeds normally.',
+  mainModeQuestionClassifier: {
+    enabled: true,
+    minConfidence: 70,
+    model: 'anthropic:claude-3-5-haiku-latest'
+  },
   checkpoint: { enabled: false },
   regressionTesting: { enabled: false },
 
@@ -706,7 +719,17 @@ const CONFIG_DEFAULTS = {
   },
 
   // --- Session Features ---
-  morningBriefing: { enabled: false },
+  autonomousMode: {
+    // Story C / wf-d712002e — values consumed by flow-session-state.js
+    stalenessThresholdMs: 60 * 60 * 1000,
+    maxAdversaryInvocations: 30,
+    maxQueueSize: 100,
+    // Story E / wf-e28b6cd8 — cascade-after-decomposition strategy
+    // "auto"    → restart when autonomous mode is active, direct otherwise
+    // "direct"  → always same-session Skill invocation (zero latency)
+    // "restart" → always SIGTERM+marker cascade (fresh context per story)
+    cascadeStrategy: 'auto'
+  },
   techDebt: {
     enabled: false,
     promptOnSessionEnd: true,
@@ -825,7 +848,27 @@ const CONFIG_DEFAULTS = {
   // inherit the full reasoning pipeline. See .claude/docs/intent-grounded-reasoning.md.
   intentGroundedReasoning: {
     enabled: true,
-    _comment: 'IGR pipeline: architect + logic adversary + truth gate. See .claude/docs/intent-grounded-reasoning.md'
+    _comment: 'IGR pipeline: architect + logic adversary + truth gate. See .claude/docs/intent-grounded-reasoning.md',
+    logicAdversary: {
+      personas: {
+        enabled: true,
+        _comment: 'Persona-library amplifier for Logic Adversary (wf-258f558c). Auto-picks one of scale-skeptic | security-hawk | simplicity-champion | platform-rigor | user-advocate based on plan content. See .workflow/agents/personas/README.md.'
+      }
+    },
+    skepticalEvaluator: {
+      enabled: true,
+      _comment: 'Validating-phase field-enumeration evaluator (wf-15175dbc). Forces UI-field / API-parameter / state-key enumeration before "done" claims are accepted. See scripts/flow-skeptical-evaluator.js.'
+    }
+  },
+
+  // --- Aider-style Repo Map (wf-f3707d2f / C1) ---
+  // Auto-generated per task at Step 1 Load Context; refreshed per turn in
+  // explore + coding phases. Surfaces TOUCHED / ADJACENT / SHAPE sections
+  // within a bounded token budget. See scripts/flow-repo-map.js.
+  repoMap: {
+    enabled: true,
+    budgetBytes: 16384,
+    _comment: 'budgetBytes ≈ 4K tokens; raise for large tasks with many touched files, lower for cheap-model executors.'
   },
 
   // --- Research Reasoning Gate ---
@@ -930,7 +973,9 @@ const CONFIG_DEFAULTS = {
     _comment: 'Per-task context reset via wogi-claude wrapper. See lib/wogi-claude.',
     enabled: true,
     maxRestartsPerSession: 50,
-    _comment_maxRestartsPerSession: 'Safety cap. The wrapper also has WOGI_MAX_RESTARTS env override.'
+    _comment_maxRestartsPerSession: 'Safety cap. The wrapper also has WOGI_MAX_RESTARTS env override.',
+    autoPickupNextTask: true,
+    _comment_autoPickupNextTask: 'When true, after a clean task completion + restart, the next SessionStart injects an AUTO-PICKUP block instructing the AI to immediately invoke /wogi-start <nextReadyId> instead of asking "what\'s next?". Skipped if pending-question.json exists, ready queue is empty, or this flag is false.'
   },
 
   // --- Contract Surface (Teams-only — activated on wogi login) ---
@@ -1018,6 +1063,8 @@ const CONFIG_DEFAULTS = {
     },
     peer: { enabled: false },
     triage: { enabled: false },
+    evidenceTiers: { enabled: true, capByTier: true },
+    confidenceTiers: { enabled: true, rubricPath: '.workflow/rubrics/confidence-tiers.md' },
     agents: REVIEW_AGENTS
   },
 
@@ -1309,7 +1356,7 @@ function applyProjectTypeDefaults(config) {
   const detected = config.testing?.detected;
   if (!detected || !detected.projectType) return config;
 
-  const { hasUI, hasAPI, projectType } = detected;
+  const { hasUI, hasAPI, _projectType } = detected;
 
   // --- Adjust testing mode default ---
   if (config.testing?.mode === 'auto') {

package/scripts/flow-context-compact/expander.js

@@ -181,7 +181,7 @@ function expandForQuery(query, options = {}) {
   const lines = [];
   let totalTokens = 0;
 
-  for (const { id, node, tokens, score } of toExpand) {
+  for (const { id, node, tokens, _score } of toExpand) {
     markExpanded(id, tokens, `query: ${query.substring(0, 50)}`);
 
     lines.push(`### ${node.summary}`);

package/scripts/flow-context-compact/section-extractor.js

@@ -157,7 +157,7 @@ function selectNodes(tree, options = {}) {
   sectionScores.sort((a, b) => b.score - a.score);
 
   // Include sections based on score and budget
-  for (const { section, score, id } of sectionScores) {
+  for (const { section, score, _id } of sectionScores) {
     // Always include certain types
     const alwaysInclude = alwaysIncludeTypes.includes(section.type);
 
@@ -266,7 +266,7 @@ function formatSelectedContext(tree, selectedNodes) {
       node.children?.includes(d.node.id)
     );
 
-    for (const { node: child, includeContent, score: childScore } of sectionChildren) {
+    for (const { node: child, includeContent, score: _childScore } of sectionChildren) {
       lines.push(`- ${child.summary}`);
 
       if (includeContent && child.content) {

package/scripts/flow-context-gatherer.js

@@ -34,7 +34,7 @@ const {
   estimateTokens,
   info,
   warn: _warn,
-  success
+  _success
 } = require('./flow-utils');
 
 const {

package/scripts/flow-context-generator.js

@@ -633,7 +633,7 @@ function generateImportsMarkdown(imports) {
     '```typescript'
   ];
 
-  for (const [name, statement] of Object.entries(imports)) {
+  for (const [_name, statement] of Object.entries(imports)) {
     lines.push(statement);
   }
 

package/scripts/flow-context-scoring.js

@@ -176,7 +176,7 @@ function categorizeScore(score) {
  * @param {string} filePath - Path to file
  * @returns {number} Estimated tokens
  */
-function estimateFileTokens(filePath) {
+function _estimateFileTokens(filePath) {
   try {
     const content = fs.readFileSync(filePath, 'utf8');
     return estimateTokens(content, { useLineEstimate: true });

package/scripts/flow-correct.js

@@ -169,7 +169,7 @@ _Generated by \`flow correct\`_
 /**
  * Update feedback-patterns.md with the correction
  */
-function updateFeedbackPatterns(brief, _taskId, skillName) {
+function updateFeedbackPatterns(brief, _taskId, _skillName) {
   const date = getTodayDate();
 
   let content = readFile(PATHS.feedbackPatterns, '');

package/scripts/flow-decision-authority.js

@@ -31,7 +31,10 @@ const AUTHORITY_LEVELS = {
   'agent-decides': 'Agent decides autonomously, reports in completion summary',
   'agent-decides-report-after': 'Agent decides, explicitly reports the decision after',
   'owner-decides': 'Present to user, wait for answer before proceeding',
-  'auto-fix-report-after': 'Agent fixes automatically, reports what was fixed'
+  'auto-fix-report-after': 'Agent fixes automatically, reports what was fixed',
+  // Autonomous-mode buckets (Story C / wf-d712002e)
+  'queue-for-review': 'Autonomous mode: append to question queue, render in completion summary',
+  'adversary-loop': 'Autonomous mode: invoke self-adversarial challenge, then queue if still <90% confidence'
 };
 
 const DEFAULT_AUTHORITY_CONFIG = {
@@ -122,16 +125,55 @@ function getAuthorityConfig() {
 }
 
 /**
- * Classify a decision text into a category
+ * Resolve the autonomous flag. Caller may pass an explicit boolean to override
+ * the session-state lookup (used by tests and by call sites that already know
+ * the flag).
+ *
+ * Default: read from session-state cache via flow-session-state. The cache is
+ * populated by SessionStart rehydration, so hot-path callers do not pay for
+ * a disk read.
+ */
+function resolveAutonomous(autonomousArg) {
+  if (typeof autonomousArg === 'boolean') return autonomousArg;
+  try {
+    const { isAutonomousActive } = require('./flow-session-state');
+    return isAutonomousActive();
+  } catch (_err) {
+    return false;
+  }
+}
+
+/**
+ * Apply autonomous-mode overrides to a base authority decision.
+ * Applied AFTER the base classification so that batch-overflow only fires for
+ * decisions the autonomous override did not handle (Blocker 1 fix).
+ */
+function applyAutonomousOverride(baseAuthority, { category, confidence }) {
+  if (confidence === 'low') {
+    return 'adversary-loop';
+  }
+  if (baseAuthority === 'owner-decides') {
+    if (category === 'productBehavior' || category === 'ux') {
+      return 'queue-for-review';
+    }
+  }
+  return baseAuthority;
+}
+
+/**
+ * Classify a decision text into a category.
+ *
  * @param {string} decisionText - The decision to classify
+ * @param {object} [options]
+ * @param {boolean} [options.autonomous] - Force autonomous mode on/off. When
+ *   omitted, reads from session-state cache.
  * @returns {{ category: string, authority: string, confidence: string }}
  */
-function classifyDecision(decisionText) {
+function classifyDecision(decisionText, options = {}) {
   const authorityConfig = getAuthorityConfig();
-  // Patterns already use /i flag, no need for toLowerCase()
+  const autonomous = resolveAutonomous(options.autonomous);
   const text = decisionText;
 
-  // Score each category
   const scores = {};
   for (const [category, patterns] of Object.entries(CATEGORY_PATTERNS)) {
     scores[category] = 0;
@@ -142,8 +184,7 @@ function classifyDecision(decisionText) {
     }
   }
 
-  // Find highest scoring category
-  let bestCategory = 'productBehavior'; // Default to owner-decides (safest)
+  let bestCategory = 'productBehavior';
   let bestScore = 0;
 
   for (const [category, score] of Object.entries(scores)) {
@@ -153,21 +194,25 @@ function classifyDecision(decisionText) {
     }
   }
 
-  // Determine confidence
   const totalMatches = Object.values(scores).reduce((a, b) => a + b, 0);
   let confidence = 'low';
   if (bestScore >= 3) confidence = 'high';
   else if (bestScore >= 2) confidence = 'medium';
   else if (bestScore === 1 && totalMatches <= 2) confidence = 'medium';
 
-  // Low-confidence decisions default to owner-decides for safety
-  const authority = confidence === 'low'
+  const baseAuthority = confidence === 'low'
     ? 'owner-decides'
     : (authorityConfig[bestCategory] ?? 'owner-decides');
 
+  const authority = autonomous
+    ? applyAutonomousOverride(baseAuthority, { category: bestCategory, confidence })
+    : baseAuthority;
+
   return {
     category: bestCategory,
     authority,
+    baseAuthority,
+    autonomous,
     confidence,
     score: bestScore,
     description: AUTHORITY_LEVELS[authority] ?? 'Unknown authority level'
@@ -179,25 +224,26 @@ function classifyDecision(decisionText) {
  * @param {string[]} decisions - Array of decision texts
  * @returns {{ classified: Object[], ownerQuestions: Object[], agentDecisions: Object[], truncated: boolean }}
  */
-function batchClassify(decisions) {
+function batchClassify(decisions, options = {}) {
   const authorityConfig = getAuthorityConfig();
   const maxOwner = authorityConfig.maxOwnerQuestionsPerBatch ?? 5;
+  const autonomous = resolveAutonomous(options.autonomous);
 
+  // Autonomous routing is applied per-decision FIRST (Blocker 1 fix).
+  // Batch-overflow only fires for decisions still routed to owner-decides
+  // after the autonomous override pass.
   const classified = decisions.map((text, idx) => ({
     index: idx,
     text,
-    ...classifyDecision(text)
+    ...classifyDecision(text, { autonomous })
   }));
 
-  // Separate owner-decides from agent-decides
   const ownerQuestions = classified.filter(d => d.authority === 'owner-decides');
   const agentDecisions = classified.filter(d => d.authority !== 'owner-decides');
 
-  // Enforce max owner questions — overflow becomes agent-decides-report-after
   let truncated = false;
   if (ownerQuestions.length > maxOwner) {
     truncated = true;
-    // Keep the first maxOwner, downgrade the rest
     const overflow = ownerQuestions.splice(maxOwner);
     for (const decision of overflow) {
       decision.authority = 'agent-decides-report-after';
@@ -214,10 +260,13 @@ function batchClassify(decisions) {
     agentDecisions,
     truncated,
     maxOwner,
+    autonomous,
     stats: {
       total: decisions.length,
       ownerDecides: ownerQuestions.length,
       agentDecides: agentDecisions.length,
+      queued: classified.filter(d => d.authority === 'queue-for-review').length,
+      adversaryLoop: classified.filter(d => d.authority === 'adversary-loop').length,
       downgraded: truncated ? agentDecisions.filter(d => d.downgraded).length : 0
     }
   };
@@ -349,6 +398,8 @@ module.exports = {
   batchClassify,
   getAuthorityConfig,
   updateCategoryAuthority,
+  applyAutonomousOverride,
+  resolveAutonomous,
   AUTHORITY_LEVELS,
   DEFAULT_AUTHORITY_CONFIG,
   CATEGORY_PATTERNS

package/scripts/flow-done.js

@@ -74,7 +74,7 @@ const {
   allStoriesComplete: _allStoriesComplete, allFeaturesComplete: _allFeaturesComplete, allEpicsComplete: _allEpicsComplete,
   markFeatureComplete: _markFeatureComplete, markEpicComplete: _markEpicComplete, markPlanComplete: _markPlanComplete,
   archiveByType: _archiveByType, archiveCompletedParent: _archiveCompletedParent, cascadeCompletion,
-  CASCADE_MAX_DEPTH: _CASCADE_MAX_DEPTH, VALID_CASCADE_TYPES
+  CASCADE_MAX_DEPTH: _CASCADE_MAX_DEPTH, _VALID_CASCADE_TYPES
 } = require('./flow-cascade-completion');
 
 // v3.1 spec verification gate
@@ -715,6 +715,38 @@ async function main() {
     if (process.env.DEBUG) console.error(`[DEBUG] Clarification learning: ${err.message}`);
   }
 
+  // Auto-touch feature dossiers matching this completed task.
+  // Appends a Change Log row to every dossier whose match-patterns match
+  // the task title/description/files. Fail-open — never blocks completion.
+  try {
+    const { autoTouchFromTask } = require('./flow-feature-dossier');
+    // Widen window to catch multi-commit tasks. execFileSync avoids shell
+    // interpretation. Union of recent commits + uncommitted working tree.
+    const fileSet = new Set();
+    try {
+      const commits = execFileSync('git', ['log', '--name-only', '--pretty=format:', '-n', '10'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
+      commits.split('\n').map(s => s.trim()).filter(Boolean).forEach(f => fileSet.add(f));
+    } catch (_err) { /* no git / no history */ }
+    try {
+      const dirty = execFileSync('git', ['diff', '--name-only', 'HEAD'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] });
+      dirty.split('\n').map(s => s.trim()).filter(Boolean).forEach(f => fileSet.add(f));
+    } catch (_err) { /* noop */ }
+
+    const touchResult = autoTouchFromTask({
+      taskId,
+      title: result.task?.title || '',
+      description: result.task?.description || '',
+      type: result.task?.type || 'feat',
+      files: [...fileSet]
+    });
+    if (touchResult.touched && touchResult.touched.length > 0) {
+      const slugs = touchResult.touched.map(t => t.slug).join(', ');
+      console.log(color('cyan', `📒 Updated feature dossiers: ${slugs}`));
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[DEBUG] dossier auto-touch: ${err.message}`);
+  }
+
   // v1.7.0: Track task completion in session state and memory blocks
   // v3.2.1: Improved error handling - don't silently swallow failures
   try {

package/scripts/flow-epic-cascade.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Epic Decompose-and-Run Cascade (Story E / wf-e28b6cd8)
+ *
+ * After /wogi-start <epicId> completes decomposition, this helper picks
+ * what happens next:
+ *
+ *   Option A — direct same-session invocation
+ *     Returns `{ action: 'invoke-skill', taskId: <firstChild> }`. The
+ *     wogi-start prompt then immediately calls
+ *     Skill(skill="wogi-start", args=<firstChild>) in the SAME turn.
+ *     Pro: zero latency. Con: epic + first-story share context.
+ *
+ *   Option B — clean-completion-marker cascade (restart)
+ *     Writes the marker file with `nextTaskId` set, returns
+ *     `{ action: 'restart-with-marker' }`. SessionStart's AUTO-PICKUP
+ *     block reads the marker and starts the first child in a fresh
+ *     session. Pro: fresh context per story. Con: restart latency.
+ *
+ *   None — abort
+ *     `{ action: 'abort', reason }`. Caller emits a warning, ends turn.
+ *
+ * Strategy resolution:
+ *   - autonomousMode.cascadeStrategy: "auto" | "direct" | "restart"
+ *   - "auto" (default) → restart when autonomous mode active, direct
+ *     otherwise.
+ *   - "direct" → always Option A.
+ *   - "restart" → always Option B.
+ *
+ * Edge cases (Phase 4 of spec):
+ *   1. Epic decomposes to 0 stories → action='abort', reason='no-children'
+ *   2. Epic decomposes to 1 story → cascade normally
+ *   3. Epic has pre-existing child stories → no decomp, cascade to first
+ *   4. Worker mode → same mechanism (ready.json is member-repo-aware)
+ *   5. Cascade target missing/malformed → action='abort', reason='target-missing'
+ *
+ * Programmatic:
+ *   const cascade = require('./flow-epic-cascade');
+ *   const result = cascade.resolveCascade({ epicId });
+ *   // result: { action: 'invoke-skill' | 'restart-with-marker' | 'abort', taskId?, reason? }
+ *
+ * Note on AC1 (latency measurement): the spec calls for a 10-cycle
+ * wall-clock measurement of the SIGTERM/relaunch cycle. That cannot be
+ * meaningfully measured from inside a Node script — it requires
+ * instrumenting the wogi-claude wrapper across actual restarts. Captured
+ * as runtime-deferred; tracked under future test infrastructure.
+ */
+
+const { getConfig, getReadyData } = require('./flow-utils');
+const { writeCleanCompletionMarker } = require('./hooks/core/task-boundary-reset');
+
+const VALID_STRATEGIES = new Set(['auto', 'direct', 'restart']);
+
+function getCascadeStrategy() {
+  const cfg = getConfig().autonomousMode || {};
+  const raw = cfg.cascadeStrategy;
+  if (typeof raw === 'string' && VALID_STRATEGIES.has(raw)) return raw;
+  return 'auto';
+}
+
+function findEpicInQueue(epicId) {
+  const data = getReadyData();
+  const allLists = [data.ready, data.inProgress, data.blocked, data.recentlyCompleted].filter(Array.isArray);
+  for (const list of allLists) {
+    const found = list.find(t => t && t.id === epicId);
+    if (found) return found;
+  }
+  return null;
+}
+
+/**
+ * Resolve the first child story for an epic from the ready queue (children
+ * land in `data.ready` after decomposition). Skips epics; respects natural
+ * order so the first appended child wins.
+ *
+ * @param {string} epicId
+ * @returns {{taskId:string,title:string}|null}
+ */
+function resolveFirstChildStory(epicId) {
+  const data = getReadyData();
+  const queue = Array.isArray(data.ready) ? data.ready : [];
+  const candidate = queue.find(t =>
+    t && t.id !== epicId && t.parentEpic === epicId && t.type !== 'epic'
+  );
+  if (candidate) {
+    return { taskId: candidate.id, title: candidate.title || null };
+  }
+  // Fallback: read epic's stories array if parentEpic isn't set.
+  const epic = findEpicInQueue(epicId);
+  if (epic && Array.isArray(epic.stories) && epic.stories.length) {
+    for (const childId of epic.stories) {
+      const child = queue.find(t => t && t.id === childId && t.type !== 'epic');
+      if (child) return { taskId: child.id, title: child.title || null };
+    }
+  }
+  return null;
+}
+
+/**
+ * Decide and (for restart strategy) write the marker.
+ *
+ * @param {object} input
+ * @param {string} input.epicId
+ * @param {boolean} [input.autonomousActive] - Override the live session
+ *   flag (used by tests). Defaults to flow-session-state.isAutonomousActive().
+ * @returns {{action:string, taskId?:string, title?:string, reason?:string, strategy:string}}
+ */
+function resolveCascade({ epicId, autonomousActive, strategy: strategyOverride } = {}) {
+  if (!epicId) {
+    return { action: 'abort', reason: 'no-epic-id', strategy: 'auto' };
+  }
+
+  const child = resolveFirstChildStory(epicId);
+  if (!child) {
+    return { action: 'abort', reason: 'no-children', strategy: 'auto' };
+  }
+
+  const strategy = (typeof strategyOverride === 'string' && VALID_STRATEGIES.has(strategyOverride))
+    ? strategyOverride
+    : getCascadeStrategy();
+  let mode;
+  if (strategy === 'direct') {
+    mode = 'invoke-skill';
+  } else if (strategy === 'restart') {
+    mode = 'restart-with-marker';
+  } else {
+    let isAuto = autonomousActive;
+    if (typeof isAuto !== 'boolean') {
+      try {
+        isAuto = require('./flow-session-state').isAutonomousActive();
+      } catch (_err) { isAuto = false; }
+    }
+    mode = isAuto ? 'restart-with-marker' : 'invoke-skill';
+  }
+
+  if (mode === 'restart-with-marker') {
+    try {
+      writeCleanCompletionMarker(epicId, `Epic decomposed; cascade to ${child.taskId}`, {
+        nextTaskId: child.taskId
+      });
+    } catch (err) {
+      return {
+        action: 'abort',
+        reason: `marker-write-failed: ${err.message}`,
+        strategy
+      };
+    }
+  }
+
+  return { action: mode, taskId: child.taskId, title: child.title, strategy };
+}
+
+module.exports = {
+  getCascadeStrategy,
+  resolveFirstChildStory,
+  resolveCascade,
+  VALID_STRATEGIES: [...VALID_STRATEGIES]
+};
+
+if (require.main === module) {
+  const [,, cmd, arg] = process.argv;
+  if (cmd === 'resolve') {
+    const r = resolveCascade({ epicId: arg });
+    console.log(JSON.stringify(r, null, 2));
+  } else if (cmd === 'strategy') {
+    console.log(getCascadeStrategy());
+  } else {
+    console.log('Usage: flow-epic-cascade <resolve <epicId>|strategy>');
+  }
+}

package/scripts/flow-epics.js

@@ -79,10 +79,6 @@ function saveEpicsState(state) {
  * Load ready.json for task data
  * @returns {Object} Ready data
  */
-// loadReadyData replaced by canonical getReadyData from flow-utils (wf-7072d3ac / dup-007).
-// Kept as a thin shim for backward-compat of the module export at L812.
-function loadReadyData() { return getReadyData(); }
-
 // ============================================================
 // Epic File Operations
 // ============================================================
@@ -570,7 +566,7 @@ function updateEpicProgress(epicId) {
     return { error: `Epic ${epicId} not found` };
   }
 
-  const readyData = loadReadyData();
+  const readyData = getReadyData();
 
   let totalWeight = 0;
   let completedWeight = 0;
@@ -635,7 +631,7 @@ function buildHierarchyTree(epicId) {
   const epic = getEpic(epicId);
   if (!epic) return null;
 
-  const readyData = loadReadyData();
+  const readyData = getReadyData();
 
   const tree = {
     ...epic,
@@ -803,7 +799,6 @@ module.exports = {
   // State management
   loadEpicsState,
   saveEpicsState,
-  loadReadyData,
 
   // Epic operations
   createEpic,

package/scripts/flow-eval-judge.js

@@ -23,7 +23,7 @@ const {
   readJson: _readJson,
   writeJson: _writeJson,
   fileExists: _fileExists,
-  safeJsonParse
+  _safeJsonParse
 } = require('./flow-utils');
 
 // ============================================================

package/scripts/flow-eval.js

@@ -28,7 +28,7 @@ const {
   aggregateScores: _aggregateScores,
   getEvalConfig: _getEvalConfig,
   getJudgeComposition: _getJudgeComposition,
-  formatEvalResults
+  _formatEvalResults
 } = require('./flow-eval-judge');
 
 // ============================================================

package/scripts/flow-export-scanner.js

@@ -43,9 +43,6 @@ function getProjectRoot() {
   return PROJECT_ROOT;
 }
 
-// Alias getConfig as loadConfig for minimal code changes
-const loadConfig = getConfig;
-
 // ============================================================
 // Export Extraction
 // ============================================================
@@ -996,7 +993,7 @@ if (require.main === module) {
 
   if (!exportMap) {
     console.log('Scanning project exports...\n');
-    const config = loadConfig();
+    const config = getConfig();
     exportMap = buildExportMap(config);
     saveExportMapCache(exportMap);
   }
@@ -1041,6 +1038,5 @@ module.exports = {
   formatComponentWithUsage,
   // Configuration functions (for use as module)
   setProjectRoot,
-  getProjectRoot,
-  loadConfig
+  getProjectRoot
 };

package/scripts/flow-failure-learning.js

@@ -34,7 +34,7 @@ const {
   info,
   warn,
   success: _success,
-  error: logError,
+  error: _logError,
   parseFlags,
   outputJson,
   safeJsonParse