kodelyth-ecc 2.24.11 → 2.29.0

package/CHANGELOG.md

@@ -2,6 +2,214 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v2.29.0 — Publish fix: ajv was an undeclared dependency (November 2026)
+
+**What happened:** v2.26.0, v2.27.0, and v2.28.0 were tagged and released on GitHub,
+but their npm publishes all **failed** — so npm stayed at v2.25.0. The pre-publish
+test step crashed with `Cannot find module 'ajv'`: `scripts/lib/state-store/
+schema.js` required `ajv` at module load, but `ajv` was never a declared
+dependency. It was present on the maintainer's machine (transitively) so local
+tests passed, and absent in CI's clean install so the publish test failed. The
+new `state-store` test (added in v2.26.0) imports state-store at the top level,
+which is what surfaced it — the same undeclared-dependency bug class as sql.js.
+
+**The fix:** `ajv` is now loaded lazily inside `getAjv()` (not at import), with a
+clean `ECC_AJV_UNAVAILABLE` error if absent, and it is declared as an **optional**
+dependency alongside `sql.js` so it travels with the SQLite state-store it
+validates. Importing state-store no longer requires ajv; the module degrades the
+same way it does without sql.js.
+
+**This release rolls up everything from v2.26.0–v2.28.0** (Memory Core, Platform
+reach, Super Agent) — all of which is already on `main` — and is the first of
+them to actually reach npm. Because npm versions and GitHub tags are immutable,
+those three versions could not be re-published under their own numbers; v2.29.0
+carries their code to npm.
+
+## v2.28.0 — Super Agent (beta): the autonomous orchestrator (November 2026)
+
+The driver the memory/orchestration audit found missing. ECC had the primitives —
+the `blueprint` DAG decomposer, the tmux+worktree swarm, the GAN evaluation loop,
+the Arena state machine — but nothing chained them, the swarm never merged its
+worker branches, and no run could resume. This adds the chain.
+
+**An Arena-style deterministic state machine.** `scripts/super-agent/`:
+
+- `dag.js` — the plan as a dependency graph: which steps are runnable now, is it
+  complete, is it stalled, is it a valid DAG (cycle/dep/self-dep checks).
+- `state.js` — resumable runs persisted after every step, plus the **budget
+  governor** (`--token-cap` / `--step-cap`) that bounds a whole run, not just one
+  session.
+- `orchestrator.js` — a **pure** `nextAction(run)` that decides the next move, and
+  `submit*` recorders that advance the phase. Because the decision function is
+  pure, the entire control plane is tested (20 tests) **without spawning an
+  agent**: decompose → dispatch (in dependency order, parallel where independent)
+  → integrate → verify → done.
+- `integrate.js` — the missing branch-merge piece: `mergeOrder` (dependency-first)
+  and `detectConflicts` via `git merge-tree --write-tree`, which finds conflicts
+  with **no working-tree side effects**.
+- `cli.js` + `kodelythecc super-agent …` — the drivable surface (start / next /
+  plan / step / integrate / verify / status / list / resume).
+
+**It cannot lie about its own state.** A step that didn't succeed is recorded
+`failed`, and a failed dependency stalls the run instead of building on it.
+Integration conflicts stop for a human. `verify --passed` requires real green
+tests. The budget cap halts the run rather than being worked around.
+
+**How it runs.** The state machine is tokenless; the driving LLM performs each
+action it names (blueprint to decompose, the swarm to dispatch, the GAN loop to
+evaluate, git to integrate) and reports back. New `super-agent` agent +
+`/super-agent` command + routing teach it the loop.
+
+*Beta:* the control plane, CLI, and branch integration are tested and working; the
+LLM-driven execution of each action is delegated (exercised by the agent persona,
+not CI). This is the 71st agent / 104th command — a count sweep across the
+hardcoded docs and brand assets is a tracked follow-up; the catalog and site
+derive their counts automatically.
+
+## v2.27.0 — Platform reach: Codex + Kiro get MCP & memory; Kiro is the 12th platform (November 2026)
+
+MCP — and therefore the whole tool surface plus **memory** — now auto-wires for
+**six** IDEs out of the box. Two releases ago it was Claude Code only.
+
+**Codex CLI gets MCP (TOML).** Codex stores MCP servers in `~/.codex/config.toml`,
+not JSON. A minimal, non-clobbering writer adds the `[mcp_servers."kodelyth-ecc"]`
+table only when it is absent and otherwise leaves the file exactly as it is
+(appending a table is order-independent in TOML, so other servers and settings
+survive). Wired into the Codex post-install.
+
+**Kiro is a first-class target now — the 12th platform.** `kodelythecc --target
+kiro` installs the rules as always-on **steering** docs (`.kiro/steering/`) and
+wires ECC's MCP server into `.kiro/settings/mcp.json`. Kiro is MCP-native, so the
+full catalog — 70 agents, 196 skills, memory — arrives over MCP on demand rather
+than as a 266-file dump into steering. Added to `install.sh`, `install.ps1`, and
+the interactive menu.
+
+**MCP auto-wiring now covers:** Claude Code, Cursor, Windsurf, Gemini CLI, Codex,
+and Kiro. The merge is the same hardened one that protects `~/.claude.json` —
+absent files created, present files merged without clobbering, unparseable files
+refused.
+
+**Honest limits (not papered over):** RTK upstream has no agent for Kiro or
+Aider, so those don't get RTK filtering (and ECC doesn't pretend they do).
+Cline / Roo Code MCP stays manual — their settings live in VS Code globalStorage
+at an editor-version-specific path ECC won't guess. The `terse enable` secondary
+flow still has project-vs-home path quirks for some IDEs (the main install copies
+Terse correctly); tracked as a follow-up.
+
+## v2.26.0 — Memory Core, first cut: identity, redaction, fused recall (November 2026)
+
+The first cut of the Memory Core track. It fixes the memory data model's biggest
+correctness and safety gaps on the existing store, without the risk of a full
+substrate swap. Everything ships with tests (51 test files, all passing).
+
+**Memory stops orphaning on clone/move.** The store keyed each project by
+`sha256(absolute path)`, so moving, cloning, or renaming a repo changed its path
+and filed all future memories under a new id — hiding everything captured before.
+Memory now keys by the **normalized git remote** (git-remote-first, path
+fallback), which is stable where the path is not. `git@github.com:o/r.git`,
+`https://github.com/o/r`, and `ssh://…/o/r` all resolve to one id. Backward
+compatible by **read-both**: recall also matches the legacy path id, so nothing
+captured under the old scheme is lost. New `scripts/memory/project-id.js`.
+
+**Secrets never reach the memory log.** A captured memory is stored, recalled,
+and injected into future sessions — so a leaked key in a `problem`/`approach`
+would persist and re-surface. Capture now runs a shared credential redactor
+(`scripts/lib/redact.js`) over everything it stores: AWS, GitHub, OpenAI/
+Anthropic, Stripe, Slack, Google, npm tokens, JWTs, and PEM private-key blocks,
+plus `--token=`/`Authorization:`/`password=`/`api_key=` forms. Every pattern is
+linear (no ReDoS). The bash-command logger now shares the same redactor, which
+also widened its coverage.
+
+**Recall ranks by more than keywords.** BM25 still decides relevance, but among
+similarly-relevant memories a **recent, proven** one now outranks an old or
+failed one (relevance × recency × outcome). A memory whose approach didn't stick
+(`resolved:false`) sinks; a confirmed one rises. Relevance still dominates — a
+much more relevant memory is never buried by a newer one.
+
+**`state.db` actually works now.** The optional SQLite layer (session store,
+status DB, skill-evolution tracker) required `sql.js` at module load, but it was
+never a declared dependency — so importing it threw "Cannot find module 'sql.js'"
+on every install, before any caller's try/catch could run. `sql.js` is now a real
+**optional** dependency, loaded lazily; a missing module becomes a clean, coded
+error (`ECC_SQLITE_UNAVAILABLE`) that callers degrade on, and `isSqliteAvailable()`
+is a non-throwing probe for `doctor`. The core (memory, RTK, Terse, graph) never
+needed it and still doesn't.
+
+**Opt-in on-device semantic recall.** An optional semantic tier, **off by
+default**, that keeps the promise: the default session stays pure BM25, zero
+dependency, zero network. Turn it on with `KODELYTH_MEMORY_EMBEDDINGS=on` and the
+optional `@xenova/transformers` dependency, and recall blends BM25 with local,
+on-device embedding similarity (hybrid rank fusion); embeddings live in a sidecar,
+so `memories.jsonl` and its index are byte-for-byte unchanged. With it off — or
+the dependency absent, or any failure — recall is exactly BM25. Inference runs
+locally; only the first-ever model load touches the network. Pluggable provider
+interface, so the fusion/gating logic is fully tested with a stub and the heavy
+dependency is never required.
+
+**Auto-capture that respects consent.** The Stop hook already auto-extracted
+memory candidates from each finished session into a review queue — but nothing
+could read or promote them, so the queue was a dead end (the `/memory
+review-pending` it pointed at did not exist). Now `kodelythecc memory
+list-pending` shows what a session proposed, `promote-pending <id|all>` stores the
+ones you confirm (capture redacts them on the way in), and `discard-pending`
+drops the rest. Candidates are collected automatically; storing them is one
+explicit command, so nothing enters the recall store silently — the memory
+protocol's "never capture without confirmation" holds. The next session surfaces
+the pending count so proposals are not forgotten.
+
+**On the substrate:** the full 5-store merge is moot by design — the core stays
+pure-JS/JSONL and SQLite is an optional add-on, not the substrate.
+
+## v2.25.0 — Foundations: honest numbers, a memory that learns, MCP beyond Claude (November 2026)
+
+The first cut of the v3.0 "Foundations" track. Almost no new surface area — this
+release makes existing systems tell the truth and wires up machinery that was
+built but never connected. Every change ships with tests (48 test files, all
+passing).
+
+**Truth-in-measurement.** Three claims did not match the code, and an enterprise
+audit would catch all three:
+
+- The Terse runtime ledger claimed "every terse-active turn is recorded" — but
+  nothing wrote it, and its per-turn savings were modeled from a fixed multiplier,
+  not measured. Rows are now flagged `estimated: true`, the docs say plainly the
+  figure is an estimate (the Terse *file* compressor stays a real measurement),
+  and the unshipped statusline badge claim is gone.
+- The RTK "5,107,394 tokens / 64.1% — all real" headline was hand-authored copy,
+  not a computed number. It is now labelled an example snapshot that points at
+  `rtk gain` for your own live figures. RTK's `gain` measurement was, and stays,
+  real.
+- The codebase-graph binary's `--version` is unreliable — builds report an old
+  number while exposing much newer tools. ECC no longer trusts it: it detects
+  what the binary can actually do and flags the inconsistency instead of showing
+  a number as fact.
+
+**The memory that learns, now actually learns.** The structured instinct engine
+recorded every correction with confidence, decay, and outcome scoring — and
+nothing ever read it, so none of it influenced a session. Session start now
+injects the high-confidence, non-stale instincts for the current project. The
+dormant loop is closed.
+
+**RTK won't wire the wrong binary.** `reachingforthejack/rtk` (Rust Type Kit)
+ships a binary also called `rtk`; ECC used to treat any `rtk` on PATH as Rust
+Token Killer and would patch hooks into the wrong tool. It now verifies the
+signature (`rtk gain`) before wiring or measuring anything.
+
+**MCP — and therefore memory — reaches beyond Claude Code.** ECC auto-registered
+its MCP server for Claude only, so the whole tool surface, memory included, was
+effectively Claude-exclusive. It now also writes the MCP config for Cursor,
+Windsurf, and Gemini CLI (the IDEs that use the same JSON config shape), reusing
+the hardened merge that never clobbers your other servers. Codex (TOML) and
+Cline/Roo (editor storage) are the next step.
+
+**Fixes found along the way.** `statusAll()` in the MCP registrar called a
+function that no longer existed (`readJson`), so `kodelythecc doctor` and the
+`mcp` status command both threw "readJson is not defined". Fixed.
+
+**Routing.** The intent router learned the newer codebase-graph capabilities:
+smart test selection (`detect_changes scope:tests`), hot-path/complexity queries,
+code-to-docs links, and ADRs.
+
 ## v2.24.11 — every docs page gets its own diagram (October 2026)
 
 Documentation and site only. No code change.

