@sayansr26/agent-os 0.6.0 → 0.6.1

package/.claude-plugin/marketplace.json

@@ -22,6 +22,17 @@
         "orchestration",
         "codebase-navigation"
       ]
+    },
+    {
+      "name": "auto-route",
+      "source": "./plugins/auto-route",
+      "description": "Picks the model and effort level for each turn from what the prompt asks for. /route pins a tier or turns routing off.",
+      "category": "productivity",
+      "keywords": [
+        "model-routing",
+        "effort",
+        "mod"
+      ]
     }
   ]
 }

package/CHANGELOG.md

@@ -5,7 +5,25 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.6.0] — 2026-09-25
+## [0.6.1] — 2026-10-21
+
+agent-os plugin unchanged (0.5.0). New plugin auto-route 0.1.0 in the same
+marketplace. 0.7.0 stays reserved for the move to Rulegate.
+
+### Added
+- **auto-route, a second plugin in the `sayan-plugins` marketplace.** A Claude
+  Code mod (a TypeScript hooks module) that picks the model and effort for each
+  turn from what the prompt asks for: lookups to Haiku, regular coding to
+  Sonnet, design and debugging to Opus, "ultrathink" and security work to Opus
+  at max effort. Subagents keep their own model. `/route` shows the route,
+  `/route light|standard|deep|max` pins a tier, `/route off` and `/route auto`
+  switch it off and on. `/plugin install auto-route@sayan-plugins`.
+- **`agent-os init` installs and updates auto-route** at project scope next to
+  agent-os, adding or refreshing the marketplace once. `--no-auto-route` leaves
+  it out; `--no-plugin` still skips both.
+- `scripts/validate-plugin.mjs` checks every other marketplace plugin built
+  from hook modules: manifest, name against its marketplace entry, the types
+  contract and each module it names.
 
 Plugin 0.5.0. Found by running 0.4.1 in a real project: the plugin passed its
 own audit while Claude ignored it — a whole feature was built without the

package/README.md

@@ -140,6 +140,28 @@ Feature directories default to the first of `src/features`, `src/modules`, `app/
 { "targets": ["claude-code"], "claude": { "features": ["src/features/*", "apps/*"], "cartographerReminder": true } }
 ```
 
+### auto-route
+
+A second, independent plugin in the same marketplace: a Claude Code mod (a TypeScript hooks module) that picks the model and effort for each turn from what the prompt asks for — lookups go to Haiku, regular coding to Sonnet, design and debugging to Opus, "ultrathink" and security work to Opus at max effort. Subagents keep their own model.
+
+```
+/plugin install auto-route@sayan-plugins
+```
+
+`agent-os init` installs and updates it alongside agent-os, at project scope; `--no-auto-route` leaves it out.
+
+`/route` shows the current route; `/route light|standard|deep|max` pins a tier, `/route off` hands control back to the session's own model, `/route auto` resumes routing. The tier table and the prompt rules sit at the top of `plugins/auto-route/hooks/register.ts`.
+
+Working on it:
+
+```sh
+claude --plugin-dir plugins/auto-route     # run a session with the working copy, hot-reloaded
+claude plugin validate plugins/auto-route  # what the engine would refuse
+claude plugin test plugins/auto-route      # tests/route.test.ts
+```
+
+Once the engine loads it, it writes `.claude-plugin/types/` (git-ignored) for the editor; `tsc -p plugins/auto-route` type-checks it after that. Bump `version` in its `plugin.json` when shipping a change so installs update.
+
 ---
 
 ## Design rules

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sayansr26/agent-os",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "One source of truth for AI coding agent config. Write your rules once; compile them to Claude Code, Cursor, Cline, Windsurf, Antigravity, Gemini CLI, OpenCode and Kilo.",
   "keywords": [
     "ai",
@@ -46,4 +46,4 @@
     "test": "node scripts/validate-plugin.mjs && node src/selftest.mjs",
     "prepublishOnly": "npm test"
   }
-}
+}

package/plugins/agent-os/.claude-plugin/plugin.json

@@ -8,6 +8,8 @@
   },
   "homepage": "https://github.com/sayansr26/agent-os",
   "repository": "https://github.com/sayansr26/agent-os",
