v0.12.0: user-owned flows and model adapters

.claude-plugin/marketplace.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-marketplace.json",
   "name": "meridian",
-  "description": "Research-first workflows, ruthless code review, and orchestrator-led reasoning for Claude Code.",
+  "description": "Professional engineering discipline with user-owned workflows and model-specific corrections.",
   "owner": {
     "name": "KodingDev"
   },
   "plugins": [
     {
       "name": "meridian",
-      "description": "Research-first workflows, ruthless code review, orchestrator-led reasoning, and opaque subagent isolation for the entire development lifecycle.",
+      "description": "Professional engineering discipline with user-owned workflows and model-specific corrections.",
       "source": "./",
       "category": "development",
-      "homepage": "https://github.com/KodingDev/claude-plugins"
+      "homepage": "https://github.com/KodingDev/meridian"
     }
   ]
 }

.claude-plugin/plugin.json

@@ -1,13 +1,13 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "meridian",
-  "description": "Research-first workflows, ruthless code review, orchestrator-led reasoning, and opaque subagent isolation for the entire development lifecycle.",
-  "version": "0.11.3",
+  "description": "Professional engineering discipline with user-owned workflows and model-specific corrections.",
+  "version": "0.12.0",
   "author": {
     "name": "KodingDev"
   },
-  "homepage": "https://github.com/KodingDev/claude-plugins",
-  "repository": "https://github.com/KodingDev/claude-plugins",
+  "homepage": "https://github.com/KodingDev/meridian",
+  "repository": "https://github.com/KodingDev/meridian",
   "license": "MIT",
-  "keywords": ["workflows", "code-review", "research", "quality", "debugging"]
+  "keywords": ["engineering", "workflows", "quality", "research", "debugging"]
 }

.cursor-plugin/plugin.json

@@ -1,14 +1,14 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "meridian",
-  "description": "Research-first workflows, ruthless code review, orchestrator-led reasoning, and opaque subagent isolation for the entire development lifecycle.",
-  "version": "0.11.3",
+  "description": "Professional engineering discipline with user-owned workflows and model-specific corrections.",
+  "version": "0.12.0",
   "author": {
     "name": "KodingDev"
   },
-  "homepage": "https://github.com/KodingDev/claude-plugins",
-  "repository": "https://github.com/KodingDev/claude-plugins",
+  "homepage": "https://github.com/KodingDev/meridian",
+  "repository": "https://github.com/KodingDev/meridian",
   "license": "MIT",
-  "keywords": ["workflows", "code-review", "research", "quality", "debugging"],
+  "keywords": ["engineering", "workflows", "quality", "research", "debugging"],
   "hooks": "./hooks/hooks-cursor.json"
 }

.github/scripts/eval-summary.mjs

@@ -8,7 +8,7 @@ const result = JSON.parse(readFileSync(process.argv[2], "utf8"));
 const rows = result.results?.results ?? result.results ?? [];
 
 let passed = 0;
-const lines = ["| | Prompt | Routed to | Expected |", "|---|---|---|---|"];
+const lines = ["| | Prompt | Skill used | Expected |", "|---|---|---|---|"];
 for (const row of rows) {
   const prompt = String(row.vars?.prompt ?? "")
     .replace(/\|/g, "\\|")
@@ -20,5 +20,5 @@ for (const row of rows) {
   lines.push(`| ${row.success ? "✅" : "❌"} | ${prompt} | \`${got}\` | \`${want}\` |`);
 }
 
-console.log(`## Routing eval — ${passed}/${rows.length} passed\n`);
+console.log(`## Invocation-boundary eval — ${passed}/${rows.length} passed\n`);
 console.log(lines.join("\n"));

.github/workflows/eval.yml

@@ -1,4 +1,4 @@
-name: Routing eval
+name: Invocation-boundary eval
 
 # On-demand only — never on push/PR. Needs the ANTHROPIC_API_KEY secret and makes
 # paid API calls, so it is not a merge gate.
@@ -10,7 +10,7 @@ permissions:
 
 jobs:
   eval:
-    name: Skill-routing eval
+    name: Invocation-boundary eval
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -21,7 +21,7 @@ jobs:
           cache: pnpm
       - name: Install dev tooling
         run: pnpm install --frozen-lockfile
-      - name: Run routing eval
+      - name: Run invocation-boundary eval
         id: eval
         continue-on-error: true
         env:
@@ -34,6 +34,6 @@ jobs:
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: routing-eval-report
+          name: invocation-boundary-eval-report
           path: eval-report.html
           if-no-files-found: warn

.plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "meridian",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "hooks": "./hooks/hooks-copilot.json"
 }

CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to Meridian are recorded here. The format follows
 to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). History before
 0.11.0 lives in the git log.
 
+## [0.12.0] - 2026-07-13
+
+### Added
+
+- A model-independent professional engineering standard and atomic model adapters selected from named profiles at session start.
+- Manual-invocation policy for formal flows across Claude Code, Cursor, Copilot, and Codex skill metadata.
+- Optional project-instruction sections for customer security, compliance, verification, deployment, rollback, artifacts, and allowed environments.
+
+### Changed
+
+- Formal `brainstorm`, `sketch`, `execute`, `review`, `commit`, `document`, and `auto` flows are user-owned. They no longer invoke one another automatically or repeat approval already granted by invocation.
+- `debug`, `research`, `triangulate`, `delegate`, and `respond` are narrow model-invoked disciplines with risk-proportionate process.
+- `execute` performs proportionate verification but no longer launches formal review or commit flows.
+- Formal review enumerates tracked and untracked working-tree changes before dispatching independent lenses.
+- Interactive flows use structured question tools when available and fall back to plain text on hosts without them.
+
+### Removed
+
+- The forced Meridian output style, automatic workflow routing table, periodic routing audit, terse-failure reroute, and their session state machinery.
+
 ## [0.11.3] - 2026-07-06
 
 ### Added

README.md

@@ -1,78 +1,118 @@
 # Meridian
 
-Claude Code plugin for development workflows that don't fall apart in long sessions.
+Professional engineering discipline without taking ownership of your workflow.
 
-## Why
+Meridian gives coding agents one model-independent quality standard, lets projects supply their own customer and repository policy, and applies small model-specific corrections where a model has a repeatable failure mode. It does not route ordinary requests into mandatory planning, review, documentation, or commit pipelines.
 
