pi-soly 1.2.0 → 1.3.0

package/README.md

@@ -56,7 +56,7 @@ GSD-inspired planning and execution. State is the source of truth, not vibes.
 
 ```bash
 /plan            # generate PLAN.md for the current phase
-/execute         # dispatch plan to soly-worker subagent
+/execute         # execute plan directly (LLM does the work)
 /resume          # pick up a paused session
 /inspect         # show current state summary
 /discuss 3       # talk through decisions before planning phase 3
@@ -182,7 +182,7 @@ todo_update({
                 ┌──────────────────┐
                 │  7 soly agents   │
                 │                  │
-                │  soly-worker     │
+                │  worker (cycle)     │
                 │  soly-debugger   │
                 │  soly-tester     │
                 │  soly-reviewer   │

package/agents-install.ts

@@ -2,17 +2,16 @@
 // assets-install.ts — Idempotent install of soly-managed user assets
 // =============================================================================
 //
-// Soly ships two kinds of user-scope assets:
+// Soly ships one kind of user-scope asset:
 //
-//   1. Subagent configs → `~/.pi/agent/agents/`
-//      The single `soly-manager` subagent (mode-switching executor).
-//
-//   2. Skills → `~/.pi/agent/skills/<name>/`
+//   Skills → `~/.pi/agent/skills/<name>/`
 //      The `soly-framework` skill — framework documentation the LLM
-//      loads on demand via the read tool.
+//      loads on demand via the read tool. This is the LLM's only
+//      "helper" for soly — pi doesn't need a separate subagent layer
+//      for plan execution (the LLM in the main session does it).
 //
-// pi discovers both from `~/.pi/agent/`, so on first session_start we
-// copy our shipped files there.
+// pi discovers the skill from `~/.pi/agent/`, so on first session_start
+// we copy our shipped file there.
 //
 // IDEMPOTENT: if the target file already exists (user may have customized
 // it), we do NOT overwrite. This is one-way "first install wins".
@@ -22,41 +21,19 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-/** soly agent files bundled with the extension. */
-const SHIPPED_AGENTS = [
-	"soly-manager.md",
-] as const;
-
 /** soly skills bundled with the extension. Each entry is a directory
  *  under `skills/` containing a SKILL.md. */
 const SHIPPED_SKILLS = [
 	"soly-framework",
 ] as const;
 
-/** Where pi looks for user agents. Respects HOME/USERPROFILE for
- *  testability (otherwise we'd always write to the real user home).
- *  Agent files live directly in the dir (no `agents/` subfolder):
- *    ~/.agents/reviewer.md   (NOT ~/.agents/agents/reviewer.md)
- *  This keeps the path clean and matches the project-level convention. */
-function userAgentsDirs(): string[] {
-	const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-	return [
-		path.join(home, ".agents"),                          // vendor-neutral (preferred)
-		path.join(home, ".pi", "agent", "agents"),           // pi native (legacy)
-	];
-}
-
-/** Where pi looks for user skills. */
+/** Where pi looks for user skills. Respects HOME/USERPROFILE for
+ *  testability (otherwise we'd always write to the real user home). */
 function userSkillsDir(): string {
 	const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
 	return path.join(home, ".pi", "agent", "skills");
 }
 
-/** Where this soly extension's `agents/` directory lives. */
-function shippedAgentsDir(extensionRoot: string): string {
-	return path.join(extensionRoot, "agents");
-}
-
 /** Where this soly extension's `skills/` directory lives. */
 function shippedSkillsDir(extensionRoot: string): string {
 	return path.join(extensionRoot, "skills");
@@ -68,19 +45,7 @@ export interface InstallResult {
 	errors: string[];
 }
 
-/** Copy a single file if destination doesn't exist. Idempotent. */
-function copyIfMissing(from: string, to: string): "installed" | "skipped" | "error" {
-	if (!fs.existsSync(from)) return "error";
-	if (fs.existsSync(to)) return "skipped";
-	try {
-		fs.copyFileSync(from, to);
-		return "installed";
-	} catch {
-		return "error";
-	}
-}
-
-/** Recursively copy a directory tree if destination doesn't exist. Idempotent. */
+/** Copy a directory tree if destination doesn't exist. Idempotent. */
 function copyDirIfMissing(from: string, to: string): "installed" | "skipped" | "error" {
 	if (!fs.existsSync(from)) return "error";
 	if (fs.existsSync(to)) return "skipped";
@@ -93,40 +58,6 @@ function copyDirIfMissing(from: string, to: string): "installed" | "skipped" | "
 	}
 }
 
-/** Install shipped soly agents to `~/.agents/` (vendor-neutral,
- *  preferred). Legacy `~/.pi/agent/agents/` copies are left alone —
- *  `discoverUserRotors` reads both, so old installs still work. */
-export function installSolyAgents(extensionRoot: string): InstallResult {
-	const result: InstallResult = { installed: [], skipped: [], errors: [] };
-	const src = shippedAgentsDir(extensionRoot);
-
-	if (!fs.existsSync(src)) return result; // dev mode no-op
-
-	// Try vendor-neutral first, then fall back to pi's native dir.
-	let dst: string | null = null;
-	for (const candidate of userAgentsDirs()) {
-		try {
-			fs.mkdirSync(candidate, { recursive: true });
-			dst = candidate;
-			break;
-		} catch (err) {
-			result.errors.push(`mkdir ${candidate}: ${(err as Error).message}`);
-		}
-	}
-	if (!dst) return result;
-
-	for (const name of SHIPPED_AGENTS) {
-		const from = path.join(src, name);
-		const to = path.join(dst, name);
-		const r = copyIfMissing(from, to);
-		if (r === "installed") result.installed.push(name);
-		else if (r === "skipped") result.skipped.push(name);
-		else result.errors.push(`missing source: ${from}`);
-	}
-
-	return result;
-}
-
 /** Install shipped soly skills to `~/.pi/agent/skills/`. Idempotent. */
 export function installSolySkills(extensionRoot: string): InstallResult {
 	const result: InstallResult = { installed: [], skipped: [], errors: [] };
@@ -147,33 +78,15 @@ export function installSolySkills(extensionRoot: string): InstallResult {
 	return result;
 }
 
-/** Install all soly assets (agents + skills). Combined for convenience. */
+/** Install all soly assets (skills only — agents are not shipped). */
 export function installSolyAssets(extensionRoot: string): {
-	agents: InstallResult;
 	skills: InstallResult;
 } {
 	return {
-		agents: installSolyAgents(extensionRoot),
 		skills: installSolySkills(extensionRoot),
 	};
 }
 
-/** Check which shipped soly agents are present across all user agent
- *  homes. A file counts as "installed" if it's in ANY of the dirs. */
-export function checkSolyAgentsInstalled(extensionRoot: string): {
-	installed: string[];
-	missing: string[];
-} {
-	const installed: string[] = [];
-	const missing: string[] = [];
-	for (const name of SHIPPED_AGENTS) {
-		const present = userAgentsDirs().some((dir) => fs.existsSync(path.join(dir, name)));
-		if (present) installed.push(name);
-		else missing.push(name);
-	}
-	return { installed, missing };
-}
-
 /** Check which shipped soly skills are present in the user dir. */
 export function checkSolySkillsInstalled(extensionRoot: string): {
 	installed: string[];

package/commands.ts

@@ -31,6 +31,10 @@ import {
 	type SolyState,
 } from "./core.ts";
 import type { SolyConfig } from "./config.ts";
+import { migrateSolyDir } from "./migrate.js";
+import { initSolyProject } from "./init.js";
+import { readNotifications, formatNotifications } from "./notifications-log.js";
+import { formatStatus } from "./status.js";
 
 /** Minimum ui surface the command handlers actually need. */
 export interface CommandUI {
@@ -332,6 +336,48 @@ What must the LLM do?
 	});
 
 	// ============================================================================
+	// /soly migrate — move .soly/ → .agents/ atomically
+	// ============================================================================
+	pi.registerCommand("soly-migrate", {
+		description:
+			"migrate project state from .soly/ to .agents/ (atomic rename, validates result, suggests git commit)",
+		handler: async (args, ctx) => {
+			const ui: CommandUI = {
+				notify: (t, k) => ctx.ui.notify(t, k ?? "info"),
+				select: async (label, options) => {
+					const result = await ctx.ui.select(label, options);
+					return result === undefined ? null : options.indexOf(result);
+				},
+				confirm: (title, message) => ctx.ui.confirm(title, message),
+			};
+			await migrateSolyDir(ctx.cwd, ui, { autoYes: args.includes("--yes") });
+		},
+	});
+
+	// /soly init — scaffold new project
+	// ============================================================================
+	pi.registerCommand("soly-init", {
+		description:
+			"scaffold a new soly project (interactive: pick template — minimal/web-app/library/cli)",
+		handler: async (args, ctx) => {
+			const ui: CommandUI = {
+				notify: (t, k) => ctx.ui.notify(t, k ?? "info"),
+				select: async (label, options) => {
+					const result = await ctx.ui.select(label, options);
+					return result === undefined ? null : options.indexOf(result);
+				},
+				confirm: (title, message) => ctx.ui.confirm(title, message),
+				input: (label, placeholder) => ctx.ui.input(label, placeholder),
+			};
+			// Parse args: --template=X, --yes, --name=X
+			const template = (args.match(/--template[= ](\S+)/)?.[1] as
+				| "minimal" | "web-app" | "library" | "cli" | undefined) ?? undefined;
+			const autoYes = args.includes("--yes");
+			const projectName = args.match(/--name[= ](\S+)/)?.[1];
+			await initSolyProject(ctx.cwd, ui, { template, autoYes, projectName });
+		},
+	});
+
 	// /soly
 	// ============================================================================
 

package/config.ts

@@ -35,12 +35,10 @@ export interface SolyConfig {
 		preferAskPro: boolean;
 		/** When soly pause is invoked, also auto-save HANDOFF.json (currently always true; knob for future). */
 		autoCheckpointOnPause: boolean;
-		/** Opt-in: install soly-manager agent config to
-		 *  ~/.pi/agent/agents/ on session_start. The single soly subagent
-		 *  is mode-switching (worker/debugger/tester/reviewer/etc. based on
-		 *  the task brief). Off by default — most users don't need a soly-
-		 *  specialized subagent since the workflow template already
-		 *  contains soly instructions. */
+		/** DEPRECATED in 1.3.0. Soly no longer ships a subagent. The LLM
+		 *  executes plans directly using the slash commands + the
+		 *  soly-framework skill. This option is kept as a no-op for
+		 *  backward compat with old config files. */
 		useSolyWorkerSubagents: boolean;
 	};
 	display: {

package/index.ts

@@ -88,9 +88,10 @@ export default function solyExtension(pi: ExtensionAPI) {
 	// ============================================================================
 	// Rotor switcher: REMOVED. The rotor cycler is now owned by the
 	// separate `pi-switch` extension (footer pill + Ctrl+Tab + /rotor slash).
-	// Soly owns a single subagent (soly-manager.md) and the auto-install on
-	// opt-in. Workflows read the current agent from
-	// globalThis.__PI_SWITCH_AGENT__ (set by pi-switch).
+	// Soly no longer ships a subagent (removed in 1.3.0). The LLM does plan
+	// execution directly using slash commands + the soly-framework skill.
+	// Workflows read the current rotor from globalThis.__PI_SWITCH_ROTOR__
+	// (set by pi-switch).
 	// ============================================================================
 
 	// Config (per-project + global + defaults). Refreshed on session_start
@@ -354,7 +355,7 @@ export default function solyExtension(pi: ExtensionAPI) {
 	pi.on("session_start", async (event, ctx) => {
 		// Deprecation warning: if the project still uses `.soly/`, nudge the
 		// user toward `.agents/`. One-time per session.
-		if (isLegacySolyDir(ctx.cwd)) {
+		if (activeConfig.agent.useSolyWorkerSubagents && isLegacySolyDir(ctx.cwd)) {
 			notifyDeprecation(
 				ctx.ui,
 				`.soly/ (legacy)`,
@@ -405,21 +406,22 @@ export default function solyExtension(pi: ExtensionAPI) {
 			}
 		}
 
-		// Auto-install soly user-scope assets (soly-manager agent + soly-framework
-		// skill) to ~/.pi/agent/ on first run. Opt-in via config
-		// `agent.useSolyWorkerSubagents` (default false). Idempotent — respects
-		// any existing user-customized copies.
+		// Auto-install soly user-scope assets (soly-framework skill only,
+		// since 1.3.0 we don't ship a subagent) to ~/.pi/agent/skills/ on
+		// first run. Opt-in via config `agent.useSolyWorkerSubagents`
+		// (kept for backward compat, now a no-op for the skill install).
+		// Idempotent — respects any existing user-customized copies.
 		if (activeConfig.agent.useSolyWorkerSubagents) {
 			const extRoot = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, "$1"));
 			const assets = installSolyAssets(extRoot);
-			const installed = [...assets.agents.installed, ...assets.skills.installed.map((s) => `skill:${s}`)];
+			const installed = assets.skills.installed.map((s) => `skill:${s}`);
 			if (installed.length > 0) {
 				ctx.ui.notify(
-					`soly: installed (${installed.join(", ")}) — run \`/subagents-doctor\` to verify`,
+					`soly: installed (${installed.join(", ")}) — pi will discover on next session`,
 					"info",
 				);
 			}
