wogiflow 2.4.4 → 2.5.1

package/lib/workspace.js

@@ -328,14 +328,24 @@ function generateWorkspaceConfig(workspaceName, members) {
     sync: {
       autoOnSessionStart: true,
       autoAfterTaskComplete: true
+    },
+    channels: {
+      enabled: true,
+      basePort: 8801,
+      members: {}
     }
   };
 
+  let port = config.channels.basePort;
+  if (port + members.length - 1 > 65535) {
+    throw new Error(`Channel port range ${port}-${port + members.length - 1} exceeds maximum port 65535. Reduce basePort or number of members.`);
+  }
   for (const member of members) {
     config.members[member.name] = {
       path: `./${member.name}`,
       role: member.role
     };
+    config.channels.members[member.name] = { port: port++ };
   }
 
   return config;
@@ -546,49 +556,43 @@ ${Object.entries(manifest.members).map(([name, m]) => {
   }).join('\n')}
 - **Both/all repos**: api contract, schema change, integration, full-stack, end-to-end
 
-### Step 3: Execute
-
-**Single-repo task — spawn one sub-agent:**
-\`\`\`
-Use the Agent tool:
-  prompt: "You are working in the <REPO> repository.
-    Stack: <STACK>
-    Task: <TASK DESCRIPTION>
+### Step 3: Dispatch via Channels
 
-    Project rules (read from <REPO>/.workflow/state/decisions.md):
-    <PASTE DECISIONS CONTENT>
+Each worker repo runs a full Claude Code session with its own CLAUDE.md, hooks, and WogiFlow pipeline. You dispatch tasks by sending HTTP requests to their channel ports. **Do NOT use the Agent tool for implementation** — use channels for full enforcement.
 
-    After completing: commit your changes with a descriptive message."
+**Worker Channel Ports:**
+${Object.entries(config.channels?.members || {}).map(([name, ch]) => `- **${name}**: \`http://localhost:${ch.port}\``).join('\n')}
 
