wogiflow 2.8.0 → 2.9.0

package/lib/workspace-gates.js

@@ -63,6 +63,12 @@ const WORKSPACE_GATES = [
     description: 'Verify integration map is up-to-date',
     phase: 'pre',
     severity: 'warning'
+  },
+  {
+    name: 'deploymentReadiness',
+    description: 'Verify changes are committed and pushed before handoff to downstream workers',
+    phase: 'post',
+    severity: 'error'
   }
 ];
 
@@ -434,6 +440,84 @@ function broadcastPostChange(workspaceRoot, fromRepo, context, options = {}) {
  * @param {Object} [taskMeta] — { taskId, taskTitle, changedFiles, impactAssessed }
  * @returns {{ passed: boolean, message: string, severity: string }}
  */
+/**
+ * Deployment readiness gate — verifies changes are committed and pushed
+ * before allowing handoff to downstream workers.
+ *
+ * In workspace mode, when backend completes and frontend needs to start,
+ * the backend's changes MUST be committed and pushed first. Otherwise the
+ * frontend worker will build against stale code.
+ *
+ * Checks:
+ * 1. No uncommitted changes in the current repo (git status clean)
+ * 2. Local branch is not ahead of remote (changes are pushed)
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} context
+ * @param {Object} taskMeta
+ * @returns {{ passed: boolean, message: string, severity: string }}
+ */
+function gateDeploymentReadiness(workspaceRoot, context, taskMeta) {
+  const { execFileSync } = require('node:child_process');
+
+  try {
+    // Check 1: No uncommitted changes
+    const statusOutput = execFileSync('git', ['status', '--porcelain'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: workspaceRoot || process.cwd()
+    }).trim();
+
+    if (statusOutput) {
+      const lineCount = statusOutput.split('\n').filter(Boolean).length;
+      return {
+        passed: false,
+        message: `${lineCount} uncommitted change(s). Commit and push before handoff to downstream workers.`,
+        severity: 'error'
+      };
+    }
+
+    // Check 2: Not ahead of remote (changes pushed)
+    try {
+      const aheadOutput = execFileSync('git', ['rev-list', '--count', '@{upstream}..HEAD'], {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: workspaceRoot || process.cwd()
+      }).trim();
+
+      const aheadCount = parseInt(aheadOutput, 10);
+      if (aheadCount > 0) {
+        return {
+          passed: false,
+          message: `${aheadCount} commit(s) not pushed to remote. Push before handoff to downstream workers.`,
+          severity: 'error'
+        };
+      }
+    } catch (_err) {
+      // No upstream configured — skip push check but warn
+      return {
+        passed: true,
+        message: 'No upstream branch configured — push check skipped',
+        severity: 'warning'
+      };
+    }
+
+    return {
+      passed: true,
+      message: 'Changes committed and pushed — ready for downstream handoff',
+      severity: 'info'
+    };
+  } catch (err) {
+    return {
+      passed: true,
+      message: `Deployment readiness check failed (${err.message}) — degraded to manual`,
+      severity: 'warning'
+    };
+  }
+}
+
 function runWorkspaceGate(gateName, workspaceRoot, context, taskMeta = {}) {
   switch (gateName) {
     case 'crossRepoImpactCheck':
@@ -451,6 +535,9 @@ function runWorkspaceGate(gateName, workspaceRoot, context, taskMeta = {}) {
     case 'integrationMapFreshness':
       return gateIntegrationMapFreshness(workspaceRoot);
 
+    case 'deploymentReadiness':
+      return gateDeploymentReadiness(workspaceRoot, context, taskMeta);
+
     default:
       return { passed: true, message: `Unknown gate: ${gateName}`, severity: 'warning' };
   }

package/lib/workspace-session.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Workspace — Manager Session Handoff
+ *
+ * The workspace manager doesn't have WogiFlow installed locally
+ * (it orchestrates, doesn't code). So /wogi-session-end fails.
+ *
+ * This module provides workspace-aware session management:
+ *   - saveManagerHandoff() — captures session state for next session
+ *   - loadManagerHandoff() — restores state at session start
+ *
+ * The handoff document (.workspace/state/manager-session.json) includes:
+ *   - Dispatched tasks summary (what was sent to which worker)
+ *   - Pending/completed workspace tasks
+ *   - Unread worker messages
+ *   - Active locks
+ *   - Last sync timestamp
+ *   - Session notes (what was discussed, decisions made)
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { WORKSPACE_CONFIG_FILE, WORKSPACE_DIR } = require('./workspace');
+
+// ============================================================
+// Manager Detection
+// ============================================================
+
+/**
+ * Detect if the current session is a workspace manager.
+ * The manager is the session running in the workspace root directory
+ * (where wogi-workspace.json lives), NOT in a member repo.
+ *
+ * @param {string} [cwd]
+ * @returns {{ isManager: boolean, workspaceRoot: string|null }}
+ */
+function isWorkspaceManager(cwd) {
+  const dir = cwd || process.cwd();
+  const configPath = path.join(dir, WORKSPACE_CONFIG_FILE);
+
+  if (fs.existsSync(configPath)) {
+    // Check this is the root, not a member repo that happens to have the config
+    // The manager's cwd IS the workspace root
+    return { isManager: true, workspaceRoot: dir };
+  }
+
+  return { isManager: false, workspaceRoot: null };
+}
+
+// ============================================================
+// Session Handoff — Save
+// ============================================================
+
+/**
+ * Save a manager session handoff document.
+ * Called when the manager session ends (or user says "wrap up").
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} [options]
+ * @param {string} [options.sessionNotes] — free-text notes about what was discussed
+ * @param {string[]} [options.decisionsM made] — decisions made during this session
+ * @returns {Object} the saved handoff document
+ */
+function saveManagerHandoff(workspaceRoot, options = {}) {
+  const handoff = {
+    savedAt: new Date().toISOString(),
+    workspaceName: '',
+    members: {},
+    dispatched: [],
+    pendingTasks: [],
+    completedTasks: [],
+    unreadMessages: [],
+    activeLocks: [],
+    contractDrifts: [],
+    lastSyncAt: null,
+    sessionNotes: options.sessionNotes || '',
+    decisions: options.decisions || []
+  };
+
+  // Read workspace config
+  const configPath = path.join(workspaceRoot, WORKSPACE_CONFIG_FILE);
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    handoff.workspaceName = config.name || '';
+
+    // Read each member's task status
+    for (const [name, memberConfig] of Object.entries(config.members || {})) {
+      const memberPath = path.resolve(workspaceRoot, memberConfig.path);
+      const readyPath = path.join(memberPath, '.workflow', 'state', 'ready.json');
+
+      const memberStatus = {
+        role: memberConfig.role,
+        inProgress: [],
+        ready: [],
+        recentlyCompleted: []
+      };
+
+      try {
+        if (fs.existsSync(readyPath)) {
+          const ready = JSON.parse(fs.readFileSync(readyPath, 'utf-8'));
+          memberStatus.inProgress = (ready.inProgress || []).map(t => ({ id: t.id, title: t.title }));
+          memberStatus.ready = (ready.ready || []).map(t => ({ id: t.id, title: t.title }));
+          memberStatus.recentlyCompleted = (ready.recentlyCompleted || []).slice(0, 5).map(t => ({ id: t.id, title: t.title }));
+        }
+      } catch (_err) {
+        // Non-critical
+      }
+
+      handoff.members[name] = memberStatus;
+    }
+  } catch (_err) {
+    // Config read failure — save what we can
+  }
+
+  // Read workspace-level tasks
+  const wsReadyPath = path.join(workspaceRoot, WORKSPACE_DIR, 'state', 'ready.json');
+  try {
+    if (fs.existsSync(wsReadyPath)) {
+      const wsReady = JSON.parse(fs.readFileSync(wsReadyPath, 'utf-8'));
+      handoff.pendingTasks = (wsReady.ready || []).map(t => ({ id: t.id, title: t.title }));
+      handoff.completedTasks = (wsReady.recentlyCompleted || []).slice(0, 10).map(t => ({ id: t.id, title: t.title }));
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+
+  // Read unread messages
+  try {
+    const messagesDir = path.join(workspaceRoot, WORKSPACE_DIR, 'messages');
+    if (fs.existsSync(messagesDir)) {
+      const files = fs.readdirSync(messagesDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        try {
+          const msg = JSON.parse(fs.readFileSync(path.join(messagesDir, file), 'utf-8'));
+          if (msg.status === 'pending') {
+            handoff.unreadMessages.push({
+              id: msg.id,
+              from: msg.from,
+              type: msg.type,
+              subject: msg.subject,
+              timestamp: msg.timestamp
+            });
+          }
+        } catch (_err) {
+          // Skip malformed
+        }
+      }
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+
+  // Read active locks
+  try {
+    const locksDir = path.join(workspaceRoot, WORKSPACE_DIR, 'state', 'locks');
+    if (fs.existsSync(locksDir)) {
+      const now = Date.now();
+      const files = fs.readdirSync(locksDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        try {
+          const lock = JSON.parse(fs.readFileSync(path.join(locksDir, file), 'utf-8'));
+          if (new Date(lock.expiresAt).getTime() > now) {
+            handoff.activeLocks.push({
+              interface: lock.interface,
+              owner: lock.owner,
+              expiresAt: lock.expiresAt
+            });
+          }
+        } catch (_err) {
+          // Skip
+        }
+      }
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+
+  // Check manifest freshness
+  const manifestPath = path.join(workspaceRoot, WORKSPACE_DIR, 'state', 'workspace-manifest.json');
+  try {
+    if (fs.existsSync(manifestPath)) {
+      const stat = fs.statSync(manifestPath);
+      handoff.lastSyncAt = stat.mtime.toISOString();
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+
+  // Write the handoff document
+  const handoffPath = path.join(workspaceRoot, WORKSPACE_DIR, 'state', 'manager-session.json');
+  fs.mkdirSync(path.dirname(handoffPath), { recursive: true });
+  fs.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2));
+
+  return handoff;
+}
+
+// ============================================================
+// Session Handoff — Load (for session start)
+// ============================================================
+
+/**
+ * Load the previous manager session handoff.
+ * Called at session start to restore context.
+ *
+ * @param {string} workspaceRoot
+ * @returns {Object|null} handoff document or null if none exists
+ */
+function loadManagerHandoff(workspaceRoot) {
+  const handoffPath = path.join(workspaceRoot, WORKSPACE_DIR, 'state', 'manager-session.json');
+
+  try {
+    if (fs.existsSync(handoffPath)) {
+      return JSON.parse(fs.readFileSync(handoffPath, 'utf-8'));
+    }
+  } catch (_err) {
+    // Non-critical
+  }
+
+  return null;
+}
+
+/**
+ * Format the handoff document as a readable session start briefing.
+ *
+ * @param {Object} handoff — from loadManagerHandoff()
+ * @returns {string} formatted briefing
+ */
+function formatHandoffBriefing(handoff) {
+  if (!handoff) return 'No previous session handoff found.';
+
+  const lines = [];
+  const age = Math.round((Date.now() - new Date(handoff.savedAt).getTime()) / (60 * 60 * 1000));
+
+  lines.push('Previous Session Handoff');
+  lines.push('━'.repeat(40));
+  lines.push(`Saved: ${handoff.savedAt} (${age}h ago)`);
+  lines.push(`Workspace: ${handoff.workspaceName}`);
+  lines.push('');
+
+  // Member status
+  lines.push('Member Status:');
+  for (const [name, status] of Object.entries(handoff.members || {})) {
+    const inProgress = status.inProgress?.length || 0;
+    const ready = status.ready?.length || 0;
+    lines.push(`  ${name} (${status.role}): ${inProgress} in-progress, ${ready} ready`);
+    for (const t of status.inProgress || []) {
+      lines.push(`    >> ${t.id}: ${t.title}`);
+    }
+  }
+  lines.push('');
+
+  // Unread messages
+  if (handoff.unreadMessages?.length > 0) {
+    lines.push(`Unread Messages (${handoff.unreadMessages.length}):`);
+    for (const msg of handoff.unreadMessages) {
+      lines.push(`  [${msg.type}] from ${msg.from}: ${msg.subject}`);
+    }
+    lines.push('');
+  }
+
+  // Active locks
+  if (handoff.activeLocks?.length > 0) {
+    lines.push(`Active Locks (${handoff.activeLocks.length}):`);
+    for (const lock of handoff.activeLocks) {
+      lines.push(`  ${lock.interface} — held by ${lock.owner} (expires: ${lock.expiresAt})`);
+    }
+    lines.push('');
+  }
+
+  // Session notes
+  if (handoff.sessionNotes) {
+    lines.push('Session Notes:');
+    lines.push(`  ${handoff.sessionNotes}`);
+    lines.push('');
+  }
+
+  // Decisions
+  if (handoff.decisions?.length > 0) {
+    lines.push('Decisions Made:');
+    for (const d of handoff.decisions) {
+      lines.push(`  - ${d}`);
+    }
+    lines.push('');
+  }
+
+  // Manifest freshness
+  if (handoff.lastSyncAt) {
+    const syncAge = Math.round((Date.now() - new Date(handoff.lastSyncAt).getTime()) / (60 * 60 * 1000));
+    lines.push(`Last sync: ${syncAge}h ago${syncAge > 24 ? ' (STALE — run flow workspace sync)' : ''}`);
+  }
+
+  return lines.join('\n');
+}
+
+// ============================================================
+// Exports
+// ============================================================
+
+module.exports = {
+  isWorkspaceManager,
+  saveManagerHandoff,
+  loadManagerHandoff,
+  formatHandoffBriefing
+};

package/lib/workspace.js

@@ -575,9 +575,45 @@ ${memberLines.join('\n')}
 ## Session Startup Checklist
 
 When you start a session, do this FIRST:
-1. Read \`.workspace/state/workspace-manifest.json\` — understand the current integration map
-2. Check \`.workspace/messages/\` for unread messages (status: "pending") — show them to the user
-3. Read each member's \`.workflow/state/ready.json\` — know what tasks are in progress
+1. **Check for previous session handoff**: Read \`.workspace/state/manager-session.json\` if it exists — this tells you what happened in the last session, what's pending, and what the user was working on. Display the briefing to the user.
+2. Read \`.workspace/state/workspace-manifest.json\` — understand the current integration map
+3. Check \`.workspace/messages/\` for unread messages (status: "pending") — show them to the user
+4. Read each member's \`.workflow/state/ready.json\` — know what tasks are in progress
+5. If manifest is stale (>24h): suggest \`flow workspace sync\`
+
+## Session End (Manager Handoff)
+
+When the user says "wrap up", "session end", "that's all":
+
+**You are the workspace manager — you don't have /wogi-session-end.** Instead, save a handoff document:
+
+1. **Collect session state**:
+   - What tasks were dispatched to which workers (and their status)
+   - Current state of each member's ready.json (in-progress, ready, completed)
+   - Unread messages from workers
+   - Active locks on shared interfaces
+   - Manifest freshness (when was last sync?)
+
+2. **Ask the user**: "Any session notes or decisions to carry forward?"
+
+3. **Save handoff** to \`.workspace/state/manager-session.json\`:
+\`\`\`bash
+# Read current workspace state and save
+cat .workspace/state/workspace-manifest.json | head -5  # Check freshness
+ls -t .workspace/messages/*.json 2>/dev/null | head -10   # Unread messages
+\`\`\`
+
+4. **Write the JSON handoff** with: savedAt, members (per-repo task status), unreadMessages, activeLocks, sessionNotes, decisions, lastSyncAt
+
+5. **Display session summary**:
+\`\`\`
+Session Summary:
+  Dispatched: N tasks to M repos
+  Completed: N tasks
+  Pending: N messages, N locks
+  Handoff saved to: .workspace/state/manager-session.json
+  Next session will resume from this point.
+\`\`\`
 
 ## How to Route Tasks
 

package/package.json

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

package/scripts/flow-config-defaults.js

@@ -161,6 +161,7 @@ const RESEARCH_TRIGGERS = {
 const CONFIG_DEFAULTS = {
   // --- Core ---
   version: '2.0.0',
+  _configVersion: 2, // Tracks config schema version for migrations (see flow-config-migrate.js)
   projectName: '',
   cli: {
     type: 'claude-code',
@@ -172,6 +173,7 @@ const CONFIG_DEFAULTS = {
   enforcement: {
     strictMode: true,
     requireTaskForImplementation: true,
+    requireGateLatch: true, // Gate latch: quality gates must pass before TaskCompleted allows completion
     requirePatternCitation: false,
     citationFormat: '// Pattern: {pattern}',
     blockAutoTask: true,
@@ -300,11 +302,11 @@ const CONFIG_DEFAULTS = {
   qualityGates: {
     preTaskBaseline: { enabled: false },
     feature: {
-      require: ['loopComplete', 'tests', 'generatedTestsPass', 'uiVerification', 'apiVerification', 'registryUpdate', 'requestLogEntry', 'integrationWiring', 'standardsCompliance'],
+      require: ['loopComplete', 'tests', 'generatedTestsPass', 'uiVerification', 'apiVerification', 'verificationProof', 'registryUpdate', 'requestLogEntry', 'integrationWiring', 'standardsCompliance'],
       optional: ['review', 'docs', 'webmcpVerification']
     },
     bugfix: {
-      require: ['loopComplete', 'tests', 'generatedTestsPass', 'requestLogEntry', 'standardsCompliance'],
+      require: ['loopComplete', 'tests', 'generatedTestsPass', 'verificationProof', 'requestLogEntry', 'standardsCompliance'],
       optional: ['learningEnforcement', 'resolutionPopulated', 'review', 'webmcpVerification']
     },
     refactor: {
@@ -327,7 +329,7 @@ const CONFIG_DEFAULTS = {
 
   // --- Standards & Compliance ---
   standardsCompliance: {
-    enabled: false,
+    enabled: true,
     mode: 'block',
     scopeByTaskType: true,
     alwaysCheck: ['naming', 'security'],
@@ -337,6 +339,27 @@ const CONFIG_DEFAULTS = {
   checkpoint: { enabled: false },
   regressionTesting: { enabled: false },
 
+  // --- Runtime Verification (CC 2.1.89+ enforcement) ---
+  // Ensures agents actually test their work before marking done.
+  // Without this, agents claim "done" based on static evidence only.
+  runtimeVerification: {
+    enabled: true,
+    autoGenerateTests: true,
+    blockOnFailure: true,
+    frontend: {
+      method: 'webmcp',
+      fallback: ['playwright', 'checklist'],
+      devServerUrl: 'http://localhost:5173'
+    },
+    backend: {
+      method: 'api-test',
+      fallback: ['curl', 'checklist'],
+      baseUrl: 'http://localhost:3000'
+    },
+    testOutput: 'tests/verification',
+    persistTests: true
+  },
+
   // --- Detection (Project Type Awareness) ---
   detection: {
     _comment: "Weighted scoring for project type detection. Overrides take precedence over scoring.",
@@ -402,7 +425,7 @@ const CONFIG_DEFAULTS = {
     threshold: 30,
     allRegistries: true,
     aiAsJudge: true,
-    blockOnSimilar: false,
+    blockOnSimilar: true,
     injectContext: true,
     preferVariants: true,
     requireAppMapEntry: true,