+  "privacyPolicyUrl": "https://s3techpulse.com/privacy-policy",
+  "supportUrl": "https://s3techpulse.com/support",
   "license": "MIT",
   "keywords": [
     "context-engineering",

package/plugins/auto-route/.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "auto-route",
+  "version": "0.1.0",
+  "description": "Picks the model and effort level for each turn from what the prompt asks for",
+  "types": "./types/index.d.ts",
+  "author": {
+    "name": "Sayan Choudhury",
+    "email": "sayan.choudhury.in@gmail.com"
+  },
+  "homepage": "https://github.com/sayansr26/agent-os",
+  "repository": "https://github.com/sayansr26/agent-os",
+  "license": "MIT",
+  "keywords": [
+    "model-routing",
+    "effort",
+    "mod"
+  ]
+}

package/plugins/auto-route/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.ts"] }

package/plugins/auto-route/hooks/register.ts

@@ -0,0 +1,143 @@
+import { atom, read, update } from 'claude-code'
+import type { ModelEffort, Register } from 'claude-code'
+
+import type { Mode, Route, Tier } from '../types'
+
+// Edit this table to change what each tier runs on.
+const TIERS: Record<Tier, { model: string; effort: ModelEffort }> = {
+  light: { model: 'claude-haiku-5-5', effort: 'low' },
+  standard: { model: 'claude-sonnet-5-5', effort: 'medium' },
+  deep: { model: 'claude-opus-5-5', effort: 'high' },
+  max: { model: 'claude-opus-5-5', effort: 'max' },
+}
+
+// Checked top to bottom; the first tier whose pattern matches wins.
+const RULES: { tier: Tier; reason: string; pattern: RegExp }[] = [
+  {
+    tier: 'max',
+    reason: 'asked to think hard',
+    pattern: /\b(ultrathink|think (really )?hard|think harder|deep dive)\b/i,
+  },
+  {
+    tier: 'max',
+    reason: 'security or concurrency',
+    pattern:
+      /\b(security (audit|review)|vulnerabilit|race condition|deadlock|memory leak|incident|data loss)/i,
+  },
+  {
+    tier: 'deep',
+    reason: 'design or debugging',
+    pattern:
+      /\b(architect|design|refactor|migrat|debug|root cause|investigate|why (is|does|doesn't|isn't)|plan|implement|build (a|the|an)|new feature|end[- ]to[- ]end|across|whole (repo|codebase|app)|optimi[sz]e|performance|review)/i,
+  },
+  {
+    tier: 'light',
+    reason: 'small or lookup task',
+    pattern:
+      /^(what|which|where|who|when|is|are|does|do|can|show|list|print|explain briefly|rename|fix (the )?typo|format|lint|bump|commit message|thanks|thank you|ok|yes|no)\b/i,
+  },
+]
+
+export const classify = (text: string): Route => {
+  const words = text.trim().split(/\s+/).filter(Boolean).length
+  const rule = RULES.find(one => one.pattern.test(text))
+
+  if (rule && !(rule.tier === 'light' && words > 40)) {
+    return { tier: rule.tier, reason: rule.reason }
+  }
+
+  if (words > 150) {
+    return { tier: 'deep', reason: 'long, detailed prompt' }
+  }
+
+  return words <= 8
+    ? { tier: 'light', reason: 'short prompt' }
+    : { tier: 'standard', reason: 'regular coding task' }
+}
+
+const MODES: readonly Mode[] = ['auto', 'off', 'light', 'standard', 'deep', 'max']
+
+const mode = atom({ plugin: 'auto-route', key: 'mode' } as const, 'auto')
+const route = atom({ plugin: 'auto-route', key: 'route' } as const, null)
+
+const describe = (current: Mode, last: Route | null) => {
+  if (current === 'off') {
+    return 'auto-route: off'
+  }
+
+  const pinned = current === 'auto' ? '' : ' (pinned)'
+  const tier = current === 'auto' ? last?.tier : current
+
+  if (!tier) {
+    return 'auto-route: waiting for a prompt'
+  }
+
+  const { model, effort } = TIERS[tier]
+
+  return `auto-route: ${tier}${pinned} · ${model.replace(/^claude-/, '')} / ${effort}`
+}
+
+export const register: Register = on => {
+  on('session.start', async ($, e, next) => {
+    await $.command.register({
+      name: 'route',
+      description: 'Auto model routing: auto, off, or pin light | standard | deep | max',
+    })
+
+    return next(e)
+  })
+
+  on('command.run', { command: 'route' }, async ($, e) => {
+    const asked = e.args.trim().toLowerCase()
+
+    if (asked !== '') {
+      const next = MODES.find(one => one === asked)
+
+      if (!next) {
+        return { text: `auto-route: unknown mode "${asked}". Use ${MODES.join(', ')}.` }
+      }
+
+      await update($, mode, () => next)
+    }
+
+    const text = describe(await read($, mode), await read($, route))
+    $.ui.status(text)
+
+    return { text: text.replace(/^auto-route: /, '') }
+  })
+
+  on('prompt.submit', async ($, e, next) => {
+    // A prompt delivered into a running turn keeps that turn's route.
+    const current = await read($, mode)
+    const isRouted = e.turnId === undefined && !e.command && current === 'auto'
+    $.ui.log(`auto-route: prompt.submit mode=${current} turnId=${e.turnId ?? '-'} command=${e.command ? 'yes' : 'no'} routed=${isRouted}`)
+
+    if (isRouted) {
+      const picked = classify(e.text)
+      await update($, route, () => picked)
+      $.ui.status(describe('auto', picked))
+    }
+
+    return next(e)
+  }).catch(($, e, next) => {
+    $.ui.log('auto-route: prompt.submit hook failed')
+
+    return next(e)
+  })
+
+  on('turn.step', async function* ($, e, next) {
+    const current = await read($, mode)
+    const last = await read($, route)
+    const tier = current === 'auto' ? last?.tier : current === 'off' ? undefined : current
+
+    // Subagents choose their own model; leave their requests alone.
+    if (e.agentId !== undefined || !tier) {
+      return yield* next(e)
+    }
+
+    const { model, effort } = TIERS[tier]
+    $.ui.log(`auto-route: turn.step ${e.model}/${e.effort ?? '-'} -> ${model}/${effort}`)
+
+    return yield* next({ ...e, model, effort })
+  })
+}

