Files
claude/.claude/tasks/TODO.md
T

61 KiB
Raw Blame History

TODO

Open (reconciled 2026-10-23, /reconcile)

Done history before 2026-10-08 removed 2026-10-23 (git keeps it: git log -p -- .claude/tasks/TODO.md); decisions live in .claude/memory/.

Context mod queue (BDR-125): one /ship-feature per phase, order (user 2026-10-25): 0 → 4a → 1 → 5 → 2 → 3 → 4b-4d

Shared rules for every phase:

  • Baseline first: claude -p "/context" at repo root (2026-10-23: 30.2k always-on = memory files 11.6k, skills 10k, agents 2.6k, system 2.5k, MCP instr 2.2k, tools 1.1k). Same measure after; the delta is a phase criterion.

  • Proof bench: .claude/tasks/plans/2026-10-24-context-mod-probe/ (canary per lever + negative control, fresh claude -p --plugin-dir). Every lever a phase uses is re-proved there before code, every "to verify" below becomes a canary criterion.

  • Subtract-only: source text stays in CLAUDE.global.md / rules / CLAUDE.md, marked <!-- jit:<id> --> … <!-- /jit -->; the mod drops a marked section only where it re-delivers it on a trigger. Mod off (~/.claude/context-mod.json "enabled": false) or hook throws → full text loads as today. Guards use .catch deny (fail closed); injections fail open.

  • Inject once per context: mod ledger in $.state of what it injected; reset on session.compact and session.end reason clear; re-inject at the next trigger. Canary test after a real compaction is a criterion (documented, not yet proved).

  • Never: forced continuation / Stop block (BDR-083, BDR-087), per-turn nag (BDR-037), forced skill invocation, hiding a dispatchable agent via agent.offer (breaks dispatch, proved).

  • Cleanup is part of each phase: delete what the phase makes obsolete (scripts, hooks, tests, doctrine lines, Makefile targets, doctor checks), grep every citer and patch in the same branch (doctrine-citers census in make test).

  • Phase 0, no mod: split project CLAUDE.md + fix higgsfield MCP

    • Move the 4 project CLAUDE.md sections (graphify vendored skill 1.4k chars, mods/ 1.3k, rules/ maintenance 1.3k, transient planning artifacts 0.9k) to .claude/rules/<name>.md with paths: (skills/graphify/**; mods/**, skills/model-router; rules/**; docs/superpowers/**). Project scope only: no ~/.claude link points at .claude/ (checked 2026-10-24); never into rules/ (= ~/.claude/rules, every project).
    • .gitignore:122 ignores .claude/*: add !.claude/rules/.
    • Higgsfield: MCP declared user-scope in ~/.claude.json (higgsfield http) and connected while toggle-external.sh says disabled; make toggle-external.sh enable|disable higgsfield own claude mcp add|remove -s user higgsfield (the user runs the first removal), + doctor check "toggle state = MCP state".
    • Proof: canary per moved rule (ABSENT at start, PRESENT after Read of a matching file); /context delta (~1.9k memory files + higgsfield MCP share).
    • Cleanup: CLAUDE.md keeps a 2-line pointer ("rules under .claude/rules load on path"); fix citers of the moved headings.
    • Other projects (user ask 2026-10-24). Measured project CLAUDE.md, loaded every session of that project: faunosteo 50,228 chars (bigger than the global one), zenquality 23,378, game 14,918, robin_petier 12,895, config 4,990, integration_alphalink 4,249; none has .claude/rules/. Splitting is judgment (always-on: overview, stack, commands, conventions; path-scoped: one module, Docker, a folder), so no background automation and no new skill:
      • /onboard gets a split mode (skill edit through /writing-skills: pressure test RED first): read the project CLAUDE.md, classify each section always-on vs path-scoped, propose globs from the real tree, user approves per project, write .claude/rules/<name>.md + slim CLAUDE.md + !.claude/rules/ in .gitignore when .claude/* is ignored.
      • Generators fixed at the source: onboarder + scaffolder (init-project) emit path rules from day one, so new projects are born split.
      • One pass over the git repos in ~/Documents/ (this repo first, then by size: faunosteo, zenquality, game, robin_petier, config, integration_alphalink): one chore/claude-md-split branch per repo, per-project approval, never an automatic merge (user signal per repo), /context before/after per project recorded in that project's journal.
      • Proof: per project, canary that a moved section is ABSENT at start and PRESENT after a Read of a matching file; total always-on delta across the 7 projects.
  • Phase 1, native context diet: no mod (redesigned 2026-10-24 after challenge: the engine already does most of it)

    • Facts 2026-10-24 (scratchpad pathtest, memtest): a paths: rule loads on Read of a matching file, NOT on Write of a new file (S1 ABSENT, S2 after Write ABSENT, S3 after Read PRESENT); "autoMemoryEnabled": false removes the auto-memory system section (PRESENT → ABSENT); classic SessionStart / UserPromptSubmit hooks inject additionalContext (seen live in every session); instruction files reload on compaction natively (InstructionsLoaded load_reason: compact in the 2.1.306 types). So each section goes to the native carrier that matches its trigger, with no mod code, no fail-open risk, and it works with the mod off and in sub-agents.
    • Section → carrier:
      • auto-memory system section → "autoMemoryEnabled": false in settings.json (one line, proven).
      • Design work (1.5k chars) → user rule rules/design-work.md with the UI globs of rules/web-building.md (fires on UI file Read) + hooks/design-toolchain-reminder.sh injects the section text itself when it detects UI work in a prompt (covers new files created from a prompt); drop its "(already in context)" wording.
      • graphify (0.6k) → hooks/session-start.sh injects the section only when graphify-out/graph.json exists (it already computes graph presence for the banner).
      • Public websites never SPA + default language + web APIs versioned (2.3k) → into the skills that brainstorm (init-project, ship-feature STEP 1, brainstorming, refactor whole-project, onboard) + session-start injects them when the cwd has no tracked code file (new project); dedupe "Web APIs" against rules/rest-api.md.
      • secure-by-default domains 4 Supabase + 6 cloud functions → user path rules (supabase/**, **/*.sql; functions/**, **/serverless.*, **/firebase.json); keep "Every API", hosting, injection, exposure and SMS/email always-on (no reliable path for messaging, 325 chars).
      • Our code vs foreign code → session-start runs lib/code-origin.sh once and injects one line ("this repo: ours, strict limits" / "foreign, keep its style"); both short sections stay always-on.
      • Registry format → compressed in phase 4a (lib/memory.sh enforces it); gitflow detail → compressed in phase 2 cleanup (hooks + lib + merge gate enforce it). No JIT needed for either.
    • Project fingerprint (stack, supabase, messaging, functions, graph, origin) moves to phase 3, its first consumer (listing filter), reused by phase 5.
    • Proof: canary per moved section (ABSENT without trigger, PRESENT after it: UI Read, UI prompt, graph.json present, empty dir, skill load, supabase Read); a new-file-only UI turn still gets Design work through the prompt hook; /context delta (~4.4k est. across phases 1, 2, 4a); hook tests extended (design-toolchain-reminder, session-start).
    • Cleanup: CLAUDE.global.md loses the moved sections (one pointer line each where needed), citers patched (doctrine-citers census); BDR-031 citers.
    • The context mod is born in phase 2 or 3 (first need: guards or listing rewrite); challenge at phase 2 launch whether guards fit better as classic hooks (push-guard pattern, transcript_path gives the last user message) or as the mod.
  • Phase 2, guards (redesigned 2026-10-25 after a 3-lens challenge: correctness FATAL(10), robustness FATAL(13), simplicity FATAL(6); plan .claude/tasks/plans/2026-10-24-context-mod-phase2.md)

    • Killed by the challenge: the phrase-list merge gate (false allows: "don't merge it yet", "should we merge it?", pasted text, skill bodies in the transcript; false denies: a plain "oui"; it blocked the BDR-068 /close auto-finish and the release-executor sub-agent finish; "ship it" contradicts the doctrine); G2 destructive guard (BLK-022: the content is withheld, not the language; stays a user-driven task with its two listed options); whole-file code-limit reports (measured 1498 lines > 80 cols across 92 files, lib/gitflow.sh 81: over-fires, LRN-091); parsing commit text from Bash (heredoc -m "$(cat <<'EOF' …)", -F, -C); registry format (in 4a).
    • Merge gate (user pick 2026-10-25: confirmation dialog). Mod tool.call on Bash|Monitor matching gitflow.sh finish, gitflow_finish, or git merge while develop/main is checked out → $.ui.ask("Merge <branch> → <target> ?"), one per branch, single use; dismissed, rejected, -p, or no surface → deny with reason "confirm at the terminal, then re-run". Named exceptions: BDR-068 ritual (this turn's prompt.submit command is capitalize or close, gitflow.sh start chore <name> seen this session, diff touches only .claude/**); release path in a decision table (verify that $.ui.ask works for a sub-agent's tool.call; else /release-candidate runs finish inline, BLK-018 option b). Cheap synchronous prefilter before the .catch deny, so a guard bug never denies every Bash call. Banner or doctor line when the guard is not live. settings.json hard_deny names mod refusals and the mod disarm paths (mods/<name>/ sources, ~/.claude/<name>.json "enabled": false, enabledPlugins <name>@skills-dir, dev-copy shadow). The finish prose stays until canaries pass across sessions. This is the first piece of the context mod.
    • Routing guard (user pick 2026-10-25: "always through a skill"). Measured: "j'aimerais que doctor.sh affiche la version de rtk" was coded inline with no skill (routing probe L3); history 2026-09-23 → 10-24: 10 code-writing bug/feature turns went through a skill, 11 coded inline (long pasted faunosteo briefs). Mod tool.call on Edit/Write/NotebookEdit of a code file by the MAIN loop (no agentId) while no skill run is active (model-router run slot or a skill.prompt seen this turn for feat/bugfix/hotfix/ship-feature/refactor/code-clean/tour…) → deny with reason "route through /hotfix (≤2 files, obvious), /feat, /bugfix or /ship-feature". Free: docs (.md), .claude/**, sub-agents (executors), any write inside a skill run. Doctrine follows in the same change: the ceiling bullet becomes "the main loop writes no code outside a skill run, whatever the model". Proof: routing bench .claude/tasks/plans/2026-10-25-routing-probe/ cases (L3 must now enter a skill), long-brief replay in a clone, false-deny fixtures (doc edits, executor edits, in-skill edits).
    • Commit message: commit-msg git hook emitted by the gitflow hook generator (global core.hooksPath, T10 drift test), active only when CLAUDECODE=1, words counted with trailers excluded, limit read from lib/commit-message.md (one place), exemption only on deterministic convention files (commit template, .gitmessage, commitlint config). A failure is a git error to fix by shortening, not a permission refusal.
    • Code limits: classic PostToolUse hook, added lines only (Edit new_string, Write content), our code only (lib/code-origin.sh on the edited file's repo), 80 columns only, at most 5 reports, once per file per turn, additionalContext, never a deny. Function length deferred (or the project's own linter rule).
    • Proof: an evasion matrix per rule (quoting, cd and -C, bash -c, heredoc, Monitor, sub-agent, non-composer turn); false-allow fixtures for the gate (negation, question, paste); the /close ritual still finishes; the release decision table is tested; destructive commands are never run live (plugin test with stubs only).
    • Cleanup: compress the gitflow section only for the forms now enforced; the commit-message line already points at the lib.
  • Phase 3, listings (scope note 2026-10-25: this is NOT the plugin advisor; per-project profiles are phase 5. Once phase 5 packs exist, the skill listing shrinks natively, so the mod listing filter shrinks to restoring truncated descriptions of kept skills; the routing hint, agent description trim and MCP names stay here; the fingerprint built here also feeds phase 5 profile detection.)

    • Skill listing: prompt.attachment type skill_listing (30,031 chars measured) rewritten from the fingerprint: categories per skill live in routing.json (new contexts field beside the phase row); a skill with no category stays SHOWN (new skills always appear); census test in make test fails on an uncategorised skill; kept skills get their full description back from SKILL.md frontmatter (LRN-175 truncation). Handle the listing delta sent mid-session.
    • To verify first (canary): a skill hidden from the listing still runs when typed (/name) and through the Skill tool.
    • Routing hint: classifier (reuse model-router's small-model call) maps a typed prompt to one skill; inject one line via prompt.submit context only above a confidence threshold, never on slash prompts, mid-turn or inside a run; names hidden skills too. Replaces the CLAUDE.global.md "Skill routing" table (2.1k chars).
    • Agent listing: agent_listing_delta (9,098 chars) rewritten with short descriptions for skill-dispatched executors, names kept. To verify first: dispatch of a trimmed agent still works (agent.offer untouched).
    • MCP: drop instructions + deferred tool names of servers the fingerprint/toggles mark irrelevant (higgsfield off, claude.ai connectors in a coding repo) via mcp_instructions_delta / deferred_tools_delta; ToolSearch still finds them.
    • Proof: canaries (hidden skill ABSENT, control PRESENT, typed hidden skill runs, trimmed agent dispatches), hint precision measured on a fixed prompt set (no hint on chat/bookkeeping), /context delta (~5-7.5k est.).
    • Cleanup: CLAUDE.global.md Skill routing section → 2 lines; LRN-043 routing-line rule superseded; doctor skill-listing budget check updated.
  • Phase 4, memory v2: write, capture, read, feedback (redesigned 2026-10-24 after measurement; 4a needs no mod and can run right after phase 0)

    • Facts 2026-10-24 (scratchpad memeval, 434 entries): registries ~1M chars (decisions 319k, learnings 357k, journal 168k, evals 85k, blockers 68k), never in always-on context, read only by /feat /bugfix /ship-feature (analyze-before-plan); Index drift 6 rows (decisions 121/125, evals 46/48); status in 3 places (title tag, body Status line, Index column; LRN/EVAL none) → reconcile false-open BLK-032..034; no single writer (skill says Edit + manual Index row; Edit needs a Read of a 357k file, so real writes are ad hoc python/bash); 93-100% of entries carry a language-neutral artifact (path, command, quoted string); lesson field present in 98% LRN, 85% BLK, 98% EVAL (median 170-560 chars vs body 1.2-2k); 2 near-duplicate title pairs only; 325/434 entries have links (1080); growth 40-90 entries/month; 44 files cite registry paths; 8 projects on this machine hold v1 registries. "Session start: read .claude/memory/" is unrealistic; caveman premise "registries load every session" is false.
    • Measured recall (5 real FR prompts, 22 relevant entries): BM25 titles 7/22, BM25 full text 9/22, haiku rerank of lexical top-30 14/22 (~8.5k chars), haiku over all titles 14/22 (~43k chars). Error 4-gram match on today's real errors: 429 credits → BLK-030 + BLK-031 exact, BLK-034 suite error exact, no false positive; 5 of 7 real errors of 2026-10-23 had NO entry (never captured): capture is the weak link, not search.
    • Storage choice: augment in place (5 files, headings and paths unchanged) + per-entry Meta line + generated Index. Rejected for now: one file per entry with frontmatter (better concurrency and per-entry history, but 44 citers + 8 project migrations; a commit-time validator + backfill give the same machine fields). Revisit if same-repo concurrent writes conflict.
    • 4a write side (shell, no mod). lib/memory.sh = single writer and reader, like gitflow.sh: add <kind> --title --apply --body-file [--status --scope --supersedes --critical] allocates next ID from headings (never the Index), appends the entry ending with - **Meta**: status=…; scope=project|global; triggers=path:…,cmd:…,skill:…,err:"…"; supersedes=…; critical=yes|no, regenerates ## Index from headings + Meta; status <ID> <new> appends a dated status line (append-only); journal "<line>" appends under today's heading; derive <ID> prints derived triggers (paths, commands, skill names, quoted errors normalized); index; check [--staged].
      • Validator: pre-commit (only when .claude/memory/ is staged; diff-based on added/changed entries, so legacy entries in the 8 projects pass) + make test: heading pattern, ID = max+1 and unique, Meta on new entries, Index == generated, no removed line from an existing entry outside a /prune-memory curation commit, English (accent-ratio threshold proven zero false positive on all 8 projects' registries). New BLK must quote ≥1 error verbatim.
      • Backfill via /prune-memory (deterministic script + user review): Meta for the 434 entries; status from the 3 legacy forms (last wins); triggers derived; Apply = LRN/BLK/EVAL lesson field, BDR = first sentence of Decision; scope proposed by the model, reviewed (global = applies in other projects too: Claude Code behaviour, permissions, mod API, CLI quirks). Coverage report is a criterion.
      • Citers: capitalize, close, prune-memory, CAPITALIZE steps of feat/bugfix/hotfix/ship-feature/commit-change, lib/capitalize-commit.md, lib/analyze-before-plan.md, lib/reconcile.sh (Meta status first, legacy fallback: fixes BLK-032..034 false-open), templates/memory, onboard/init-project; doctrine-citers census. CLAUDE.global.md Memory registries: write only via lib/memory.sh; fix the false "load every session" premise (keep caveman: it keeps reads and injections small).
    • 4b capture (mod). Failure ledger: every tool result with isError, deny or non-zero exit carrying a distinctive error line → normalized + verbatim + command, kept per session in $.store, matched against the registry error index; unmatched = new failure modes. Milestones observed: feat/fix commit, gitflow finish, a suite red then green. memory_pending tool (isDeferred: false) returns unmatched failures + milestones verbatim; /capitalize, /close and every CAPITALIZE step call it first; one context note at the next prompt after a milestone, never per turn, never at Stop. Judgment triggers (design choice, surprising discovery, dead end) stay with the model: "Proactive capitalization" paragraph KEPT. Writing always = model draft + user approval + lib/memory.sh (validated).
    • 4c read side (mod). Tier 1 always-on: ≤10 user-marked critical=yes lessons, one line each (~1k chars) in prompt.context. Session digest in prompt.context (open BLK from Meta status, actionable TODO, last journal line; re-read by the engine on compaction and /clear). Intent recall at prompt.submit only for model-router classifier labels design/analysis or the first coding prompt after idle: BM25 top-30 over title + Apply + triggers + body → haiku keeps ≤3 (option: same call as the classifier, no added latency), bounded 3 s, fail open. Execution recall: Read path triggers (lands before the edit), Bash command triggers (after the result; critical → deny once with the Apply line, retry allowed), tool error 4-gram match. Injection = ID + title + Apply only; superseded entries never injected (successor shown); linked IDs as one-line see-also; EVAL excluded from auto recall; budget ~1.5k chars per turn; once per context (ledger reset on compact/clear). Config-repo entries with scope=global indexed in every project (repo resolved from the ~/.claude/lib link). memory_search tool for skills (analyze-before-plan pass 1 calls it).
    • 4d feedback and promotion. Log each injection (ID, trigger kind, turn) and whether the turn cited the ID or the retried action succeeded; /prune-memory reads it: never-recalled entries, noisy entries (injected often, never used) get triggers fixed; entries recalled ≥N times → proposed promotion to a mechanism (guard, test, skill step), BDR-100 "mechanisms, not lessons".
    • Proof: validator zero false positive on the 8 projects; writer round-trip; backfill coverage; recall precision on ≥20 real prompts and ≥10 real errors (journal + transcripts), target ≥ the 14/22 baseline; digest canary after a compaction; haiku rerank latency inside the mod measured; /context delta; captured-failure demo: an error from session N recalled by match in session N+1.
    • Cleanup: hand-maintained Index steps in skills, "add one row to the Index" instructions, ad hoc append snippets, the false doctrine premise, reconcile legacy-only status parsing once backfill lands.
  • Phase 5, per-project and per-conversation profiles, native packs (redesigned 2026-10-25, facts + user answers)

    • Facts 2026-10-24/25 (scratch projects, fresh headless sessions, canaries, run concurrently, one shared ~/.claude): .claude/settings.local.json enabledPlugins per project works both ways and concurrently (ui-ux-pro-max off in A while on in B; pr-review-toolkit on in A only); claude --settings '<json>' gives two SIMULTANEOUS conversations in the SAME project different plugin sets; a skills-dir plugin (~/.claude/skills/<name> + .claude-plugin/plugin.json, like model-router) obeys both; plugin skills keep their short name (Skill tool ui-styling and typed /ui-styling resolve); plugin agents need the plugin: prefix (silent-failure-hunter → not found); permissions.deny Skill(x) does not hide a skill; a user-scope MCP cannot be switched off per project by settings (disabledMcpjsonServers and disabledMcpServers had no effect): project-specific MCP belongs in a pack plugin or at local scope; claude.ai connectors do not load under -p (untestable headless).
    • User answers 2026-10-25: profile can change per project and per conversation, never one profile for all conversations; tracked .claude/settings.json keeps deny/allow only, profiles go local; a project without a profile gets a detected proposal once, written on accept; the global mode (skills/ ↔ skills-disabled/ symlinks + user-scope plugin toggling) is DELETED; core = everything except the heavy packs (design, seo/geo, web-validate, scroll/3d, higgsfield, gstack); agents stay global (no packs, short names kept); a skill needing an off pack proposes to enable it then /reload-plugins (spike first; fallback: stop and name the pack); all 11 profiles kept, rewritten as pack compositions.
    • Packs: each heavy group becomes a skills-dir plugin skills/pack-<name>/ (.claude-plugin/plugin.json + skills/<skill>/SKILL.md, + .mcp.json for higgsfield, + hooks if a pack has any). Spike first: nested skills inside a skills-dir plugin load as plugin skills and not twice as user skills; gstack (external installer, symlinks) as a pack.
    • Profile = lib/profiles/<name>.profile → generated ~/.claude/profiles/<name>.json ({"enabledPlugins": {...}}). Per project: profile.sh set <name> writes enabledPlugins into the cwd project's .claude/settings.local.json (never user scope; gitignore line checked). Per conversation: launcher claude --settings ~/.claude/profiles/<name>.json (shell function or make helper, named with the user), wins over the project default for that conversation only.
    • Detection: session-start hook reads the fingerprint (stack, web public vs app, supabase, messaging, graph; from phase 3, or a minimal shell version here) when the project has no profile and proposes one in one line; writing it needs the user's yes.
    • Pack needed mid-skill: orchestrators' existing gates (lib/design-gate.md + design-tool-gate.sh, lib/plugin-gate.md) check the required packs; off → propose enabling for this conversation/project + /reload-plugins; spike that a settings change + /reload-plugins loads the pack mid-session.
    • Listing budget (user pick 2026-10-25: after the packs): measured 124 skills listed, 46 name-only at the default budget (incl. tour, seo, web-validate, status, profile, plugin-check, review, qa, spec, test-driven-development); SLASH_COMMAND_TOOL_CHAR_BUDGET=60000 → 0 name-only, listing 30k → 47k chars (~+5.7k tokens). Once packs shrink the listing, set the budget in settings.json env to the smallest value that leaves 0 name-only in the full profile (measured with the ctxprobe bench), and record the cost.
    • Spikes listed: nested skills in a pack, /reload-plugins after a settings change, claude.ai connectors per project (interactive session only), user-scope MCP moved into packs (higgsfield first).
    • Proof: two concurrent conversations in one project and two projects, canaries prove different listings, MCP and hooks per pack; /context per profile; old global toggling gone and nothing references skills-disabled/.
    • Cleanup: lib/profile.sh symlink toggling + skills-disabled/ (24 entries), user-scope plugin toggling in set|apply|reset, Makefile profile* targets rewired, /profile skill rewritten for packs, plugin-gate prose tied to global toggling, banner hint "/plugin-check before starting a new project", doctor profile checks, profile tests rewritten; lib/profiles/*.profile stay as the definitions.

Actionable

  • deferred (BDR-123): remap inline-writing best-tier skills (design Build stack, writing-skills, deprecation-and-migration, /tour single-project, /audit-delta 3d, /harden STEP 3); stale citers skills/feat/SKILL.md:6, skills/code-clean/SKILL.md:36; + impeccable row in routing.json (design Build stack has none; frontend-design has reflect; census test pins the table)

  • parked (GATE 2 LOW, 5a98c2c): probe table names not checked with IDENT.fullmatch per table (a / walks a path on the approved Supabase host); printable lets Unicode bidi/format controls (U+202E, U+2066…) through to the tty

  • profile name charset check (LOW, security gate): ^[A-Za-z0-9_-]+$ on the cached profile / <prof> argument before it becomes a path in read_profile() (lib/profile.sh:154-156) and install Step 11

  • P22 make new-skill scaffold: agent stub lacks effort: pin, skill stub lacks entry level, body loads .claude/agents/$(name).md instead of $HOME/.claude/agents/<name>.md → /hotfix; also: no routing.json row reminder

  • lib/tests/design-tool-gate.test.sh reds on any machine with the 21st CLI installed ("FAIL precondition: system-wide 21st present, CLI_ABSENT case not hermetic") — pre-existing on develop (fa67664), independent of the diff. Make the CLI_ABSENT case hermetic (PATH shim / stubbed probe) so make test is green on a design-profile machine. Until then full-suite oracles (make test exit 0) cannot be MET here.

  • post-run-D residuals (gates, 2026-10-07): settings.json soft_deny names only gitflow.autopush false → add "or an unparseable value" (restriction only, settings run); capitalize STEP 6: manual mode with ahead = 0 (user pushed by hand between merge and read) matches no closing line, and the 5C ahead = 0 bullet still says "(auto-push mode did it)"; release-executor:86 line > 80 cols; push-guard header line 4 > 80 cols (pre-existing); unpushed-guard Stop silence now also covers a missing lib (SessionStart names it) — accepted

  • gitflow LOW leftovers (run B, rest done in run D 472cccb): --end-of-options/-- on refname args and printf %q in copy-paste hints; gitflow_delete: check _gitflow_checkout_containing_base rc (lib/gitflow.sh:270) before --unset-upstream

  • docker host-root mount spellings uncovered by deny (security gate 2026-10-23, pre-existing): --volume /:/x, -v=/:/x, --mount type=bind,source=/,...; prove each with a harmless analogue (--settings one-rule file) before adding

  • 6 dead deny entries (Bash(docker run * -v /:*), Bash(git push * :*), 4 Write(...)) kept by the push-guard T41/T42 non-weakening lock; drop them with a justified-removal list in T42 at the next release (working forms added 2026-10-23)

Release 3.0.0

  • MIGRATION.md "Upgrading to 3.0.0" (CHANGELOG Unreleased says breaking: typed /effort-* removed; only the 2.0.0 section exists)
  • routing.json confirmed (15 agents, 11 phases, 3 skills) ships to every clone (by design: decisions travel); revisit at the 3.0.0 cut
  • CHANGELOG [2.0.0] "Linux make test still to be done after 2.0.0" is stale: suite green on Linux (bchanot-server, 2026-10); note it under Unreleased
  • BLK-018 decide at 3.0.0: release-executor finish span vs classifier (did not recur at 2.0.0, no fix applied)

Docs backlog (doc-sync 2026-10-06)

  • P17 README restructure to Standard-Readme (Install / Usage / Configuration / License); move inline reference parts to USAGE.md, CONFIGURE.md from settings.json + .env.example
  • P18 README Requirements line (Linux apt/dnf/pacman + macOS brew): Linux run done, write the line
  • P31 USAGE narrative: Exemple 9 "sans superpowers" (vendored, always on), "Edit tool" bypasses /hotfix, Pattern E + Exemple 9 route bugs to /ship-feature instead of /bugfix|/hotfix
  • P32 USAGE missing sections: design work (21st CLI, design stack, /site-motion), media generation (Higgsfield toggles), gitflow auto-push + global hooks
  • P33 USAGE token figures ("Budget Pro ~11k tokens/5h", per-pattern) have no source in code — verify or drop
  • P34 USAGE + agents/plugin-advisor.md "gstack ON/OFF", "context7 ON" vocabulary — gstack is per-profile, ctx7 is a CLI; move both together
  • P41 templates/settings/settings.json: permissions.ask entries (npx, docker rm, make deploy, psql…) inert under defaultMode auto → config fix, not doc

User decisions and hand edits

  • user decision: pin a commit for higgsfield-ai/skills and a version for @higgsfield/cli (security gate, 2 MEDIUM, accepted as is)
  • user hand edit pending: remove the four Bash(npm … -g|--global *) lines from permissions.deny (they override the classifier); then the first global install is the live test of the entry

Blocked

  • G2 hooks/guard-bash.sh (BLK-022, safety classifier withheld the body): PreToolUse Bash, exit 2 + reason, logger trace, fail-closed without jq; spec lib/tests/guard-bash.test.sh (214 cases) SKIPs until it exists
  • launch claude with TMPDIR=$HOME/.cache/claude-tmp in dtach_claude() (~/.bashrc), user side (BLK-021)

Model-router live checks (opportunistic, need a real session or incident)

  • LIVE CHECK after /reload-plugins: best-tier phase w/ Fable out of credits → /route show lists fable down (probe), main on opus, effort bumped.
  • LIVE CHECK: does parentModel follow the turn.step rewrite or the session model? Read general-purpose's step-0 message.model in a transcript during a demoted turn (if it is already the session model, the pin is a harmless no-op).
  • W1-C live verification part 2 (needs a real incident): StopFailure vs turn.complete order; PostModelSwitch auto semantics and its from_model after a router upgrade; whether a router rewrite raises auto; [1m] carry validity on opus (only on a session whose steps carry it)
  • W4-B AC9: type a few plain prompts, read route: classifier <phase> (verbose line with /route verbose on), drop bookkeeping if it misfires
  • W3-A: a parallel same-agent dispatch answered after > 10 s; what an unanswered dialog resolves to on the terminal (must be Later or nothing written). T1 skill-row dialogs seen live (f8665b2, d3635b6)
  • cold-read cap on the opus session: a coding prompt → spinner sonnet-5-5/medium; above 120k cold read the skip line once; /route show cap text

Optional backlog (user call)

  • router: /route set, /route confirm, (unconfirmed) in show, dialog edits of phases, frontmatter auto-alignment, session-start warning when routing.json is dirty, per-machine projects.; step heuristics, quota-aware downgrade, A/B
  • gates.sh could refuse a CHECK holding <<
  • per-skill positive/negative prompt ranking (Tier 2 second half), not started
  • frame floor-guard snippets as data in the verifier step (LOW)
  • graphify pilot on robin_petier: graph + .graphifyignore + gitignore graphify-out/ + GRAPHIFY_FORCE=1 graphify update . in the post-commit hook when a graph exists

Parked

  • Higgsfield parked (final review, rulings in BDR-109): remedy line ignores a pinned lock version (latent while latest); Step 8.6 spawns higgsfield version up to 3 times; rollback needs npm uninstall -g @higgsfield/cli + session removal + hand removal of skills-external/higgsfield-*
  • Higgsfield parked (per-task minors, none blocking): "rename" comment vs rm-then-mv; no -- before the clone URL; ssh URL can prompt; no sweep of a stale .higgsfield-stage.*; timeout path itself untested; "pack not installed" when only unlisted skills are synced; doctor version read unbounded
  • Reticle pilot recipe: section "2026-09-27" below (trigger: first app-type project, BDR-103)

Known limits (accepted, no action)

  • model-router spawn path unprobed: 1st gate of an outage window dies once (seen live 2026-10-23, retry lands on the opus floor); tour/onboard/audit-delta no retry; onAutoSwitch with main on opus marks nothing if the engine auto-falls a gate off Fable
  • Residuals (accepted): explicit Agent(model:"fable") pins (client-handover) still fail w/o credits (BDR-115 kept); spawn path not probed; session model itself out of credits → CLOSED 2026-10-16 c11cd3b (kept cur probed too); no cross-session persistence → ≤8 s stall per new session; timed-out probe keeps retrying in engine (no cancel); [1m] gating unverified (bare id probed); no Esc regression test (kit cannot abort signal); probe sleep eats ~8 of 10 s turn.step budget.
  • Residuals left (accepted): TTL known only after the first PostModelSwitch of the process (no API exposes the account TTL; 60 min default before); hooks-below context and a dropped prompt leave the estimate conservative/stale; onAutoSwitch targets main's lastPlan even for a sub-agent's auto fallback (pre-existing); agent_id: null on a main switch (if the engine ever sends null) would freeze sessionModel/TTL updates.
  • W1-C accepted-by-design (security 2026-10-09, MEDIUM, not coded around;): (1) the model itself can raise the main loop to fable for the rest of a turn through the route tool (plan/reflect/escalate/judge) or a background dispatch (derived orchestrate = best tier) — bounded by the turn and upgradeMaxTokens, no sticky route is model-callable; (2) CLOSED by feat C 786ee13 (keywords, ultrathink and derived orchestrate set effort only). Residuals: PostModelSwitch auto covers "other programmatic change" (a healthy model could be marked 15 min); strikes never decay inside a session; a [1m] variant's model_not_found marks the base model until reload; classifier deferred to W2. 2026-10-23 feat C 786ee13: (1) derived-orchestrate part and (2) keyword/ultrathink part CLOSED (effort-only routes); (1) route-tool lift stays by design (sanctioned path)
  • W3-B residuals: SKILL.md symlink follow (LOW, kept: skills/ itself is a symlink); descs cap and "(custom)" label untested. (security-auditor changed entry purged 2026-10-11.)
  • W4-B: W4-B residuals: smallModelBusy assumes the engine's small model is the haiku alias ($.model.classify takes no model: documented in code 2026-10-11, no fix possible); abort paths judged by reading only; the 3-s tests pin the upper bound only.
  • W3-A residuals (security LOW, accepted): non-atomic cross-process write (two sessions, crash mid-write → file reads as failed, previous config kept); host/path of a private remote in the tracked file; a persistent write failure re-asks every use (asked.delete in the catch); out.length vs byte size at the cap; changePatch scope 'project' with a vanished key writes Everywhere (cwd change mid-dialog).

History (2026-10-08 → 2026-10-19, done)

2026-10-19 — guardrails split: /a11y + injection/exposure (feature/a11y-split-inj-exp)

  • run — SDD 9/9, gates 0/1/2 green, opus review Importants fixed (c0fdbec, 9275e0d, 63a88bc), capitalize BDR-122 LRN-219..221 BLK-032; merge = user go
  • parked review Minors + GATE 2 residuals (probe supabase.url, redirects, _nonempty_rows, printable) → /bugfix 2026-10-21, 5a98c2c + 633faa2, BLK-033
  • routing policy /feat (user 2026-10-19, BLK-032): settings model → Opus 5.5; judge split (security-auditor + verifier → Fable, plan-challenger/analyzer/code review → opus); executors stay sonnet, "what to write" on opus; ceiling rule: main on Fable never writes code beyond a hotfix edit → dispatched executor; BDR superseding part of BDR-066 / BDR-115.
    • feat A audit phase: d3635b6 (dialog writes, session model opus), a7d747c (audit row, opus floor, census, citers), dae142b (docs); gates 0/1/2 green, LRN-224
    • feat B (feature/routing-ceiling-rule): ceiling rule CLAUDE.global.md, README doctrine, challenge citers, deploy effort: xhigh, routing.json changed cleared; ef13713 + 887cf89, gates 0/1/2 green, BDR-123; merge = user go
    • feat C: cap the default keyword prompt rules (plan|design|architecture, why|review|audit|analyze, ultrathink) at the session model, effort only like the classifier; close BLK-032 after — DONE 2026-10-23 feature/router-keyword-cap: 786ee13 effort-only routes (keywords, ultrathink, derived orchestrate), d2d590f docs, gates green, BLK-032 resolved; merge = user go
    • bugfix lib/tests/mods.test.sh (bugfix/mods-validate-advisory): verdict = --strict rc, positive control warnfix/cleanfix; 801992a, gates green, BLK-034 LRN-225; merge = user go. Residual: 3 historical contracts keep the old scrape oracle (BLK-034)

2026-10-18 — secure-by-default guardrails: 5 domains + /guardrails skill (feature/secure-by-default)

User ask: hosting, a11y, Supabase, SMS/email consent, cloud functions must be baseline on every project, API and access secured systematically, plus a skill that tests all of it. Language call: scanner is Python stdlib, not Rust (default-language contraindication: skill scripts here are interpreted, no build step, same as explain-diff checker).

  • T1 rules/secure-by-default.md always-on (no paths:, BDR-085 path: CLAUDE.global.md is at 320/320)
  • T2 skills/guardrails/scripts/ scanner: common, apis, hosting, a11y, supabase, messaging, functions + scan.py CLI (FAIL / WARN / MANUAL, exit 1 on FAIL)
  • T3 skills/guardrails/SKILL.md + references/checks.md (rule catalogue, manual items, live Supabase queries) + test-prompts.json
  • T4 lib/tests/guardrails-scan.test.sh: clean fixture passes, one mutant per FAIL rule
  • T5 wiring: security-auditor checklist (+ scanner run), interviewer failure-mode row, init-project founding table
  • T6 registration: profiles full/max/dev, routing.json row, README, USAGE x2, CHANGELOG
  • T7 make test all green (70 guardrails checks), shellcheck clean, 25/80/5/5 limits met; calibrated on 8 real projects (game, faunosteo, zenquality, robin_petier, alphalink, game-deploy, config, explanations), 9 false-positive classes fixed and locked by benign tests. Journal done. BDR-120 accepted, merged bee377a.
  • T8 passwords (user ask 2026-10-18): doctrine bullet in the rule (argon2id, no clear compare, no log, no literal, delegated auth), checks/passwords.py in the api domain (API-PASSWORD-PLAINTEXT / WEAK-HASH / LOGGED FAIL, LITERAL WARN), 8 mutants + 10 benign locks (89 checks), auditor maps PLAINTEXT to CRITICAL; calibrated on 7 projects: 0 hits after one FP fix (yaml volume mount htpasswd:/etc/...)
  • T9 live probe (user ask 2026-10-18, "attaque de l'exterieur ?"): skills/guardrails/scripts/probe.py read-only (GET/HEAD/OPTIONS, --authorized gate, env secrets, same-host redirect only, request budget, 25-req burst cap). 5 probes: anon-read, cross-user, no-auth route, cors-reflect, rate-limit. Suite lib/tests/guardrails-probe.test.sh 16/16 vs a localhost http.server fixture. SKILL STEP 5 + checks.md section + CHANGELOG/README/USAGE. Redirect-guard unit test blocked by the auto-mode classifier (SSRF-shaped fixture), guard is code-reviewed.
  • Fix loop (user ask 2026-10-18): audit -> fix proposals (Fable via route plan) -> user accepts -> fixes applied -> re-pass proves all fixed. Reuse /bugfix circuit: contract with scanner oracles, bugfixer executor, lib/verify-secure-loop.md gates.
  • T10 scan.py --assert-absent RULE:path,... (contract oracle: exit + marker reflect only the listed pairs, positive control = domain applies + files>0) and --baseline <json> (re-pass: fixed / remaining / new); tests incl. positive control
  • T11 SKILL.md: model gate, STEP propose (grouped per rule+path, visible choices named, MANUAL = user steps), STEP approve (prose gate), STEP fix (gitflow aiguillage, contract + oracles, bugfixer, verify-secure-loop), STEP re-pass (baseline diff + probe re-run on go, max 2 rounds), commit gate
  • T12 citers: verify-secure-loop header, contract-interview flow list, bugfixer description, model-routing census adds guardrails
  • T13 docs: checks.md oracle section, CHANGELOG, README, USAGE, test-prompts
  • T14 make test green (scan suite 106: check modes + gates.sh UNMET->MET), oracle calibrated read-only on game: real hit -> PRESENT rc1, self-baseline -> NO-NEW rc0

2026-10-17 — /explain-diff skill: HTML explanation of a diff (feature/explain-diff)

Source: geoffreylitt gist explain-diff-html (Notion variant dropped). Built through the skill-creator loop (draft, evals with/without skill, user review).

  • T1 skills/explain-diff/SKILL.md (target resolution, understand, 4 sections, style, save outside repo, check, hand-over) + test-prompts.json
  • T2 assets/template.html (self-contained skeleton: light/dark tokens, TOC, diagram primitives, diff + quiz JS) + references/components.md
  • T3 scripts/check_explanation.py (deterministic floor: name, location, sections, TOC, 5-question quiz, code escaping, no ASCII art, no em-dash, self-contained) + lib/tests/explain-diff-check.test.sh (17 checks: valid page, raw template, one mutant per check)
  • T4 registration: full/max/dev profiles, routing.json row reflect, README + USAGE x2 + CHANGELOG
  • T5 skill-creator iteration 1 (runs on opus: Fable out of credits): 3 evals x (with skill, baseline), graded, pass rate 100% vs 45%; fixes faedb98 (arrow/edge class collision, bundled fill_template.py). Static viewer in session scratchpad. + iteration 2
  • T6 make test all green, shellcheck clean, impeccable detect [] on the template, contrast >= 5.8:1 both themes; commits b353fac faedb98.

2026-10-16 — impeccable = Build path for all UI (chore/impeccable-build-path)

User validated: frontend-design overlaps impeccable 4.6; gate still blocked on frontend-design. Supersedes the 2026-07-05 "complementary, keep both" call.

  • CLAUDE.global.md Build line: impeccable leads, frontend-design = light path only, rule count 45 -> 61
  • design.profile GATE-BLOCK: frontend-design out, impeccable in (frontend-design stays installed, profile-listed)
  • lib/design-gate.md: core-set prose + section 5 (impeccable now blocking, so only the PRODUCT.md check remains)
  • agents/plugin-advisor.md: frontend/design-system rows, package rows, two RULE blocks
  • 45 -> 61 detector rules: README, plugins.lock.json note, install-plugins.sh comment + echo
  • BDR-119 + CHANGELOG Unreleased + journal
  • make test: 1 red suite = known design-tool-gate precondition (21st CLI installed, see 2026-10-06 entry), shellcheck clean, impeccable resolves under skills/

2026-10-15 — short commit messages (feature/short-commit-messages)

  • lib/commit-message.md: lookup of a documented convention (README, CONTRIBUTING, CLAUDE.md, .claude/ rules, commitlint, template), else 50 words max, medium technical level. Git log is not a convention.
  • Citers patched: commit-changer, bugfix STEP 6, feat STEP 5, hotfix STEP 4, client-handover-writer, CLAUDE.global.md (1 line, 320-line budget).

2026-10-15 — model-router: probe a move target before routing main to it (bugfix/router-probe-before-route)

Contract .claude/tasks/contracts/2026-10-14-router-probe-before-route-0005.md, plan r3 .claude/tasks/plans/2026-10-14-router-probe-before-route-0005.md.

  • /bugfix run: Fable out of credits routed (BLK-030, LRN-218); r1 → r3; 497 tests, verifier CONFORME 11/11, security PASS; commit 2cccc43 + docs.

2026-10-13 — model-router: cold-read cap, switch on by default, classifier routes down (feature/router-downgrade-cap)

Contract .claude/tasks/contracts/2026-10-13-router-downgrade-cap-0013.md, plan r3 .claude/tasks/plans/2026-10-13-router-downgrade-cap-0013.md.

  • /feat run: 3 lenses (10 MAJOR) → r2; confirmation pass FATAL(7) (BLOCKER: served record only on routed steps) → r3; feater DONE (19 tests + 3 extra, 450 pass), GATE 0 MET 4/4, verifier CONFORME 10/10 first pass, security PASS. Commit 2ce203a.
  • Residuals (1)-(3) closed 2026-10-13, commit 1be57a3 (contract .claude/tasks/contracts/2026-10-13-router-cap-residuals-1902.md, plan r3): session pin for built-in general-purpose spawned by main below the session model; prompt-size estimate (text + context + typed skill body, code points / 3) added to the cap's size at the first main step unless usage grew by half; document attachment = unknown = blocked; engine cache_ttl ('5m'|'1h') adopted from main's PostModelSwitch. 3 lenses (2 BLOCKER same finding: frontmatter model invisible to the hook) → r2; confirmation CONCERNS(3) → r3; feater DONE 472 tests; verifier CONFORME 7/7; security PASS. Residual (4) "model unknown to the table" not reproduced since (later route answers named claude-fable-5-1): closed as transient.

2026-10-12 — code-clean whole repo (chore/code-clean)

  • audit r1→r3 (3 lenses + confirmation), user approved all 14 non-deferred items, code-cleaner DONE, make test 47 green — plan .claude/tasks/plans/2026-10-12-code-clean-0103.md, scope .claude/audits/CODE-CLEAN-SCOPE.md
  • fix BUGS-FOUND: toggle-external.sh usage() prints header 3-26, list ends at 32
  • C4/C5 deferred dedupes via /refactor (tool_kind/tool_source + shared gstack_* in lib/gstack-removed.sh; 496-run golden identical) (tool list ×4, profile/toggle-external twins)
  • deferred: C1 gitflow-test.sh move (blocked: T19 drift lock), B13-B17 (no change by design)

2026-10-08 — model-router mod: one mod routes model + effort per request (feature/model-router-mod)

Plan .claude/tasks/plans/2026-10-08-model-router-mod.md. Decisions 2026-10-08: main-loop model switch spike-first then flag off; load via CLAUDE_CODE_PLUGIN_DIRS + link.sh; migration of shifters/pins/model-gate in wave 2 after proof; names model-router / route / /route.

  • W0 spike in dev-mods (hot reload): facts a-d established 2026-10-08 (plan file § Spike facts); e moved to W1.10
  • W1-A the mod in mods/model-router/ (b721c94, contract 2026-10-08-model-router-w1a-1533, plan r3): challenge 3 lenses + 1 confirmation (2 BLOCKER + 10 MAJOR closed by named changes), feater DONE first pass, GATE 0 MET 5/5, verifier CONFORME 6/6, security PASS (4 MEDIUM + 5 LOW reported, below)
  • W1-A hardening (user go "oui durcis", contract criteria 7-11): /route composer-only; no agent model axis (effort only after spawn); pattern ≤ 200 / scan ≤ 4096 / phase keys ^[a-z][a-z0-9_-]{0,31}$ / config ≤ 64 KB / additionalProperties: false / typeof e.skill; warnOnce in all 14 catches + config-drop logs; safely around post-next bookkeeping. feater DONE, gap round (dead Loop.frozen, spawn returns started verbatim, tool description), GATE 0 MET 9/9, verifier CONFORME 11/11, security PASS.
  • W1-A residuals CLOSED 2026-10-11 (bugfix/model-router-residuals): nested-quantifier patterns rejected (NESTED_QUANT); stat.kind !== 'file' → layer failed; rejected keys masked in logs (keyWord), alias keys KEY_NAME; route-tool catch text says the route may be partly applied. Left (accepted): agentId read from the flat tool event; closures without a kit test.
  • W1-B1 floor precedence (contract 2026-10-08-model-router-floor-1835, 2026-10-09): ultrathink + typed /effort-<l> = the main turn's default AND minimum (r2 after 3 lenses: a pure floor made /effort-low a no-op); one helper mainEffort; per-axis precedence; mid-turn prompt floors now + next turn; "enabled": false per machine, kept across /clear and failed reload; typed slash attested. 30 tests; verifier CONFORME 6/6 (after 1 gap round); security PASS ×2
  • W1-B1 residuals CLOSED 2026-10-11: broken override at first load → router off (fail closed, logged); non-boolean enabled → off; /route reload answers config unreadable; previous config kept; errWord (name + code only) replaces every String(err) log. Superseded by W2-B: skill.prompt preload guard, /effort-* marker (bridge removed). Left (accepted): transient missing override lifts a config-set off (ENOENT must mean defaults on most machines); /route show display items (no defect named).
  • W1-B2 wiring (contract 2026-10-08-model-router-wiring-1835, 2026-10-09): tracked symlink skills/model-router → ../mods/model-router loads as model-router@skills-dir (fresh-process claude plugin list --json proves it), .gitignore mods/*/tsconfig.json, lib/tests/mods.test.sh (4 checks, capability probe, bounded, SKIP), doctor ── Mods ── fail-soft, CLAUDE.md ## mods/. Plan r2 from 3 lenses (5 MAJOR), feater DONE, gap round (4b label + unbounded probe), verifier CONFORME 8/8, security PASS
  • W1-B2 residuals CLOSED 2026-10-11: mods suite probe greps the claude plugin test usage line; doctor plugin list --json under timeout 60; update-all skips @skills-dir mods. Left (accepted): doctor echo -e helpers (tracked names only); fallback timeout guard orphans grandchildren without coreutils timeout.
  • W1 close-out (2026-10-09): doc-sync opus audit SIGNIFICANT → user go all 10 → patched (README effort routing + Explore row + /route, USAGE, ARCHITECTURE mods/, CHANGELOG Unreleased) b22f894; hot-reload link removed from ~/.claude/dev-mods/<session>/; BDR-115 amended (a6e2003). Pending user: /reload-plugins in this session (new sessions load the skills-dir copy by themselves); merge decision on feature/model-router-mod (gitflow finish, human signal)
  • W1-C adaptive tiers (user 2026-10-09, contract 2026-10-09-model-router-tiers-1237, plan r4 after 3 lenses + 2 confirmations: 6 BLOCKER + 29 MAJOR closed by named changes): phases name absolute tiers (best fable>opus>sonnet · big opus>fable>sonnet · work sonnet>opus · cheap haiku>sonnet); breaker fed by classic.StopFailure kinds rate_limit|overloaded|billing_error|model_not_found + PostModelSwitch auto (episode backoff 15→300 min, /model clears, /clear keeps, /route reload clears); fallback chain fable→opus→sonnet→haiku; main UPGRADE by default under upgradeMaxTokens 200k (fails closed on unknown usage), DOWNGRADE gated by mainModelSwitch; sticky turnModel per turn; derived orchestrate on background dispatches; prompt default rules (plan/reflect FR+EN, Unicode guards, skipped on /…, floor match, mid-turn). 58 tests; verifier CONFORME then 3 gap/hardening rounds; security PASS
  • W1-C live verification part 1 (2026-10-09 after /reload-plugins, skills-dir copy loaded, 12 hooks): derived orchestrate on a real background Explore (main high → medium while it ran → high after its end); Explore on sonnet/medium; route plan → next request xhigh (engine record); Skill(effort-low) bridged → next request low (engine record); /route show resolves all 10 phases to full ids, down: none; steps arrive as bare claude-fable-5-1 (no [1m]) so the suffix carry never fires on this session
  • W2-A mod (2026-10-09, bb56f3e on feature/model-router-w2, contract 2026-10-09-model-router-w2a-1546, plan r4 2026-10-09-model-router-w2-1546): user decisions — effort-* skills deleted (W2-B), pins REWORKED not deleted (rows = phases by role; frontmatter model:/effort: kept as census-locked off-state floor after a robustness BLOCKER), orchestrators declare phases, slim model gate. Phases write work/high + apply work/low; 56 skill rows, 21 agent rows; agents' model at spawn within tier, upward only, project-defined agents skipped (agent.offer); typed slash → name-bound marker (composer|sdk|bridge) + pending slot + idle fallback; best-tier rows in a runMain slot surviving turn end; unrowed skill leaves the route; route answer always names the id; null override rows. 3 lenses + 2 confirmations (1 BLOCKER each round closed), feater + 4 gap rounds, GATE 0 MET, verifier 3× ECARTS on coverage clauses only → user accepted at the cap, security PASS (2 MEDIUM pre-existing: first-load kill switch fails open, ReDoS size-bounded). Kit 58 → 88 tests. Doc-sync skipped for A (mod-only, docs at B).
  • W2 gate A→B (2026-10-10, engine records): typed /status → main low then medium during the dispatch; analyzer opus/xhigh from step 0 (frontmatter high) = spawn bookkeeping first, row beats frontmatter; status-reporter haiku step 0. Probe 3 dropped (gate always calls route). Probe 4 (typed skill while a background agent is live: marker vs fallback) NOT observed → limit in lib/effort-shift.md; re-check in the records whenever the user types a skill with an agent alive.
  • W2-B repo migration (2026-10-10, 1f2d33b, contract 2026-10-10-model-router-w2b-1045): 15 citers → mcp__model-router__route per phase, effort= on built-in judgment dispatches + SDD sonnet implementers (effort="medium"), lib/effort-shift.md + lib/model-gate.md rewritten (witness = route answer, /route on), deletions (effort-, effort-pins., model-check.sh, tests, installer blocks), bridge removed from the mod, census rewritten (140 checks, drift lock rows ↔ frontmatter), analyzer xhigh, CLAUDE.global.md Design-work line. Verifier ECARTS(7) → CONFORME 10/10, security PASS, full make test green (design-tool-gate env red). Docs P1-P8 user-approved; SemVer: breaking → next release 3.0.0 (MIGRATION section at release).
  • W2-A residuals CLOSED 2026-10-11 (first load fail closed, nested quantifiers, errWord, alias keys, offers capped at 256, __proto__/constructor keys tested). Known limits (unchanged): skillCalls/spawning counters are global; offers keyed by name only; builtin /effort is not a lever inside a run.