-  The sub-agent runs with the full codebase of that repo available.
-  It follows that repo's own WogiFlow rules, decisions, and patterns.
+**Check if workers are running:**
+\`\`\`bash
+${Object.entries(config.channels?.members || {}).map(([name, ch]) => `curl -s http://localhost:${ch.port}/health`).join('\n')}
 \`\`\`
 
-**Cross-repo task — sequential delegation:**
-1. Read the contract from \`.workspace/contracts/\` (if exists)
-2. If the API contract needs updating, update it first
-3. Spawn provider sub-agent (${providers.join(' or ')}) — implement the API side
-4. Read what the provider changed (from its git diff or commit message)
-5. Write a message to \`.workspace/messages/\` describing the change
-6. Spawn consumer sub-agent (${consumers.join(' or ')}) — implement the client side, include the message as context
-7. Verify both sides work together
-
-**Bug investigation — parallel agents:**
-\`\`\`
-Spawn ${memberNames.length} agents IN PARALLEL (single message with multiple Agent tool calls):
+If a worker is down, tell the user: "Start the ${'{'}repo{'}'} worker: \`cd ${'{'}repo{'}'}/ && flow workspace start\`"
 
-Agent 1 (${memberNames[0]}):
-  "Investigate this bug in ${memberNames[0]}: <BUG DESCRIPTION>
-   Check: recent changes, error logs, relevant code.
-   Report: Is the issue on YOUR side? What did you find?"
+**Single-repo task:**
+1. Create task in the repo's ready.json using \`decomposeToRepoTasks()\` or directly
+2. Dispatch: \`curl -s -X POST http://localhost:${'{'}port{'}'} -d "/wogi-start ${'{'}taskId${'}'}"\`
+3. The worker's full WogiFlow pipeline handles the rest (explore, spec, implement, verify)
+4. Monitor: check \`.workspace/messages/\` for a \`task-complete\` message
 
-${memberNames.length > 1 ? `Agent 2 (${memberNames[1]}):
-  "Investigate this bug in ${memberNames[1]}: <BUG DESCRIPTION>
-   Check: recent changes, error logs, relevant code.
-   Report: Is the issue on YOUR side? What did you find?"` : ''}
-
-Then synthesize the findings and route the fix to the correct repo.
+**Cross-repo task:**
+1. Read the contract from \`.workspace/contracts/\` (if exists)
+2. If the API contract needs updating, update it first
+3. Create tasks in each repo's ready.json (provider gets P0 priority)
+4. Dispatch to provider first: \`curl -s -X POST http://localhost:${providers[0] ? config.channels?.members?.[providers[0]]?.port || '{port}' : '{port}'} -d "/wogi-start ${'{'}providerTaskId${'}'}"\`
+5. Wait for provider completion message in \`.workspace/messages/\`
+6. Then dispatch to consumer: \`curl -s -X POST http://localhost:${consumers[0] ? config.channels?.members?.[consumers[0]]?.port || '{port}' : '{port}'} -d "/wogi-start ${'{'}consumerTaskId${'}'}"\`
+7. Wait for consumer completion, then verify integration
+
+**Bug investigation — dispatch to all workers:**
+\`\`\`bash
+# Send investigation request to all workers in parallel
+${Object.entries(config.channels?.members || {}).map(([name, ch]) =>
+  `curl -s -X POST http://localhost:${ch.port} -d "Investigate: <BUG_DESCRIPTION>. Check recent changes, error logs, relevant code. Report back via workspace message."`
+).join('\n')}
 \`\`\`
+Then read responses from \`.workspace/messages/\` and synthesize findings.
 
 ## Reading Member State (What to Read, When)
 
@@ -637,6 +641,51 @@ When spawning a sub-agent, check for pending messages to that repo and include t
 Shared API contracts: \`.workspace/contracts/\`
 When a provider changes an endpoint, update the contract BEFORE the consumer implements.
 
+## Peer Communication (Worker ↔ Worker)
+
+Workers can talk directly to each other — no manager bottleneck. Each worker knows its peers' channel ports.
+
+A worker asking its peer a question:
+\`\`\`bash
+curl -s -X POST http://localhost:{peer_port} -H "X-Wogi-From: {my_repo}" -d "Is the POST /users endpoint ready? What's the expected payload shape?"
+\`\`\`
+
+The peer receives this as a channel event, reads its codebase to answer, and can reply back the same way. This is useful when:
+- Frontend needs to know the exact API shape before implementing
+- Backend wants to know which fields the frontend actually uses
+- Any repo needs real-time coordination without going through the manager
+
+Workers also have a \`workspace_send_message\` MCP tool that handles this automatically.
+
+## Command Routing (CRITICAL)
+
+**You are an orchestrator — you do NOT execute code-level commands locally.** When the user invokes a WogiFlow command, route it based on this table:
+
+| Command | Action | Why |
+|---------|--------|-----|
+| \`/wogi-review\` | **Dispatch to ALL workers** → aggregate findings + cross-repo analysis | Workers have the source code and full pipeline |
+| \`/wogi-audit\` | **Dispatch to ALL workers** → aggregate audit results + cross-repo analysis | Same reason |
+| \`/wogi-test\` | **Dispatch to ALL workers** → aggregate test results | Tests run in each repo's environment |
+| \`/wogi-health\` | **Dispatch to ALL workers** → unified health report | Each repo has its own workflow state |
+| \`/wogi-start "task"\` | **Analyze → decompose → dispatch** to correct worker(s) | Already designed for this |
+| \`/wogi-status\` | Run **locally** — workspace-level overview | Reads workspace state files |
+| \`/wogi-ready\` | Run **locally** — cross-repo task queue | Reads all repos' ready.json |
+| \`/wogi-session-end\` | Run **locally** — end workspace session | Workspace-level action |
+
+**How to dispatch a command to all workers:**
+\`\`\`bash
+${Object.entries(config.channels?.members || {}).map(([name, ch]) =>
+  `curl -s -X POST http://localhost:${ch.port} -d "/wogi-review"  # → ${name}`
+).join('\n')}
+\`\`\`
+
+**After all workers complete:** Run a cross-repo analysis that only you can do:
+1. Collect findings from \`.workspace/messages/\` (workers write results there)
+2. Check API contract alignment between provider and consumer
+3. Check for integration gaps (orphaned consumers, drifted contracts)
+4. Check shared decisions compliance (\`.workspace/state/decisions.md\`)
+5. Present unified report: per-repo findings + cross-repo findings
+
 ## Workspace Commands
 
 | Command | What it does |
@@ -645,6 +694,7 @@ When a provider changes an endpoint, update the contract BEFORE the consumer imp
 | \`flow workspace status\` | Show all repos, tasks, messages, contracts |
 | \`flow workspace add <path>\` | Add a new member repo |
 | \`flow workspace remove <name>\` | Remove a member repo |
+| \`flow workspace start\` | Start a worker session (run from within a member repo) |
 
 ## File Reference
 
@@ -690,7 +740,13 @@ function generateWorkspaceSettings(memberNames) {
     'Bash(node --check *)',
     'Bash(node scripts/*)',
     'Bash(ls *)',
-    'Bash(cat *)'
+    'Bash(cat *)',
+    'Bash(curl http://localhost:*)',
+    'Bash(curl http://127.0.0.1:*)',
+    'Bash(curl -s http://localhost:*)',
+    'Bash(curl -s http://127.0.0.1:*)',
+    'Bash(curl -s -X POST http://localhost:*)',
+    'Bash(curl -s -X POST http://127.0.0.1:*)'
   ];
 
   for (const name of (memberNames || [])) {
@@ -785,6 +841,95 @@ state/contract-versions.json
   }
 }
 
+// ============================================================
+// ============================================================
+// Channel MCP Config Generation
+// ============================================================
+
+/**
+ * Generate .mcp.json for each member repo with channel server config.
+ * This allows workers to receive task dispatches from the manager
+ * and communicate with peer repos via channels.
+ *
+ * @param {string} workspaceRoot
+ * @param {Object} config — workspace config (with channels section)
+ */
+function generateMemberMcpConfigs(workspaceRoot, config) {
+  const channelMembers = config.channels?.members || {};
+  const memberNames = Object.keys(channelMembers);
+
+  const VALID_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
+
+  for (const [name, channelConfig] of Object.entries(channelMembers)) {
+    if (!VALID_NAME.test(name)) {
+      console.error(`  ✗ ${name}: invalid member name (must match [a-zA-Z0-9_-]) — skipping`);
+      continue;
+    }
+
+    const memberPath = path.resolve(workspaceRoot, config.members[name]?.path || `./${name}`);
+
+    // Path traversal guard — ensure member path is inside workspace root
+    if (!memberPath.startsWith(workspaceRoot + path.sep) && memberPath !== workspaceRoot) {
+      console.error(`  ✗ ${name}: path escapes workspace root (${config.members[name]?.path}) — skipping`);
+      continue;
+    }
+
+    const mcpJsonPath = path.join(memberPath, '.mcp.json');
+
+    // Build peer list (all other members)
+    const peers = memberNames
+      .filter(n => n !== name)
+      .map(n => `${n}:${channelMembers[n].port}`)
+      .join(',');
+
+    // Resolve channel server script path
+    // Use require.resolve to find the installed wogiflow package
+    let channelServerPath;
+    try {
+      channelServerPath = require.resolve('wogiflow/lib/workspace-channel-server.js');
+    } catch (_err) {
+      // Fallback: relative path from workspace root
+      channelServerPath = path.join(__dirname, 'workspace-channel-server.js');
+    }
+
+    const mcpConfig = {
+      mcpServers: {
+        'wogi-workspace-channel': {
+          command: 'node',
+          args: [channelServerPath],
+          env: {
+            WOGI_CHANNEL_PORT: String(channelConfig.port),
+            WOGI_REPO_NAME: name,
+            WOGI_PEERS: peers,
+            WOGI_WORKSPACE_ROOT: workspaceRoot
+          }
+        }
+      }
+    };
+
+    // Merge with existing .mcp.json if present
+    let existingConfig = {};
+    try {
+      if (fs.existsSync(mcpJsonPath)) {
+        existingConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
+      }
+    } catch (_err) {
+      // Ignore malformed existing config
+    }
+
+    const merged = {
+      ...existingConfig,
+      mcpServers: {
+        ...(existingConfig.mcpServers || {}),
+        ...mcpConfig.mcpServers
+      }
+    };
+
+    fs.writeFileSync(mcpJsonPath, JSON.stringify(merged, null, 2));
+    console.log(`  ✓ ${name}/.mcp.json (channel port ${channelConfig.port}, peers: ${peers || 'none'})`);
+  }
+}
+
 // ============================================================
 // Main Init Function
 // ============================================================
@@ -794,16 +939,76 @@ state/contract-versions.json
  * @param {string[]} args — CLI arguments
  */
 async function initWorkspace(args) {
-  const workspaceRoot = process.cwd();
-  const workspaceName = path.basename(workspaceRoot);
+  let workspaceRoot = process.cwd();
+
+  // Walk up to find existing workspace root (same as startWorkerSession)
+  let existingWorkspaceRoot = null;
+  let dir = workspaceRoot;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, WORKSPACE_CONFIG_FILE))) {
+      existingWorkspaceRoot = dir;
+      break;
+    }
+    dir = path.dirname(dir);
+  }
 
-  // Check if workspace already exists
-  if (fs.existsSync(path.join(workspaceRoot, WORKSPACE_CONFIG_FILE))) {
-    console.error(`Workspace already initialized in ${workspaceRoot}`);
-    console.error('Use `flow workspace sync` to update.');
+  // If we're inside an existing workspace (found in parent or CWD)
+  if (existingWorkspaceRoot) {
+    // Check if channels need to be enabled (upgrade path)
+    let existingConfig;
+    try {
+      existingConfig = JSON.parse(fs.readFileSync(path.join(existingWorkspaceRoot, WORKSPACE_CONFIG_FILE), 'utf-8'));
+    } catch (err) {
+      console.error(`Error reading workspace config: ${err.message}`);
+      process.exit(1);
+    }
+
+    if (!existingConfig.channels?.enabled) {
+      console.log(`Workspace found at ${existingWorkspaceRoot}`);
+      console.log('Channels not yet enabled — adding channel configuration...\n');
+
+      // Add channels section to existing config
+      const members = Object.keys(existingConfig.members);
+      const basePort = 8801;
+      existingConfig.channels = {
+        enabled: true,
+        basePort,
+        members: {}
+      };
+      let port = basePort;
+      for (const name of members) {
+        existingConfig.channels.members[name] = { port: port++ };
+      }
+
+      // Write updated config
+      fs.writeFileSync(
+        path.join(existingWorkspaceRoot, WORKSPACE_CONFIG_FILE),
+        JSON.stringify(existingConfig, null, 2)
+      );
+      console.log(`  ✓ Updated ${WORKSPACE_CONFIG_FILE} with channels (ports ${basePort}-${basePort + members.length - 1})`);
+
+      // Generate .mcp.json for each member
+      console.log('');
+      console.log('── Setting up workspace channels ────────────\n');
+      generateMemberMcpConfigs(existingWorkspaceRoot, existingConfig);
+      console.log('');
+      console.log('Channels enabled! Run `flow workspace start` from a member repo to begin.');
+      return;
+    }
+
+    // Workspace exists and channels are already enabled
+    if (existingWorkspaceRoot !== workspaceRoot) {
+      console.error(`You are inside workspace "${path.basename(existingWorkspaceRoot)}" at ${existingWorkspaceRoot}`);
+      console.error(`Run this command from the workspace root, or use \`flow workspace sync\` to update.`);
+    } else {
+      console.error(`Workspace already initialized in ${workspaceRoot}`);
+      console.error('Use `flow workspace sync` to update.');
+    }
     process.exit(1);
   }
 
