kenaz 0.3.10 → 0.3.12

package/core/.formation/tools/post-complete.js

@@ -43,24 +43,18 @@
  * |-------|------------------------------------------|-------------------------------------------|----------------------------|-------------------------------------|
  * | GC    | gcStaleWorktrees()                       | always                                    | try/catch (non-fatal)      | orphan worktrees accumulate          |
  * | Guard | Duplicate-suppress guard                 | recent worktree pass for same taskId (<2m) | try/catch (non-fatal)     | double execution                    |
- * | 0     | Hippocampus episode start                | taskId && !dryRun                         | try/catch (non-fatal)      | episodes not started                |
  * | 1     | archiveCheck()                           | !skipArchive                              | inline logging             | none — optional                     |
  * | 2     | gitBranchAndMerge() or _gitMergeFromWorktree() | !skipGit && taskId              | throws (caught at CLI)     | task stuck in active                |
  * | 2.5a  | Yggdrasil commit-sync (fire-and-forget)  | gitResult.committed && !dryRun            | catch (silent)             | sync missed silently                |
- * | 2.6a  | Passive rune extraction                  | gitResult.committed && !dryRun            | catch (silent)             | runes not extracted                 |
  * | 2.7   | Outcome recording + surprise detection   | !dryRun                                   | catch (silent)             | no outcome metrics recorded         |
  * | 2.8   | Skill matrix update                      | !dryRun                                   | catch (log warning)        | metrics not updated                 |
  * | 2.9   | Cognitive attribution                    | !dryRun && mergeSucceeded                 | catch (silent)             | attribution missed                  |
  * | 2.5b  | Complete/block task via task-api         | merge success or failure                  | spawnSync; safety net move | task stuck in active                |
  * | 2.5c  | Record AC failures (ACCEPTANCE_FAILED)   | acFailures.length > 0                     | catch (log)                | AC failures invisible               |
  * | 2.5d  | Safety net: force-move to done           | merge succeeded but complete() failed     | spawnSync                  | task stays in active                |
- * | 2.5e  | Passive rune extraction (completed)      | result.taskCompleted && !dryRun           | catch (silent)             | completion runes not tagged         |
  * | 2.6b  | Ansuz inbox signal                       | result.taskCompleted && !dryRun           | catch (silent)             | Ansuz not notified                  |
  * | 2.6c  | Relay task_completed event (TASK_1409)   | result.taskCompleted && !dryRun && relay  | catch (silent)             | PM inbox not notified cross-node    |
  * | 3     | Memory agent onTaskCompleted/onError     | memoryAgent && taskId                     | catch (log warning)        | memory event not queued             |
- * | 3b    | Provenance runes (synapse_inscribe)      | !dryRun && git.merged                     | catch (silent)             | provenance not tagged               |
- * | 4     | Guardian health check + KEEP/REVERT      | taskId (always)                           | catch (log)                | no feedback signal for loop         |
- * | 6     | Hippocampus episode close                | hippocampusEpisodeId set                  | catch (log warning)        | episode not closed properly         |
  *
  * A.2  gitBranchAndMerge() — serial mode (L2344)
  *
