wogiflow 2.6.0 → 2.6.1

package/lib/workspace.js

@@ -990,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
 
@@ -1024,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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.6.0",
+  "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,88 +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
-      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
+      // Get 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'
-      };
-
-      // Write to file (fallback / persistent record)
-      fs.writeFileSync(path.join(messagesDir, `${msgId}.json`), JSON.stringify(message, null, 2));
+      const body = summaryParts.join('\n') || `${repoName} finished processing.`;
 
-      // Also HTTP POST to manager's channel port for real-time notification
-      // This makes the message appear as a prompt in the manager's session immediately
-      const managerPort = process.env.WOGI_MANAGER_PORT;
-      if (managerPort && repoName !== 'manager') {
-        try {
-          const http = require('node:http');
-          const body = Buffer.from(message.body, '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': body.byteLength,
-              'X-Wogi-From': repoName
-            }
-          });
-          req.on('error', () => { /* best effort — file is the fallback */ });
-          req.write(body);
-          req.end();
-        } catch (_err) { /* non-critical */ }
-      }
-
-      if (process.env.DEBUG) {
-        console.error(`[Stop] Workspace message written: ${msgId}${managerPort ? ` + HTTP to manager:${managerPort}` : ''}`);
+      // 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}`);
       }
     }
   }