-			for (const e of [...assets.agents.errors, ...assets.skills.errors]) {
+			for (const e of assets.skills.errors) {
 				ctx.ui.notify(`soly: install error — ${e}`, "warning");
 			}
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-soly",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Project management framework for pi-coding-agent. Workflows, planning, multi-question picker, agent switcher, live task list — one npm install, zero config.",
   "type": "module",
   "main": "index.ts",
@@ -38,7 +38,6 @@
     "scratchpad.ts",
     "tools.ts",
     "agents-install.ts",
-    "agents",
     "ask",
     "skills",
     "switch",

package/skills/soly-framework/SKILL.md

@@ -27,7 +27,7 @@ The **soly** extension adds project-management workflow to [pi-coding-agent](htt
 | Command | What it does |
 |---|---|
 | `/plan [N]` | Generate or update `PLAN.md` for phase N (or current phase) |
-| `/execute [N[.MM]]` | Dispatch plan(s) to `soly-manager` subagent. `N` = all plans in phase. `N.MM` = specific plan. |
+| `/execute [N[.MM]]` | Execute plan(s) in phase N. `N` = all plans. `N.MM` = specific plan. The LLM (you) executes directly. |
 | `/discuss N` | Discussion-driven scoping for phase N — capture decisions before planning |
 | `/inspect` | One-screen summary: position, phases, recent decisions |
 | `/pause` | Save handoff (`HANDOFF.json` + `.continue-here.md`) for later resume |
@@ -211,24 +211,11 @@ Once production commits exist, returning without a committed `SUMMARY.md` is an
 
 Switch with `/rotor <name>` or `Ctrl+Tab` (cycles through). Footer pill shows current: `· ⚡ worker` / `▶ 🐢 oracle`.
 
-**Why "rotors"?** Because they *rotate* — `Ctrl+Tab` cycles through them. The word emphasizes the cycling behavior. Subagents (like `soly-manager`) are still called agents — they're a different concept (spawned for a task, not cycled through).
+**Why "rotors"?** Because they *rotate* — `Ctrl+Tab` cycles through them. The word emphasizes the cycling behavior. As of 1.3.0 there are no soly subagents — only the cycle rotors.
 
-## Subagent: soly-manager (single, mode-switching)
+## Subagent: none (as of 1.3.0)
 
-Spawn via `subagent({ agent: "soly-manager", task: ... })`. The task brief tells it which mode to be in:
-
-| Task brief mentions | Mode |
-|---|---|
-| implement, build, write code, add feature, create | **worker** |
-| debug, bug, fix, crash, error, repro, broken | **debugger** |
-| test, coverage, spec, assert, only modify tests | **tester** |
-| review, audit, adversarial, find bugs, qa | **reviewer** |
-| refactor, simplify, extract, rename, no behavior change | **refactor** |
-| document, readme, jsdoc, comment, intent doc | **documenter** |
-| validate, scope, drift, decision, before committing | **oracle** |
-| plan, design, outline, structure, decompose | **planner** |
-
-**soly-manager is ONE agent that switches modes. Don't spawn soly-worker / soly-debugger / etc. — those don't exist anymore.**
+**Soly no longer ships a subagent.** You (the LLM) execute plans directly in the main session using the slash commands above. If you need help, use pi's built-in cycle agents (\`worker\`, \`oracle\`, \`scout\`, \`reviewer\`) or the user's custom agents in \`~/.agents/\`. Don't spawn \`soly-manager\` / \`soly-worker\` / etc. — they don't exist.
 
 ## Tools the LLM can call
 
@@ -358,7 +345,7 @@ If `/execute` complains about illegal partial state:
 
 - ❌ Edit `.soly/rules/` files you didn't write — those are project invariants
 - ❌ Skip the SUMMARY — illegal partial state
-- ❌ Spawn `soly-worker` or `soly-debugger` — use `soly-manager` (mode-switches)
+- ❌ Spawn `soly-manager` / `soly-worker` / etc. — there are no soly subagents (removed in 1.3.0). Use pi's built-in subagents via the parent LLM's \`subagent(...)\` call.
 - ❌ Write rules in code comments — use `.soly/rules/*.md` or `.agents/rules/*.md` files
 - ❌ Edit `.soly/phases/*/PLAN.md` after `status: in_progress` — create a new plan
 - ❌ Put intent docs anywhere other than `.soly/docs/` (or `.agents/docs/` for vendor-neutral)

package/switch/README.md

@@ -25,7 +25,7 @@ Agents are markdown files with YAML frontmatter. pi-subagents (and pi-switch) di
 |---|---|---|
 | `~/.pi/agent/npm/node_modules/pi-subagents/agents/*.md` | built-in (worker, oracle, scout, reviewer) | ❌ |
 | `~/.pi/agent/agents/*.md` | user-defined | ✅ |
-| `~/.pi/agent/extensions/pi-soly/agents/*.md` (auto-installed if `useSolyWorkerSubagents: true` in `.soly/config.json`) | soly-manager (mode-switching subagent) | ✅ source |
+| `~/.pi/agent/extensions/pi-soly/agents/*.md` (auto-installed if `useSolyWorkerSubagents: true` in `.soly/config.json`) | (removed in 1.3.0 — soly no longer ships a subagent) | — |
 
 ### Frontmatter schema
 
@@ -61,7 +61,7 @@ You'll be prompted for a one-liner description. Then edit the file to specialize
 |---|---|
 | See current + available | `/agent` |
 | Cycle | `Ctrl+Tab` (or `F2`) |
-| Set explicitly | `/agent soly-manager` |
+| Set explicitly | `(n/a — no soly subagent since 1.3.0)` |
 | Diagnose | `/agent doctor` |
 | Recommend for a task | `/agent recommend investigate React Server Components` |
 
@@ -76,7 +76,7 @@ The LLM's system prompt includes a table mapping task keywords to agents. When t
 | scout, scan, map, where is, locate, skim | 🔍 scout | codebase recon |
 | review, audit, check, adversarial, critique, qa | 👀 reviewer | adversarial review |
 | oracle, decision, tradeoff, which approach, drift | 🔮 oracle | decision consistency |
-| implement, build, write code, add feature, debug, fix, test, refactor, document, plan, validate | ⚡ soly-manager | workflow executor, mode-switches from task brief |
+| implement, build, write code, add feature, debug, fix, test, refactor, document, plan, validate | ⚡ worker | do it yourself using slash commands |
 | (anything else) | ⚡ worker | generic implementation |
 
 Same keywords in Russian work (изучи, баг, тест, etc.).
@@ -84,7 +84,7 @@ Same keywords in Russian work (изучи, баг, тест, etc.).
 ## Integration with other extensions
 
 - **pi-soly** reads `globalThis.__PI_SWITCH_AGENT__` to know which cycle agent is active. Falls back to `"worker"` if pi-switch isn't loaded.
-- **pi-soly** also auto-installs `soly-manager.md` (single mode-switching subagent) to `~/.pi/agent/agents/` when `useSolyWorkerSubagents: true` in `.soly/config.json`.
+- **pi-soly no longer ships a subagent** (removed in 1.3.0). The LLM in the main session executes plans directly using the slash commands + the `soly-framework` skill.
 
 ## Files
 

package/switch/index.ts

@@ -35,6 +35,7 @@ import {
 	saveAgent,
 } from "./core.ts";
 import { buildPiSwitchSection, recommendAgent } from "./prompt.ts";
+import { watchRotors, type WatcherHandle } from "./watcher.ts";
 
 const GLOBAL_KEY = "__PI_SWITCH_ROTOR__";
 
@@ -43,6 +44,22 @@ export default function piSwitchExtension(pi: ExtensionAPI) {
 	let currentRotor: string = DEFAULT_ROTOR;
 	let cycle: string[] = [DEFAULT_ROTOR];
 	let lastUi: ExtensionUIContext | null = null;
+	let rotorWatcher: WatcherHandle | null = null;
+
+	function startRotorWatcher(): void {
+		// Already running — restart to pick up new cwd
+		rotorWatcher?.stop();
+		rotorWatcher = watchRotors(cwd, {
+			onChange: () => {
+				refreshCycle();
+				publish();
+				rerender();
+			},
+			onNotify: (msg) => {
+				lastUi?.notify(`pi-switch: ${msg}`, "info");
+			},
+		});
+	}
 
 	function refreshCycle(): void {
 		cycle = availableAgents(cwd);
@@ -87,6 +104,7 @@ export default function piSwitchExtension(pi: ExtensionAPI) {
 		refreshCycle();
 		publish();
 		rerender();
+		startRotorWatcher();
 	});
 
 	// ----- before_agent_start: inject system-prompt section -----

package/switch/prompt.ts

@@ -19,7 +19,7 @@ export const TASK_AGENT_HINTS: ReadonlyArray<{
 	  agent: "scout", emoji: "\ud83d\udd0d",
 	  why: "codebase recon, patterns, file locations" },
 	{ pattern: /\b(plan|design|architect|outline|structure|break\s*down|steps|order)\b/i,
-	  agent: "soly-manager", emoji: "\ud83d\udccb",
+	  agent: "worker", emoji: "\ud83d\udccb",
 	  why: "decompose into ordered steps, identify risks" },
 	{ pattern: /\b(review|audit|check|adversarial|critique|find\s+bugs|qa)\b/i,
 	  agent: "reviewer", emoji: "\ud83d\udc40",
@@ -28,22 +28,22 @@ export const TASK_AGENT_HINTS: ReadonlyArray<{
 	  agent: "oracle", emoji: "\ud83d\udd2e",
 	  why: "decision consistency, hidden assumptions, drift detection" },
 	{ pattern: /\b(debug|bug|fix|crash|error|stack\s*trace|repro|why\s+is\s+this\s+broken)\b/i,
-	  agent: "soly-manager", emoji: "\ud83d\udc1e",
+	  agent: "worker", emoji: "\ud83d\udc1e",
 	  why: "isolated bug investigation with minimal repro" },
 	{ pattern: /\b(test|tests|coverage|spec|assert)\b/i,
-	  agent: "soly-manager", emoji: "\ud83e\uddea",
+	  agent: "worker", emoji: "\ud83e\uddea",
 	  why: "test-only work, never modifies prod code" },
 	{ pattern: /\b(refactor|clean\s*up|simplify|extract|rename|restructure|no\s+behavior\s+change)\b/i,
-	  agent: "soly-manager", emoji: "\ud83d\udd04",
+	  agent: "worker", emoji: "\ud83d\udd04",
 	  why: "pure refactoring, behavior-preserving" },
 	{ pattern: /\b(document|docs|readme|jsdoc|comment|annotate)\b/i,
-	  agent: "soly-manager", emoji: "\ud83d\udcdd",
+	  agent: "worker", emoji: "\ud83d\udcdd",
 	  why: "doc updates, READMEs, inline annotations" },
 	{ pattern: /\b(implement|build|write\s+code|add\s+feature|create\s+the)\b/i,
 	  agent: "worker", emoji: "\u26a1",
 	  why: "generic implementation with all tools" },
 	{ pattern: /\b(orchestrate|coordinate|dispatch|chain|run\s+in\s+parallel|first\s+.+\s+then)\b/i,
-	  agent: "soly-manager", emoji: "\ud83e\udd1d",
+	  agent: "worker", emoji: "\ud83e\udd1d",
 	  why: "multi-agent orchestration" },
 	// Russian keywords (loose match — Russian words inflect heavily; we match
 	// word stems, accepting some false positives as the cost of broader coverage)
@@ -54,7 +54,7 @@ export const TASK_AGENT_HINTS: ReadonlyArray<{
 	  agent: "scout", emoji: "\ud83d\udd0d",
 	  why: "codebase recon, patterns, file locations" },
 	{ pattern: /(спланир|plan|design|architect)/i,
-	  agent: "soly-manager", emoji: "\ud83d\udccb",
+	  agent: "worker", emoji: "\ud83d\udccb",
 	  why: "decompose into ordered steps, identify risks" },
 	{ pattern: /(проверь|ревью|аудит|review|audit)/i,
 	  agent: "reviewer", emoji: "\ud83d\udc40",
@@ -63,22 +63,22 @@ export const TASK_AGENT_HINTS: ReadonlyArray<{
 	  agent: "oracle", emoji: "\ud83d\udd2e",
 	  why: "decision consistency, hidden assumptions, drift detection" },
 	{ pattern: /(баг|ошибк|почему\s+(?:падает|ломает)|debug|bug|crash|stack\s*trace|repro)/i,
-	  agent: "soly-manager", emoji: "\ud83d\udc1e",
+	  agent: "worker", emoji: "\ud83d\udc1e",
 	  why: "isolated bug investigation with minimal repro" },
 	{ pattern: /(тест|покрыт|test|coverage|spec|assert)/i,
-	  agent: "soly-manager", emoji: "\ud83e\uddea",
+	  agent: "worker", emoji: "\ud83e\uddea",
 	  why: "test-only work, never modifies prod code" },
 	{ pattern: /(рефактор|упрост|refactor|simplify|extract|restructure)/i,
-	  agent: "soly-manager", emoji: "\ud83d\udd04",
+	  agent: "worker", emoji: "\ud83d\udd04",
 	  why: "pure refactoring, behavior-preserving" },
 	{ pattern: /(документ|описани|document|readme|jsdoc)/i,
-	  agent: "soly-manager", emoji: "\ud83d\udcdd",
+	  agent: "worker", emoji: "\ud83d\udcdd",
 	  why: "doc updates, READMEs, inline annotations" },
 	{ pattern: /(реализуй|сделай|напиши|создай|implement|build|add\s+feature|create\s+the)/i,
 	  agent: "worker", emoji: "\u26a1",
 	  why: "generic implementation with all tools" },
 	{ pattern: /(оркестрируй|координируй|orchestrate|coordinate|dispatch|chain)/i,
-	  agent: "soly-manager", emoji: "\ud83e\udd1d",
+	  agent: "worker", emoji: "\ud83e\udd1d",
 	  why: "multi-agent orchestration" },
 ];
 
@@ -108,7 +108,7 @@ The current agent is shown in the footer status line as \`[emoji name]\`.
 
 When you need a specialist for a sub-task, use the right agent via the parent LLM's \`subagent(...)\` call.
 
-**Soly subagent:** there is exactly one — \`soly-manager\`. It's a workflow executor that switches modes (worker/debugger/tester/reviewer/refactor/documenter/oracle/planner) based on the task brief. For any soly plan execution, spawn \`soly-manager\` via \`subagent(...)\` with the task — it picks the right mode itself.
+**No soly subagent.** As of 1.3.0, soly no longer ships a subagent. The LLM in the main session executes plans directly using the slash commands (\`/plan\`, \`/execute\`, etc.) and the \`soly-framework\` skill. Use pi's built-in subagents (\`worker\`, \`oracle\`, \`scout\`, \`reviewer\`) for read-only research.
 
 **Task → agent heuristics.** Before launching a generic \`subagent(...)\`, scan the request for these keywords:
 
@@ -117,14 +117,14 @@ When you need a specialist for a sub-task, use the right agent via the parent LL
 | scout, scan, map, find all, where is, locate, explore codebase, skim | 🔍 scout | codebase recon, patterns, file locations |
 | review, audit, check, adversarial, critique, find bugs, qa | 👀 reviewer | adversarial correctness, security, style review |
 | oracle, decision, tradeoff, compare, which approach, is this wise, drift | 🔮 oracle | decision consistency, hidden assumptions |
-| implement, build, write code, add feature, create the, debug, fix, test, refactor, document, plan, validate | ⚡ soly-manager | workflow executor, picks mode from task brief |
-| (anything else) | ⚡ worker | generic implementation, all tools |
+| (anything else, including implement, debug, fix, test, refactor, document, plan) | ⚡ worker | generic implementation, all tools — prefer to do it yourself |
 
 For multi-step tasks, the orchestrator (you) decides which agents run and in what order. You can chain agents via \`subagent({ chain: [...] })\` or run them in parallel via parallel tasks.
 
 DON'T:
 - Launch a worker for analysis (use oracle/scout/reviewer)
 - Launch an oracle for implementation (it has no write tools)
+- Spawn \`soly-manager\` / \`soly-worker\` / etc. — there are no soly subagents anymore (as of 1.3.0)
 - Spawn soly-worker / soly-debugger / soly-tester — there is only \`soly-manager\`
 - Manually edit \`.soly/agent\` or \`~/.pi-switch/agent\` — use the slash command
 `;

package/switch/tests/prompt.test.ts

@@ -21,8 +21,8 @@ describe("buildPiSwitchSection", () => {
 		expect(s).toContain("scout");
 		expect(s).toContain("worker");
 	});
-	test("mentions soly-manager as the single subagent", () => {
-		expect(s).toContain("soly-manager");
+	test("mentions worker as the main cycle rotor", () => {
+		expect(s).toContain("worker");
 	});
 	test("explains user-defined", () => {
 		expect(s).toMatch(/user[- ]?defined/i);
@@ -60,36 +60,36 @@ describe("recommendAgent", () => {
 		expect(recommendAgent("Изучи React Server Components")?.agent).toBe("researcher");
 		expect(recommendAgent("Найди инфу про Zustand")?.agent).toBe("researcher");
 	});
-	test("debug keywords → soly-manager", () => {
-		expect(recommendAgent("fix this bug")?.agent).toBe("soly-manager");
-		expect(recommendAgent("why is this crash happening")?.agent).toBe("soly-manager");
-		expect(recommendAgent("repro the failing test")?.agent).toBe("soly-manager");
-		expect(recommendAgent("Почему падает тест?")?.agent).toBe("soly-manager");
+	test("debug keywords → worker", () => {
+		expect(recommendAgent("fix this bug")?.agent).toBe("worker");
+		expect(recommendAgent("why is this crash happening")?.agent).toBe("worker");
+		expect(recommendAgent("repro the failing test")?.agent).toBe("worker");
+		expect(recommendAgent("Почему падает тест?")?.agent).toBe("worker");
 	});
-	test("refactor keywords → soly-manager", () => {
-		expect(recommendAgent("refactor this function")?.agent).toBe("soly-manager");
-		expect(recommendAgent("simplify the auth flow")?.agent).toBe("soly-manager");
-		expect(recommendAgent("Упрости эту функцию")?.agent).toBe("soly-manager");
+	test("refactor keywords → worker", () => {
+		expect(recommendAgent("refactor this function")?.agent).toBe("worker");
+		expect(recommendAgent("simplify the auth flow")?.agent).toBe("worker");
+		expect(recommendAgent("Упрости эту функцию")?.agent).toBe("worker");
 	});
-	test("test keywords → soly-manager", () => {
-		expect(recommendAgent("write tests for the parser")?.agent).toBe("soly-manager");
-		expect(recommendAgent("improve coverage")?.agent).toBe("soly-manager");
-		expect(recommendAgent("Напиши тесты для парсера")?.agent).toBe("soly-manager");
+	test("test keywords → worker", () => {
+		expect(recommendAgent("write tests for the parser")?.agent).toBe("worker");
+		expect(recommendAgent("improve coverage")?.agent).toBe("worker");
+		expect(recommendAgent("Напиши тесты для парсера")?.agent).toBe("worker");
 	});
 	test("review keywords → reviewer", () => {
 		expect(recommendAgent("review this PR")?.agent).toBe("reviewer");
 		expect(recommendAgent("audit the security")?.agent).toBe("reviewer");
 		expect(recommendAgent("Проверь этот код")?.agent).toBe("reviewer");
 	});
-	test("docs keywords → soly-manager", () => {
-		expect(recommendAgent("update the readme")?.agent).toBe("soly-manager");
-		expect(recommendAgent("add jsdoc to the function")?.agent).toBe("soly-manager");
-		expect(recommendAgent("Обнови документацию")?.agent).toBe("soly-manager");
+	test("docs keywords → worker", () => {
+		expect(recommendAgent("update the readme")?.agent).toBe("worker");
+		expect(recommendAgent("add jsdoc to the function")?.agent).toBe("worker");
+		expect(recommendAgent("Обнови документацию")?.agent).toBe("worker");
 	});
-	test("plan keywords → soly-manager", () => {
-		expect(recommendAgent("plan the migration")?.agent).toBe("soly-manager");
-		expect(recommendAgent("design the API")?.agent).toBe("soly-manager");
-		expect(recommendAgent("Спланируй миграцию")?.agent).toBe("soly-manager");
+	test("plan keywords → worker", () => {
+		expect(recommendAgent("plan the migration")?.agent).toBe("worker");
+		expect(recommendAgent("design the API")?.agent).toBe("worker");
+		expect(recommendAgent("Спланируй миграцию")?.agent).toBe("worker");
 	});
 	test("implement keywords → worker", () => {
 		expect(recommendAgent("implement the feature")?.agent).toBe("worker");

package/switch/tests/watcher.test.ts

@@ -0,0 +1,147 @@
+// =============================================================================
+// tests/watcher.test.ts — Tests for rotor hot-reload watcher
+// =============================================================================
+
+/// <reference types="bun-types" />
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { watchRotors } from "../watcher.js";
+
+let tmpRoot: string;
+let fakeHome: string;
+let origHome: string | undefined;
+let origUserProfile: string | undefined;
+
+beforeAll(() => {
+	tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "rotor-watch-"));
+	fakeHome = path.join(tmpRoot, "home");
+	fs.mkdirSync(fakeHome, { recursive: true });
+	origHome = process.env.HOME;
+	origUserProfile = process.env.USERPROFILE;
+	process.env.HOME = fakeHome;
+	process.env.USERPROFILE = fakeHome;
+});
+
+afterAll(() => {
+	if (origHome !== undefined) process.env.HOME = origHome;
+	if (origUserProfile !== undefined) process.env.USERPROFILE = origUserProfile;
+	fs.rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((r) => setTimeout(r, ms));
+}
+
+describe("watchRotors", () => {
+	test("calls onChange when a rotor .md is added", async () => {
+		const projectDir = fs.mkdtempSync(path.join(tmpRoot, "proj-"));
+		fs.mkdirSync(path.join(projectDir, ".agents"), { recursive: true });
+		let changes = 0;
+		const handle = watchRotors(projectDir, {
+			home: fakeHome,
+			onChange: () => { changes++; },
+		});
+		try {
+			fs.writeFileSync(path.join(projectDir, ".agents", "new-rotor.md"), "---\nname: new-rotor\n---\n# body");
+			await sleep(400);
+			expect(changes).toBeGreaterThan(0);
+		} finally {
+			handle.stop();
+			fs.rmSync(projectDir, { recursive: true, force: true });
+		}
+	});
+
+	test("coalesces multiple rapid changes into one onChange", async () => {
+		const projectDir = fs.mkdtempSync(path.join(tmpRoot, "proj-"));
+		fs.mkdirSync(path.join(projectDir, ".agents"), { recursive: true });
+		let changes = 0;
+		const handle = watchRotors(projectDir, {
+			home: fakeHome,
+			onChange: () => { changes++; },
+		});
+		try {
+			// Burst: 3 quick writes
+			fs.writeFileSync(path.join(projectDir, ".agents", "a.md"), "x");
+			await sleep(50);
+			fs.writeFileSync(path.join(projectDir, ".agents", "a.md"), "xy");
+			await sleep(50);
+			fs.writeFileSync(path.join(projectDir, ".agents", "a.md"), "xyz");
+			await sleep(400); // wait past debounce
+			// All three bursts collapse into ~1-2 calls (debounce)
+			expect(changes).toBeLessThan(3);
+			expect(changes).toBeGreaterThanOrEqual(1);
+		} finally {
+			handle.stop();
+			fs.rmSync(projectDir, { recursive: true, force: true });
+		}
+	});
+
+	test("ignores non-.md files", async () => {
+		const projectDir = fs.mkdtempSync(path.join(tmpRoot, "proj-"));
+		fs.mkdirSync(path.join(projectDir, ".agents"), { recursive: true });
+		let changes = 0;
+		const handle = watchRotors(projectDir, {
+			home: fakeHome,
+			onChange: () => { changes++; },
+		});
+		try {
+			fs.writeFileSync(path.join(projectDir, ".agents", "notes.txt"), "ignore me");
+			fs.writeFileSync(path.join(projectDir, ".agents", ".hidden.md"), "also ignore");
+			await sleep(300);
+			expect(changes).toBe(0);
+		} finally {
+			handle.stop();
+			fs.rmSync(projectDir, { recursive: true, force: true });
+		}
+	});
+
+	test("calls onNotify with summary", async () => {
+		const projectDir = fs.mkdtempSync(path.join(tmpRoot, "proj-"));
+		fs.mkdirSync(path.join(projectDir, ".agents"), { recursive: true });
+		const notifies: string[] = [];
+		const handle = watchRotors(projectDir, {
+			home: fakeHome,
+			onChange: () => {},
+			onNotify: (msg) => { notifies.push(msg); },
+		});
+		try {
+			fs.writeFileSync(path.join(projectDir, ".agents", "x.md"), "x");
+			await sleep(1000); // debounce (200) + coalesce (500) + buffer
+			expect(notifies.length).toBeGreaterThan(0);
+			expect(notifies[0]).toContain("rotors reloaded");
+		} finally {
+			handle.stop();
+			fs.rmSync(projectDir, { recursive: true, force: true });
+		}
+	});
+
+	test("stop() prevents further callbacks", async () => {
+		const projectDir = fs.mkdtempSync(path.join(tmpRoot, "proj-"));
+		fs.mkdirSync(path.join(projectDir, ".agents"), { recursive: true });
+		let changes = 0;
+		const handle = watchRotors(projectDir, {
+			home: fakeHome,
+			onChange: () => { changes++; },
+		});
+		handle.stop();
+		fs.writeFileSync(path.join(projectDir, ".agents", "a.md"), "x");
+		await sleep(300);
+		expect(changes).toBe(0);
+		fs.rmSync(projectDir, { recursive: true, force: true });
+	});
+
+	test("handles non-existent dirs gracefully (creates them)", () => {
+		const projectDir = fs.mkdtempSync(path.join(tmpRoot, "proj-"));
+		// Don't create .agents — watcher should create it
+		const handle = watchRotors(projectDir, {
+			home: fakeHome,
+			onChange: () => {},
+		});
+		// .agents should now exist (created by watchRotors)
+		expect(fs.existsSync(path.join(projectDir, ".agents"))).toBe(true);
+		handle.stop();
+		fs.rmSync(projectDir, { recursive: true, force: true });
+	});
+});

package/switch/watcher.ts

@@ -0,0 +1,112 @@
+// =============================================================================
+// watcher.ts — Hot-reload the rotor cycle when rotor .md files change
+// =============================================================================
+//
+// Watches all known rotor home dirs (project + user) and triggers a cycle
+// refresh + brief notify when a .md file is added/removed/changed. The
+// watcher is debounced (editors save in bursts) and stops cleanly on
+// extension reload.
+//
+// Why: previously, adding a new rotor .md to `.agents/` only took effect on
+// the next Ctrl+Tab. With this watcher, the new rotor appears in the next
+// pill render — no user action required.
+// =============================================================================
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { rotorHomeDirs } from "./core.js";
+
+/** Debounce window for file events (editors save in bursts). */
+const DEBOUNCE_MS = 200;
+/** Coalesce window for the "rotors reloaded" notify. */
+const NOTIFY_COALESCE_MS = 500;
+
+export interface WatcherOptions {
+	/** Called when rotors change (debounced). */
+	onChange: () => void;
+	/** Called with a debounced message about what changed. */
+	onNotify?: (message: string) => void;
+	/** Override HOME for tests. */
+	home?: string;
+}
+
+export interface WatcherHandle {
+	stop: () => void;
+}
+
+/** Watch all rotor home dirs for *.md add/remove/change. */
+export function watchRotors(cwd: string | undefined, opts: WatcherOptions): WatcherHandle {
+	const home = opts.home ?? process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+	const dirs = rotorHomeDirs(cwd).map((d) => d.replace(/^~/, home));
+
+	const watchers: fs.FSWatcher[] = [];
+	let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+	let notifyTimer: ReturnType<typeof setTimeout> | null = null;
+	let pendingReasons: string[] = [];
+	let stopped = false;
+
+	const fire = () => {
+		if (stopped) return;
+		opts.onChange();
+	};
+
+	const scheduleNotify = (reason: string) => {
+		pendingReasons.push(reason);
+		if (notifyTimer) clearTimeout(notifyTimer);
+		notifyTimer = setTimeout(() => {
+			const reasons = [...new Set(pendingReasons)];
+			pendingReasons = [];
+			notifyTimer = null;
+			if (opts.onNotify) {
+				const summary =
+					reasons.length === 1
+						? reasons[0]!
+						: `${reasons.length} changes (${reasons.slice(0, 3).join(", ")}${reasons.length > 3 ? "…" : ""})`;
+				opts.onNotify(`rotors reloaded (${summary})`);
+			}
+		}, NOTIFY_COALESCE_MS);
+	};
+
+	const onEvent = (event: "add" | "change" | "unlink", filename: string | null) => {
+		if (stopped) return;
+		if (!filename || !filename.endsWith(".md")) return;
+		// Skip dotfiles (frontmatter dumps, etc.)
+		if (filename.startsWith(".")) return;
+		// Coalesce
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = null;
+			scheduleNotify(event);
+			fire();
+		}, DEBOUNCE_MS);
+	};
+
+	for (const dir of dirs) {
+		// Ensure dir exists before watching (fs.watch errors on non-existent)
+		try {
+			fs.mkdirSync(dir, { recursive: true });
+		} catch { /* ignore */ }
+		try {
+			const w = fs.watch(dir, { persistent: false }, (_eventType, filename) => {
+				onEvent(_eventType as "add" | "change" | "unlink", filename);
+			});
+			watchers.push(w);
+		} catch (err) {
+			// Some dirs may not exist or be unwatchable. Skip silently.
+			// eslint-disable-next-line no-console
+			console.error(`[pi-soly] cannot watch ${dir}: ${(err as Error).message}`);
+		}
+	}
+
+	return {
+		stop: () => {
+			stopped = true;
+			if (debounceTimer) clearTimeout(debounceTimer);
+			if (notifyTimer) clearTimeout(notifyTimer);
+			for (const w of watchers) {
+				try { w.close(); } catch { /* ignore */ }
+			}
+		},
+	};
+}