@@ -333,7 +327,6 @@ try {
 
 const CONFIG = {
   DEFAULT_KEEP: 10,
-  GUARDIAN_INTERVAL: 10, // Run synapse_health snapshot every N completed tasks
 };
 
 // ?????????????????????????????????????????????????????????????????????????????
@@ -1199,20 +1192,15 @@ function gcStaleWorktrees(currentTaskId, projectPath) {
 
 // ============================================================================
 // Cognitive tool usage tracking (TASK_1105)
-// Records which cognitive tools (synapse_recall, kenaz_lsp_*, ddx, etc.) were
+// Records which cognitive tools (kenaz_lsp_*, ddx, etc.) were
 // invoked during the task, aggregates into .kenaz/specialist/ansuz_self_model.json
 // under cognitive_competence, and flags negative-trend tools as mirror blind spots.
 // ============================================================================
 
 const COGNITIVE_TOOLS = [
-  'synapse_recall',
   'kenaz_lsp_callers',
   'kenaz_lsp_references',
-  'synapse_inscribe',
-  'synapse_forge',
   'ddx',
-  'hippocampus_episode_start',
-  'cortex_recall',
 ];
 
 function sleepSync(ms) {
@@ -1778,6 +1766,98 @@ function classifyMergeFailureReason(g) {
   return 'git_step_failed';
 }
 
+/**
+ * TASK_2420: the real cause of a failed spawnSync. stderr/stdout first, then the spawn
+ * error (ENOENT / ETIMEDOUT), then the signal, then the exit code — never a bare "unknown".
+ */
+function spawnFailureCause(res) {
+  if (!res) return 'no result from child process';
+  const text = (res.stderr || res.stdout || '').toString().trim();
+  if (text) return text.split('\n')[0];
+  if (res.error) return `${res.error.code ? res.error.code + ': ' : ''}${res.error.message}`;
+  if (res.signal) return `child killed by signal ${res.signal} (timeout?)`;
+  return `child exited with code ${res.status} and no output`;
+}
+
+/**
+ * TASK_2420: git step that has nothing to integrate (task declared source-less: runtime /
+ * config repair). Never skips when real work exists: a worktree or a task/<id> branch that
+ * is ahead of the user branch means there IS something to merge, so that is a failure.
+ */
+function buildNoSourceGitResult(taskId, projectPath, worktreePath) {
+  const skipReason = 'no branch: nothing to integrate';
+  const taskBranch = `task/${taskId.toLowerCase()}`;
+  const root = resolveProjectRoot(projectPath);
+  const refuse = (why) => ({
+    taskBranch, userBranch: null, originalBranch: null, committed: false, merged: false,
+    verify_merge_landed: false, failure_reason: 'no_source_but_work_exists', blockedReason: why,
+  });
+  if (worktreePath) return refuse(`--no-source given but worktree ${worktreePath} exists; merge it or drop --no-source`);
+  if (root && branchExists(taskBranch, root)) {
+    const userBranch = resolveUserBranch(root);
+    const ahead = userBranch ? git(`rev-list ${userBranch}..${taskBranch}`, { cwd: root, throws: false }) : null;
+    if (ahead === null || ahead.trim()) {
+      return refuse(`--no-source given but ${taskBranch} exists with commits not on ${userBranch}; merge it or drop --no-source`);
+    }
+  }
+  return { taskBranch: null, userBranch: null, originalBranch: null, committed: false, merged: false,
+    noChanges: true, gitSkipped: true, noSource: true, gitSkipReason: 'no_source', gitSkipDetail: skipReason };
+}
+
+/**
+ * TASK_2420: truthful per-step summary of a postComplete() result.
+ * outcome: 'completed' | 'completed_with_warnings' | 'not_completed'.
+ * Semantics: a git step that failed means the card must NOT be reported completed — it is
+ * moved to blocked/ (existing behaviour) and `cardState` says where it really is. Failures
+ * after the merge landed (card bookkeeping) leave code delivered, so they are warnings.
+ */
+function summarizePostComplete(result) {
+  const steps = [];
+  const warnings = [];
+  const g = result.git;
+  let gitFailed = false;
+  if (!g) {
+    steps.push({ step: 'git', status: 'skipped', reason: 'git step not run' });
+  } else if (isVerifiedMergeSuccess(g)) {
+    steps.push({ step: 'git', status: 'ok' });
+  } else if (g.noSource) {
+    steps.push({ step: 'git', status: 'skipped', reason: g.gitSkipDetail });
+    steps.push({ step: 'verify_merge', status: 'skipped', reason: g.gitSkipDetail });
+  } else if (g.gitSkipped) {
+    steps.push({ step: 'git', status: 'skipped', reason: g.gitSkipReason || 'git step skipped' });
+  } else if (g.noGitRepo) {
+    steps.push({ step: 'git', status: 'skipped', reason: 'not a git repository' });
+  } else if (g.noChanges) {
+    steps.push({ step: 'git', status: 'skipped', reason: g.memoryOnly ? 'memory-only task' : 'no changes within declared scope' });
+  } else {
+    gitFailed = true;
+    const cause = [classifyMergeFailureReason(g), g.blockedReason, g.mergeErrorText, g.gitException, g.verify_merge_landed_reason]
+      .filter(Boolean).map(s => String(s).split('\n')[0]).filter((s, i, a) => a.indexOf(s) === i).join(' | ');
+    steps.push({ step: 'git', status: 'failed', reason: cause });
+  }
+  let cardState = null;
+  if (gitFailed) {
+    if (result.taskBlocked || result.reconciliationApplied) {
+      cardState = 'blocked';
+      steps.push({ step: 'move_blocked', status: 'ok' });
+    } else if (result.reconciliationChecked) {
+      cardState = 'active';
+      steps.push({ step: 'move_blocked', status: 'failed', reason: g.blockError || 'card is not in done/ but could not be moved to blocked/' });
+    } else {
+      cardState = 'done_unreconciled';
+      steps.push({ step: 'move_blocked', status: 'failed', reason: g.blockError || 'unknown' });
+      steps.push({ step: 'reconcile', status: 'failed', reason: result.reconcileError || 'reconciliation did not run' });
+    }
+  } else if (g && !result.taskCompleted && result.completeError) {
+    warnings.push(`card completion step failed: ${result.completeError || 'see log'}`);
+  }
+  if (result.forsetiL0 && result.forsetiL0.status === 'FAIL') {
+    warnings.push(`Forseti L0: ${result.forsetiL0.failures.map(f => f.message).join('; ')}`);
+  }
+  const outcome = gitFailed ? 'not_completed' : (warnings.length ? 'completed_with_warnings' : 'completed');
+  return { outcome, cardState, steps, warnings };
+}
+
 function blockTaskForMergeFailure(taskId, projectPath, gitResult) {
   if (!taskId) return false;
 
@@ -1858,7 +1938,9 @@ function blockTaskForMergeFailure(taskId, projectPath, gitResult) {
 
   if (updateResult.status !== 0) {
     const errMsg = (updateResult.stderr || updateResult.stdout || '').trim();
-    console.log(`   ⚠️  Failed to move ${taskId} to blocked/: ${errMsg.split('\n')[0] || 'unknown error'}`);
+    const cause = spawnFailureCause(updateResult);
+    console.log(`   ⚠️  Failed to move ${taskId} to blocked/: ${cause}`);
+    if (gitResult) gitResult.blockError = cause;
     return false;
   }
 
@@ -2039,23 +2121,6 @@ setStagingConfig(CONFIG);
 // ─────────────────────────────────────────
 
 const TASK_STATUS_DIRS = ['backlog', 'todo', 'active', 'done', 'blocked'];
-// ?????????????????????????????????????????????????????????????????????????????
-// SECTION: HEALTH_AND_GUARDIAN (extracted to ./post-complete/health.js)
-// ?????????????????????????????????????????????????????????????????????????????
-const {
-  resolveMcpProjectPath,
-  readLoopConfig,
-  measureHealthScoreSync,
-  readPreTaskHealthSnapshot,
-  saveTaskHealthSnapshot,
-  computeHealthVerdict,
-  writeVerdictToTask,
-  readGuardianCounter,
-  writeGuardianCounter,
-  triggerGuardianHealthCheck,
-  HEALTH_SNAPSHOTS_DIR_NAME,
-} = require('./post-complete/health');
-
 // TASK_1885: deliberately NOT the same knob as loopCfg.revert_threshold (DEFAULT_REVERT_THRESHOLD
 // in health.js). This is a fixed calibration point for the Design Reasoning Attribution valence
 // classifier (feeds skill matrix / EFE learning signals) -- it answers "was this outcome bad
@@ -2076,8 +2141,6 @@ const {
   parseCognitiveCheckpoint,
   detectCognitiveCheckpoint,
   collectThinkingTags,
-  triggerPassiveRuneExtraction,
-  callHippocampusMcpSync,
 } = require('./post-complete/cognitive');
 initCognitive({ findLogForTask, getPostCompleteChangedFiles, rankTouchedFiles, stripCJK });
 
@@ -2094,7 +2157,7 @@ const {
   updateSkillMatrix,
   accumulateValence,
 } = require('./post-complete/outcome');
-initOutcome({ resolveProjectRoot, resolveTasksBase, loadTaskScopePaths, getPostCompleteChangedFiles, callHippocampusMcpSync });
+initOutcome({ resolveProjectRoot, resolveTasksBase, loadTaskScopePaths, getPostCompleteChangedFiles });
 
 // ?????????????????????????????????????????????????????????????????????????????
 // SECTION: INTEGRATION_GAPS (extracted to ./post-complete/integration-gaps.js)
@@ -2155,6 +2218,7 @@ function postComplete(opts = {}) {
     formation,
     skill,
     worktreePath = process.env.FORMATION_WORKTREE_PATH || null,
+    noSource = false,
   } = opts;
 
   // B11: opportunistic GC of orphan worktrees from prior failed dispatches
@@ -2182,56 +2246,6 @@ function postComplete(opts = {}) {
 
   const result = { archive: null, git: null };
 
-  // Step 0: Hippocampus Episode Start (episodic memory — TASK_716)
-  // TASK_963: Resolve touched file_paths so Rust can create TOUCHES edges to Symbols
-  let hippocampusEpisodeId = null;
-  if (taskId && !dryRun) {
-    try {
-      // Collect file_paths from worktree git diff or task scope_paths
-      let filePaths = [];
-      const diffRoot = worktreePath || resolveProjectRoot(projectPath);
-      if (diffRoot) {
-        try {
-          const diffCmd = worktreePath
-            ? 'git diff --name-only main...HEAD'
-            : 'git diff --name-only HEAD~1 HEAD';
-          const diffOut = spawnSync('git', diffCmd.split(' ').slice(1), {
-            cwd: diffRoot, encoding: 'utf8', timeout: 8000, windowsHide: true,
-          });
-          if (diffOut.status === 0 && diffOut.stdout) {
-            filePaths = diffOut.stdout.trim().split('\n').filter(Boolean);
-          }
-        } catch { /* git diff failed — fall through to scope_paths */ }
-      }
-      if (filePaths.length === 0) {
-        filePaths = loadTaskScopePaths(taskId, projectPath);
-      }
-
-      const epArgs = {
-        task_id: taskId,
-        scope: `post-complete:${taskId}`,
-        agent_role: formation || 'unit',
-        agent_skill: skill || 'do',
-        ...(filePaths.length > 0 ? { file_paths: filePaths } : {}),
-        // TASK_2025: hippocampus_episode_start is now a write tool that requires
-        // an explicit projectPath (mcp.rs resolve_project_for_write) -- it no
-        // longer silently falls back to the Dashboard's currently-selected
-        // project. projectPath is only set here when --project-path was passed
-        // (sub-project dispatch); core-project dispatches never pass it, so
-        // fall back to ROOT (this script's own core project root) rather than
-        // omitting the param and hard-failing every core-project run.
-        projectPath: projectPath || ROOT,
-      };
-      const epResult = callHippocampusMcpSync('hippocampus_episode_start', epArgs);
-      if (epResult && epResult.episode_id) {
-        hippocampusEpisodeId = epResult.episode_id;
-        console.log(`   🧠 Hippocampus: episode ${hippocampusEpisodeId} started (${filePaths.length} file_paths)`);
-      }
-    } catch (e) {
-      console.log(`   ⚠️  Hippocampus episode start skipped: ${e.message}`);
-    }
-  }
-
   // Step 1: Archive
   if (!skipArchive) {
     console.log('── Archive Check ──');
@@ -2325,7 +2339,13 @@ function postComplete(opts = {}) {
       // branch commits + the YAML move enter main).
       // Flag absent (default) => legacy gitBranchAndMerge path, byte-identical
       // to previous behavior — rollback is trivial. Dry runs stay on legacy.
-      if (process.env.KENAZ_INTEGRATION_QUEUE === '1' && !dryRun) {
+      if (noSource) {
+        // TASK_2420: explicit source-less completion (runtime/config repair, no branch).
+        gitResult = buildNoSourceGitResult(taskId, projectPath, worktreePath);
+        console.log(gitResult.noSource
+          ? `   ⏭️  git merge/verify skipped (${gitResult.gitSkipDetail})`
+          : `   ❌ --no-source refused: ${gitResult.blockedReason}`);
+      } else if (process.env.KENAZ_INTEGRATION_QUEUE === '1' && !dryRun) {
         gitResult = require('./integration.js').integrateForPostComplete({ taskId, projectPath, message });
       } else {
         gitResult = gitBranchAndMerge({ taskId, message, dryRun, projectPath, skipTests, testCommands, worktreePath });
@@ -2356,17 +2376,6 @@ function postComplete(opts = {}) {
       } catch { /* commit-sync not available — graceful degradation */ }
     }
 
-    // Step 2.6: Passive Rune Extraction（fire-and-forget）
-    if (gitResult.committed && !dryRun) {
-      try {
-        const commitMsg = message || `[${taskId}] task completed`;
-        const projectRoot = resolveProjectRoot(projectPath);
-        if (projectRoot) {
-          triggerPassiveRuneExtraction(commitMsg, projectRoot, projectPath);
-        }
-      } catch { /* rune extraction failed — never block post-complete */ }
-    }
-
     // Step 2.7: Outcome Recording + Surprise Detection（fire-and-forget）
     if (!dryRun) {
       try {
@@ -2472,10 +2481,12 @@ function postComplete(opts = {}) {
           result.taskCompleted = true;
           console.log(`   ✅ Task ${taskId} already in done/`);
         } else {
-          console.log(`   ⚠️  Failed to complete task: ${errMsg.split('\n')[0]}`);
+          result.completeError = spawnFailureCause(completeResult);
+          console.log(`   ⚠️  Failed to complete task: ${result.completeError}`);
         }
       }
     } catch (e) {
+      result.completeError = e.message;
       console.log(`   ⚠️  Task complete error: ${e.message}`);
     }
   } else if (taskId && !dryRun && result.git && result.git.noChanges) {
@@ -2503,10 +2514,12 @@ function postComplete(opts = {}) {
           result.taskCompleted = true;
           console.log(`   ✅ Task ${taskId} already in done/`);
         } else {
-          console.log(`   ⚠️  Failed to complete task: ${errMsg.split('\n')[0]}`);
+          result.completeError = spawnFailureCause(completeResult);
+          console.log(`   ⚠️  Failed to complete task: ${result.completeError}`);
         }
       }
     } catch (e) {
+      result.completeError = e.message;
       console.log(`   ⚠️  Task complete error: ${e.message}`);
     }
   } else if (taskId && result.git && !isVerifiedMergeSuccess(result.git) && !result.git.noGitRepo && !result.git.noChanges) {
@@ -2599,12 +2612,14 @@ function postComplete(opts = {}) {
         console.log(`   🚨 [TASK_1536] Reconciliation: task ${taskId} was in done/ but merge did not land — moved to blocked/ (failure_reason=${reconcileVitals.failure_reason})`);
       } else if (reconcileResult.status === 0) {
         // task was not in done/ — already blocked or active, nothing to reconcile
+        result.reconciliationChecked = true;
         console.log(`   ✅ [TASK_1536] Reconciliation check: task ${taskId} not in done/ — no reconciliation needed`);
       } else {
-        const errMsg = (reconcileResult.stderr || reconcileResult.stdout || '').trim();
-        console.log(`   ⚠️  [TASK_1536] Reconciliation failed: ${errMsg.split('\n')[0] || 'unknown error'}`);
+        result.reconcileError = spawnFailureCause(reconcileResult);
+        console.log(`   ⚠️  [TASK_1536] Reconciliation failed: ${result.reconcileError}`);
       }
     } catch (reconcileErr) {
+      result.reconcileError = reconcileErr.message || String(reconcileErr);
       console.log(`   ⚠️  [TASK_1536] Reconciliation error (non-fatal): ${(reconcileErr.message || '').split('\n')[0]}`);
     }
   }
@@ -2636,10 +2651,12 @@ function postComplete(opts = {}) {
           result.taskCompleted = true;
           console.log(`   ✅ Task ${taskId} already in done/`);
         } else {
-          console.log(`   ⚠️  Safety net move failed: ${errMsg.split('\n')[0]}`);
+          result.completeError = spawnFailureCause(moveResult);
+          console.log(`   ⚠️  Safety net move failed: ${result.completeError}`);
         }
       }
     } catch (e) {
+      result.completeError = e.message;
       console.log(`   ⚠️  Safety net error: ${e.message}`);
     }
   }
@@ -2694,74 +2711,6 @@ function postComplete(opts = {}) {
     }
   }
 
-  // Step 2.5: Passive Rune Extraction — task completion signal (TASK_747)
-  if (result.taskCompleted && taskId && !dryRun) {
-    try {
-      const runeScope = loadTaskScopePaths(taskId, projectPath);
-      if (runeScope.length > 0) {
-        // Read task title and requirements via task-api get
-        let runeContent = `Task ${taskId}: completed.`;
-        try {
-          const getArgs = projectPath ? ['--project-path', projectPath] : [];
-          getArgs.push('get', taskId);
-          const getResult = spawnSync('node', [COLLABORATION_API, ...getArgs], {
-            encoding: 'utf8', timeout: 10000, cwd: ROOT, windowsHide: true,
-          });
-          if (getResult.status === 0 && getResult.stdout) {
-            const taskData = JSON.parse(getResult.stdout.trim());
-            const rawTitle = taskData.title || '';
-            const reqs = Array.isArray(taskData.requirements) ? taskData.requirements : [];
-            // MEM-LANG-001: strip CJK so FTS5 unicode61 tokenizer can index the rune
-            const title = stripCJK(rawTitle);
-            const reqSummary = stripCJK(reqs.slice(0, 3).join('; '));
-            // Fallback: if English portion of title is too short, use task ID as title
-            const effectiveTitle = title.length >= 10 ? title : `${taskId} task`;
-            runeContent = `Task ${taskId}: ${effectiveTitle}. Requirements: ${reqSummary}`;
-            if (runeContent.length > 300) runeContent = runeContent.slice(0, 297) + '...';
-          }
-        } catch { /* skip — use fallback content */ }
-
-        // Fire-and-forget synapse_inscribe for each scope path
-        const http = require('http');
-        let fired = 0;
-        for (const scopePath of runeScope) {
-          try {
-            const inscribeArgs = {
-              symbol_id: scopePath,
-              type: 'summary',
-              content: runeContent,
-              confidence: 0.65,
-              linked_task: taskId,
-              // TASK_2025: write tool -- must not omit projectPath (see epArgs comment above).
-              projectPath: projectPath || ROOT,
-            };
-            const payload = JSON.stringify({
-              jsonrpc: '2.0',
-              id: `task-rune-${taskId}-${fired}`,
-              method: 'tools/call',
-              params: { name: 'synapse_inscribe', arguments: inscribeArgs },
-            });
-            const req = http.request({
-              hostname: '127.0.0.1', port: 18080, path: '/api/mcp',
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
-              timeout: 10000,
-            }, (res) => {
-              res.on('data', () => {});
-              res.on('end', () => {});
-            });
-            req.on('error', (err) => { console.warn(`   ⚠️  synapse_inscribe HTTP error: ${err.message}`); });
-            req.on('timeout', () => { req.destroy(); });
-            req.write(payload);
-            req.end();
-            fired++;
-          } catch { /* skip this scope path */ }
-        }
-        console.log(`   🧠 Rune extraction: ${fired} scope symbols for ${taskId}`);
-      }
-    } catch { /* skip — never blocks post-complete */ }
-  }
-
   // Step 2.55 (cognitive tool usage -> cognitive_competence) was removed in TASK_2348: its only
   // data source, turn_feedback.jsonl, was written by the retired reflex hook.
 
@@ -3077,138 +3026,6 @@ function postComplete(opts = {}) {
     }
   }
 
