pi-soly 1.16.4 → 2.1.0

package/README.md

@@ -27,7 +27,7 @@ pi install npm:pi-soly
 Restart pi (`/reload`), and you have:
 
 - **Project management** — plans, state, phases, decisions
-- **Workflow engine** — plain-text verbs: `soly discuss` · `plan` · `execute` · `verify` · `pause`/`resume`
+- **Workflow engine** — runs inline (no subagent plugin). The model proposes the next step and drives it via the `soly_workflow` tool on your plain-language intent; the verbs `soly discuss` · `plan` · `execute` · `verify` · `pause`/`resume` still work as text
 - **Self-review loop** — `soly verify` re-reviews the work until "No issues found."
 - **Visual chrome** — native footer, equalizer working spinner with live telemetry, gradient welcome banner
 - **Rules & docs modal** — `/rules` and `/docs` open a fuzzy list + preview panel (no chat dumps)
@@ -37,7 +37,7 @@ Restart pi (`/reload`), and you have:
 - **HTML artifacts** — `html_artifact` tool serves self-contained HTML from a per-session browser gallery (live-updating, one stable URL)
 - **Skill-based execution** — LLM reads the `soly-framework` skill on demand
 
-The LLM drives execution; `plan`/`execute` delegate to a `worker` subagent when one is available (via pi-subagents), with first-party delegation on the roadmap. You focus on the work.
+The LLM drives execution **inline, in the main session** — no external subagent plugin. Say what you want in plain language ("let's plan this", "start executing") and the model calls the first-party `soly_workflow` tool for you; the `soly <verb>` text form still works as a fallback. You focus on the work.
 
 ### Known install issue (upstream `pi install`)
 
@@ -82,7 +82,7 @@ Tracked upstream — fix is expected on the pi side, not here.
 soly new feat/auth-jwt       # create branch + .agents/plans/<name>/ + stub PLAN.md
 soly discuss feat/auth-jwt   # interactive discussion of the plan
 soly plan feat/auth-jwt      # flesh out PLAN.md via ask_pro
-soly execute feat/auth-jwt   # execute the plan in a subagent
+soly execute feat/auth-jwt   # execute the plan inline in this session
 soly done feat/auth-jwt      # commit, push, open draft PR via gh
 soly verify                  # self-review loop until "No issues found." (soly verify stop to exit)
 soly pause                   # save a handoff; soly resume to pick it back up

package/config.ts