package/CLAUDE.md

@@ -12,7 +12,7 @@ Guidance for Claude Code when working with this repository.
 - **44 hook entries** across 8 events — quality gates, memory inject + capture, correction encoding, prompt-injection guard, token-budget enforcer
 - **15 rules** — always-on coding standards + semantic intent routing + memory protocol + self-improvement
 
-Works with Claude Code, Windsurf, Cursor, Codex CLI, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, and Gemini CLI — **11 platforms** (13 install targets).
+Works with Claude Code, Windsurf, Cursor, Codex CLI, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI, and Kiro — **12 platforms** (14 install targets). MCP (and therefore memory) auto-wires for Claude Code, Cursor, Windsurf, Gemini CLI, Codex, and Kiro.
 
 ## Architecture
 
@@ -131,7 +131,7 @@ These fire multiple specialist agents simultaneously:
 - Agent format: Markdown with YAML frontmatter (name, description, tools, model)
 - Skill format: Markdown with clear sections (description, when to use, how it works)
 - Hook format: JSON with matcher conditions and command/notification hooks
-- No runtime deps in core — `@modelcontextprotocol/sdk` is an optionalDependency for MCP server only
+- No **required** runtime deps — the core (agents, skills, memory, RTK, Terse, graph) is pure-JS and runs on a default install with nothing installed. Three `optionalDependencies`: `@modelcontextprotocol/sdk` (MCP server), `sql.js` (optional SQLite for the session store / status DB / skill-evolution tracker), and `@xenova/transformers` (optional on-device memory embeddings, off by default). Each degrades cleanly to the pure-JS path when absent.
 
 ## Contributing
 