-  // Step 3b: Provenance rune — record which task + role modified scope paths (Cognee-inspired)
-  if (taskId && !dryRun && result.git && result.git.merged) {
-    try {
-      const scopePaths = loadTaskScopePaths(taskId, projectPath);
-      const role = result.taskRole || 'unknown';
-      if (scopePaths.length > 0 && scopePaths.length <= 5) {
-        const http = require('http');
-        for (const scopePath of scopePaths) {
-          try {
-            const payload = JSON.stringify({
-              jsonrpc: '2.0', id: `provenance-${taskId}`,
-              method: 'tools/call',
-              params: { name: 'synapse_inscribe', arguments: {
-                symbol_id: scopePath,
-                type: 'summary',
-                content: `Modified by ${taskId} (${role}). Scope: ${scopePaths.join(', ')}`,
-                confidence: 0.6,
-                author: `agent:${role}`,
-                linked_task: taskId,
-                // TASK_2025: write tool -- must not omit projectPath (see epArgs comment above).
-                projectPath: projectPath || ROOT,
-              }},
-            });
-            const req = http.request({
-              hostname: '127.0.0.1', port: 18080, path: '/api/mcp',
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
-              timeout: 5000,
-            }, (res) => { res.on('data', () => {}); res.on('end', () => {}); });
-            req.on('error', () => {});
-            req.on('timeout', () => { req.destroy(); });
-            req.write(payload);
-            req.end();
-          } catch { /* skip */ }
-        }
-        console.log(`   📝 Provenance runes: ${scopePaths.length} scope paths tagged with ${taskId}/${role}`);
-      }
-    } catch { /* never blocks */ }
-  }
-
-  // Step 4: Guardian Health Check + KEEP/REVERT delta (TASK_706)
-  if (taskId) {
-    const counter = readGuardianCounter();
-    counter.completed_since_last_health = (counter.completed_since_last_health || 0) + 1;
-
-    const loopCfg = readLoopConfig(projectPath);
-    const regressionSkipVerdictReason = result.git?.regression?.skipVerdictReason || '';
-    const shouldSkipHealthVerdict = !!result.git?.regression?.skipVerdict;
-
-    // TASK_2341: synapse_health now scores MEMORY (rune/episode/conflict backlog), not code,
-    // so it can never revert, block or penalise a task. Both modes only RECORD the trend.
-    if (loopCfg.mode === 'auto' && shouldSkipHealthVerdict) {
-      console.log('── Guardian Memory-Health Trend (loop auto mode) ──');
-      console.log(`   ⚠️  Guardian: health snapshot skipped — ${regressionSkipVerdictReason}`);
-      result.healthVerdictSkipped = { reason: regressionSkipVerdictReason };
-      counter.completed_since_last_health = 0;
-      counter.last_health_check = new Date().toISOString();
-      writeGuardianCounter(counter);
-    } else {
-      const preSn = readPreTaskHealthSnapshot(taskId, projectPath);
-      if (preSn && typeof preSn.score === 'number') {
-        console.log(`── Guardian Memory-Health Trend (${loopCfg.mode} mode — record only, never reverts) ──`);
-        const postHealth = measureHealthScoreSync(projectPath);
-        if (postHealth) {
-          const afterPayload = saveTaskHealthSnapshot(taskId, 'after', postHealth, projectPath);
-          const vr = computeHealthVerdict(preSn, postHealth, loopCfg.revert_threshold, {
-            trendDeltaFromPrevious: afterPayload ? afterPayload.delta_from_previous : null,
-          });
-          console.log(`   🛡️  Memory health: ${postHealth.score}/100 (${vr.reason})`);
-          if (typeof vr.trendDeltaFromPrevious === 'number') {
-            console.log(`   📈 Trend (delta_from_previous): ${vr.trendDeltaFromPrevious >= 0 ? '+' : ''}${vr.trendDeltaFromPrevious}`);
-          }
-          writeVerdictToTask(taskId, vr.verdict, vr.delta, vr.reason, projectPath);
-          result.healthVerdict = { verdict: vr.verdict, delta: vr.delta, reason: vr.reason };
-          // Auto-acted_on: mark runes recalled during this task as acted_on (closes the
-          // recall->acted_on->confidence_boost loop). Route still exists (synapse.rs).
-          if (loopCfg.mode === 'auto') {
-            try {
-              const actedOnPayload = JSON.stringify({ taskId });
-              const actReq = require('http').request({
-                hostname: '127.0.0.1',
-                port: 18080,
-                path: '/api/synapse/runes/mark-acted-on-by-task',
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(actedOnPayload) },
-                timeout: 3000,
-              }, (res) => {
-                let body = '';
-                res.on('data', c => body += c);
-                res.on('end', () => {
-                  try {
-                    const r = JSON.parse(body);
-                    if (r.marked > 0) console.log(`   🔗 Acted-on: ${r.marked} runes marked for ${taskId}`);
-                  } catch { /* parse error — silent */ }
-                });
-              });
-              actReq.on('error', () => { /* Dashboard offline — silent skip */ });
-              actReq.write(actedOnPayload);
-              actReq.end();
-            } catch { /* never blocks post-complete */ }
-          }
-          counter.completed_since_last_health = 0;
-          counter.last_health_check = new Date().toISOString();
-        } else {
-          console.log(`   🛡️  Guardian: Dashboard not running — after-snapshot skipped for ${taskId}`);
-        }
-      } else if (loopCfg.mode === 'auto') {
-        const postHealth = measureHealthScoreSync(projectPath);
-        if (postHealth) {
-          saveTaskHealthSnapshot(taskId, 'before', postHealth, projectPath);
-          console.log(`   🛡️  Guardian: memory health=${postHealth.score}/100 (${postHealth.grade}) — saved as baseline (no pre-task snapshot found)`);
-        } else {
-          console.log('   🛡️  Guardian: Dashboard not running — health snapshot skipped');
-        }
-        counter.completed_since_last_health = 0;
-        counter.last_health_check = new Date().toISOString();
-      } else if (counter.completed_since_last_health >= CONFIG.GUARDIAN_INTERVAL) {
-        console.log(`── Guardian Health Check (every ${CONFIG.GUARDIAN_INTERVAL} tasks) ──`);
-        triggerGuardianHealthCheck(projectPath);
-        counter.completed_since_last_health = 0;
-        counter.last_health_check = new Date().toISOString();
-      } else {
-        const remaining = CONFIG.GUARDIAN_INTERVAL - counter.completed_since_last_health;
-        console.log(`   🛡️  Guardian: ${remaining} tasks until next health snapshot (no pre-dispatch snapshot for ${taskId})`);
-      }
-    }
-
-    if (!shouldSkipHealthVerdict || loopCfg.mode !== 'auto') {
-      writeGuardianCounter(counter);
-    }
-  }
-
   // Step 4.6: Guard Failure Detector (TASK_1653)
   // Runs shadow-mode failure detectors for active lesson guards that carry failure_signature.
   // Reads guard snapshots directly from lesson_guards.yaml (not the task chart) because
