wogiflow 2.30.4 → 2.31.1

package/scripts/hooks/core/task-boundary-restart-coordinator.js

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+ * Task-boundary restart coordinator (wf-6e31850e A-3 / extracted from stop.js).
+ *
+ * Coordinates session restart at task boundary. Calls into
+ * task-boundary-reset for the actual SIGTERM, but handles the surrounding
+ * concerns: Phase 1 fallback marking, session-history recording.
+ *
+ * Returns `{ shouldReturn: true, result: {...} }` when the entry should
+ * short-circuit; otherwise `null` to continue.
+ */
+
+async function handleTaskBoundaryRestart({ parsedInput }) {
+  try {
+    const {
+      consumeAndTriggerRestart,
+      hasPendingMarker,
+      ensurePhase1MarkedIfRecentlyCompleted
+    } = require('./task-boundary-reset');
+
+    // Phase 1 fallback
+    try {
+      const fallback = ensurePhase1MarkedIfRecentlyCompleted();
+      if (fallback.marked && process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback marked ${fallback.taskId}`);
+      } else if (!fallback.marked && fallback.reason !== 'marker-already-present' &&
+                 fallback.reason !== 'no-fresh-completion' &&
+                 fallback.reason !== 'stale-completion' &&
+                 fallback.reason !== 'already-triggered-for-this-task' &&
+                 process.env.DEBUG) {
+        console.error(`[Stop] Phase 1 fallback skipped: ${fallback.reason}`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Stop] Phase 1 fallback error (fail-open): ${err.message}`);
+    }
+
+    if (hasPendingMarker()) {
+      try {
+        const { recordSessionEnd } = require('./session-history');
+        let cliSessionId = parsedInput?.sessionId || null;
+        if (!cliSessionId) {
+          const { PATHS, safeJsonParse } = require('../../flow-utils');
+          const path = require('node:path');
+          const ss = safeJsonParse(path.join(PATHS.state, 'session-state.json'), {});
+          cliSessionId = ss.cliSessionId || null;
+        }
+        if (cliSessionId) {
+          const { PATHS, safeJsonParse } = require('../../flow-utils');
+          const path = require('node:path');
+          const ready = safeJsonParse(path.join(PATHS.state, 'ready.json'), {});
+          const recent = ready.recentlyCompleted || [];
+          const lastCompleted = recent[0] || null;
+          recordSessionEnd({
+            cliSessionId,
+            endReason: 'task-boundary-restart',
+            tasksCompletedInSession: recent.slice(0, 5).map(t => t.id).filter(Boolean),
+            lastActiveTaskTitle: lastCompleted?.title || null
+          });
+        }
+      } catch (err) {
+        if (process.env.DEBUG) console.error(`[Stop] Session history record failed (non-fatal): ${err.message}`);
+      }
+    }
+
+    const restartResult = await consumeAndTriggerRestart({
+      transcriptPath: parsedInput?.transcriptPath
+    });
+    if (restartResult.triggered) {
+      if (process.env.DEBUG) {
+        console.error(`[Stop] Task-boundary restart triggered — claude will exit, wrapper will relaunch`);
+      }
+      return { shouldReturn: true, result: { __raw: true, continue: false } };
+    }
+    if (restartResult.reason !== 'no-pending-marker' && process.env.DEBUG) {
+      console.error(`[Stop] Task-boundary restart check: ${restartResult.reason}`);
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Task-boundary restart module error (fail-open): ${err.message}`);
+  }
+  return null;
+}
+
+module.exports = { handleTaskBoundaryRestart };

package/scripts/hooks/core/user-prompt-orchestrator.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * Wogi Flow — UserPromptSubmit Orchestrator (wf-6e31850e A-3)
+ *
+ * Extracted from scripts/hooks/entry/claude-code/user-prompt-submit.js to
+ * bring that entry file under the 120-LOC budget per
+ * .claude/rules/architecture/hook-three-layer.md.
+ *
+ * Same control flow as before. Entry user-prompt-submit.js is now a thin
+ * pass-through. Returns the coreResult that the entry forwards to the
+ * adapter.
+ */
+
+const fs = require('node:fs');
+const { checkImplementationGate } = require('./implementation-gate');
+const { checkResearchRequirement } = require('./research-gate');
+const { setRoutingPending, clearRoutingPending, ROUTING_CLEARED_PATH } = require('./routing-gate');
+const { getPhaseContextPrompt } = require('./phase-gate');
+const { buildOverdueContext } = require('./overdue-dispatches');
+const { getDossierInjection } = require('./feature-dossier-gate');
+const {
+  shouldForceExtractReview,
+  buildEnforcementMessage,
+  markLongInputPending
+} = require('./long-input-enforcement');
+const { markSkillPending, loadDurableSession } = require('../../flow-durable-session');
+const { captureCurrentPrompt } = require('../../flow-prompt-capture');
+const { spawnBackgroundDetection } = require('../../flow-correction-detector');
+const { getConfig } = require('../../flow-utils');
+
+async function orchestrateUserPromptSubmit({ input, parsedInput }) {
+  if (!input || Object.keys(input).length === 0) {
+    return { __raw: true, continue: true, hookSpecificOutput: { hookEventName: 'UserPromptSubmit' } };
+  }
+
+  const prompt = parsedInput.prompt;
+  const source = parsedInput.source;
+
+  // wf-729ab5c0 follow-up — clear pending-question marker on user response.
+  try {
+    const { clearPendingQuestion } = require('../../flow-ask');
+    const r = clearPendingQuestion();
+    if (r.wasPresent && process.env.DEBUG) {
+      console.error(`[UserPromptSubmit] Cleared pending-question marker — restart deferral released`);
+    }
+  } catch (_err) { /* non-fatal */ }
+
+  // v4.1: Detect skill commands that need execution tracking
+  if (typeof prompt === 'string') {
+    const skillMatch = prompt.match(/^\/(wogi-bulk|wogi-start)\b/i);
+    if (skillMatch) {
+      const skillName = skillMatch[1].toLowerCase();
+      markSkillPending(skillName, { prompt });
+      if (process.env.DEBUG) console.error(`[Hook] Marked /${skillName} as pending execution`);
+    }
+  }
+
+  let hookConfig;
+  try { hookConfig = getConfig(); } catch (_err) { hookConfig = {}; }
+
+  // v5.0: Capture prompt for learning system (non-blocking)
+  if (hookConfig.hooks?.rules?.intelligence?.promptCapture?.enabled !== false) {
+    if (typeof prompt === 'string' && prompt.trim().length > 0) {
+      setImmediate(() => {
+        try { captureCurrentPrompt(prompt); } catch (err) {
+          if (process.env.DEBUG) console.error(`[Hook] Prompt capture failed: ${err.message}`);
+        }
+      });
+    }
+  }
+
+  // wf-5cd71b1f: Research-required classifier
+  if (typeof prompt === 'string' && prompt.trim().length > 0) {
+    try {
+      const { applyClassification: applyResearchClassification } = require('./research-required-classifier');
+      const r = applyResearchClassification(prompt, hookConfig);
+      if (r.applied && process.env.DEBUG) {
+        console.error(`[Hook] Research-required classifier: category=${r.category}, match="${r.match}"`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Research-required classifier failed: ${err.message}`);
+    }
+  }
+
+  // wf-b8839d99: AI-based deferral classifier
+  if (typeof prompt === 'string' && prompt.trim().length > 0) {
+    try {
+      const { applyClassification } = require('./deferral-classifier');
+      const r = await applyClassification(prompt, hookConfig);
+      if (r.applied && process.env.DEBUG) {
+        console.error(`[Hook] Deferral classifier (AI): intent=${r.intent}, confidence=${r.confidence}, standing=${r.standing}, scope=${JSON.stringify(r.scope)}`);
+      } else if (process.env.DEBUG && r.reason) {
+        console.error(`[Hook] Deferral classifier (AI): no-op — ${r.reason}`);
+      }
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Deferral classifier failed: ${err.message}`);
+    }
+  }
+
+  // Correction detection (background)
+  if (hookConfig.hooks?.rules?.intelligence?.correctionDetection?.enabled !== false) {
+    if (typeof prompt === 'string' && prompt.trim().length > 0) {
+      try {
+        const session = loadDurableSession();
+        spawnBackgroundDetection(prompt, session?.taskId || '');
+      } catch (err) {
+        if (process.env.DEBUG) console.error(`[Hook] Correction detection spawn failed: ${err.message}`);
+      }
+    }
+  }
+
+  // v6.0: Routing-pending flag set/clear
+  const isWogiCommand = typeof prompt === 'string' && /^\/wogi-[a-z0-9-]+\b/i.test(prompt.trim());
+  if (!isWogiCommand) {
+    try { fs.unlinkSync(ROUTING_CLEARED_PATH); }
+    catch (err) {
+      if (err.code !== 'ENOENT' && process.env.DEBUG) console.error(`[Hook] Failed to delete cleared marker: ${err.message}`);
+    }
+    try { setRoutingPending(); }
+    catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Routing gate set failed: ${err.message}`);
+    }
+  } else {
+    try {
+      clearRoutingPending();
+      if (process.env.DEBUG) console.error(`[Hook] Cleared routing flag — prompt is a /wogi-* command`);
+    } catch (err) {
+      if (process.env.DEBUG) console.error(`[Hook] Routing gate clear failed: ${err.message}`);
+    }
+  }
+
+  // Phase context + dossier injection
+  let phasePrompt = null;
+  try {
+    const phaseContext = getPhaseContextPrompt();
+    if (phaseContext.inject && phaseContext.prompt) phasePrompt = phaseContext.prompt;
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Phase context injection failed: ${err.message}`);
+  }
+  let dossierPrompt = null;
+  try { dossierPrompt = getDossierInjection(); } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Dossier injection failed: ${err.message}`);
+  }
+  if (dossierPrompt) {
+    phasePrompt = phasePrompt ? `${phasePrompt}\n\n${dossierPrompt}` : dossierPrompt;
+  }
+
+  // Research + implementation gates
+  const researchResult = checkResearchRequirement({ prompt, source });
+  let coreResult = checkImplementationGate({ prompt, source });
+
+  if (researchResult.injectProtocol && researchResult.protocolSteps) {
+    coreResult = {
+      ...coreResult,
+      systemReminder: researchResult.protocolSteps,
+      researchTriggered: true,
+      questionType: researchResult.questionType,
+      suggestedDepth: researchResult.suggestedDepth
+    };
+  } else if (researchResult.warning && coreResult.allowed) {
+    coreResult = {
+      ...coreResult,
+      warning: true,
+      researchWarning: researchResult.message,
+      suggestedCommand: researchResult.suggestedCommand
+    };
+  }
+
+  if (phasePrompt) coreResult = { ...coreResult, phasePrompt };
+
+  // wf-d3e67abe — overdue workspace dispatches
+  try {
+    const overduePrompt = buildOverdueContext();
+    if (overduePrompt) coreResult = { ...coreResult, overduePrompt };
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Overdue dispatches check failed: ${err.message}`);
+  }
+
+  // P11.5 mechanical enforcement — long-form prompts without source-link
+  try {
+    const enforce = shouldForceExtractReview({ text: prompt, source });
+    if (enforce.forced) {
+      const msg = buildEnforcementMessage(enforce.reason, enforce.level);
+      coreResult = { ...coreResult, longInputEnforcement: msg };
+      markLongInputPending({
+        level: enforce.level,
+        reason: enforce.reason,
+        promptPreview: typeof prompt === 'string' ? prompt.slice(0, 200) : '(non-string)',
+        source: source || null,
+        repoName: process.env.WOGI_REPO_NAME || null
+      });
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Hook] Long-input enforcement check failed: ${err.message}`);
+  }
+
+  return coreResult;
+}
+
+module.exports = { orchestrateUserPromptSubmit };