package/plugins/auto-route/tests/route.test.ts

@@ -0,0 +1,87 @@
+import { expect, test } from 'claude-code/testing'
+import type { HookStream, TurnStepChunk, TurnStepInput, TurnStepResult } from 'claude-code'
+
+import { classify } from '../hooks/register'
+
+const STEP: TurnStepInput = {
+  turnId: 't1',
+  index: 0,
+  model: 'claude-opus-5-5',
+  effort: 'high',
+  messageCount: 1,
+}
+
+const ORIGIN = { kind: 'composer' } as const
+
+const prompt = (text: string) => ({ text, wait: false, origin: ORIGIN })
+
+const route = (args: string) => ({
+  command: 'route',
+  args,
+  origin: ORIGIN,
+  presentation: { isFullscreen: false, columns: 120 },
+})
+
+// Reads the request's stream to its end, as the engine would.
+type Steps = { turn: { step: (e: TurnStepInput) => HookStream<TurnStepChunk, TurnStepResult> } }
+
+const step = async ($: Steps, e: TurnStepInput) => {
+  const stream = $.turn.step(e)
+  for await (const _ of stream) {
+  }
+  return stream.result
+}
+
+test('prompts land in the expected tier', async () => {
+  expect(classify('what does this function return?').tier).toBe('light')
+  expect(classify('ok').tier).toBe('light')
+  expect(
+    classify('add a loading spinner to the submit button on the ask form and disable it while saving').tier,
+  ).toBe('standard')
+  expect(classify('refactor the fix ranking so it weighs environment matches').tier).toBe('deep')
+  expect(classify('debug why the MCP search is slow').tier).toBe('deep')
+  expect(classify('ultrathink about the verification model').tier).toBe('max')
+  expect(classify('is there a race condition in the release watcher?').tier).toBe('max')
+})
+
+test('the routed model and effort reach the request, subagents untouched', async ($, on) => {
+  const sent: TurnStepInput[] = []
+  on('ui.status', () => ({ value: undefined }))
+  on('prompt.submit', (_, e) => ({ text: e.text }))
+  on('turn.step', async function* (_, e) {
+    sent.push(e)
+    return { turnId: e.turnId, index: e.index, answer: '', toolUses: [], stopReason: 'end_turn', usage: null }
+  })
+
+  await $.prompt.submit(prompt('what is in package.json?'))
+  await step($, STEP)
+  await step($, { ...STEP, agentId: 'a1' })
+
+  expect(sent[0]?.model).toBe('claude-haiku-5-5')
+  expect(sent[0]?.effort).toBe('low')
+  expect(sent[1]?.model).toBe('claude-opus-5-5')
+  expect(sent[1]?.effort).toBe('high')
+})
+
+test('/route pins a tier and off stops routing', async ($, on) => {
+  const sent: TurnStepInput[] = []
+  on('command.register', () => ({ value: { command: 'route' } }))
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  on('ui.status', () => ({ value: undefined }))
+  on('prompt.submit', (_, e) => ({ text: e.text }))
+  on('turn.step', async function* (_, e) {
+    sent.push(e)
+    return { turnId: e.turnId, index: e.index, answer: '', toolUses: [], stopReason: 'end_turn', usage: null }
+  })
+
+  await $.session.start({ cwd: '/', surface: 'terminal', isInteractive: true })
+  await $.command.run(route('max'))
+  await $.prompt.submit(prompt('ok'))
+  await step($, STEP)
+  expect(sent[0]?.effort).toBe('max')
+
+  await $.command.run(route('off'))
+  await step($, { ...STEP, model: 'claude-sonnet-5-5', effort: 'medium' })
+  expect(sent[1]?.model).toBe('claude-sonnet-5-5')
+  expect(sent[1]?.effort).toBe('medium')
+})

