session-orchestrator 3.16.0 → 3.19.0

package/skills/vault-sync/validator.mjs

@@ -62,6 +62,7 @@ import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import YAML from 'yaml';
 import { resolveInstructionFile } from '../../scripts/lib/common.mjs';
+import { findSessionConfigBlock } from '../../scripts/lib/config/section-extractor.mjs';
 import {
   computeSchemaHash,
   writeBaseline,
@@ -159,14 +160,27 @@ const _schemaHash = (() => {
 const args = process.argv.slice(2);
 const checkExpires = args.includes('--check-expires');
 
-// Parse --mode <hard|warn|off|baseline|diff|full> (default: hard)
+// Parse --mode <hard|strict|warn|off|baseline|diff|full> (default: hard)
 //   hard      — legacy alias; identical to full enforcement
+//   strict    — alias of hard (#835). The Session Config schema
+//               (scripts/lib/config-schema.mjs VAULT_MODE_VALUES) uses
+//               strict|warn|off, so a caller forwarding the configured value
+//               verbatim would otherwise hit exit 2. Normalized to 'hard' at
+//               parse time so exactly one internal value flows downstream.
 //   full      — enforce: exit 1 on errors
 //   warn      — report but exit 0
 //   off       — skip entirely
 //   baseline  — write snapshot then exit 0
 //   diff      — compare against snapshot, emit JSON diff
 // Parse --exclude <glob> (repeatable)
+const MODE_VALUES = new Set(['hard', 'strict', 'warn', 'off', 'baseline', 'diff', 'full']);
+const MODE_EXPECTED = 'hard|strict|warn|off|baseline|diff|full';
+
+/** Normalize CLI mode aliases to the single internal value used downstream. */
+function normalizeMode(v) {
+  return v === 'strict' ? 'hard' : v;
+}
+
 let mode = 'hard';
 const excludePatterns = [];
 
@@ -204,22 +218,22 @@ for (let i = 0; i < args.length; i++) {
   const a = args[i];
   if (a === '--mode') {
     const v = args[i + 1];
-    if (v === 'hard' || v === 'warn' || v === 'off' || v === 'baseline' || v === 'diff' || v === 'full') {
-      mode = v;
+    if (MODE_VALUES.has(v)) {
+      mode = normalizeMode(v);
     } else {
       process.stderr.write(
-        `validator.mjs: invalid --mode value "${v}" (expected hard|warn|off|baseline|diff|full)\n`,
+        `validator.mjs: invalid --mode value "${v}" (expected ${MODE_EXPECTED})\n`,
       );
       process.exit(2);
     }
     i++;
   } else if (a.startsWith('--mode=')) {
     const v = a.slice('--mode='.length);
-    if (v === 'hard' || v === 'warn' || v === 'off' || v === 'baseline' || v === 'diff' || v === 'full') {
-      mode = v;
+    if (MODE_VALUES.has(v)) {
+      mode = normalizeMode(v);
     } else {
       process.stderr.write(
-        `validator.mjs: invalid --mode value "${v}" (expected hard|warn|off|baseline|diff|full)\n`,
+        `validator.mjs: invalid --mode value "${v}" (expected ${MODE_EXPECTED})\n`,
       );
       process.exit(2);
     }
@@ -283,18 +297,38 @@ function isExcluded(relPath) {
 // Returns true if dir contains at least one recognized vault marker:
 //   1. _meta/ directory
 //   2. CLAUDE.md or AGENTS.md (alias — see skills/_shared/instruction-file-resolution.md)
-//      containing both "## Session Config" and "vault-sync:". The instruction
-//      file is resolved via resolveInstructionFile() so CLAUDE.md wins ties and
-//      AGENTS.md is accepted on Codex CLI repos.
+//      whose `## Session Config` block declares a `vault-sync:` key. The
+//      instruction file is resolved via resolveInstructionFile() so CLAUDE.md
+//      wins ties and AGENTS.md is accepted on Codex CLI repos.
 //   3. .obsidian/ directory
+//
+// Marker 2 was two whole-file substring tests until #968:
+//   content.includes('## Session Config') && content.includes('vault-sync:')
+// A substring test is the wrong instrument for "does this directory look like
+// a vault" in three independent ways, all reachable:
+//   (a) `'### Session Config'.includes('## Session Config')` is TRUE (from
+//       index 1), so an H3 — or any deeper heading — passed the marker.
+//       HTML comment matched. Any document ABOUT session-orchestrator config
+//       reads as a vault marker.
+//   (b) A `## Session Config` mention in ordinary prose (not at line start)
+//       matched, e.g. "see the ## Session Config block" mid-sentence.
+//   (c) `vault-sync:` was accepted ANYWHERE in the file — a prose sentence or
+//       a doc-comment sufficed; it never had to be a config key, let alone one
+//       inside the Session Config block.
+// Misclassifying a directory as a vault is not cosmetic: it makes the
+// validator crawl and enforce vault frontmatter over an arbitrary tree, and
+// (via the cwd branch below) silently adopt it as VAULT_DIR.
+//
+// The fix uses the SSOT block extractor, so the heading must be a real
+// heading LINE and `vault-sync:` must be a key INSIDE that block.
 function isVaultDir(dir) {
   if (existsSync(join(dir, '_meta')) && statSync(join(dir, '_meta')).isDirectory()) return true;
   if (existsSync(join(dir, '.obsidian')) && statSync(join(dir, '.obsidian')).isDirectory()) return true;
   const instr = resolveInstructionFile(dir);
   if (instr) {
     try {
-      const content = readFileSync(instr.path, 'utf8');
-      if (content.includes('## Session Config') && content.includes('vault-sync:')) return true;
+      const block = findSessionConfigBlock(readFileSync(instr.path, 'utf8'));
+      if (block && /^\s*(?:-\s+)?(?:\*\*)?vault-sync(?:\*\*)?\s*:/m.test(block.body)) return true;
     } catch {
       // unreadable instruction file — not a vault marker
     }
@@ -335,13 +369,29 @@ if (process.env.VAULT_DIR) {
   }
 }
 
+// Directories the crawler never descends into. These are structurally
+// invisible: their notes are neither checked NOR available as link targets.
 const EXCLUDED_DIRS = new Set([
   'node_modules',
   '.git',
   '.obsidian',
-  '90-archive',
 ]);
 
+// Top-level directories whose notes are skipped by the CHECK set but remain in
+// the link-target register (#833). Before this split, '90-archive' lived in
+// EXCLUDED_DIRS, so archiving a note silently turned every inbound
+// [[wiki-link]] into a dangling-link warning. The register and the check-set
+// are now decoupled: walk() still visits these notes (so they resolve links),
+// the validation loop skips them (so their frontmatter never blocks a close).
+const CHECK_EXCLUDED_TOP_DIRS = new Set(['90-archive']);
+
+/** True when relPath's FIRST path segment is a check-excluded top-level dir. */
+function isArchived(relPath) {
+  const p = String(relPath).replace(/\\/g, '/');
+  const top = p.split('/', 1)[0];
+  return CHECK_EXCLUDED_TOP_DIRS.has(top);
+}
+
 function emit(obj) {
   process.stdout.write(JSON.stringify(obj) + '\n');
 }
@@ -354,6 +404,7 @@ if (mode === 'off') {
     vault_dir: vaultDir,
     files_checked: 0,
     excluded_count: 0,
+    archived_skipped_count: 0,
     files_skipped_no_frontmatter: 0,
     errors: [],
     warnings: [],
@@ -415,16 +466,86 @@ function parseFrontmatter(raw) {
   }
 }
 
-// ── Build link index (filename -> path) ─────────────────────────────────────
-const fileIndex = new Map(); // basename-without-ext -> [absolute paths]
-for (const f of mdFiles) {
-  const key = basename(f, '.md');
-  if (!fileIndex.has(key)) fileIndex.set(key, []);
-  fileIndex.get(key).push(f);
+// ── Wiki-link regex — captures link body for target parsing ─────────────────
+// NOTE: intentionally NOT module-level. A shared `/g` regex driven by
+// `.exec()` in a loop carries `lastIndex` state across calls; the previous
+// module-level `WIKILINK_RE` was safe only because the loop always ran to
+// exhaustion (never an early return/continue). Constructing a fresh regex
+// per `extractWikiLinks()` call removes that hazard structurally rather than
+// relying on "the loop happens to always finish" (#852).
+function wikilinkRegex() {
+  return /\[\[([^\]]+)\]\]/g;
 }
 
-// ── Wiki-link regex — captures link body for target parsing ─────────────────
-const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+// ── Code-span stripping (#852, hardened post-review) ────────────────────────
+// A wikilink written as inline code (`` `[[target]]` ``) or inside a fenced /
+// indented code block is pedagogical prose ABOUT the Obsidian wiki-link
+// convention (#159 pattern: keep named invariants in backticks), not a real
+// link, and must never surface a dangling-wiki-link warning. All span kinds
+// are blanked out (non-newline chars -> space, newlines preserved) BEFORE the
+// wikilink regex runs, so their `[[...]]` content is invisible to
+// extractWikiLinks() while line count / offsets stay stable for any future
+// position-aware consumer.
+//
+// NOTE: intentionally functions, not module-level `/g` regex constants. Every
+// call below builds a fresh RegExp so no shared `lastIndex` state can leak
+// across calls (same rationale as wikilinkRegex() above, #852).
+//
+// Order: fenced blocks (multi-line) -> indented code blocks (line-based) ->
+// inline spans (single/double backtick, same line only). Fenced blocks run
+// first because they are the only multi-line shape; the other two are
+// line-local and their relative order does not change the result (a line
+// already blanked by an earlier pass is all-spaces and matches idempotently
+// under either later pass).
+//
+// Fenced-block fix (post-#852 QA review): the ORIGINAL `/```[\s\S]*?```/g`
+// paired ANY two ``` runs in the whole file — including a ``` merely
+// MENTIONED mid-sentence in prose — which silently blanked (and hid dangling
+// links inside) everything between an unrelated mention and the next real
+// fence. Real CommonMark fences must open at the START of a line (up to 3
+// leading spaces); this regex is now line-anchored so a mid-line mention can
+// never open a fence. The closing fence must reuse the SAME fence character
+// (backtick vs tilde) with a run of at least 3 — `(?:\1){3,}` repeats the
+// single captured fence character, so a backtick fence cannot be closed by a
+// tilde run or vice versa. Also handles `~~~` fences and fenced blocks that
+// carry an info string (e.g. ```` ```md ````) — the info string is just the
+// rest of the opening line, already consumed by `[^\n]*`.
+function fencedCodeRegex() {
+  return /^ {0,3}(`|~)\1{2,}[^\n]*\n[\s\S]*?^ {0,3}(?:\1){3,}[ \t]*$/gm;
+}
+
+// Indented code blocks (4+ leading spaces, or a leading tab) are CommonMark
+// code too. Required to be flanked by a blank line (or start/end of text) on
+// both sides — mirrors CommonMark's "separated from surrounding paragraph
+// text" rule closely enough to avoid blanking ordinary 4-space-indented list
+// continuation text that isn't actually a code block, while still catching
+// the FP shape this fixes.
+function indentedCodeRegex() {
+  return /(?<=^|\n\n)(?: {4,}|\t)[^\n]*(?:\n(?: {4,}|\t)[^\n]*)*/g;
+}
+
+// Inline code spans: single-backtick (`` ` `` ... `` ` ``) or double-backtick
+// (`` `` `` ... `` `` ``, used when the wrapped content itself contains a
+// backtick) delimiters, same line only. The closing delimiter must be the
+// SAME LENGTH as the opening one (`\1` backreference on the captured 1-2
+// backtick run) so a double-backtick span isn't mis-closed by the first lone
+// backtick inside its own content — the over-strip hazard called out in
+// #852. A lone/stray backtick with no same-length partner on the same line
+// therefore matches nothing and is left as plain text.
+function inlineCodeRegex() {
+  return /(`{1,2})[^\n]*?\1(?!`)/g;
+}
+
+function blank(match) {
+  return match.replace(/[^\n]/g, ' ');
+}
+
+function stripCodeSpans(text) {
+  let out = text.replace(fencedCodeRegex(), blank);
+  out = out.replace(indentedCodeRegex(), blank);
+  out = out.replace(inlineCodeRegex(), blank);
+  return out;
+}
 
 function findAliasSeparatorIndex(linkBody) {
   for (let i = 0; i < linkBody.length; i++) {
@@ -441,18 +562,81 @@ function extractWikiLinkTarget(linkBody) {
 }
 
 function extractWikiLinks(content) {
+  const stripped = stripCodeSpans(content);
   const targets = new Set();
+  const re = wikilinkRegex();
   let m;
-  while ((m = WIKILINK_RE.exec(content)) !== null) {
+  while ((m = re.exec(stripped)) !== null) {
     const target = extractWikiLinkTarget(m[1]);
     if (target.length > 0) targets.add(target);
   }
   return [...targets];
 }
 
+// ── Pass 1: read every file ONCE ────────────────────────────────────────────
+// Builds the record set the link-target register (below) and the validation
+// loop (further down) both consume. Net-neutral on I/O versus the previous
+// shape, which read the file once but ran the frontmatter match twice.
+// A malformed note must never abort this pass — every failure is recorded on
+// the record and surfaced later by the validation loop.
+const records = [];
+for (const file of mdFiles) {
+  const rel = relative(vaultDir, file);
+  let raw;
+  try {
+    raw = readFileSync(file, 'utf8');
+  } catch (err) {
+    records.push({ file, rel, readError: err.message || String(err) });
+    continue;
+  }
+  let fm;
+  let links;
+  try {
+    fm = parseFrontmatter(raw);
+    const body = raw.slice(raw.match(FRONTMATTER_RE)?.[0].length || 0);
+    links = extractWikiLinks(body);
+  } catch (err) {
+    fm = { hasFrontmatter: true, parseError: err.message || String(err) };
+    links = [];
+  }
+  records.push({ file, rel, fm, links });
+}
+
+// ── Link-target register ────────────────────────────────────────────────────
+// Keys: basename-without-ext, frontmatter `id`, and every frontmatter `aliases`
+// entry (#833). Keys are normalized NFC + lowercase at BOTH insert and lookup:
+// NFC is required, not cosmetic — APFS returns decomposed (NFD) filenames and
+// this is a German-language corpus, so "Übung" from a filename and "Übung" from
+// a YAML string would otherwise be different strings. Values are already
+// arrays, so a case-collision (Topic.md + topic.md) merely appends.
+const fileIndex = new Map(); // normalized key -> [absolute paths]
+
+function indexKey(k) {
+  return String(k).normalize('NFC').toLowerCase();
+}
+
+function addIndexKey(key, file) {
+  if (typeof key !== 'string' || key.length === 0) return;
+  const k = indexKey(key);
+  if (!fileIndex.has(k)) fileIndex.set(k, []);
+  fileIndex.get(k).push(file);
+}
+
+for (const rec of records) {
+  addIndexKey(basename(rec.file, '.md'), rec.file);
+  const data = rec.fm && rec.fm.hasFrontmatter && !rec.fm.parseError ? rec.fm.data : null;
+  if (!data || typeof data !== 'object') continue;
+  // Type-guard: `id` must be a string, `aliases` an array of strings. A note
+  // with `aliases: some-scalar` contributes no alias keys instead of throwing.
+  if (typeof data.id === 'string') addIndexKey(data.id, rec.file);
+  if (Array.isArray(data.aliases)) {
+    for (const alias of data.aliases) addIndexKey(alias, rec.file);
+  }
+}
+
 function resolveWikiLink(target, sourceFile) {
   // Target may be a bare name ("my-note") or a path ("01-projects/foo/_overview").
-  // Try exact path first (relative to vault), then basename lookup.
+  // Try exact path first (relative to vault), then register lookup.
   const candidate1 = resolve(vaultDir, target.endsWith('.md') ? target : target + '.md');
   if (existsSync(candidate1)) return true;
 
@@ -463,9 +647,8 @@ function resolveWikiLink(target, sourceFile) {
   );
   if (existsSync(candidate2)) return true;
 
-  // Try basename lookup anywhere in index
-  const key = basename(target, '.md');
-  if (fileIndex.has(key)) return true;
+  // Try register lookup anywhere in the vault (basename / id / alias)
+  if (fileIndex.has(indexKey(basename(target, '.md')))) return true;
 
   return false;
 }
@@ -476,29 +659,31 @@ const warnings = [];
 let filesChecked = 0;
 let filesSkippedNoFrontmatter = 0;
 let excludedCount = 0;
+let archivedSkippedCount = 0;
 
 const todayIso = new Date().toISOString().slice(0, 10);
 
-for (const file of mdFiles) {
-  const rel = relative(vaultDir, file);
+// ── Pass 2: validate ────────────────────────────────────────────────────────
+for (const rec of records) {
+  const { file, rel, fm } = rec;
   if (isExcluded(rel)) {
     excludedCount++;
     continue;
   }
-  let raw;
-  try {
-    raw = readFileSync(file, 'utf8');
-  } catch (err) {
+  // Archived notes stay in the link-target register but are never CHECKED.
+  if (isArchived(rel)) {
+    archivedSkippedCount++;
+    continue;
+  }
+  if (rec.readError) {
     errors.push({
       file: rel,
       path: '',
-      message: `Cannot read file: ${err.message || err}`,
+      message: `Cannot read file: ${rec.readError}`,
     });
     continue;
   }
 
-  const fm = parseFrontmatter(raw);
-
   if (!fm.hasFrontmatter) {
     filesSkippedNoFrontmatter++;
     continue;
@@ -527,10 +712,8 @@ for (const file of mdFiles) {
     // Even if frontmatter is invalid, still check wiki-links to surface all problems.
   }
 
-  // Wiki-link check
-  const body = raw.slice(raw.match(FRONTMATTER_RE)?.[0].length || 0);
-  const links = extractWikiLinks(body);
-  for (const target of links) {
+  // Wiki-link check (links were extracted in pass 1)
+  for (const target of rec.links) {
     if (!resolveWikiLink(target, file)) {
       warnings.push({
         file: rel,
@@ -589,6 +772,7 @@ if (mode === 'diff') {
       vault_dir: vaultDir,
       files_checked: filesChecked,
       excluded_count: excludedCount,
+      archived_skipped_count: archivedSkippedCount,
       files_skipped_no_frontmatter: filesSkippedNoFrontmatter,
       errors,
       warnings,
@@ -608,6 +792,7 @@ if (mode === 'diff') {
       vault_dir: vaultDir,
       files_checked: filesChecked,
       excluded_count: excludedCount,
+      archived_skipped_count: archivedSkippedCount,
       files_skipped_no_frontmatter: filesSkippedNoFrontmatter,
       errors,
       warnings,
@@ -629,6 +814,7 @@ if (mode === 'diff') {
     vault_dir: vaultDir,
     files_checked: filesChecked,
     excluded_count: excludedCount,
+    archived_skipped_count: archivedSkippedCount,
     files_skipped_no_frontmatter: filesSkippedNoFrontmatter,
   });
 
@@ -640,7 +826,8 @@ if (mode === 'diff') {
 }
 
 // ── mode=full | hard | warn ───────────────────────────────────────────────
-// 'full' and 'hard' are identical (hard is the legacy alias).
+// 'full' and 'hard' are identical (hard is the legacy alias; 'strict' was
+// normalized to 'hard' at parse time — see normalizeMode, #835).
 // In warn mode, errors are reported but the status is "ok" for exit-code purposes.
 // The errors array is still populated so the caller can surface them as warnings.
 const status = hasErrors ? (mode === 'warn' ? 'ok' : 'invalid') : 'ok';
@@ -650,6 +837,7 @@ emit({
   vault_dir: vaultDir,
   files_checked: filesChecked,
   excluded_count: excludedCount,
+  archived_skipped_count: archivedSkippedCount,
   files_skipped_no_frontmatter: filesSkippedNoFrontmatter,
   errors,
   warnings,

package/skills/wave-executor/SKILL.md

@@ -246,7 +246,7 @@ Each agent prompt MUST include:
 2. **Full context**: file paths, current code structure, issue description. If a bite-sized executable plan exists at `docs/plans/<feature>.md` for the wave's tasks (see `skills/write-executable-plan/SKILL.md`), include the path in each agent's prompt and instruct the agent to follow the plan's 5-step structure verbatim.
 3. **Acceptance criteria**: measurable definition of done
 4. **Rule references**: the wave's applicable rules are injected automatically as the `<APPLICABLE-RULES>` block produced by `scripts/print-applicable-rules.mjs` (see `wave-loop.md` § "Pre-Dispatch: Glob-Scoped Rule Injection (#336/#694)"). The block is computed once per wave from the wave's `allowedPaths` and prepended to every agent prompt — do not hand-copy rule paths into the prompt.
-5. **Testing expectation**: "Write tests for your changes" or "Run existing tests"
+5. **Testing expectation** (need-gated): "Before writing any test, name the concrete bug a NEW test would catch that the existing suite does not. No nameable bug → write NO test and report `no-tests-needed: <reason>` — that is a SUCCESS outcome, not a gap. With a nameable bug: exactly one test for it. Running existing tests is always mandatory."
 6. **Commit instruction**: "Do NOT commit. The coordinator handles commits."
 7. **Turn limit**: Include the maxTurns instruction from `circuit-breaker.md`
 8. **Verification before completion**: Before claiming any task done, run the verification command and quote the evidence inline. See `.claude/rules/verification-before-completion.md`.
@@ -272,10 +272,13 @@ During this wave, you may propose a learning to the session's memory via the CLI
       --subject "one-line title (max 100 chars, no newlines)" \
       --insight "your discovery paragraph (max 2000 chars)" \
       --evidence "concrete proof: code citation / log excerpt / commit ref (max 5000 chars)" \
-      --confidence <0.5 to 1.0>
+      --confidence <0.5 to 1.0> \
+      --file-paths "scripts/lib/a.mjs,scripts/lib/b.mjs"
 
 MUST prefix with `SO_WAVE_AGENT=1` — without it the CLI returns exit 3 `rejected-wrong-context`. The env-var is the per-process guard that distinguishes wave-executor agents from coordinator-context invocations.
 
+`--file-paths` is optional but strongly encouraged: repo-relative path(s) this learning applies to (repeatable and/or comma-separated, deduped; rejects absolute paths, `..` segments, embedded newlines, entries over 256 chars, and more than 20 entries). Without `--file-paths` this learning can never become `/reconcile`-eligible — the reconciliation engine can only convert a learning into a conditional `.claude/rules/*.md` rule when it carries a non-empty scope (issue #900).
+
 Exit code 0 = queued (the coordinator will present at session-end via AskUserQuestion); 1 = quota-exceeded; 2 = rejected-low-confidence (below floor 0.5); 3 = rejected-wrong-context (STATE.md not active OR SO_WAVE_AGENT != "1"); 4 = error (arg validation or internal).
 
 Use ONLY when you find a recurring pattern, anti-pattern, or constraint worth carrying into future sessions. The coordinator confirms each proposal before it lands in learnings.jsonl. Do NOT over-propose — quota is bounded per wave.

package/skills/wave-executor/circuit-breaker.md

@@ -31,6 +31,7 @@ The coordinator determines each agent's status after the wave completes:
 1. **Read the agent's final output** and look for the `STATUS:` line
 2. **Map to status**:
    - `STATUS: done` → agent completed successfully
+   - `STATUS: no-tests-needed` → **SUCCESS variant, treat exactly like `done`.** test-writer-specific: the agent found no nameable bug the existing suite misses, so writing a test was the wrong move (`.claude/rules/test-value.md`; enum in `agents/schemas/test-writer.schema.json`). NEVER map this to `failed` or carry it over.
    - `STATUS: partial` → agent hit turn limit or couldn't finish (PARTIAL)
    - `STATUS: failed` → agent encountered an error it couldn't recover from (FAILED)
    - No STATUS line found → infer from output: if agent produced changes, mark as `done`; if it reported errors, mark as `failed`; if output is truncated, mark as `partial`
@@ -45,6 +46,7 @@ The coordinator determines each agent's status after the wave completes:
 | Status | Meaning | Trigger | Recovery |
 |--------|---------|---------|----------|
 | **done** | Agent completed all assigned work | Agent reports `STATUS: done` | None needed |
+| **no-tests-needed** | SUCCESS variant of **done** — test-writer found no nameable gap, so no test was the correct outcome | Agent reports `STATUS: no-tests-needed` | None needed — never a failure, never a carryover |
 | **partial** | Agent made progress but couldn't finish | Turn limit hit, or agent reports `STATUS: partial` | Carry forward remaining work to next wave with context |
 | **failed** | Agent couldn't make meaningful progress | Tool errors, invalid assumptions, agent reports `STATUS: failed` | Re-dispatch with corrected instructions and narrower scope |
 | **spiral** | Agent got stuck in an edit loop | Same file edited 3+ times (detected post-wave) | Revert agent's changes, narrow scope, split task if needed |