get-claudia 1.61.0 → 1.62.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.62.0 (2026-06-13)
+
+### Loop engineering foundation (Proposal 11, Phases 1-2)
+
+The first two phases of the Autonomy & Personalization Layer: the Maker-Checker pattern on the existing `auto-research` loop, a bounded self-repair sub-loop, the shared loop infrastructure later loops reuse, and a `meditate` feed that reviews how the loops themselves performed. See `docs/proposals/11-autonomy-personalization-layer.md`.
+
+### Added
+
+- **Independent Checker for `auto-research`** (Proposal 11, E2). The iteration loop no longer grades its own work. Each iteration now dispatches a new `loop-checker` agent (Haiku, adversarial brief) that scores the artifact against the rubric independently; the Checker's score, not Claudia's, drives the keep/revert decision. When the Checker's score and Claudia's self-score diverge past threshold, the iteration is flagged `contested` and surfaced in the end-of-run summary. New files: `template-v2/.claude/agents/loop-checker.md` and `template-v2/.claude/skills/_loop/` (`maker.md`, `checker.md`, `README.md`).
+- **Loop status-file schema** (Proposal 11, E1). `docs/loop-status-schema.md` defines a standard Markdown-body + YAML-frontmatter control plane (`last_input`, `maker_proposal`, `checker_verdict`, `verified`, `next_action`, and friends) plus the exit-condition standard every loop must declare up front. `auto-research` now writes `research_status.md` in this format each iteration.
+- **Atomic status-file helper** (Proposal 11, E1/B3). New daemon module `claudia_memory/loops/status.py` (`write_status` / `read_status`) writes a status file through a same-directory temp file plus `os.replace`, so an interrupted write never leaves a partial file at the canonical path. Six tests in `memory-daemon/tests/test_loop_status.py` cover round-trip, native-type preservation, parent-dir creation, temp cleanup, and crash-safety.
+- **Self-repair sub-loop** (Proposal 11, E3). When a loop stalls (the Checker fails 3 times running or scores regress), `auto-research` now enters a bounded self-repair pass (`template-v2/.claude/skills/_loop/repair.md`): it diagnoses whether the rubric or a brief is the real problem, proposes one fix, and proves it on the exact failing input before adopting it. Capped at 2 repair attempts; confirmed repairs leave a regression fixture under `~/.claudia/loops/regressions/`; edits to shipped briefs always go to a human approval gate.
+- **`meditate` reviews loop-harness performance** (Proposal 11, E4). End-of-session reflection now reads recent loop status files, summarizes how Claudia's own Maker-Checker loops did (contested iterations, stuck loops, recurring Checker findings), and can propose a harness improvement. Any such proposal passes through the Checker before it is written, and edits to shipped briefs are presented as a diff for approval.
+
+## 1.61.1 (2026-05-23)
+
+### `claudia` command works from anywhere, and repairs itself
+
+A follow-up to 1.61.0's shell command. The installer was storing a relative path, so `claudia` only worked from the install's parent directory. This release fixes the stored path and makes the command self-healing, so the error cannot recur.
+
+### Fixed
+
+- **`claudia` command failing with "Claudia home directory not found: claudia".** The installer wrote a *relative* path (`claudia`) into `~/.claudia/claudia-home` instead of the absolute install path, because the shell-helper step was handed `targetDir` (relative) rather than the resolved `targetPath`. The `claudia` command then only worked when run from the install's parent directory and failed everywhere else. The installer now always stores the absolute path (via `path.resolve`, which also fixes a separate bug where passing an absolute install path as an argument produced a doubled path like `/home/you/home/you/claudia`).
+- **`claudia` command now self-heals a bad `claudia-home`.** The shell function resolves a relative stored value against `$HOME` (never the current directory), falls back to the default `~/claudia` install when the stored path is missing or stale, and rewrites `claudia-home` with the corrected absolute path so the error cannot recur. Existing installs that already have a bad value are repaired the first time `claudia` runs after upgrading.
+- **`--skip-memory` installs now get the `claudia` command too.** Previously the shell-helper step was skipped entirely on the `--skip-memory` path, leaving those users with no `claudia`/`update-claudia` command. The shell helper is independent of the memory system and now installs on every path.
+
 ## 1.61.0 (2026-05-22)
 
 ### Launch from anywhere, upgrade from anywhere
@@ -19,7 +45,6 @@ This release adds a `claudia` shell command (and `update-claudia`) so you no lon
 
 - **ASCII greeting logo: row 1 (hair top) realigned over face** (in `template-v2/CLAUDE.md`). The top hair row was indented 6 leading spaces while the face row below it starts at column 0, so the hair appeared shifted ~4 characters to the right. Now sits correctly above the face. Existing installs see the fix on next upgrade.
 - **Installer no longer treats flag-looking arguments as install targets.** Previously, `npx get-claudia --help` (or any unrecognized `--flag`) was interpreted as the install path and would create a `./--help/` directory with templates copied into it. Now: `--help`/`-h` prints a proper usage message and exits, `--version`/`-V` prints the version, and any other leading-dash argument prints `Error: unrecognized argument: <flag>` and exits 1 without touching the filesystem.
-
 ## 1.60.1 (2026-05-22)
 
 ### Two bug fixes from the fixing-phase pass

package/bin/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync, writeFileSync, statSync, renameSync, unlinkSync, copyFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { spawn, execFileSync } from 'child_process';
 import { homedir } from 'os';