@@ -3376,14 +3193,6 @@ function postComplete(opts = {}) {
       console.log(`   👉 On branch: ${result.git.userBranch} — merge to main when ready`);
     }
   }
-  // Health verdict summary (TASK_706)
-  if (result.healthVerdict) {
-    const hv = result.healthVerdict;
-    console.log(`   Memory Health: ${hv.verdict} (trend=${typeof hv.delta === 'number' ? hv.delta.toFixed(1) : 'n/a'}) — ${hv.reason}`);
-  } else if (result.healthVerdictSkipped) {
-    console.log(`   Health Verdict: SKIPPED ⚠️ — ${result.healthVerdictSkipped.reason}`);
-  }
-
   // Cognitive checkpoint summary
   if (result.cognitive) {
     const cog = result.cognitive;
@@ -3398,84 +3207,6 @@ function postComplete(opts = {}) {
   }
   console.log('');
 
-  // Step 8a: Hippocampus Episode Append — record task outcome (TASK_969)
-  if (hippocampusEpisodeId && !dryRun) {
-    try {
-      const contentParts = [`Task ${taskId} outcome:`];
-
-      // Changed files
-      const changedFileList = result.git?.diffStat || [];
-      if (changedFileList.length > 0) {
-        contentParts.push(`Changed files: ${changedFileList.join(', ')}`);
-      } else if (result.git?.committed) {
-        contentParts.push('Changes committed (file list unavailable).');
-      } else if (result.git?.noChanges) {
-        contentParts.push('No file changes detected.');
-      }
-
-      // Health delta (regression test results)
-      if (result.git?.regression?.skipVerdict) {
-        contentParts.push(`Health verdict skipped: ${result.git.regression.skipVerdictReason}.`);
-      } else if (result.git?.regression && !result.git.regression.skipped) {
-        contentParts.push(result.git.regression.passed
-          ? 'Health: tests passed.'
-          : `Health: tests FAILED.${result.git.regressionFixTask ? ` Fix task: ${result.git.regressionFixTask}` : ''}`);
-      }
-
-      // Fix loop status
-      if (result.git?.acceptanceFixTasks && result.git.acceptanceFixTasks.length > 0) {
-        contentParts.push(`Fix loop triggered: ${result.git.acceptanceFixTasks.join(', ')}`);
-      }
-
-      // Git merge status
-      if (isVerifiedMergeSuccess(result.git)) {
-        contentParts.push(`Merged to ${result.git.userBranch}.`);
-      }
-
-      const appendArgs = {
-        episode_id: hippocampusEpisodeId,
-        phase: 'outcome',
-        content: contentParts.join(' '),
-        confidence: 0.8,
-        outcome: isVerifiedMergeSuccess(result.git) ? 'success' : 'partial',
-        // TASK_2025: write tool -- must not omit projectPath (see epArgs comment above).
-        projectPath: projectPath || ROOT,
-      };
-      callHippocampusMcpSync('hippocampus_episode_append', appendArgs);
-      console.log(`   🧠 Hippocampus: episode ${hippocampusEpisodeId} appended outcome entry`);
-    } catch (e) {
-      console.log(`   ⚠️  Hippocampus episode append skipped: ${e.message}`);
-    }
-  }
-
-  // Step 8b: Hippocampus Episode Close (episodic memory — TASK_716)
-  if (hippocampusEpisodeId && !dryRun) {
-    try {
-      const outcome = isVerifiedMergeSuccess(result.git)
-        ? 'success'
-        : (result.git?.noChanges || result.git?.memoryOnly ? 'success' : 'partial');
-      const summaryParts = [`Task ${taskId} post-complete finished.`];
-      if (isVerifiedMergeSuccess(result.git)) summaryParts.push(`Git merged to ${result.git.userBranch}.`);
-      if (result.taskCompleted) summaryParts.push('Task marked done.');
-      if (result.git?.regression?.skipVerdict) {
-        summaryParts.push('Health verdict skipped due to cargo lock contention.');
-      } else if (result.git?.regression && !result.git.regression.skipped) {
-        summaryParts.push(result.git.regression.passed ? 'Tests passed.' : 'Tests failed — fix task created.');
-      }
-      const closeArgs = {
-        episode_id: hippocampusEpisodeId,
-        outcome,
-        summary: summaryParts.join(' '),
-        // TASK_2025: write tool -- must not omit projectPath (see epArgs comment above).
-        projectPath: projectPath || ROOT,
-      };
-      callHippocampusMcpSync('hippocampus_episode_close', closeArgs);
-      console.log(`   🧠 Hippocampus: episode ${hippocampusEpisodeId} closed (${outcome})`);
-    } catch (e) {
-      console.log(`   ⚠️  Hippocampus episode close skipped: ${e.message}`);
-    }
-  }
-
   // TASK_1593: Record outcome in dedup guard so a failed pass does not
   // suppress the next legitimate retry (Guard 1 worktree->null check).
   if (taskId && !dryRun) {
@@ -3484,6 +3215,14 @@ function postComplete(opts = {}) {
     updatePostCompleteGuardOutcome(guardFile, taskId, passSucceeded ? 'success' : 'failure');
   }
 
+  // TASK_2420: truthful outcome — never "completed" when a required step failed.
+  result.summary = summarizePostComplete(result);
+  if (taskId && !dryRun && result.summary.outcome !== 'completed') {
+    console.log(`── Outcome: ${result.summary.outcome.toUpperCase()} ──`);
+    for (const st of result.summary.steps) console.log(`   ${st.status === 'failed' ? '❌' : st.status === 'skipped' ? '⏭️ ' : '✅'} ${st.step}: ${st.status}${st.reason ? ' — ' + st.reason : ''}`);
+    for (const w of result.summary.warnings) console.log(`   ⚠️  ${w}`);
+  }
+
   return result;
 }
 
@@ -3509,6 +3248,7 @@ Options:
   --keep N               保留最新 N 個 done 任務（預設 10）
   --skip-archive         跳過 archive 檢查
   --skip-git             跳過 git 分支管理
+  --no-source            無 source 任務（runtime/config 修復，無 branch）：git merge/verify 標記 skipped
   --skip-tests           跳過回歸測試（PPL-113）
   --test-cmd "CMD"       Agent 指定的測試指令（可多次指定，PPL-113）
   --message "MSG"        自訂 commit message
@@ -3562,6 +3302,7 @@ Examples:
   const keep = getArg('--keep') ? parseInt(getArg('--keep'), 10) : CONFIG.DEFAULT_KEEP;
   const skipArchive = args.includes('--skip-archive');
   const skipGit = args.includes('--skip-git');
+  const noSource = args.includes('--no-source');
   const skipTests = args.includes('--skip-tests');
   const dryRun = args.includes('--dry-run');
   const message = getArg('--message');
@@ -3584,7 +3325,7 @@ Examples:
   }
 
   try {
-    postComplete({ taskId, keep, skipArchive, skipGit, skipTests, dryRun, message, projectPath, testCommands, worktreePath });
+    postComplete({ taskId, keep, skipArchive, skipGit, skipTests, dryRun, message, projectPath, testCommands, worktreePath, noSource });
   } catch (e) {
     console.error(`❌ Post-complete failed: ${e.message}`);
     process.exit(1);
@@ -3593,58 +3334,13 @@ Examples:
 // ?????????????????????????????????????????????????????????????????????????????
 // SECTION: EXPORTS
 // ?????????????????????????????????????????????????????????????????????????????
-// ─────────────────────────────────────────
-// Sub-agent post-complete (lightweight equivalent for Agent tool dispatch)
-// ─────────────────────────────────────────
-
-/**
- * Lightweight post-complete for tasks dispatched via Agent tool (isolation=worktree).
- * The Agent tool handles worktree git isolation automatically, so git merge is skipped.
- * Health scoring is deferred to the next Heimdall cycle (dashboard must be running
- * for measureHealthScoreSync to work; safe to call from Ansuz interactive session).
- *
- * Call this after the Agent tool sub-agent returns to record the health delta.
- *
- * @param {string} taskId - Task ID (TASK_XXX)
- * @param {string|null} projectPath - Sub-project path (null = core)
- * @returns {Promise<{ healthDelta: number|null, grade: string|null }>}
- */
-async function subagentPostComplete(taskId, projectPath) {
-  const result = { healthDelta: null, grade: null };
-
-  try {
-    // Record post-task health snapshot (for audit trail + Heimdall comparison)
-    const postHealth = measureHealthScoreSync(projectPath);
-    if (postHealth && taskId) {
-      saveTaskHealthSnapshot(taskId, 'after', postHealth, projectPath);
-      const preSn = readPreTaskHealthSnapshot(taskId, projectPath);
-      if (preSn?.score != null) {
-        // TASK_2341: null when the baseline is graph-era (different score_version)
-        result.healthDelta = computeHealthVerdict(preSn, postHealth).delta;
-        result.grade = postHealth.grade;
-        console.log(
-          `   🛡️  Sub-agent Guardian: health=${postHealth.score}/100 (${postHealth.grade})` +
-          ` trend=${typeof result.healthDelta === 'number' ? (result.healthDelta >= 0 ? '+' : '') + result.healthDelta : 'n/a'}`
-        );
-      } else {
-        // Save as baseline for future comparison
-        saveTaskHealthSnapshot(taskId, 'before', postHealth, projectPath);
-        result.grade = postHealth.grade;
-        console.log(`   🛡️  Sub-agent Guardian: health=${postHealth.score}/100 (${postHealth.grade}) — saved as baseline`);
-      }
-    }
-  } catch { /* never block Ansuz on health check failure */ }
-
-  return result;
-}
-
 module.exports = {
   classifyMergeFailureReason,
+  summarizePostComplete,
+  spawnFailureCause,
   postComplete,
   archiveCheck,
   gitBranchAndMerge,
-  measureHealthScoreSync,
-  saveTaskHealthSnapshot,
   classifySkillKey,
   isDaemonManagedPath,
   listDaemonManagedPaths,
@@ -3653,7 +3349,6 @@ module.exports = {
   checkAndUpdatePostCompleteGuard,
   updatePostCompleteGuardOutcome,
   writeInboxEntryIdempotent,
-  subagentPostComplete,
   readLatestHandoff, // TASK_1828: handoffs/-first resolver for relay summaries
   reclaimWorktreeDir, // TASK_2028: unlock + git-level reclaim for stale/interrupted worktrees
   appendPhase9OutcomeLog, // TASK_2078: exported for agent_result/transcript precedence unit testing