package/agents/soly-manager.md

@@ -1,124 +0,0 @@
----
-name: soly-manager
-description: Soly workflow executor. Handles any soly task end-to-end — plan, execute, debug, test, review, refactor, document. Reads the workflow brief passed by the parent and picks the right role for the task. The single writer/reviewer for soly projects.
-thinking: high
-systemPromptMode: replace
-inheritProjectContext: true
-inheritSkills: false
-tools: read, grep, find, ls, bash, edit, write
-defaultContext: fork
-defaultReads: context.md, plan.md
-defaultProgress: true
----
-
-You are `soly-manager`: the workflow executor for the **soly** project-management extension.
-
-The parent agent passes you a task with one of these roles. **Pick the right one based on the task brief, not on your name:**
-
-| Task brief mentions | You are in mode | Your job |
-|---|---|---|
-| implement, build, write code, add feature, create | **worker** | Write the code, run verification, commit |
-| debug, bug, fix, crash, error, repro, broken | **debugger** | Repro → isolate → fix → regression test |
-| test, coverage, spec, assert, only modify tests | **tester** | Write tests, run full suite, never touch prod |
-| review, audit, adversarial, find bugs, qa | **reviewer** | Read-only review with file:line evidence |
-| refactor, simplify, extract, rename, no behavior change | **refactor** | Behavior-preserving structural change |
-| document, readme, jsdoc, comment, intent doc | **documenter** | Update docs, never change product behavior |
-| validate, scope, drift, decision, before committing | **oracle** | Read-only consistency check, no edits |
-| plan, design, outline, structure, decompose | **planner** | Ordered steps with risks; not code |
-
-**You are one agent that switches modes. You are not seven agents.** The system prompt above is your only persona — the task brief tells you which hat to wear.
-
-## Soly-aware defaults (apply in every mode)
-
-**Path discipline — NON-NEGOTIABLE.** All soly-managed files live under `.soly/`:
-- `PLAN.md`, `CONTEXT.md`, `RESEARCH.md`, `SUMMARY.md` → `.soly/phases/<NN>-<slug>/`
-- iteration files → `.soly/iterations/`
-- handoffs → `.soly/HANDOFF.json`, `.soly/.continue-here.md`
-- rules → `.soly/rules/` (NEVER edit — version-controlled)
-- All other files (source code, tests) → normal project dirs
-
-**Close-out order** (when working a plan): production-code commit(s) → SUMMARY commit → `STATUS: done` update.
-Once production commits exist, returning without a committed SUMMARY is an **illegal partial-plan state**.
-
-**Frontmatter contract** for `PLAN.md`: `id`, `title`, `status: pending|in_progress|done`, `phase`, `depends-on`, `parallelizable`. Read frontmatter first.
-
-**pi-todo integration** (auto-tracks plan sub-tasks if `todo_update` tool is available):
-1. At task start: call `todo_update` with all `status: "pending"`
-2. Set first to `in_progress` before starting
-3. Update as you go: `pending` → `in_progress` → `completed`
-4. Clear list (`todo_update({todos: []})`) after SUMMARY committed
-Skip silently if `todo_update` is not available.
-
-## Read first (soly-aware order)
-
-1. `.soly/STATE.md` — milestone, current position, recent decisions
-2. `.soly/ROADMAP.md` — overall phase plan
-3. The target `PLAN.md` (the contract) if a plan is in scope
-4. `<phase>-CONTEXT.md` if it exists (honor user decisions)
-5. `<phase>-RESEARCH.md` if it exists (use chosen libs/patterns)
-
-**Iteration context file** (if the parent references one) is a pre-aggregated bundle. If given, read that INSTEAD of the individual files.
-
-## Mode-specific discipline
-
-These are the few hard rules per mode. Follow them or fail loudly.
-
-### As worker (implement)
-- Atomic edits only — no speculative scaffolding, no TODO comments
-- Per task: read `<read_first>` → minimal correct change → verify `<acceptance_criteria>` (HARD GATE; log deviation after 2 failed fix attempts) → run `<verification>` → commit with `<type>(${PHASE}-${PLAN}): <summary>`
-- Do NOT edit `.soly/rules/`
-
-### As debugger (fix)
-- **Reproduce first.** No fix without a repro. If the user gave a stack trace, build a minimal test that triggers it. If they said "X is broken", find one test case that demonstrates it.
-- **Isolate.** Git blame, grep, bisect. State the root cause in one sentence before fixing.
-- **Fix the cause, not the symptom.** Extra null checks, swallowed errors, type casts mask the bug.
-- **Regression test.** If a test would have caught this, write it. Run the full suite.
-
-### As tester
-- **Hard rule:** you can edit `*.test.*`, `*.spec.*`, `tests/`, `__tests__/`, `test/`. You CANNOT edit anything else. If a test fails because of a prod bug, STOP and report — don't "fix" the prod code.
-- Match the project's existing test style. Don't introduce a new style.
-- Test behavior, not implementation. Black-box > white-box.
-
-### As reviewer (adversarial)
-- **Read-only.** Do NOT edit files. Do NOT fix bugs. Do NOT commit. You produce a review with file:line evidence; the parent decides what to do.
-- Read spec → read test → read impl → diff them. Where do they disagree?
-- Pick 3-4 relevant review angles (correctness, security, performance, maintainability, soly-style).
-- Specific over vague: "Line 47: SQL injection. Use parameterized query." not "the code is buggy".
-
-### As refactor
-- **Behavior preservation is the entire point.** If a test starts failing, you've changed behavior — that's a bug, not a refactor.
-- Smallest possible diff. Run tests after EVERY change.
-- Don't refactor AND fix a bug. Two concerns = unreviewable.
-- If you find a bug, stop, log it, finish the refactor without touching it.
-
-### As documenter
-- **You do NOT change product code.** You write READMEs, JSDoc, `.soly/docs/`, ADRs.
-- Update, don't append. If the README has an "Architecture" section, edit in place.
-- Link, don't repeat. 5 lines + a link > 50 lines of pasted explanation.
-- Don't add marketing fluff ("this powerful, elegant framework...").
-
-### As oracle (validate)
-- **Read-only.** No edits, no code, no new workflow trees.
-- Check: drift, hidden assumptions, scope creep, missing prerequisites, repeated mistakes, unresolved `depends-on`.
-- Sometimes the answer is "this shouldn't be a soly plan at all" — say so.
-- Output: inherited decisions → drift check → hidden assumptions → missing prereqs → scope check → recommendation → confidence.
-
-### As planner
-- Output ordered steps with explicit risks. No code. No "let me also...".
-- Each step: description, depends-on, verification (test or command), acceptance criteria.
-- If the parent asks for a plan, give a plan. Don't drift into implementation.
-
-## Returning
-
-Your final response should follow this shape:
-
-```
-Mode: <worker | debugger | tester | reviewer | refactor | documenter | oracle | planner>
-Did: <one-sentence summary of what you did or found>
-Changed files: <list, or "none" for read-only modes>
-Validation: <test/typecheck/build output, or "n/a" for read-only modes>
-Open risks / decisions needing approval: <list, or "none">
-Recommended next step: <one line>
-```
-
-Be concise. The parent synthesizes, not you.