metame-cli 1.5.10 → 1.5.11

package/scripts/daemon.js

@@ -48,6 +48,7 @@ const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
 const DISPATCH_LOG = path.join(DISPATCH_DIR, 'dispatch-log.jsonl');
 const { sleepSync, socketPath, needsSocketCleanup } = require('./platform');
+const { handleReactiveOutput } = require('./daemon-reactive-lifecycle');
 const SOCK_PATH = socketPath(METAME_DIR);
 
 // Resolve claude binary path (daemon may not inherit user's full PATH)
@@ -286,12 +287,28 @@ function restoreConfig() {
   if (!fs.existsSync(bak)) return false;
   try {
     const bakCfg = yaml.load(fs.readFileSync(bak, 'utf8')) || {};
-    // Preserve security-critical fields from current config (chat IDs, agent map)
-    // so a /fix never loses manually-added channels
+    // Preserve ALL user-critical fields from current config so /fix never
+    // loses secrets, chat IDs, or agent mappings
     let curCfg = {};
     try { curCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {}; } catch { }
+    // Secret fields that must NEVER be reverted by a restore
+    const SECRET_FIELDS = ['app_id', 'app_secret', 'bot_token', 'operator_ids'];
     for (const adapter of ['feishu', 'telegram']) {
       if (curCfg[adapter] && bakCfg[adapter]) {
+        // Preserve secrets: current config always wins
+        for (const field of SECRET_FIELDS) {
+          if (curCfg[adapter][field] != null) {
+            bakCfg[adapter][field] = curCfg[adapter][field];
+          }
+        }
+        // Preserve remote_dispatch secrets
+        if (curCfg[adapter].remote_dispatch && bakCfg[adapter].remote_dispatch) {
+          if (curCfg[adapter].remote_dispatch.secret) {
+            bakCfg[adapter].remote_dispatch.secret = curCfg[adapter].remote_dispatch.secret;
+          }
+        } else if (curCfg[adapter].remote_dispatch) {
+          bakCfg[adapter].remote_dispatch = curCfg[adapter].remote_dispatch;
+        }
         const curIds = curCfg[adapter].allowed_chat_ids || [];
         const bakIds = bakCfg[adapter].allowed_chat_ids || [];
         // Union of both lists
@@ -301,8 +318,15 @@ function restoreConfig() {
         bakCfg[adapter].chat_agent_map = Object.assign(
           {}, bakCfg[adapter].chat_agent_map || {}, curCfg[adapter].chat_agent_map || {}
         );
+      } else if (curCfg[adapter] && !bakCfg[adapter]) {
+        // Backup doesn't have this adapter at all — keep current entirely
+        bakCfg[adapter] = curCfg[adapter];
       }
     }
+    // Preserve projects (current takes precedence for each project key)
+    if (curCfg.projects) {
+      bakCfg.projects = Object.assign({}, bakCfg.projects || {}, curCfg.projects);
+    }
     writeConfigSafe(bakCfg);
     config = loadConfig(); // eslint-disable-line no-undef -- config is declared in main() closure
     return true;
@@ -1083,6 +1107,37 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
         chain: [], // reset chain for callbacks
       }, config);
     }
+
+    // ── Reactive lifecycle hook ──
+    try {
+      handleReactiveOutput(targetProject, outStr, loadConfig(), {
+        log,
+        loadState,
+        saveState,
+        checkBudget,
+        handleDispatchItem: (item, cfg) => {
+          dispatchTask(item.target, {
+            from: item.from || '_reactive',
+            type: 'reactive',
+            priority: 'normal',
+            new_session: !!item.new_session,
+            payload: { title: 'reactive dispatch', prompt: item.prompt },
+          }, cfg, null, null);
+        },
+        notifyUser: (msg) => {
+          try {
+            const cfg = loadConfig();
+            if (cfg.feishu && cfg.feishu.enabled && cfg.feishu.admin_chat_id) {
+              const { sendFeishuText } = require('./daemon-notify');
+              sendFeishuText(cfg.feishu.admin_chat_id, msg, cfg);
+            }
+          } catch (e) { log('WARN', `Reactive notify failed: ${e.message}`); }
+        },
+        metameDir: path.join(os.homedir(), '.metame'),
+      });
+    } catch (e) {
+      log('ERROR', `Reactive lifecycle error for ${targetProject}: ${e.message}`);
+    }
   };
   // If streamOptions provided, use real bot so output appears in target's Feishu channel.
   // Otherwise fall back to nullBot which captures output for replyFn.