package/README.md

@@ -32,7 +32,7 @@ npx kodelyth-ecc
 ```
 
 Works on **macOS, Linux and Windows** with Claude Code, Windsurf, Cursor, Codex CLI,
-Google Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi and Gemini CLI.
+Google Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI and Kiro.
 
 ---
 
@@ -99,7 +99,7 @@ Most "AI agent kits" are folders of markdown files you have to remember the name
 | **8 parallel commands** | Fire 3-8 agents simultaneously, aggregate results | Rare |
 | **Compound memory** | BM25 local recall + auto-inject + project lessons | Cloud-only or absent |
 | **44 hook entries** | Quality gates, secret scan, project-DNA detection | Often missing |
-| **11 IDE platforms** | Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI (13 install targets) | 1-2 platforms typical |
+| **12 IDE platforms** | Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI, Kiro (14 install targets) | 1-2 platforms typical |
 | **Zero telemetry** | Everything stays on your disk; verifiable | Many kits phone home |
 
 ### Quick Comparison vs Other Kits
@@ -524,13 +524,16 @@ kodelythecc rtk gain --all             # raw rtk savings output
 kodelythecc rtk --help                 # focused help
 ```
 
-### Live proof (from this repo maintainer's Mac)
+### Example snapshot (one maintainer's Mac, one point in time)
+
+Not a guaranteed figure — RTK measures savings per command, and yours depend on
+which commands you run. Run `rtk gain` to see your own live numbers.
 
 ```
 total_commands:    1,285
 total_input:       7,964,612    (raw)
 total_output:      2,858,501    (after RTK filter)
-total_saved:       5,107,394    ← 64.1% average reduction
+total_saved:       5,107,394    ← 64.1% on this sample
 ```
 
 ---

