@amsterdamdatalabs/enact-extensions 0.1.37 → 0.1.42

package/dist/internal/agents.d.ts

@@ -12,7 +12,7 @@ export interface AgentDef {
     name: string;
     description: string;
     body: string;
-    /** Codex/enact canonical model id (e.g. `gpt-5.4`). */
+    /** Codex/enact canonical model id (e.g. `gpt-5.6-luna`). */
     model?: string;
     /** Claude model alias (codex `model` is a separate namespace). */
     claudeModel?: string;

package/dist/internal/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/internal/agents.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;GAOG;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAYD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAcxD;AAgBD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,qBAAqB,GAAG,MAAM,CAczF;AAgCD,UAAU,mBAAmB;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAA;CAAE,CA0BlD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAWpF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAmB/F"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/internal/agents.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;GAOG;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAYD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAcxD;AAgBD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,qBAAqB,GAAG,MAAM,CAczF;AAgCD,UAAU,mBAAmB;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAA;CAAE,CA0BlD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAWpF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAmB/F"}

package/extensions/enact-factory/agents/architect.toml

@@ -1,6 +1,6 @@
 name = "architect"
 description = "Architectural review and GO/NO-GO verdict with evidence pointers — independent grader"
-model = "gpt-5.5"
+model = "gpt-5.6-sol"
 claude_model = "opus"
 cursor_model = "default"
 model_reasoning_effort = "high"

package/extensions/enact-factory/agents/code-reviewer.toml

@@ -1,6 +1,6 @@
 name = "code-reviewer"
 description = "Binding code review pass — independent grader on a separate model"
-model = "gpt-5.3-codex-spark"
+model = "gpt-5.6-sol"
 claude_model = "haiku"
 cursor_model = "default"
 model_reasoning_effort = "high"

package/extensions/enact-factory/agents/critic.toml

@@ -1,6 +1,6 @@
 name = "critic"
 description = "Adversarial debate participant for high-risk decision review — independent grader"
-model = "gpt-5.3-codex-spark"
+model = "gpt-5.6-sol"
 claude_model = "haiku"
 cursor_model = "default"
 model_reasoning_effort = "high"

package/extensions/enact-factory/agents/executor.toml

@@ -1,6 +1,6 @@
 name = "executor"
 description = "Focused implementation worker for small, reviewable diffs with verification"
-model = "gpt-5.4"
+model = "gpt-5.6-luna"
 claude_model = "sonnet"
 cursor_model = "composer-2.5"
 model_reasoning_effort = "medium"

package/extensions/enact-factory/agents/explore.toml

@@ -1,6 +1,6 @@
 name = "explore"
 description = "Codebase sweep agent for absolute-path findings and quote-friendly evidence"
-model = "gpt-5.3-codex-spark"
+model = "gpt-5.6-luna"
 claude_model = "haiku"
 cursor_model = "default"
 model_reasoning_effort = "medium"

package/extensions/enact-factory/agents/planner.toml

@@ -1,9 +1,9 @@
 name = "planner"
 description = "Structured implementation planner that never writes production code"
-model = "gpt-5.5"
+model = "gpt-5.6-terra"
 claude_model = "opus"
 cursor_model = "default"