package/plugins/auto-route/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./.claude-plugin/types/tsconfig.json"
+}

package/plugins/auto-route/types/index.d.ts

@@ -0,0 +1,12 @@
+export type Tier = 'light' | 'standard' | 'deep' | 'max'
+
+// 'auto' classifies each prompt; a tier pins it; 'off' leaves the session's own.
+export type Mode = 'auto' | 'off' | Tier
+
+export type Route = { tier: Tier; reason: string }
+
+declare module 'claude-code' {
+  interface PluginState {
+    'auto-route': { mode: Mode; route: Route | null }
+  }
+}

package/src/cli.mjs

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { detect, summarise, TOOLS } from "./detect.mjs";
 import { load, write, readIfExists, matches, BANNER, DIR } from "./source.mjs";
 import { adopt } from "./adopt.mjs";
-import { ensurePlugin, MARKETPLACE_NAME, PLUGIN } from "./plugin.mjs";
+import { ensurePlugin, MARKETPLACE_NAME, PLUGIN, PLUGINS } from "./plugin.mjs";
 import { setupState, describeState } from "../plugins/agent-os/skills/init/scripts/state.mjs";
 import { applyScope, describe } from "./claude-setup.mjs";
 import { createInterface } from "node:readline/promises";
@@ -33,7 +33,9 @@ Options
   --root <dir>   project directory (default: cwd)
   --dry-run      print what would change, write nothing
   --force        overwrite files agent-os did not generate (it refuses by default)
