wogiflow 2.7.1 → 2.9.0

package/lib/workspace-routing.js

@@ -222,7 +222,9 @@ After completing the task:
     agentConfig: {
       description: `${repoName}: ${task.substring(0, 50)}...`,
       // Named subagent (2.1.88+): shows in @ mention typeahead as @repoName
-      name: repoName
+      name: repoName,
+      // Propagate reasoning effort from manager to worker
+      ...(process.env.WOGI_EFFORT_LEVEL && { model_options: { effort: process.env.WOGI_EFFORT_LEVEL } })
     }
   };
 }
@@ -704,9 +706,11 @@ function checkWorkerHealth(port) {
  * @param {string} workspaceRoot
  * @param {string} repoName — target repo
  * @param {string} taskId — task ID to start
+ * @param {Object} [opts] — dispatch options
+ * @param {string} [opts.effortLevel] — reasoning effort to propagate ('low'|'medium'|'high')
  * @returns {Promise<{ ok: boolean, message: string }>}
  */
-async function dispatchToChannel(workspaceRoot, repoName, taskId) {
+async function dispatchToChannel(workspaceRoot, repoName, taskId, opts = {}) {
   // Validate taskId format to prevent injection into channel body
   if (!/^wf-[0-9a-f]{8}$/i.test(taskId)) {
     return { ok: false, message: `Invalid task ID format: "${taskId}" — expected wf-XXXXXXXX` };
@@ -738,10 +742,16 @@ async function dispatchToChannel(workspaceRoot, repoName, taskId) {
     };
   }
 
-  // Dispatch the task
-  const result = await httpPost('127.0.0.1', port, `/wogi-start ${taskId}`);
+  // Dispatch the task with effort level propagation
+  // When the manager uses ultrathink/high effort, workers should too
+  const VALID_EFFORTS = new Set(['low', 'medium', 'high']);
+  const rawEffort = opts.effortLevel || process.env.WOGI_EFFORT_LEVEL || '';
+  const effortLevel = VALID_EFFORTS.has(rawEffort) ? rawEffort : '';
+  const effortPrefix = effortLevel ? `[effort:${effortLevel}] ` : '';
+  const dispatchBody = `${effortPrefix}/wogi-start ${taskId}`;
+  const result = await httpPost('127.0.0.1', port, dispatchBody);
   if (result.ok) {
-    return { ok: true, message: `Dispatched /wogi-start ${taskId} to ${repoName} (port ${port})` };
+    return { ok: true, message: `Dispatched /wogi-start ${taskId} to ${repoName} (port ${port})${effortLevel ? ` [effort: ${effortLevel}]` : ''}` };
   }
 
   return { ok: false, message: `Dispatch failed: HTTP ${result.status} — ${result.body}` };

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
 
@@ -645,6 +681,16 @@ ${Object.keys(config.channels?.members || {}).map(name => `- **@${name}-investig
 
 When spawning agents for delegation, always include the \`name\` field in the Agent config to enable @mention addressing.
 
+## Reasoning Effort Propagation
+
+When the user requests high reasoning effort (e.g., "ultrathink"), propagate it to workers:
+- Set \`WOGI_EFFORT_LEVEL=high\` environment variable before dispatching
+- The dispatch system automatically prefixes channel messages with \`[effort:high]\`
+- Workers receiving \`[effort:high]\` should apply the same reasoning level to their work
+- This ensures workers don't use lower effort than what the user requested for the manager
+
+**In curl dispatches**, prefix the message: \`curl -s -X POST http://localhost:{port} -d "[effort:high] /wogi-start {taskId}"\`
+
 ## Waiting for Worker Results (CRITICAL — Automatic Return Path)
 
 Workers **automatically write results** to \`.workspace/messages/\` when they complete a task. You do NOT need to ask them to report back — the task-completed hook writes a \`task-complete\` message automatically.

package/package.json

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