@rune-kit/rune 2.27.0 → 2.29.0

package/hooks/post-session-reflect/index.cjs

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateFile } = require('../lib/context-key.cjs');
 const { captureConsole } = require('../lib/hook-output.cjs');
 // Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
 // discards the output). Capture the prints below and emit one envelope on exit.
@@ -12,12 +12,17 @@ captureConsole('Stop');
 
 
 const cwd = process.cwd();
-const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+let sessionId;
+try {
+  sessionId = JSON.parse(fs.readFileSync(0, 'utf-8')).session_id;
+} catch {
+  // Older runtimes may not provide hook input.
+}
 
 // === H3: Flush Session Metrics ===
 
-const metricsJsonl = path.join(os.tmpdir(), `rune-metrics-${hash}.jsonl`);
-const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+const metricsJsonl = stateFile('rune-metrics', sessionId, cwd).replace(/\.json$/, '.jsonl');
+const counterFile = stateFile('rune-context-watch', sessionId, cwd);
 const runeMetricsDir = path.join(cwd, '.rune', 'metrics');
 
 // Resolve skill names → expected model from agent frontmatter
@@ -101,33 +106,69 @@ function flushMetrics() {
   const modelsUsed = resolveSkillModels(skillCounts);
 
   // Use session ID from context-watch (shared) or generate new
-  const sessionId = watchState.sessionId
+  const metricSessionId = sessionId
+    || watchState.sessionId
     || `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
 
-  // 1. Append to sessions.jsonl
+  // 1. Upsert sessions.jsonl. Stop can fire more than once in one session;
+  // appending every time inflated session counts and duration metrics.
+  let previousSession = null;
+  const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');
+  let sessionEntries = [];
+  if (fs.existsSync(sessionsFile)) {
+    sessionEntries = fs
+      .readFileSync(sessionsFile, 'utf-8')
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .flatMap((line) => {
+        try {
+          return [JSON.parse(line)];
+        } catch {
+          return [];
+        }
+      });
+    previousSession = [...sessionEntries].reverse().find((entry) => entry.id === metricSessionId) || null;
+  }
+
+  const mergedSkillCounts = { ...(previousSession?.skill_counts || {}) };
+  for (const [skill, count] of Object.entries(skillCounts)) {
+    mergedSkillCounts[skill] = (mergedSkillCounts[skill] || 0) + count;
+  }
+  const mergedSkillDurations = { ...(previousSession?.skill_durations || {}) };
+  for (const [skill, duration] of Object.entries(skillDurations)) {
+    mergedSkillDurations[skill] = (mergedSkillDurations[skill] || 0) + duration;
+  }
+  const mergedModels = { ...(previousSession?.models_used || {}) };
+  for (const [model, count] of Object.entries(modelsUsed)) {
+    mergedModels[model] = (mergedModels[model] || 0) + count;
+  }
+  const mergedSkills = Object.keys(mergedSkillCounts);
+  const mergedPrimarySkill = Object.entries(mergedSkillCounts)
+    .sort((a, b) => b[1] - a[1])[0]?.[0]
+    || previousSession?.primary_skill
+    || primarySkill;
+
   const sessionEntry = {
-    id: sessionId,
+    id: metricSessionId,
     date: now.slice(0, 10),
     duration_min: durationMin,
     tool_calls: watchState.count,
     tool_distribution: watchState.toolCounts,
-    skill_invocations: skillEvents.length,
-    skills_used: Object.keys(skillCounts),
-    primary_skill: primarySkill,
-    models_used: modelsUsed,
-    skill_durations: Object.keys(skillDurations).length > 0 ? skillDurations : undefined
+    skill_invocations: Object.values(mergedSkillCounts).reduce((sum, count) => sum + count, 0),
+    skills_used: mergedSkills,
+    primary_skill: mergedPrimarySkill,
+    models_used: mergedModels,
+    skill_counts: Object.keys(mergedSkillCounts).length > 0 ? mergedSkillCounts : undefined,
+    skill_durations: Object.keys(mergedSkillDurations).length > 0 ? mergedSkillDurations : undefined
   };
 
-  const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');
-  fs.appendFileSync(sessionsFile, JSON.stringify(sessionEntry) + '\n');
-
-  // Cap at 100 sessions (rotate oldest)
-  try {
-    const allLines = fs.readFileSync(sessionsFile, 'utf-8').trim().split('\n').filter(Boolean);
-    if (allLines.length > 100) {
-      fs.writeFileSync(sessionsFile, allLines.slice(-100).join('\n') + '\n');
-    }
-  } catch { /* cap is best-effort */ }
+  sessionEntries = sessionEntries.filter((entry) => entry.id !== metricSessionId);
+  sessionEntries.push(sessionEntry);
+  fs.writeFileSync(
+    sessionsFile,
+    `${sessionEntries.slice(-100).map((entry) => JSON.stringify(entry)).join('\n')}\n`,
+  );
 
   // 2. Merge into skills.json (running totals)
   const skillsFile = path.join(runeMetricsDir, 'skills.json');
@@ -153,7 +194,7 @@ function flushMetrics() {
   if (skillChain.length > 0) {
     const chainsFile = path.join(runeMetricsDir, 'chains.jsonl');
     const chainEntry = {
-      session: sessionId,
+      session: metricSessionId,
       chain: skillChain,
       depth: skillChain.length
     };
@@ -170,7 +211,7 @@ function flushMetrics() {
     .map(([s, c]) => `${s}(${c})`)
     .join(', ');
 
-  console.log(`\n📊 [Rune metrics] Session ${sessionId} — ${durationMin}min, ${watchState.count} tool calls, ${skillEvents.length} skill invocations`);
+  console.log(`\n📊 [Rune metrics] Session ${metricSessionId} — ${durationMin}min, ${watchState.count} tool calls, ${skillEvents.length} new skill invocations`);
   if (skillList) console.log(`   Skills: ${skillList}`);
   console.log(`   Saved to .rune/metrics/\n`);
 }

package/hooks/pre-compact/index.cjs

@@ -7,20 +7,26 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateFile } = require('../lib/context-key.cjs');
 
 const { captureConsole } = require('../lib/hook-output.cjs');
 // Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
 // discards the output). Capture the prints below and emit one envelope on exit.
-captureConsole('PreCompact');
+captureConsole('PreCompact', { captureError: true });
 
 
 const cwd = process.cwd();
 const runeDir = path.join(cwd, '.rune');
 
+let sessionId;
+try {
+  sessionId = JSON.parse(fs.readFileSync(0, 'utf-8')).session_id;
+} catch {
+  // Older runtimes may not provide hook input.
+}
+
 // Read context-watch state (tool counts, session timing)
-const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
-const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+const counterFile = stateFile('rune-context-watch', sessionId, cwd);
 
 let watchState = null;
 try {

package/hooks/pre-tool-guard/index.cjs

@@ -66,14 +66,14 @@ function appendGateOutcome(gate, outcome, detail) {
  *
  * @param {string} toolName
  * @param {object} toolInput
- * @returns {string} target path, or '' when this is not a patch we understand
+ * @returns {string[]} target paths
  */
-function patchTargetPath(toolName, toolInput) {
-  if (toolName !== 'apply_patch') return '';
-  const patch = typeof toolInput === 'string' ? toolInput : toolInput.input || toolInput.patch || '';
-  if (typeof patch !== 'string') return '';
-  const match = patch.match(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/m);
-  return match ? match[1].trim() : '';
+function patchTargetPaths(toolName, toolInput) {
+  if (toolName !== 'apply_patch') return [];
+  const patch =
+    typeof toolInput === 'string' ? toolInput : toolInput.command || toolInput.input || toolInput.patch || '';
+  if (typeof patch !== 'string') return [];
+  return Array.from(patch.matchAll(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/gm), (match) => match[1].trim());
 }
 
 // Read tool_input from Claude Code hook stdin
@@ -92,11 +92,9 @@ process.stdin.on('end', () => {
     process.exit(0);
   }
 
-  const filePath = toolInput.file_path || toolInput.path || patchTargetPath(toolName, toolInput);
-  if (!filePath) process.exit(0);
-
-  const basename = path.basename(filePath);
-  const normalized = filePath.replace(/\\/g, '/');
+  const directPath = toolInput.file_path || toolInput.path;
+  const filePaths = directPath ? [directPath] : patchTargetPaths(toolName, toolInput);
+  if (filePaths.length === 0) process.exit(0);
 
   // Load project-specific privacy config
   const privacyConfig = loadPrivacyConfig();
@@ -147,33 +145,37 @@ process.stdin.on('end', () => {
   const activeSkill = process.env.RUNE_ACTIVE_SKILL || '';
   const isElevated = elevatedSkills.has(activeSkill);
 
-  const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
-  if (isSafe) process.exit(0);
-
-  const isBlocked = blockPatterns.some((p) => p.test(basename) || p.test(normalized));
-  if (isBlocked) {
-    // Append block outcome BEFORE printing/exiting — fail-safe, never affects exit code.
-    // Only "blocked" is captured here; "passed" and "bypassed" are not observable
-    // at this layer and intentionally remain uncaptured (see GAP-1 in governance-collector.js).
-    appendGateOutcome('privacy-mesh', 'blocked', `file matched BLOCK-tier pattern: ${basename}`);
-
-    console.log(`\n🚫 [Rune privacy-mesh] BLOCKED: ${filePath}`);
-    console.log('  This file matches a BLOCK-tier pattern (private keys, certificates).');
-    console.log('  Override: add path to .rune/privacy.json "allow" list if intentional.\n');
-    process.exit(2); // Exit code 2 = BLOCK
-  }
+  for (const filePath of filePaths) {
+    const basename = path.basename(filePath);
+    const normalized = filePath.replace(/\\/g, '/');
+    const isSafe = safeExceptions.some((p) => p.test(basename) || p.test(normalized));
+    if (isSafe) continue;
+
+    const isBlocked = blockPatterns.some((p) => p.test(basename) || p.test(normalized));
+    if (isBlocked) {
+      // Append block outcome BEFORE printing/exiting — fail-safe, never affects exit code.
+      // Only "blocked" is captured here; "passed" and "bypassed" are not observable
+      // at this layer and intentionally remain uncaptured (see GAP-1 in governance-collector.js).
+      appendGateOutcome('privacy-mesh', 'blocked', `file matched BLOCK-tier pattern: ${basename}`);
+
+      console.log(`\n🚫 [Rune privacy-mesh] BLOCKED: ${filePath}`);
+      console.log('  This file matches a BLOCK-tier pattern (private keys, certificates).');
+      console.log('  Override: add path to .rune/privacy.json "allow" list if intentional.\n');
+      process.exit(2); // Exit code 2 = BLOCK
+    }
 
-  const isWarned = warnPatterns.some((p) => p.test(basename) || p.test(normalized));
-  if (isWarned && !isElevated) {
-    // Content-aware check: scan first 4KB for secret patterns
-    const contentWarning = scanContentForSecrets(filePath);
+    const isWarned = warnPatterns.some((p) => p.test(basename) || p.test(normalized));
+    if (isWarned && !isElevated) {
+      // Content-aware check: scan first 4KB for secret patterns
+      const contentWarning = scanContentForSecrets(filePath);
 
-    console.log(`\n⚠ [Rune privacy-mesh] Sensitive file: ${filePath}`);
-    if (contentWarning) {
-      console.log(`  Content scan: ${contentWarning}`);
+      console.log(`\n⚠ [Rune privacy-mesh] Sensitive file: ${filePath}`);
+      if (contentWarning) {
+        console.log(`  Content scan: ${contentWarning}`);
+      }
+      console.log('  This file may contain secrets. Confirm access is intentional.');
+      console.log('  Elevated skills (sentinel, review, audit) bypass this warning.\n');
     }
-    console.log('  This file may contain secrets. Confirm access is intentional.');
-    console.log('  Elevated skills (sentinel, review, audit) bypass this warning.\n');
   }
 
   process.exit(0);

package/hooks/run-hook

@@ -8,7 +8,7 @@ if (!hookName) {
   process.exit(1);
 }
 
-const hookPath = path.join(__dirname, hookName, 'index.js');
+const hookPath = path.join(__dirname, hookName, 'index.cjs');
 try {
   require(hookPath);
 } catch (e) {

package/hooks/run-hook.cmd

@@ -1 +1 @@
-@node "%~dp0run-hook.js" %*
+@node "%~dp0run-hook.cjs" %*

package/hooks/secrets-scan/index.cjs

@@ -6,10 +6,26 @@
 // Zero false-positive tolerance on BLOCK patterns.
 
 const { execSync } = require('child_process');
+const fs = require('fs');
+const { captureConsole } = require('../lib/hook-output.cjs');
+
+captureConsole('PreToolUse', { captureError: true });
 
 // Only intercept git commit commands
-const input = JSON.parse(process.env.CLAUDE_TOOL_INPUT || '{}');
-const command = (input.command || '').trim();
+let rawInput = '';
+try {
+  rawInput = fs.readFileSync(0, 'utf-8');
+} catch {
+  // Claude compatibility fallback below.
+}
+let event = {};
+try {
+  event = JSON.parse(rawInput.trim() || process.env.CLAUDE_TOOL_INPUT || '{}');
+} catch {
+  process.exit(0);
+}
+const toolInput = event.tool_input || event;
+const command = (toolInput.command || '').trim();
 
 // Check if this is a git commit command
 if (!/^git\s+commit\b/.test(command)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.27.0",
-  "description": "65-skill mesh for AI coding assistants — runtime auto-discipline via native hooks (Claude/Cursor/Windsurf/Antigravity), 5-layer architecture, 204 connections + 43 signals, multi-platform compiler. converge (L3) scans spec vs code so dead-button/frontend-only implementations can't ship.",
+  "version": "2.29.0",
+  "description": "66-skill mesh for AI coding assistants — native lifecycle hooks for Claude Code and Codex, 5-layer architecture, 248 connections + 45 signals, and a 13-platform compiler.",
   "type": "module",
   "bin": {
     "rune": "./compiler/bin/rune.js"
@@ -52,6 +52,7 @@
     "commands/",
     "agents/",
     "hooks/",
+    ".codex-plugin/",
     "references/"
   ],
   "homepage": "https://rune-kit.github.io/rune",

package/skills/browser-pilot/SKILL.md

@@ -25,6 +25,7 @@ Browser automation for testing and verification using MCP Playwright tools. Navi
 - `launch` (L1): verify live site after deployment
 - `perf` (L2): Lighthouse / Core Web Vitals measurement
 - `audit` (L2): visual verification during quality assessment
+- `design` (L2): render the surface before any visual property is claimed (design Step 5.4 — render blindness)
 
 ## Calls (outbound)
 

package/skills/completion-gate/SKILL.md

@@ -148,11 +148,11 @@ For each claim, look for corresponding evidence in the conversation context:
 
 | Claim Type | Required Evidence | Where to Find |
 |---|---|---|
-| "tests pass" | Test runner stdout with pass count | Bash output from test command |
-| "build succeeds" | Build command stdout showing success | Bash output from build command |
-| "lint clean" | Linter stdout (even if empty = 0 errors) | Bash output from lint command |
-| "fixed" | Git diff showing the change + test proving fix | Edit/Write tool calls + test output |
-| "implemented" | Files created/modified matching the plan | Write/Edit tool calls vs plan |
+| "tests pass" | Test runner stdout with pass count | Shell output from test command |
+| "build succeeds" | Build command stdout showing success | Shell output from build command |
+| "lint clean" | Linter stdout (even if empty = 0 errors) | Shell output from lint command |
+| "fixed" | Git diff showing the change + test proving fix | File-edit evidence + test output |
+| "implemented" | Files created/modified matching the plan | File changes compared with the plan |
 | "no security issues" | Sentinel report with PASS verdict | Sentinel skill output |
 | "coverage ≥ X%" | Coverage tool output with actual percentage | Test runner with coverage flag |
 

package/skills/design/SKILL.md

@@ -3,7 +3,7 @@ name: design
 description: "Design system reasoning. Maps product domain to style, palette, typography, and platform-specific patterns. Generates .rune/design-system.md as the shared design contract for all UI-generating skills."
 metadata:
   author: runedev
-  version: "0.8.0"
+  version: "0.9.0"
   layer: L2
   model: sonnet
   group: creation
@@ -27,6 +27,7 @@ Design system reasoning layer. Converts a product description into a concrete de
 
 - `scout` (L2): detect existing design tokens, component library, platform targets
 - `asset-creator` (L3): generate base visual assets (logo, OG image) from design system
+- `browser-pilot` (L3): render the surface and inspect it before claiming any visual property holds (Step 5.4)
 - `review` (L2): accessibility violations found → flag for fix in next code review
 
 ## Called By (inbound)
@@ -477,21 +478,47 @@ sm: 6px | md: 8px | lg: 12px | xl: 16px | full: 9999px
 [detected library or "custom"]
 
 ## Pre-Delivery Checklist
-- [ ] Color contrast ≥ 4.5:1 for all text
-- [ ] Focus-visible ring on ALL interactive elements (never outline-none alone)
-- [ ] Touch targets ≥ 44×44px on mobile / ≥ 24×24px on desktop, with 8px gap between targets (matches Step 2.9 Rule 1)
+> Items marked 👁 describe what a human would SEE — tick them only from a render, or mark them ASSUMED (Step 5.4).
+- [ ] 👁 Color contrast ≥ 4.5:1 for all text
+- [ ] 👁 Focus-visible ring on ALL interactive elements (never outline-none alone)
+- [ ] 👁 Touch targets ≥ 44×44px on mobile / ≥ 24×24px on desktop, with 8px gap between targets (matches Step 2.9 Rule 1)
 - [ ] All icon-only buttons have aria-label
 - [ ] All inputs have associated <label> or aria-label
-- [ ] Empty state, error state, loading state for all async data
+- [ ] 👁 Empty state, error state, loading state for all async data
 - [ ] cursor-pointer on all clickable non-button elements
 - [ ] prefers-reduced-motion respected for all animations
 - [ ] Dark mode support (or explicit reasoning why not)
-- [ ] Responsive tested at 375px / 768px / 1024px / 1440px
+- [ ] 👁 Responsive tested at 375px / 768px / 1024px / 1440px
 - [ ] No pure #000 or #fff in semantic tokens (use oklch neutrals)
 - [ ] No lorem ipsum / placeholder copy in shipped output (use real data or labelled `[ PLACEHOLDER: ... ]` blocks)
 - [ ] If multi-language: CJK-capable font listed FIRST in stack (`"Noto Sans SC", "Inter", ...`)
 ```
 
+### Step 5.4 — Render Blindness (advisory)
+
+A checklist item ticked from source is a prediction, not an observation. You emit markup and
+imagine the result, and **the imagined render is always flattering** — overflow, wrapping,
+contrast failure, misalignment and collision are invisible in source form. Every item in the
+checklist above that describes what a human would *see* is unverified until the surface is
+rendered and inspected, or the specific property is computed.
+
+| Claim | What source-reading proves | What actually settles it |
+|-------|---------------------------|--------------------------|
+| "Contrast ≥ 4.5:1" | The token values were chosen | Compute the ratio for the rendered pair — a token used on an unexpected background fails anyway |
+| "Responsive at 375px" | Breakpoints exist | Render at 375px and look: wrapping, overflow, tap-target collision |
+| "No overflow / clean alignment" | Nothing | Render — this class of failure has no textual signature |
+| "Focus ring visible" | The CSS rule exists | Tab through it; a parent `overflow:hidden` or a later rule can eat it |
+| "Empty / error / loading states work" | The branches exist | Render each one; the happy path is the only state most designs are ever seen in |
+
+**Advisory, not a gate.** When the runtime grants a browser, `browser-pilot` is the strongest
+check available and costs one call — take it, then report what was seen. When it does not,
+say so: mark the visual items **ASSUMED (not rendered)** rather than ticking them. A checklist
+of predictions labelled as observations is worse than a short one that is honest — see
+`completion-gate` → `references/claim-discipline.md`.
+
+Highest-yield renders, when budget allows only a few: narrowest breakpoint, longest realistic
+content string, empty state, dark mode.
+
 ### Step 5.5 — UI Design Contract (UI-SPEC.md)
 
 After generating the design system, lock key visual decisions in `.rune/ui-spec.md` — a binding contract that prevents design drift during implementation.

package/skills/doc-processor/SKILL.md

@@ -41,7 +41,7 @@ None — pure L3 utility. Receives content, produces formatted output.
 
 | Format | Generate | Parse | Node.js Library | Python Library |
 |--------|----------|-------|-----------------|----------------|
-| PDF | Yes | Yes (via Read tool) | jsPDF, Puppeteer (HTML→PDF) | reportlab, weasyprint |
+| PDF | Yes | Yes (via the runtime's document/PDF reader) | jsPDF, Puppeteer (HTML→PDF) | reportlab, weasyprint |
 | DOCX | Yes | Yes | docx (officegen) | python-docx |
 | XLSX | Yes | Yes | ExcelJS | openpyxl |
 | PPTX | Yes | Yes | pptxgenjs | python-pptx |
@@ -157,7 +157,7 @@ Identify file format from extension and MIME type.
 
 | Format | Extraction Strategy |
 |--------|-------------------|
-| PDF | Use Read tool (Claude can read PDFs natively) |
+| PDF | Use the runtime's native document/PDF reader when available; otherwise use a supported PDF parsing library |
 | DOCX | docx library → extract text, tables, images |
 | XLSX | ExcelJS → extract sheets, rows, formulas |
 | PPTX | pptxgenjs → extract slides, text, notes |

package/skills/hallucination-guard/SKILL.md

@@ -39,6 +39,7 @@ Post-generation validation that verifies AI-generated code references actually e
 - `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
+- `logic-guardian` (L2): verify referenced functions and imports after guarded logic edits
 
 ## Execution
 

package/skills/journal/SKILL.md

@@ -39,6 +39,7 @@ None — pure L3 state management utility.
 - `graft` (L2): auto-log graft operations — source URL, mode, challenge score, files changed
 - `retro` (L2): record retrospective insights and decisions
 - `improve-architecture` (L2): record an ADR when the user rejects a deepening candidate with a load-bearing reason
+- `logic-guardian` (L2): record guarded logic changes for cross-session persistence
 
 ## Files Managed
 

package/skills/problem-solver/SKILL.md

@@ -3,7 +3,7 @@ name: problem-solver
 description: "Structured reasoning frameworks for complex problems. 19 analytical frameworks, 12 cognitive bias detectors, 10 decomposition methods, 10 mental models, Cynefin domain classification, ethical dimension check, and 6 communication patterns. McKinsey-grade problem solving for AI coding assistants."
 metadata:
   author: runedev
-  version: "0.5.0"
+  version: "0.6.0"
   layer: L3
   model: sonnet
   group: reasoning
@@ -77,6 +77,10 @@ NEVER skip bias detection. Every problem has biases — explicitly address them.
 This is the #1 value-add from structured reasoning. Without it, solutions are just dressed-up gut feelings.
 </HARD-GATE>
 
+Two catalogs run here, not one: the biases of the people and organisation in the problem, and the failure modes of the model doing the analysis. Skipping the second is how a rigorous-looking analysis reaches a confidently wrong conclusion.
+
+#### Human and organisational biases
+
 Scan the problem statement and context for bias indicators. Check the top 6 most dangerous biases:
 
 | Bias | Detection Question | Debiasing Strategy |
@@ -96,6 +100,32 @@ Additional biases to check when relevant:
 - **Survivorship Bias**: Are we only looking at successful cases? Who tried this approach and failed?
 - **Recency Bias**: Are we extrapolating from the last few data points instead of looking at 5-10 years of data?
 
+#### Model failure modes (the reasoner's own biases — ALSO run)
+
+The table above catalogs how *humans and organisations* misjudge. It says nothing about how
+*you* misjudge. These are the failure modes of the thing doing the analysis, and naming one
+is the first countermeasure — they are invisible from the inside precisely because each one
+feels like competence.
+
+| Failure mode | What it feels like | Countermeasure |
+|--------------|--------------------|----------------|
+| **Pattern-match satisfaction** | The first explanation that fits a familiar template feels like the diagnosis | Familiarity is retrieval, not verification. Hold a second hypothesis before investigating the first |
+| **Template hijack** | A question whose surface matches a stored template ("flaky test → add retry", "slow query → add index") fires the template's answer before this question's constraints are read | Re-derive from *this* problem's details. Familiarity raises the risk, not lowers it |
+| **Fluent ≠ true** | Confidence rises as well-formed prose flows; the argument feels stronger the longer it gets | Confidence tracks evidence, not token count. Audit each point where it rose and name what moved it |
+| **Prior-as-fact** | Training knowledge stated in the grammar of observed fact | Type the claim (`completion-gate` → `references/claim-discipline.md`). Priors decay — APIs, defaults, prices, versions |
+| **Frame adoption** | The asker's framing inherited as fact ("the cache is broken again") | Trust their goal absolutely; treat their diagnosis as testimony to verify |
+| **Completion pressure** | Producing something answer-shaped now feels better than checking one more thing | An answer-shaped non-answer is worse than "here is what I verified, here is what is still open" |
+| **Surface blindness** | Any claim about the form of your own output — which symbols it contains, how many units it has — read back as true | You see tokens, not characters; a re-read always passes. Verify unit by unit or by tool (`verification` → Constraint Loop) |
+
+**Three tells you are inside one right now**: the answer arrived instantly with high
+confidence; your draft never used one of the problem's stated details; two or three attempts
+failed inside the same framing. Any tell means stop and re-derive — never repeat a failed
+probe harder.
+
+**Output**: alongside the human-bias warnings, name any model failure mode active in THIS
+analysis and what you did about it. "None apparent" is a valid answer only if you can say
+which tell you checked.
+
 **Steel Manning** (apply when evaluating competing options):
 Before dismissing any option, construct the STRONGEST possible version of the argument for it. If you can't articulate why a smart, informed person would choose it, you haven't understood it yet. Steel Manning prevents strawman dismissals and forces genuine evaluation.
 
@@ -335,6 +365,7 @@ Structure the output report using the selected pattern.
 ### Bias Warnings
 - ⚠️ [Bias 1]: [how it might affect this analysis] → [debiasing action taken]
 - ⚠️ [Bias 2]: [how it might affect this analysis] → [debiasing action taken]
+- 🤖 [Model failure mode]: [which tell fired] → [what was re-derived or verified]
 
 ### Reasoning Chain
 1. [step with evidence or reasoning]

package/skills/retro/SKILL.md

@@ -316,8 +316,8 @@ Pull from all installed domain packs:
 - **Engineering**: git history (commits, velocity, test ratio, fix ratio, hotspots)
 - **Revenue** (@rune-pro/sales): pipeline metrics, deal velocity, churn risk
 - **Support** (@rune-pro/support): ticket volume, SLA compliance, CSAT
-- **Finance** (@rune-business/finance): burn rate, runway, budget variance
-- **Compliance** (@rune-business/legal): framework status, audit dates, open items
+- **Finance** (@rune-pro/finance): burn rate, runway, budget variance
+- **Compliance** (@rune-pro/legal): framework status, audit dates, open items
 
 ### Business Execution Steps
 

package/skills/session-bridge/SKILL.md

@@ -41,6 +41,7 @@ Solve the #1 developer complaint: context loss across sessions. Session-bridge a
 - `context-pack` (L3): coordinate state for sub-agent handoff
 - `neural-memory` (L3): sync key decisions back to `.rune/` files after Capture Mode
 - `adversary` (L2): (oracle-mode) detach protocol when target model is opus-class for non-blocking dispatch
+- `logic-guardian` (L2): preserve logic-manifest state across sessions
 
 ## State Files Managed
 

package/skills/session-bridge/scripts/load-invariants.js

@@ -132,7 +132,7 @@ export function parseInvariants(text) {
   let current = null;
 
   const flush = () => {
-    if (current && current.title) rules.push(current);
+    if (current?.title) rules.push(current);
     current = null;
   };
 

package/skills/verification/SKILL.md

@@ -3,7 +3,7 @@ name: verification
 description: "Universal verification runner. Runs lint, type-check, tests, and build. Use after any code change to verify nothing is broken."
 metadata:
   author: runedev
-  version: "0.7.0"
+  version: "0.8.0"
   layer: L3
   model: haiku
   group: validation
@@ -207,6 +207,47 @@ Exit 0 without a confirming output artifact or success string = UNVERIFIED.
 Report the specific line that confirmed success (e.g., "3 passed, 0 failed").
 </HARD-GATE>
 
+### Surface-Constraint Verification (the Constraint Loop)
+
+Everything above verifies *behaviour* with a tool. Some deliverables instead carry a
+constraint on their own **surface form**: a banned or required character, an exact word or
+line count, a positional pattern, a strict format, a naming scheme every entry must follow,
+a diff that must not touch a listed path. These look trivial and are the opposite — a model
+generates meaning-first and reads its own output as tokens, not characters, so the
+constraint sits exactly where its perception is weakest. The most natural wording for the
+topic is usually the likeliest violator.
+
+**Re-reading the output and judging that it complies is not verification.** A re-read always
+passes. That is the whole failure mode.
+
+Run this loop whenever a deliverable carries a mechanically checkable surface constraint:
+
+1. **Expand the constraint before producing anything.** Restate it as a test every governed
+   unit must pass, and decide *how you will count* before there is anything to count. List
+   the on-topic vocabulary most likely to violate it — starting with the subject's own name,
+   which the constraint may rule out — and pick compliant substitutes up front.
+2. **Draft away from the final answer** — a scratch file or reasoning space, never straight
+   into the deliverable.
+3. **Verify mechanically, strongest tool available.** A script, `grep`, `wc`, a formatter's
+   `--check`, a schema validator — seconds of work and the strongest possible evidence. With
+   no tool available, decompose the text into the units the constraint governs and test each
+   one explicitly (spell the word out; count with a running index). Manual decomposition is
+   the fallback for tool-poor runtimes, not a substitute where a tool exists.
+4. **Repair and re-verify the whole artifact.** A fix can introduce a new violation
+   elsewhere, so re-scan everything — one green check on the edited line says nothing about
+   its neighbours. Loop until one complete pass over the final text is clean.
+5. **Ship the verified text byte-for-byte.** Any post-verification rewording, however small,
+   invalidates the check — touch one unit and step 3 runs again.
+
+<HARD-GATE name="surface-constraint">
+"The output satisfies the constraint" is a verified claim only after step 3 has run against
+the EXACT delivered text. Asserted from a re-read, it is an assumption wearing the grammar of
+an observation — see `completion-gate` → `references/claim-discipline.md`. Report the check
+that was run, not the conclusion.
+</HARD-GATE>
+
+Report it like any other phase: `Constraint: <the rule> | Check: <command or method> | Units tested: N | Violations: 0`.
+
 ## Error Recovery
 
 - If project type cannot be detected: report "Unknown project type" and skip all checks

package/skills/video-creator/SKILL.md

@@ -265,7 +265,7 @@ Known failure modes for this skill. Check these before declaring done.
 - Storyboard created scene-by-scene with transitions
 - Shot list categorized by type (screen recording, terminal, code, diagram)
 - Assets needed checklist generated
-- video-plan.md written to output_path via Write tool
+- `video-plan.md` written to `output_path` with the runtime's file-edit capability
 - Video Plan Created report emitted with scene count, shot count, and asset count
 
 ## Cost Profile