wogiflow 2.5.9 → 2.6.0

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

@@ -411,30 +411,50 @@ After implementing all scenarios, BEFORE quality gates:
    | Remove deprecated API | "What in this file provides the same FUNCTIONALITY as the deprecated API?" | Wrapper functions, polyfills, compatibility shims, re-implementations |
    | Fix all raw JSON.parse | "What in this file deserializes JSON?" | Utility functions that call JSON.parse internally, library wrappers |
 
-3. **Produce a numbered inventory** and display it to the user:
+3. **Trace data-providing imports one level (MANDATORY)**:
+
+   The semantic scan in step 2 catches inline instances but gives a free pass to imported values. Imported constants, configurations, and helpers can contain the exact thing you're looking for — hidden behind one level of indirection and a legitimate-sounding name (`DEFAULT_*`, `INITIAL_*`, `FALLBACK_*`, `BASE_*`).
+
+   **For every import statement in each scoped file**, classify it:
+
+   | Import Type | Example | Action |
+   |-------------|---------|--------|
+   | **Data-providing** | `import { RATE_OPTIONS } from './constants'` | MUST read the source file and apply the semantic question to its contents |
+   | **Utility/function** | `import { formatDate } from './utils'` | Skip — unless the function wraps or returns the target pattern |
+   | **Type/interface** | `import type { Customer } from './types'` | Skip — types don't contain runtime data |
+   | **Style/asset** | `import styles from './styles.module.css'` | Skip |
+   | **Component** | `import { Button } from './ui'` | Skip — unless it's a wrapper that embeds the target pattern |
+
+   **How to classify**: If the import provides a value that gets **rendered, displayed, logged, passed to an API, or used as configuration** — it's data-providing. Read its source.
+
+   **Anti-pattern — naming convention bias**: Constants named `DEFAULT_*`, `INITIAL_*`, `FALLBACK_*`, `CONFIG_*`, `BASE_*` look legitimate but are often hardcoded placeholders. The name is NOT evidence of legitimacy. Only the source is.
+
+   **Rule**: Any imported value that contributes to **user-visible output** and resolves to a hardcoded literal (not an API call, env var, or database query) is an instance of [X] — regardless of what it's named or which directory it lives in.
+
+4. **Produce a numbered inventory** and display it to the user:
    ```
    ━━━ PRE-IMPLEMENTATION INVENTORY ━━━
    Found N instances of [X] across M files:
 
-     1. [file:lines] — [description] [TYPE: syntactic|semantic]
-     2. [file:lines] — [description] [TYPE: syntactic|semantic]
+     1. [file:lines] — [description] [TYPE: syntactic|semantic|import-traced]
+     2. [file:lines] — [description] [TYPE: syntactic|semantic|import-traced]
      ...
 
    Total: N instances (S syntactic, M semantic)
    Confirm inventory is complete before proceeding? [Y/adjust]
    ```
 
-4. **Wait for user confirmation** that the inventory is complete. If the user identifies missing items, add them. This step is CRITICAL — it commits the AI to a concrete scope that can be verified later.
+5. **Wait for user confirmation** that the inventory is complete. If the user identifies missing items, add them. This step is CRITICAL — it commits the AI to a concrete scope that can be verified later.
 
 #### Phase B: Implementation
 
-5. Implement the removal/fix/replacement for EVERY item in the inventory. Each inventory item becomes a trackable unit of work.
+6. Implement the removal/fix/replacement for EVERY item in the inventory. Each inventory item becomes a trackable unit of work.
 
 #### Phase C: Post-Implementation Re-Inventory (AFTER all changes)
 
-6. **Re-run the SAME semantic scan** from Phase A on the SAME set of files. Use the same questions — do NOT downgrade to pattern-only search.
+7. **Re-run the SAME semantic scan** from Phase A (including import tracing from step 3) on the SAME set of files. Do NOT downgrade to pattern-only search.
 
-7. **Diff the inventories**:
+8. **Diff the inventories**:
    ```
    ━━━ POST-IMPLEMENTATION VERIFICATION ━━━
    Re-scanned M files for [X]:
@@ -447,9 +467,9 @@ After implementing all scenarios, BEFORE quality gates:
    Result: N/N removed (0 remaining)
    ```
 
-8. **If ANY items remain** → task is NOT done. Fix the remaining items and re-verify. Do NOT proceed to quality gates with remaining items.
+9. **If ANY items remain** → task is NOT done. Fix the remaining items and re-verify. Do NOT proceed to quality gates with remaining items.
 
-9. **If new instances are discovered** during re-scan that weren't in the original inventory → add them, fix them, and note them as "discovered during verification."
+10. **If new instances are discovered** during re-scan (including via import tracing) that weren't in the original inventory → add them, fix them, and note them as "discovered during verification."
 
 **Why this works**: The inventory creates a concrete, numbered checklist BEFORE implementation. The AI cannot claim "done" when the post-inventory shows items still present — the evidence is in the conversation. The pre/post diff is unfakeable.
 

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))
           }
         }
       }
@@ -1039,6 +1040,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 +1420,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 +1497,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.9",
+  "version": "2.6.0",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

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

@@ -134,10 +134,35 @@ runHook('Stop', async ({ parsedInput }) => {
         status: 'pending'
       };
 
+      // Write to file (fallback / persistent record)
       fs.writeFileSync(path.join(messagesDir, `${msgId}.json`), JSON.stringify(message, null, 2));
 
+      // 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}`);
+        console.error(`[Stop] Workspace message written: ${msgId}${managerPort ? ` + HTTP to manager:${managerPort}` : ''}`);
       }
     } catch (err) {
       // Non-critical — best effort