package/agents/super-agent.md

@@ -0,0 +1,102 @@
+---
+name: super-agent
+description: Autonomous multi-step orchestrator — Kodelyth. Takes a single large objective and drives it to done through a deterministic state machine: decompose into a dependency DAG, route and dispatch each step (parallel where independent), evaluate against exit criteria, merge the worker branches with conflict detection, and verify. Resumable and budget-governed. Use for objectives that are too big for one pass and decompose into dependent steps. NOT for a single edit or a one-file change.
+tools: Read, Grep, Glob, Bash, Write, Edit, Task
+model: opus
+---
+
+# Super Agent — the autonomous orchestrator
+
+You are the driver of a tokenless state machine. You do **not** improvise the
+control flow — the machine owns it, so a run is deterministic, resumable, and
+bounded. Your job is to perform each action the machine asks for, using ECC's
+existing primitives, and report the result back.
+
+The machine lives in `scripts/super-agent/` and is driven entirely through:
+
+```bash
+kodelythecc super-agent <command> ...
+```
+
+## The loop
+
+1. **Start** a run from the objective:
+   ```bash
+   kodelythecc super-agent start --goal "<objective>" [--token-cap N] [--step-cap N] [--scope .]
+   ```
+   Always set a `--step-cap` or `--token-cap`. An autonomous run without a budget
+   is how costs run away. The output gives you a `runId` and the first action.
+
+2. **Ask what to do next**, and do exactly that:
+   ```bash
+   kodelythecc super-agent next <runId>
+   ```
+   The JSON `action` is one of:
+
+   - **`decompose`** — Break the goal into a dependency DAG. Use the `blueprint`
+     skill to produce it: each step is `{ id, description, deps: [ids],
+     contextBrief, exitCriteria }`. `contextBrief` must let a fresh agent execute
+     the step cold. Write the array to a file and install it:
+     ```bash
+     kodelythecc super-agent plan <runId> --file plan.json
+     ```
+
+   - **`dispatch`** — The listed steps are ready (their dependencies are done).
+     For a single small step, do it yourself or with one subagent. For several
+     independent steps, run them in parallel (the Task tool, or
+     `kodelythecc swarm` for isolated git worktrees). Each step does its work on
+     its **own branch**. As each finishes, report it:
+     ```bash
+     kodelythecc super-agent step <runId> <stepId> --status done --branch <branch> [--tokens N]
+     # or, if it could not be completed:
+     kodelythecc super-agent step <runId> <stepId> --status failed
+     ```
+     A failed step whose result others depend on stalls the run — that is the
+     machine protecting you from building on a broken foundation.
+
+   - **`integrate`** — All steps are done. Merge the worker branches. Detect
+     conflicts first, without touching the tree, via
+     `scripts/super-agent/integrate.js` (`mergeOrder` for the order,
+     `detectConflicts` for the check). If clean, merge in that order and:
+     ```bash
+     kodelythecc super-agent integrate <runId>
+     ```
+     If branches conflict, do **not** force it — report the conflicting files and
+     stop for a human:
+     ```bash
+     kodelythecc super-agent integrate <runId> --conflicts path/a,path/b
+     ```
+
+   - **`verify`** — Run the real verification gate (tests, build, type-check — use
+     `/verify`). Then:
+     ```bash
+     kodelythecc super-agent verify <runId> --passed --detail "693 tests pass"
+     # or --failed --detail "2 tests red"
+     ```
+
+   - **`halt`** — The budget cap was reached or the plan stalled. Stop and report
+     the reason. Do not work around the cap.
+
+   - **`report`** — The run is done, failed, or stopped. Summarize with
+     `kodelythecc super-agent status <runId>`.
+
+3. **Repeat** `next` → act → submit until the action is `report`.
+
+## Resuming
+
+A run persists after every step. To pick up a crashed or earlier run:
+`kodelythecc super-agent list`, then `kodelythecc super-agent next <runId>` — it
+continues from exactly where it stopped.
+
+## Rules
+
+- Never fabricate a step result. If a step did not actually succeed, submit it as
+  `--status failed` — the machine handles the consequences honestly.
+- Never bypass the budget or an `integrate` conflict. Those stops exist on purpose.
+- The verification gate is real: only submit `--passed` when tests/build actually
+  pass, with evidence in `--detail`.
+- Decompose into the smallest steps that still make sense as a unit of work, with
+  honest dependency edges — parallelism and correct integration both depend on
+  the edges being right.
+
+You are the calm operator of a machine that cannot lie about its own state.

