wogiflow 2.0.1 → 2.1.0

package/.claude/commands/wogi-bulk.md

@@ -23,16 +23,31 @@ Execute multiple tasks in sequence, following all workflow rules.
 **Default behavior** (when `bulkOrchestrator.enabled: true`):
 
 1. **Build Execution Plan**:
-   - Detect dependencies between tasks
+   - Detect dependencies between tasks (parent→child, shared files, API contracts)
    - Group independent tasks into parallel batches
    - Order batches to respect dependencies
 
-2. **Execute Each Batch**:
+2. **Smart Ordering** (when `config.autoCompact.smartOrdering: true`):
+   Within each batch, order tasks to maximize context reuse:
+   - Analyze which files each task will likely touch (from spec, title, or task type)
+   - Group tasks that touch the same files/components together
+   - Execute related tasks consecutively to reuse loaded context
+   - Example: Tasks touching auth files → tasks touching UI files → tasks touching API files
+   - **Dependencies always take priority over context optimization**
+
+3. **Execute Each Batch**:
    - For each batch, spawn sub-agent(s) with **fresh context**
    - Independent tasks in same batch run in parallel
    - Dependent tasks wait for their dependencies
 
-3. **Pass-Forward Summaries**:
+4. **Auto-Compact Between Tasks** (when `config.autoCompact.betweenTasks: true`):
+   - After completing a task, check: does the NEXT task share context with this one?
+   - If YES (same files/components): keep context, proceed immediately
+   - If NO (different area of codebase): compact automatically before starting next task
+   - **Do NOT ask the user** — compact silently between tasks. This is automatic.
+   - This prevents context pollution and saves tokens on long batch runs
+
+5. **Pass-Forward Summaries**:
    - When Task A completes, generate completion summary
    - Task B (if dependent on A) receives summary as context
    - Ensures continuity without context pollution

package/.claude/commands/wogi-pending.md

@@ -0,0 +1,72 @@
+Manage the pending prompts queue — save requests for later while Claude is busy.
+
+**Triggers**: `/wogi-pending`, "save this for later", "add to pending"
+
+## Usage
+
+```bash
+/wogi-pending "fix the header alignment"   # Add item to queue
+/wogi-pending --list                       # Show all pending items
+/wogi-pending --clear 3                    # Remove item #3
+/wogi-pending --clear-all                  # Clear entire queue
+```
+
+## How It Works
+
+### Adding Items
+
+When invoked with a prompt string:
+1. Read `.workflow/state/pending-prompts.json`
+2. Append new item with auto-incrementing ID, prompt text, timestamp
+3. Save file
+4. Display: "Saved to pending queue (#N). Will process after current task completes."
+
+### Listing Items
+
+When invoked with `--list` or no args:
+1. Read pending-prompts.json
+2. Display numbered list with timestamps
+3. Show count: "N items pending"
+
+### Processing (Auto-triggered)
+
+After any task completes (via task-completed hook):
+1. Check if pending-prompts.json has items
+2. If yes, display:
+   ```
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   PENDING QUEUE (N items)
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+   1. "fix the header alignment" (added 15m ago)
+   2. "API returns 500 on empty input" (added 12m ago)
+   3. "wrong color on submit button" (added 8m ago)
+   ...
+
+   I've analyzed these items for dependencies and grouping:
+
+   Group A (related — header/UI fixes):
+     #1 fix header alignment
+     #3 wrong color on submit button
+     → Process together as one task
+
+   Group B (separate — API bug):
+     #2 API returns 500 on empty input
+     → Process as individual task
+
+   Proposed order: Group B first (bug fix), then Group A (UI)
+
+   Ready to start? [Y/adjust/skip]
+   ```
+3. User approves or adjusts
+4. Each group/item goes through `/wogi-start` individually
+
+### Key Principles
+
+- Items are NEVER compressed or merged without user approval
+- Each item preserves its original wording exactly
+- Grouping is suggested but user decides
+- Processing is one-at-a-time through /wogi-start (not one big batch)
+- The queue persists across sessions (saved to disk)
+
+ARGUMENTS: {args}

package/.claude/commands/wogi-start.md

@@ -16,7 +16,11 @@ When invoked with a **quoted request** instead of a task ID, assess intent and r
 
 ### Pre-Routing Checks (Automatic)
 
