metame-cli 1.5.18 → 1.5.20

package/scripts/daemon-command-router.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { resolveEngineModel } = require('./daemon-engine-runtime');
+const { rawChatId: extractOriginalChatId } = require('./core/thread-chat-id');
 
 function createCommandRouter(deps) {
   const {
@@ -224,6 +225,50 @@ function createCommandRouter(deps) {
     return inferredKey ? `_bound_${inferredKey}` : rawChatId;
   }
 
+  function resolveCurrentSessionContext(chatId, config) {
+    const chatIdStr = String(chatId || '');
+    const chatAgentMap = {
+      ...(config && config.telegram ? config.telegram.chat_agent_map : {}),
+      ...(config && config.feishu ? config.feishu.chat_agent_map : {}),
+      ...(config && config.imessage ? config.imessage.chat_agent_map : {}),
+      ...(config && config.siri_bridge ? config.siri_bridge.chat_agent_map : {}),
+    };
+    const _rawChatId = extractOriginalChatId(chatIdStr);
+    const mappedKey = chatAgentMap[chatIdStr] || chatAgentMap[_rawChatId] || projectKeyFromVirtualChatId(chatIdStr);
+    const mappedProject = mappedKey && config && config.projects ? config.projects[mappedKey] : null;
+    const preferredEngine = String((mappedProject && mappedProject.engine) || getDefaultEngine()).toLowerCase();
+    const state = loadState() || {};
+    const sessions = state.sessions || {};
+    const candidateIds = [
+      mappedKey ? buildSessionChatId(chatIdStr, mappedKey) : null,
+      buildSessionChatId(chatIdStr),
+      chatIdStr,
+    ].filter(Boolean);
+
+    for (const candidateId of candidateIds) {
+      const record = sessions[candidateId];
+      if (!record) continue;
+      const candidateSlots = [];
+      if (record.engines && typeof record.engines === 'object') {
+        if (record.engines[preferredEngine]) candidateSlots.push([preferredEngine, record.engines[preferredEngine]]);
+        for (const [engineName, slot] of Object.entries(record.engines)) {
+          if (engineName === preferredEngine) continue;
+          candidateSlots.push([engineName, slot]);
+        }
+      } else if (record.engine) {
+        candidateSlots.push([String(record.engine).toLowerCase(), record]);
+      }
+
+      for (const [engineName, slot] of candidateSlots) {
+        if (!slot) continue;
+        if (slot.id || record.cwd || slot.runtimeSessionObserved === false) {
+          return { record, slot, sessionChatId: candidateId, engine: engineName || preferredEngine };
+        }
+      }
+    }
+    return null;
+  }
+
   function getBoundProjectForChat(chatId, cfg) {
     const map = {
       ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}),
@@ -445,6 +490,13 @@ function createCommandRouter(deps) {
     const workspaceDir = extractPathFromText(input);
     const hasWorkspacePath = !!workspaceDir;
 
+    // Exclude third-party product context — "智能体" about other companies is NOT about our agents
+    // Requires BOTH a company name AND agent-related keyword to trigger, avoiding false positives on generic verbs
+    const _hasThirdPartyName = /(阿里|百度|腾讯|字节|谷歌|google|openai|微软|microsoft|deepseek|豆包|通义|文心|kimi)/i.test(input);
+    const _hasAgentWord = /(智能体|agent|助手|机器人)/i.test(input);
+    const _isAboutOurAgents = /(我的|我们的|当前|这个群|这里的|metame)/i.test(input);
+    if (_hasThirdPartyName && _hasAgentWord && !_isAboutOurAgents) return false;
+
     const hasAgentContext = /(agent|智能体|工作区|人设|绑定|当前群|这个群|chat|workspace)/i.test(input);
     const wantsList = /(列出|查看|显示|有哪些|list|show)/i.test(input) && /(agent|智能体|工作区|绑定)/i.test(input);
     const wantsUnbind = /(解绑|取消绑定|断开绑定|unbind|unassign)/i.test(input) && hasAgentContext;
@@ -574,7 +626,7 @@ function createCommandRouter(deps) {
     return false;
   }
 
-  async function handleCommand(bot, chatId, text, config, executeTaskByName, senderId = null, readOnly = false) {
+  async function handleCommand(bot, chatId, text, config, executeTaskByName, senderId = null, readOnly = false, meta = {}) {
     if (text && !text.startsWith('/chatid') && !text.startsWith('/myid')) log('INFO', `CMD [${String(chatId).slice(-8)}]: ${text.slice(0, 80)}`);
     const state = loadState();
 
@@ -604,20 +656,36 @@ function createCommandRouter(deps) {
       ...(config.siri_bridge ? config.siri_bridge.chat_agent_map : {}),
     };
     const _chatIdStr = String(chatId);
+    const _rawChatId2 = extractOriginalChatId(_chatIdStr);
     const mappedKey = chatAgentMap[_chatIdStr] ||
+      chatAgentMap[_rawChatId2] ||
       projectKeyFromVirtualChatId(_chatIdStr);
     if (mappedKey && config.projects && config.projects[mappedKey]) {
       const proj = config.projects[mappedKey];
       const projCwd = normalizeCwd(proj.cwd);
       const sessionChatId = buildSessionChatId(chatId, mappedKey);
-      const cur = loadState().sessions?.[sessionChatId];
+      const sessions = loadState().sessions || {};
+      const cur = sessions[sessionChatId];
+      const rawSession = sessions[String(chatId)];
       const projEngine = String((proj && proj.engine) || getDefaultEngine()).toLowerCase();
       // Multi-engine format stores engines in cur.engines object; legacy format uses cur.engine string.
       // Check whether the session already has a slot for the project's configured engine.
       const curHasEngine = cur && (
         cur.engines ? !!cur.engines[projEngine] : String(cur.engine || '').toLowerCase() === projEngine
       );
-      if (!cur || cur.cwd !== projCwd || !curHasEngine) {
+      const rawHasEngine = rawSession && (
+        rawSession.engines ? !!rawSession.engines[projEngine] : String(rawSession.engine || '').toLowerCase() === projEngine
+      );
+      const isVirtualSession = _chatIdStr.startsWith('_agent_') || _chatIdStr.startsWith('_scope_');
+      const shouldReattachForCwdChange =
+        !isVirtualSession &&
+        !!cur &&
+        !!curHasEngine &&
+        cur.cwd !== projCwd &&
+        !rawHasEngine;
+      if (!cur || !curHasEngine || shouldReattachForCwdChange) {
+        const initReason = !cur ? 'no-session' : (!curHasEngine ? 'engine-missing' : 'cwd-changed');
+        log('INFO', `SESSION-INIT [${String(sessionChatId).slice(-32)}] ${initReason}`);
         attachOrCreateSession(sessionChatId, projCwd, proj.name || mappedKey, proj.engine || getDefaultEngine());
       }
     }
@@ -722,10 +790,15 @@ function createCommandRouter(deps) {
     // "继续" when no task running → resume most recent session via /last, then send prompt
     const CONTINUE_RE = /^(继续|接着|go\s*on|continue)$/i;
     if (!activeProcesses.has(chatId) && CONTINUE_RE.test(text.trim())) {
-      // Delegate to /last which attaches the most recent session
+      const currentSession = resolveCurrentSessionContext(chatId, config);
+      if (currentSession) {
+        resetCooldown(chatId);
+        await askClaude(bot, chatId, '继续上面的工作', config, readOnly, senderId);
+        return;
+      }
+      // No current session bound to this chat — delegate to /last as a fallback.
       const handled = await handleSessionCommand({ bot, chatId, text: '/last' });
       if (handled) {
-        // /last attached the session — now send "继续" to actually resume the conversation
         resetCooldown(chatId);
         await askClaude(bot, chatId, '继续上面的工作', config, readOnly, senderId);
         return;
@@ -740,7 +813,8 @@ function createCommandRouter(deps) {
       ...(config.imessage ? config.imessage.chat_agent_map : {}),
       ...(config.siri_bridge ? config.siri_bridge.chat_agent_map : {}),
     };
-    const _isStrictChat = !!(_strictChatAgentMap[String(chatId)] || projectKeyFromVirtualChatId(String(chatId)));
+    const _rawChatId3 = extractOriginalChatId(String(chatId));
+    const _isStrictChat = !!(_strictChatAgentMap[String(chatId)] || _strictChatAgentMap[_rawChatId3] || projectKeyFromVirtualChatId(String(chatId)));
 
     // Nickname-only switch: bypass cooldown + budget (no Claude call)
     // Skipped for strict chats (fixed-agent groups)

package/scripts/daemon-engine-runtime.js

@@ -15,6 +15,19 @@ const CODEX_TOOL_MAP = Object.freeze({
   web_fetch: 'WebFetch',
 });
 
+const ENGINE_TIMEOUT_DEFAULTS = Object.freeze({
+  codex: Object.freeze({
+    idleMs: 10 * 60 * 1000,
+    toolMs: 25 * 60 * 1000,
+    ceilingMs: null,
+  }),
+  claude: Object.freeze({
+    idleMs: 5 * 60 * 1000,
+    toolMs: 25 * 60 * 1000,
+    ceilingMs: null,
+  }),
+});
+
 function resolveBinary(engineName, deps = {}) {
   const engine = normalizeEngineName(engineName);
   const home = deps.HOME || os.homedir();
@@ -269,6 +282,12 @@ function parseCodexStreamEvent(line) {
   return out;
 }
 
+function resolveEngineTimeouts(engineName) {
+  const engine = normalizeEngineName(engineName);
+  const base = ENGINE_TIMEOUT_DEFAULTS[engine] || ENGINE_TIMEOUT_DEFAULTS.claude;
+  return { ...base };
+}
+
 function buildClaudeArgs(options = {}) {
   const { model = ENGINE_MODEL_CONFIG.claude.main, readOnly = false, session = {}, addDirs } = options;
   const args = ['-p', '--model', model];
@@ -392,7 +411,7 @@ function buildCodexArgs(options = {}) {
   return args;
 }
 
-function buildCodexEnv(baseEnv = {}, { metameProject = '', metameSenderId = '' } = {}) {
+function buildCodexEnv(baseEnv = {}, { metameProject = '', metameSenderId = '', cwd = '' } = {}) {
   const env = { ...baseEnv, METAME_PROJECT: metameProject, METAME_SENDER_ID: String(metameSenderId || '') };
   const strippedKeys = [
     'CODEX_THREAD_ID',
@@ -400,6 +419,7 @@ function buildCodexEnv(baseEnv = {}, { metameProject = '', metameSenderId = '' }
     'CLAUDE_CODE_SSE_PORT',
   ];
   for (const key of strippedKeys) delete env[key];
+  void cwd;
   if (env.CODEX_HOME && !fs.existsSync(env.CODEX_HOME)) delete env.CODEX_HOME;
   return env;
 }
@@ -421,9 +441,9 @@ function createEngineRuntimeFactory(deps = {}) {
         defaultModel: ENGINE_MODEL_CONFIG.codex.main,
         stdinBehavior: 'write-and-close',
         killSignal: 'SIGTERM',
-        timeouts: { idleMs: 10 * 60 * 1000, toolMs: 25 * 60 * 1000, ceilingMs: 60 * 60 * 1000 },
+        timeouts: resolveEngineTimeouts('codex'),
         buildArgs: buildCodexArgs,
-        buildEnv: ({ metameProject = '', metameSenderId = '' } = {}) => buildCodexEnv(process.env, { metameProject, metameSenderId }),
+        buildEnv: ({ metameProject = '', metameSenderId = '', cwd = '' } = {}) => buildCodexEnv(process.env, { metameProject, metameSenderId, cwd }),
         parseStreamEvent: parseCodexStreamEvent,
         classifyError: classifyEngineError,
       };
@@ -434,7 +454,7 @@ function createEngineRuntimeFactory(deps = {}) {
       defaultModel: ENGINE_MODEL_CONFIG.claude.main,
       stdinBehavior: 'write-and-close',
       killSignal: 'SIGTERM',
-      timeouts: { idleMs: 5 * 60 * 1000, toolMs: 25 * 60 * 1000, ceilingMs: 60 * 60 * 1000 },
+      timeouts: resolveEngineTimeouts('claude'),
       buildArgs: buildClaudeArgs,
       buildEnv: ({ metameProject = '', metameSenderId = '' } = {}) => ({
         ...(() => {
@@ -460,6 +480,7 @@ module.exports = {
   ENGINE_DISTILL_MAP,
   ENGINE_DEFAULT_MODEL,
   _private: {
+    ENGINE_TIMEOUT_DEFAULTS,
     classifyEngineError,
     parseClaudeStreamEvent,
     parseCodexStreamEvent,
@@ -472,5 +493,6 @@ module.exports = {
     BUILTIN_CLAUDE_MODEL_VALUES,
     normalizeClaudeModel,
     looksLikeCodexModel,
+    resolveEngineTimeouts,
   },
 };

package/scripts/daemon-message-pipeline.js

@@ -283,9 +283,9 @@ function createMessagePipeline(deps) {
    */
   async function _processOne(chatId, text, ctx) {
     if (resetCooldown) resetCooldown(chatId);
-    const { bot, config, executeTaskByName, senderId, readOnly } = ctx;
+    const { bot, config, executeTaskByName, senderId, readOnly, meta } = ctx;
     try {
-      return await handleCommand(bot, chatId, text, config, executeTaskByName, senderId, readOnly);
+      return await handleCommand(bot, chatId, text, config, executeTaskByName, senderId, readOnly, meta || {});
     } catch (err) {
       log('ERROR', `Pipeline: error processing message for ${chatId}: ${err.message}`);
       return { ok: false, error: err.message };

package/scripts/daemon-reactive-lifecycle.js

@@ -4,7 +4,9 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const { execSync } = require('child_process');
-const EVENTS_DIR = path.join(os.homedir(), '.metame', 'events');
+const { buildReactivePrompt } = require('./core/reactive-prompt');
+const { calculateNextAction } = require('./core/reactive-signal');
+const { resolveReactivePaths } = require('./core/reactive-paths');
 
 /**
  * daemon-reactive-lifecycle.js — Reactive Loop Lifecycle Module
@@ -16,7 +18,7 @@ const EVENTS_DIR = path.join(os.homedir(), '.metame', 'events');
  *   3. Fresh session — every reactive dispatch uses new_session: true
  *   4. Completion signal — configurable per project (default: MISSION_COMPLETE)
  *   5. Verifier hook — runs project verifier before waking parent
- *   6. Event sourcing — all state changes logged to ~/.metame/events/
+ *   6. Event sourcing — all state changes logged to ~/.metame/reactive/<key>/
  */
 
 // ── Signal parsing ──────────────────────────────────────────────
@@ -87,6 +89,33 @@ function setReactiveStatus(state, projectKey, status, reason) {
   rs.updated_at = new Date().toISOString();
 }
 
+function isReactiveExecutionActive(projectKey, config, deps) {
+  const active = deps && deps.activeProcesses;
+  if (!active || typeof active.values !== 'function') return false;
+  const key = String(projectKey || '').trim();
+  if (!key) return false;
+  const parent = config && config.projects ? config.projects[key] : null;
+  const memberKeys = new Set(
+    Array.isArray(parent && parent.team)
+      ? parent.team.map(member => String(member && member.key || '').trim()).filter(Boolean)
+      : []
+  );
+  for (const proc of active.values()) {
+    if (!proc || proc.aborted) continue;
+    const reactiveProjectKey = String(proc.reactiveProjectKey || '').trim();
+    if (reactiveProjectKey && reactiveProjectKey === key) return true;
+    const procChatId = String(proc.chatId || proc.logicalChatId || '').trim();
+    if (!procChatId) continue;
+    if (procChatId === `_agent_${key}`) return true;
+    if (procChatId.startsWith('_scope_') && procChatId.endsWith(`__${key}`)) return true;
+    for (const memberKey of memberKeys) {
+      if (procChatId === `_agent_${memberKey}`) return true;
+      if (procChatId.startsWith('_scope_') && procChatId.endsWith(`__${memberKey}`)) return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Find the reactive parent project key for a given team member.
  * Returns the parent key string, or null if not found.
@@ -171,6 +200,24 @@ function readPhaseFromState(statePath) {
   } catch { return ''; }
 }
 
+/**
+ * Load working memory file for a project.
+ * Returns the file content as a string, or empty string if not found.
+ *
+ * @param {string} projectKey
+ * @param {string} [metameDir] - Override ~/.metame path (for testing)
+ * @returns {string}
+ */
+function loadWorkingMemory(projectKey, metameDir) {
+  const base = metameDir || path.join(os.homedir(), '.metame');
+  const paths = resolveReactivePaths(projectKey, base);
+  const memPath = paths.memory;
+  try {
+    const content = fs.readFileSync(memPath, 'utf8').trim();
+    return content || '';
+  } catch { return ''; }
+}
+
 /**
  * Run project-level verifier script if it exists.
  * Returns parsed JSON result or null if no verifier / error.
@@ -184,7 +231,8 @@ function runProjectVerifier(projectKey, config, deps) {
   if (!fs.existsSync(scripts.verifier)) return null;
 
   const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
-  const statePath = path.join(metameDir, 'memory', 'now', `${projectKey}.md`);
+  const paths = resolveReactivePaths(projectKey, metameDir);
+  const statePath = paths.state;
 
   // Read phase from event log (SoT), fall back to state file for backward compat
   const { phase: eventPhase } = replayEventLog(projectKey, deps);
@@ -223,10 +271,9 @@ function runCompletionHooks(projectKey, projectCwd, deps) {
   // 1. Archive (if script exists)
   if (fs.existsSync(scripts.archiver)) {
     try {
-      const statePath = path.join(
-        deps.metameDir || path.join(os.homedir(), '.metame'),
-        'memory', 'now', `${projectKey}.md`
-      );
+      const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
+      const rPaths = resolveReactivePaths(projectKey, metameDir);
+      const statePath = rPaths.state;
       let projectName = projectKey;
       try {
         const stateContent = fs.readFileSync(statePath, 'utf8');
@@ -304,12 +351,13 @@ function runCompletionHooks(projectKey, projectCwd, deps) {
 
 /**
  * Append an event to the project's event log.
- * Daemon-exclusive: agents cannot write to ~/.metame/events/.
+ * Daemon-exclusive: agents cannot write to ~/.metame/reactive/<key>/.
  */
 function appendEvent(projectKey, event, metameDir) {
-  const evDir = metameDir ? path.join(metameDir, 'events') : EVENTS_DIR;
-  fs.mkdirSync(evDir, { recursive: true });
-  const logPath = path.join(evDir, `${projectKey}.jsonl`);
+  const base = metameDir || path.join(os.homedir(), '.metame');
+  const paths = resolveReactivePaths(projectKey, base);
+  fs.mkdirSync(paths.dir, { recursive: true });
+  const logPath = paths.events;
   const line = JSON.stringify({ ts: new Date().toISOString(), ...event }) + '\n';
   fs.appendFileSync(logPath, line, 'utf8');
 }
@@ -323,8 +371,9 @@ function appendEvent(projectKey, event, metameDir) {
  * This function NEVER throws.
  */
 function replayEventLog(projectKey, deps) {
-  const evDir = deps?.metameDir ? path.join(deps.metameDir, 'events') : EVENTS_DIR;
-  const logPath = path.join(evDir, `${projectKey}.jsonl`);
+  const base = deps?.metameDir || path.join(os.homedir(), '.metame');
+  const paths = resolveReactivePaths(projectKey, base);
+  const logPath = paths.events;
   if (!fs.existsSync(logPath)) return { phase: '', mission: null, history: [] };
 
   const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n').filter(Boolean);
@@ -365,8 +414,9 @@ function projectProgressTsv(projectCwd, projectKey, metameDir) {
   const tsvPath = path.join(projectCwd, 'workspace', 'progress.tsv');
   const header = 'phase\tresult\tverifier_passed\tartifact\ttimestamp\tnotes\n';
 
-  const evDir = metameDir ? path.join(metameDir, 'events') : EVENTS_DIR;
-  const logPath = path.join(evDir, `${projectKey}.jsonl`);
+  const base = metameDir || path.join(os.homedir(), '.metame');
+  const paths = resolveReactivePaths(projectKey, base);
+  const logPath = paths.events;
   if (!fs.existsSync(logPath)) return;
 
   const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n').filter(Boolean);
@@ -403,7 +453,8 @@ function projectProgressTsv(projectCwd, projectKey, metameDir) {
  */
 function generateStateFile(projectKey, config, deps) {
   const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
-  const statePath = path.join(metameDir, 'memory', 'now', projectKey + '.md');
+  const paths = resolveReactivePaths(projectKey, metameDir);
+  const statePath = paths.state;
 
   const { phase, mission, history } = replayEventLog(projectKey, deps);
 
@@ -457,6 +508,10 @@ function reconcilePerpetualProjects(config, deps) {
     const staleThreshold = staleMinutes * 60 * 1000;
 
     if (Date.now() - lastUpdate > staleThreshold) {
+      if (isReactiveExecutionActive(key, config, deps)) {
+        deps.log('INFO', `Reconcile: ${key} exceeds stale threshold but reactive execution is still active`);
+        continue;
+      }
       deps.log('WARN', `Reconcile: ${key} stuck since ${rs.updated_at}`);
       setReactiveStatus(st, key, 'stale', 'no_activity');
       deps.saveState(st);
@@ -481,8 +536,8 @@ function reconcilePerpetualProjects(config, deps) {
  */
 function parseEventLog(projectKey, deps) {
   const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
-  const evDir = path.join(metameDir, 'events');
-  const logPath = path.join(evDir, `${projectKey}.jsonl`);
+  const paths = resolveReactivePaths(projectKey, metameDir);
+  const logPath = paths.events;
   if (!fs.existsSync(logPath)) return [];
 
   const raw = fs.readFileSync(logPath, 'utf8').trim().split('\n').filter(Boolean);
@@ -689,9 +744,9 @@ function buildWorkingMemory(projectKey, config, deps) {
  */
 function persistMemoryFiles(projectKey, config, deps, opts = {}) {
   const metameDir = deps.metameDir || path.join(os.homedir(), '.metame');
-  const memDir = path.join(metameDir, 'memory', 'now');
-  fs.mkdirSync(memDir, { recursive: true });
-  const memPath = path.join(memDir, `${projectKey}_memory.md`);
+  const paths = resolveReactivePaths(projectKey, metameDir);
+  fs.mkdirSync(paths.dir, { recursive: true });
+  const memPath = paths.memory;
 
   // Single parse of event log — shared across L1 and round counting
   const events = parseEventLog(projectKey, deps);
@@ -724,15 +779,13 @@ function persistMemoryFiles(projectKey, config, deps, opts = {}) {
     l2 = buildWorkingMemory(projectKey, config, deps);
     // Stash L2 for next time
     try {
-      const l2CachePath = path.join(memDir, `${projectKey}_l2cache.md`);
-      fs.writeFileSync(l2CachePath, l2, 'utf8');
+      fs.writeFileSync(paths.l2cache, l2, 'utf8');
     } catch { /* non-critical */ }
   } else {
     // Read stale L2 from cache
     try {
-      const l2CachePath = path.join(memDir, `${projectKey}_l2cache.md`);
-      if (fs.existsSync(l2CachePath)) {
-        l2 = fs.readFileSync(l2CachePath, 'utf8').trim();
+      if (fs.existsSync(paths.l2cache)) {
+        l2 = fs.readFileSync(paths.l2cache, 'utf8').trim();
       }
     } catch { /* non-critical */ }
   }
@@ -880,12 +933,51 @@ function handleReactiveOutput(targetProject, output, config, deps) {
 
   // ── Case 1: targetProject is a reactive parent ──
   if (isReactiveParent(targetProject, config)) {
-    if (!hasSignals) return;
-
     const projectKey = targetProject;
     const pName = config.projects[projectKey]?.name || projectKey;
     const st = deps.loadState();
     const rs = getReactiveState(st, projectKey);
+    const maxRetries = manifest?.no_signal_max_retries || 3;
+
+    const decision = calculateNextAction({
+      hasSignals,
+      isComplete: signals.complete,
+      noSignalCount: rs._no_signal_count || 0,
+      maxRetries,
+    });
+
+    rs._no_signal_count = decision.nextNoSignalCount;
+
+    if (decision.action === 'pause') {
+      setReactiveStatus(st, projectKey, 'paused', decision.pauseReason);
+      deps.saveState(st);
+      logEvent(projectKey, { type: 'NO_SIGNAL_PAUSE', count: decision.nextNoSignalCount });
+      if (deps.notifyUser) {
+        deps.notifyUser(`\u26a0\ufe0f ${pName} continuous ${maxRetries} rounds without signal, paused`);
+      }
+      return;
+    }
+
+    if (decision.action === 'retry') {
+      deps.saveState(st);
+      logEvent(projectKey, { type: 'NO_SIGNAL_RETRY', count: decision.nextNoSignalCount, output_length: output.length });
+      const maxDepthForRetry = manifest?.max_depth || rs.max_depth || 50;
+      const workingMemory = loadWorkingMemory(projectKey, deps.metameDir);
+      deps.handleDispatchItem({
+        target: projectKey,
+        prompt: buildReactivePrompt(
+          'Check progress and continue executing the task.',
+          { depth: rs.depth, maxDepth: maxDepthForRetry, completionSignal, workingMemory, isRetry: true }
+        ),
+        from: '_system',
+        _reactive: true,
+        _reactive_project: projectKey,
+        new_session: true,
+      }, config);
+      return;
+    }
+
+    // decision.action === 'proceed' — reset no-signal count, continue normal flow
 
     // Mission complete takes priority
     if (signals.complete) {
@@ -925,6 +1017,7 @@ function handleReactiveOutput(targetProject, output, config, deps) {
               prompt: completionResult.nextMissionPrompt,
               from: '_system',
               _reactive: true,
+              _reactive_project: projectKey,
               new_session: true,
             }, config);
           }
@@ -965,13 +1058,17 @@ function handleReactiveOutput(targetProject, output, config, deps) {
     deps.saveState(st);
 
     // Dispatch each directive with fresh session
+    const workingMemory = loadWorkingMemory(projectKey, deps.metameDir);
     for (const d of signals.directives) {
       logEvent(projectKey, { type: 'DISPATCH', target: d.target, prompt: d.prompt.slice(0, 200) });
       deps.handleDispatchItem({
         target: d.target,
-        prompt: d.prompt,
+        prompt: buildReactivePrompt(d.prompt, {
+          depth: rs.depth, maxDepth, completionSignal, workingMemory,
+        }),
         from: projectKey,
         _reactive: true,
+        _reactive_project: projectKey,
         new_session: true,
       }, config);
     }
@@ -1001,8 +1098,7 @@ function handleReactiveOutput(targetProject, output, config, deps) {
 
   // Depth gate (manifest max_depth overrides default)
   const rs = getReactiveState(st, parentKey);
-  const parentManifestForDepth = projectCwd ? loadProjectManifest(projectCwd) : null;
-  const maxDepth = parentManifestForDepth?.max_depth || rs.max_depth || 50;
+  const maxDepth = manifest?.max_depth || rs.max_depth || 50;
   if (rs.depth >= maxDepth) {
     deps.log('WARN', `Reactive: depth ${rs.depth} >= ${maxDepth}, pausing ${parentKey} (via member ${targetProject})`);
     setReactiveStatus(st, parentKey, 'paused', 'depth_exceeded');
@@ -1084,11 +1180,16 @@ function handleReactiveOutput(targetProject, output, config, deps) {
   const parentManifest = parentCwd ? loadProjectManifest(parentCwd) : null;
   const signal = parentManifest?.completion_signal || 'MISSION_COMPLETE';
   const summary = extractOutputSummary(output);
+  const parentWorkingMemory = loadWorkingMemory(parentKey, deps.metameDir);
   deps.handleDispatchItem({
     target: parentKey,
-    prompt: `[${targetProject} delivery]${verifierBlock}\n\n${summary}\n\nDecide next step. Use NEXT_DISPATCH or ${signal}.`,
+    prompt: buildReactivePrompt(
+      `[${targetProject} delivery]${verifierBlock}\n\n${summary}\n\nDecide next step.`,
+      { depth: rs.depth, maxDepth: manifest?.max_depth || rs.max_depth || 50, completionSignal: signal, workingMemory: parentWorkingMemory }
+    ),
     from: targetProject,
     _reactive: true,
+    _reactive_project: parentKey,
     new_session: true,
   }, config);
 }
@@ -1098,5 +1199,5 @@ module.exports = {
   parseReactiveSignals,
   reconcilePerpetualProjects,
   replayEventLog,
-  __test: { runProjectVerifier, readPhaseFromState, resolveProjectCwd, appendEvent, projectProgressTsv, generateStateFile, loadProjectManifest, resolveProjectScripts, parseEventLog, buildRunningMemory, scanRelevantArtifacts, buildWorkingMemory, persistMemoryFiles, extractInlineFacts, extractOutputSummary },
+  __test: { runProjectVerifier, readPhaseFromState, resolveProjectCwd, appendEvent, projectProgressTsv, generateStateFile, loadProjectManifest, resolveProjectScripts, parseEventLog, buildRunningMemory, scanRelevantArtifacts, buildWorkingMemory, persistMemoryFiles, extractInlineFacts, extractOutputSummary, isReactiveExecutionActive, loadWorkingMemory },
 };