2026-10-10 — model-router wave 3-A: first-use route confirmation + decision memory (feature/model-router-confirm)

Plan .claude/tasks/plans/2026-10-10-model-router-w3a-confirm-1201.md r4, contract 2026-10-10-model-router-w3a-confirm-1201. User decisions 2026-10-10: tracked routing.json reached through the plugin dir (no new link); blocking $.ui.ask dialog at first use; per skill row, agent row, main phase.

  • W3-A landed (22455c0, 2026-10-11): routing.json = phases + rows + decisions; T1/T2/T3 dialogs; project exceptions projects[<normalized remote>] in the tracked file (project-tree layer dropped: security); writers = dialog + /route ask; /route pending; census from the file with the changed WARN exemption; kit 86 → 190. Gates: 3 lenses + 1 confirmation (BLOCKER census), feater + 4 rounds, verifier CONFORME + re-verify, security BLOCK(1) credential leak fixed → PASS, full make test green (design-tool-gate env red). Live: T2 dialogs answered by the user (verifier Keep, feater Keep, security-auditor → implement then reset to verify on user go).
  • W3-B dialog with context (2026-10-11, 604a6c4, contract 2026-10-11-model-router-w3b-dialog-1240, plan r3): descriptions (skill frontmatter / agent.offer / phase about), real id + effort in the question, Later / Keep / Change, model → effort (derived from the phases of that model) → scope, rows stay phases, T3 Later/Keep. 3 lenses (2 BLOCKERs on my r1 avoided) + 1 confirmation, feater + 2 rounds, verifier CONFORME (3rd), security PASS (4 LOW: symlinked SKILL.md read, TOCTOU, raw key in a log, any plugin hooking AskUserQuestion could answer). Live decisions: security-auditor → judge (kept, floor aligned model: opus), plan-challenger → verify (reset on user go), orchestrate Keep (T3 live check done).
  • "auto mode: use Bash/sed" block attributed to the mod: traced 2026-10-11 by reading, it is the harness's own auto-mode instruction rendered after the mod's MCP block; not in the mod source. Closed.
  • W3-C /route forget (2026-10-11, cd8d72f, contract 2026-10-11-model-router-w3c-forget-1457, plan r3): name/all/projects, guarded restore, confirmation dialog for all/projects, no-write paths, docs. 3 lenses + 1 confirmation, feater + 3 rounds (1 real defect: ForgetPlan typo), verifier at the cap on coverage (user accepted), security PASS. Kit 232 → 284. Live: orchestrate + escalate T3 Keeps seen.
  • W3-C residuals closed in W4-A (68d7ea6). Live smoke of /route forget from the terminal still unseen.
  • W4-A transition logs + residuals (2026-10-11, 68d7ea6, contract 2026-10-11-model-router-w4a-logs-residuals-1637, plan r3): verbose = transitions only (main line, hand-off per dispatch, agent moves, answered-by anomaly), stream lines removed, host prefix respected; residuals of W3-A/B/C closed (a)-(g). 3 lenses (BLOCKER: agent moves decided at spawn) + 1 confirmation, feater + 4 rounds, verifier at the cap on coverage (user accepted), security PASS + 2 MEDIUM fixed. Kit 284 → 358.
  • W4-A residuals CLOSED 2026-10-11: errWord; logCall → tryLog, noteMain refresh under safely.
  • push-guard argv check (2026-10-11, bugfix/push-guard-argv): the text match is now a prefilter; the command is split into simple commands (awk tokenizer: quotes, escapes, separators, heredoc bodies) and a push must be git's own subcommand (push/send-pack; subtree, wrappers, assignments, no-awk keep the text verdict). grep/heredoc/git log -S/git stash push over-blocks closed; "git" push miss closed. Suite 98 → 124 checks.
  • W4-B classifier (2026-10-11, e54a2b5, contract 2026-10-11-model-router-w4b-classifier-1858, plan r3): $.model.classify on plain composer prompts with no route in force → turn effort only (design→plan, analysis→reflect, coding→implement, bookkeeping→apply, chat→nothing), 3-s race, abort not counted, 3 failures pause cooldownMinutes, no dialog, no file write, classify config key, /route classify on|off, status + verbose line. 3 lenses (BLOCKER: unbounded await) + 1 confirmation, feater + 1 round, verifier CONFORME (2nd), security PASS. Kit 358 → 428. Deviation from the TODO line: no first-use confirmation on classified phases (noise per prompt; T3 already confirms the phase).