-**Long Input Detection**: If `config.longInputGate.enabled` and prompt > `lineThreshold` (60) lines, auto-invoke `/wogi-extract-review` instead of normal triage. Skip for task IDs or primarily-code prompts.
+**Long Input Detection**: If `config.longInputGate.enabled` and EITHER:
+- Prompt > `lineThreshold` (40) lines, OR
+- Prompt contains 5+ discrete items (numbered lists, bullet points, semicolon-separated requests)
+
+→ Auto-invoke `/wogi-extract-review` instead of normal triage. This ensures zero-loss extraction of every item. Skip for task IDs or primarily-code prompts.
 
 **Plugin Registry Routing**: After command catalog finds no match and `config.plugins.enabled`, check `.workflow/state/plugin-registry.json` for trigger phrase matches (score >= 0.5). Plugin routing has LOWER priority than built-in commands.
 
@@ -158,6 +162,36 @@ Before generating specs (skip for small tasks ≤2 files, bugfixes, explicit spe
 - Scope validation, assumption surfacing, edge cases, integration points
 - Config: `config.clarifyingQuestions`
 
+### Step 1.25: Item Reconciliation Gate (Multi-Item Inputs)
+
+**Activates when**: User input contains 3+ discrete requests (identified by: numbered lists, bullet points, "and also", "plus", semicolons separating requests, or distinct topics in voice-transcribed text).
+
+**Purpose**: Prevent item loss when the AI compresses many requests into fewer stories. This is the #1 cause of "silently dropped items" in long inputs.
+
+**Procedure**:
+1. **Enumerate**: Produce a numbered checklist of EVERY discrete request from the user's input. Each item = one testable action. No compression, no grouping, no summarization.
+2. **Confirm count**: Display the checklist and count: "I found N items in your request: [list]. Is this complete?"
+3. **Map to work items**: Each checklist item becomes a trackable acceptance criterion. Items may be grouped into stories, but EVERY item must appear as a criterion in at least one story. No item may be dropped during grouping.
+4. **Reconciliation check**: After stories/tasks are created, cross-reference: for each original checklist item, verify it appears in at least one acceptance criterion. If any item is missing → add it before proceeding.
+5. **At completion** (Step 3.5): The criteria verification must trace back to this original checklist. Every checklist item must be verified as implemented.
+
+**Example**:
+```
+User: "Fix the login page, add forgot password, remove mock data,
+       update the header logo, and add loading states to all forms"
+
+Item Reconciliation:
+  1. Fix the login page [→ Story A, criterion 1]
+  2. Add forgot password flow [→ Story A, criterion 2]
+  3. Remove all mock data [→ Story B, all criteria]
+  4. Update header logo [→ Story C, criterion 1]
+  5. Add loading states to all forms [→ Story C, criterion 2]
+
+  5 items found → 5 criteria across 3 stories → 0 items dropped ✓
+```
+
+**Skip when**: Input has only 1-2 items, or is a task ID reference.
+
 ### Step 1.3: Explore Phase (MANDATORY Multi-Agent Research)
 
 **For L2+ tasks. Research is MANDATORY** — do NOT skip even if you think you know the answer.
@@ -270,6 +304,31 @@ After implementing all scenarios, BEFORE quality gates:
 
 **This prevents "claiming done when not done."**
 
+### Step 3.55: Semantic Verification Pass (for "remove/fix all X" tasks)
+
+**Activates when**: The task involves removing, cleaning up, or fixing ALL instances of something (e.g., "remove all mock data", "fix all console.log", "replace all hardcoded URLs", "remove all deprecated APIs").
+
+**Purpose**: Pattern-based search (regex, grep) finds instances that match a naming pattern. But semantic variants — hardcoded values, helper functions that serve the same purpose, inline fallbacks — are invisible to pattern search. This pass catches what regex misses.
+
+**Procedure**:
+1. After the implementation agent completes, do NOT immediately mark the task as done
+2. Run a **second verification pass** that asks SEMANTICALLY, not syntactically:
+   - "Does any remaining code serve the purpose of [what we're removing]?"
+   - NOT: "Does any remaining code match the pattern [MOCK_*]?"
+3. For each type of removal, use type-specific semantic checks:
+
+| Removal Type | Semantic Check |
+|-------------|----------------|
+| Mock data | Scan render output for hardcoded business data (customer names, dollar amounts, percentages, dates that look like test data) |
+| Console.log | Scan for any debugging output (console.warn, console.debug, alert(), debugger statements) |
+| Hardcoded URLs | Scan for string literals containing http://, https://, localhost, IP addresses |
+| Deprecated APIs | Scan for the FUNCTIONALITY the API provided, not just its name |
+
+4. Use AI reasoning, NOT regex — the whole point is catching what regex misses
+5. Report any findings as additional criteria to fix before completion
+
+**Cross-cutting principle**: Pattern matching is for discovery. AI reasoning is for verification. The two-pass approach (pattern search → semantic verification) is the standard for any "fix all X" task.
+
 ### Step 3.6: Integration Wiring Validation (MANDATORY)
 
 Run `node node_modules/wogiflow/scripts/flow-wiring-verifier.js wf-XXXXXXXX`
@@ -356,7 +415,7 @@ Reflection: "Have I introduced any bugs or regressions?"
 
 **Quality gate keeps failing**: Report, attempt fix, after 3 failures suggest `/wogi-debug-hypothesis`.
 
-**Context too large**: Pre-task check handles proactively. Mid-task: commit progress, suggest `/wogi-compact`.
+**Context too large**: When `config.autoCompact.betweenTasks` is true (default), compact AUTOMATICALLY between tasks — do NOT ask the user. Just do it. Mid-task: commit progress, invoke `/wogi-compact` directly (don't suggest — execute).
 
 ## Mandatory Rules
 

package/.claude/commands/wogi-test.md

@@ -193,6 +193,12 @@ Determine which test types to run:
 | No flag | Run based on `config.testing.mode`: `ui`→UI only, `api`→API only, `full`→all 3, `auto`→detect and run applicable |
 
 #### Run UI Tests
+
+**Pre-check (MANDATORY)**: Before running UI tests, verify the testing tool is available. Do NOT skip this step — it prevents false-negative "not available" reports.
+
+1. If `config.testing.provider` is `playwright-mcp`: Call `ToolSearch("playwright")` to verify Playwright MCP tools are loaded. If tools are found → proceed. If not found → report "Playwright MCP not configured" (distinct from "no test files").
+
+2. Run the test script:
 ```bash
 node -e "
 const { runUITests } = require('./scripts/flow-test-ui');
@@ -200,6 +206,12 @@ runUITests('TASK_ID').then(r => console.log(JSON.stringify(r))).catch(err => con
 "
 ```
 
+3. **Interpret results separately**:
+   - Script returns `reason: 'no-test-files'` → "No test files found. Run `/wogi-test --generate` to create tests."
+   - MCP tools not available → "Playwright MCP not configured. Add it to `.claude/settings.json` MCP servers."
+   - Both → Show both facts separately, don't merge into one message.
+   - Script returns test results → show normally.
+
 #### Run API Tests
 ```bash
 node -e "

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

@@ -158,6 +158,7 @@ See `.claude/docs/commands.md` for complete command reference.
 | "audit project", "project audit", "full project analysis", "full analysis" | `/wogi-audit` |
 | "register plugin", "list plugins", "remove plugin", "register MCP" | `/wogi-register` |
 | "run tests", "test everything", "verify tests", "run the tests", "test this task", "check if it works" | `/wogi-test` |
+| "save for later", "add to pending", "queue this", "pending items", "show pending" | `/wogi-pending` |
 
 **IMPORTANT**: When a user's message matches one of these patterns, immediately invoke the Skill tool with the corresponding command. Do not ask for confirmation. These `/wogi-*` commands satisfy the mandatory routing requirement — you do NOT also need to invoke `/wogi-start` when a detection match exists. `/wogi-start` is the fallback for messages that don't match this table.
 

package/package.json

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

package/scripts/flow

@@ -600,6 +600,9 @@ case "${1:-}" in
                 ;;
         esac
         ;;
+    pending)
+        node "$SCRIPT_DIR/flow-pending.js" "${@:2}"
+        ;;
     queue)
         node "$SCRIPT_DIR/flow-queue.js" "${@:2}"
         ;;
@@ -1031,6 +1034,10 @@ case "${1:-}" in
         # Background task execution
         node "$SCRIPT_DIR/flow-background.js" "${@:2}"
         ;;
+    contract-scan)
+        # Contract surface scanner (teams feature)
+        node "$SCRIPT_DIR/flow-contract-scan.js" "${@:2}"
+        ;;
     version|--version|-v)
         show_version
         ;;

package/scripts/flow-config-defaults.js

@@ -684,7 +684,7 @@ const CONFIG_DEFAULTS = {
   longInputGate: {
     enabled: true,
     charThreshold: 3000,
-    lineThreshold: 60,
+    lineThreshold: 40,
     smartDefault: true,
     contentRules: { transcript: 'full', spec: 'full', requirements: 'full', code: 'skip', default: 'quick' },
     autoTriggerTypes: ['transcript', 'specs', 'requirements', 'feature-request'],
@@ -731,6 +731,33 @@ const CONFIG_DEFAULTS = {
     phases: ['exploring', 'spec_review', 'scenario', 'criteria_check', 'validating']
   },
 
+  // --- Damage Control ---
+  // --- Auto-Compact (context-aware task scheduling) ---
+  autoCompact: {
+    betweenTasks: true,
+    smartOrdering: true,
+    respectDependencies: true
+  },
+
+  // --- Contract Surface (Teams-only — activated on wogi login) ---
+  contractSurface: {
+    enabled: false,
+    projectType: 'auto',
+    scanOn: ['sessionStart', 'afterTask'],
+    scanners: {
+      httpClients: true,
+      routes: true,
+      events: true,
+      sharedTypes: true,
+      envVars: true
+    },
+    httpClientPatterns: ['axios', 'fetch', 'ky', '$fetch'],
+    routePatterns: ['express', 'fastify', 'hono', 'next-api'],
+    ignoreEndpoints: ['/health', '/metrics', '/favicon.ico'],
+    sharedPackages: [],
+    maxFiles: 500
+  },
+
   // --- Damage Control ---
   damageControl: {
     enabled: false,

package/scripts/flow-constants.js

@@ -132,8 +132,8 @@ const KNOWN_CONFIG_KEYS = [
   // Session management
   'metrics', 'requestLog', 'sessionState', 'smartCompaction',
   // Features (alphabetical)
-  'audit', 'bestOfN', 'bugFlow', 'capture',
-  'cascade', 'checkpoint', 'commits', 'community',
+  'audit', 'autoCompact', 'bestOfN', 'bugFlow', 'capture',
+  'cascade', 'checkpoint', 'commits', 'community', 'contractSurface',
   'damageControl', 'decide', 'decisions', 'epics', 'errorRecovery',
   'eval', 'figmaAnalyzer', 'finalization', 'gateConfidence', 'guidedEdit',
   'hooks', 'longInputGate', 'lsp', 'mandatorySteps', 'modelAdapters',

package/scripts/flow-contract-scan.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+'use strict';
+
+/**
+ * Wogi Flow - Contract Surface Scanner CLI
+ *
+ * TEAMS-ONLY feature: Scans a project's integration surface and generates
+ * contract-surface.json for the wogiflow-cloud orchestration agent.
+ *
+ * Usage:
+ *   flow contract-scan                    # Scan and save to default path
+ *   flow contract-scan --output <path>    # Custom output path
+ *   flow contract-scan --type backend     # Force project type
+ *   flow contract-scan --json             # Output JSON to stdout
+ *   flow contract-scan --verbose          # Show scan progress
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { getProjectRoot, getConfig } = require('./flow-utils');
+
+const PROJECT_ROOT = getProjectRoot();
+const DEFAULT_OUTPUT = path.join(PROJECT_ROOT, '.workflow', 'state', 'contract-surface.json');
+
+function parseArgs(args) {
+  const options = {
+    output: DEFAULT_OUTPUT,
+    type: null,
+    json: false,
+    verbose: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--output':
+      case '-o':
+        options.output = args[++i];
+        break;
+      case '--type':
+      case '-t':
+        options.type = args[++i];
+        break;
+      case '--json':
+        options.json = true;
+        break;
+      case '--verbose':
+      case '-v':
+        options.verbose = true;
+        break;
+      case '--help':
+      case '-h':
+        showHelp();
+        process.exit(0);
+    }
+  }
+
+  return options;
+}
+
+function showHelp() {
+  console.log(`
+Contract Surface Scanner
+
+Scans a project's integration surface (HTTP endpoints, events, shared types,
+environment variables) and generates contract-surface.json.
+
+Usage: flow contract-scan [options]
+
+Options:
+  --output, -o <path>   Output path (default: .workflow/state/contract-surface.json)
+  --type, -t <type>     Force project type (frontend|backend|fullstack|library|monorepo)
+  --json                Output JSON to stdout instead of saving to file
+  --verbose, -v         Show scan progress
+  --help, -h            Show this help
+
+Examples:
+  flow contract-scan                          # Scan with defaults
+  flow contract-scan --verbose                # Scan with progress output
+  flow contract-scan --json                   # Output to stdout
+  flow contract-scan --type backend --json    # Force type, output to stdout
+`);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  // Check teams config
+  const config = getConfig();
+  const contractConfig = config.contractSurface || {};
+
+  if (!contractConfig.enabled && !options.json) {
+    console.log('Contract surface scanning is not enabled.');
+    console.log('This feature activates when connected to a team (wogi login).');
+    console.log('');
+    console.log('To scan anyway, use: flow contract-scan --json');
+    process.exit(0);
+  }
+
+  // Lazy-load the scanner to keep startup fast
+  const { scanContracts } = require('./registries/contract-scanner');
+
+  const scanOptions = {
+    projectName: path.basename(PROJECT_ROOT),
+    projectType: options.type || contractConfig.projectType || undefined,
+    maxFiles: contractConfig.maxFiles || 500,
+    maxDepth: contractConfig.maxDepth || 6,
+    verbose: options.verbose
+  };
+
+  if (options.verbose) {
+    console.log(`Scanning ${PROJECT_ROOT}...`);
+    console.log('');
+  }
+
+  const surface = scanContracts(PROJECT_ROOT, scanOptions);
+
+  if (options.json) {
+    console.log(JSON.stringify(surface, null, 2));
+    return;
+  }
+
+  // Save to file
+  const outputDir = path.dirname(options.output);
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(options.output, JSON.stringify(surface, null, 2));
+
+  const relOutput = path.relative(PROJECT_ROOT, options.output);
+  console.log(`Contract surface saved to ${relOutput}`);
+  console.log('');
+  console.log('Summary:');
+  console.log(`  Project type:      ${surface.projectType}`);
+  console.log(`  Consumed endpoints: ${surface.endpoints.consumes.length}`);
+  console.log(`  Exposed endpoints:  ${surface.endpoints.exposes.length}`);
+  console.log(`  Event emits:        ${surface.events.emits.length}`);
+  console.log(`  Event listeners:    ${surface.events.listensTo.length}`);
+  console.log(`  Shared type imports:${surface.sharedTypes.imports.length}`);
+  console.log(`  Shared type exports:${surface.sharedTypes.exports.length}`);
+  console.log(`  Env vars required:  ${surface.environment.requires.length}`);
+  console.log(`  Env vars defined:   ${surface.environment.exposes.length}`);
+}
+
+main();

package/scripts/flow-pending.js

@@ -0,0 +1,153 @@
+'use strict';
+
+/**
+ * Wogi Flow - Pending Prompts Queue
+ *
+ * Manages a queue of user requests saved for later processing.
+ * Items are saved individually and processed after the current task completes.
+ *
+ * Usage:
+ *   flow pending add "prompt text"   # Add item to queue
+ *   flow pending list                # Show all pending items
+ *   flow pending clear [id]          # Clear specific item or all
+ *   flow pending count               # Get pending count
+ *   flow pending mark-processed <id> # Mark item as processed
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { PATHS, readJson, writeJson } = require('./flow-utils');
+
+const PENDING_PATH = path.join(PATHS.state, 'pending-prompts.json');
+
+/**
+ * Load pending queue from disk
+ * @returns {{ items: Array, nextId: number }}
+ */
+function loadPending() {
+  return readJson(PENDING_PATH, { items: [], nextId: 1 });
+}
+
+/**
+ * Save pending queue to disk
+ * @param {Object} data - Queue data
+ */
+function savePending(data) {
+  return writeJson(PENDING_PATH, data);
+}
+
+/**
+ * Add an item to the pending queue
+ * @param {string} prompt - The prompt text to queue
+ * @returns {Object} The created item
+ */
+function addItem(prompt) {
+  const data = loadPending();
+  const item = {
+    id: data.nextId || (data.items.length + 1),
+    prompt: prompt.trim(),
+    addedAt: new Date().toISOString(),
+    status: 'pending'
+  };
+  data.items.push(item);
+  data.nextId = (data.nextId || data.items.length) + 1;
+  savePending(data);
+  return item;
+}
+
+/**
+ * List all pending (non-processed) items
+ * @returns {Array} Pending items
+ */
+function listItems() {
+  const data = loadPending();
+  return data.items.filter(i => i.status === 'pending');
+}
+
+/**
+ * Remove a specific item by ID
+ * @param {number} id - Item ID to remove
+ * @returns {boolean} Whether the item was found and removed
+ */
+function clearItem(id) {
+  const data = loadPending();
+  const idx = data.items.findIndex(i => i.id === id);
+  if (idx === -1) return false;
+  data.items.splice(idx, 1);
+  savePending(data);
+  return true;
+}
+
+/**
+ * Clear all items from the queue
+ * @returns {boolean} Always true
+ */
+function clearAll() {
+  savePending({ items: [], nextId: 1 });
+  return true;
+}
+
+/**
+ * Get the count of pending (non-processed) items
+ * @returns {number}
+ */
+function getPendingCount() {
+  const data = loadPending();
+  return data.items.filter(i => i.status === 'pending').length;
+}
+
+/**
+ * Mark an item as processed
+ * @param {number} id - Item ID to mark
+ */
+function markProcessed(id) {
+  const data = loadPending();
+  const item = data.items.find(i => i.id === id);
+  if (item) {
+    item.status = 'processed';
+    item.processedAt = new Date().toISOString();
+    savePending(data);
+  }
+}
+
+// CLI entry point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (command === 'add') {
+    const prompt = args.slice(1).join(' ');
+    if (!prompt) {
+      console.error('Usage: flow pending add "prompt text"');
+      process.exit(1);
+    }
+    const item = addItem(prompt);
+    console.log(JSON.stringify({ success: true, item }));
+  } else if (command === 'list') {
+    const items = listItems();
+    console.log(JSON.stringify({ success: true, items, count: items.length }));
+  } else if (command === 'clear') {
+    const id = parseInt(args[1], 10);
+    if (isNaN(id)) {
+      clearAll();
+      console.log(JSON.stringify({ success: true, cleared: 'all' }));
+    } else {
+      const removed = clearItem(id);
+      console.log(JSON.stringify({ success: removed, cleared: id }));
+    }
+  } else if (command === 'count') {
+    console.log(JSON.stringify({ count: getPendingCount() }));
+  } else if (command === 'mark-processed') {
+    const id = parseInt(args[1], 10);
+    if (isNaN(id)) {
+      console.error('Usage: flow pending mark-processed <id>');
+      process.exit(1);
+    }
+    markProcessed(id);
+    console.log(JSON.stringify({ success: true, marked: id }));
+  } else {
+    console.log('Usage: flow pending [add|list|clear|count|mark-processed]');
+  }
+}
+
+module.exports = { addItem, listItems, clearItem, clearAll, getPendingCount, markProcessed, loadPending, savePending, PENDING_PATH };

package/scripts/flow-test-ui.js

@@ -576,7 +576,7 @@ async function runUITests(taskId, options = {}) {
   if (testFlows.length === 0) {
     const report = generateReport(
       taskId,
-      [{ name: 'No UI tests found', status: 'skipped', expected: [], found: [], missing: [], duration: 0 }],
+      [{ name: 'No UI test files found', status: 'skipped', reason: 'no-test-files', expected: [], found: [], missing: [], duration: 0, hint: 'Run /wogi-test --generate to create tests, or /wogi-test-browser for interactive browser testing' }],
       { checked: stateChecks, covered: [], missing: stateChecks },
       null
     );

package/scripts/hooks/core/task-completed.js

@@ -251,6 +251,19 @@ async function handleTaskCompleted(input) {
     } catch (_err) {
       // Non-critical - registry manager may not be available
     }
+    // Check pending queue — notify user if items are waiting
+    try {
+      const { getPendingCount } = require('../../flow-pending');
+      const pendingCount = getPendingCount();
+      if (pendingCount > 0) {
+        result.pendingQueue = {
+          count: pendingCount,
+          message: `You have ${pendingCount} pending item${pendingCount !== 1 ? 's' : ''} queued. Run /wogi-pending --list to review, or I'll process them next.`
+        };
+      }
+    } catch (_err) {
+      // Non-critical — pending module may not be available
+    }
   } catch (err) {
     result.message = `Task completed handler error: ${err.message}`;
   }