package/bin/kodelyth-ecc.js

@@ -419,11 +419,49 @@ if (args[0] === 'memory') {
       w(`Top tags: ${s.topTags.slice(0, 8).map(t => t[0] + '(' + t[1] + ')').join(', ')}`);
       process.exit(0);
     }
-    process.stderr.write('unknown memory subcommand. try: capture | recall | list | stats\n');
+    // Auto-capture review queue: the Stop hook auto-queues candidates; these are
+    // the consent gate that turns them into stored memories.
+    if (sub === 'list-pending' || sub === 'review-pending') {
+      const pending = require(path.join(ROOT, 'scripts', 'memory', 'pending.js'));
+      const items = pending.listPending();
+      if (!items.length) { w('No memory candidates pending review.'); process.exit(0); }
+      w(`${items.length} candidate(s) pending review:`);
+      for (const c of items) w(`  [${c.id}] (score ${c.score ?? '-'})  ${(c.problem || '').slice(0, 70)}`);
+      w('Confirm: kodelythecc memory promote-pending <id|all>   ·   drop: kodelythecc memory discard-pending <id|all>');
+      process.exit(0);
+    }
+    if (sub === 'promote-pending') {
+      const pending = require(path.join(ROOT, 'scripts', 'memory', 'pending.js'));
+      const sel = rest.find(a => !a.startsWith('--')) || 'all';
+      const stored = pending.promotePending(sel);
+      if (!stored.length) { w('Nothing promoted (no matching pending candidate).'); process.exit(0); }
+      w(`✓ stored ${stored.length} memor${stored.length === 1 ? 'y' : 'ies'}:`);
+      for (const m of stored) w(`  ${m.id}  ${(m.problem || '').slice(0, 60)}`);
+      process.exit(0);
+    }
+    if (sub === 'discard-pending') {
+      const pending = require(path.join(ROOT, 'scripts', 'memory', 'pending.js'));
+      const sel = rest.find(a => !a.startsWith('--')) || 'all';
+      w(`Discarded ${pending.discardPending(sel)} pending candidate(s).`);
+      process.exit(0);
+    }
+    process.stderr.write('unknown memory subcommand. try: capture | recall | list | stats | list-pending | promote-pending | discard-pending\n');
     process.exit(2);
   } catch (e) { process.stderr.write(`[memory] ${e.message}\n`); process.exit(1); }
 }
 