@@ -49,13 +49,6 @@ export interface SolyConfig {
 		 *    "off"   — no gate.
 		 *  Booleans accepted for back-compat: true = "scope", false = "off". */
 		confirmBeforeCode: boolean | "off" | "ask" | "scope";
-		/** Inject a compact list of rules applicable to the file being
-		 *  edited/written, appended to the tool's result. Forces the LLM to
-		 *  confirm in the next message which rules were applied — closes the
-		 *  "rules read at start of turn, forgotten by edit time" gap.
-		 *  Default on. Disable for verbose rule sets that would otherwise
-		 *  flood the per-edit context. */
-		preActionRuleReminder: boolean;
 	};
 	display: {
 		/** Always show the recommended (⭐) option as the first row. */
@@ -148,7 +141,6 @@ export const DEFAULT_CONFIG: SolyConfig = {
 		nudgeNotify: false,
 		toolHints: true,
 		confirmBeforeCode: "scope",
-		preActionRuleReminder: true,
 	},
 	display: {
 		defaultRecommendedFirst: true,
@@ -248,8 +240,6 @@ function deepMerge(base: SolyConfig, over: RawConfig): SolyConfig {
 			over.agent.confirmBeforeCode === "scope"
 		)
 			merged.agent.confirmBeforeCode = over.agent.confirmBeforeCode;
-		if (typeof over.agent.preActionRuleReminder === "boolean")
-			merged.agent.preActionRuleReminder = over.agent.preActionRuleReminder;
 	}
 	if (over.display) {
 		if (typeof over.display.defaultRecommendedFirst === "boolean")

package/core.ts

@@ -571,68 +571,6 @@ ${blocks.join("\n\n---\n\n")}${skippedNote}
   return { section, loaded: applicable.map(ruleKey), interactive };
 }
 
-// ============================================================================
-// Per-file rule lookup (used by pre-action reminder in tool_result hook)
-// ============================================================================
-//
-// Returns the subset of `rules` that apply to a single file path. Mirrors the
-// glob logic in `buildRulesSection` (always/no-globs = universal; otherwise
-// match `filePath` against `meta.globs`). Excludes disabled rules. Use this
-// to feed the pre-action reminder — LLM should see applicable rules AT THE
-// MOMENT of edit, not just at the start of the turn (where they decay).
-export function getApplicableRulesForFile(
-  filePath: string,
-  rules: RuleFile[],
-): RuleFile[] {
-  return rules.filter((r) => {
-    if (!r.enabled) return false;
-    if (r.meta.always === true) return true;
-    const globs = r.meta.globs;
-    if (!globs || globs.length === 0) return true;
-    return globs.some((g) => matchesGlob(filePath, g));
-  });
-}
-
-// Formats a compact reminder block for the LLM to see right after editing
-// `filePath`. Sorted by priority (high → medium → low → undefined), capped
-// at `cap` rules (default 3) so the LLM isn't flooded. Returns "" when no
-// rules apply — caller should treat that as "don't inject anything".
-export function formatRuleReminder(
-  rules: RuleFile[],
-  filePath: string,
-  cap = 3,
-): string {
-  if (rules.length === 0) return "";
-
-  const priorityOrder: Record<string, number> = { high: 0, medium: 1, low: 2 };
-  const sorted = [...rules].sort((a, b) => {
-    const pa = priorityOrder[a.meta.priority ?? ""] ?? 1;
-    const pb = priorityOrder[b.meta.priority ?? ""] ?? 1;
-    if (pa !== pb) return pa - pb;
-    return a.relPath.localeCompare(b.relPath);
-  });
-
-  const shown = sorted.slice(0, cap);
-  const remaining = rules.length - shown.length;
-
-  const lines: string[] = [];
-  lines.push(`\n\n---\n\n📋 **Applicable rules for \`${filePath}\`:**\n`);
-  shown.forEach((r, i) => {
-    const desc = r.meta.description ? ` — ${r.meta.description}` : "";
-    lines.push(`${i + 1}. [\`${r.relPath}\`]${desc}`);
-  });
-  if (remaining > 0) {
-    lines.push(
-      `\n_…and ${remaining} more — use \`/why ${filePath}\` to see all._`,
-    );
-  }
-  lines.push(
-    `\nIn your next message, briefly confirm which were applied (or note why not).`,
-  );
-
-  return lines.join("\n");
-}
-
 // ============================================================================
 // Phase-scoped rules loader
 // ============================================================================

package/index.ts

@@ -32,9 +32,7 @@ import {
 	CONTEXT_WINDOW_TOKENS,
 	DEFAULT_PROGRESS,
 	extractFilePathsFromPrompt,
-	formatRuleReminder,
 	formatTok,
-	getApplicableRulesForFile,
 	loadAllRules,
 	loadPhaseRules,
 	loadProjectState,
@@ -57,7 +55,8 @@ import {
 	pruneOldIterations,
 	type SolyConfig,
 } from "./config.ts";
-import { classifyTaskHeuristics, buildNudgeSection } from "./nudge.ts";
+import { classifyTaskHeuristics, buildNudgeSection, buildSuggestionSection, type WorkflowSituation } from "./nudge.ts";
+import { registerWorkflowTool } from "./workflows/llm-tools.ts";
 import { detectToolHints, buildToolHintSection } from "./tool-hints.ts";
 import { notifyNudge, notifyDeprecation } from "./notification.ts";
 import { registerCommands, type CommandUI } from "./commands.ts";
@@ -403,6 +402,24 @@ export default function solyExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	// First-party LLM tool that drives the same workflow verbs — lets the model
+	// start plan/execute/etc. itself on the user's natural-language intent,
+	// with no external subagent plugin. Reuses the workflow builders.
+	registerWorkflowTool(pi, {
+		getState: () => state,
+		getInteractiveRules: () =>
+			combinedRules()
+				.filter((r) => r.interactiveOnly)
+				.map((r) => r.relPath),
+		getActiveTools: () => pi.getActiveTools(),
+		getConfig: getActiveConfig,
+		onWorkflowUsed: resetSolyDrift,
+		setVerbLabel: (verb) => {
+			chrome.data.verbLabel = verb;
+			chrome.poke();
+		},
+	});
+
 	// ============================================================================
 	// Events
 	// ============================================================================
@@ -612,6 +629,44 @@ export default function solyExtension(pi: ExtensionAPI) {
 		persistRuleMtimes();
 	});
 
+	// Snapshot where the user is in the plan-branch workflow, for the proactive
+	// "suggested next step" section. Reads git branch (cached) + the plan dir on
+	// disk; the section builder itself is pure (nudge.ts).
+	const computeWorkflowSituation = (): WorkflowSituation => {
+		const branch = gitContext.branch;
+		const onPlanBranch =
+			!!branch && branch !== "master" && branch !== "main" && !branch.startsWith("HEAD");
+		const dirSlug = branch ? branch.replace(/\//g, "-") : null;
+		let planExists = false;
+		let planIsStub = false;
+		if (onPlanBranch && dirSlug && state.exists) {
+			const planFile = path.join(state.solyDir, "plans", dirSlug, "PLAN.md");
+			try {
+				const body = fs.readFileSync(planFile, "utf-8");
+				planExists = true;
+				planIsStub = body.includes("_Stub — fill in via");
+			} catch {
+				planExists = false;
+			}
+		}
+		const doneIds = new Set(state.tasks.filter((t) => t.status === "done").map((t) => t.id));
+		const readyTaskIds = state.tasks
+			.filter((t) => t.status === "ready" && t.dependsOn.every((d) => doneIds.has(d)))
+			.map((t) => t.id);
+		return {
+			hasProject: state.exists,
+			branch,
+			onPlanBranch,
+			// Target the branch name verbatim — the workflow builders accept
+			// `<prefix>/<slug>` and `<slug>` alike.
+			planSlug: onPlanBranch ? branch : null,
+			planExists,
+			planIsStub,
+			dirty: !!gitContext.statusShort && gitContext.statusShort.trim().length > 0,
+			readyTaskIds,
+		};
+	};
+
 	pi.on("before_agent_start", async (event, ctx) => {
 		// Keep the chrome (ctx%, model, phase) current for the upcoming turn.
 		updateChromeData(ctx);
@@ -698,6 +753,14 @@ export default function solyExtension(pi: ExtensionAPI) {
 			}),
 		);
 
+		// 7.05 Proactive "suggested next step" — always on when a project exists.
+		// Lets the model OFFER the next workflow action and call `soly_workflow`
+		// itself, so the user never has to remember a verb.
+		if (state.exists) {
+			const suggestion = buildSuggestionSection(computeWorkflowSituation());
+			if (suggestion) sections.push(suggestion);
+		}
+
 		// 7.1 Interactive-tool affordance hints (examples → html_artifact, options
 		// → decision_deck, …) — only on turns whose wording mentions them.
 		if (getActiveConfig().agent.toolHints) {
@@ -836,29 +899,6 @@ export default function solyExtension(pi: ExtensionAPI) {
 		}
 	});
 
-	// ============================================================================
-	// tool_result: inject a compact reminder of rules applicable to the file
-	// just edited/written, so the LLM sees them AT THE MOMENT of action (not
-	// 30 turns later when they've decayed in attention). The LLM is asked to
-	// confirm in its next message which rules were applied — closing the gap
-	// where rules loaded at the start of a turn are forgotten by the time the
-	// agent actually edits something.
-	// ============================================================================
-	pi.on("tool_result", async (event, _ctx) => {
-		if (!getActiveConfig().agent.preActionRuleReminder) return;
-		if (event.toolName !== "edit" && event.toolName !== "write") return;
-		if (event.isError) return; // tool failed — don't pile on
-		const input = event.input as { path?: string };
-		const filePath = input?.path;
-		if (!filePath) return;
-		const applicable = getApplicableRulesForFile(filePath, combinedRules());
-		const reminder = formatRuleReminder(applicable, filePath);
-		if (!reminder) return;
-		return {
-			content: [...event.content, { type: "text" as const, text: reminder }],
-		};
-	});
-
 	// ============================================================================
 	// Chrome: working-indicator telemetry lifecycle + reactive data refresh
 	// ============================================================================

package/nudge.ts

@@ -3,7 +3,8 @@
 // =============================================================================
 //
 // Goal: gently push the agent toward "ask before acting on non-trivial
-// tasks" and "use background subagents with fresh context for research".
+// tasks", "scout with soly's own read tools", and "route project work through
+// the soly workflow — proactively, without making the user memorize verbs".
 //
 // Implementation is prompt-only (no UI blocking) — the model reads the nudge
 // in its system prompt and follows it. Heuristics on the user prompt tell the
@@ -12,6 +13,11 @@
 //
 // The input event also surfaces a soft UI notify to the human, so they know
 // the model was told to pause and ask — but it never blocks input.
+//
+// `buildSuggestionSection` is a separate, always-on (when a project exists)
+// block that surfaces soly's computed "suggested next step" so the model can
+// proactively offer it and call the `soly_workflow` tool on the user's
+// confirmation — no external subagent plugin involved.
 // =============================================================================
 
 // Words that suggest the user is asking for non-trivial changes.
@@ -157,17 +163,19 @@ export function buildNudgeSection(
 		opts.hasProject && heuristics.nonTrivial
 			? `\n\n4. **Route project work through the soly plan workflow.** Each plan is a git branch with \`.agents/plans/<slug>/PLAN.md\` on it. Two parallel plans don't collide.
 
+   **Read the user's intent and act on it — don't make them memorize verbs.** When the user expresses a workflow intent in plain language — even loosely ("давай план", "let's plan this", "go", "start executing", "wrap it up") — call the \`soly_workflow\` tool with the matching action (\`new\` / \`plan\` / \`discuss\` / \`execute\` / \`done\`) instead of asking them to type a command. You propose the next step, they say what they want, you run it. Everything runs INLINE in this session — there is no external worker or subagent.
+
    **Branch naming convention for THIS project:** ${branchLine}
-   \`soly new <slug>\` applies the project prefix automatically. \`soly new <prefix>/<slug>\` overrides it (use this when the work isn't a "feature" — e.g. \`soly new fix/login-redirect-bug\`).
+   \`soly_workflow({action:"new", target:"<slug>"})\` applies the project prefix automatically. A \`<prefix>/<slug>\` target overrides it (use this when the work isn't a "feature" — e.g. \`fix/login-redirect-bug\`).
 
-   Lifecycle (text commands you type — pi routes them through the workflow handlers):
-      - \`soly new <slug-or-prefix>/<slug>\`   — scaffold: branch + plan dir + stub PLAN.md + commit
-      - \`soly discuss <slug>\`                — interactive discussion of the plan (uses ask_pro)
-      - \`soly plan <slug>\`                   — flesh out PLAN.md via ask_pro
-      - \`soly execute <slug>\`                — execute the plan in a subagent
-      - \`soly done <slug>\`                   — commit + push + open draft PR via gh
-      - \`soly verify\`                         — self-review loop until clean
-      - \`soly status\`                         — current position + progress (no LLM round-trip)
+   Lifecycle — call \`soly_workflow({action, target})\`, or the user can type the equivalent \`soly <verb>\` text:
+      - \`new\`      — scaffold: branch + plan dir + stub PLAN.md + commit
+      - \`discuss\`  — interactive discussion of the plan (uses ask_pro)
+      - \`plan\`     — flesh out PLAN.md via ask_pro
+      - \`execute\`  — execute the plan inline in THIS session
+      - \`done\`     — commit + push + open draft PR via gh
+      - \`soly verify\`  — self-review loop until clean (type this verb; it's a stateful loop)
+      - \`soly status\`  — current position + progress (no LLM round-trip)
 
    **You may scaffold a new plan yourself** when the user asks for a new piece of work and the scope is clear (or the user just confirmed). Propose the slug AND the full branch name first via ask_pro — offer the default \`${prefix ? prefix + "/" : ""}<slug>\` plus the alternatives \`fix/<slug>\`, \`chore/<slug>\`, or just \`<slug>\` (no prefix). Pick whatever fits the work, then type \`soly new …\` in your next output. Don't ask for trivial one-liners or when the user already said "go". Skip only for a genuine one-off that doesn't deserve a plan branch.
 
@@ -214,10 +222,76 @@ The following are user-set defaults, not project rules. They tell you how the us
 1. **Pre-action gate.** Before starting non-trivial work, take a 10-second pause and decide: do I have enough to act, or should I ask? If the prompt has ambiguity, missing scope, or a hidden assumption, surface one short clarifying question (or a small set of multi-choice options) instead of starting to code. Skip the gate for trivial fixes ("rename X", "add log line", "fix typo") and for follow-up turns in an already-clarified task.${confirmBlock}
    ${triggerLine}${anglesBlock}
 
-2. **Background subagents by default.** When you need to read unfamiliar code, scout a directory, gather external evidence, or run a multi-step review, prefer \`subagent(...)\` with \`async: true\` and \`context: "fresh"\` over doing it inline. Reserve your own context for the actual decision the user is paying you to make. If the work needs the parent conversation history, use \`context: "fork"\` instead. Do not silently block on long runs — launch async and continue with independent work.
+2. **Scout with soly's own read tools.** When you need to read unfamiliar code, map a directory, or gather context, use soly's read tools — \`soly_snippet(path, offset, limit)\`, \`soly_doc_search(query)\`, \`soly_read(...)\` — plus \`grep\` / \`find\`. Prefer bounded snippets over reading whole files. soly does the work INLINE in this session; there is no separate worker or \`subagent(...)\` tool to delegate to (and none is required).
+
+3. **Reach for soly's interaction tools.** For structured questions use \`ask_pro\` (batched, multi-select, ⭐ recommended); for design/architecture forks where the choice hinges on the concrete code shape use \`decision_deck\`; for visual output (galleries, comparisons, diagrams) use \`html_artifact\`. Give each question a concrete recommended default + rationale — don't dump open-ended prompts.${workflowPoint}
+
+Treat (1) and (2) as defaults, not laws. The user can always override per-task ("just do it", "ask me everything"). When overriding, briefly acknowledge it.
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Proactive "suggested next step" section (pillar C)
+// ---------------------------------------------------------------------------
+//
+// Always-on when a soly project exists (independent of the non-trivial
+// heuristic). soly computes where the user is in the workflow and surfaces the
+// single most useful next action so the model can OFFER it — and, on the
+// user's confirmation, call the `soly_workflow` tool itself. The user never
+// has to remember a verb.
+
+/** Snapshot of where the user is in the plan-branch workflow. Computed by the
+ *  caller (it needs git + fs); kept out of the pure section builder so the
+ *  builder stays trivially testable. */
+export interface WorkflowSituation {
+	/** A soly project (`.agents/`) exists in cwd. */
+	hasProject: boolean;
+	/** Current git branch, or null if not resolvable. */
+	branch: string | null;
+	/** Branch is a plan branch (not master/main, not detached). */
+	onPlanBranch: boolean;
+	/** Plan slug derived from the branch (drops any `<prefix>/`). */
+	planSlug: string | null;
+	/** `.agents/plans/<slug>/PLAN.md` exists on this branch. */
+	planExists: boolean;
+	/** The PLAN.md is still the scaffold stub (not fleshed out). */
+	planIsStub: boolean;
+	/** Working tree has uncommitted changes. */
+	dirty: boolean;
+	/** Task ids that are `status: ready` with all deps satisfied. */
+	readyTaskIds: string[];
+}
+
+/** Build the "suggested next step" system-prompt section. Pure. Returns "" when
+ *  there's no project (nothing to suggest). */
+export function buildSuggestionSection(sit: WorkflowSituation): string {
+	if (!sit.hasProject) return "";
+
+	// Decide the single best next action + how to invoke it.
+	let suggestion: string;
+	const slug = sit.planSlug ?? "<slug>";
+
+	if (sit.onPlanBranch && sit.planExists && sit.planIsStub) {
+		suggestion = `You're on plan branch \`${sit.branch}\` and its PLAN.md is still a scaffold stub. **Next:** flesh it out — \`soly_workflow({ action: "plan", target: "${slug}" })\` (or discuss first with \`action: "discuss"\`).`;
+	} else if (sit.onPlanBranch && sit.planExists && !sit.planIsStub) {
+		suggestion = sit.dirty
+			? `You're on plan branch \`${sit.branch}\` with a fleshed-out PLAN.md and uncommitted changes. **Next:** finish the work, then \`soly_workflow({ action: "done", target: "${slug}" })\` to commit + push + open the PR.`
+			: `You're on plan branch \`${sit.branch}\` with a ready PLAN.md. **Next:** execute it — \`soly_workflow({ action: "execute", target: "${slug}" })\`.`;
+	} else if (sit.onPlanBranch && !sit.planExists) {
+		suggestion = `You're on plan branch \`${sit.branch}\` but there's no \`.agents/plans/${slug}/PLAN.md\`. **Next:** scaffold it — \`soly_workflow({ action: "new", target: "${slug}" })\`.`;
+	} else if (sit.readyTaskIds.length > 0) {
+		const ids = sit.readyTaskIds.slice(0, 5).join(", ");
+		suggestion = `There ${sit.readyTaskIds.length === 1 ? "is 1 ready task" : `are ${sit.readyTaskIds.length} ready tasks`} (${ids}${sit.readyTaskIds.length > 5 ? ", …" : ""}). **Next:** execute one — \`soly_workflow({ action: "execute", target: "<task-id>" })\` — or start fresh work with \`action: "new"\`.`;
+	} else {
+		suggestion = `On \`${sit.branch ?? "the current branch"}\`, no plan in flight. **Next:** when the user describes a piece of work, scaffold a plan — \`soly_workflow({ action: "new", target: "<slug>" })\` — instead of editing files ad-hoc.`;
+	}
+
+	return `
+
+## soly — suggested next step
 
-3. **Subagent tool ergonomics.** When delegating: give the child a concrete role, scope, success criteria, hard constraints, and expected output. Do not pass vague instructions like "implement this" or "look into that". Async is the default; foreground is the explicit opt-out.${workflowPoint}
+${suggestion}
 
-Treat (1) and (2) as defaults, not laws. The user can always override per-task ("just do it", "ask me everything", "no subagents"). When overriding, briefly acknowledge it.
+**You propose; the user confirms; you run it.** When the user expresses intent in plain language — even loosely ("давай план", "let's build it", "go", "start", "wrap it up") — call the \`soly_workflow\` tool with the matching action yourself. Do NOT make the user type \`soly <verb>\` (that text form still works, but it's a fallback, not a requirement). Everything runs inline in this session — no external subagent.
 `;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-soly",
-  "version": "1.16.4",
-  "description": "Project management + workflow framework for pi-coding-agent. Plans, state, MANDATORY rules, self-review, multi-question picker, native footer + welcome chrome — one npm install, zero config. The LLM drives execution and delegates to a worker subagent when available.",
+  "version": "2.1.0",
+  "description": "Project management + workflow framework for pi-coding-agent. Plans, state, MANDATORY rules, self-review, multi-question picker, native footer + welcome chrome — one npm install, zero config. The LLM drives the workflow inline via the soly_workflow tool — no external subagent plugin.",
   "type": "module",
   "main": "index.ts",
   "scripts": {

package/skills/soly-framework/SKILL.md

@@ -47,17 +47,28 @@ Workflow verbs are **plain text** — type `soly <verb>` (NOT a slash command):
 | `/why` | What rules + state grounded the last turn |
 | `/rulewizard` | Rule vs .editorconfig vs linter guide |
 
-## Delegation
-
-`soly plan` and `soly execute` delegate the heavy work to a `worker` subagent
-(via the `subagent(...)` tool from pi-subagents); the parent session keeps the
-close-out (production commits → `SUMMARY.md` → `STATE.md` → then `soly verify`).
-If the `subagent` tool is NOT installed they run **inline** in the main session
-instead — `soly doctor` reports which mode is active. First-party delegation is
-on the roadmap. Other agents are read-only helpers: `oracle` (second opinion),
-`scout` (recon), `reviewer` (adversarial review). `soly discuss` is always
-interactive in the main session (not delegated). Rotors / `Ctrl+Tab` cycling
-were removed in 1.4.0.
+## How work runs (inline — no subagent plugin)
+
+soly runs everything **inline, in the main session**. `soly plan` and
+`soly execute` transform your request into a detailed instruction (the relevant
+workflow markdown, the iteration context bundle, the close-out discipline) and
+the model does the work itself — production commits → `SUMMARY.md` → `STATE.md`
+→ then `soly verify`. There is **no dependency on the external pi-subagents
+plugin** (removed in 2.0.0); nothing breaks when that plugin changes.
+
+**Two ways to drive the workflow — both hit the same code:**
+
+1. **Let the model propose and run it (preferred).** soly injects a "suggested
+   next step" into the system prompt every turn. Just say what you want in
+   plain language ("let's plan this", "go", "start executing", "wrap it up")
+   and the model calls the `soly_workflow` tool for you — you never have to
+   memorize a verb.
+2. **Type the verb yourself.** `soly plan <slug>`, `soly execute <slug>`, etc.
+   still work as plain-text input (a fallback for power users).
+
+`soly discuss` is always interactive in the main session. `soly verify` is a
+stateful self-review loop you start by typing `soly verify` (it's not a
+`soly_workflow` action).
 
 ## File structure
 
@@ -212,6 +223,7 @@ Once production commits exist, returning without a committed `SUMMARY.md` is an
 
 | Tool | Purpose |
 |---|---|
+| `soly_workflow(action, target?)` | Drive the lifecycle inline: `new` / `discuss` / `plan` / `execute` / `done`. Call it on the user's natural-language intent instead of making them type `soly <verb>`. Returns the workflow instruction to follow in this session |
 | `soly_read(artifact, phase, taskId)` | Read soly artifacts: STATE, plan, context, research, ROADMAP, requirements, project, milestone, task |
 | `soly_log_decision(decision, rationale, phase)` | Append to STATE.md Decisions table |
 | `soly_list_phases()` | List all phases with plan counts, C/R markers |
@@ -296,6 +308,6 @@ Call `soly_read(artifact: "state")` and `soly_read(artifact: "roadmap")` first.
 
 - ❌ Edit `.agents/rules/` files you didn't write — those are project invariants
 - ❌ Skip the SUMMARY — illegal partial state
-- ❌ 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.
+- ❌ Reach for a `subagent(...)` tool — soly runs inline, in this session. There is no soly subagent and no dependency on pi-subagents (removed in 2.0.0). Use `soly_workflow` (or the plain `soly <verb>` text) instead.
 - ❌ Edit `.agents/phases/*/PLAN.md` after `status: in_progress` — create a new plan
 - ❌ Put intent docs anywhere other than `.agents/docs/`

package/workflows/execute.ts

@@ -3,17 +3,17 @@
 // =============================================================================
 //
 // Intercepts "soly execute 11" (phase) or "soly execute 11.02" (specific plan)
-// and transforms it into a detailed LLM instruction that launches a worker
-// subagent with the soly execute workflow loaded into its system prompt.
+// and transforms it into a detailed LLM instruction that carries the soly
+// execute workflow inline.
 //
-// We use `action: "transform"` (not `action: "handled"`) — the LLM still
-// receives the request, but with the full workflow context, so it can call
-// the `subagent(...)` tool itself and apply the SOLY-specific close-out
-// discipline (commits, SUMMARY.md, STATE.md update).
+// We use `action: "transform"` (not `action: "handled"`) — the LLM receives
+// the request enriched with the full workflow context and executes it INLINE,
+// in the same session, applying the SOLY-specific close-out discipline
+// (commits, SUMMARY.md, STATE.md update).
 //
-// We do NOT spawn the subagent directly from the extension — `subagent(...)`
-// is a tool only available to the LLM (via pi-subagents), and the parent
-// session needs to keep ownership of the close-out loop.
+// No external subagent plugin is involved: the model does the work itself.
+// The same instruction is emitted whether the request arrives as the plain
+// "soly execute …" verb (input hook) or via the `soly_workflow` tool.
 // =============================================================================
 
 import * as fs from "node:fs";
@@ -67,7 +67,6 @@ export function buildExecuteTransform(
 	cmd: SolyCommand,
 	state: SolyState,
 	interactiveRules: string[] = [],
-	opts: { agent?: string } = {},
 ): ExecuteHandlerResult {
 	if (!state.exists) {
 		return {
@@ -165,7 +164,7 @@ export function buildExecuteTransform(
 		});
 		const inlineSummary = inlinePlanSummary(path.join(task.dir, "PLAN.md"));
 
-		const instruction = `soly execute ${target.taskId} — launching worker for task.
+		const instruction = `soly execute ${target.taskId} — executing task.
 
 **Task:** ${task.id}
 **Feature:** ${task.feature}
@@ -177,20 +176,13 @@ export function buildExecuteTransform(
 **Dir:** ${task.dir}
 
 **Iteration context file written:** \`${iter.relPath}\` (${iter.tokens} tokens, ${iter.bytes} bytes)
-The worker reads this file first — it contains intent, STATE, ROADMAP (n/a for tasks), the feature README, prior task SUMMARYs, and the current task PLAN.
+Read this file first — it contains intent, STATE, ROADMAP (n/a for tasks), the feature README, prior task SUMMARYs, and the current task PLAN.
 
-**0-POINT CHECK.** Worker must re-read .agents/docs/ (intent) and .agents/features/${task.feature}/README.md before implementing.
+**0-POINT CHECK.** Re-read .agents/docs/ (intent) and .agents/features/${task.feature}/README.md before implementing.
 
-**STUDY THE REPO.** The worker MUST use \`soly_snippet(path, offset, limit)\`, \`soly_doc_search(query)\`, and \`## project layout\` from the system prompt to understand the area before changing any file. Read at least: the module being modified, one similar feature for the pattern, and the corresponding test file. Do NOT change code based on assumptions about how the existing code works.
+**STUDY THE REPO.** Use \`soly_snippet(path, offset, limit)\`, \`soly_doc_search(query)\`, and \`## project layout\` from the system prompt to understand the area before changing any file. Read at least: the module being modified, one similar feature for the pattern, and the corresponding test file. Do NOT change code based on assumptions about how the existing code works.
 
-Launch a single subagent for this work. Do NOT do the work inline.
-
-subagent({
-  agent: ${JSON.stringify(opts.agent ?? "worker")},
-  context: "fresh",
-  async: true,
-  maxSubagentDepth: 1,
-  task: \`You are soly-executor (single-task writer).
+**Execute this now — inline, in THIS session. You are soly-executor (single-task writer). Do the work directly; there is no separate worker to delegate to.**
 
 Your job: execute ONE task (atomic unit) and produce its SUMMARY.md.
 
@@ -227,15 +219,12 @@ ${workflow}
 Hard rules:
   - Do not skip the close-out order: production commits -> SUMMARY commit -> status: done.
   - Do not modify any .agents/rules/ files.
-  - Do not run subagents yourself.
   - Do not start a task whose \`depends-on:\` lists tasks that are not \`done\`.
   - PATH DISCIPLINE: all files YOU create must live under \`.agents/\` (iteration, handoff, etc.) or under the project's source dirs. Never write to the project root.
-  - Return: changed files, commands run with exit codes, validation evidence, surprises, decisions needing parent approval.
-  - Interactive-only rules are NOT in scope for you: ${interactiveRules.length > 0 ? interactiveRules.join(", ") : "(none)"}.
-\`
-})
+  - Report as you go: changed files, commands run with exit codes, validation evidence, surprises, decisions needing user approval.
+  - Interactive-only rules are NOT in scope here: ${interactiveRules.length > 0 ? interactiveRules.join(", ") : "(none)"}.
 
-When the subagent completes, synthesize the result. Do not re-execute its work. Then suggest \`soly verify\` to self-review the change with fresh eyes before calling it done.`;
+When done, confirm the SUMMARY.md was written and the task flipped to \`status: done\`. Then suggest \`soly verify\` to self-review the change with fresh eyes before calling it done.`;
 		return { handled: true, transformedText: instruction };
 	}
 
@@ -272,7 +261,7 @@ When the subagent completes, synthesize the result. Do not re-execute its work.
 				`**v0.1 limitation:** tasks run sequentially, not in parallel. Parallel mode is v0.2.\n\n` +
 				`Ready tasks (in suggested order):\n` +
 				ready.map((t, i) => `  ${i + 1}. ${t.id}  [${t.kind}]  prio=${t.priority}`).join("\n") +
-				`\n\nLaunch a single subagent to execute them one at a time in this order. The subagent uses the task execution workflow (execute-task.md) per task.`,
+				`\n\nExecute them one at a time in this order, inline in this session, using the task execution workflow (execute-task.md) per task.`,
 		};
 	}
 
@@ -318,7 +307,7 @@ When the subagent completes, synthesize the result. Do not re-execute its work.
 **PLAN.md:** ${planFile}
 
 **Iteration context file written:** \`${iter.relPath}\` (${iter.tokens} tokens)
-The worker reads this file first — it contains intent, STATE, ROADMAP, the
+Read this file first — it contains intent, STATE, ROADMAP, the
 plan body inline, and any prior SUMMARYs for this plan (none on first run).
 
 **Inline plan body (so you have must-haves before reading the file):**
@@ -326,20 +315,13 @@ plan body inline, and any prior SUMMARYs for this plan (none on first run).
 ${planBody.slice(0, 4000)}${planBody.length > 4000 ? "\n…(truncated)" : ""}
 \`\`\`
 
-**0-POINT CHECK.** Worker must re-read .agents/docs/ (intent) before implementing.
+**0-POINT CHECK.** Re-read .agents/docs/ (intent) before implementing.
 
-**STUDY THE REPO.** Worker MUST use \`soly_snippet(path, offset, limit)\`, \`soly_doc_search(query)\`, and \`## project layout\` from the system prompt to map the area before editing. Read at least: the module(s) the plan touches, one adjacent feature for the convention, and any test files in the same area. Do NOT edit code on assumptions about how existing code is structured.
+**STUDY THE REPO.** Use \`soly_snippet(path, offset, limit)\`, \`soly_doc_search(query)\`, and \`## project layout\` from the system prompt to map the area before editing. Read at least: the module(s) the plan touches, one adjacent feature for the convention, and any test files in the same area. Do NOT edit code on assumptions about how existing code is structured.
 
 **Corporate reviewer — gap-hunt the plan first.** Re-read the entire PLAN.md end-to-end. Identify concrete gaps (file paths not named, error handling missing, boundary cases unmentioned, no test file cited, no migration plan for existing instances, etc.). If you find ANY material gap, use \`ask_pro\` to surface it to the user BEFORE editing a single file — phrase each question with a recommended default + 2-3 alternatives. Only after gaps are resolved (or explicitly accepted by the user) may implementation begin.
 
-Launch a single subagent to execute the plan. Do NOT do the work inline.
-
-subagent({
-  agent: ${JSON.stringify(opts.agent ?? "worker")},
-  context: "fresh",
-  async: true,
-  maxSubagentDepth: 1,
-  task: \`You are soly-executor. Execute the plan at \`${planFile}\` end-to-end.
+**Execute this now — inline, in THIS session. You are soly-executor. Execute the plan at \`${planFile}\` end-to-end. Do the work directly.**
 
 **FIRST ACTION — read the iteration context file:**
 \`\`\`
@@ -364,8 +346,8 @@ Hard rules:
   - When the plan is fully executed and verified, write a SUMMARY.md next to
     PLAN.md summarizing what was done, what was deferred, and any deviations.
   - Do not commit unless the workflow tells you to; the user reviews and merges.
-\`)
-}`;
+
+When done, suggest \`soly verify\` to self-review with fresh eyes, then \`soly done ${target.raw}\` to open the PR.`;
 		return { handled: true, transformedText: instruction };
 	}
 
@@ -451,26 +433,19 @@ The iteration context file lists all plans (their frontmatter) in section 6, gro
 		? `soly-executor (single-plan writer)`
 		: `soly-executor (wave-based parallel phase executor)`;
 
-	const instruction = `soly execute ${target.raw} — launching worker for ${targetDesc}.
+	const instruction = `soly execute ${target.raw} — executing ${targetDesc}.
 
 **Iteration context file written:** \`${iter.relPath}\` (${iter.tokens} tokens, ${iter.bytes} bytes)
-The worker reads this file first — it contains intent, STATE, ROADMAP row for this phase, phase CONTEXT, phase RESEARCH, prior SUMMARYs, ${isPlanLevel ? "and the current PLAN" : "and all PLAN frontmatter summaries"}, and (for exec) the Critical Anti-Patterns from .continue-here.md.
+Read this file first — it contains intent, STATE, ROADMAP row for this phase, phase CONTEXT, phase RESEARCH, prior SUMMARYs, ${isPlanLevel ? "and the current PLAN" : "and all PLAN frontmatter summaries"}, and (for exec) the Critical Anti-Patterns from .continue-here.md.
 
-**0-POINT CHECK — worker must read .agents/docs/ first.**
-These are the project's INTENT docs. The worker is about to implement tasks; if the implementation diverges from intent, it will be wrong even if the tests pass. Have the worker re-read .agents/docs/ (and any intent docs linked from PLAN.md) before each plan.
+**0-POINT CHECK — read .agents/docs/ first.**
+These are the project's INTENT docs. You are about to implement tasks; if the implementation diverges from intent, it will be wrong even if the tests pass. Re-read .agents/docs/ (and any intent docs linked from PLAN.md) before each plan.
 
 ${scopeBlock}
 
-Launch a single subagent for this work. Do NOT do the work inline.
-
-subagent({
-  agent: ${JSON.stringify(opts.agent ?? "worker")},
-  context: "fresh",
-  async: true,
-  maxSubagentDepth: 1,  // worker must not spawn sub-sub-agents
-  task: \`You are ${childRole}.
+**Execute this now — inline, in THIS session. You are ${childRole}. Do the work directly; there is no separate worker to delegate to.**
 
-Your job: ${isPlanLevel ? "execute ONE plan and produce its SUMMARY.md" : useTasks ? "execute the phase's ready tasks in dependency order, each producing its SUMMARY.md" : "execute ALL plans in this phase using wave-based parallel execution"}.
+Your job: ${isPlanLevel ? "execute ONE plan and produce its SUMMARY.md" : useTasks ? "execute the phase's ready tasks in dependency order, each producing its SUMMARY.md" : "execute ALL plans in this phase using wave-based sequential execution"}.
 
 **FIRST ACTION — read the iteration context file:**
 \`\`\`
@@ -499,14 +474,11 @@ ${workflow}
 Hard rules:
   - Do not skip the close-out order: production commits -> SUMMARY commit -> STATE/ROADMAP update.
   - Do not modify any .agents/rules/ files.
-  - Do not run subagents yourself.
   - PATH DISCIPLINE: all files YOU create must live under \`.agents/\` (e.g. .agents/iterations/, .agents/phases/<slug>/, .agents/HANDOFF.json) or under the project's source dirs. Never write PLAN/SUMMARY/CONTEXT/RESEARCH/iteration files to the project root.
-  - Return: changed files, commands run with exit codes, validation evidence, surprises, and any decisions needing parent approval.
-  - Interactive-only rules are NOT in scope for you: ${interactiveRules.length > 0 ? interactiveRules.join(", ") : "(none)"}. They describe how the user-facing conversation should go, not how to execute work.
-\`
-})
+  - Report as you go: changed files, commands run with exit codes, validation evidence, surprises, and any decisions needing user approval.
+  - Interactive-only rules are NOT in scope here: ${interactiveRules.length > 0 ? interactiveRules.join(", ") : "(none)"}. They describe how the user-facing conversation should go, not how to execute work.
 
-When the subagent completes, synthesize the result and confirm STATE.md was updated. Do not re-execute its work. Then suggest \`soly verify\` to self-review the work with fresh eyes before calling the phase done.`;
+When done, confirm STATE.md was updated. Then suggest \`soly verify\` to self-review the work with fresh eyes before calling the phase done.`;
 
 	return { handled: true, transformedText: instruction };
 }