-[Superpowers](https://github.com/obra/superpowers) is great. Skill-based workflows, iterative spec review, subagent-driven development — all genuinely good ideas that I used for a long time. But some patterns kept showing up that I wanted to fix:
+## How it works
 
-Agents get confident in their own prior reasoning. If you review code, fix stuff, then review again — the second pass comes back suspiciously clean. The agent's own reasoning from the first review is right there in context, and it can't really fathom that it missed something when its own thoughts are telling it everything was fine. Meridian isolates review subagents so the orchestrator only ever sees defects and a verdict, not the reviewer's internal reasoning.
+Meridian has four layers:
 
-They trust their training data way too much. Confidently writing code against APIs that have changed, using library features that don't work the way they remember — then wasting ages debugging when a quick docs check would've caught it upfront. Meridian verifies external APIs against live documentation before writing code.
+1. **Professional engineering standard** — shared expectations for correctness, evidence, security, maintainability, operability, delivery hygiene, user agency, proportionality, and stopping.
+2. **Project policy** — your `CLAUDE.md`, `AGENTS.md`, and repository instructions define customer, compliance, tooling, deployment, rollback, and artifact requirements.
+3. **Model adapters** — atomic corrections for observable quirks such as comment narration or recursive reviewing. They change steering, never the quality bar or authorization.
+4. **Skills** — formal flows are user-owned; narrow engineering disciplines can be selected by the model inside an ordinary task.
 
-Skill systems can be too rigid. Not everything needs the full brainstorm -> plan -> execute pipeline. Changing a button color shouldn't require a design spec. Meridian uses judgment about what warrants ceremony and what just needs doing.
+The result is deliberately asymmetric: different models may receive different corrective wording, but every model owes the same professional outcome.
 
-Agents commit stuff you didn't ask for. Spec files staged automatically, AI attribution in every message, design docs forced past your gitignore. Meridian doesn't commit anything without asking, doesn't stage spec files, and doesn't put "Co-Authored-By: Claude" in your commits.
+## Skills
 
-They don't push back enough. If you ask for something that'll cause problems, the agent should say so — with evidence and actual alternatives, each with an honest case made for it. And once you've picked a direction, it should go all in, not half-ass it and relitigate in review.
+### User-invoked flows
 
-Hard-won knowledge dies with the session. You debug something for two hours, nail the root cause, and next session the agent suggests the exact approach you already ruled out. Meridian has a documentation skill for capturing gotchas, debugging context, and "we already tried this" notes so future sessions don't start from scratch.
+These run only when you invoke them. One flow never silently enrolls you in another.
 
-## Skills
+| Skill | Purpose |
+| --- | --- |
+| `brainstorm` | Develop an idea into an approved implementation spec |
+| `sketch` | Produce a lightweight contract for a small change |
+| `execute` | Implement an approved spec or clear scope with proportionate verification |
+| `review` | Perform a focused, report-only code review |
+| `commit` | Create one clean, narrowly staged commit |
+| `document` | Capture requested durable engineering knowledge |
+| `auto` | Grant elevated autonomy for reversible, in-scope work |
 
-| Skill | Does |
-|-------|------|
-| `research` | Verify APIs/libs against live docs before implementing |
-| `brainstorm` | Design exploration -> spec through conversation |
-| `sketch` | Lightweight spec for a small, well-scoped fix |
-| `execute` | Implement from spec with verification gates |
-| `delegate` | Dispatch subagents with clean context isolation |
-| `debug` | Root-cause investigation, no fixes without understanding |
-| `review` | Code review via isolated subagent |
-| `respond` | Evaluate review feedback before acting on it |
-| `commit` | Clean git commits, no AI attribution |
-| `document` | Human-readable docs from resolved work |
+Invoking a flow authorizes its ordinary documented behavior. Separate approval is still required for destructive operations, unrequested external effects, material scope expansion, and unresolved high-cost choices.
 
-Two more compose with these rather than standing alone: `triangulate` (a verification lens that grounds specific-value claims against their source) and `auto` (a modifier that runs any task autonomously when you step away). Routing lives in the session orientation injected at startup — there is no separate router skill.
+### Model-invoked disciplines
 
-## What gets installed
+These are narrow internal tools, not workflow gates:
 
-- A `Meridian` output style applied automatically while the plugin is enabled (overrides any `/output-style` selection while loaded). It carries the durable principles — three pillars, voice, commit-attribution override, the challenge protocol — directly in the system prompt rather than relying on per-turn reminders.
-- A session-start hook that injects the routing table and active-mode triggers as a quiet system reminder at the start of every session, so the orientation is felt rather than announced.
-- The skills below, dispatched by judgement against the routing table.
+| Skill | Purpose |
+| --- | --- |
+| `debug` | Diagnose failures from evidence before fixing them |
+| `research` | Verify unstable external behavior against primary sources |
+| `triangulate` | Escalate contested or load-bearing claims beyond one source |
+| `delegate` | Isolate genuinely independent or context-heavy work |
+| `respond` | Evaluate review feedback while preserving user intent |
 
-## Install
+## Model profiles
 
-### Claude Code
+At session start Meridian injects the professional standard followed by the adapters for the resolved profile. Resolution order is:
+
+1. `MERIDIAN_MODEL_PROFILE`
+2. exact model identifier
+3. registered model-family prefix
+4. host-local fallback
+5. baseline standard only
+
+Initial profiles are:
 
+| Profile | Adapters |
+| --- | --- |
+| `opus-4.8` | comment narration, artifact overproduction |
+| `sol` | review recursion, depth escalation, workflow literalism, agreement seeking |
+| `fable` | none |
+
+Only model identifiers observed from host payloads or documented by the host are mapped automatically. Unknown models receive the baseline rather than a guessed profile.
+
+Set a host-local fallback in `<state-base>/meridian/config.json`:
+
+```json
+{
+  "fallbackProfile": "sol"
+}
 ```
+
+The state base is host-specific, such as `CODEX_HOME` for Codex. GitHub Copilot does not currently expose a model identifier in its documented session-start payload, so use the environment override or fallback there.
+
+## Installation
+
+### Claude Code
+
+```text
 /plugin marketplace add KodingDev/meridian
 /plugin install meridian@meridian
 ```
 
 ### Cursor
 
-Install from the [Cursor plugin marketplace](https://cursor.com/marketplace), or enable **Third-party skills** in Cursor Settings → Features if you use the Claude plugin bundle.
+Install Meridian from the Cursor plugin marketplace, or enable third-party skills and install the Claude plugin bundle.
 
-Hooks are Node scripts (`node ./hooks/*.mjs`) — no Git Bash or shell polyglot required. Session orientation injects via `additional_context` on `sessionStart`. If hooks fail silently, check View → Output → **Hooks** and restart Cursor after updating the plugin.
+### GitHub Copilot CLI and Codex
 
-### GitHub Copilot CLI
+Install the same plugin bundle through the host's plugin support. Meridian ships host-specific hook manifests where their schemas differ. The session hook is read-only context composition; the existing pre-tool commit guard still blocks AI attribution and staging ignored `.meridian/` working artifacts where supported.
 
-Copilot CLI installs the same plugin via its `/plugin` commands and loads the skills and subagents directly. Copilot resolves the Claude subagent tool names as compatible aliases — `Read`, `Grep`, `Glob`, `Bash` map to its `view`, `grep`, `glob`, `bash` tools — so file, search, and shell access carry over unchanged. Its web tool (`web_fetch`) has no Claude-name alias, so the agents that need the web (`research`, `triangulate`) also list `web_fetch` explicitly; otherwise `WebFetch`/`WebSearch` resolve to nothing and the agent silently loses web access.
+## Project policy
 
-Hooks ship in Copilot's own format: Copilot's command schema treats `command` as a shell string and has no `args` array, so the Claude exec-form config would run a bare `node`. Copilot is pointed at `hooks/hooks-copilot.json` via `.plugin/plugin.json` (a manifest slot Copilot reads but Claude and Cursor don't). Session orientation injects via a flat `additionalContext` on `sessionStart`; prompt submission is state-only, because Copilot's `userPromptSubmitted` hook cannot inject context (same ceiling as Cursor).
+Use repository instructions for requirements that vary by customer or environment. The included `templates/CLAUDE.md` provides optional headings for security and compliance, required verification, deployment and rollback, repository artifacts, and allowed tools. Meridian intentionally ships no AWS-, employer-, customer-, or Stella-specific defaults.
 
-### Codex
+## Development
 
-Codex CLI installs the plugin from the same marketplace and loads the plugin's default `hooks/hooks.json` — the same Claude-shaped hook config (event → matcher groups → `{ "type": "command" }`) — sharing Claude's `hookSpecificOutput` context contract. So, unlike Cursor and Copilot, orientation injects on `SessionStart` **and** the routing audit injects on `UserPromptSubmit`, and the commit-attribution `PreToolUse` guard runs. Codex is detected by the un-prefixed `PLUGIN_ROOT` it sets (Claude sets only `CLAUDE_PLUGIN_ROOT`, which Codex also sets as a compat alias); state lives under `CODEX_HOME` (default `~/.codex`). Codex does not honor a plugin-manifest hook redirect ([openai/codex#16430](https://github.com/openai/codex/issues/16430)), so there is no Codex-specific hooks file — the default `hooks/hooks.json` drives it. Plugin hooks install untrusted; run one interactive Codex session to review and trust them, after which they fire automatically.
+```text
+pnpm check
+node --test test/meridian-hooks.test.mjs
+```
 
-Hook tests: `node --test test/meridian-hooks.test.mjs`
+The live evaluation harness is on-demand because it makes paid model calls:
 
-## Credit
+```text
+pnpm eval
+pnpm eval:view
+```
 
-Built on ideas from [superpowers](https://github.com/obra/superpowers) by Jesse Vincent — the skill-based workflow, subagent development, and iterative spec review all come from there. Meridian wouldn't exist without it.
+## Credit
 
-Orchestration approach informed by Anthropic's [context engineering research](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) and the [Claude Certification Guide](https://claudecertificationguide.com).
+Built on ideas from [Superpowers](https://github.com/obra/superpowers) by Jesse Vincent and informed by Matt Pocock's user-invoked/model-invoked skill split.
 
 ## License
 

behavior/adapters/agreement-seeking.md

@@ -0,0 +1,3 @@
+[Meridian model adapter: agreement seeking]
+
+This model tends to use agreement, extra work, or procedural ceremony as a substitute for help. Preferences and intent belong to the user; technical conclusions require independent judgment. State a concise evidence-based disagreement when warranted. Do not add work or validation language merely to appear cooperative.

behavior/adapters/artifact-overproduction.md

@@ -0,0 +1,3 @@
+[Meridian model adapter: artifact overproduction]
+
+This model tends to turn discussion into plans, specs, summaries, and documentation. Discussion remains discussion. Create a durable artifact only when the user requests it or when it is necessary to continue an explicitly chosen multi-session workflow. Do not create artifacts to demonstrate thoroughness.

behavior/adapters/comment-narration.md

@@ -0,0 +1,3 @@
+[Meridian model adapter: comment narration]
+
+This model tends to narrate implementation in comments. Produce zero comments by default. Retain one only when it preserves a hidden constraint, subtle invariant, or specific workaround that cannot be expressed through code structure or naming. Keep it to one short line and never describe the diff or session reasoning.

behavior/adapters/depth-escalation.md

@@ -0,0 +1,3 @@
+[Meridian model adapter: depth escalation]
+
+This model tends to equate available effort with useful depth. Depth follows risk and unresolved uncertainty, not model capacity. Complete the requested outcome at the smallest defensible scope. Stop when the professional standard's completion condition is satisfied; do not invent adjacent work, extra abstractions, or additional analysis to prove diligence.

behavior/adapters/review-recursion.md

@@ -0,0 +1,3 @@
+[Meridian model adapter: review recursion]
+
+This model tends to repeat full reviews after every correction. Use one risk-proportionate review pass when review is part of the request. After addressing findings, run targeted verification over the affected surface. Start another full review only when new evidence or a material design change invalidates the earlier review.