2026-09-30 — Higgsfield pack: CLI + skills in the install process, off by default (feature/higgsfield-pack)

Contract .claude/tasks/contracts/2026-09-30-higgsfield-pack-1412.md, spec + plan under docs/superpowers/ (transient). Approved 2026-09-30: toggle pack off by default, two toggles, routing lines, complete scope, TTY fix on ctx7 + 21st (option A), deny aliases.

  • /ship-feature run: 9 plan tasks, fix wave after the final review, doc sync, registries (BDR-109)
  • user decision: close the remaining npm global-install spellings in settings.json deny (npm i <pkg> -g, npm add -g, npm -g i) — pattern grammar for a mid-string wildcard unverified (BLK-025) — CLOSED 2026-10-06 (reconcile, user go: soft_deny settings.json:472 names npm add -g + flag-after-package)
  • feature/higgsfield-pack merged into develop 2026-09-30 (df6dbce, user go)
  • soft_deny "Global npm installs" entry merged 2026-09-30 (chore/npm-global-soft-deny)
  • (was) user decision pending: npm global installs from deny to a prompt tier — ask does not prompt under defaultMode: auto (BDR-090); option = one autoMode.soft_deny entry (vet the package first), deny lines removed by the user by hand — DONE 2026-09-30 (soft_deny "Global npm installs", 95168c1; reconcile 2026-10-06)

