pi-soly 1.15.0 → 1.16.0

package/ask/picker.ts

@@ -498,7 +498,11 @@ export class AskProComponent extends Container {
 	 *  string in a multi answer). Returns "" if no custom string. */
 	private getCustomString(ans: AskAnswer | AskMultiAnswer | undefined): string {
 		if (ans === undefined) return "";
+		// Single-pick answers are numbers — not an array, so .find() would crash.
+		// Cover the string case (typed Other… in single-pick) and treat numeric
+		// answers as "no custom string yet".
 		if (typeof ans === "string") return ans;
+		if (typeof ans === "number") return "";
 		const found = (ans as AskMultiAnswer).find((a) => typeof a === "string");
 		return typeof found === "string" ? found : "";
 	}

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);
+						if (r.handled && r.transformedText) ui.notify(r.transformedText, "info");
+						return;
+					}
+					case "done": {
+						const r = buildDoneTransform(cmd, state, ui, ctx.cwd);
+						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/nudge.ts

@@ -142,10 +142,23 @@ 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 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 named by a kebab-case slug (\`statistic-preparation\`, \`login-redirect-bug\`, \`stats-rollup\`, …) with \`.agents/plans/<slug>/PLAN.md\` on it. Two parallel plans don't collide.
+
+   Lifecycle (text commands you type — pi routes them through the workflow handlers):
+      - \`soly new <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 first via ask_pro (\"I'll create plan 'statistic-preparation' — continue?\"), then type \`soly new statistic-preparation\` in your next output. Don't ask for confirmation on 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.0",
+  "version": "1.16.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 execution and delegates to a worker subagent when available.",
   "type": "module",
   "main": "index.ts",

package/workflows/done.ts

@@ -93,10 +93,10 @@ 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>`);
 	}
-	const { type, name } = parsed;
-	const branchName = `${type}/${name}`;
+	const { name } = parsed;
+	const branchName = name;
 
 	// 1. Preconditions
 	const currentBranch = git(["branch", "--show-current"], { cwd: projectRoot });
@@ -126,7 +126,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);
@@ -194,6 +194,9 @@ export function buildDoneTransform(
 		`  Commit:   ${commitHash.slice(0, 7)}\n` +
 		`  Pushed:   ${pushed ? "yes" : "no (no origin remote)"}\n` +
 		`  ${prLine}`;
+
+	// (No registry file to update — the plan's git branch IS the source of
+	// truth for "active plans". See PLAN.md / "Out of scope" for the trade-off.)
 	ui.notify(notice, "info");
 	return {
 		handled: true,

package/workflows/new.ts

@@ -88,8 +88,11 @@ 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}`;
+	const { name } = parsed;
+	// Branch IS the slug (no <type>/ prefix). Convention chosen over
+	// Conventional-Branches because `soly new` users tend to give a full
+	// descriptive name already; the type prefix adds noise without info.
+	const branchName = 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>`.
@@ -116,7 +119,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,54 @@ 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 } | { 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) {
+	// Must contain at least one letter — pure-digit strings are reserved for
+	// phase numbers (`soly plan 11` → phase 11), not plan 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> (kebab-case, no type prefix, must contain a letter)\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`,
 		};
 	}
-	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> (kebab-case, no type prefix)\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 };
 }
 
 export interface SolyCommand {
@@ -160,7 +178,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 +214,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 +249,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 +268,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 +286,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 +322,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 +344,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;
 }