wogiflow 2.22.0 → 2.22.2

package/scripts/hooks/core/session-start-worker.js

@@ -0,0 +1,114 @@
+/**
+ * Wogi Flow — Worker SessionStart handler (wf-restart-handoff)
+ *
+ * Handles the "worker just started" branch of SessionStart:
+ *
+ *   - If worker has queued channel dispatches in ready.json:
+ *     inject additionalContext telling the model to invoke
+ *     /wogi-start <nextId> now. Mirrors the existing Stop-hook
+ *     autopickup flow (task-completed.js::buildAutoPickupContext)
+ *     but fires at session boundary instead of turn boundary —
+ *     necessary because restart (wf-d3e67abe/2.22.1) kills the
+ *     previous claude and the Stop-hook autopickup no longer bridges
+ *     between tasks.
+ *
+ *   - Else if worker has zero in-progress + zero queued channel
+ *     dispatches: write a `worker-ready` message to the workspace
+ *     message bus so the manager can reconcile against its durable
+ *     dispatched-tasks.json and re-dispatch any work lost during
+ *     the restart window.
+ *
+ * Returns a context fragment (or null) that the SessionStart entry
+ * merges into the overall hook output.
+ *
+ * Fail-open: any error returns null and logs in DEBUG mode. Never
+ * blocks session startup.
+ */
+
+const path = require('node:path');
+
+const WORKER_READY_LIB = path.join(__dirname, '..', '..', '..', 'lib', 'workspace-worker-ready.js');
+const TASK_COMPLETED_CORE = path.join(__dirname, 'task-completed.js');
+
+/**
+ * Handle worker SessionStart.
+ *
+ * @returns {{branch: 'auto-resume'|'announce-ready'|'skip', context?: string, announced?: Object, pickup?: Object}}
+ */
+function handleWorkerSessionStart() {
+  try {
+    const { isWorker, shouldAnnounceReady, announceWorkerReady } = require(WORKER_READY_LIB);
+    if (!isWorker()) return { branch: 'skip', reason: 'not-worker' };
+
+    // Check for queued work first — if any, tell the model to pick it up
+    // instead of announcing idle readiness.
+    let pickup;
+    try {
+      const { findQueuedChannelDispatches, buildAutoPickupContext } = require(TASK_COMPLETED_CORE);
+      pickup = findQueuedChannelDispatches();
+      if (pickup && pickup.count > 0 && pickup.nextTaskId) {
+        const base = buildAutoPickupContext(pickup);
+        // Adjust the leading line for session-start context — the canonical
+        // pickup message starts with "You just completed a task." which isn't
+        // true on session start. Re-frame it here.
+        const context = [
+          `⚡ WORKSPACE SESSION START — ${pickup.count} CHANNEL DISPATCH${pickup.count === 1 ? '' : 'ES'} QUEUED`,
+          '',
+          `This fresh worker session has ${pickup.count} channel-dispatched task${pickup.count === 1 ? '' : 's'} queued in ready.json.`,
+          `The previous session restarted cleanly (wogi-claude wrapper). Pick up the next task now.`,
+          '',
+          `Next: ${pickup.nextTaskId} — ${pickup.nextTaskTitle || '(no title)'}`,
+          '',
+          'AUTONOMOUS MODE CONTRACT (workspace worker):',
+          '  • These dispatches are pre-approved by the manager.',
+          '  • You MUST start the next one IMMEDIATELY in this same turn.',
+          '  • Do NOT hedge ("awaiting signal", "let me know"). Forbidden.',
+          '',
+          `ACT NOW: Invoke Skill(skill="wogi-start", args="${pickup.nextTaskId}")`
+        ].join('\n');
+        // base included for logging/telemetry parity if we ever want to diff them
+        void base;
+        return { branch: 'auto-resume', context, pickup };
+      }
+    } catch (err) {
+      if (process.env.DEBUG) {
+        console.error(`[session-start-worker] pickup-check failed (fail-open): ${err.message}`);
+      }
+    }
+
+    // No queued work — announce readiness so the manager can reconcile.
+    const decision = shouldAnnounceReady();
+    if (!decision.announce) {
+      return { branch: 'skip', reason: decision.reason };
+    }
+
+    const announced = announceWorkerReady(decision.workspaceRoot, decision.repoName);
+    if (!announced.written) {
+      if (process.env.DEBUG) {
+        console.error(`[session-start-worker] announce failed: ${announced.reason}`);
+      }
+      return { branch: 'skip', reason: announced.reason };
+    }
+
+    // Optional context surface — not strictly needed since the manager
+    // handles reconciliation asynchronously, but a one-line note helps
+    // humans reading worker transcripts understand why the worker is idle.
+    const context = [
+      `Worker session started with empty queue.`,
+      `Announced readiness to manager (msg ${announced.messageId}) —`,
+      `manager will reconcile against its dispatch log and re-dispatch`,
+      `any work lost during the restart window.`
+    ].join(' ');
+
+    return { branch: 'announce-ready', context, announced };
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[session-start-worker] unexpected error (fail-open): ${err.message}`);
+    }
+    return { branch: 'skip', reason: `error: ${err.message}` };
+  }
+}
+
+module.exports = {
+  handleWorkerSessionStart
+};

package/scripts/hooks/entry/claude-code/session-start.js

@@ -303,5 +303,27 @@ runHook('SessionStart', async ({ parsedInput }) => {
     }
   }
 
+  // Workspace worker restart-handoff (wf-restart-handoff / 2.22.2).
+  // When the wogi-claude wrapper restarts a worker (via task-boundary-reset),
+  // queued dispatches from the PRIOR session are picked up by auto-resume;
+  // if the queue is truly empty, announce worker-ready so the manager can
+  // reconcile against its dispatch log and re-dispatch anything lost during
+  // the restart window. See scripts/hooks/core/session-start-worker.js.
+  try {
+    const { handleWorkerSessionStart } = require('../../core/session-start-worker');
+    const workerResult = handleWorkerSessionStart();
+    if (workerResult.context && coreResult && coreResult.context) {
+      if (workerResult.branch === 'auto-resume') {
+        coreResult.context.workerAutoResume = workerResult.context;
+      } else if (workerResult.branch === 'announce-ready') {
+        coreResult.context.workerReadyAnnounce = workerResult.context;
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[session-start] Worker session-start handler failed: ${err.message}`);
+    }
+  }
+
   return coreResult;
 }, { failMode: 'warn' });

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

