wogiflow 2.5.10 → 2.6.1

package/lib/workspace-channel-server.js

@@ -270,8 +270,27 @@ function handleRequest(msg) {
           };
           const msgPath = require('node:path').join(messagesDir, `${msgId}.json`);
           fs.writeFileSync(msgPath, JSON.stringify(msgObj, null, 2));
+
+          // Also POST to manager's channel port for real-time notification
+          const managerPort = process.env.WOGI_MANAGER_PORT;
+          if (managerPort) {
+            try {
+              const buf = Buffer.from(message, 'utf-8');
+              const req = http.request({
+                hostname: '127.0.0.1',
+                port: parseInt(managerPort, 10),
+                path: '/',
+                method: 'POST',
+                headers: { 'Content-Type': 'text/plain', 'Content-Length': buf.byteLength, 'X-Wogi-From': REPO_NAME }
+              });
+              req.on('error', () => { /* best effort */ });
+              req.write(buf);
+              req.end();
+            } catch (_err) { /* fallback is file */ }
+          }
+
           sendResponse(msg.id, {
-            content: [{ type: 'text', text: `Message sent to manager (written to ${msgPath}).` }]
+            content: [{ type: 'text', text: `Message sent to manager${managerPort ? ' (file + channel notification)' : ' (file only)'}.` }]
           });
         } catch (err) {
           sendResponse(msg.id, {

package/lib/workspace.js

@@ -945,7 +945,8 @@ function generateMemberMcpConfigs(workspaceRoot, config) {
             WOGI_CHANNEL_PORT: String(channelConfig.port),
             WOGI_REPO_NAME: name,
             WOGI_PEERS: peers,
-            WOGI_WORKSPACE_ROOT: workspaceRoot
+            WOGI_WORKSPACE_ROOT: workspaceRoot,
+            WOGI_MANAGER_PORT: String(config.channels.managerPort || (config.channels.basePort - 1))
           }
         }
       }
@@ -989,22 +990,32 @@ description: "Workspace worker rules — reply to manager after every channel ta
 
 You are **${name}** in a Wogi Workspace managed by an orchestrator.
 
-## CRITICAL: Always Reply to the Manager
+## CRITICAL: Always Reply to the Manager (port ${config.channels.managerPort || (config.channels.basePort - 1)})
 
-When you receive a message via the workspace channel (appears as a channel notification), you MUST send results back to the manager after completing the work. **The user only sees the manager terminal — if you don't reply, they never see your results.**
+When you receive a message via the workspace channel, you MUST send results back to the manager after completing the work. **The user only sees the manager terminal — if you don't reply, they never see your results.**
 
-Use the \`workspace_send_message\` MCP tool:
+**PRIMARY method — curl to manager port (always works, even if MCP tools haven't loaded yet):**
+
+\`\`\`bash
+curl -s -X POST http://localhost:${config.channels.managerPort || (config.channels.basePort - 1)} -H "Content-Type: text/plain" -H "X-Wogi-From: ${name}" -d "## Results
+
+[your findings/summary here]"
+\`\`\`
+
+**ALTERNATIVE — workspace_send_message MCP tool (if available):**
 
 \`\`\`
 workspace_send_message(to: "manager", message: "## Results\\n\\n[your findings/summary here]")
 \`\`\`
 
-This is NON-OPTIONAL. Every channel-dispatched task MUST end with a workspace_send_message to "manager".
+If the MCP tool is not available (shows "MCP servers still connecting"), use the curl command. **Do NOT write JSON files to .workspace/messages/ directly — that doesn't notify the manager.**
+
+This is NON-OPTIONAL. Every channel-dispatched task MUST end with a reply to the manager.
 
 ## Peer Communication
 
-You can talk to peer repos using the same tool:
-${peerNames.map(p => `- \`workspace_send_message(to: "${p}", message: "...")\``).join('\n')}
+You can talk to peer repos via curl or the MCP tool:
+${peerNames.map(p => `- \`curl -s -X POST http://localhost:${channelMembers[p]?.port || '???'} -H "X-Wogi-From: ${name}" -d "your message"\``).join('\n')}
 
 ## Autonomous Mode — Auto-Approve Everything
 
@@ -1023,7 +1034,7 @@ Only send a question to the manager (instead of results) when:
 - The task requires **deleting user data** or making irreversible changes
 - You are genuinely **stuck** and cannot proceed
 