2026-09-27 — case 4 of the 6-repo review: reticle parked with a pilot recipe (chore/six-repo-review-notes)

User go "parquer avec la recette". Real gap (runtime store state, structured verdicts with file:line, replayable flows, CI gate --since), no current project needs it; cost = per-project build instrumentation in the client repo, ~4.9k tokens of MCP schemas per session, PostHog telemetry on by default, a skill that auto-runs init against "ask, don't guess". Trigger: first app-type project (client state, forms, auth, cart).

  • P1 external opt-in in lib/toggle-external.sh + profiles (off by default, qa-class); @reticlehq/server pinned in plugins.lock.json (plugin v3.3.0 seen 2026-09-27), never @latest.
  • P2 local wrapper skill replacing theirs: npx @reticlehq/server init --dry-run shown to the user, never run by the agent (runbook doctrine); MCP env DO_NOT_TRACK=1 RETICLE_TELEMETRY=0; verify only after the user ran init.
  • P3 pilot on staging only (secret redaction is name-based); flows committed, evidence gitignored; gate --since in CI evaluated before adoption.
  • P4 measure tokens per verification loop vs gstack browse on one page. Sources read 2026-09-27: docs/what-is-recorded.md, telemetry.md, token-efficiency.md, enterprise.md (core verification free; SSO/SCIM/RBAC/ policy gates under ee/), LICENSE split FSL-1.1-ALv2 server+init, Apache adapters/core/engine. Stars 898, created 2026-06-11, 2 551 commits.