+  const workspaceName = path.basename(workspaceRoot);
+
   console.log('🔍 Scanning for WogiFlow-enabled projects...\n');
 
   // Discover member repos
@@ -899,6 +1104,13 @@ async function initWorkspace(args) {
     JSON.stringify(settings, null, 2)
   );
   console.log('  ✓ .claude/settings.json');
+
+  // Generate .mcp.json for each member repo (channel server config)
+  if (config.channels?.enabled) {
+    console.log('');
+    console.log('── Setting up workspace channels ────────────\n');
+    generateMemberMcpConfigs(workspaceRoot, config);
+  }
   console.log('');
 
   // Summary
@@ -981,6 +1193,122 @@ function generateIntegrationMap(manifest) {
   return lines.join('\n');
 }
 
+// ============================================================
+// Worker Session Launcher
+// ============================================================
+
+/**
+ * Start a Claude Code worker session with the workspace channel enabled.
+ * Must be run from within a member repo directory.
+ *
+ * @param {string} cwd — current working directory (should be a member repo)
+ */
+function startWorkerSession(cwd) {
+  const { execSync } = require('node:child_process');
+
+  // Find workspace root by walking up
+  let workspaceRoot = null;
+  let dir = cwd;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, WORKSPACE_CONFIG_FILE))) {
+      workspaceRoot = dir;
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+
+  if (!workspaceRoot) {
+    console.error('Error: Not inside a workspace. Could not find wogi-workspace.json in any parent directory.');
+    process.exit(1);
+  }
+
+  // Read workspace config
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(path.join(workspaceRoot, WORKSPACE_CONFIG_FILE), 'utf-8'));
+  } catch (err) {
+    console.error(`Error reading workspace config: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!config.channels?.enabled) {
+    console.error('Error: Channels are not enabled in this workspace. Run "flow workspace init" to set up channels.');
+    process.exit(1);
+  }
+
+  // Determine which member we are based on cwd
+  const relativePath = path.relative(workspaceRoot, cwd);
+  let memberName = null;
+  let memberChannel = null;
+
+  for (const [name, memberConfig] of Object.entries(config.members)) {
+    const memberRelPath = memberConfig.path.replace(/^\.\//, '');
+    if (relativePath === memberRelPath || relativePath.startsWith(memberRelPath + path.sep)) {
+      memberName = name;
+      memberChannel = config.channels.members[name];
+      break;
+    }
+  }
+
+  if (!memberName || !memberChannel) {
+    console.error(`Error: Current directory "${relativePath}" does not match any workspace member.`);
+    console.error('Members:', Object.keys(config.members).join(', '));
+    process.exit(1);
+  }
+
+  // Build peer list
+  const peers = Object.entries(config.channels.members)
+    .filter(([n]) => n !== memberName)
+    .map(([n, ch]) => `${n}:${ch.port}`)
+    .join(',');
+
+  // Verify .mcp.json exists with channel config
+  const mcpJsonPath = path.join(cwd, '.mcp.json');
+  let mcpConfigValid = false;
+  try {
+    if (fs.existsSync(mcpJsonPath)) {
+      const mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
+      mcpConfigValid = !!mcpConfig?.mcpServers?.['wogi-workspace-channel'];
+    }
+  } catch (_err) {
+    // Malformed .mcp.json
+  }
+
+  if (!mcpConfigValid) {
+    console.error(`Error: .mcp.json missing or does not contain wogi-workspace-channel config.`);
+    console.error('Run "flow workspace init" from the workspace root to generate channel configs.');
+    process.exit(1);
+  }
+
+  console.log(`Starting worker session for "${memberName}" (port ${memberChannel.port})`);
+  if (peers) console.log(`Peers: ${peers}`);
+  console.log('');
+
+  // Set up environment for the channel server
+  const env = {
+    ...process.env,
+    WOGI_CHANNEL_PORT: String(memberChannel.port),
+    WOGI_REPO_NAME: memberName,
+    WOGI_PEERS: peers,
+    WOGI_WORKSPACE_ROOT: workspaceRoot
+  };
+
+  // Launch Claude Code with the channel
+  try {
+    execSync('claude --dangerously-load-development-channels server:wogi-workspace-channel', {
+      cwd,
+      env,
+      stdio: 'inherit'
+    });
+  } catch (err) {
+    // Exit code 0 or SIGINT from user quit — that's fine
+    if (err.status && err.status !== 0 && err.signal !== 'SIGINT') {
+      console.error(`Worker session exited with error (code ${err.status}): ${err.message}`);
+      process.exit(err.status);
+    }
+  }
+}
+
 // ============================================================
 // CLI Router
 // ============================================================
@@ -1033,6 +1361,10 @@ async function workspace(args) {
       console.log(`✓ Removed '${name}' from workspace`);
       break;
     }
+    case 'start': {
+      startWorkerSession(process.cwd());
+      break;
+    }
     default:
       console.log(`
 Wogi Workspace — Multi-Repo Orchestration
@@ -1045,11 +1377,13 @@ Commands:
   status     Show unified workspace status
   add        Add a member repo to the workspace
   remove     Remove a member repo from the workspace
+  start      Start a worker session with channel (run from a member repo)
 
 Examples:
   flow workspace init          # Create workspace from subdirectories
   flow workspace sync          # Refresh after external changes
   flow workspace status        # Show all repos, tasks, contracts
+  cd frontend/ && flow workspace start   # Start worker session
 `);
   }
 }
@@ -1069,5 +1403,7 @@ module.exports = {
   createWorkspaceStructure,
   WORKSPACE_CONFIG_FILE,
   WORKSPACE_DIR,
-  MEMBER_ROLES
+  MEMBER_ROLES,
+  generateMemberMcpConfigs,
+  startWorkerSession
 };

package/package.json

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