-To escalate: \`workspace_send_message(to: "manager", message: "## Need Decision\\n\\n[describe the choice and options]")\`
+To escalate: \`curl -s -X POST http://localhost:${config.channels.managerPort || (config.channels.basePort - 1)} -H "X-Wogi-From: ${name}" -d "## Need Decision: [describe the choice and options]"\`
 
 For everything else — just do the work and report results.
 
@@ -1039,6 +1050,50 @@ For everything else — just do the work and report results.
     fs.writeFileSync(path.join(rulesDir, 'worker-rules.md'), workerRule);
     console.log(`  ✓ ${name}/.claude/rules/workspace/worker-rules.md`);
   }
+
+  // Generate .mcp.json at workspace root for the manager's channel server
+  const managerPort = config.channels.managerPort || (config.channels.basePort - 1);
+  let channelServerPath;
+  try {
+    channelServerPath = require.resolve('wogiflow/lib/workspace-channel-server.js');
+  } catch (_err) {
+    channelServerPath = path.join(__dirname, 'workspace-channel-server.js');
+  }
+
+  const allMembers = memberNames.map(n => `${n}:${channelMembers[n].port}`).join(',');
+  const managerMcpConfig = {
+    mcpServers: {
+      'wogi-workspace-channel': {
+        command: 'node',
+        args: [channelServerPath],
+        env: {
+          WOGI_CHANNEL_PORT: String(managerPort),
+          WOGI_REPO_NAME: 'manager',
+          WOGI_PEERS: allMembers,
+          WOGI_WORKSPACE_ROOT: workspaceRoot
+        }
+      }
+    }
+  };
+
+  // Merge with existing .mcp.json at workspace root
+  const managerMcpPath = path.join(workspaceRoot, '.mcp.json');
+  let existingManagerMcp = {};
+  try {
+    if (fs.existsSync(managerMcpPath)) {
+      existingManagerMcp = JSON.parse(fs.readFileSync(managerMcpPath, 'utf-8'));
+    }
+  } catch (_err) { /* ignore */ }
+
+  const mergedManager = {
+    ...existingManagerMcp,
+    mcpServers: {
+      ...(existingManagerMcp.mcpServers || {}),
+      ...managerMcpConfig.mcpServers
+    }
+  };
+  fs.writeFileSync(managerMcpPath, JSON.stringify(mergedManager, null, 2));
+  console.log(`  ✓ .mcp.json (manager channel port ${managerPort}, workers: ${allMembers})`);
 }
 
 // ============================================================
@@ -1375,13 +1430,50 @@ function startWorkerSession(cwd) {
     }
   }
 
+  // Manager mode: CWD is the workspace root itself (not a member)
   if (!memberName || !memberChannel) {
+    if (relativePath === '' || relativePath === '.') {
+      // Start as workspace manager
+      const managerPort = config.channels.managerPort || (config.channels.basePort - 1);
+      const allMembers = Object.entries(config.channels.members)
+        .map(([n, ch]) => `${n}:${ch.port}`)
+        .join(',');
+
+      console.log(`Starting manager session (port ${managerPort})`);
+      console.log(`Workers: ${allMembers}`);
+      console.log('');
+
+      const env = {
+        ...process.env,
+        WOGI_CHANNEL_PORT: String(managerPort),
+        WOGI_REPO_NAME: 'manager',
+        WOGI_PEERS: allMembers,
+        WOGI_WORKSPACE_ROOT: workspaceRoot
+      };
+
+      try {
+        execSync('claude --dangerously-skip-permissions --dangerously-load-development-channels server:wogi-workspace-channel', {
+          cwd,
+          env,
+          stdio: 'inherit'
+        });
+      } catch (err) {
+        if (err.status && err.status !== 0 && err.signal !== 'SIGINT') {
+          console.error(`Manager session exited with error (code ${err.status}): ${err.message}`);
+          process.exit(err.status);
+        }
+      }
+      return;
+    }
+
     console.error(`Error: Current directory "${relativePath}" does not match any workspace member.`);
     console.error('Members:', Object.keys(config.members).join(', '));
+    console.error('Or run from the workspace root to start as manager.');
     process.exit(1);
   }
 
-  // Build peer list
+  // Build peer list (include manager port)
+  const managerPort = config.channels.managerPort || (config.channels.basePort - 1);
   const peers = Object.entries(config.channels.members)
     .filter(([n]) => n !== memberName)
     .map(([n, ch]) => `${n}:${ch.port}`)
@@ -1415,6 +1507,7 @@ function startWorkerSession(cwd) {
     WOGI_CHANNEL_PORT: String(memberChannel.port),
     WOGI_REPO_NAME: memberName,
     WOGI_PEERS: peers,
+    WOGI_MANAGER_PORT: String(managerPort),
     WOGI_WORKSPACE_ROOT: workspaceRoot
   };
 

package/package.json

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

package/scripts/hooks/entry/claude-code/stop.js

@@ -61,22 +61,19 @@ runHook('Stop', async ({ parsedInput }) => {
     };
   }
 
-  // Workspace worker: auto-write results back to manager when stopping
-  // This runs in the hook (not the AI), so it's guaranteed to execute.
-  // The AI can't be relied on to call workspace_send_message — the stop
-  // hook fires before the AI gets a chance, or the AI forgets.
-  if (process.env.WOGI_WORKSPACE_ROOT && process.env.WOGI_REPO_NAME) {
+  // Workspace worker: send results to manager via HTTP when stopping.
+  // Uses synchronous curl to guarantee delivery before the hook process exits.
+  // The async http.request approach was unreliable — process exited before request completed.
+  if (process.env.WOGI_MANAGER_PORT && process.env.WOGI_REPO_NAME && process.env.WOGI_REPO_NAME !== 'manager') {
     try {
+      const { execSync } = require('node:child_process');
       const fs = require('node:fs');
       const path = require('node:path');
-      const crypto = require('node:crypto');
-      const workspaceRoot = process.env.WOGI_WORKSPACE_ROOT;
       const repoName = process.env.WOGI_REPO_NAME;
-      const messagesDir = path.join(workspaceRoot, '.workspace', 'messages');
-      fs.mkdirSync(messagesDir, { recursive: true });
+      const managerPort = process.env.WOGI_MANAGER_PORT;
 
       // Build summary from available state
-      const summary = [];
+      const summaryParts = [];
       const { PATHS, safeJsonParse } = require('../../flow-utils');
 
       // Get current/recently completed task info
@@ -86,63 +83,40 @@ runHook('Stop', async ({ parsedInput }) => {
       const task = recentTask || inProgressTask;
 
       if (task) {
-        summary.push(`**Task**: ${task.title || task.id}`);
-        if (task.type) summary.push(`**Type**: ${task.type}`);
+        summaryParts.push(`**Task**: ${task.title || task.id}`);
+        if (task.type) summaryParts.push(`**Type**: ${task.type}`);
       }
 
-      // Get last request-log entry
+      // Get changed files
       try {
-        const logPath = path.join(PATHS.root, 'request-log.md');
-        if (fs.existsSync(logPath)) {
-          const stat = fs.statSync(logPath);
-          if (stat.size < 200 * 1024) {
-            const logContent = fs.readFileSync(logPath, 'utf-8');
-            const parts = logContent.split(/^### R-/m);
-            if (parts.length > 1) {
-              const lastEntry = parts[parts.length - 1];
-              if (lastEntry.length < 2000) {
-                summary.push(`**Log entry**:\n### R-${lastEntry.trim()}`);
-              }
-            }
-          }
-        }
-      } catch (_err) { /* non-critical */ }
-
-      // Get git status for changed files
-      try {
-        const { execSync } = require('node:child_process');
         const diff = execSync('git diff --name-only HEAD 2>/dev/null || true', { cwd: PATHS.root, encoding: 'utf-8' }).trim();
         const staged = execSync('git diff --name-only --staged 2>/dev/null || true', { cwd: PATHS.root, encoding: 'utf-8' }).trim();
         const allChanged = [...new Set([...diff.split('\n'), ...staged.split('\n')].filter(Boolean))];
         if (allChanged.length > 0) {
-          summary.push(`**Files changed**: ${allChanged.join(', ')}`);
+          summaryParts.push(`**Files changed**: ${allChanged.join(', ')}`);
         }
       } catch (_err) { /* non-critical */ }
 