-model_reasoning_effort = "medium"
+model_reasoning_effort = "high"
 sandbox_mode = "danger-full-access"
 developer_instructions = """
 Agent definition: structured implementation planner that never writes production code.

package/extensions/enact-factory/agents/verifier.toml

@@ -1,6 +1,6 @@
 name = "verifier"
 description = "Evidence-first verifier for real-surface QA and completion claims — independent grader"
-model = "gpt-5.3-codex-spark"
+model = "gpt-5.6-sol"
 claude_model = "haiku"
 cursor_model = "default"
 model_reasoning_effort = "high"

package/extensions/enact-factory/skills/advisor/SKILL.md

@@ -36,7 +36,7 @@ passed AND that cheap graders would likely have false-GO'd.
 ## Model selection
 
 Advisor runs on a **strong cross-vendor** model:
-- **gpt-5.5** — preferred for Frontend / UI a11y / visual judgment (distinct from sonnet executor)
+- **gpt-5.6-sol** with high thinking — preferred for Frontend / UI a11y / visual judgment (distinct from sonnet executor)
 - **opus 4.8** — preferred when executor is codex / gpt lineage (cross-vendor from OpenAI)
 
 If the strong escalation model is unavailable, say so and STOP — do not substitute a cheap or
@@ -60,7 +60,7 @@ same-lineage model and call it independent.
    ```
    Agent({
      subagent_type: "critic" | "architect" | "verifier",   // fit the question
-     model: "gpt-5.5" | "claude-opus-4-8",                  // strong cross-vendor; ≠ executor model
+     model: "gpt-5.6-sol" | "claude-opus-4-8",                  // strong cross-vendor; ≠ executor model
      prompt: "<WorkItem context + the exact decision/artifact +
               acceptance criteria + 'Return GO / CONCERNS / NO-GO with
               rationale and the single most important risk.'>"

package/extensions/enact-factory/skills/autonomous-runner/SKILL.md

@@ -153,10 +153,10 @@ logic** and add a judgment grader. (Full tree:
 
 | Type | Executor (surface) | Grader — default cheap | Escalate to strong grader when |
 |---|---|---|---|
-| Frontend / UI | `claude` / sonnet — UX, visual, copy | **minimax M3** / **kimi K2.7** | `advisor` (gpt-5.5) for a11y / visual / UX judgment |
-| Backend / logic | `codex` / **gpt-5.4** — mechanical workhorse | **minimax M3** / **kimi K2.7** | `committee` (opus + gpt-5.5) if architecture unclear |
-| Data-heavy | `codex` / **gpt-5.4** high-effort + data-safety stages | **minimax M3** / **kimi K2.7** | `committee` for risky or irreversible migrations |
-| Infra / CI | `codex` / **gpt-5.4** + pipeline validation | **minimax M3** / **kimi K2.7** | `committee` before branch policy; `opus 4.8` for security/public-API changes |
+| Frontend / UI | `claude` / sonnet — UX, visual, copy | **minimax M3** / **kimi K2.7** | `advisor` (GPT-5.6 Sol High) for a11y / visual / UX judgment |
+| Backend / logic | `codex` / **GPT-5.6 Terra** — heavyweight implementation | **minimax M3** / **kimi K2.7** | `committee` (opus + GPT-5.6 Terra) if architecture unclear |
+| Data-heavy | `codex` / **GPT-5.6 Terra** high-effort + data-safety stages | **minimax M3** / **kimi K2.7** | `committee` for risky or irreversible migrations |
+| Infra / CI | `codex` / **GPT-5.6 Terra** + pipeline validation | **minimax M3** / **kimi K2.7** | `committee` before branch policy; `opus 4.8` for security/public-API changes |
 | Docs | `claude` / sonnet (writing) | **minimax M3** / **kimi K2.7** | rarely |
 
 The **executor ≠ grader** rule is a hard gate everywhere (see contract above).
@@ -169,16 +169,16 @@ each role:
 
 | Function tier | Models | Used for |
 |---|---|---|
-| Workers (execute) | **sonnet** (in-window) · **codex/gpt-5.4** | implementation, diffs, refactors, bugfixes |
-| Planning / architecture | **opus 4.8** · **gpt-5.5** (reasoning: xhigh) | plans, interface/architecture design, hard root-cause, committee |
-| Verify / review / grade (DEFAULT cheap) | **minimax M3** (opencode) · **kimi K2.7** | first-pass judgment on routine code-review / verify / docs (~80% of grading) |
+| Workers (execute) | **sonnet** (in-window) · **codex/GPT-5.6 Luna** for focused fast execution · **GPT-5.6 Terra** for heavyweight work | implementation, diffs, refactors, bugfixes |
+| Planning / architecture | **opus 4.8** · **GPT-5.6 Terra** (reasoning: high+) | plans, interface/architecture design, hard root-cause, committee |
+| Verify / review / grade (DEFAULT cheap) | **MiniMax M3** (`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) · **kimi K2.7** | first-pass judgment on routine code-review / verify / docs (~80% of grading) |
 | Explorers (map, read-only) | **haiku** · **cursor composer 2.5** | codebase sweeps, naming maps, brownfield discovery — never grade |
 
-**Grading = cheap default + risk-based escalation.** minimax M3 / kimi K2.7 grade the routine
-~80%. Escalate to a strong cross-vendor grader for:
-- Frontend / UI a11y or visual / UX judgment → **advisor** = **gpt-5.5** (or opus if executor was codex)
+**Grading = cheap default + risk-based escalation.** MiniMax M3 (`minimax-coding-plan/MiniMax-M3`, always
+`--thinking on`) / kimi K2.7 grade the routine ~80%. Escalate to a strong cross-vendor grader for:
+- Frontend / UI a11y or visual / UX judgment → **advisor** = **GPT-5.6 Sol High** (or opus if executor was codex)
 - Security, public API / barrel / contract changes → **opus 4.8**
-- Architecture decisions / risky or irreversible migrations → **committee** (opus + gpt-5.5)
+- Architecture decisions / risky or irreversible migrations → **committee** (opus + GPT-5.6 Terra)
 
 #### Contract shape per tier
 
@@ -201,11 +201,11 @@ When the executor is **`claude-sonnet-4-6`** (or any sonnet-tier model), the
 `cursor` grader (`cursor/claude-sonnet-4-6`) is **NOT model-distinct** — it runs
 the same underlying model and the independence rule is violated.
 
-**Default cheap graders for sonnet work:** use **minimax M3** (opencode) or **kimi K2.7** — both
-are vendor-distinct from sonnet and satisfy the independence rule cleanly. Use:
+**Default cheap graders for sonnet work:** use **MiniMax M3** (`minimax-coding-plan/MiniMax-M3`, always
+`--thinking on`) or **kimi K2.7** — both are vendor-distinct from sonnet and satisfy the independence rule cleanly. Use:
 
-- **minimax M3** / **kimi K2.7** — default graders for sonnet-executor work (cheap, independent)
-- **opus 4.8** / **gpt-5.5** — escalation graders for high-risk judgment (see escalation table above)
+- **MiniMax M3** (`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) / **kimi K2.7** — default graders for sonnet-executor work (cheap, independent)
+- **opus 4.8** / **GPT-5.6 Sol High** — escalation graders for high-risk judgment (see escalation table above)
 - `cursor` grader ONLY when the executor is opus-tier (cursor runs claude-sonnet, so it is distinct from opus)
 
 #### Paseo permission-mode table
@@ -218,7 +218,7 @@ or return an empty session:
 | `codex` | `--mode auto-review` | Routes the grader's eligible `on-request` approvals through codex's auto-reviewer subagent instead of BLOCKING — without it a grader can stall on an approval (e.g. a cargo/network fetch during build verification). `--mode bypass` is rejected by codex |
 | `cursor` | default / agent | `--mode bypass` is a claude mode, NOT cursor's — previously documented wrong; cursor uses default or agent mode |
 | `kimi` | `--mode auto` | Same as codex |
-| `opencode` (minimax M3) | default | No special mode flag needed |
+| `opencode` (MiniMax M3) | `--mode plan --thinking on` | Required for every MiniMax M3 dispatch |
 
 Codex mode enum (authoritative): `read-only` · `auto` · `auto-review` · `full-access`. The grader
 stays read-only BY PROMPT; `auto-review` only governs approval handling and composes with

package/extensions/enact-factory/skills/committee/SKILL.md

@@ -34,14 +34,14 @@ two independent strong perspectives before proceeding.
 
 ## Model selection
 
-Committee always uses **opus 4.8 + gpt-5.5** — the two strongest available models from different
+Committee always uses **opus 4.8 + gpt-5.6-terra** — the two strongest available models from different
 vendors. This pairing provides genuine diversity: one OpenAI-lineage, one Anthropic-lineage.
 
 ## Boundaries (hard)
 
 - **Diagnose + plan only.** No code changes, no commits, no board mutation. The
   output is a plan; implementation happens later via `drive-loop`.
-- **Two distinct vendors: opus 4.8 + gpt-5.5.** Both members run on models that are different
+- **Two distinct vendors: opus 4.8 + gpt-5.6-terra.** Both members run on models that are different
   from each other and from the executor (genuine diversity). If two distinct models are
   unavailable, run what you can and STATE the reduced diversity loudly — do not
   pretend two same-model passes are a committee.
@@ -52,11 +52,11 @@ vendors. This pairing provides genuine diversity: one OpenAI-lineage, one Anthro
 
 1. Assemble the dossier: `factory_workitem_get` (goal, acceptance, current
    state, `blockedBy`), the loop status / stall reason, recent failing output.
-2. Spawn TWO agents on **opus 4.8 + gpt-5.5**, with contrasting lenses:
+2. Spawn TWO agents on **opus 4.8 + gpt-5.6-terra**, with contrasting lenses:
 
    ```
    Agent({ subagent_type: "critic",    model: "claude-opus-4-8", prompt: "<dossier> — root-cause why this is stuck; what is the real blocker?" })
-   Agent({ subagent_type: "architect", model: "gpt-5.5",         prompt: "<dossier> — is the current approach right? propose the smallest viable path to closure." })
+   Agent({ subagent_type: "architect", model: "gpt-5.6-terra",         prompt: "<dossier> — is the current approach right? propose the smallest viable path to closure." })
    ```
 
 3. Reconcile their findings into ONE plan: the root cause, the chosen approach

package/extensions/enact-factory/skills/deslop-handover/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: deslop-handover
+description: "Strip AI-authoring tells (emoji, marketing tone, over-bolding, edit scars) from handover docs for a no-AI customer, while preserving every number, reference, code block, and finding verbatim."
+---
+
+# Deslop Handover
+
+Make a documentation handover read as plain, human-authored engineering notes — for a
+customer that enforces a **strict no-AI policy** — without losing any of the hard-won
+technical substance.
+
+This is sharper than `ai-slop-cleaner` (which targets TODO/placeholder code residue) because
+it adds the two things that matter for prose handovers:
+
+1. **Preserve-rules** — numbers, percentages, file:line refs, code blocks, table data,
+   citations/DOIs stay byte-for-byte. The value is the substance; only the *voice* changes.
+2. **Sanctioned-vs-violation distinction** — the delivered product running on the customer's
+   OWN infrastructure (Azure OpenAI, LLM parser, embeddings, BM25, vector search, ontology,
+   taxonomy) is **architecture, not a violation** — KEEP it. Only AI-*authoring* tells go.
+
+## Use When
+
+- Preparing any markdown/docs bundle for handover to a no-AI / compliance-sensitive customer.
+- After an AI-assisted writing or redaction pass that left tone slop or edit scars.
+- When docs must look human-authored but every finding/number must survive intact.
+
+## What counts as slop (REMOVE / NEUTRALIZE)
+
+- **Emoji & decorative symbols** (✅ ✔ ✓ ❌ ⚠️ 🎯 📊 🚀 ✨ ⭐). Badge labels like `✅ Good` →
+  the plain word (`Good`); decorative ones → delete. (Arrows `→`, dashes `—`, math `≤ ≥ ≠`
+  are notation — keep.)
+- **Marketing / filler**: comprehensive, seamless, robust (only when decorative — keep
+  "robust to X" technical usage), powerful, leverage, elegant, best practices, closes the
+  gap, dive in, it's worth noting, it's important to note, "Note that" openers, "Overall,",
+  "In summary", "In conclusion", game-changer, unlock(s), elevate, supercharge, effortless,
+  cutting-edge.
+- **Rule-of-three flourishes** and hype cadence ("X, Y, and Z — all real") → plain statement.
+- **Over-bolding** — bold used for sentence emphasis; keep bold only on genuine key terms/values.
+- **Self-referential tells** — "generated by an AI", "LLM-authored", "I analyzed", "this
+  session", "as an AI"; template title prefixes like `Learning:` / `Fix:`.
+- **Edit scars** from prior passes — blank-date holes (`as of )`, `On , `, `( run, …)`),
+  empty parens `( )`, leading-comma parens `(, …)`, space-before-colon `Foo :`, dangling
+  heading dashes `# Title —`, duplicated words.
+
+## What to PRESERVE (do not touch)
+
+Every number, percentage, row count, threshold, column name, file path, file:line reference,
+SQL/code block (verbatim), table data cell, citation, DOI, author, journal, year. Every
+finding, root cause, decision, and deferred/open/superseded note. Section structure. The
+sanctioned product-architecture terms listed above.
+
+## Workflow
+
+**Step 1 — mechanical pass (the ~80%).** Run the bundled script in report mode first, then fix:
+
+```bash
+python skills/deslop-handover/deslop.py --report <root-or-globs...>   # see what's there
+python skills/deslop-handover/deslop.py --fix    <root-or-globs...>   # apply mechanical fixes
+```
+
+The script is **code-fence-aware** (never touches fenced ``` blocks, inline `code`, or digits)
+and only does safe structural edits: emoji removal/badge-strip, edit-scar repair, trailing
+whitespace. It does NOT auto-rewrite prose — it **reports** slop phrases, over-bold lines, and
+blank-date holes for the judgment pass.
+
+**Step 2 — judgment pass (the ~20%), fanned out.** Tone, over-bolding ("key term vs emphasis"),
+rule-of-three, and ambiguous scars need a reader. Parallelize:
+
+1. Write a shared rubric file (this SKILL's "What counts as slop" + "PRESERVE" sections).
+2. Group the dirty files into batches of ~6.
+3. Dispatch one sonnet executor per batch: *"Read the rubric at <path>. Deslop these files in
+   place: <list>. Preserve all numbers/refs/code verbatim. Report per file."*
+4. Each executor reports per-file changes and confirms zero numbers/refs/code changed.
+
+**Step 3 — verification gate.** Re-grep the whole bundle; the count must be zero:
+
+```bash
+rg -lP '[\x{1F300}-\x{1FAFF}\x{2600}-\x{26FF}\x{2705}\x{274C}\x{2714}\x{2713}\x{2716}]' <root>   # emoji
+rg -ni -e seamless -e '\bleverage' -e '\bunlock' -e 'best practices' -e 'dive in' <root>          # phrases
+rg -n -e 'as of \)' -e '\( *\)' -e '\(, ' -e ' —$' <root>                                          # scars
+```
+
+A grep hit inside a fenced code block (e.g. `.collect()` matching empty-parens) is a
+false positive — confirm by line before acting.
+
+## State Contract
+
+- Reads: the target docs (and a temp rubric file for the judgment pass).
+- Writes: the same docs, in place. No new files in the handover bundle, no frontmatter added.
+
+## Final Check
+
+- Zero emoji, zero slop phrases, zero edit scars outside fenced code.
+- Every number, file:line ref, code block, table cell, and citation is unchanged (diff to confirm).
+- Product-architecture terms (Azure OpenAI / LLM / embeddings / BM25 / ontology) intact.
+- Protected docs (e.g. a `STRATEGY.md`) excluded unless the user explicitly opts them in.
+- Ambiguous scars (missing words, duplicated phrases, lost dates) surfaced to the user, not guessed.

package/extensions/enact-factory/skills/deslop-handover/deslop.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""deslop-handover — mechanical AI-tone cleanup for markdown handover docs.
+
+Code-fence-aware. Does the safe, deterministic ~80% of a deslop pass:
+  - strips emoji / badge symbols (keeps arrows, dashes, math notation)
+  - repairs edit scars (empty parens, leading-comma parens, space-before-colon,
+    space-before-comma, dangling heading dashes, trailing whitespace)
+  - REPORTS (never auto-rewrites) slop phrases, over-bold lines, and blank-date holes
+    that need the judgment/agent pass.
+
+NEVER touches: fenced ``` code blocks, inline `code` spans, digits, or table data values.
+
+Usage:
+    python deslop.py --report PATH [PATH ...]    # default: show findings, change nothing
+    python deslop.py --fix    PATH [PATH ...]    # apply the mechanical fixes in place
+
+PATH may be a file, a directory (recursed for *.md), or a glob. Vendored dirs
+(.venv/.git/node_modules/dist-info/.pytest_cache) are skipped.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import re
+import sys
+from pathlib import Path
+
+_SKIP_DIRS = {".venv", ".git", "node_modules", ".pytest_cache", "__pycache__"}
+
+# Emoji / decorative symbols. Deliberately EXCLUDES arrows (U+2190-21FF, →),
+# dashes (—, –) and math (≤ ≥ ≠) which are technical notation.
+EMOJI = re.compile(
+    "[\U0001F300-\U0001FAFF\U00002600-\U000027BF\U00002B00-\U00002BFF"
+    "✅❌✔✓✖✗✨️]"
+)
+
+SLOP_PHRASES = [
+    "comprehensive", "seamless", "powerful", "leverage", "elegant", "best practices",
+    "closes the gap", "dive in", "worth noting", "important to note", "game-changer",
+    "game changer", "unlock", "elevate", "supercharge", "effortless", "cutting-edge",
+    "in conclusion", "in summary",
+]
+# matches that are technical, not slop — do not flag these
+SLOP_ALLOW = re.compile(r"robust to|robustness|leverage point|highest leverage", re.I)
+
+# Ambiguous scars that imply a lost word/date — REPORT, do not auto-fix.
+HOLE = re.compile(r"as of \)|\( *run\b|On , |Effective ,|\bpre-\s*$")
+
+_INLINE_CODE = re.compile(r"`[^`]*`")
+_FENCE = re.compile(r"^\s*(```|~~~)")
+
+
+def _split_protecting_code(line: str):
+    """Yield (text, is_code) chunks so transforms skip inline `code` spans."""
+    pos = 0
+    for m in _INLINE_CODE.finditer(line):
+        if m.start() > pos:
+            yield line[pos:m.start()], False
+        yield m.group(0), True
+        pos = m.end()
+    if pos < len(line):
+        yield line[pos:], False
+
+
+def _fix_text(text: str, is_heading: bool) -> str:
+    """Apply mechanical fixes to a non-code text chunk."""
+    text = EMOJI.sub("", text)
+    text = text.replace("️", "")
+    text = re.sub(r"\(\s*\)", "", text)          # empty parens
+    text = re.sub(r"\(,\s*", "(", text)          # leading-comma paren
+    text = re.sub(r"\(\s+", "(", text)           # leading space in paren
+    text = re.sub(r"\s+\)", ")", text)           # space before close paren
+    text = re.sub(r"\s+,", ",", text)            # space before comma
+    text = re.sub(r"\s+:\*\*", ":**", text)      # space before bold-closing colon
+    text = re.sub(r"(\*\*[^*\n]+?) :", r"\1:", text)  # "label :" inside bold
+    text = re.sub(r"\s+:\s*$", ":", text)        # space before trailing label colon
+    if is_heading:
+        text = re.sub(r"\s*[—–-]\s*$", "", text)  # dangling heading dash
+    text = re.sub(r"(?<=\S)  +", " ", text)      # collapse runs of inner spaces
+    return text
+
+
+def process(path: Path, fix: bool):
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=False)
+    in_fence = False
+    out, report = [], {"emoji": 0, "scars": 0, "phrases": [], "bold": [], "holes": []}
+    for n, line in enumerate(lines, 1):
+        if _FENCE.match(line):
+            in_fence = not in_fence
+            out.append(line)
+            continue
+        if in_fence:
+            out.append(line)
+            continue
+
+        # ---- report-only signals (computed on the original line) ----
+        for p in SLOP_PHRASES:
+            if p in line.lower() and not SLOP_ALLOW.search(line):
+                report["phrases"].append((n, p))
+        if HOLE.search(line):
+            report["holes"].append((n, line.strip()[:80]))
+        for b in re.findall(r"\*\*([^*\n]+)\*\*", line):
+            if "." in b or len(b.split()) > 6:   # bold wrapping a sentence/clause
+                report["bold"].append((n, b[:60]))
+        report["emoji"] += len(EMOJI.findall(line))
+
+        # ---- mechanical fix ----
+        lead = re.match(r"^\s*", line).group(0)
+        rest = line[len(lead):]
+        is_heading = rest.startswith("#") or rest.startswith(">")
+        rebuilt = "".join(
+            chunk if is_code else _fix_text(chunk, is_heading)
+            for chunk, is_code in _split_protecting_code(rest)
+        )
+        rebuilt = (lead + rebuilt).rstrip()
+        if rebuilt != line:
+            report["scars"] += 1
+        out.append(rebuilt)
+
+    changed = out != lines
+    if fix and changed:
+        path.write_text("\n".join(out) + "\n", encoding="utf-8")
+    return changed, report
+
+
+def collect(paths):
+    files = []
+    for p in paths:
+        for hit in glob.glob(p, recursive=True) if any(c in p for c in "*?[") else [p]:
+            hp = Path(hit)
+            if hp.is_dir():
+                files += [f for f in hp.rglob("*.md")
+                          if not any(part in _SKIP_DIRS for part in f.parts)]
+            elif hp.suffix == ".md":
+                files.append(hp)
+    return sorted(set(files))
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Mechanical deslop for handover markdown.")
+    ap.add_argument("--fix", action="store_true", help="apply fixes (default: report only)")
+    ap.add_argument("--report", action="store_true", help="report only (default; no-op flag for clarity)")
+    ap.add_argument("paths", nargs="+", help="files, dirs, or globs")
+    args = ap.parse_args()
+
+    files = collect(args.paths)
+    if not files:
+        print("no markdown files found", file=sys.stderr)
+        return 1
+
+    total_changed = 0
+    for f in files:
+        changed, r = process(f, args.fix)
+        signal = r["emoji"] or r["scars"] or r["phrases"] or r["bold"] or r["holes"]
+        if not signal:
+            continue
+        total_changed += int(bool(changed))
+        tag = "FIXED " if (args.fix and changed) else "FOUND "
+        print(f"\n{tag}{f}")
+        if r["emoji"]:
+            print(f"  emoji/badges: {r['emoji']}")
+        if r["scars"] and not args.fix:
+            print(f"  mechanical scars: {r['scars']} line(s) (run --fix)")
+        if r["phrases"]:
+            print("  slop phrases (judgment): " +
+                  ", ".join(f"L{n}:{p}" for n, p in r["phrases"][:8]))
+        if r["bold"]:
+            print(f"  over-bold lines (judgment): {len(r['bold'])} "
+                  f"(e.g. L{r['bold'][0][0]})")
+        if r["holes"]:
+            print("  blank-date / lost-word HOLES (needs human): " +
+                  "; ".join(f"L{n}" for n, _ in r["holes"]))
+
+    verb = "fixed" if args.fix else "with findings"
+    print(f"\n{total_changed if args.fix else len(files)} file(s) {verb}. "
+          f"Run the verification grep + judgment pass next (see SKILL.md).")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/extensions/enact-factory/skills/drive-loop/SKILL.md

@@ -161,7 +161,7 @@ For each judgment stage:
 > the factory MCP tool `factory_paseo_grader_run` runs the grader with
 > `paseo run --output-schema --json --wait-timeout` so **stdout is the validated `{verdict,
 > evidence}` object** — no `paseo logs | grep`. It bakes in the per-provider `--mode`
-> (codex `auto-review` so on-request approvals don't block, kimi `auto`, cursor/opencode default) and recovers the actual resolved model via
+> (codex `auto-review` so on-request approvals don't block, kimi `auto`, cursor default, opencode MiniMax M3 `--mode plan --thinking on`) and recovers the actual resolved model via
 > `paseo ls --label` / `inspect`, which you relay as `graderModelActual` on `loop_grader_verdict`.
 > Full design: `enact-loop/docs/design/2026-06-22-paseo-verdict-capture.md`.
 
@@ -235,16 +235,16 @@ acceptance criteria in a real surface.
 
 #### Grader selection — cheap default + risk-based escalation
 
-**minimax M3** (opencode) and **kimi K2.7** are the default cheap graders for routine judgment
+**MiniMax M3** (`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) and **kimi K2.7** are the default cheap graders for routine judgment
 (~80% of grading). Escalate to a strong cross-vendor grader when:
-- Frontend / UI a11y or visual / UX judgment → `advisor` = **gpt-5.5** (or opus 4.8 if executor was codex)
+- Frontend / UI a11y or visual / UX judgment → `advisor` = **GPT-5.6 Sol High** (or opus 4.8 if executor was codex)
 - Security, public API / barrel / contract changes → **opus 4.8**
-- Architecture decisions / risky or irreversible migrations → `committee` (opus 4.8 + gpt-5.5)
+- Architecture decisions / risky or irreversible migrations → `committee` (opus 4.8 + GPT-5.6 Terra)
 
-**Independence (hard gate — model-distinct):** grader model ≠ executor model. minimax M3 / kimi K2.7
-are vendor-distinct from both sonnet and codex workers, so default cheap graders are always
-independent. On escalation keep cross-vendor: grade codex work with **opus** (not gpt-5.5 — same
-OpenAI lineage); grade sonnet work with gpt-5.5 / opus / minimax / kimi.
+**Independence (hard gate — model-distinct):** grader model ≠ executor model. MiniMax M3
+(`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) / kimi K2.7 are vendor-distinct from both sonnet and codex workers, so default cheap graders are always
+independent. On escalation keep cross-vendor: grade codex work with **opus** (not GPT-5.6 Sol — same
+OpenAI lineage); grade sonnet work with GPT-5.6 Sol High / opus / minimax / kimi.
 
 #### Permission modes (REQUIRED — non-default modes prevent stall/empty sessions)
 
@@ -253,7 +253,7 @@ OpenAI lineage); grade sonnet work with gpt-5.5 / opus / minimax / kimi.
 | `codex` | `--mode auto-review` | Routes the grader's eligible `on-request` approvals through codex's auto-reviewer subagent instead of BLOCKING — without it a grader can stall on an approval (e.g. a cargo/network fetch during build verification). `--mode bypass` is rejected by codex |
 | `cursor` | default / agent | `--mode bypass` is a claude mode, NOT cursor's — previously documented wrong |
 | `kimi` | `--mode auto` | Same as codex |
-| `opencode` (minimax M3) | default | No special mode flag needed |
+| `opencode` (MiniMax M3) | `--mode plan --thinking on` | Required for every MiniMax M3 dispatch |
 
 Codex mode enum (authoritative): `read-only` · `auto` · `auto-review` · `full-access`. The grader
 stays read-only BY PROMPT; `auto-review` only governs approval handling and composes with
@@ -262,8 +262,8 @@ stays read-only BY PROMPT; `auto-review` only governs approval handling and comp
 #### Sonnet-executor caveat
 
 `cursor` (`cursor/claude-sonnet-4-6`) is NOT model-distinct from a sonnet executor.
-Use **minimax M3** or **kimi K2.7** as the clean default cheap graders for sonnet-executor work;
-escalate to opus 4.8 / gpt-5.5 for high-risk judgment. Reserve `cursor` for opus-tier executors.
+Use **MiniMax M3** (`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) or **kimi K2.7** as the clean default cheap graders for sonnet-executor work;
+escalate to opus 4.8 / GPT-5.6 Sol High for high-risk judgment. Reserve `cursor` for opus-tier executors.
 
 #### Verdict capture — structured `--output-schema`, not log-scraped
 

package/extensions/enact-factory/skills/paseo-dispatch/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: paseo-dispatch
+description: >-
+  Canonical Enact Factory reference for launching Paseo agents, reviewers,
+  graders, advisors, committees, and handoffs with correct provider/model/mode
+  selection across Codex, Claude Code, Kimi, OpenCode/MiniMax, and Cursor. Use
+  when a skill invokes Paseo, chooses a grader/advisor/committee model, runs
+  factory_paseo_grader_run, needs auto-review/nonblocking review modes, or must
+  prove model-distinct review provenance.
+metadata:
+  author: Amsterdam Data Labs
+  version: 1.0.0
+---
+
+# paseo-dispatch
+
+Paseo dispatch is fragile because provider names, model ids, and permission modes
+are not interchangeable. Use this skill whenever factory work launches agents
+through Paseo or records an independent review verdict.
+
+## Discovery First
+
+Before choosing a provider or mode, inspect the live surface:
+
+```bash
+paseo provider ls --json
+paseo provider models <provider> --json
+```
+
+If `~/.paseo/orchestration-preferences.json` exists, read it and treat it as the
+user's preferred role map unless the task explicitly requires a different model.
+Do not assume a model id from old docs when live `paseo provider models` disagrees.
+
+Prefer explicit provider and model flags:
+
+```bash
+paseo run --provider <provider> --model <model-id> --mode <mode> --cwd <repo> "<prompt>"
+```
+
+This keeps provider, model, and permission mode separable. Record the actual
+model from `paseo inspect <id> --json` when a verdict or committee depends on
+independence.
+
+## Review Modes
+
+Use the provider's nonblocking review mode for graders, advisors, and committees.
+The prompt still makes the reviewer read-only; the mode only controls whether
+tool approvals stall the agent.
+
+| Provider | Review mode | Common model ids | Notes |
+|---|---|---|---|
+| `codex` | `--mode auto-review` | `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna` | Use Sol with `--thinking high` for reviewers/graders; use Terra for heavyweight work and Luna for lightweight fast execution. Never use `bypass`. |
+| `claude` | `--mode auto` | `claude-opus-4-8`, `claude-sonnet-4-6`, `claude-fable-5` | Claude Code's nonblocking review path is Auto mode. Use `--mode plan` only for pure planning where no tool approvals are expected. |
+| `kimi` | `--mode auto` | `kimi-code/kimi-for-coding` | Kimi K2.7 Code supports `--thinking on`; use it for review unless speed matters more. |
+| `opencode` | `--mode plan` for review, `--mode build` for implementation | `minimax-coding-plan/MiniMax-M3`, `opencode-go/kimi-k2.7-code` | MiniMax M3 is a MiniMax model, not an OpenCode model. Every OpenCode/MiniMax M3 dispatch MUST pass `--thinking on`. |
+| `cursor` | `--mode ask` or `--mode plan` for review, `--mode agent` for implementation | provider defaults vary | Do not pass Claude `bypass` to Cursor. Verify modes live before use. |
+
+## Standard Review Commands
+
+Codex Sol High grader:
+
+```bash
+paseo run --provider codex --model gpt-5.6-sol --mode auto-review \
+  --thinking high --cwd "$ROOT" --wait-timeout 10m \
+  --label role=reviewer "<review prompt>"
+```
+
+Claude strong reviewer:
+
+```bash
+paseo run --provider claude --model claude-opus-4-8 --mode auto \
+  --thinking high --cwd "$ROOT" --wait-timeout 10m \
+  --label role=reviewer "<review prompt>"
+```
+
+Kimi K2.7 reviewer:
+
+```bash
+paseo run --provider kimi --model kimi-code/kimi-for-coding --mode auto \
+  --thinking on --cwd "$ROOT" --wait-timeout 10m \
+  --label role=reviewer "<review prompt>"
+```
+
+MiniMax M3 reviewer:
+
+```bash
+paseo run --provider opencode --model minimax-coding-plan/MiniMax-M3 --mode plan \
+  --thinking on --cwd "$ROOT" --wait-timeout 10m \
+  --label role=reviewer "<review prompt>"
+```
+
+## Structured Verdict Capture
+
+For loop judgment stages, prefer `factory_paseo_grader_run`; it wraps
+`paseo run --output-schema --json --wait-timeout`, labels the run with the
+continuation id, and recovers the actual model for `loop_grader_verdict`.
+
+When direct CLI dispatch is required:
+
+```bash
+paseo run --provider <provider> --model <model-id> --mode <review-mode> \
+  --output-schema <verdict-schema.json> --json \
+  --label continuation=<continuationId> --cwd "$ROOT" "<grader prompt>"
+```
+
+Then recover provenance:
+
+```bash
+paseo ls -a --label continuation=<continuationId> --json
+paseo inspect <agent-id> --json
+```
+
+Relay `graderModelActual` exactly as resolved. A claimed GO without the actual
+model is weak evidence.
+
+## Model Choice
+
+Use model-distinct reviewers. For risky decisions, prefer vendor-distinct too.
+
+- Routine judgment: MiniMax M3 (`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) or Kimi K2.7.
+- Strong single advisor or grader: Claude Opus 4.8 when the executor is Codex;
+  GPT-5.6 Sol with `--thinking high` when the executor is Claude/Sonnet;
+  MiniMax/Kimi when cost or breadth matters.
+- Heavyweight implementation and planning: GPT-5.6 Terra. Lightweight focused
+  execution and exploration: GPT-5.6 Luna.
+- Committee: launch two contrasting models. Default strong pair is Claude Opus
+  4.8 plus GPT-5.6 Terra. For a cost-sensitive or extra-breadth committee, use Kimi
+  K2.7 plus MiniMax M3, or add them as extra reviewers.
+- Never grade with the exact executor model/session. If distinct reviewers are
+  unavailable, stop or state reduced diversity loudly.
+
+## Operating Rules
+
+- Use `--label` for traceability: `role=...`, `workItem=...`, `continuation=...`.
+- Use `--wait-timeout` for synchronous review requests; otherwise detach and let
+  Paseo notify on finish.
+- Do not poll running agents. Use `paseo attach <id>` only when live output is
+  needed.
+- Do not restart the Paseo daemon to unstick a run; it kills active agents.
+- Do not confuse implementation modes with review modes. A read-only reviewer in
+  `auto-review` or `auto` is still read-only because of its prompt and role.

package/extensions/enact-loop/scripts/validate.mjs

@@ -113,6 +113,35 @@ if (!existsSync(join(root, skillPath))) {
   }
 }
 
+const intakeSkillPath = "skills/loop-intake/SKILL.md";
+if (!existsSync(join(root, intakeSkillPath))) {
+  fail(`${intakeSkillPath} is missing`);
+} else {
+  const intake = readFileSync(join(root, intakeSkillPath), "utf8");
+  if (!/^name:\s*loop-intake\s*$/m.test(intake)) {
+    fail(`${intakeSkillPath} frontmatter must declare name: loop-intake`);
+  }
+  if (!/approvalRequired/i.test(intake) || !/MUST NOT call `loop_start`/.test(intake)) {
+    fail(`${intakeSkillPath} must require approval and prohibit loop_start`);
+  }
+  if (!/loop_operations_snapshot/.test(intake)) {
+    fail(`${intakeSkillPath} must use the read-only operations projection`);
+  }
+}
+
+const budgetSkillPath = "skills/loop-budget/SKILL.md";
+if (!existsSync(join(root, budgetSkillPath))) {
+  fail(`${budgetSkillPath} is missing`);
+} else {
+  const budget = readFileSync(join(root, budgetSkillPath), "utf8");
+  if (!/^name:\s*loop-budget\s*$/m.test(budget)) {
+    fail(`${budgetSkillPath} frontmatter must declare name: loop-budget`);
+  }
+  if (!/loop_operations_snapshot/.test(budget) || !/unavailable/i.test(budget)) {
+    fail(`${budgetSkillPath} must use the operational projection and preserve unavailable host-token truth`);
+  }
+}
+
 if (failures.length > 0) {
   for (const failure of failures) {
     console.error(`[enact-loop validate] ${failure}`);

package/extensions/enact-loop/skills/enact-loop/SKILL.md

@@ -38,7 +38,7 @@ Stage {
   name: string
   type: 'mechanical' | 'judgment'
   required: boolean
-  requires?: string[]   # stage ids that must pass before this stage runs
+  requires?: string[]   # stage ids that must pass before this stage may run or dispatch
   command?: string        # mechanical stages only
   grader?: GraderSpec     # judgment stages only
   passCriteria?: string
@@ -111,13 +111,12 @@ idle → running → verifying → completed (terminal)
 1. Read current state: `loop_status`
 2. If no active loop, start one:
    ```
-   loop_start  goal="<goal>"  preset=<preset>|contract=<stages JSON>
+   loop_start  goal="<goal>"  contract=<stages JSON>
    ```
-   Built-in presets: `frontend-ui` (5 mechanical: lint/typecheck/test/build/visual,
-   then **two** judgment stages — `code-review` **and** `verify` — the shape that
-   reliably catches both correctness and acceptance defects), `docs` (mechanical +
-   one lighter `review`), plus `docs-workflow` / `custom-pipeline`. Use a preset to
-   get the right judgment shape by default instead of hand-authoring stages.
+   If you want a named delivery shape such as `frontend-ui` or `docs-workflow`,
+   build an explicit contract from the factory-owned profile catalog first.
+   Legacy runtime preset compatibility may still exist for migration, but profile
+   ownership belongs to `enact-factory`, not `enact-loop`.
 3. Implement the work while in phase `running`.
 4. Advance to verification:
    ```
@@ -192,9 +191,9 @@ The independence rule is checked by model identity, not by vendor or surface nam
 runs the same underlying model. The engine will emit `grader-independence-missing` and
 block closure. Ensure the resolved `grader.model` differs from the executor's model string.
 
-**Default cheap graders:** **minimax M3** (opencode) and **kimi K2.7** are vendor-distinct from
+**Default cheap graders:** **MiniMax M3** (`minimax-coding-plan/MiniMax-M3`, always `--thinking on`) and **kimi K2.7** are vendor-distinct from
 both sonnet and codex, making them always-independent defaults (~80% of grading). Escalate to
-**opus 4.8** or **gpt-5.5** for high-risk judgment (a11y / visual / security / architecture).
+**opus 4.8** or **GPT-5.6 Sol High** for high-risk judgment (a11y / visual / security / architecture).
 `cursor` is only distinct when the executor is opus-tier (cursor runs claude-sonnet).
 
 ### fallbackModels rotation on spawn failure (529 / overload)
@@ -270,7 +269,8 @@ verdict fingerprints.
 
 Each verdict is stamped with a worktree fingerprint. When the workspace changes (e.g. after
 retarget or filesystem drift), stale `passed` verdicts are invalidated (`BLOCKER_FILESYSTEM_STATE_CHANGED`).
-`loop_retarget` preserves verdicts only when `id + type + worktreeFingerprint` match unchanged stages.
+`loop_retarget` preserves verdicts only when `id + type + stage definition + worktreeFingerprint`
+still match unchanged stages.
 
 ## Workspace root resolution
 
@@ -353,7 +353,7 @@ last message) to decide the next action after the loop completes.
 
 | Tool | Purpose |
 |------|---------|
-| `loop_start` | Start loop with goal + contract/preset; stamps executorIdentity |
+| `loop_start` | Start loop with goal + explicit contract; stamps executorIdentity |
 | `loop_status` | Read current loop state |
 | `loop_advance` | Phase transition |
 | `loop_grade` | Run a mechanical stage command in loop root; args: `stageId`, optional `timeoutMs` |

package/extensions/enact-loop/skills/loop-budget/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: loop-budget
+description: This skill should be used when inspecting enact-loop budget status, execution limits, host token availability, 80 percent warnings, exhausted budgets, or why a loop will not run another command or grader.
+---
+
+# Enact Loop Budget
+
+Use this skill to inspect and explain an existing loop's execution budget. It is an operational-read path, not a loop driver.
+
+## Safety boundary
+
+- Read state only through `loop_operations_snapshot` or `enact-loop operations --json`.
+- NEVER edit `~/.enact/` files directly.
+- MUST NOT call `loop_start`, `loop_grade`, `loop_grader_dispatch`, `loop_advance`, `loop_retarget`, `loop_complete`, `loop_block`, `loop_abort`, `loop_pause`, or `loop_resume`.
+- Do not invent host-reported token use. If `hostReportedTokens.availability` is `unavailable`, report exactly that a trusted host usage adapter is not configured.
+
+## Read and report
+
+1. Call `loop_operations_snapshot` from the loop workspace. If MCP is unavailable, run `enact-loop operations --json` from that workspace.
+2. Report the loop id, phase, goal, ledger entry count, and latest event kind.
+3. For each budget counter, preserve its status exactly:
+   - `unbounded`: no configured cap.
+   - `normal`: below 80% of a configured cap.
+   - `warning`: at least 80% used but not exhausted.
+   - `exhausted`: the cap is reached; the next matching mechanical command or grader dispatch is refused.
+4. Separate engine-observed counters from host-owned data. Mechanical attempts and grader dispatches are durable runtime facts. Host tokens remain unavailable unless a future trusted adapter attests them.
+5. Recommend an explicit, human-approved next action; do not execute it in this skill.
+
+## Contract fields
+
+An execution contract may declare:
+
+```yaml
+executionBudget:
+  maxMechanicalAttempts: 3       # per mechanical stage; 0 is an explicit no-op
+  maxTotalMechanicalAttempts: 8  # total engine-run mechanical commands; 0 is an explicit no-op
+  maxTotalGraderDispatches: 2    # total host grader launches; 0 is an explicit no-op
+```
+
+At 80% the projection warns. At 100% the runtime refuses the next matching action. A zero cap is a deliberate no-op, never an inferred lack of data.

package/extensions/enact-loop/skills/loop-intake/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: loop-intake
+description: This skill should be used when triaging ambiguous work, an issue, CI failure, or PR into a proposed enact-loop contract and readiness report before any execution loop is approved.
+---
+
+# Enact Loop Intake
+
+Turn incoming work into a report-only readiness assessment and a proposed contract. This skill plans; it does not start, mutate, or drive a loop.
+
+## Hard boundary
+
+- MUST NOT call `loop_start`, `loop_grade`, `loop_grader_dispatch`, `loop_advance`, `loop_retarget`, `loop_complete`, `loop_block`, `loop_abort`, `loop_pause`, or `loop_resume`.
+- MUST NOT edit `~/.enact/`, create a state file, change a factory board, modify a worktree, or run a mutating command.
+- MAY call `loop_operations_snapshot`, `loop_status`, `enact-loop operations --json`, and other read-only inspection commands.
+- Every result ends with `approvalRequired: true`. A proposed contract is not approval to execute it.
+
+## Intake procedure
+
+1. Capture the request verbatim: desired outcome, affected workspace, constraints, deadline/risk, and available evidence (issue, CI log, PR, or reproduction).
+2. Inspect only the named workspace and any existing loop through `loop_operations_snapshot` or `loop_status`. If an active loop exists, report its id/phase and do not replace or retarget it.
+3. Identify unknowns that could change scope, acceptance, risk, or ownership. Ask concise questions instead of assuming those facts.
+4. Produce a proposed contract only when the goal and acceptance evidence are sufficient. Keep mechanical stages executable and evidence-based; use judgment stages only where an independent assessment is genuinely required.
+5. State dependencies, blockers, expected evidence, and the suggested budget. Set every budget cap deliberately; use `0` only for an explicit no-op.
+
+## Required report shape
+
+```yaml
+intake:
+  outcome: ready | needs-clarification | blocked | active-loop-present
+  scope: <one sentence>
+  evidence: [<facts inspected>]
+  openQuestions: [<questions>]
+  risks: [<risks>]
+  proposedContract: <contract object or null>
+  approvalRequired: true
+  proposedNextAction: <human approval or clarification only>
+```
+
+When `outcome` is not `ready`, set `proposedContract: null`. When it is ready, return the contract in the report only; do not write it to disk or invoke any loop lifecycle tool.
+
+## Contract checklist
+
+- Unique stage ids and an acyclic `requires` graph.
+- Required mechanical stages have a resolvable command and a concrete pass criterion.
+- Judgment stages name a model distinct from the executor and specify the needed number of rounds.
+- `executionBudget` includes only deliberate limits: per-stage mechanical attempts, total mechanical attempts, and total grader dispatches.
+- Host token data is not part of the proposal unless a trusted host adapter is explicitly available; otherwise mark it unavailable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amsterdamdatalabs/enact-extensions",
-  "version": "0.1.37",
+  "version": "0.1.42",
   "description": "Create and validate Enact multi-platform plugin manifests",
   "license": "UNLICENSED",
   "type": "module",

package/scripts/enact-extensions.mjs

@@ -5,7 +5,7 @@ import { listBundles } from "./lib/list-bundles.mjs";
 import { buildIndex } from "./lib/build-index.mjs";
 import { runValidate } from "./lib/run-validate.mjs";
 import { runSync } from "./lib/run-sync.mjs";
-import { runInstall } from "./lib/run-install.mjs";
+import { INSTALL_DRY_RUN_UNSUPPORTED_MESSAGE, runInstall } from "./lib/run-install.mjs";
 import { runUpdate } from "./lib/run-update.mjs";
 import { runPrune } from "./lib/run-prune.mjs";
 import { runUninstall } from "./lib/run-uninstall.mjs";
@@ -66,6 +66,7 @@ Usage:
   enact-extensions install [path|name] --platform shared   Install skills to host-neutral .agents/skills/
   enact-extensions install [path|name] --platform all      Install to every plugin platform (codex, claude, cursor, enact)
   enact-extensions install [path|name] --platform claude,cursor   Install to a subset of platforms
+  enact-extensions install [path|name] --dry-run           Unsupported; exits non-zero without writing anything
   enact-extensions install [path|name] --global            Install into the default agent home (default)
   enact-extensions install [path|name] --local             Install into a project home under cwd (./.codex, ...)
   enact-extensions uninstall [path|name]                   Uninstall plugin from Codex-compatible homes (default: enact)
@@ -932,8 +933,8 @@ if (command === "serve") {
 //
 // Currently supported sub-commands:
 //   enact-extensions hook session-start
-//     Runs the advisory drift-check and prints a single line only when plugin
-//     surfaces are outdated.
+//     Runs the advisory drift-check and prints valid hook JSON only when plugin
+//     surfaces are outdated or auto-updated.
 //   enact-extensions hook user-prompt-submit
 //     Reads a UserPromptSubmit hook payload from stdin, extracts the prompt,
 //     builds the skill catalog from the bundled extensions dir, routes the
@@ -962,12 +963,12 @@ if (command === "hook") {
   (async () => {
     if (subCommand === "session-start") {
       try {
-        const { handleSessionStartDrift } = await import("./lib/auto-update.mjs");
+        const { handleSessionStartDrift, sessionStartHookJson } = await import("./lib/auto-update.mjs");
         // Opt-in is the USER's: gate auto-apply on the env var they set.
         const autoApply = !!process.env.ENACT_EXTENSIONS_AUTO_UPDATE;
         const result = handleSessionStartDrift({ autoApply });
         if (result.line) {
-          process.stdout.write(`${result.line}\n`);
+          process.stdout.write(`${sessionStartHookJson(result.line)}\n`);
         }
       } catch {
         // Fail-silent for session-start hooks.
@@ -1085,6 +1086,10 @@ try {
   }
 
   if (command === "install") {
+    if (options.dryRun) {
+      console.error(INSTALL_DRY_RUN_UNSUPPORTED_MESSAGE);
+      process.exit(1);
+    }
     // Single global ledger: every install (local or global scope) records to
     // <homedir>/.enact/extensions/ledger.jsonl so `log` always finds it,
     // regardless of which per-platform home the bundle was installed to. The

package/scripts/hooks/session-start-drift-check.mjs

@@ -12,7 +12,8 @@
  *   - FAIL-SILENT: wrap everything in try/catch; never throw; always exit 0.
  *   - FAST: imports the helper directly (no subprocess) for speed.
  *   - READ-ONLY by default: only mutates state when the user opts into auto-apply.
- *   - NO OUTPUT on success (or error): only print when there are outdated entries.
+ *   - NO OUTPUT on success (or error): only print valid hook JSON when there
+ *     are outdated entries.
  *   - DEPENDENCY-FREE: only node builtins + enact-extensions own modules.
  */
 
@@ -25,7 +26,7 @@ const REPO_ROOT = resolve(__dirname, "..", "..");
 
 try {
   // Dynamically import so any module-load failure is caught by the outer try/catch.
-  const { handleSessionStartDrift } = await import(join(REPO_ROOT, "scripts", "lib", "auto-update.mjs"));
+  const { handleSessionStartDrift, sessionStartHookJson } = await import(join(REPO_ROOT, "scripts", "lib", "auto-update.mjs"));
 
   // Opt-in is the USER's: gate auto-apply on the env var they set.
   const autoApply = !!process.env.ENACT_EXTENSIONS_AUTO_UPDATE;
@@ -39,7 +40,7 @@ try {
   }
 
   if (result.line) {
-    process.stdout.write(`${result.line}\n`);
+    process.stdout.write(`${sessionStartHookJson(result.line)}\n`);
   }
 } catch {
   // Any top-level error (import failure, parse error, etc.) — silent exit 0.

package/scripts/lib/auto-update.mjs

@@ -3,13 +3,14 @@
  * auto-apply when opted in via ENACT_EXTENSIONS_AUTO_UPDATE.
  *
  * Single export:
- *   handleSessionStartDrift({ autoApply, home, cwd }) → { outdated, applied, updated, line }
+ *   handleSessionStartDrift({ autoApply, home, cwd }) -> { outdated, applied, updated, line }
+ *   sessionStartHookResponse(line) -> valid hook JSON response object
  *
  * Behaviour:
  *   - Compute the outdated (drifted) surfaces from the ledger vs canonical source.
  *   - No outdated surfaces           → { outdated: [], applied: false, line: null }.
  *   - Outdated + autoApply=false     → advisory line (default; mutates nothing).
- *   - Outdated + autoApply=true      → runUpdate({ all: true }); summary line naming
+ *   - Outdated + autoApply=true      → runUpdate({ all: true, silent: true }); summary line naming
  *                                      what was refreshed. If the refresh updated
  *                                      nothing actionable (e.g. all orphaned), fall
  *                                      back to the advisory line.
@@ -43,6 +44,18 @@ export function autoUpdateSummaryLine(updated) {
   );
 }
 
+/** Convert a drift advisory/update line into valid SessionStart hook JSON. */
+export function sessionStartHookResponse(line) {
+  const response = { continue: true };
+  if (line) response.systemMessage = line;
+  return response;
+}
+
+/** JSON-string form for command hooks that write their response to stdout. */
+export function sessionStartHookJson(line) {
+  return JSON.stringify(sessionStartHookResponse(line));
+}
+
 /**
  * Resolve SessionStart drift: advise by default, or auto-apply when opted in.
  *
@@ -62,7 +75,7 @@ export function handleSessionStartDrift({ autoApply, home, cwd } = {}) {
   }
 
   if (autoApply) {
-    const summary = runUpdate({ all: true, home, cwd });
+    const summary = runUpdate({ all: true, silent: true, home, cwd });
     const updated = summary?.updated ?? [];
     if (updated.length === 0) {
       // Nothing actionable was refreshed (e.g. orphaned source) — advise instead.

package/scripts/lib/run-install.mjs

@@ -17,6 +17,9 @@ import { provisionMcp, summarizeProvision } from "./provision-mcp.mjs";
 import { registerPluginHooks, removeHook, removePluginHooks } from "./hooks.mjs";
 import { assertSupportedHookEvents } from "../../dist/index.js";
 
+export const INSTALL_DRY_RUN_UNSUPPORTED_MESSAGE =
+  "install --dry-run is not supported. No changes were made.";
+
 // scope: "global" (default) -> the agent's default home (~/.codex, ~/.enact/agent, ~/.claude, ~/.cursor, ~/.agents)
 //        "local"            -> a project-scoped home under the current dir (./.codex, ./.enact/agent, ...)
 // An explicit --<platform>-home always wins over the scope default.
@@ -439,6 +442,10 @@ function runProvision(pluginRoot, options) {
 }
 
 export function runInstall(pluginRoot, options = {}) {
+  if (options.dryRun) {
+    throw new Error(INSTALL_DRY_RUN_UNSUPPORTED_MESSAGE);
+  }
+
   // Refuse to install a bundle that declares hook events outside the
   // cross-surface intersection (claude, codex, cursor, enact).
   assertSupportedHookEvents(pluginRoot);

package/scripts/lib/run-update.mjs

@@ -2,7 +2,7 @@
  * run-update.mjs — refresh installed plugins that have drifted from their
  * canonical source bundle.
  *
- * runUpdate({ name?, all?, dryRun?, home?, cwd? }) → summary
+ * runUpdate({ name?, all?, dryRun?, home?, cwd?, silent? }) → summary
  *
  * The update is driven ENTIRELY by the ledger, per (plugin, surface, home):
  *
@@ -80,11 +80,12 @@ function safeResolveBundlePath(name, cwd) {
  * @param {string} [opts.name]   — restrict to a single plugin name.
  * @param {boolean} [opts.all]   — update every outdated surface.
  * @param {boolean} [opts.dryRun]— report only; make no changes.
+ * @param {boolean} [opts.silent]— suppress install stdout during refresh.
  * @param {string} [opts.home]   — ledger home override (defaults to os.homedir()).
  * @param {string} [opts.cwd]    — working dir for canonical bundle resolution.
  * @returns {{ planned: object[], updated: object[], skipped: object[], failed: {entry: object, error: Error}[], dryRun: boolean }}
  */
-export function runUpdate({ name, all, dryRun, home, cwd } = {}) {
+export function runUpdate({ name, all, dryRun, silent, home, cwd } = {}) {
   const resolvedHome = home ?? homedir();
   const resolvedCwd = cwd ?? processCwd();
 
@@ -131,17 +132,29 @@ export function runUpdate({ name, all, dryRun, home, cwd } = {}) {
 
     const homeOption = PLATFORM_HOME_OPTION[entry.platform] ?? "codexHome";
     try {
-      runInstall(canonicalPath, {
-        platform: entry.platform,
-        scope: entry.scope,
-        [homeOption]: entry.home,
-        ledgerHome: resolvedHome,
-        // Refresh the already-installed surface only; do not regenerate source
-        // manifests, and skip MCP provisioning (a refresh re-installs identical
-        // package deps — provisioning is best-effort and not needed here).
-        sync: false,
-        noProvision: true,
-      });
+      const install = () =>
+        runInstall(canonicalPath, {
+          platform: entry.platform,
+          scope: entry.scope,
+          [homeOption]: entry.home,
+          ledgerHome: resolvedHome,
+          // Refresh the already-installed surface only; do not regenerate source
+          // manifests, and skip MCP provisioning (a refresh re-installs identical
+          // package deps — provisioning is best-effort and not needed here).
+          sync: false,
+          noProvision: true,
+        });
+      if (silent) {
+        const originalLog = console.log;
+        try {
+          console.log = () => {};
+          install();
+        } finally {
+          console.log = originalLog;
+        }
+      } else {
+        install();
+      }
       updated.push(entry);
     } catch (err) {
       failed.push({ entry, error: err instanceof Error ? err : new Error(String(err)) });