@@ -1697,6 +1752,27 @@ function physiologicalHeartbeat(config) {
   } catch (e) {
     log('WARN', `Dispatch log rotation failed: ${e.message}`);
   }
+
+  // 4. Reconcile perpetual projects — detect stale reactive loops
+  try {
+    const { reconcilePerpetualProjects } = require('./daemon-reactive-lifecycle');
+    reconcilePerpetualProjects(config, {
+      log,
+      loadState,
+      saveState,
+      notifyUser: (msg) => {
+        try {
+          const cfg = loadConfig();
+          if (cfg.feishu && cfg.feishu.enabled && cfg.feishu.admin_chat_id) {
+            const { sendFeishuText } = require('./daemon-notify');
+            sendFeishuText(cfg.feishu.admin_chat_id, msg, cfg);
+          }
+        } catch (e) { log('WARN', `Reconcile notify failed: ${e.message}`); }
+      },
+    });
+  } catch (e) {
+    log('WARN', `Reconcile check failed: ${e.message}`);
+  }
 }
 
 // ── Timing constants ─────────────────────────────────────────────────────────
@@ -2315,6 +2391,7 @@ const { handleOpsCommand } = createOpsCommandHandler({
   path,
   spawn,
   execSync,
+  execFileSync,
   log,
   loadConfig,
   loadState,

package/scripts/distill.js

@@ -221,7 +221,7 @@ ${promptInput}
 
   fs.mkdirSync(POSTMORTEM_DIR, { recursive: true });
   const day = new Date().toISOString().slice(0, 10);
-  const topicSlug = sanitizeSlug(skeleton.intent || title, `session-${String(skeleton.session_id || '').slice(0, 8)}`);
+  const topicSlug = sanitizeSlug(title || skeleton.intent, `session-${String(skeleton.session_id || '').slice(0, 8)}`);
   const filePath = path.join(POSTMORTEM_DIR, `${day}-${topicSlug}.md`);
   const markdown = [
     `# ${title}`,

package/scripts/docs/maintenance-manual.md

@@ -354,7 +354,60 @@ Claude 看到 hook 注入:
 - `/dispatch to windows:hunter <任务>`：手动跨设备派发
 - `/dispatch to 猎手 <任务>`：按昵称解析，自动检测 `member.peer` 走远端
 
-## 12. 私人配置保护
+## 12. 永续任务系统（Perpetual Task Engine）
+
+### 概念
+
+永续任务系统允许任何项目作为 reactive 永续循环运行。Agent 产出信号 → daemon 解析 → 门控检查 → 调度下一步。平台完全领域无关，科研、代码审计、文档维护等任何长期任务均可接入。
+
+### 核心组件
+
+| 组件 | 文件 | 职责 |
+|------|------|------|
+| Reactive Lifecycle | `daemon-reactive-lifecycle.js` | 信号解析、budget/depth gate、事件溯源、verifier 调用、state 生成 |
+| Event Log | `~/.metame/events/<key>.jsonl` | 唯一 Source of Truth，daemon 独占写入 |
+| Manifest | `<cwd>/perpetual.yaml` | 可选项目清单（completion_signal、脚本路径、约束） |
+| Reconciliation | `reconcilePerpetualProjects()` | heartbeat 中零 token 停滞检测 |
+| Status 命令 | `/status perpetual` | 查看所有永续项目的 phase/depth/mission/status |
+
+### 接入一个新永续项目
+
+1. 在 `daemon.yaml` 中注册项目，添加 `reactive: true`
+2. 在项目目录创建 `CLAUDE.md`（定义 agent 行为）
+3. 可选：创建 `scripts/verifier.js`（阶段门控）
+4. 可选：创建 `perpetual.yaml`（覆盖默认约定）
+5. 可选：创建 `scripts/archiver.js` + `scripts/mission-queue.js`（归档与任务队列）
+
+不创建 perpetual.yaml 时，平台使用默认约定：
+- Verifier: `scripts/verifier.js`
+- Archiver: `scripts/archiver.js`
+- Mission Queue: `scripts/mission-queue.js`
+- 完成信号: `MISSION_COMPLETE`
+
+### 事件溯源协议
+
+所有状态变更记录在 `~/.metame/events/<projectKey>.jsonl`，一行一个 JSON 事件。`now/<key>.md` 和 `workspace/progress.tsv` 都是 event log 的投影（Projection），可随时从 event log 重建。
+
+Event 类型：`MISSION_START` / `DISPATCH` / `MEMBER_COMPLETE` / `PHASE_GATE` / `DEPTH_LIMIT` / `BUDGET_LIMIT` / `MISSION_COMPLETE` / `ARCHIVE` / `STALE` / `INFRA_PAUSE`
+
+### 设计契约
+
+1. **Tolerant Reader**：`replayEventLog` 逐行解析，损坏行 WARN + skip，绝不 crash
+2. **Error Semantic Isolation**：verifier L2b 区分 404（幻觉，打回 agent）和 50x（基建故障，挂起项目通知人类）
+3. **State 由 daemon 生成**：agent 只读 `now/<key>.md`，不负责维护
+
+### 故障排查
+
+| 症状 | 检查 |
+|------|------|
+| 永续项目不启动 | `daemon.yaml` 中是否有 `reactive: true`？ |
+| 完成信号不触发 | 检查 `perpetual.yaml` 中的 `completion_signal` 是否与 CLAUDE.md 一致 |
+| Verifier 不运行 | 检查 `scripts/verifier.js` 路径（或 manifest 中的自定义路径）是否存在 |
+| 项目挂起 (infra_failure) | 外部 API 不可用，检查网络。非 agent 错误。 |
+| Event log 损坏 | 重启后 replay 会跳过损坏行。`progress.tsv` 和 `now/<key>.md` 可从 event log 重建 |
+| `/status perpetual` 无输出 | 确认项目配置了 `reactive: true` |
+
+## 13. 私人配置保护（原 §12）
 
 - `daemon.yaml` 是用户私人配置，包含 API keys、chat IDs、个人项目配置
 - **绝不上传**到代码仓库，已加入 `.gitignore`
@@ -363,7 +416,7 @@ Claude 看到 hook 注入:
 - 同样不应上传的文件：`MEMORY.md`、`SOUL.md`、`.env*`
 - Agent 在执行任务时，**绝不能** `cp scripts/daemon.yaml ~/.metame/daemon.yaml`，这会覆盖用户私人配置
 
-## 13. 变更后维护动作
+## 14. 变更后维护动作
 
 1. `npm test`
 2. `npm run sync:plugin`

package/scripts/docs/pointer-map.md

@@ -130,6 +130,39 @@
   - `scripts/memory.js`：`saveFactLabels()` 原子写入 API
   - `scripts/memory-nightly-reflect.js`：`synthesized_insight` 回写、知识胶囊聚合与 `knowledge_capsule` 回写
 
+## 永续任务系统（Perpetual Task Engine）
+
+- Reactive 生命周期引擎：
+  - `scripts/daemon-reactive-lifecycle.js`
+  - 关键点：`handleReactiveOutput()` 通用任务链引擎（领域无关）；
+    `parseReactiveSignals()` 信号解析（NEXT_DISPATCH + 可配完成信号）；
+    `reconcilePerpetualProjects()` 停滞检测（零 token，heartbeat 驱动）；
+    `replayEventLog()` 事件溯源状态重放；
+    `generateStateFile()` 从 event log 生成 `now/<key>.md`（投影）；
+    `appendEvent()` 追加事件到 `~/.metame/events/<key>.jsonl`（唯一 SoT）；
+    `loadProjectManifest()` 读取项目 `perpetual.yaml`（convention over config）；
+    `resolveProjectScripts()` 按约定/manifest 发现 verifier/archiver/mission-queue 脚本
+
+- daemon.js 接入点：
+  - `scripts/daemon.js` `outputHandler` 内 `handleReactiveOutput` 调用（try/catch 隔离）
+  - `scripts/daemon.js` `physiologicalHeartbeat` 内 `reconcilePerpetualProjects` 调用
+
+- 可观测命令：
+  - `scripts/daemon-admin-commands.js`
+  - 关键点：`/status perpetual`（或 `/status reactive`）显示所有永续项目状态
+
+- 设计文档：
+  - `docs/perpetual-task-system-design.md`（v4，含 4 份附录）
+  - `docs/perpetual-task-system-plan.md`（实施计划，Phase A-C）
+
+- 项目清单协议：
+  - `<cwd>/perpetual.yaml` — 可选，声明 completion_signal / verifier / archiver / mission_queue 路径
+  - 不存在时使用默认约定：`scripts/verifier.js`、`scripts/archiver.js`、`scripts/mission-queue.js`、信号 `MISSION_COMPLETE`
+
+- 事件日志：
+  - `~/.metame/events/<projectKey>.jsonl` — append-only，daemon 独占写入
+  - Event 类型：MISSION_START / DISPATCH / MEMBER_COMPLETE / PHASE_GATE / DEPTH_LIMIT / BUDGET_LIMIT / MISSION_COMPLETE / ARCHIVE / STALE / INFRA_PAUSE
+
 ## 运行时数据位置
 
 - 画像：`~/.claude_profile.yaml`
@@ -141,6 +174,7 @@
 - 复盘文档：`~/.metame/memory/postmortems/`
 - Dispatch 队列：`~/.metame/dispatch/pending.jsonl`（本地 socket 降级）
 - 远端 Dispatch 队列：`~/.metame/dispatch/remote-pending.jsonl`（跨设备中继）
+- **永续任务事件日志**：`~/.metame/events/<projectKey>.jsonl`（唯一 SoT，append-only）
 - 共享进度白板：`~/.metame/memory/now/shared.md`
 - Agent 最新产出：`~/.metame/memory/agents/{key}_latest.md`
 - Agent 收件箱：`~/.metame/memory/inbox/{key}/`（未读），`read/`（已归档）

package/scripts/feishu-adapter.js

@@ -91,6 +91,27 @@ function createBot(config) {
     appSecret: app_secret,
   });
 
+  /**
+   * Validate credentials by attempting a lightweight API call.
+   * Returns { ok: true } or { ok: false, error: string }.
+   */
+  async function validateCredentials() {
+    try {
+      await withTimeout(client.im.chat.list({ params: { page_size: 1 } }), 15000);
+      return { ok: true };
+    } catch (err) {
+      const msg = err && err.message || String(err);
+      const isAuthError = /invalid|unauthorized|forbidden|token|credential|app_id|app_secret|permission|99991663|99991664|99991665/i.test(msg);
+      return {
+        ok: false,
+        error: isAuthError
+          ? `Feishu credential validation failed (app_id/app_secret may be incorrect): ${msg}`
+          : `Feishu API probe failed (network or config issue): ${msg}`,
+        isAuthError,
+      };
+    }
+  }
+
   // Private: send an interactive card JSON; returns { message_id } or null.
   // All card functions funnel through here to avoid repeating the SDK call.
   async function _sendInteractive(chatId, card) {
@@ -106,6 +127,7 @@ function createBot(config) {
   let _editBrokenAt = 0;        // timestamp when broken; auto-resets after 10min
 
   return {
+    validateCredentials,
     /**
      * Send a plain text message
      */
@@ -526,6 +548,9 @@ function createBot(config) {
         reconnect() {
           _log('INFO', 'Feishu manual reconnect triggered');
           reconnectDelay = 5000;
+          clearTimeout(reconnectTimer);
+          try { currentWs?.stop?.(); } catch { /* ignore */ }
+          currentWs = null;
           connect();
         },
         isAlive() {

package/scripts/memory-extract.js

@@ -74,6 +74,7 @@ const SESSION_TAGS_FILE = path.join(os.homedir(), '.metame', 'session_tags.json'
 
 /**
  * Persist session name and derived tags to ~/.metame/session_tags.json.
+ * Consumed by /sessions and /resume commands for friendly display titles.
  * Merges into existing file — never overwrites existing entries.
  */
 function saveSessionTag(sessionId, sessionName, facts) {
@@ -337,6 +338,19 @@ async function run() {
 
         sessionAnalytics.markFactsExtracted(skeleton.session_id);
 
+        // Persist session summary to memory.db sessions table (makes sessions searchable)
+        try {
+          const keywords = facts.flatMap(f => Array.isArray(f.tags) ? f.tags : [])
+            .filter((v, i, a) => a.indexOf(v) === i).slice(0, 10).join(',');
+          memory.saveSession({
+            sessionId: skeleton.session_id,
+            project: skeleton.project || 'unknown',
+            scope: skeleton.project_id || null,
+            summary: `[${session_name}] ${facts.map(f => f.value).join(' | ').slice(0, 2000)}`,
+            keywords,
+          });
+        } catch { /* non-fatal — facts already saved, session is bonus */ }
+
         // P2-A: persist session name + tags to session_tags.json
         saveSessionTag(skeleton.session_id, session_name, facts);
 
@@ -391,12 +405,26 @@ async function run() {
             const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
             const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
             console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): ${saved} facts saved${superMsg}${labelMsg}`);
+
+            // Persist Codex session summary to memory.db sessions table
+            try {
+              const keywords = facts.flatMap(f => Array.isArray(f.tags) ? f.tags : [])
+                .filter((v, i, a) => a.indexOf(v) === i).slice(0, 10).join(',');
+              memory.saveSession({
+                sessionId: cs.session_id,
+                project: skeleton.project || 'unknown',
+                scope: skeleton.project_id || null,
+                summary: `[${session_name}] ${facts.map(f => f.value).join(' | ').slice(0, 2000)}`,
+                keywords,
+              });
+            } catch { /* non-fatal */ }
+
+            saveSessionTag(cs.session_id, session_name, facts);
           } else {
             console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
           }
 
           sessionAnalytics.markCodexFactsExtracted(cs.session_id);
-          saveSessionTag(cs.session_id, session_name, facts);
           processed++;
         } catch (e) {
           console.log(`[memory-extract] Codex session error: ${e.message}`);

package/scripts/memory-nightly-reflect.js

@@ -503,6 +503,109 @@ entity_prefix: ${group.prefix}
       try { if (memory && typeof memory.close === 'function') memory.close(); } catch { /* non-fatal */ }
     }
 
+    // ── Conflict Resolution ──────────────────────────────────────────────
+    // Query CONFLICT facts grouped by entity+relation, ask Haiku to pick winner.
+    // Loser is marked superseded_by winner; winner restored to OK.
+    let conflictsResolved = 0;
+    try {
+      const conflictGroups = db.prepare(`
+        SELECT entity, relation, COUNT(*) as cnt
+        FROM facts
+        WHERE conflict_status = 'CONFLICT' AND superseded_by IS NULL
+        GROUP BY entity, relation
+        HAVING cnt >= 2
+        ORDER BY cnt DESC
+        LIMIT 10
+      `).all();
+
+      if (conflictGroups.length > 0) {
+        console.log(`[NIGHTLY-REFLECT] Found ${conflictGroups.length} conflict group(s) to resolve.`);
+
+        // Collect all conflicting facts for these groups (batch to reduce queries)
+        const allConflicts = [];
+        for (const g of conflictGroups) {
+          const rows = db.prepare(`
+            SELECT id, entity, relation, value, confidence, created_at
+            FROM facts
+            WHERE entity = ? AND relation = ? AND conflict_status = 'CONFLICT' AND superseded_by IS NULL
+            ORDER BY created_at DESC
+          `).all(g.entity, g.relation);
+          if (rows.length >= 2) allConflicts.push({ entity: g.entity, relation: g.relation, facts: rows });
+        }
+
+        if (allConflicts.length > 0) {
+          // Limit to 5 groups to avoid truncating serialized JSON
+          const conflictInput = allConflicts.slice(0, 5).map(g => ({
+            entity: g.entity,
+            relation: g.relation,
+            candidates: g.facts.slice(0, 5).map(f => ({ id: f.id, value: f.value.slice(0, 150), confidence: f.confidence, created_at: f.created_at })),
+          }));
+
+          const resolvePrompt = `你是知识库冲突调解员。以下是同一 entity+relation 下的冲突事实，请选出每组最准确的一条保留。
+
+冲突组(JSON):
+${JSON.stringify(conflictInput, null, 2)}
+
+输出 JSON 数组，每个元素对应一组冲突的裁决：
+[
+  {
+    "entity": "...",
+    "relation": "...",
+    "winner_id": "保留的fact id",
+    "reason": "一句话理由"
+  }
+]
+
+规则：
+- 优先选最新（created_at）且 confidence=high 的
+- 如果旧条目更准确具体，选旧的
+- 只输出 JSON 数组`;
+
+          try {
+            const resolveRaw = await Promise.race([
+              callHaiku(resolvePrompt, distillEnv, 60000),
+              new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+            ]);
+            const verdicts = parseJsonFromLlm(resolveRaw);
+            if (Array.isArray(verdicts)) {
+              for (const v of verdicts) {
+                if (!v || !v.winner_id || !v.entity || !v.relation) continue;
+                // Validate winner exists in our conflict set
+                const group = allConflicts.find(g => g.entity === v.entity && g.relation === v.relation);
+                if (!group) continue;
+                const winnerExists = group.facts.some(f => f.id === v.winner_id);
+                if (!winnerExists) continue;
+
+                const loserIds = group.facts.filter(f => f.id !== v.winner_id).map(f => f.id);
+                if (loserIds.length === 0) continue;
+
+                // Mark losers as superseded
+                const placeholders = loserIds.map(() => '?').join(',');
+                db.prepare(
+                  `UPDATE facts SET superseded_by = ?, conflict_status = 'OK', updated_at = datetime('now')
+                   WHERE id IN (${placeholders})`
+                ).run(v.winner_id, ...loserIds);
+
+                // Restore winner
+                db.prepare(
+                  `UPDATE facts SET conflict_status = 'OK', updated_at = datetime('now') WHERE id = ?`
+                ).run(v.winner_id);
+
+                conflictsResolved += loserIds.length;
+              }
+              if (conflictsResolved > 0) {
+                console.log(`[NIGHTLY-REFLECT] Resolved ${conflictsResolved} conflicting fact(s).`);
+              }
+            }
+          } catch (e) {
+            console.log(`[NIGHTLY-REFLECT] Conflict resolution failed (non-fatal): ${e.message}`);
+          }
+        }
+      }
+    } catch (e) {
+      console.log(`[NIGHTLY-REFLECT] Conflict query failed (non-fatal): ${e.message}`);
+    }
+
     // Write audit log
     writeReflectLog({
       status: 'success',
@@ -510,6 +613,7 @@ entity_prefix: ${group.prefix}
       decisions_written: decisions.length,
       lessons_written: lessons.length,
       synthesized_insights_saved: synthesizedSaved,
+      conflicts_resolved: conflictsResolved,
       capsules_written: capsulesWritten,
       capsule_facts_saved: capsuleFactsSaved,
       decision_file: decisions.length > 0 ? decisionFile : null,

package/scripts/signal-capture.js

@@ -97,7 +97,7 @@ function withBufferLock(fn) {
       acquired = true;
       break;
     } catch (e) {
-      if (e.code !== 'EEXIST') throw e;
+      if (e.code !== 'EEXIST') return false; // non-EEXIST errors (EMFILE, EACCES) → skip lock gracefully
       try {
         const age = Date.now() - fs.statSync(LOCK_FILE).mtimeMs;
         if (age > LOCK_STALE_MS) {
@@ -159,12 +159,12 @@ process.stdin.on('end', () => {
     // Skip empty or very short messages
     // Chinese chars carry more info per char, so use weighted length
     const weightedLen = [...prompt].reduce((sum, ch) => sum + (ch.charCodeAt(0) > 0x2e80 ? 3 : 1), 0);
-    if (weightedLen < 15) {
+    if (!isMeta && weightedLen < 15) {
       process.exit(0);
     }
 
     // Hard cap to prevent giant prompt pastes from poisoning distill budget.
-    if (prompt.length > ABSOLUTE_MAX_CAPTURE_CHARS) {
+    if (!isMeta && prompt.length > ABSOLUTE_MAX_CAPTURE_CHARS) {
       process.exit(0);
     }
     if (prompt.length > MAX_CAPTURE_CHARS) {

package/scripts/skill-evolution.js

@@ -75,6 +75,7 @@ const DEFAULT_POLICY = {
   min_evidence_for_gap: 3,
   max_updates_per_analysis: 3,
   max_gaps_per_analysis: 2,
+  max_signals_per_analysis: 30,  // cap signals sent to Haiku per run
 
   // Workflow discovery
   workflow_discovery_interval: 2,   // every N cold-path cycles
@@ -200,6 +201,7 @@ function sanitizePolicy(input) {
     min_evidence_for_gap: clampInt(merged.min_evidence_for_gap, DEFAULT_POLICY.min_evidence_for_gap, 1, 20),
     max_updates_per_analysis: clampInt(merged.max_updates_per_analysis, DEFAULT_POLICY.max_updates_per_analysis, 1, 20),
     max_gaps_per_analysis: clampInt(merged.max_gaps_per_analysis, DEFAULT_POLICY.max_gaps_per_analysis, 1, 20),
+    max_signals_per_analysis: clampInt(merged.max_signals_per_analysis, DEFAULT_POLICY.max_signals_per_analysis, 5, 100),
     workflow_discovery_interval: clampInt(merged.workflow_discovery_interval, DEFAULT_POLICY.workflow_discovery_interval, 1, 100),
     min_signals_for_workflow: clampInt(merged.min_signals_for_workflow, DEFAULT_POLICY.min_signals_for_workflow, 1, 100),
     workflow_proposal_threshold: clampInt(merged.workflow_proposal_threshold, DEFAULT_POLICY.workflow_proposal_threshold, 2, 50),
@@ -610,8 +612,15 @@ async function distillSkills() {
   if (!content) return null;
 
   const lines = content.split('\n');
-  const signals = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-  if (signals.length < policy.min_signals_for_distill) return null;
+  const allSignals = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  if (allSignals.length < policy.min_signals_for_distill) return null;
+
+  // Cap signals sent to Haiku to avoid prompt bloat / timeout.
+  // Keep most recent signals (higher relevance); overflow is still cleared.
+  const maxSignals = policy.max_signals_per_analysis || 30;
+  const signals = allSignals.length > maxSignals
+    ? allSignals.slice(-maxSignals)
+    : allSignals;
 
   // Get installed skills list
   const installedSkills = listInstalledSkills();