+// ── Subcommand: super-agent (autonomous orchestrator driver) ─────────────────
+// Arena-style state machine: it does not run agents, it tells the driving LLM
+// what to do next. start → plan → step… → integrate → verify → done, resumable.
+//   kodelythecc super-agent start --goal "<objective>" [--token-cap N] [--step-cap N]
+//   kodelythecc super-agent next|status|list <id> ; plan/step/integrate/verify to advance
+if (args[0] === 'super-agent' || args[0] === 'superagent') {
+  try {
+    require(path.join(ROOT, 'scripts', 'super-agent', 'cli.js')).main(args.slice(1));
+    process.exit(0);
+  } catch (e) { process.stderr.write(`[super-agent] ${e.message}\n`); process.exit(1); }
+}
+
 // ── Subcommand: god / evil / arena (the adversarial arena) ──────────────────
 // Usage:
 //   kodelythecc god  --task "<task>" [--json]        plan a GOD-mode build
@@ -1883,7 +1921,24 @@ function runPostInstall(status, args) {
         const marker = r.action === 'added' ? '✓ added' : r.action === 'updated' ? '✓ updated' : r.action === 'unchanged' ? '· unchanged' : `· ${r.action}`;
         process.stdout.write(`  ${marker}: ${r.file}\n`);
       }
-      process.stdout.write(`  · Restart Claude Code / Claude Desktop to pick up the server\n`);
+
+      // Also wire ECC's MCP server into the specific non-Claude IDE this install
+      // targeted, when that IDE uses a JSON MCP config we can safely merge
+      // (Cursor, Windsurf, Gemini CLI). This is what extends memory and the whole
+      // MCP tool surface beyond Claude Code — previously they were Claude-only.
+      const mcpTargetIdx = args.indexOf('--target');
+      const mcpRawTarget = mcpTargetIdx >= 0 && args[mcpTargetIdx + 1] ? args[mcpTargetIdx + 1] : 'claude-code';
+      if (!/^claude/.test(mcpRawTarget)) {
+        for (const r of reg.registerForTarget(mcpRawTarget, { cwd: process.cwd(), log: () => {} })) {
+          if (r.action === 'added' || r.action === 'updated') {
+            process.stdout.write(`  ✓ ${r.action}: ${r.file}\n`);
+          } else if (r.action === 'error') {
+            process.stdout.write(`  · skipped ${r.file}: ${r.error}\n`);
+          }
+          // 'unsupported' / 'unchanged' stay quiet — not every target has a JSON MCP config
+        }
+      }
+      process.stdout.write(`  · Restart your AI tool to pick up the server\n`);
     } catch (e) {
       process.stderr.write(`[mcp] self-register skipped: ${e.message}\n`);
     }