-  --no-plugin    skip installing or updating the Claude Code plugin during init
+  --no-plugin    skip installing or updating the Claude Code plugins during init
+  --no-auto-route
+                 init: install agent-os but not the auto-route model router
   --global       init: also write ~/.claude settings without asking
   --no-global    init: leave ~/.claude alone
 `;
@@ -265,19 +267,25 @@ Pick one:
     }
 
     if (cmd === "init" && targets.includes("claude-code") && !argv.includes("--no-plugin")) {
-      console.log(`\n${bold("Claude Code plugin")} ${dim(`${PLUGIN}@${MARKETPLACE_NAME}`)}\n`);
-      const r = ensurePlugin({ root, dry });
-      for (const line of r.done) console.log(`  ${dim(line)}`);
-      if (r.ok) console.log({
-        installed: `\n  installed ${r.to || ""} at project scope ${dim("— .claude/settings.json, so it travels with the repo")}`,
-        updated: `\n  updated ${r.from} → ${r.to}`,
-        current: `\n  already the latest (${r.to})`,
-        "dry-run": `\n  ${dim(r.from ? `installed: ${r.from} — would refresh and update` : "not installed — would install")}`,
-      }[r.reason]);
-      for (const line of r.hint) console.log(`  ${r.ok ? dim(line) : line}`);
-      if (r.reason === "installed" || r.reason === "updated")
-        console.log(`  ${dim("restart Claude Code, or /reload-plugins, to load it")}`);
-      console.log(`\n  ${dim("--no-plugin skips this")}`);
+      // Both come from the same marketplace, so it is added or refreshed once:
+      // by the first plugin whose run gets that far.
+      let refresh = true;
+      for (const plugin of PLUGINS.filter((p) => p === PLUGIN || !argv.includes(`--no-${p}`))) {
+        console.log(`\n${bold("Claude Code plugin")} ${dim(`${plugin}@${MARKETPLACE_NAME}`)}\n`);
+        const r = ensurePlugin({ root, dry, plugin, refresh });
+        if (r.done.length || r.reason === "no-cli") refresh = false;
+        for (const line of r.done) console.log(`  ${dim(line)}`);
+        if (r.ok) console.log({
+          installed: `\n  installed ${r.to || ""} at project scope ${dim("— .claude/settings.json, so it travels with the repo")}`,
+          updated: `\n  updated ${r.from} → ${r.to}`,
+          current: `\n  already the latest (${r.to})`,
+          "dry-run": `\n  ${dim(r.from ? `installed: ${r.from} — would refresh and update` : "not installed — would install")}`,
+        }[r.reason]);
+        for (const line of r.hint) console.log(`  ${r.ok ? dim(line) : line}`);
+        if (r.reason === "installed" || r.reason === "updated")
+          console.log(`  ${dim("restart Claude Code, or /reload-plugins, to load it")}`);
+      }
+      console.log(`\n  ${dim("--no-plugin skips this; --no-auto-route skips only the model router")}`);
     }
 
     if (cmd === "init" && !dry) {

package/src/plugin.mjs

@@ -2,8 +2,10 @@
  * Install or update the Claude Code half of agent-os during `init`.
  *
  * The CLI compiles rules for every tool. Claude Code additionally gets the
- * agents, skills, per-agent memory and hooks, which ship as a plugin. `init`
- * brings that plugin to the latest version whatever state it finds:
+ * agents, skills, per-agent memory and hooks, which ship as a plugin, and
+ * auto-route, a mod that picks the model and effort per turn. Both live in
+ * this repo's marketplace. `init` brings each to the latest version whatever
+ * state it finds:
  *
  *   not installed        marketplace add + install, at project scope
  *   installed, disabled  enable
@@ -19,18 +21,25 @@
  * on. The rules are the part that must not depend on this.
  */
 import { spawnSync } from "node:child_process";
-import { realpathSync } from "node:fs";
-import { bundledVersion, cmpVersion } from "../plugins/agent-os/skills/init/scripts/state.mjs";
+import { readFileSync, realpathSync } from "node:fs";
+import { cmpVersion } from "../plugins/agent-os/skills/init/scripts/state.mjs";
 
 export const MARKETPLACE = "sayansr26/agent-os";
 export const MARKETPLACE_NAME = "sayan-plugins";
 export const PLUGIN = "agent-os";
-const ID = `${PLUGIN}@${MARKETPLACE_NAME}`;
+// Installed by `init` in this order; each can be skipped with --no-<name>.
+export const PLUGINS = [PLUGIN, "auto-route"];
+const idOf = (plugin) => `${plugin}@${MARKETPLACE_NAME}`;
 
 const run = (args, cwd) =>
   spawnSync("claude", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
 const json = (r) => { try { return JSON.parse(r.stdout); } catch { return null; } };
 const real = (p) => { try { return realpathSync(p); } catch { return p; } };
+/** The version this package ships for a plugin, from its plugin.json. */
+const bundled = (plugin) => {
+  try { return JSON.parse(readFileSync(new URL(`../plugins/${plugin}/.claude-plugin/plugin.json`, import.meta.url), "utf8")).version || null; }
+  catch { return null; }
+};
 const tail = (r) => (r.stderr || r.stdout || String(r.error || "")).trim().split("\n").slice(-3);
 
 /** Is the Claude Code CLI usable from here? */
@@ -39,40 +48,46 @@ export function claudeAvailable() {
   return !r.error && r.status === 0;
 }
 
-/** This project's install of the plugin, per `claude plugin list --json`, or null. */
-export function installed(root) {
+/** This project's install of a plugin, per `claude plugin list --json`, or null. */
+export function installed(root, plugin = PLUGIN) {
   const list = json(run(["plugin", "list", "--json"], root));
   if (!Array.isArray(list)) return null;
-  const mine = list.filter((p) => p.id === ID &&
+  const mine = list.filter((p) => p.id === idOf(plugin) &&
     (p.scope === "user" || (p.projectPath && real(p.projectPath) === real(root))));
   return mine.find((p) => p.scope === "project" || p.scope === "local") || mine[0] || null;
 }
 
 /**
- * Bring the plugin to the latest version for this project.
+ * Bring a plugin to the latest version for this project.
  * Returns { ok, reason, from, to, done, hint } with reason one of
  * "installed" | "updated" | "current" | "dry-run" | "no-cli" | "failed".
+ * `refresh: false` skips the marketplace step when an earlier call this run
+ * already added or updated it.
  */
-export function ensurePlugin({ root = process.cwd(), dry = false, scope = "project" } = {}) {
+export function ensurePlugin({ root = process.cwd(), dry = false, scope = "project", plugin = PLUGIN, refresh = true } = {}) {
+  const ID = idOf(plugin);
   if (!claudeAvailable())
     return {
       ok: false, reason: "no-cli", done: [],
       hint: [
-        "The `claude` CLI is not on PATH, so the plugin was not installed or updated.",
-        "Inside Claude Code, run:",
-        `  /plugin marketplace add ${MARKETPLACE}`,
+        ...(refresh ? [
+          "The `claude` CLI is not on PATH, so the plugin was not installed or updated.",
+          "Inside Claude Code, run:",
+          `  /plugin marketplace add ${MARKETPLACE}`,
+        ] : []),
         `  /plugin install ${ID}     (or /plugin update ${ID} if it is already there)`,
       ],
     };
 
-  const before = installed(root);
-  const markets = json(run(["plugin", "marketplace", "list", "--json"], root));
-  const haveMarket = Array.isArray(markets) && markets.some((m) => m.name === MARKETPLACE_NAME);
-
+  const before = installed(root, plugin);
   const steps = [];
-  steps.push(haveMarket
-    ? ["plugin", "marketplace", "update", MARKETPLACE_NAME]
-    : ["plugin", "marketplace", "add", MARKETPLACE, "--scope", scope]);
+  if (refresh) {
+    const markets = json(run(["plugin", "marketplace", "list", "--json"], root));
+    const haveMarket = Array.isArray(markets) && markets.some((m) => m.name === MARKETPLACE_NAME);
+    steps.push(haveMarket
+      ? ["plugin", "marketplace", "update", MARKETPLACE_NAME]
+      : ["plugin", "marketplace", "add", MARKETPLACE, "--scope", scope]);
+  }
   if (!before) steps.push(["plugin", "install", ID, "--scope", scope, "--yes"]);
   else {
     if (before.enabled === false) steps.push(["plugin", "enable", ID, "--scope", before.scope]);
@@ -99,14 +114,14 @@ export function ensurePlugin({ root = process.cwd(), dry = false, scope = "proje
     done.push(`claude ${args.join(" ")}`);
   }
 
-  const after = installed(root);
+  const after = installed(root, plugin);
   const to = after?.version || null;
   const from = before?.version || null;
-  const want = bundledVersion();
+  const want = bundled(plugin);
   const hint = [];
   // The marketplace serves what is pushed to GitHub; this package may be newer.
   if (to && want && cmpVersion(to, want) < 0)
-    hint.push(`Marketplace still serves ${to}; this agent-os ships ${want}. It updates once ${MARKETPLACE} is pushed.`);
+    hint.push(`Marketplace still serves ${plugin} ${to}; this agent-os ships ${want}. It updates once ${MARKETPLACE} is pushed.`);
   return {
     ok: true,
     reason: !before ? "installed" : from !== to ? "updated" : "current",

package/src/selftest.mjs

@@ -101,6 +101,11 @@ try {
     ok(pi.stdout.includes("SETUP  FRESH"), "init on an empty project reports a fresh setup");
     ok(/marketplace add sayansr26\/agent-os|plugin marketplace add|not on PATH/.test(pi.stdout),
        "init names the marketplace step or says why it could not run it");
+    ok(pi.stdout.includes("auto-route@sayan-plugins"), "init sets up auto-route by default");
+    ok((pi.stdout.match(/marketplace add/g) || []).length <= 1, "the marketplace is added once, not per plugin");
+    const na = cli(["init", "--dry-run", "--no-auto-route"], r4);
+    ok(!/install auto-route@sayan-plugins/.test(na.stdout) && /install agent-os@sayan-plugins/.test(na.stdout),
+       "--no-auto-route keeps agent-os and skips auto-route");
     rmSync(r4, { recursive: true, force: true });
 
     // A hand-written file at a generated path must survive a sync.