@@ -828,7 +828,9 @@ async function main() {
   // Support "." or "upgrade" for current directory
   const isCurrentDir = arg === '.' || arg === 'upgrade';
   const targetDir = isCurrentDir ? '.' : (arg || 'claudia');
-  const targetPath = isCurrentDir ? process.cwd() : join(process.cwd(), targetDir);
+  // resolve() (not join) so an absolute arg is honored as-is and the result is
+  // always absolute (this value is what gets written into ~/.claudia/claudia-home).
+  const targetPath = isCurrentDir ? process.cwd() : resolve(process.cwd(), targetDir);
 
   // Check if directory already exists with Claudia files
   let isUpgrade = false;
@@ -969,11 +971,14 @@ async function main() {
     }
     renderer.render();
 
-    // Only run vault step
-    runVaultStep(renderer, () => {
-      renderer.stopSpinner();
-      renderer.render();
-      showCompletion(targetDir, isCurrentDir, false, undefined, isUpgrade);
+    // The `claudia` shell command is independent of the memory system, so install
+    // it here too, otherwise --skip-memory users get no `claudia` command.
+    runShellStep(renderer, targetPath, () => {
+      runVaultStep(renderer, () => {
+        renderer.stopSpinner();
+        renderer.render();
+        showCompletion(targetDir, isCurrentDir, false, undefined, isUpgrade);
+      });
     });
     return;
   }
@@ -1563,8 +1568,11 @@ async function main() {
 
   renderer.stopSpinner();
 
-  // Shell helper step, then vault, then completion
-  runShellStep(renderer, targetDir, () => {
+  // Shell helper step, then vault, then completion.
+  // Pass the absolute targetPath (not the relative targetDir): this value lands
+  // in ~/.claudia/claudia-home, and a relative value there breaks `claudia` from
+  // any directory other than the install's parent.
+  runShellStep(renderer, targetPath, () => {
     runVaultStep(renderer, () => {
       renderer.render();
       showDbScanResults(dbScan);

package/bin/shell-init.js

@@ -28,17 +28,37 @@ export const SHELL_INIT_CONTENT = `# Claudia shell helpers — sourced from your
 
 _claudia_home() {
   local home_file="$HOME/.claudia/claudia-home"
-  if [ ! -f "$home_file" ]; then
-    echo "Claudia home not configured. Run: npx get-claudia ." >&2
-    return 1
+  local dir=""
+  [ -f "$home_file" ] && dir="$(cat "$home_file" 2>/dev/null)"
+
+  # A relative value (e.g. an older install that stored "claudia") is anchored to
+  # $HOME, never the current directory, so \`claudia\` works from anywhere.
+  case "$dir" in
+    /*) ;;                  # already absolute
+    "") ;;                  # empty -> handled by recovery below
+    *) dir="$HOME/$dir" ;;  # relative -> resolve under $HOME
+  esac
+
+  # Recover from a missing or stale path by falling back to the default install
+  # location when it looks like a real Claudia install.
+  if [ -z "$dir" ] || [ ! -d "$dir" ]; then
+    if [ -d "$HOME/claudia/.claude" ] || [ -f "$HOME/claudia/CLAUDE.md" ]; then
+      dir="$HOME/claudia"
+    fi
   fi
-  local dir
-  dir="$(cat "$home_file")"
-  if [ ! -d "$dir" ]; then
-    echo "Claudia home directory not found: $dir" >&2
-    echo "Fix by editing $home_file" >&2
+
+  if [ -z "$dir" ] || [ ! -d "$dir" ]; then
+    echo "Claudia install not found. Run: npx get-claudia ." >&2
+    [ -f "$home_file" ] && echo "(or set the correct path in $home_file)" >&2
     return 1
   fi
+
+  # Self-heal: persist the corrected absolute path so the error never recurs.
+  if [ "$(cat "$home_file" 2>/dev/null)" != "$dir" ]; then
+    mkdir -p "$HOME/.claudia" 2>/dev/null
+    printf '%s\\n' "$dir" > "$home_file" 2>/dev/null || true
+  fi
+
   printf '%s' "$dir"
 }
 

package/memory-daemon/claudia_memory/loops/__init__.py

@@ -0,0 +1,9 @@
+"""Loop-engineering helpers (Proposal 11).
+
+Shared infrastructure for Maker-Checker loops: atomic, human-readable status
+files that act as the control plane for both skill-level and daemon-level loops.
+"""
+
+from claudia_memory.loops.status import read_status, write_status
+
+__all__ = ["read_status", "write_status"]

package/memory-daemon/claudia_memory/loops/status.py

@@ -0,0 +1,85 @@
+"""Atomic status-file helper for loop engineering (Proposal 11, E1/B3).
+
+A status file is Markdown with a YAML frontmatter block. The frontmatter carries
+the structured control fields (loop_id, verified, checker_verdict, next_action,
+...) and the body carries the human-readable narrative:
+
+    ---
+    loop_id: consolidation
+    verified: true
+    next_action: none
+    ---
+
+    # Loop status: consolidation
+
+    Last run consolidated 12 memories; all invariants held.
+
+Writes go through a temp file in the same directory followed by ``os.replace``,
+so an interrupted write never leaves a partially-written file at the canonical
+path. A reader sees either the complete previous file or the complete new one.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+_DELIM = "---"
+
+
+def write_status(path: str | os.PathLike, fields: dict[str, Any], body: str = "") -> None:
+    """Atomically write a status file at ``path``.
+
+    Serializes ``fields`` as YAML frontmatter and appends ``body`` as the
+    Markdown body. Creates missing parent directories. If the final rename
+    fails, the canonical path is left untouched and the temp file is removed.
+    """
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+
+    frontmatter = yaml.safe_dump(fields, sort_keys=False, default_flow_style=False).strip()
+    content = f"{_DELIM}\n{frontmatter}\n{_DELIM}\n\n{body}"
+
+    # Temp file lives in the SAME directory as the target so that os.replace is
+    # a same-filesystem rename (atomic), not a cross-device copy.
+    tmp = target.with_name(f".{target.name}.tmp")
+    try:
+        with open(tmp, "w", encoding="utf-8") as fh:
+            fh.write(content)
+            fh.flush()
+            os.fsync(fh.fileno())
+        os.replace(tmp, target)
+    except BaseException:
+        # Any failure (including the rename) must leave the canonical path
+        # intact and must not litter the directory with a temp file.
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+def read_status(path: str | os.PathLike) -> tuple[dict[str, Any], str]:
+    """Read a status file, returning ``(fields, body)``.
+
+    ``fields`` is the parsed frontmatter (empty dict if there is none); ``body``
+    is the Markdown body with the single separating blank line removed.
+    """
+    text = Path(path).read_text(encoding="utf-8")
+    return _split_frontmatter(text)
+
+
+def _split_frontmatter(text: str) -> tuple[dict[str, Any], str]:
+    if not text.startswith(_DELIM):
+        return {}, text
+    rest = text[len(_DELIM):].lstrip("\n")
+    end = rest.find(f"\n{_DELIM}")
+    if end == -1:
+        return {}, text
+    raw = rest[:end]
+    body = rest[end + 1 + len(_DELIM):].lstrip("\n")
+    fields = yaml.safe_load(raw) or {}
+    return fields, body

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.61.0",
+  "version": "1.62.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/agents/loop-checker.md

@@ -0,0 +1,51 @@
+---
+name: loop-checker
+description: Independently scores a loop iteration's output against a rubric and returns a structured verdict. Adversarial by design: finds faults, does not confirm. Used by auto-research and future Maker-Checker loops.
+model: haiku
+dispatch-category: verification
+dispatch-tier: task
+auto-dispatch: false
+---
+
+# Loop Checker
+
+You are Claudia's Loop Checker. When a loop produces an iteration, Claudia
+dispatches you to score it independently of whoever produced it. You are the
+"Checker" half of the Maker-Checker pattern (Proposal 11).
+
+Your brief is the Checker role brief at `.claude/skills/_loop/checker.md`. Follow
+it exactly. The short version:
+
+- You receive a `rubric`, an `artifact` to score, and the `proposed_change` the
+  Maker made (with the Maker's expected effect, if any).
+- Score the artifact against each rubric dimension. Sum to a total.
+- Hunt for faults: unmet constraints, regressions the change introduced,
+  dimensions the Maker over-claimed.
+- Decide `verified`. When uncertain, default to `verified: false`: a false pass
+  costs more than one more iteration.
+- Do not be swayed by the Maker's self-score. Score independently.
+
+## Output
+
+Return exactly the verdict JSON defined in the Checker role brief:
+
+```json
+{
+  "verified": false,
+  "score": 7.2,
+  "max_score": 10,
+  "issues": [
+    {"severity": "major", "issue": "the ask is buried in paragraph 3", "where": "body"}
+  ],
+  "rationale": "One or two sentences, grounded in the rubric.",
+  "hard_constraint_violated": false
+}
+```
+
+## Constraints
+
+- Do NOT edit the artifact. You score and report; the Maker edits.
+- Do NOT decide keep or revert. You return a verdict; the loop applies the rule.
+- Do NOT soften findings to be agreeable. Disagreement with the Maker is the
+  entire reason you exist as a separate agent.
+- Be concrete: every issue names a severity, what is wrong, and where.

package/template-v2/.claude/manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.61.0",
-  "generated": "2026-05-23T02:25:12.290Z",
+  "version": "1.62.0",
+  "generated": "2026-06-14T02:37:03.060Z",
   "algorithm": "sha256",
   "files": {
     ".claude/rules/claudia-principles.md": "939e9720421628e7f2e4c8dfbaa4aeb9c1e18e8c6a5379cd6b772a6835b812e5",
@@ -10,6 +10,10 @@
     ".claude/rules/shell-compatibility.md": "565977bc04e269b3ce7d8a7963173df4f44bb9634692ea76abb1b64f6a67513e",
     ".claude/rules/trust-north-star.md": "0188b17c26b791cf597ce975bb75d40f543aa3d6b84b7edb1309b78530b3d43f",
     ".claude/skills/README.md": "22311215317c61dcb67975af02bdd1d7164578713ff9faf6fbed8aec14256bcd",
+    ".claude/skills/_loop/README.md": "13d44b9d2f88be477a71773a1dbbe8a3270bdda39a16785beaeff92abaeb019e",
+    ".claude/skills/_loop/checker.md": "dcec7e38330244973020050bb95e76853ff5f05ebf4ca82b6b442d2eb26f7832",
+    ".claude/skills/_loop/maker.md": "eadc6c2c59f3e43f4b029c3d40ce3af29cd746da219c132da0888d31a0743e01",
+    ".claude/skills/_loop/repair.md": "675704a1aa1eb8463dac6270bd02ea34099674a9012e1b65924ef6923b384d5b",
     ".claude/skills/agent-dispatcher.md": "b48fc5283f0a88d1ebbc692b30b6c326fef012d4168dcf721a94e3c954b76b90",
     ".claude/skills/archetypes/_base-structure.md": "c0d8df77c07aa48cd9ba9c5ba3eddb533fcea790c7f98440fa3d31405fd5c75d",
     ".claude/skills/archetypes/consultant.md": "1e0ccbf89115f92a1fa0c86b48edcce22668c4bb828ba4268376fcd6b5c05680",
@@ -17,7 +21,7 @@
     ".claude/skills/archetypes/executive.md": "0d43c5c2c6315f5a4d6d36150778b55229cc922e0491a80af54824d87ac52e82",
     ".claude/skills/archetypes/founder.md": "a5bf3f22439c7c5f554c13966899a4af4de80f90c8f6a25eb62be1c68de6d54f",
     ".claude/skills/archetypes/solo.md": "cc26332b96394775e62a0f1a06f32093be6147bb75fa3783aa271e554d323c6b",
-    ".claude/skills/auto-research/SKILL.md": "1a54e5d82f4e87c78a54e1331ff2d32aaff12c2712058e21173aa900a57b01c3",
+    ".claude/skills/auto-research/SKILL.md": "2f7f8a7d0731813921094b0117026693314f0f59e8d9b52637bd3e775a2e95f8",
     ".claude/skills/auto-research/references/program-template.md": "850457de96bde5ad65d24f1018509da94dd31fec9ec45c15087031f470a28dbc",
     ".claude/skills/auto-research/references/safety-rules.md": "ae036270e86949ed0f9bface582f6038276adafd3f40a29aa733698111a26683",
     ".claude/skills/brain/SKILL.md": "b87dd93c85923c676292bea67f7a0580ee71eea2bea05426ea6eda951a140d5c",
@@ -46,7 +50,7 @@
     ".claude/skills/ingest-sources/references/extraction-patterns.md": "28d6dc604c4a11eacfe4523e705ad430ba8fe26632bafcccaef656e9618e5aea",
     ".claude/skills/judgment-awareness.md": "0077129a87f91d295515108f3f9a68ca6874c6e38fc7f2a73a462704fa00ba2d",
     ".claude/skills/map-connections/SKILL.md": "e8133d5e3de36e32e3858a1ee3918a577855e77ade022933097f87a0100cc9a3",
-    ".claude/skills/meditate/SKILL.md": "1d814f0c52f4309708669139ba4b637bf05a228e2381950ee3851c6145e25cc7",
+    ".claude/skills/meditate/SKILL.md": "1d4eab90fdedd652f75750df1a1c3be885fbeefb89d5d99979324e395eb6fd83",
     ".claude/skills/meditate/evals/basic.yaml": "daba441b2fd9d1d4afddcff6eaa9673884198b1d0f85d9d06edbe0738012291a",
     ".claude/skills/meeting-prep/SKILL.md": "cb0b2afc41052a0652e7de30d09e71ab489162fbb09c648e3c95cec2d438ba63",
     ".claude/skills/memory-audit/SKILL.md": "7daed2ec128ea70171b8e3ffaf4d933ca69db2637b1487f69724e3428c04663a",

package/template-v2/.claude/skills/_loop/README.md

@@ -0,0 +1,33 @@
+# _loop: shared loop-engineering resources
+
+This directory is **not a skill**. It has no `SKILL.md` and is not listed in
+`skill-index.json`, so the skill router never loads it directly. It holds the
+versioned Maker and Checker prompt templates that skill-level loops reuse, so the
+Maker-Checker pattern is defined once and shared.
+
+Consumers today:
+
+- `auto-research` (Proposal 11, E2) uses `checker.md` to score each iteration
+  independently of the Maker.
+- `build-team` (Proposal 11, E6, not yet built) will reuse both templates.
+
+The underscore prefix marks this as an internal resource, not a user-facing
+capability. See `docs/loop-status-schema.md` for the status-file contract these
+loops write, and `docs/proposals/11-autonomy-personalization-layer.md` for the
+design.
+
+## Files
+
+| File | Role |
+|------|------|
+| `maker.md` | The producer prompt: makes one bounded change per iteration. |
+| `checker.md` | The independent verifier prompt: scores adversarially, returns a structured verdict. |
+| `repair.md` | The self-repair sub-loop: when a loop stalls, diagnose and fix the harness, proven on the exact failing input. |
+
+## Why Maker and Checker are separate
+
+A single agent grading its own work has a self-justification bias: it tends to
+rate what it just produced as good. Splitting the roles, and giving the Checker
+an adversarial brief (find faults, do not confirm), makes a passing verdict
+actually mean something. The Checker runs on a cheaper model tier (Haiku) so the
+verification pass is fast and inexpensive.

package/template-v2/.claude/skills/_loop/checker.md

@@ -0,0 +1,64 @@
+# Checker role brief (Proposal 11, E1/B2)
+
+The Checker verifies work the Maker produced. It is dispatched as a separate
+agent (`loop-checker`, Haiku) so it reasons independently of the Maker and costs
+little to run. Its brief is adversarial: **find faults, do not confirm.** A
+passing verdict from a Checker told to look for problems is worth something; a
+rubber stamp is not.
+
+## What the Checker receives
+
+The dispatching skill passes:
+
+- `rubric`: the scoring criteria (from the loop's program/rubric file).
+- `artifact`: the current output to score (the edited draft, the proposed team,
+  the consolidation result).
+- `proposed_change`: the one change the Maker made this iteration, and the
+  Maker's expected effect (the self-score), if any.
+
+## How the Checker scores
+
+1. Score the artifact against each rubric dimension on its stated scale. Sum to a
+   total `score`.
+2. Actively hunt for what is wrong or weak: unmet constraints, regressions the
+   change introduced, dimensions the Maker over-claimed, anything the rubric
+   penalizes.
+3. Decide `verified`: did this artifact meet the rubric's bar (and not violate
+   any hard constraint)? When uncertain, default to `verified: false`. The cost
+   of a false pass is higher than the cost of one more iteration.
+4. Do not be swayed by the Maker's self-score. Score independently first, then
+   you may note divergence.
+
+## Output contract (return exactly this JSON)
+
+```json
+{
+  "verified": false,
+  "score": 7.2,
+  "max_score": 10,
+  "issues": [
+    {"severity": "major", "issue": "the ask is buried in paragraph 3", "where": "body"},
+    {"severity": "minor", "issue": "two sentences exceed the length cap", "where": "closing"}
+  ],
+  "rationale": "Lede improved, but the rubric weights ask-clarity heavily and the ask is still not in the opening.",
+  "hard_constraint_violated": false
+}
+```
+
+- `verified` (bool): does the artifact clear the bar this iteration?
+- `score` (float): total across rubric dimensions.
+- `max_score` (float): the maximum the rubric allows, so the caller can normalize.
+- `issues` (array): concrete, located faults. Empty only when there genuinely are
+  none. Each has `severity` (`major` | `minor`), `issue`, and `where`.
+- `rationale` (string): one or two sentences. Why this verdict, grounded in the
+  rubric.
+- `hard_constraint_violated` (bool): true if any non-negotiable constraint failed
+  (which forces `verified: false` regardless of score).
+
+## What the Checker does not do
+
+- It does not edit the artifact. It scores and reports; the Maker edits.
+- It does not decide keep/revert. It returns a verdict; the loop applies the
+  rule (keep if the score beats the running best and no hard constraint failed).
+- It does not soften findings to be agreeable. Disagreement with the Maker is the
+  whole point.

package/template-v2/.claude/skills/_loop/maker.md

@@ -0,0 +1,39 @@
+# Maker role brief (Proposal 11, E1/B2)
+
+The Maker produces work. In a Claudia loop, the Maker is Claudia herself (the
+main model), not a dispatched subagent. This brief defines how the Maker behaves
+inside any Maker-Checker loop, so the producer role is consistent across
+`auto-research`, `build-team`, and future loops.
+
+## Contract
+
+Each iteration, the Maker does exactly one thing:
+
+1. **Read the state.** The program/rubric, the current artifact, and the last
+   few rows of history (what was tried, what was kept, what was reverted).
+2. **Propose ONE change.** One specific, bounded edit, justified in a single
+   sentence. Not a rewrite. Not a refactor. Not three changes bundled together.
+   One lever, pulled deliberately, so the Checker can attribute the score delta
+   to it.
+3. **Apply it** to the working copy (never the user's original file during the
+   loop).
+4. **Hand off to the Checker.** The Maker does not score its own work for the
+   keep/revert decision. It may state an expected effect ("this should raise the
+   lede dimension"), which becomes the Maker self-score the Checker's verdict is
+   compared against, but the Checker's score governs.
+
+## Discipline
+
+- One change per iteration. Bundling changes destroys the signal.
+- Justify in one sentence. If the justification needs a paragraph, the change is
+  too big; split it.
+- Stay inside the bounds declared up front (see the exit-condition standard in
+  `docs/loop-status-schema.md`).
+- Honest self-assessment. Do not inflate the expected effect to pre-empt the
+  Checker. The point of the split is that the Checker is not you.
+
+## Why the Maker does not grade itself
+
+A model that grades its own output rates it generously: it just argued itself
+into producing exactly that. The keep/revert decision therefore belongs to an
+independent Checker (see `checker.md`). The Maker proposes; the Checker disposes.

package/template-v2/.claude/skills/_loop/repair.md

@@ -0,0 +1,85 @@
+# Self-repair brief (Proposal 11, E3)
+
+When a Maker-Checker loop keeps failing, the problem may not be the artifact: it
+may be the harness (the rubric, the Maker brief, or the Checker brief). The
+self-repair sub-loop diagnoses that, proposes a fix, and proves the fix on the
+exact input that failed before adopting it. It is itself bounded, and it never
+auto-edits shipped briefs or the user's live files.
+
+This brief is shared. `auto-research` uses it today; future loops reuse it.
+
+## B1: When self-repair triggers
+
+Enter the self-repair sub-loop when any of these holds during a loop:
+
+- The Checker returns `verified: false` for **3 iterations in a row**.
+- The Checker's `score` **regresses** across 3 consecutive iterations (each lower
+  than the last).
+- An iteration raises an **exception** the loop cannot attribute to the artifact
+  (for example, the Checker returns malformed output twice).
+
+These are signals that hill-climbing has stalled for a structural reason, not
+that one more edit will help.
+
+## B2: The repair sub-loop
+
+Self-repair is itself a small Maker-Checker loop, run on the harness instead of
+the artifact:
+
+1. **Diagnose (Maker).** Read the last few status rows and the Checker's `issues`.
+   State, in one or two sentences, the single most likely harness cause: an
+   ambiguous rubric dimension, a Maker brief that permits bundled changes, a
+   Checker brief that scores the wrong thing, a missing hard constraint.
+2. **Propose one fix (Maker).** One concrete edit to exactly one harness piece
+   (the rubric in `program.md`, `maker.md`, or `checker.md`). Not a rewrite. One
+   lever.
+3. **Validate on the exact failing input (Checker).** Re-run the failing
+   iteration's input through the loop **with the proposed fix applied in a scratch
+   copy**, and dispatch the `loop-checker`. The fix is adopted only if that exact
+   previously-failing case now reaches `verified: true` (or scores materially
+   higher) and no previously-passing regression fixture breaks.
+4. **Adopt or discard.** If it passes, apply the fix (see B4 for where).
+   If it does not, discard it and either try one more diagnosis (within the B4
+   bound) or stop and hand the loop back to the user with the diagnosis.
+
+The non-negotiable rule is step 3: a fix is never adopted on a hunch. It must be
+proven on the input that exposed the problem.
+
+## B3: Regression capture
+
+Every confirmed repair leaves a regression behind so the same failure cannot
+silently return:
+
+- Save the failing input plus the verdict it should now produce as a fixture
+  under `~/.claudia/loops/regressions/<loop-id>/<short-slug>.md` (a status file in
+  the standard schema, with the expected `verified`/`score`).
+- On future runs of that loop, replay the loop-id's regression fixtures through
+  the Checker first. If any regression breaks, the loop refuses to start and
+  reports which fix regressed.
+
+Shipped-skill regressions (ones that should travel with the template, not just
+the user's machine) are proposed to the user for inclusion as in-repo test
+fixtures instead.
+
+## B4: Bound and safety
+
+Self-repair obeys the same bounded-autonomy rules as every loop:
+
+- **Bounded.** At most **2 repair attempts** per loop run. After that, stop and
+  hand back to the user with the diagnosis. Self-repair never loops forever.
+- **Workspace-only for artifacts.** The repair sub-loop validates in a scratch
+  copy and never touches the user's original file.
+- **Never auto-edit shipped briefs.** A fix to `maker.md` or `checker.md` (files
+  that ship in the template) is **proposed as a diff for the user to approve**,
+  never written silently. A fix to a run-local `program.md` rubric may be applied
+  within the run, since that rubric is the user's own per-run governance file.
+- **Logged.** Each repair attempt appends to the loop's status file: what was
+  diagnosed, what was changed, and whether the exact failing input passed after
+  the change.
+
+## What self-repair is not
+
+- It is not a license to rewrite the harness whenever a loop is hard. It triggers
+  only on the B1 signals, and it changes one thing at a time.
+- It is not autonomous prompt-editing of shipped files. Those changes always end
+  at a human approval gate.

package/template-v2/.claude/skills/auto-research/SKILL.md

@@ -14,11 +14,11 @@ A hill-climber for any local artifact with a rubric. Inspired by [Karpathy's aut
 Three primitives, one governance file:
 
 1. **The artifact** — what gets iterated on (a draft email, a brief, a wiki page, a one-pager). Lives in the workspace, never touches the user's original file during the loop.
-2. **The evaluator** — a scalar rubric Claudia scores against. Plain English. Must produce a number for the original artifact before the loop starts.
+2. **The evaluator** — a scalar rubric. Plain English. An independent Checker (the `loop-checker` agent, Haiku) scores each iteration against it, not Claudia herself. The rubric must produce a number for the original artifact before the loop starts.
 3. **The budget** — iteration count (default 20). Loop stops when budget is exhausted or score plateaus.
 4. **The program** (governance file) — what the user wants, what's off-limits, what counts as "better." Claudia helps the user write this if they don't volunteer it.
 
-Loop: read program + artifact + results history → propose one specific change → implement → score → if better, ratchet (commit); if worse, revert (git reset). Report each iteration as a one-line update. Repeat until budget is hit.
+Loop: read program + artifact + results history, Claudia (the Maker) proposes one specific change, implements it, then dispatches the `loop-checker` (the Checker) to score it independently. If the Checker's score beats the running best, ratchet (commit); if worse, revert (git reset). Write the status file. Report each iteration as a one-line update. Repeat until budget is hit.
 
 ## When to invoke this skill
 
@@ -53,7 +53,8 @@ Each run gets its own workspace at `~/.claudia/auto-research/<task-id>/`:
 ├── program.md           the brief (user-authored with Claudia's help)
 ├── artifact.md          (or .txt, the working copy that gets edited)
 ├── original.md          immutable copy of the input, for reference and diff
-├── results.tsv          one row per iteration: timestamp, score, kept/reverted, change-summary
+├── results.tsv          one row per iteration: timestamp, score, kept/reverted/contested, change-summary
+├── research_status.md   loop control plane (see docs/loop-status-schema.md): iteration, verified, score, checker_verdict, next_action
 ├── best.md              symlink (or copy on Windows) to the highest-scoring version
 └── iterations/
     ├── 01/artifact.md
@@ -111,16 +112,50 @@ For each iteration N:
 1. **Read the state.** Read `program.md`, `artifact.md`, last 3 rows of `results.tsv`.
 2. **Propose one change.** One specific edit, justified in one sentence. Not a rewrite. Not a refactor. One change.
 3. **Implement.** Apply the edit to `artifact.md`. Save.
-4. **Score.** Score the new `artifact.md` against the rubric in `program.md`. Sum the dimensions. Round to one decimal.
-5. **Decide.** If new score > best score so far: ratchet. Copy `artifact.md` to `iterations/NN/`, update `best.md` to point at the new winner, append a row to `results.tsv` marked `kept`. If new score <= best: revert. Copy `iterations/(best_iter)/artifact.md` back to `artifact.md`, append a row marked `reverted`.
-6. **Report.** One line to the user: `iter N: score 7.4 (kept), change: tightened lede to one sentence`.
-7. **Check stop conditions.** If budget exhausted: stop. If score plateaued (no improvement for 5 iterations): stop. Otherwise: next iteration.
+4. **Score (independent Checker).** Dispatch the `loop-checker` agent (Haiku) with the rubric from `program.md`, the new `artifact.md`, and the one change you just made plus your expected effect (your Maker self-score). The Checker returns a verdict JSON: `verified`, `score`, `max_score`, `issues`, `rationale`, `hard_constraint_violated`. You do NOT score it yourself; the Checker's `score` governs the decision. (See `.claude/skills/_loop/checker.md`.)
+5. **Decide.** If the Checker's `score` > best score so far and `hard_constraint_violated` is false: ratchet. Copy `artifact.md` to `iterations/NN/`, update `best.md` to point at the new winner, append a row to `results.tsv` marked `kept`. Otherwise: revert. Copy `iterations/(best_iter)/artifact.md` back to `artifact.md`, append a row marked `reverted`.
+6. **Flag divergence.** Compare the Checker's `score` against your Maker self-score. If they diverge by more than 1.5 points on a 10-point scale, mark the iteration `contested` in `results.tsv`. The Checker's verdict still governs; the flag just surfaces the disagreement in the end-of-run summary.
+7. **Write the status file.** Atomically update `research_status.md` with `iteration`, `verified`, `score`, `budget_remaining`, `last_input`, `maker_proposal`, `checker_verdict` (the Checker's rationale), and `next_action`. Write to a temp sibling and rename; never edit it in place. (See `docs/loop-status-schema.md`.)
+8. **Report.** One line to the user: `iter N: score 7.4 (kept), change: tightened lede to one sentence`. Append `[contested]` when flagged.
+9. **Check stop conditions and self-repair.** If the Checker has returned `verified: false` 3 times in a row, or its score has regressed for 3 straight iterations, enter the self-repair sub-loop (see `.claude/skills/_loop/repair.md`) before giving up: it diagnoses whether the rubric or a brief is the real problem, proposes one fix, and proves it on the exact failing input. If budget exhausted: stop. If score plateaued (no improvement for 5 iterations): stop. Otherwise: next iteration.
+
+## The independent Checker (Maker-Checker)
+
+This loop separates the producer from the verifier (Proposal 11, E2). Claudia is
+the **Maker**: she reads the state and proposes one change. The **Checker** is a
+separate agent (`loop-checker`, Haiku) that scores the result independently. The
+two never collapse into one model grading its own work, which is the bias the
+split exists to remove.
+
+- The Checker's `score`, not Claudia's, drives keep/revert. Claudia's expected
+  effect is only a self-score, used to detect disagreement.
+- The Checker is adversarial by brief: it hunts for faults and defaults to
+  `verified: false` when uncertain. A passing verdict therefore means something.
+- A `hard_constraint_violated: true` verdict forces a revert regardless of score.
+
+**Contested iterations.** When the Checker's score and Claudia's self-score
+diverge by more than 1.5 points (10-point scale), the iteration is marked
+`contested`. The Checker still governs the decision; the flag makes the
+disagreement visible. The end-of-run summary reports how many iterations were
+contested, which is a useful signal that the rubric is ambiguous or that Claudia
+was over-optimistic.
+
+**Cost.** The Checker runs on Haiku, so the verification pass is cheap and fast.
+With the default 20-iteration budget, that is at most 21 Checker dispatches
+(including the baseline), each scoped to a single small artifact.
+
+**Self-repair.** If the loop stalls (the Checker fails 3 times running, or scores
+regress), `auto-research` enters a bounded self-repair sub-loop that treats the
+harness, not the artifact, as the suspect: it diagnoses the rubric or a brief,
+proposes one fix, and proves it on the exact failing input before adopting it.
+See `.claude/skills/_loop/repair.md`. It is capped at 2 repair attempts and never
+auto-edits shipped briefs (those changes go to a human approval gate).
 
 ## Safety rules (mandatory, follow without exception)
 
 1. **Workspace-only edits.** The loop never writes to a file outside `~/.claudia/auto-research/<task-id>/`. The user's original file at `/Users/.../wherever.md` is untouched until the user explicitly approves the final hand-off.
 2. **No external actions during the loop.** No sending, no posting, no scheduling, no calling tools that affect the outside world. The loop is a closed system.
-3. **Baseline-score gate.** Before iteration 1, score the original artifact and write it to `results.tsv` as `iter 0: score X (baseline)`. If the rubric cannot produce a number for the original, the loop does not start; Claudia tells the user the rubric needs to be more specific.
+3. **Baseline-score gate.** Before iteration 1, dispatch the `loop-checker` to score the original artifact and write it to `results.tsv` as `iter 0: score X (baseline)` and to `research_status.md` as iteration 0. If the Checker cannot produce a number for the original, the loop does not start; Claudia tells the user the rubric needs to be more specific.
 4. **Bounded budget.** Default 20 iterations. User can set higher (50 max) or lower. Plateau detection (no improvement for 5 in a row) stops early. The loop is not allowed to be "open-ended" the way Karpathy's autoresearch is; Claudia's safety principles require an end.
 5. **Per-iteration revertability.** Each iteration is a git commit inside the workspace. Workspace is a fresh git repo (`git init` on start, `git commit -am` per iteration). At any point: `git log` shows the history, `git checkout` rolls back to any prior iteration.
 6. **User interrupt at any time.** If the user says "stop", "pause", "show me what you have", or otherwise interrupts: stop the loop immediately. The workspace persists. The best version so far is in `best.md`. The user can resume by saying "continue" (loop picks up from the current best).
@@ -178,10 +213,13 @@ When the user gives a bad rubric, help them turn it into a good one before start
 - `wiki` for iterating wiki pages specifically (compress, sharpen, restructure)
 - `draft-reply`, `follow-up-draft` for one-shot draft generation
 - `summarize-doc` for one-pass summarization
+- `.claude/skills/_loop/` for the shared Maker and Checker role briefs
+- `.claude/agents/loop-checker.md` for the Checker agent definition
+- `docs/loop-status-schema.md` for the `research_status.md` control-plane format
 
 ## Open questions for future versions
 
-- Shell-command evaluators (run `node test.js my-draft.md`, take the number it prints) are deferred. Today, Claudia scores against the rubric in `program.md` directly.
+- Shell-command evaluators (run `node test.js my-draft.md`, take the number it prints) are deferred. Today, the `loop-checker` agent scores against the rubric in `program.md`.
 - Token-spend budget and wall-clock budget are deferred. Today, only iteration count is supported.
 - Parallel branches (try 3 different changes in parallel, keep the winner) are deferred. Today, sequential only.
 - Wiki-page iteration as a first-class use case (apply auto-research to a wiki page until it's < N words while citing all sources) is deferred. The skill supports this in principle today, but a worked example doesn't ship until the wiki has earned its keep.

package/template-v2/.claude/skills/meditate/SKILL.md

@@ -42,6 +42,7 @@ Silently retrieve:
 
 - Call the `memory_reflections` MCP tool to see what already exists
 - Call the `memory_session_context` MCP tool for recent context (if available)
+- Read recent loop status files (`~/.claudia/loops/*_status.md`, and any `research_status.md` from `auto-research` runs this session) to see how Claudia's own Maker-Checker loops performed: which iterations were `contested`, which loops never reached `verified`, where budgets ran out. This feeds the harness review in Step 2b.
 
 ### Step 2: Generate Reflections
 
@@ -78,6 +79,18 @@ Review the session and identify 1-3 reflections. Ask yourself:
 
 **Quality over quantity.** One genuine insight beats three generic observations.
 
+### Step 2b: Loop harness review (only if loops ran this session)
+
+If any Maker-Checker loop ran this session (`auto-research`, or a wrapped daemon job), review how the harness itself performed, separately from reflections about the user. Read the signal from the status files gathered in Step 1, not from memory:
+
+- **Contested iterations.** Did the Maker (Claudia) and the Checker disagree often? Frequent `contested` flags usually mean the rubric is ambiguous or Claudia was over-optimistic, not that the Checker is wrong.
+- **Stuck loops.** Did a loop burn its whole budget without reaching `verified`? That points at the rubric, the Maker brief, or the Checker brief needing sharpening.
+- **Recurring failure shape.** Across runs, is the same kind of issue showing up in the Checker's `issues` list?
+
+If a clear, repeatable harness problem emerges, draft a **harness-improvement proposal**: a concrete edit to a rubric, the Maker brief (`.claude/skills/_loop/maker.md`), the Checker brief (`.claude/skills/_loop/checker.md`), or a new judgment rule about how to run loops. Do not apply it yet. Harness proposals go through the Checker gate in Step 5.
+
+Most sessions produce no harness proposal. Raise one only when the evidence is in the status files.
+
 ### Step 3: Present for Approval
 
 Format reflections clearly and ask for approval:
@@ -171,6 +184,12 @@ Call the `memory_end_session` MCP tool with:
 5. Set `source` to `meditate/YYYY-MM-DD` (today's date)
 6. Write the updated file
 
+**Harness proposals go through the Checker before anything is written** (Proposal 11, E4). If Step 2b produced a harness-improvement proposal (a rubric edit, a Maker or Checker brief edit, or a loop-running judgment rule), validate it first:
+
+1. Dispatch the `loop-checker` agent with the proposal as the artifact and a one-line rubric: "does this change actually fix the observed failure without breaking the brief's contract?"
+2. Write the proposal only if the Checker returns `verified: true`. A proposal the Checker rejects is surfaced to the user as an open question, not saved.
+3. Edits to shipped briefs (`_loop/maker.md`, `_loop/checker.md`) are never auto-applied. Present them as a diff for the user to approve, like any other change to Claudia's own files. Loop-running judgment rules go into `context/judgment.yaml` like any other rule, after passing the Checker.
+
 Confirm storage with both reflections and rules:
 "Got it. I've saved [N] reflection(s) and added [M] judgment rule(s) to your judgment file. I'll apply them going forward. See you next time."