@@ -61,57 +61,84 @@ runHook('Stop', async ({ parsedInput }) => {
     };
   }
 
-  // Workspace worker: send results to manager via HTTP when stopping.
-  // Uses execFileSync with array args to avoid shell injection (finding-001).
-  if (process.env.WOGI_MANAGER_PORT && process.env.WOGI_REPO_NAME && process.env.WOGI_REPO_NAME !== 'manager') {
+  // Workspace worker: write a structured `worker-stopped` message to the
+  // workspace message bus when stopping. This is the graceful-stop half of
+  // silent-halt detection (wf-d3e67abe) — the manager's overdue check uses
+  // this (vs. task-complete vs. nothing) to tell "finished" from "gave up
+  // gracefully" from "died silently".
+  //
+  // Replaces the previous plain-text curl POST to the manager channel — that
+  // was fire-and-forget with no structure, so manager-side reconciliation
+  // couldn't distinguish graceful stops from silent deaths.
+  if (process.env.WOGI_REPO_NAME && process.env.WOGI_REPO_NAME !== 'manager') {
     try {
-      const { execFileSync, execSync } = require('node:child_process');
-      const path = require('node:path');
+      const nodePath = require('node:path');
+      const childProcess = require('node:child_process');
       const VALID_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
       const repoName = process.env.WOGI_REPO_NAME;
-      const managerPort = parseInt(process.env.WOGI_MANAGER_PORT, 10);
 
-      // Validate inputs before using them (finding-001, finding-002)
-      if (!VALID_NAME.test(repoName) || !Number.isInteger(managerPort) || managerPort < 1024 || managerPort > 65535) {
-        throw new Error(`Invalid WOGI_REPO_NAME or WOGI_MANAGER_PORT`);
+      if (!VALID_NAME.test(repoName)) {
+        throw new Error(`Invalid WOGI_REPO_NAME`);
       }
 
-      // Build summary from available state
-      const summaryParts = [];
-      const { PATHS, safeJsonParse } = require('../../flow-utils');
+      const workspaceRoot = process.env.WOGI_WORKSPACE_ROOT;
+      if (workspaceRoot) {
+        const { PATHS, safeJsonParse } = require('../../flow-utils');
+        const ready = safeJsonParse(nodePath.join(PATHS.state, 'ready.json'), {});
+        const recentTask = (ready.recentlyCompleted || [])[0];
+        const inProgressTask = (ready.inProgress || [])[0];
+        const mostRecent = recentTask || inProgressTask;
 
-      const ready = safeJsonParse(path.join(PATHS.state, 'ready.json'), {});
-      const recentTask = (ready.recentlyCompleted || [])[0];
-      const inProgressTask = (ready.inProgress || [])[0];
-      const task = recentTask || inProgressTask;
+        // Determine worker state at stop-time
+        const hasInProgress = Boolean(inProgressTask);
+        const state = hasInProgress ? 'mid-work' : 'idle';
+        const taskInProgress = hasInProgress ? inProgressTask.id : null;
 
-      if (task) {
-        summaryParts.push(`**Task**: ${task.title || task.id}`);
-        if (task.type) summaryParts.push(`**Type**: ${task.type}`);
-      }
+        // Best-effort lastSha
+        let lastSha = null;
+        try {
+          lastSha = childProcess.execSync('git rev-parse --short HEAD 2>/dev/null || true', {
+            cwd: PATHS.root,
+            encoding: 'utf-8',
+            timeout: 2000
+          }).trim() || null;
+        } catch (_err) { /* non-critical */ }
 
-      try {
-        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) {
-          summaryParts.push(`**Files changed**: ${allChanged.join(', ')}`);
+        // Build structured message and persist via the workspace message bus.
+        // The worker-stopped type was added to MESSAGE_TYPES in
+        // workspace-messages.js (wf-d3e67abe).
+        try {
+          const libMessages = nodePath.resolve(__dirname, '..', '..', '..', '..', 'lib', 'workspace-messages');
+          const { createMessage, saveMessage } = require(libMessages);
+          const msg = createMessage({
+            from: repoName,
+            to: 'manager',
+            type: 'worker-stopped',
+            subject: hasInProgress
+              ? `Worker stopped mid-work on ${taskInProgress}`
+              : `Worker stopped (idle)`,
+            body: [
+              `Worker "${repoName}" is stopping.`,
+              `State: ${state}`,
+              taskInProgress ? `Task in progress: ${taskInProgress}` : null,
+              mostRecent?.title ? `Most recent task: ${mostRecent.title}` : null,
+              lastSha ? `Last commit: ${lastSha}` : null
+            ].filter(Boolean).join('\n'),
+            priority: hasInProgress ? 'high' : 'medium',
+            actionRequired: hasInProgress
+          });
+          // Attach structured fields the manager-side reconciler consumes.
+          msg.taskId = taskInProgress;
+          msg.reason = 'graceful';
+          msg.state = state;
+          msg.taskInProgress = taskInProgress;
+          msg.lastSha = lastSha;
+          saveMessage(workspaceRoot, msg);
+        } catch (err) {
+          if (process.env.DEBUG) {
+            console.error(`[Stop] Workspace message write failed: ${err.message}`);
+          }
         }
-      } catch (_err) { /* non-critical */ }
-
-      const body = summaryParts.join('\n') || `Work completed by ${repoName}.`;
-
-      // execFileSync with array args — no shell interpretation (finding-001 fix)
-      try {
-        execFileSync('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'] });
-      } catch (_err) {
-        // Manager might be offline — that's OK
       }
     } catch (err) {
       if (process.env.DEBUG) {
@@ -168,14 +195,32 @@ runHook('Stop', async ({ parsedInput }) => {
     }
 
     const restartResult = consumeAndTriggerRestart();
-    if (restartResult.triggered && process.env.DEBUG) {
-      console.error(`[Stop] Task-boundary restart triggered — claude will exit, wrapper will relaunch`);
-    } else if (!restartResult.triggered && restartResult.reason !== 'no-pending-marker' && process.env.DEBUG) {
+    if (restartResult.triggered) {
+      if (process.env.DEBUG) {
+        console.error(`[Stop] Task-boundary restart triggered — claude will exit, wrapper will relaunch`);
+      }
+      // CRITICAL: return NOW, short-circuiting subsequent stop-blocking gates.
+      //
+      // Before this fix (observed 2026-04-17): Phase 2 would SIGTERM claude and
+      // write the restart flag, then fall through to the workspace autopickup
+      // gate (lines below). For a worker with queued dispatches (the common
+      // case), that gate returns `{ continue: true, stopReason: ... }` which
+      // Claude Code honours as "don't stop, pick up next dispatch." Result: the
+      // SIGTERM + restart flag became a no-op because claude was told to keep
+      // running in the SAME session. Symptom: single claude PID survives across
+      // N tasks, context accumulates, tokens burn — exactly the complaint this
+      // feature was supposed to solve.
+      //
+      // The restart is our stop path. The next session's SessionStart hook will
+      // inject queued-dispatch context, so the worker picks up the next task
+      // on RESTART rather than via the autopickup gate's continue-override.
+      // __raw skips the adapter transform — we want the literal {continue:false}
+      // wire format to reach claude unchanged.
+      return { __raw: true, continue: false };
+    }
+    if (restartResult.reason !== 'no-pending-marker' && process.env.DEBUG) {
       console.error(`[Stop] Task-boundary restart check: ${restartResult.reason}`);
     }
-    // If we SIGTERM'd our parent, the process will begin shutting down. Still
-    // return the normal Stop-hook result so any in-flight return value flows
-    // back to claude before the signal is handled.
   } catch (err) {
     if (process.env.DEBUG) {
       console.error(`[Stop] Task-boundary restart module error (fail-open): ${err.message}`);

package/scripts/hooks/entry/claude-code/user-prompt-submit.js

@@ -12,6 +12,7 @@ const { checkImplementationGate } = require('../../core/implementation-gate');
 const { checkResearchRequirement } = require('../../core/research-gate');
 const { setRoutingPending, clearRoutingPending, ROUTING_CLEARED_PATH } = require('../../core/routing-gate');
 const { getPhaseContextPrompt } = require('../../core/phase-gate');
+const { buildOverdueContext } = require('../../core/overdue-dispatches');
 const { markSkillPending, loadDurableSession } = require('../../../flow-durable-session');
 const { captureCurrentPrompt } = require('../../../flow-prompt-capture');
 const { spawnBackgroundDetection } = require('../../../flow-correction-detector');
@@ -172,6 +173,23 @@ runHook('UserPromptSubmit', async ({ input, parsedInput }) => {
     };
   }
 
+  // wf-d3e67abe — surface overdue workspace dispatches (silent worker deaths)
+  // to the manager model before it processes the next prompt. Manager-only;
+  // fail-open (buildOverdueContext returns null on any error or wrong scope).
+  try {
+    const overduePrompt = buildOverdueContext();
+    if (overduePrompt) {
+      coreResult = {
+        ...coreResult,
+        overduePrompt
+      };
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[Hook] Overdue dispatches check failed: ${err.message}`);
+    }
+  }
+
   return coreResult;
 }, {
   failMode: 'block',