package/scripts/hooks/core/workspace-stop-gates.js

@@ -0,0 +1,133 @@
+'use strict';
+
+/**
+ * Workspace Stop-hook gates (wf-6e31850e A-3 / extracted from stop.js).
+ *
+ * Three gates in sequence, all fail-open:
+ *   1. Gap B — block end-of-turn when worker has queued dispatches but no
+ *      task in progress.
+ *   2. Worker Tool-First Turn Gate (G1+G4+G6) — every worker turn after a
+ *      UserPromptSubmit must contain at least one tool call.
+ *   3. AI Worker Question Classifier (G3) — Haiku classifier blocks
+ *      turns ending with an open user-facing question in worker mode.
+ *
+ * Returns `{ shouldReturn: true, result: {...} }` to short-circuit, or null.
+ */
+
+async function checkWorkspaceStopGates({ parsedInput }) {
+  // Gap B
+  try {
+    const isWorker = process.env.WOGI_WORKSPACE_ROOT &&
+                     process.env.WOGI_REPO_NAME &&
+                     process.env.WOGI_REPO_NAME !== 'manager';
+    if (isWorker) {
+      const { getConfig, PATHS, safeJsonParse } = require('../../flow-utils');
+      const path = require('node:path');
+      const config = getConfig();
+      const gateEnabled = config.workspace?.autoPickupChannelDispatches !== false;
+      if (gateEnabled) {
+        const ready = safeJsonParse(path.join(PATHS.state, 'ready.json'), { ready: [], inProgress: [] });
+        const inProgressCount = (ready.inProgress || []).length;
+        const queued = (ready.ready || []).filter(t => {
+          if (!t || typeof t !== 'object') return false;
+          return t.channelSource === 'wogi-workspace-channel' ||
+                 t.dispatchedBy === 'workspace-manager' ||
+                 (typeof t.source === 'string' && t.source.startsWith('workspace:'));
+        });
+        if (inProgressCount === 0 && queued.length > 0) {
+          const nextId = queued[0].id;
+          const msg = [
+            `AUTONOMOUS MODE VIOLATION: ${queued.length} channel dispatch(es) queued, no task in progress.`,
+            '',
+            `You are a workspace worker — "awaiting your signal" / "let me know" / "or will proceed" is NOT a valid terminal state.`,
+            '',
+            'Exactly one of these must be true at end-of-turn:',
+            '  (a) You started the next pre-approved dispatch (ACTION), or',
+            '  (b) You channel-dispatched a "## QUESTION:" to manager (ESCALATION), or',
+            '  (c) Zero queued and zero in-progress (IDLE — not your current state).',
+            '',
+            `ACT NOW: Invoke Skill(skill="wogi-start", args="${nextId}")`,
+            '',
+            `Or escalate: curl -s -X POST http://127.0.0.1:${process.env.WOGI_MANAGER_PORT || '8800'} \\`,
+            `  -H "X-Wogi-From: ${process.env.WOGI_REPO_NAME}" \\`,
+            `  --data-binary "## QUESTION: <your blocker>"`
+          ].join('\n');
+          return { shouldReturn: true, result: { __raw: true, continue: true, stopReason: msg } };
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Workspace autopickup gate error (fail-open): ${err.message}`);
+  }
+
+  // Worker Tool-First Turn Gate
+  try {
+    const { isWorkerMode, checkWorkerToolFirstTurn, renderBlockMessage } = require('./worker-tool-first-gate');
+    if (isWorkerMode() && parsedInput?.transcriptPath) {
+      const { getConfig } = require('../../flow-utils');
+      const config = getConfig();
+      const gateCfg = config.workspace?.toolFirstTurnGate;
+      const enabled = gateCfg?.enabled !== false;
+      if (enabled) {
+        const strict = gateCfg?.strict !== false;
+        const result = checkWorkerToolFirstTurn({ transcriptPath: parsedInput.transcriptPath, strict });
+        if (result.blocked) {
+          return { shouldReturn: true, result: { __raw: true, continue: true, stopReason: renderBlockMessage(result) } };
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Worker tool-first gate error (fail-open): ${err.message}`);
+  }
+
+  // AI Worker Question Classifier
+  try {
+    const isWorker = process.env.WOGI_WORKSPACE_ROOT &&
+                     process.env.WOGI_REPO_NAME &&
+                     process.env.WOGI_REPO_NAME !== 'manager';
+    if (isWorker) {
+      const { getConfig } = require('../../flow-utils');
+      const config = getConfig();
+      const clf = config.workspace?.aiWorkerQuestionClassifier;
+      const enabled = clf?.enabled !== false;
+      if (enabled && parsedInput?.transcriptPath) {
+        const { classifyWorkerQuestion } = require('../../flow-worker-question-classifier');
+        const result = await classifyWorkerQuestion({
+          transcriptPath: parsedInput.transcriptPath,
+          minConfidence: Number.isFinite(clf?.minConfidence) ? clf.minConfidence : 70,
+          model: typeof clf?.model === 'string' ? clf.model : undefined
+        });
+        if (result?.blocked) {
+          const port = process.env.WOGI_MANAGER_PORT || '8800';
+          const repo = process.env.WOGI_REPO_NAME;
+          const msg = [
+            `WORKER→USER QUESTION DETECTED (confidence ${result.confidence}%, threshold ${result.minConfidence}%):`,
+            `  "${String(result.reason || '').slice(0, 200)}"`,
+            '',
+            'In workspace mode, workers CANNOT ask the user directly — the user only sees',
+            'the manager terminal. Your question will stall silently.',
+            '',
+            'Channel-dispatch to the manager instead, THEN end the turn:',
+            '',
+            `  curl -s -X POST http://127.0.0.1:${port} \\`,
+            `    -H "X-Wogi-From: ${repo}" \\`,
+            `    --data-binary "## QUESTION: <your question>"`,
+            '',
+            'The manager will relay to the user, capture the answer, and dispatch a',
+            'follow-up task to you with the resolved context.',
+            '',
+            'If you don\'t actually need the user — make a reasonable autonomous decision',
+            'and note it in your ## Results reply to the manager. Then end the turn.'
+          ].join('\n');
+          return { shouldReturn: true, result: { __raw: true, continue: true, stopReason: msg } };
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[Stop] Worker question classifier error (fail-open): ${err.message}`);
+  }
+
+  return null;
+}
+
+module.exports = { checkWorkspaceStopGates };

package/scripts/hooks/core/workspace-stop-notify.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/**
+ * Workspace worker-stopped notification (wf-6e31850e A-3 / extracted from stop.js).
+ *
+ * Writes a structured `worker-stopped` message to the workspace message bus
+ * so the manager's overdue-check can distinguish "graceful stop" from
+ * "silent death" vs "task-complete". Original: wf-d3e67abe.
+ */
+
+async function notifyWorkerStopped() {
+  if (!process.env.WOGI_REPO_NAME || process.env.WOGI_REPO_NAME === 'manager') return;
+  try {
+    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;
+    if (!VALID_NAME.test(repoName)) throw new Error('Invalid WOGI_REPO_NAME');
+
+    const workspaceRoot = process.env.WOGI_WORKSPACE_ROOT;
+    if (!workspaceRoot) return;
+
+    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 hasInProgress = Boolean(inProgressTask);
+    const state = hasInProgress ? 'mid-work' : 'idle';
+    const taskInProgress = hasInProgress ? inProgressTask.id : null;
+
+    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 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
+      });
+      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) {
+    if (process.env.DEBUG) console.error(`[Stop] Workspace notification failed: ${err.message}`);
+  }
+}
+
+module.exports = { notifyWorkerStopped };