package/workflows/index.ts

@@ -33,8 +33,9 @@ import type { SolyConfig } from "../config.js";
 
 export interface WorkflowsDeps {
 	getState: () => SolyState;
-	/** List of rule relPaths marked `interactive: true` — passed to subagent
-	 *  workers so they know which rules are explicitly out of scope. */
+	/** List of rule relPaths marked `interactive: true` — inlined into the
+	 *  execute instruction so the model knows which rules are explicitly out of
+	 *  scope for the execution work. */
 	getInteractiveRules: () => string[];
 	/** List of active tool names. Used to detect optional cross-extension
 	 *  dependencies (e.g. `ask_pro` from the separate `pi-ask` extension). */
@@ -55,24 +56,6 @@ export interface WorkflowsDeps {
 /** Verbs that put the session into a visible "mode" (shown in the chrome top bar). */
 const MODE_VERBS: readonly string[] = ["execute", "plan", "discuss", "resume"];
 
-/**
- * execute/plan instructions tell the model to launch a `subagent(...)`. That
- * tool is provided by the external pi-subagents plugin. When it's absent the
- * instruction is impossible, so prepend an authoritative override telling the
- * model to do the work inline instead — removing the silent breakage until
- * soly ships first-party delegation.
- */
-export function withSubagentPreflight(text: string, activeTools: string[]): string {
-	if (activeTools.includes("subagent")) return text;
-	return (
-		"> ⚠ The `subagent` tool is NOT installed in this session. Ignore any " +
-		'"launch a subagent / do not work inline" instruction below — instead do this ' +
-		"work yourself, inline, in THIS session, applying the same close-out discipline. " +
-		"(Install pi-subagents for delegated/parallel execution.)\n\n" +
-		text
-	);
-}
-
 export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 	const { getState, getInteractiveRules, getActiveTools, getConfig, onWorkflowUsed } = deps;
 
@@ -118,7 +101,7 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 		if (cmd.verb === "execute") {
 			const result = buildExecuteTransform(cmd, state, getInteractiveRules());
 			if (!result.handled || !result.transformedText) return;
-			return { action: "transform", text: withSubagentPreflight(result.transformedText, getActiveTools()) };
+			return { action: "transform", text: result.transformedText };
 		}
 
 		if (cmd.verb === "pause" || cmd.verb === "compact") {
@@ -137,7 +120,7 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 		if (cmd.verb === "plan") {
 			const result = buildPlanTransform(cmd, state);
 			if (!result.handled || !result.transformedText) return;
-			return { action: "transform", text: withSubagentPreflight(result.transformedText, getActiveTools()) };
+			return { action: "transform", text: result.transformedText };
 		}
 
 		if (cmd.verb === "discuss") {

package/workflows/inspect.ts

@@ -200,15 +200,15 @@ export function showDoctor(_cmd: unknown, state: SolyState, ui: InspectUI, confi
 		});
 	}
 
-	// 11. subagent tool (execute/plan delegate to it; without it they run inline)
+	// 11. execution model (always inline — no external subagent plugin)
 	if (state.exists) {
-		const hasSubagent = activeTools.includes("subagent");
+		const hasWorkflowTool = activeTools.includes("soly_workflow");
 		checks.push({
-			name: "subagent tool (delegated execution)",
-			status: hasSubagent ? "pass" : "info",
-			detail: hasSubagent
-				? "subagent tool loaded — soly execute/plan delegate to a worker"
-				: "not installed — soly execute/plan run inline in this session (install pi-subagents for delegated/parallel execution)",
+			name: "workflow execution (inline)",
+			status: hasWorkflowTool ? "pass" : "info",
+			detail: hasWorkflowTool
+				? "soly_workflow tool loaded — the model drives plan/execute/etc. inline in this session (no subagent plugin needed)"
+				: "soly_workflow tool not detected — the plain-text `soly <verb>` forms still run inline; reload if it's missing",
 		});
 	}
 

package/workflows/llm-tools.ts

@@ -0,0 +1,123 @@
+// =============================================================================
+// workflows/llm-tools.ts — `soly_workflow` tool (first-party, no subagents)
+// =============================================================================
+//
+// Exposes the soly lifecycle to the LLM as a single callable tool so the model
+// can drive the workflow itself in response to the user's natural-language
+// intent — instead of the user having to type `soly <verb>` by hand.
+//
+//   soly_workflow({ action: "new" | "plan" | "discuss" | "execute" | "done",
+//                   target?: "<slug>" | "<prefix>/<slug>" | "<N>" | "<task-id>" })
+//
+// The tool reuses the SAME builders the plain-text `soly <verb>` input hook
+// uses (buildNewTransform / buildPlanTransform / …), so there is exactly one
+// implementation of each verb. It returns the builder's instruction text as
+// the tool result — which flows back into the model's context, and the model
+// continues the work INLINE, in this session. No external subagent plugin.
+//
+// `verify` is intentionally NOT exposed here: it's a stateful self-review loop
+// driven by the interactive input channel (the user types `soly verify`).
+// Starting it mid-tool-call would fight the streaming turn.
+// =============================================================================
+
+import { Type } from "typebox";
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SolyCommand } from "./parser.ts";
+import { buildExecuteTransform } from "./execute.ts";
+import { buildPlanTransform, buildDiscussTransform } from "./planning.ts";
+import { buildNewTransform } from "./new.ts";
+import { buildDoneTransform } from "./done.ts";
+import type { SolyState } from "../core.js";
+import type { SolyConfig } from "../config.js";
+
+/** Actions the LLM can drive through `soly_workflow`. Order matches lifecycle. */
+export const WORKFLOW_ACTIONS = ["new", "discuss", "plan", "execute", "done"] as const;
+export type WorkflowAction = (typeof WORKFLOW_ACTIONS)[number];
+
+/** Actions that put the session into a visible "mode" (chrome top bar). */
+const MODE_ACTIONS: readonly WorkflowAction[] = ["execute", "plan", "discuss"];
+
+export interface WorkflowToolDeps {
+	getState: () => SolyState;
+	getInteractiveRules: () => string[];
+	getActiveTools: () => string[];
+	getConfig: () => SolyConfig;
+	/** Reset drift counters etc. (same hook the input handler fires). */
+	onWorkflowUsed?: () => void;
+	/** Set the active workflow-mode label shown in the chrome top bar. */
+	setVerbLabel?: (verb: string | null) => void;
+}
+
+/** Build the shared `{ handled, transformedText }` result for one action.
+ *  Pure dispatch over the existing builders — no side effects beyond what the
+ *  individual builders do (new/done touch git + ui.notify). */
+function dispatch(
+	action: WorkflowAction,
+	cmd: SolyCommand,
+	deps: WorkflowToolDeps,
+	ui: { notify: (t: string, level?: "info" | "warning" | "error") => void },
+	cwd: string,
+): { handled: boolean; transformedText?: string } {
+	const state = deps.getState();
+	switch (action) {
+		case "new":
+			return buildNewTransform(cmd, state, ui, cwd, deps.getConfig().plan.defaultBranchPrefix);
+		case "done":
+			return buildDoneTransform(cmd, state, ui, cwd, {
+				defaultBranchPrefix: deps.getConfig().plan.defaultBranchPrefix,
+			});
+		case "plan":
+			return buildPlanTransform(cmd, state);
+		case "execute":
+			return buildExecuteTransform(cmd, state, deps.getInteractiveRules());
+		case "discuss":
+			return buildDiscussTransform(cmd, state, {
+				hasAskPro: deps.getActiveTools().includes("ask_pro"),
+			});
+	}
+}
+
+export function registerWorkflowTool(pi: ExtensionAPI, deps: WorkflowToolDeps): void {
+	pi.registerTool({
+		name: "soly_workflow",
+		label: "soly workflow",
+		description:
+			"Drive the soly plan lifecycle in THIS session (no subagent needed). Call this when the user expresses intent to plan or ship work — even loosely (\"let's plan this\", \"go\", \"start executing\", \"wrap it up\"). Actions: `new` (scaffold a plan branch + stub PLAN.md), `discuss` (interactive scoping via ask_pro), `plan` (flesh out PLAN.md), `execute` (implement the plan inline), `done` (commit + push + draft PR). `target` is the plan slug / `<prefix>/<slug>` / phase number / task id (required for new/done; optional for the phase-based forms). The result is the full workflow instruction — follow it inline; do not delegate. (For the `verify` self-review loop, tell the user to type `soly verify` — it's a stateful loop, not a one-shot action.)",
+		promptSnippet:
+			"Run a soly workflow step (new/discuss/plan/execute/done) when the user asks to plan or ship work",
+		promptGuidelines: [
+			"Use soly_workflow when the user expresses intent to plan, discuss, execute, or finish a piece of work — call it yourself instead of asking them to type a `soly <verb>` command.",
+			"After soly_workflow returns, follow the returned instruction inline in this session; there is no separate worker to hand off to.",
+		],
+		parameters: Type.Object({
+			action: StringEnum([...WORKFLOW_ACTIONS] as [WorkflowAction, ...WorkflowAction[]]),
+			target: Type.Optional(
+				Type.String({
+					description:
+						"Plan slug (e.g. `auth-jwt`), `<prefix>/<slug>` (e.g. `fix/login-bug`), phase number (e.g. `3` or `3.02`), or task id. Required for new/done.",
+				}),
+			),
+		}),
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const action = params.action as WorkflowAction;
+			const target = (params.target ?? "").trim();
+			const cmd: SolyCommand = {
+				verb: action,
+				args: target ? target.split(/\s+/) : [],
+				raw: `soly ${action}${target ? ` ${target}` : ""}`,
+			};
+
+			// Same bookkeeping the input hook does for a recognized verb.
+			deps.onWorkflowUsed?.();
+			if (MODE_ACTIONS.includes(action)) deps.setVerbLabel?.(action);
+
+			const result = dispatch(action, cmd, deps, ctx.ui, ctx.cwd);
+			const text = result.transformedText ?? `soly_workflow: nothing to do for action "${action}".`;
+			return {
+				content: [{ type: "text", text }],
+				details: { action, target: target || null, handled: result.handled },
+			};
+		},
+	});
+}

