@rune-kit/rune 2.11.0 → 2.12.2

package/compiler/doctor.js

@@ -2,6 +2,7 @@
  * Doctor — Validates compiled output
  *
  * Checks: files exist, cross-references resolve, layer discipline, source freshness.
+ * Mesh checks: reciprocal connections, version suggestions, required sections.
  */
 
 import { existsSync } from 'node:fs';
@@ -454,6 +455,241 @@ async function checkOrgTemplates(_runeRoot, config) {
   return errors;
 }
 
+/**
+ * Check mesh integrity: reciprocal connections, version suggestions, required sections
+ *
+ * @param {string} runeRoot - path to Rune source root
+ * @returns {Promise<object>} mesh check results
+ */
+export async function checkMeshIntegrity(runeRoot) {
+  const results = {
+    checks: [],
+    warnings: [],
+    errors: [],
+    stats: { skills: 0, connections: 0, missingReciprocals: 0 },
+  };
+
+  const skillsDir = path.join(runeRoot, 'skills');
+  if (!existsSync(skillsDir)) {
+    results.errors.push('skills/ directory not found');
+    return results;
+  }
+
+  // Step 1: Parse all skills
+  const skills = new Map(); // name → { calls: [], calledBy: [], version, sections }
+  const entries = await readdir(skillsDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+    if (!existsSync(skillFile)) continue;
+
+    const content = await readFile(skillFile, 'utf-8');
+    const parsed = parseSkillConnections(content, entry.name);
+    skills.set(entry.name, parsed);
+  }
+
+  results.stats.skills = skills.size;
+
+  // Step 2: Validate reciprocals
+  const missingReciprocals = [];
+
+  for (const [name, skill] of skills) {
+    for (const called of skill.calls) {
+      const targetSkill = skills.get(called.skill);
+      if (!targetSkill) continue; // External skill or L4 pack
+
+      // Check if target acknowledges this caller
+      const acknowledges = targetSkill.calledBy.some((c) => c.skill === name);
+      if (!acknowledges) {
+        missingReciprocals.push({
+          caller: name,
+          callee: called.skill,
+          reason: called.reason,
+        });
+      }
+    }
+    results.stats.connections += skill.calls.length;
+  }
+
+  results.stats.missingReciprocals = missingReciprocals.length;
+
+  if (missingReciprocals.length === 0) {
+    results.checks.push({ name: 'Reciprocal connections', status: 'pass' });
+  } else {
+    results.checks.push({
+      name: 'Reciprocal connections',
+      status: 'warn',
+      detail: `${missingReciprocals.length} missing`,
+    });
+    // Group by callee for cleaner output
+    const byCallee = {};
+    for (const m of missingReciprocals) {
+      if (!byCallee[m.callee]) byCallee[m.callee] = [];
+      byCallee[m.callee].push(m.caller);
+    }
+    for (const [callee, callers] of Object.entries(byCallee)) {
+      results.warnings.push(`${callee}: missing callers in Called By: ${callers.join(', ')}`);
+    }
+  }
+
+  // Step 3: Check version maturity
+  const matureButLow = [];
+  for (const [name, skill] of skills) {
+    if (!skill.version) continue;
+    const [major, minor] = skill.version.split('.').map(Number);
+    // Suggest 1.0 if version is 0.8+ and has all required sections
+    if (major === 0 && minor >= 8 && skill.hasAllSections) {
+      matureButLow.push({ name, version: skill.version });
+    }
+  }
+
+  if (matureButLow.length === 0) {
+    results.checks.push({ name: 'Version maturity', status: 'pass' });
+  } else {
+    results.checks.push({
+      name: 'Version maturity',
+      status: 'warn',
+      detail: `${matureButLow.length} skills ready for 1.0`,
+    });
+    for (const s of matureButLow) {
+      results.warnings.push(`${s.name} v${s.version}: mature skill, consider promoting to 1.0`);
+    }
+  }
+
+  // Step 4: Check required sections
+  const requiredSections = ['Sharp Edges', 'Done When', 'Cost Profile'];
+  const missingSections = [];
+
+  for (const [name, skill] of skills) {
+    const missing = requiredSections.filter((s) => !skill.sections.includes(s));
+    if (missing.length > 0) {
+      missingSections.push({ name, missing });
+    }
+  }
+
+  if (missingSections.length === 0) {
+    results.checks.push({ name: 'Required sections', status: 'pass' });
+  } else {
+    results.checks.push({
+      name: 'Required sections',
+      status: 'warn',
+      detail: `${missingSections.length} skills incomplete`,
+    });
+    for (const s of missingSections) {
+      results.warnings.push(`${s.name}: missing sections: ${s.missing.join(', ')}`);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Parse skill connections from SKILL.md content
+ */
+function parseSkillConnections(content, skillName) {
+  const result = {
+    name: skillName,
+    calls: [],
+    calledBy: [],
+    version: null,
+    sections: [],
+    hasAllSections: false,
+  };
+
+  // Extract version from frontmatter
+  const versionMatch = content.match(/version:\s*["']?([\d.]+)["']?/);
+  if (versionMatch) {
+    result.version = versionMatch[1];
+  }
+
+  // Extract Calls section
+  const callsMatch = content.match(/## Calls \(outbound\)\s*\n([\s\S]*?)(?=\n## |\n---|Z)/);
+  if (callsMatch) {
+    const lines = callsMatch[1].split('\n');
+    for (const line of lines) {
+      // Match patterns like: - `scout` (L2): scan codebase
+      // Or: - scout (L2): scan codebase
+      const match = line.match(/^-\s*`?([a-z][\w-]*)`?\s*\(L\d\)/i);
+      if (match) {
+        const skillRef = match[1].toLowerCase();
+        const reason = line
+          .replace(match[0], '')
+          .replace(/^[:\s-]+/, '')
+          .trim();
+        result.calls.push({ skill: skillRef, reason });
+      }
+    }
+  }
+
+  // Extract Called By section
+  const calledByMatch = content.match(/## Called By \(inbound\)\s*\n([\s\S]*?)(?=\n## |\n---|Z)/);
+  if (calledByMatch) {
+    const lines = calledByMatch[1].split('\n');
+    for (const line of lines) {
+      const match = line.match(/^-\s*`?([a-z][\w-]*)`?\s*\(L\d\)/i);
+      if (match) {
+        const skillRef = match[1].toLowerCase();
+        result.calledBy.push({ skill: skillRef });
+      }
+    }
+  }
+
+  // Check for required sections
+  const sectionPatterns = [
+    { name: 'Sharp Edges', pattern: /## Sharp Edges/ },
+    { name: 'Done When', pattern: /## Done When/ },
+    { name: 'Cost Profile', pattern: /## Cost Profile/ },
+    { name: 'Returns', pattern: /## Returns/ },
+  ];
+
+  for (const { name, pattern } of sectionPatterns) {
+    if (pattern.test(content)) {
+      result.sections.push(name);
+    }
+  }
+
+  result.hasAllSections = sectionPatterns.every(({ name }) => result.sections.includes(name));
+
+  return result;
+}
+
+/**
+ * Format mesh results for console output
+ */
+export function formatMeshResults(results) {
+  const lines = [];
+  lines.push(`\n  Mesh Integrity Check`);
+  lines.push(`  Skills: ${results.stats.skills} | Connections: ${results.stats.connections}`);
+  lines.push('');
+
+  for (const check of results.checks) {
+    const icon = check.status === 'pass' ? '✓' : check.status === 'warn' ? '!' : '✗';
+    const detail = check.detail ? ` (${check.detail})` : '';
+    lines.push(`  [${icon}] ${check.name}${detail}`);
+  }
+
+  if (results.warnings.length > 0) {
+    lines.push('');
+    for (const w of results.warnings) {
+      lines.push(`  ⚠ ${w}`);
+    }
+  }
+
+  if (results.errors.length > 0) {
+    lines.push('');
+    for (const e of results.errors) {
+      lines.push(`  ✗ ${e}`);
+    }
+  }
+
+  const healthy = results.errors.length === 0 && results.warnings.length === 0;
+  lines.push('');
+  lines.push(healthy ? '  ✓ Mesh is healthy' : `  ! Mesh has ${results.warnings.length} warnings`);
+
+  return lines.join('\n');
+}
+
 /**
  * Format doctor results for console output
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.11.0",
-  "description": "62-skill mesh for AI coding assistants — 5-layer architecture, 215+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
+  "version": "2.12.2",
+  "description": "62-skill mesh for AI coding assistants — runtime auto-discipline via native hooks (Claude/Cursor/Windsurf/Antigravity), 5-layer architecture, 215+ connections, multi-platform compiler.",
   "type": "module",
   "bin": {
     "rune": "./compiler/bin/rune.js"

package/skills/ba/SKILL.md

@@ -3,7 +3,7 @@ name: ba
 description: Business Analyst agent. Deeply understands user requirements before any planning or coding begins. Asks probing questions, identifies hidden requirements, maps stakeholders, defines scope boundaries, and produces a structured Requirements Document that plan and cook consume.
 metadata:
   author: runedev
-  version: "0.5.0"
+  version: "0.6.0"
   layer: L2
   model: opus
   group: creation
@@ -41,6 +41,7 @@ Output is a Requirements Document → hand off to rune:plan for implementation p
 - `cook` (L1): before Phase 2 PLAN, when task is non-trivial
 - `scaffold` (L1): Phase 1, before any project generation
 - `plan` (L2): when plan receives vague requirements
+- `mcp-builder` (L2): requirements elicitation before MCP server design
 - User: `/rune ba` direct invocation
 
 ## Cross-Hub Connections
@@ -271,6 +272,47 @@ Assess and document ONLY relevant NFRs:
 
 Only include NFRs relevant to this specific task. Don't generate a generic checklist.
 
+### Step 6.5 — Tiered Recommendations
+
+For product-oriented requirements (Feature Request, Integration, Greenfield), generate **tiered strategic recommendations**. This structures the path forward into actionable time horizons.
+
+**Three Tiers:**
+
+| Tier | Timeframe | Focus | Characteristics |
+|------|-----------|-------|-----------------|
+| **Quick Win** | 0-30 days | Immediate impact | Low effort, high visibility, builds momentum |
+| **Differentiation** | 1-3 months | Competitive edge | Medium effort, unique value, hard to copy |
+| **Long-term Moat** | 6-12 months | Sustainable advantage | High effort, defensible, compounds over time |
+
+**For each tier, specify:**
+
+```markdown
+### Quick Win (0-30 days)
+- **Action**: [Specific deliverable]
+- **Resources**: [Team size, tools, dependencies]
+- **Expected Impact**: [Measurable outcome]
+- **Risk if skipped**: [What happens without this]
+
+### Differentiation (1-3 months)
+- **Action**: [...]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+- **Risk if skipped**: [...]
+
+### Long-term Moat (6-12 months)
+- **Action**: [...]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+- **Risk if skipped**: [...]
+```
+
+**Rules:**
+- Quick Win MUST be achievable in first sprint — no dependencies on later tiers
+- Differentiation should create switching costs or unique capabilities
+- Long-term Moat should compound (network effects, data moats, ecosystem lock-in)
+- Every tier includes "Risk if skipped" — makes trade-offs explicit
+- Skip this step for Bug Fix and Refactor types (no strategic dimension)
+
 ### Step 7 — Requirements Document
 
 Produce structured output and hand off to `plan`:
@@ -306,6 +348,24 @@ Created: [date] | BA Session: [summary]
 ## Risks
 - [risk]: [mitigation]
 
+## Strategic Recommendations
+[from Step 6.5 — skip for Bug Fix/Refactor]
+
+### Quick Win (0-30 days)
+- **Action**: [specific deliverable]
+- **Resources**: [effort estimate]
+- **Expected Impact**: [measurable outcome]
+
+### Differentiation (1-3 months)
+- **Action**: [...]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+
+### Long-term Moat (6-12 months)
+- **Action**: [...]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+
 ## Next Step
 → Hand off to rune:plan for implementation planning
 ```
@@ -360,6 +420,27 @@ US-1: As a [persona], I want to [action] so that [benefit]
 
 Plan gates on Decision compliance — Discretion items don't need approval.
 
+## Strategic Recommendations
+[Skip for Bug Fix/Refactor]
+
+### Quick Win (0-30 days)
+- **Action**: [immediate deliverable]
+- **Resources**: [effort + dependencies]
+- **Expected Impact**: [measurable KPI]
+- **Risk if skipped**: [consequence]
+
+### Differentiation (1-3 months)
+- **Action**: [competitive advantage work]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+- **Risk if skipped**: [...]
+
+### Long-term Moat (6-12 months)
+- **Action**: [defensible position work]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+- **Risk if skipped**: [...]
+
 ## Next Step
 → Hand off to rune:plan for implementation planning
 ```
@@ -401,6 +482,8 @@ Known failure modes for this skill. Check these before declaring done.
 | Recommending shortcuts without Completeness Score | MEDIUM | Step 3.5: every option needs X/10 score + dual effort estimate (human vs AI). "90% coverage" is a red flag when 100% costs 15 min more |
 | Handing off to plan with ambiguity > 40% | CRITICAL | Step 2.5 HARD-GATE: compute ambiguity score after elicitation, block handoff if > 40%, ask targeted follow-up on weakest dimension |
 | Skipping ambiguity scoring because "user seems clear" | HIGH | Always compute the score — perceived clarity ≠ measured clarity. The formula catches gaps humans miss |
+| Tiered recommendations too vague ("improve things") | MEDIUM | Each tier needs specific Action + measurable Expected Impact. "Build better UX" → "Reduce checkout steps from 5 to 3, targeting 15% conversion lift" |
+| All three tiers have same resources/effort | MEDIUM | Quick Win should be low-effort. If all tiers need "2 engineers, 3 months" → re-scope Quick Win to something achievable in 1 sprint |
 
 ## Done When
 
@@ -411,6 +494,7 @@ Known failure modes for this skill. Check these before declaring done.
 - Scope defined (in/out/assumptions/dependencies)
 - User stories with testable acceptance criteria produced
 - Non-functional requirements assessed (relevant ones only)
+- Tiered recommendations generated (Quick Win / Differentiation / Moat) — skip for Bug Fix/Refactor
 - Requirements Document saved to `.rune/features/<name>/requirements.md`
 - Handed off to `plan` for implementation planning
 

package/skills/brainstorm/SKILL.md

@@ -3,7 +3,7 @@ name: brainstorm
 description: Creative ideation and solution exploration. Generates multiple approaches with trade-offs, uses structured frameworks (SCAMPER, First Principles), and hands off to plan for structuring.
 metadata:
   author: runedev
-  version: "0.4.0"
+  version: "0.5.0"
   layer: L2
   model: opus
   group: creation
@@ -101,6 +101,7 @@ Direct API call ≠ Wrapper/middleware layer ≠ Reverse engineering ≠ Browser
 - `plan` (L2): when architecture decision needs creative exploration (Discovery Mode)
 - User: `/rune brainstorm <topic>` direct invocation (Discovery Mode)
 - User: `/rune brainstorm rescue <context>` manual rescue (Rescue Mode)
+- `ba` (L2): when multiple requirement approaches exist
 
 ## Cross-Hub Connections
 
@@ -243,6 +244,7 @@ Additionally in Rescue Mode:
 For approaches with many interacting variables, invoke `rune:sequential-thinking` to reason through trade-offs systematically.
 
 ### Step 4 — Recommend
+
 Select ONE approach as the recommendation. State:
 - Which option is recommended
 - Primary reason (1 sentence)
@@ -250,6 +252,42 @@ Select ONE approach as the recommendation. State:
 
 Do not recommend "it depends" without a concrete decision rule.
 
+### Step 4.5 — Tiered Recommendations (Product/Strategy Mode)
+
+For product-level brainstorming (Vision Mode or when approaches have strategic implications), structure the recommendation into **time-horizon tiers**:
+
+| Tier | Timeframe | Focus |
+|------|-----------|-------|
+| **Quick Win** | 0-30 days | Immediate value, validates direction, low risk |
+| **Differentiation** | 1-3 months | Competitive advantage, harder to copy |
+| **Long-term Moat** | 6-12 months | Defensible position, compounds over time |
+
+**For each tier, specify:**
+
+```markdown
+### Quick Win (0-30 days)
+- **Action**: [specific deliverable from the chosen approach]
+- **Resources**: [team/tools needed]
+- **Expected Impact**: [measurable outcome]
+- **Validates**: [what assumption this proves/disproves]
+
+### Differentiation (1-3 months)
+- **Action**: [...]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+
+### Long-term Moat (6-12 months)
+- **Action**: [...]
+- **Resources**: [...]
+- **Expected Impact**: [...]
+```
+
+**Rules:**
+- Quick Win MUST be achievable with chosen approach in first sprint
+- Each tier builds on the previous — not 3 independent tracks
+- Skip this step for pure technical brainstorming (no product/strategy dimension)
+- If all tiers look equally expensive → approach may be too complex for Quick Win
+
 ### Step 5 — Return to Plan
 Pass the recommended approach back to `rune:plan` for structuring into an executable implementation plan. Include:
 - The chosen option name

package/skills/browser-pilot/SKILL.md

@@ -24,6 +24,7 @@ Browser automation for testing and verification using MCP Playwright tools. Navi
 - `marketing` (L2): screenshot for assets
 - `launch` (L1): verify live site after deployment
 - `perf` (L2): Lighthouse / Core Web Vitals measurement
+- `audit` (L2): visual verification during quality assessment
 
 ## Calls (outbound)
 

package/skills/context-engine/SKILL.md

@@ -4,7 +4,7 @@ description: "Context window management. Auto-triggered when context is filling
 user-invocable: false
 metadata:
   author: runedev
-  version: "0.9.0"
+  version: "1.0.0"
   layer: L3
   model: haiku
   group: state
@@ -44,7 +44,11 @@ Context-engine also manages **behavioral mode injection** via `contexts/` direct
 
 ## Called By (inbound)
 
-- Auto-triggered at phase boundaries and context thresholds by L1 orchestrators
+- `cook` (L1): Phase boundaries and when tool count exceeds thresholds
+- `team` (L1): before parallel workstream dispatch, after merge
+- `rescue` (L1): between refactoring sessions for state persistence
+- `context-pack` (L3): when packaging context for sub-agent handoff
+- `session-bridge` (L3): coordinates with context-engine for compaction timing
 
 ## Execution
 

package/skills/design/SKILL.md

@@ -32,6 +32,7 @@ Design system reasoning layer. Converts a product description into a concrete de
 ## Called By (inbound)
 
 - `cook` (L1): before any frontend code generation
+- `scaffold` (L1): design system for new project
 - `brainstorm` (L2): when selected approach has UI/UX implications
 - `ba` (L2): when requirements include UI/UX components
 - `review` (L2): when AI anti-pattern detected in diff

package/skills/docs-seeker/SKILL.md

@@ -25,6 +25,7 @@ None — pure L3 utility using `WebSearch`, `WebFetch`, and Context7 MCP tools d
 - `debug` (L2): lookup API docs for unclear errors
 - `fix` (L2): check correct API usage before applying changes
 - `review` (L2): verify API usage is current and correct
+- `adversary` (L2): verify framework/API assumptions in plan are correct
 
 ## Execution
 

package/skills/fix/SKILL.md

@@ -3,7 +3,7 @@ name: fix
 description: Apply code changes and fixes. Writes implementation code, applies bug fixes, and verifies changes with tests. Core action hub in the development mesh.
 metadata:
   author: runedev
-  version: "0.9.0"
+  version: "1.0.0"
   layer: L2
   model: sonnet
   group: development
@@ -49,6 +49,8 @@ If unsure whether the test is wrong or the implementation is wrong → call `run
 - `review` (L2): bug found during review, needs fixing
 - `surgeon` (L2): apply refactoring changes
 - `review-intake` (L2): apply fixes identified during structured review intake
+- `graft` (L2): apply integration fixes for grafted code
+- `scaffold` (L1): apply fixes during project scaffolding
 
 ## Cross-Hub Connections
 
@@ -278,7 +280,7 @@ Append to Fix Report when invoked standalone. Suppress when called as sub-skill
 ```yaml
 chain_metadata:
   skill: "rune:fix"
-  version: "0.9.0"
+  version: "1.0.0"
   status: "[DONE | DONE_WITH_CONCERNS | NEEDS_CONTEXT | BLOCKED]"
   domain: "[area fixed]"
   files_changed:

package/skills/hallucination-guard/SKILL.md

@@ -38,6 +38,7 @@ Post-generation validation that verifies AI-generated code references actually e
 - `db` (L2): verify SQL syntax and ORM method calls are real
 - `review-intake` (L2): verify imports in code submitted for review
 - `skill-forge` (L2): verify imports in newly generated skill code
+- `adversary` (L2): verify APIs/packages in plan actually exist
 
 ## Execution
 

package/skills/journal/SKILL.md

@@ -37,6 +37,7 @@ None — pure L3 state management utility.
 - `incident` (L2): record incident timeline and postmortem
 - `skill-forge` (L2): record skill creation decisions and rationale
 - `graft` (L2): auto-log graft operations — source URL, mode, challenge score, files changed
+- `retro` (L2): record retrospective insights and decisions
 
 ## Files Managed
 

package/skills/logic-guardian/SKILL.md

@@ -3,11 +3,12 @@ name: logic-guardian
 description: Protects complex business logic from accidental deletion or overwrite. Maintains a logic manifest, enforces pre-edit gates, and validates post-edit diffs.
 metadata:
   author: runedev
-  version: "0.1.0"
+  version: "0.3.0"
   layer: L2
   model: sonnet
   group: quality
   tools: "Read, Write, Edit, Glob, Grep"
+  listen: invariants.loaded
 ---
 
 # logic-guardian
@@ -41,15 +42,23 @@ Complex projects (trading bots, payment systems, game engines, state machines) c
 
 ## Workflow
 
-### Phase 0 — Load or Initialize Manifest
+### Phase 0 — Load Manifest + Invariants
 
 1. Use `Read` on `.rune/logic-manifest.json`
 2. If file exists:
    - Parse manifest, display summary: "Loaded logic manifest: N components, M functions, K parameters"
-   - Proceed to Phase 1 (Validate)
-3. If file does NOT exist:
+   - Proceed to step 4 (load invariants)
+3. If manifest does NOT exist:
    - Announce: "No logic manifest found. Scanning project to generate one."
    - Proceed to Phase 3 (Generate)
+4. Obtain invariants (seeded by `onboard` — see onboard Step 5.4):
+   - **Preferred**: consume the `invariants.loaded` signal emitted by `session-bridge` at session start (contains pre-parsed `rules[]` + stats). No second file read needed.
+   - **Fallback**: if no signal was emitted this session, `Read` `.rune/INVARIANTS.md` directly and invoke `skills/session-bridge/scripts/load-invariants.js` to parse.
+   - Entries come from `## Danger Zones`, `## Critical Invariants`, `## State Machine Rules`, `## Cross-File Consistency`, and `## Auto-detected (new)`. Archived rules are automatically excluded by the loader.
+   - Each entry follows the `WHAT / WHERE / WHY` contract from `invariants-template.md`.
+   - Treat `INVARIANTS.md` as the **primary source of cross-file rules** — the JSON manifest covers component-level signatures; INVARIANTS.md covers rules that span files (shared constants, state transitions, mirrored schemas).
+   - If the file is absent, log **WARN**: "INVARIANTS.md not found — run `rune onboard` to seed baseline rules." Do not block.
+   - Cache parsed rules keyed by glob so Phase 2 can match the edit target in O(rules × globs) time.
 
 ### Phase 1 — Validate Manifest Against Codebase
 
@@ -83,6 +92,15 @@ Before ANY edit to a manifested file:
    - What it will NOT change
    - Which existing functions/logic will be preserved
 4. If the agent cannot list the existing functions → BLOCK the edit. Force a `Read` of the file first.
+5. **Cross-file invariant check** — for each rule loaded from `.rune/INVARIANTS.md` in Phase 0:
+   - If the target file matches any rule's `WHERE` glob, surface the rule to the agent before the edit proceeds:
+     ```
+     INVARIANT (from .rune/INVARIANTS.md):
+       WHAT:  <rule.what>
+       WHY:   <rule.why>
+     ```
+   - The agent MUST either (a) acknowledge the rule in its plan, or (b) explicitly mark it obsolete and move the entry to `## Archived`.
+   - A matched rule with no acknowledgement → BLOCK in `strict` preset, WARN in `gentle` preset.
 
 ### Phase 3 — Generate Manifest (first-time or rescan)