package/commands/super-agent.md

@@ -0,0 +1,47 @@
+---
+name: super-agent
+description: Drive a large objective to completion through the autonomous orchestrator — decompose, dispatch (parallel), integrate branches, verify. Resumable, budget-governed.
+---
+
+# /super-agent
+
+Turn one big objective into a finished, verified result by running it through the
+**super-agent** orchestrator — a deterministic, resumable, budget-governed state
+machine (`scripts/super-agent/`).
+
+## Usage
+
+```
+/super-agent <objective>            e.g. /super-agent build a rate-limited login API with tests
+/super-agent resume <runId>         continue a crashed or earlier run
+```
+
+## What it does
+
+Behaves as the `super-agent` agent and runs the loop:
+
+1. `kodelythecc super-agent start --goal "<objective>" --step-cap <N>` — always with a budget.
+2. `kodelythecc super-agent next <id>` → perform the action it names:
+   - **decompose** → build a dependency DAG with the `blueprint` skill, `… plan <id> --file`.
+   - **dispatch** → run each ready step (parallel where independent, each on its own branch), `… step <id> <step> --status done --branch`.
+   - **integrate** → conflict-check with `scripts/super-agent/integrate.js`, merge in `mergeOrder`, `… integrate <id>` (or `--conflicts …` to stop).
+   - **verify** → run `/verify`, then `… verify <id> --passed|--failed`.
+3. Repeat until **report**.
+
+## When to use it
+
+- A feature or change too large for one pass, that splits into dependent steps.
+- You want parallel execution of independent steps with correct, conflict-checked integration.
+- You want the run to survive a crash and resume.
+
+## When NOT to use it
+
+- A single edit, one-file change, or a quick fix — just do it, or use the specific specialist.
+- Something with no real internal dependencies — the swarm (`/swarm`) or a single agent is lighter.
+
+## Guarantees
+
+- Nothing is faked: a step that did not succeed is recorded `failed`, and a failed
+  dependency stalls the run instead of building on it.
+- The budget cap and integration-conflict stop are honored, never bypassed.
+- `verify --passed` requires the tests/build to actually pass, with evidence.

package/hooks/memory/capture-stop.js

@@ -70,7 +70,7 @@ function main() {
     // ── Improvement A: build contextual advisory from session activity ────────
     const parts = [];
     if (candidates.length > 0) {
-      parts.push(`${candidates.length} memory candidate(s) queued — run "/memory review-pending" to confirm`);
+      parts.push(`${candidates.length} memory candidate(s) queued — review with "kodelythecc memory list-pending", then "promote-pending <id|all>" to confirm`);
     }
     if (hadFileWrites) {
       parts.push('files written this session — run "/memory save" or "/learn-eval" to save what we learned');

package/install.ps1

@@ -155,6 +155,17 @@ switch ($Target) {
         $HooksDest    = ""
         $RulesDest    = "$Dest\rules"
     }
+    "kiro" {
+        # Kiro (AWS AI IDE): rules become always-on steering; the full catalog
+        # arrives via the MCP server the Node post-install wires into
+        # .kiro\settings\mcp.json. MCP-native, so no file dump into steering.
+        $Dest         = "$(Get-Location)\.kiro"
+        $AgentsDest   = ""
+        $SkillsDest   = ""
+        $CommandsDest = ""
+        $HooksDest    = ""
+        $RulesDest    = "$Dest\steering"
+    }
     "cline" {
         $Dest         = "$(Get-Location)\.clinerules"
         $AgentsDest   = ""
@@ -205,7 +216,7 @@ switch ($Target) {
     }
     default {
         Write-Host "Unknown target: $Target" -ForegroundColor Red
-        Write-Host "Valid targets: claude-home, windsurf-project, windsurf-home, antigravity, cursor-project, codex-home, opencode, cline, roocode, aider, kimi, gemini-project, gemini-home"
+        Write-Host "Valid targets: claude-home, windsurf-project, windsurf-home, antigravity, cursor-project, codex-home, opencode, cline, roocode, aider, kimi, gemini-project, gemini-home, kiro"
         exit 1
     }
 }

package/install.sh

@@ -359,9 +359,22 @@ case "$TARGET" in
     RULES_DEST="$DEST/rules"
     INSTALL_MODE="user"
     ;;
+  kiro|kiro-project)
+    # Kiro (AWS AI IDE). Rules become always-on steering docs; the full catalog
+    # (agents, skills, commands, memory) arrives via the MCP server the Node
+    # post-install wires into .kiro/settings/mcp.json. Kiro is MCP-native, so we
+    # do not dump 266 agent/skill files into steering — that is what MCP is for.
+    DEST="$(pwd)/.kiro"
+    AGENTS_DEST=""
+    SKILLS_DEST=""
+    COMMANDS_DEST=""
+    HOOKS_DEST=""
+    RULES_DEST="$DEST/steering"
+    INSTALL_MODE="project"
+    ;;
   *)
     echo -e "${RED}Unknown target: $TARGET${RESET}"