package/workflows/parser.ts

@@ -8,8 +8,9 @@
 // Convention:
 //   - User types exactly "soly <verb> <args...>" (lowercase required for match)
 //   - The extension intercepts via the `input` event (no slash-command needed)
-//   - The handler transforms the input into a detailed LLM instruction that
-//     delegates to the `subagent(...)` tool (provided by pi-subagents)
+//   - The handler transforms the input into a detailed LLM instruction the
+//     model follows INLINE, in this session (the same instruction the
+//     `soly_workflow` tool returns). No external subagent plugin.
 //
 // This module is pure parsing — no I/O, no extension state. Trivial to unit
 // test in isolation.

package/workflows/planning.ts

@@ -8,8 +8,8 @@
 //                          phase before any planning starts (phase-only in v0.2)
 //
 // Both transform into LLM instructions that load the relevant workflow
-// markdown (plan-phase.md / plan-task.md / discuss-phase.md) and delegate
-// to a subagent.
+// markdown (plan-phase.md / plan-task.md / discuss-phase.md) inline — the
+// model does the planning itself, in the same session. No subagent plugin.
 // =============================================================================
 
 import * as fs from "node:fs";
@@ -172,13 +172,9 @@ These documents hold the project's INTENT — business context, design vision, w
 Phase directory: ${phase.dir}
 Current state:   planCount=${phase.planCount}, context=${phase.contextExists}, research=${phase.researchExists}
 
