pi-soly 1.15.1 → 1.16.1

package/commands.ts

@@ -46,6 +46,12 @@ import type { SolyConfig } from "./config.ts";
 import { initSolyProject } from "./init.js";
 import { ListPanel, type ListItem, type ListAction } from "./visual/list-panel.ts";
 import { getArtifactServer, ensureArtifactServer, artifactDir } from "./artifact/session.ts";
+import { parseSolyCommand, type SolyCommand, type WorkflowVerb } from "./workflows/parser.ts";
+import { buildNewTransform } from "./workflows/new.ts";
+import { buildDoneTransform } from "./workflows/done.ts";
+import { buildMigrateTransform } from "./workflows/migrate.ts";
+import { buildPlanTransform, buildDiscussTransform } from "./workflows/planning.ts";
+import { buildExecuteTransform } from "./workflows/execute.ts";
 
 /** Minimum ui surface the command handlers actually need. */
 export interface CommandUI {
@@ -558,6 +564,70 @@ What must the LLM do?
 				description: string;
 				run: (parts: string[]) => void | Promise<void>;
 			};
+			/** Dispatch a workflow verb from the `/soly` slash-command picker.
+			 *  Same handlers used by the `soly <verb> ...` text-command path —
+			 *  registered here so humans can also drive them via
+			 *  `/soly <verb> ...` without having to type natural language and
+			 *  wait for the LLM to translate. */
+			const runWorkflow = async (
+				verb: WorkflowVerb,
+				parts: string[],
+				ctx: ExtensionCommandContext,
+				ui: CommandUI,
+			): Promise<void> => {
+				// parts[0] is the verb name; the args follow.
+				const args = parts.slice(1);
+				const cmd: SolyCommand = {
+					verb,
+					args,
+					raw: `soly ${verb}${args.length ? " " + args.join(" ") : ""}`,
+				};
+				const state = getState();
+				if (!state.exists) {
+					ui.notify("soly: no .agents/ project here — run `/soly init` to scaffold one", "info");
+					return;
+				}
+				switch (verb) {
+					case "new": {
+						const r = buildNewTransform(cmd, state, ui, ctx.cwd, getConfig().plan.defaultBranchPrefix);
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					case "done": {
+						const r = buildDoneTransform(cmd, state, ui, ctx.cwd, { defaultBranchPrefix: getConfig().plan.defaultBranchPrefix });
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					case "migrate": {
+						const r = buildMigrateTransform(state, ui, ctx.cwd);
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					case "plan": {
+						const r = buildPlanTransform(cmd, state);
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					case "discuss": {
+						// Slash-command path doesn't have live ask_pro detection.
+						// Pass `false` so the discuss transform falls back to its
+						// plain-text discussion format; the LLM-driven path still
+						// gets the richer ask_pro flow.
+						const r = buildDiscussTransform(cmd, state, { hasAskPro: false });
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					case "execute": {
+						// Slash-command path doesn't have live interactive rules.
+						const r = buildExecuteTransform(cmd, state, []);
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					default:
+						ui.notify(`soly: workflow '${verb}' not yet wired into slash command`, "info");
+						return;
+				}
+			};
 			const subcommands: Record<string, SolySub> = {
 				// `agent` subcommand REMOVED — moved to the separate `pi-switch`
 				// extension (rotor switcher removed in 1.4.0).
@@ -612,17 +682,25 @@ What must the LLM do?
 					run: () => showFile("STATE.md", getState().stateBody),
 				},
 				plan: {
-					description: "current PLAN.md body",
-					run: () => {
-						const s = getState();
-						if (!s.currentPlanPath) {
-							ui.notify("soly: no current plan", "error");
+					description: "current PLAN.md body, OR `plan <slug>` to flesh out a plan",
+					run: (parts) => {
+						// Dual-purpose: no args = show current PLAN.md; with args
+						// = dispatch to the plan-mode workflow. Same key the
+						// state picker already had (state picker items and
+						// workflow verbs share the same `/soly` namespace).
+						if (parts.length <= 1) {
+							const s = getState();
+							if (!s.currentPlanPath) {
+								ui.notify("soly: no current plan", "error");
+								return;
+							}
+							showFile(
+								`PLAN: ${path.basename(s.currentPlanPath)}`,
+								readIfExists(s.currentPlanPath),
+							);
 							return;
 						}
-						showFile(
-							`PLAN: ${path.basename(s.currentPlanPath)}`,
-							readIfExists(s.currentPlanPath),
-						);
+						void runWorkflow("plan", parts, ctx, ui);
 					},
 				},
 				context: {
@@ -797,6 +875,35 @@ What must the LLM do?
 						);
 					},
 				},
+				// ------------------------------------------------------------------
+				// Workflow verbs — same handlers used by the `soly <verb> ...`
+				// text-command path. Registered here so humans can also drive
+				// them via `/soly <verb> ...` from the slash picker without
+				// typing natural language and waiting for the LLM to translate.
+				// Each verb's buildXxxTransform already calls ui.notify on
+				// success, so we just need to construct a fake `SolyCommand`
+				// from the slash args and call the handler.
+				// ------------------------------------------------------------------
+				new: {
+					description: "scaffold a new plan: create branch + .agents/plans/<slug>/PLAN.md (e.g. `/soly new statistic-preparation`)",
+					run: (parts) => runWorkflow("new", parts, ctx, ui),
+				},
+				execute: {
+					description: "execute a plan via subagent (e.g. `/soly execute statistic-preparation`)",
+					run: (parts) => runWorkflow("execute", parts, ctx, ui),
+				},
+				discuss: {
+					description: "interactive discussion of a plan (e.g. `/soly discuss statistic-preparation`)",
+					run: (parts) => runWorkflow("discuss", parts, ctx, ui),
+				},
+				done: {
+					description: "commit + push + open draft PR for a plan branch (e.g. `/soly done statistic-preparation`)",
+					run: (parts) => runWorkflow("done", parts, ctx, ui),
+				},
+				migrate: {
+					description: "one-shot: import .agents/phases/<NN>-<slug>/plans/PLAN.md as plan branches",
+					run: () => runWorkflow("migrate", [], ctx, ui),
+				},
 			};
 
 			// Single-width BMP glyphs only — astral/VS16 emoji are mis-measured by

package/config.ts

@@ -121,6 +121,18 @@ export interface SolyConfig {
 		 *  0 = keep forever. */
 		retentionDays: number;
 	};
+	plan: {
+		/** Optional branch prefix prepended when the user runs `soly new <slug>`
+		 *  without an explicit `<prefix>/<slug>` form. Common values:
+		 *    "feature"   → branches like `feature/statistic-preparation`
+		 *    "fix"       → branches like `fix/login-redirect`
+		 *    "" (default)→ no prefix; branch = slug verbatim.
+		 *  Per-project only (set in `.agents/soly.json`). User-supplied
+		 *  `<prefix>/<slug>` always wins over this default.
+		 *  Plan dir is always `.agents/plans/<prefix>-<slug>` (flattened)
+		 *  so the on-disk layout stays one-deep. */
+		defaultBranchPrefix: string;
+	};
 }
 
 export const DEFAULT_CONFIG: SolyConfig = {
@@ -184,6 +196,9 @@ export const DEFAULT_CONFIG: SolyConfig = {
 		theme: "",
 		retentionDays: 7,
 	},
+	plan: {
+		defaultBranchPrefix: "", // "" = no prefix; branch = slug verbatim
+	},
 };
 
 /** Raw parsed shape from a config.json — could be partial, could have wrong types. */
@@ -256,6 +271,13 @@ function deepMerge(base: SolyConfig, over: RawConfig): SolyConfig {
 	if (over.editor && typeof over.editor.command === "string") {
 		merged.editor.command = over.editor.command;
 	}
+	if (over.plan && typeof over.plan.defaultBranchPrefix === "string") {
+		// Sanitize: allow only kebab-case words (no slashes, dots, etc.).
+		// Empty string is allowed and means "no prefix".
+		const sanitized = over.plan.defaultBranchPrefix.replace(/[^a-z0-9-]/gi, "");
+		const collapsed = sanitized.replace(/-+/g, "-").replace(/^-|-$/g, "");
+		merged.plan.defaultBranchPrefix = collapsed;
+	}
 	if (over.chrome) {
 		if (typeof over.chrome.enabled === "boolean") merged.chrome.enabled = over.chrome.enabled;
 		if (typeof over.chrome.ascii === "boolean") merged.chrome.ascii = over.chrome.ascii;

package/index.ts

@@ -694,6 +694,7 @@ export default function solyExtension(pi: ExtensionAPI) {
 			buildNudgeSection(heuristics, {
 				hasProject: state.exists,
 				confirmBeforeCode: getActiveConfig().agent.confirmBeforeCode,
+				defaultBranchPrefix: getActiveConfig().plan.defaultBranchPrefix,
 			}),
 		);
 

package/nudge.ts

@@ -117,7 +117,11 @@ const ASK_DIRECTIVE = `**Confirm before coding.** Don't jump straight into writi
 
 export function buildNudgeSection(
 	heuristics: TaskHeuristics,
-	opts: { hasProject?: boolean; confirmBeforeCode?: boolean | ConfirmLevel } = {},
+	opts: {
+		hasProject?: boolean;
+		confirmBeforeCode?: boolean | ConfirmLevel;
+		defaultBranchPrefix?: string;
+	} = {},
 ): string {
 	// Always-on rules (cheap to add, high signal):
 	//   - Don't dive in on non-trivial tasks without a brief check
@@ -142,10 +146,30 @@ export function buildNudgeSection(
 		: "";
 
 	// When there's an active soly project and the task is non-trivial, steer the
-	// model toward the workflow lifecycle instead of ad-hoc edits.
+	// model toward the workflow lifecycle instead of ad-hoc edits. This block
+	// also tells the model it may *itself* scaffold a new plan after asking the
+	// user — the user explicitly opted into this in 1.16.0.
+	const prefix = opts.defaultBranchPrefix ?? "";
+	const branchLine = prefix
+		? `Branches look like \`${prefix}/<slug>\` (the project default is **\`"${prefix}"\`**). Plan dir: \`.agents/plans/${prefix}-<slug>/\`.`
+		: `Branches look like \`<slug>\` (no project default prefix is set). Plan dir: \`.agents/plans/<slug>/\`.`;
 	const workflowPoint =
 		opts.hasProject && heuristics.nonTrivial
-			? `\n\n4. **Route project work through the soly workflow.** For phase/task work in \`.agents/\`, prefer the lifecycle over ad-hoc edits: \`soly discuss <N>\` (scope) → \`soly plan <N>\` (write tasks) → \`soly execute <N>\` (do them) → \`soly verify\` (review). Run \`soly status\` to see where you are. Skip only for a genuine one-off.`
+			? `\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.
+
+   **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\`).
+
+   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)
+
+   **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.`
 			: "";
 
 	// Confirm-before-coding gate: for non-trivial implementation, pull the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-soly",
-  "version": "1.15.1",
+  "version": "1.16.1",
   "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.",
   "type": "module",
   "main": "index.ts",

package/workflows/done.ts

@@ -84,7 +84,7 @@ export function buildDoneTransform(
 	state: SolyState,
 	ui: Notifier,
 	projectRoot: string,
-	opts: { ghPath?: string } = {},
+	opts: { ghPath?: string; defaultBranchPrefix?: string } = {},
 ): DoneResult {
 	if (!state.exists) {
 		return reply(`soly done: no .agents/ directory in cwd — run /soly init first.`);
@@ -93,10 +93,11 @@ export function buildDoneTransform(
 	const raw = cmd.args.join(" ").trim();
 	const parsed = parsePlanName(raw);
 	if ("error" in parsed) {
-		return reply(`soly done: ${parsed.error}\n\nUsage: soly done <type>/<name>`);
+		return reply(`soly done: ${parsed.error}\n\nUsage: soly done <slug> OR soly done <prefix>/<slug>`);
 	}
-	const { type, name } = parsed;
-	const branchName = `${type}/${name}`;
+	const { name, prefix } = parsed;
+	const effectivePrefix = prefix ?? opts.defaultBranchPrefix ?? "";
+	const branchName = effectivePrefix ? `${effectivePrefix}/${name}` : name;
 
 	// 1. Preconditions
 	const currentBranch = git(["branch", "--show-current"], { cwd: projectRoot });
@@ -126,7 +127,7 @@ export function buildDoneTransform(
 			// Re-check after add
 			const statusAfter = git(["status", "--short"], { cwd: projectRoot });
 			if (statusAfter) {
-				git(["commit", "-m", `${type}(${name}): wip`], { cwd: projectRoot });
+				git(["commit", "-m", `${name}: wip`], { cwd: projectRoot });
 			}
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);

package/workflows/index.ts

@@ -148,7 +148,13 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 		}
 
 		if (cmd.verb === "new") {
-			const result = buildNewTransform(cmd, state, ctx.ui, ctx.cwd);
+			const result = buildNewTransform(
+				cmd,
+				state,
+				ctx.ui,
+				ctx.cwd,
+				getConfig().plan.defaultBranchPrefix,
+			);
 			if (!result.handled || !result.transformedText) return;
 			// Direct execution (the workflow already called ui.notify). The
 			// transformed text goes to the model so it can also tell the user
@@ -157,7 +163,9 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 		}
 
 		if (cmd.verb === "done") {
-			const result = buildDoneTransform(cmd, state, ctx.ui, ctx.cwd);
+			const result = buildDoneTransform(cmd, state, ctx.ui, ctx.cwd, {
+				defaultBranchPrefix: getConfig().plan.defaultBranchPrefix,
+			});
 			if (!result.handled || !result.transformedText) return;
 			// Direct execution — workflow already called ui.notify. The
 			// transformed text tells the LLM (and the user in chat) what happened.

package/workflows/new.ts

@@ -80,6 +80,7 @@ export function buildNewTransform(
 	state: SolyState,
 	ui: Notifier,
 	projectRoot: string,
+	defaultBranchPrefix = "",
 ): NewResult {
 	if (!state.exists) {
 		return reply(`soly new: no .agents/ directory in cwd — run /soly init first.`);
@@ -88,13 +89,18 @@ export function buildNewTransform(
 	const parsed = parsePlanName(cmd.args.join(" "));
 	if ("error" in parsed) return reply(`soly new: ${parsed.error}`);
 
-	const { type, name } = parsed;
-	const branchName = `${type}/${name}`;
-	// Path used by `git add`/`commit` — relative to projectRoot (where `.git/` is).
-	// The plan lives at `<root>/.agents/plans/<name>/`, so the repo-relative path
-	// is `.agents/plans/<name>`.
-	const planDirRel = `.agents/plans/${name}`;
-	const planDirAbs = `${state.solyDir}/plans/${name}`;
+	const { name, prefix } = parsed;
+	// Branch can be one of three shapes:
+	//   - "feature/statistic-preparation" (user typed <prefix>/<slug>)
+	//   - "feature/statistic-preparation" (config has defaultBranchPrefix "feature", user typed "statistic-preparation")
+	//   - "statistic-preparation"          (no prefix anywhere)
+	// The plan dir is always flattened to keep the on-disk layout one-deep:
+	// `.agents/plans/<prefix>-<slug>` or `.agents/plans/<slug>`.
+	const effectivePrefix = prefix ?? defaultBranchPrefix;
+	const branchName = effectivePrefix ? `${effectivePrefix}/${name}` : name;
+	const dirSlug = effectivePrefix ? `${effectivePrefix}-${name}` : name;
+	const planDirRel = `.agents/plans/${dirSlug}`;
+	const planDirAbs = `${state.solyDir}/plans/${dirSlug}`;
 	const planFile = `${planDirAbs}/PLAN.md`;
 
 	// 1. Preconditions
@@ -116,7 +122,15 @@ export function buildNewTransform(
 	}
 
 	const currentBranch = git(["branch", "--show-current"], { cwd: projectRoot }) || "HEAD (detached)";
-	if (currentBranch !== "master" && currentBranch !== "main" && !/^[a-z]+\//.test(currentBranch)) {
+	// A plan branch is a kebab-case slug (no `<type>/` prefix after 1.15.x).
+	// The branch can also be the long-lived integration branches `master`
+	// or `main`. Anything else (release tags, weird suffixes) → user must
+	// checkout first.
+	if (
+		currentBranch !== "master" &&
+		currentBranch !== "main" &&
+		!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(currentBranch)
+	) {
 		return reply(
 			`soly new: currently on "${currentBranch}" (not master/main, not a soly plan branch). ` +
 				`Switch back to master first with \`git checkout master\`.`,

package/workflows/parser.ts

@@ -21,36 +21,81 @@ export type WorkflowVerb =
 	| "plan" | "discuss" | "help" | "doctor" | "iterations" | "phase" | "todos" | "verify"
 	| "new" | "done" | "migrate";
 
-/** Allowed Conventional Commits types for `soly new` / `soly plan <type>/<name>` / etc. */
-export const PLAN_TYPES = ["feat", "fix", "chore", "refactor", "docs", "test", "perf", "build", "ci"] as const;
-
 /**
- * Validate `<type>/<name>` (e.g. `feat/auth-jwt`). Returns parsed parts or
+ * Validate `<slug>` (e.g. `statistic-preparation`). Returns parsed parts or
  * an error message. Pure — no I/O. Shared by `soly new` (workflows/new.ts)
  * and the plan-mode dispatch in `describePlanTarget` / `describeExecuteTarget`.
+ *
+ * Convention: a plan is a kebab-case slug that doubles as the git branch
+ * name. No type prefix — we dropped the Conventional-Branches `<type>/<name>`
+ * shape after 1.15.x because the type adds noise without information for
+ * `soly new` users (the branch list itself is the registry, and the prefix
+ * doesn't help readers pick the right branch).
+ *
+ * Examples:
+ *   soly new statistic-preparation
+ *   soly new login-redirect-bug
+ *   soly new stats-rollup
  */
-export function parsePlanName(raw: string): { type: string; name: string } | { error: string } {
+export function parsePlanName(
+	raw: string,
+): { name: string; prefix: string | null } | { error: string } {
 	const trimmed = raw.trim();
 	if (!trimmed) return { error: "missing plan name" };
-	const m = trimmed.match(/^([a-z]+)\/([a-z0-9][a-z0-9-]*[a-z0-9])$/);
-	if (!m) {
+
+	// Optional `<prefix>/<slug>` form: prefix is one kebab-case word
+	// (no internal slashes), slug is the same kebab-case shape. Examples:
+	//   feature/statistic-preparation
+	//   fix/login-redirect-bug
+	//   chore/upgrade-deps
+	// Plan dirs flatten the slash: `.agents/plans/<prefix>-<slug>`.
+	const slashIdx = trimmed.indexOf("/");
+	if (slashIdx > 0) {
+		const prefix = trimmed.slice(0, slashIdx);
+		const slug = trimmed.slice(slashIdx + 1);
+		const prefixOk = /^[a-z][a-z0-9-]*[a-z0-9]$/.test(prefix);
+		const slugOk = /^[a-z][a-z0-9-]*[a-z0-9]$/.test(slug);
+		if (!prefixOk || !slugOk) {
+			return {
+				error:
+					`bad plan name "${trimmed}".\n` +
+					`\nExpected: <slug> OR <prefix>/<slug>\n` +
+					`  prefix: one kebab-case word (e.g. "feature", "fix", "chore")\n` +
+					`  slug:   kebab-case (lowercase letters, digits, hyphens)\n` +
+					`\nExample: soly new feature/statistic-preparation`,
+			};
+		}
+		return { name: slug, prefix };
+	}
+
+	// Plain slug form. Must contain at least one letter — pure-digit strings
+	// are reserved for phase numbers (`soly plan 11` → phase 11), not slugs.
+	if (!/[a-z]/.test(trimmed)) {
 		return {
 			error:
 				`bad plan name "${trimmed}".\n` +
-				`\nExpected: <type>/<name>\n` +
-				`  type  = one of ${PLAN_TYPES.join(", ")}\n` +
-				`  name  = kebab-case\n` +
-				`\nExample: soly plan feat/auth-jwt`,
+				`\nExpected: <slug> OR <prefix>/<slug>\n` +
+				`  chars:  lowercase letters, digits, and hyphens\n` +
+				`         must start and end with a letter or digit\n` +
+				`\nExample: soly new statistic-preparation`,
 		};
 	}
-	const [, type, name] = m;
-	if (!(PLAN_TYPES as readonly string[]).includes(type as string)) {
-		return { error: `bad type "${type}". Must be one of: ${PLAN_TYPES.join(", ")}` };
+	const m = trimmed.match(/^[a-z0-9][a-z0-9-]*[a-z0-9]$/);
+	if (!m) {
+		return {
+			error:
+				`bad plan name "${trimmed}".\n` +
+				`\nExpected: <slug> OR <prefix>/<slug>\n` +
+				`  length: 2-64 chars\n` +
+				`  chars:  lowercase letters, digits, and hyphens\n` +
+				`         must start and end with a letter or digit\n` +
+				`\nExample: soly new statistic-preparation`,
+		};
 	}
-	if ((name as string).length > 64) {
-		return { error: `name "${name}" is too long (max 64 chars)` };
+	if (trimmed.length > 64) {
+		return { error: `name "${trimmed}" is too long (max 64 chars)` };
 	}
-	return { type: type as string, name: name as string };
+	return { name: trimmed, prefix: null };
 }
 
 export interface SolyCommand {
@@ -160,7 +205,10 @@ function parsePhaseOnlyShape(s: string): { phase: number } | null {
 
 /** Match task-id `<slug>-<4hex>`, case-insensitive. */
 function parseTaskIdShape(s: string): string | null {
-	return s.match(/^[a-z0-9][a-z0-9-]*-[a-f0-9]{4}$/i) ? s : null;
+	const m = s.match(/^([a-z0-9][a-z0-9-]*)-([a-f0-9]{4})$/i);
+	if (!m) return null;
+	// Normalize to lowercase hex so downstream comparisons match.
+	return `${m[1]}-${m[2].toLowerCase()}`;
 }
 
 /** Extract `--feature <name>` from args. Returns null if not present or invalid. */
@@ -193,7 +241,7 @@ function parseNewTaskFlag(
  */
 export type ExecuteTarget =
 	| { kind: "phase"; phase: number; plan: number | null; raw: string }
-	| { kind: "plan"; type: string; name: string; raw: string }
+	| { kind: "plan"; name: string; raw: string }
 	| { kind: "task"; taskId: string; raw: string }
 	| { kind: "all"; raw: string }
 	| { kind: "feature"; feature: string; raw: string };
@@ -228,10 +276,18 @@ export function describeExecuteTarget(args: string[]): ExecuteTarget | null {
 	const target = positional.trim();
 	if (!target) return null;
 
-	// <type>/<name> plan name — same identifier model as `soly new`.
+	// <slug> plan name — same identifier model as `soly new`. Checked AFTER
+	// task ids because some task ids look exactly like plan slugs (e.g.
+	// `auth-be-login-a3f9` matches the kebab-case regex). Task-id check
+	// is more specific (trailing 4-hex) so it wins.
+	const taskId = parseTaskIdShape(target);
+	if (taskId) {
+		return { kind: "task", taskId, raw };
+	}
+
 	const plan = parsePlanName(target);
 	if (!("error" in plan)) {
-		return { kind: "plan", type: plan.type, name: plan.name, raw };
+		return { kind: "plan", name: plan.name, raw };
 	}
 
 	const phase = parsePhaseShape(target);
@@ -239,11 +295,6 @@ export function describeExecuteTarget(args: string[]): ExecuteTarget | null {
 		return { kind: "phase", phase: phase.phase, plan: phase.plan, raw };
 	}
 
-	const taskId = parseTaskIdShape(target);
-	if (taskId) {
-		return { kind: "task", taskId, raw };
-	}
-
 	return null;
 }
 
@@ -262,7 +313,7 @@ export function describeExecuteTarget(args: string[]): ExecuteTarget | null {
  */
 export type PlanTarget =
 	| { kind: "phase"; phase: number; raw: string }
-	| { kind: "plan"; type: string; name: string; raw: string }
+	| { kind: "plan"; name: string; raw: string }
 	| { kind: "task"; taskId: string; raw: string }
 	| { kind: "new-task"; slug: string; feature: string; raw: string }
 	| { kind: "feature"; feature: string; raw: string };
@@ -298,11 +349,19 @@ export function describePlanTarget(args: string[]): PlanTarget | null {
 	const target = positional.trim();
 	if (!target) return null;
 
-	// <type>/<name> plan name (e.g. feat/auth-jwt) — plans live at
-	// .agents/plans/<name>/PLAN.md, identity is the branch name.
+	// <slug> plan name (e.g. statistic-preparation) — plans live at
+	// .agents/plans/<slug>/PLAN.md, identity is the branch name. Checked
+	// AFTER task ids because some task ids look exactly like plan slugs
+	// (e.g. `auth-be-login-a3f9` matches the kebab-case regex). Task-id
+	// check is more specific (trailing 4-hex) so it wins.
+	const taskId = parseTaskIdShape(target);
+	if (taskId) {
+		return { kind: "task", taskId, raw };
+	}
+
 	const plan = parsePlanName(target);
 	if (!("error" in plan)) {
-		return { kind: "plan", type: plan.type, name: plan.name, raw };
+		return { kind: "plan", name: plan.name, raw };
 	}
 
 	// Plan target only matches plain N (no .MM — plan is per-phase, executed
@@ -312,10 +371,5 @@ export function describePlanTarget(args: string[]): PlanTarget | null {
 		return { kind: "phase", phase: phase.phase, raw };
 	}
 
-	const taskId = parseTaskIdShape(target);
-	if (taskId) {
-		return { kind: "task", taskId, raw };
-	}
-
 	return null;
 }