-    echo "Valid targets: claude-home (aka claude-code), antigravity, cursor-project, windsurf-project, windsurf-home, codex-home, opencode, cline, roocode, aider, kimi, gemini-project, gemini-home"
+    echo "Valid targets: claude-home (aka claude-code), antigravity, cursor-project, windsurf-project, windsurf-home, codex-home, opencode, cline, roocode, aider, kimi, gemini-project, gemini-home, kiro"
     exit 1
     ;;
 esac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "2.24.11",
+  "version": "2.29.0",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 196 skills, 103 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works on macOS, Linux and Windows with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
@@ -75,7 +75,10 @@
     "portability": "node scripts/portability/scan.js agents commands skills hooks rules scripts"
   },
   "optionalDependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4"
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "sql.js": "^1.8.0",
+    "@xenova/transformers": "^2.17.2",
+    "ajv": "^8.12.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/rules/common/agent-intent-routing.md

@@ -60,9 +60,14 @@ Beyond the 10 priority tiers below, watch for these newer signals — they map t
 | "talk shorter" / "be brief" / "less verbose" / "caveman mode" | `/terse` (skill activation) |
 | "who calls X" / "where is X used" / "trace the call chain" / "impact analysis" | `codebase-memory-mcp` via `search_graph` / `trace_path` |
 | "index this project" / "build the graph" / "scan the codebase" | `codebase-memory-mcp` via `index_repository` |
+| "which tests does this change affect" / "what tests should I run" / "smart test selection" | `codebase-memory-mcp` via `detect_changes` with `scope: "tests"` (Smart CI) |
+| "find the bottleneck" / "hottest paths" / "most complex functions" / "refactor candidates" | `codebase-memory-mcp` via `query_graph` (complexity / hot-path metrics) |
+| "what docs explain X" / "where is X documented" / "link code to docs" | `codebase-memory-mcp` via `trace_path` (inbound `MENTIONS` edges) |
+| "record this decision" / "write an ADR" / "architecture decision record" | `codebase-memory-mcp` via `manage_adr` |
 | "remove ECC" / "uninstall kodelythecc" / "clean this up" | Suggest `kodelythecc uninstall --dry-run` |
 | "how much did I save" / "show my token savings" / "RTK stats" | `kodelythecc dashboard` OR `kodelythecc rtk gain` |
-| "install for another IDE" / "add to Cursor / Windsurf / Antigravity" | `kodelythecc --target <ide>` |
+| "install for another IDE" / "add to Cursor / Windsurf / Antigravity / Kiro" | `kodelythecc --target <ide>` |
+| "orchestrate this" / "build the whole X end-to-end" / "autonomously build" / "break this big goal into steps and build it" / "run it until it's done" | `super-agent` (the autonomous orchestrator) — decompose → dispatch (parallel) → integrate → verify, resumable + budget-governed. Not for a single edit. |
 
 ### 5. Compound intent → parallel agents
 

package/scripts/cli/menu.js

@@ -144,7 +144,7 @@ async function pickIdeAndInstall(ROOT) {
   const targets = [
     'claude-code', 'cursor-project', 'windsurf-home', 'windsurf-project',
     'antigravity', 'codex-home', 'opencode', 'cline', 'roocode',
-    'gemini-home', 'gemini-project', 'kimi', 'aider',
+    'gemini-home', 'gemini-project', 'kimi', 'aider', 'kiro',
   ];
   const chosen = await pick('Pick an IDE to install for', targets);
   if (chosen == null) return main();