-Launch a subagent to produce the phase's tasks. Do NOT plan inline.
+**Plan this now — inline, in THIS session. You are the planner. Produce the phase's tasks directly.**
 
-subagent({
-  agent: "worker",
-  context: "fresh",
-  async: true,
-  task: \`You are a planner. Break phase ${target.phase} into discrete tasks (unified model): write one PLAN.md per task at phases/<NN>-slug/tasks/<task-id>/PLAN.md with frontmatter, plus ${phase.contextExists ? "" : "CONTEXT.md / "}RESEARCH.md if missing.
+Break phase ${target.phase} into discrete tasks (unified model): write one PLAN.md per task at phases/<NN>-slug/tasks/<task-id>/PLAN.md with frontmatter, plus ${phase.contextExists ? "" : "CONTEXT.md / "}RESEARCH.md if missing.
 
 **FIRST ACTION — read the iteration context file:**
 \`\`\`
@@ -203,11 +199,8 @@ Hard rules:
   - Each task PLAN needs requirements, must_haves.truths, must_haves.artifacts, must_haves.key_links.
   - PATH DISCIPLINE: all task PLAN.md / phase CONTEXT.md / RESEARCH.md go under \`.agents/phases/<NN>-<slug>/\`. Never write to the project root.
   - Update .agents/STATE.md Current Position at the end.
-  - Return: created task ids, the dependency order (which tasks are ready first), open questions.
-\`
-})
 
-When the subagent returns, summarize the tasks + their dependency order, then suggest \`soly execute ${target.phase}\` (or ask the user to confirm before execution).`;
+When done, summarize the created task ids + their dependency order (which are ready first) and any open questions, then suggest \`soly execute ${target.phase}\` (or ask the user to confirm before execution).`;
 		return { handled: true, transformedText: instruction };
 	}
 
@@ -278,13 +271,7 @@ ${inlineSummary}
 
 This task already has PLAN.md. Your job is to flesh it out / improve it based on intent and feature context — not to start from scratch.
 
-Launch a single subagent to refine the plan:
-
-subagent({
-  agent: "worker",
-  context: "fresh",
-  async: true,
-  task: \`You are a planner. Refine PLAN.md for an existing task.
+**Refine this now — inline, in THIS session. You are the planner. Refine PLAN.md for an existing task, directly.**
 
 **FIRST ACTION — read the iteration context file:**
 \`\`\`
@@ -309,11 +296,8 @@ Hard rules:
   - If you change the plan body materially, commit it as \`chore(tasks): refine plan <task-id>\`.
   - If you only add small clarifications, no commit needed (or include in same commit).
   - PATH DISCIPLINE: PLAN.md lives at \`.agents/features/<feature>/tasks/<id>/PLAN.md\`. Never write to the project root.
-  - Return: what changed, open questions, dependencies discovered.
-\`
-})
 
-When the subagent returns, summarize what was refined. Do not execute — planning only.`;
+When done, summarize what was refined (what changed, open questions, dependencies discovered). Do not execute — planning only.`;
 		return { handled: true, transformedText: instruction };
 	}
 
@@ -402,13 +386,7 @@ depends-on: []
 [body produced by the planner workflow below]
 \`\`\`
 
-Launch a single subagent to flesh out the plan body:
-
-subagent({
-  agent: "worker",
-  context: "fresh",
-  async: true,
-  task: \`You are a planner. Create a new task dir + write PLAN.md with frontmatter.
+**Do this now — inline, in THIS session. You are the planner. Create a new task dir + write PLAN.md with frontmatter, directly.**
 
 Project root: ${projectRoot}
 Soly dir:    ${state.solyDir}
@@ -428,11 +406,8 @@ Hard rules:
   - Pick a reasonable \`priority:\` (default: medium).
   - Leave \`depends-on:\` as \`[]\` unless you have a clear dep on an existing task.
   - Commit: \`chore(tasks): plan <id>\`.
-  - Return: created path, task id, plan summary.
-\`
-})
 
-When the subagent returns, show the user the new task id + summary. They can then run \`soly execute <id>\`.`;
+When done, show the user the created path, new task id + plan summary. They can then run \`soly execute <id>\`.`;
 		return { handled: true, transformedText: instruction };
 	}
 
@@ -479,7 +454,7 @@ When the subagent returns, show the user the new task id + summary. They can the
 				`soly plan --feature ${target.feature}: ${ready.length} task(s) need planning.\n\n` +
 				`Tasks:\n` +
 				ready.map((t, i) => `  ${i + 1}. ${t.id}  [${t.kind}]  prio=${t.priority}`).join("\n") +
-				`\n\nLaunch a single subagent to plan them in order. The subagent uses the plan-task.md workflow per task.`,
+				`\n\nPlan them in order, inline in this session, using the plan-task.md workflow per task.`,
 		};
 	}
 
@@ -614,7 +589,7 @@ Read it first — it contains intent, STATE, ROADMAP, and any existing phase art
 
 ${resumeBlock}
 
-**This is NOT a subagent task.** You're running interactively. Drive the discussion yourself, in this session, by asking the user a few questions one at a time.
+**This is interactive.** Drive the discussion yourself, in this session, by asking the user a few questions one at a time.
 
 ---