-      const msgId = 'msg-' + crypto.randomBytes(4).toString('hex');
-      const message = {
-        id: msgId,
-        from: repoName,
-        to: 'manager',
-        type: 'task-complete',
-        priority: 'medium',
-        timestamp: new Date().toISOString(),
-        subject: task ? `Completed: ${task.title || task.id}` : `Work completed by ${repoName}`,
-        body: summary.join('\n') || `${repoName} finished processing.`,
-        taskId: task?.id || null,
-        actionRequired: false,
-        status: 'pending'
-      };
-
-      fs.writeFileSync(path.join(messagesDir, `${msgId}.json`), JSON.stringify(message, null, 2));
+      const body = summaryParts.join('\n') || `${repoName} finished processing.`;
 
-      if (process.env.DEBUG) {
-        console.error(`[Stop] Workspace message written: ${msgId}`);
+      // PRIMARY: Synchronous curl to manager port — guaranteed to complete before exit
+      try {
+        execSync(
+          `curl -s -X POST http://127.0.0.1:${managerPort} -H "Content-Type: text/plain" -H "X-Wogi-From: ${repoName}" --data-binary @-`,
+          { input: body, timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
+        );
+        if (process.env.DEBUG) {
+          console.error(`[Stop] Sent results to manager via curl :${managerPort}`);
+        }
+      } catch (_err) {
+        // Manager might be offline — that's OK
+        if (process.env.DEBUG) {
+          console.error(`[Stop] curl to manager:${managerPort} failed: ${_err.message}`);
+        }
       }
     } catch (err) {
-      // Non-critical — best effort
       if (process.env.DEBUG) {
-        console.error(`[Stop] Workspace message failed: ${err.message}`);
+        console.error(`[Stop] Workspace notification failed: ${err.message}`);
       }
     }
   }