pi-soly 1.11.2 → 1.12.0

package/visual/topbar.ts

@@ -0,0 +1,55 @@
+// =============================================================================
+// visual/topbar.ts — soly's top "polosa" (aboveEditor widget)
+// =============================================================================
+//
+//   execute ───────────────────────────────────────────  ⊙ opus-4.8 · high
+//   └─ left: verb                   right: model (+ thinking level) ─┘
+//
+// Carries soly's active *workflow verb* only (phase moved to the footer).
+// Hidden entirely (renders []) when no verb is active — so ordinary sessions
+// show no extra line. The model is shown here when the bar is visible, and in
+// the footer otherwise (see footer.ts), so it never appears twice.
+// =============================================================================
+
+import type { Component } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { composeBar, type Segment } from "./segments.ts";
+import type { ChromeData } from "./data.ts";
+import { modelText } from "./footer.ts";
+import { themeStyler, type ChromeStyler } from "./style.ts";
+
+export type TopBarOpts = { ascii: boolean; styler: ChromeStyler };
+
+/**
+ * Build the top-bar lines. Returns `[]` (hidden) when there is no verb and no
+ * phase. Pure given a styler.
+ */
+export function buildTopBarLines(data: ChromeData, width: number, opts: TopBarOpts): string[] {
+	const { ascii, styler } = opts;
+	const left: Segment[] = [];
+	// Phase now lives in the footer; the top bar appears only for an active verb.
+	if (data.verbLabel) left.push({ id: "verb", text: styler.fg("muted", data.verbLabel), priority: 8 });
+	if (left.length === 0) return [];
+
+	const right: Segment[] = [];
+	if (data.modelId) right.push({ id: "model", text: styler.fg("muted", modelText(data, ascii)), priority: 6 });
+
+	return [composeBar({ left, right, width, styleFill: styler.dim })];
+}
+
+/** pi Component wrapping the top bar; reads live ChromeData each render. */
+export class SolyTopBar implements Component {
+	constructor(
+		private readonly data: ChromeData,
+		private readonly theme: Theme,
+		private readonly getAscii: () => boolean,
+	) {}
+
+	invalidate(): void {
+		/* stateless — render() always reads fresh data */
+	}
+
+	render(width: number): string[] {
+		return buildTopBarLines(this.data, width, { ascii: this.getAscii(), styler: themeStyler(this.theme) });
+	}
+}

package/visual/welcome.ts

@@ -0,0 +1,265 @@
+// =============================================================================
+// visual/welcome.ts — soly startup header (replaces pi's built-in banner)
+// =============================================================================
+//
+// Installed via ctx.ui.setHeader, shown once at startup above the chat:
+//
+//   ████  block "soly" wordmark (accent) ...
+//   the project framework · running on pi, the coding engine
+//
+//   soly adds   plans · state · rules · workflows · ask_pro picker
+//   project     v1.12 · plan 2/5 — auth refactor · ≡ 4 rules · 2 docs
+//   next        → /execute
+//   start here  /soly-init · /plan · /soly · /why · /rules stats
+//   recent      1.11.2  …  ·  1.10.0  …
+//
+// pi is explicitly credited (engine) with soly as the framework on top. The
+// builder is pure; fs access (version + CHANGELOG) is isolated in
+// readWelcomeMeta so the layout is unit-testable.
+// =============================================================================
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Component } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { themeStyler, type ChromeStyler } from "./style.ts";
+import { type ColorMode, type RGB, colorizeColumns, gradient, hexToRgb, parseAnsiColor, variations } from "./gradient.ts";
+
+/** Letter-fill texture (dense, with a lighter weave) — readable but detailed. */
+const LETTER_TEX = ["█", "▓", "█", "▒"];
+/** Particle ramp for the right-side field: sparse/light → dense/full. */
+const PARTICLE = ["·", "░", "▒", "▓", "█"];
+/** Left margin before the wordmark. */
+const LEFT_PAD = 2;
+
+/** Stable, well-distributed [0,1) hash of a cell (murmur3 finalizer). `salt`
+ *  yields independent streams for placement vs. glyph weight. No flicker. */
+function hash01(x: number, y: number, salt = 0): number {
+	let h = (Math.imul(x, 374761393) + Math.imul(y, 668265263) + Math.imul(salt, 2246822519)) | 0;
+	h = Math.imul(h ^ (h >>> 13), 1274126177);
+	h ^= h >>> 16;
+	return (h >>> 0) / 4294967296;
+}
+
+/** Block wordmark for "soly" (accent + bold). Falls back to plain text in ASCII mode. */
+export const SOLY_ART: readonly string[] = [
+	"█████ █████ █     █   █",
+	"█     █   █ █     █   █",
+	"█████ █   █ █     █████",
+	"    █ █   █ █         █",
+	"█████ █████ █████ █████",
+];
+
+const TAGLINE = "the project framework · running on pi, the coding engine";
+const SOLY_ADDS = "plans · state · rules · workflows · ask_pro picker";
+const START_HERE: ReadonlyArray<[string, string]> = [
+	["/soly-init", "scaffold .agents/ in a new project"],
+	["/plan", "plan the current phase"],
+	["/soly", "state picker  ·  /why  ·  /rules stats"],
+];
+const LABEL_WIDTH = 11;
+
+/** Live values for the welcome header. */
+export type WelcomeInput = {
+	version: string;
+	hasProject: boolean;
+	phaseLabel: string | null;
+	nextHint: string | null;
+	rulesActive: number;
+	docsCount: number;
+	/** Up to N "version  summary" strings parsed from CHANGELOG.md. */
+	recent: string[];
+};
+
+export type WelcomeOpts = {
+	ascii: boolean;
+	styler: ChromeStyler;
+	width: number;
+	/** Terminal color depth; "none" (default) disables the gradient. */
+	colorMode?: ColorMode;
+	/** Explicit gradient stops (hex); when empty the accent is used instead. */
+	colorStops?: string[];
+	/** Theme accent in RGB — the default gradient is variations of this. */
+	accent?: RGB | null;
+};
+
+/** Indented `label  value` row with a fixed label column. */
+function row(label: string, value: string, styler: ChromeStyler): string {
+	return `  ${styler.dim(label.padEnd(LABEL_WIDTH))}${value}`;
+}
+
+/**
+ * One field cell to the right of the wordmark — a particle spray that fades
+ * outward. Placement uses one cell hash (so it scatters, no vertical bands);
+ * the glyph weight uses a second, independent hash mixed with the falloff, so
+ * dense near the letters and sparse sparkles toward the edge — never solid bands.
+ */
+function fieldCell(row: number, col: number, start: number, width: number): string {
+	const span = Math.max(12, width - start);
+	const fall = Math.max(0, 1 - (col - start) / span) ** 1.8; // bright near letters → faint outward
+	const density = Math.max(fall, 0.05); // faint starfield floor so sparks reach the full width
+	if (hash01(col, row) > density) return " ";
+	const weight = hash01(col, row, 101);
+	const idx = Math.min(PARTICLE.length - 1, Math.floor(fall * (0.55 + 0.5 * weight) * PARTICLE.length));
+	return PARTICLE[idx] ?? "·";
+}
+
+/** Build one banner row: textured letters (left) + dissolving particle field (right). */
+function bannerRow(row: number, width: number): string {
+	const mask = SOLY_ART[row] ?? "";
+	const artW = visibleWidth(SOLY_ART[0] ?? "");
+	let line = " ".repeat(LEFT_PAD);
+	for (let c = LEFT_PAD; c < width; c++) {
+		const ac = c - LEFT_PAD;
+		if (ac < artW) {
+			const cell = mask[ac];
+			line += cell && cell !== " " ? (LETTER_TEX[(row + ac) % LETTER_TEX.length] ?? "█") : " ";
+		} else {
+			line += fieldCell(row, c, LEFT_PAD + artW, width);
+		}
+	}
+	return line;
+}
+
+/**
+ * The banner: a "soly" wordmark drawn with mixed block glyphs that dissolves
+ * into a generative particle field on the right, swept by a gradient derived
+ * from the theme accent (or explicit stops). Falls back to a plain accent
+ * wordmark in ASCII / no-color / very narrow terminals.
+ */
+function bannerLines(opts: WelcomeOpts): string[] {
+	const { ascii, styler, width, colorMode = "none", colorStops = [], accent = null } = opts;
+	const artW = visibleWidth(SOLY_ART[0] ?? "");
+	if (ascii || width < artW + LEFT_PAD) return [styler.bold(styler.fg("accent", "soly"))];
+
+	const rows = SOLY_ART.map((_, r) => bannerRow(r, width));
+	const explicit = colorStops.map(hexToRgb).filter((c): c is RGB => c !== null);
+	const stops = explicit.length > 0 ? explicit : accent ? variations(accent) : [];
+	if (colorMode === "none" || stops.length === 0) return rows.map((row) => styler.fg("accent", row));
+
+	const colors = gradient(stops, width);
+	return rows.map((row) => colorizeColumns(row, colors, colorMode));
+}
+
+/** The "project" row value, depending on whether a soly project exists. */
+function projectValue(input: WelcomeInput, styler: ChromeStyler): string {
+	if (!input.hasProject) return styler.dim("no soly project here  →  /soly-init to scaffold");
+	const bits = [styler.fg("accent", `v${input.version}`)];
+	if (input.phaseLabel) bits.push(input.phaseLabel);
+	if (input.rulesActive > 0) bits.push(`≡ ${input.rulesActive}`);
+	if (input.docsCount > 0) bits.push(`${input.docsCount} docs`);
+	return bits.join(styler.dim(" · "));
+}
+
+/**
+ * Build the full welcome header. Pure given a styler (identity in tests).
+ * Width is used only to choose the banner form; rows are not hard-wrapped.
+ */
+export function buildWelcomeLines(input: WelcomeInput, opts: WelcomeOpts): string[] {
+	const { styler } = opts;
+	const lines: string[] = [...bannerLines(opts), "", `  ${styler.dim(TAGLINE)}`, ""];
+
+	lines.push(row("soly adds", styler.dim(SOLY_ADDS), styler));
+	lines.push(row("project", projectValue(input, styler), styler));
+	if (input.hasProject && input.nextHint) lines.push(row("next", styler.fg("accent", input.nextHint), styler));
+
+	lines.push("");
+	START_HERE.forEach(([cmd, desc], i) => {
+		const label = i === 0 ? "start here" : "";
+		lines.push(row(label, `${styler.fg("accent", cmd.padEnd(11))} ${styler.dim(desc)}`, styler));
+	});
+
+	if (input.recent.length > 0) {
+		lines.push("");
+		input.recent.forEach((entry, i) => lines.push(row(i === 0 ? "recent" : "", styler.dim(entry), styler)));
+	}
+
+	return lines;
+}
+
+// ---------------------------------------------------------------------------
+// Metadata (fs) — version from package.json, recent entries from CHANGELOG.md
+// ---------------------------------------------------------------------------
+
+function readChangelogText(extRoot: string): string | null {
+	for (const p of [path.join(extRoot, "CHANGELOG.md"), path.join(extRoot, "..", "..", "CHANGELOG.md")]) {
+		try {
+			return fs.readFileSync(p, "utf-8");
+		} catch {
+			/* try next */
+		}
+	}
+	return null;
+}
+
+/** Strip markdown emphasis/links from a bullet and trim to a one-liner. */
+function changelogTitle(bullet: string): string {
+	const bold = bullet.match(/\*\*(.+?)\*\*/);
+	const raw = (bold ? bold[1] : bullet).replace(/[`*_]/g, "").replace(/\[(.+?)\]\(.*?\)/g, "$1").trim();
+	return raw.length > 46 ? `${raw.slice(0, 45)}…` : raw;
+}
+
+/** Parse the top `n` "version  summary" lines from CHANGELOG.md. */
+export function parseRecentChanges(text: string, n: number): string[] {
+	const out: string[] = [];
+	let version: string | null = null;
+	for (const line of text.split(/\r?\n/)) {
+		const head = line.match(/^#{2,}\s*\[?v?(\d+\.\d+\.\d+)\]?/);
+		if (head?.[1]) {
+			version = head[1];
+			continue;
+		}
+		const bullet = line.match(/^\s*-\s+(.*\S)\s*$/);
+		if (version && bullet?.[1]) {
+			out.push(`${version}  ${changelogTitle(bullet[1])}`);
+			version = null;
+			if (out.length >= n) break;
+		}
+	}
+	return out;
+}
+
+/** Read version + recent changelog entries from the installed package. */
+export function readWelcomeMeta(extRoot: string, recentCount = 2): { version: string; recent: string[] } {
+	let version = "0.0.0";
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(extRoot, "package.json"), "utf-8")) as { version?: string };
+		if (typeof pkg.version === "string") version = pkg.version;
+	} catch {
+		/* keep default */
+	}
+	const text = readChangelogText(extRoot);
+	return { version, recent: text ? parseRecentChanges(text, recentCount) : [] };
+}
+
+/** pi Component for the startup header. Reads the welcome snapshot live. */
+export class SolyHeader implements Component {
+	constructor(
+		private readonly getWelcome: () => WelcomeInput | null,
+		private readonly theme: Theme,
+		private readonly getAscii: () => boolean,
+		private readonly getBannerColors: () => string[],
+	) {}
+
+	invalidate(): void {
+		/* stateless */
+	}
+
+	render(width: number): string[] {
+		const input = this.getWelcome();
+		if (!input) return [];
+		const ascii = this.getAscii();
+		const colorMode: ColorMode = ascii ? "none" : this.theme.getColorMode();
+		const lines = buildWelcomeLines(input, {
+			ascii,
+			styler: themeStyler(this.theme),
+			width,
+			colorMode,
+			colorStops: this.getBannerColors(),
+			accent: parseAnsiColor(this.theme.getFgAnsi("accent")),
+		});
+		// Never let a line overflow the viewport.
+		return lines.map((line) => (visibleWidth(line) > width ? truncateToWidth(line, width, "") : line));
+	}
+}

package/visual/working.ts

@@ -0,0 +1,66 @@
+// =============================================================================
+// visual/working.ts — working-indicator telemetry message (pure builder)
+// =============================================================================
+//
+// pi animates the working spinner natively (ctx.ui.setWorkingIndicator with
+// our snowflake frames). This module only builds the *text* shown next to it
+// via ctx.ui.setWorkingMessage — a live telemetry line:
+//
+//   Working · 8s · ↑12.4k ↓1.2k · 148 tok/s
+//
+//   ↑ = context tokens sent with the request (from getContextUsage at start)
+//   ↓ = tokens generated so far this turn (grows via message_update)
+//   tok/s = ↓ / elapsed seconds
+//
+// Fields drop by priority on narrow terminals (tok/s → tokens → time → label),
+// via segments.fitParts. Pure: pass an explicit maxWidth in tests.
+// =============================================================================
+
+import { fitParts, type Segment } from "./segments.ts";
+import { formatElapsed, formatTokens } from "./format.ts";
+
+/** Default spinner frames + interval (user-chosen): braille "breathing"
+ *  (grow→shrink) → a quadrant arrow sweep → breathing again, slowed down. */
+export const SPINNER_FRAMES = [
+	"⠁", "⠉", "⠙", "⠹", "⠽", "⠿", "⠾", "⠼", "⠶", "⠦", "⠆", "⠂",
+	"◴", "◷", "◶", "◵",
+	"⠁", "⠉", "⠙", "⠹", "⠽", "⠿", "⠾", "⠼", "⠶", "⠦", "⠆", "⠂",
+] as const;
+export const SPINNER_INTERVAL_MS = 150;
+
+export type WorkingTelemetry = {
+	/** Leading word, e.g. "Working". */
+	label: string;
+	/** Elapsed time since the turn started, in ms. */
+	elapsedMs: number;
+	/** Context tokens sent with the request (↑). */
+	inputTokens: number;
+	/** Tokens generated so far this turn (↓). */
+	outputTokens: number;
+};
+
+/**
+ * Build the working telemetry line, fitted to `maxWidth` visible columns.
+ * Drops low-priority fields first: tok/s, then tokens, then elapsed; the
+ * label is kept last. Text is plain (no ANSI) — the caller may style it.
+ */
+export function buildWorkingMessage(t: WorkingTelemetry, maxWidth: number): string {
+	const elapsedSec = Math.floor(t.elapsedMs / 1000);
+	const parts: Segment[] = [{ id: "label", text: t.label, priority: 5 }];
+
+	parts.push({ id: "time", text: formatElapsed(t.elapsedMs), priority: 4 });
+
+	const tokenBits: string[] = [];
+	if (t.inputTokens > 0) tokenBits.push(`↑${formatTokens(t.inputTokens)}`);
+	if (t.outputTokens > 0) tokenBits.push(`↓${formatTokens(t.outputTokens)}`);
+	if (tokenBits.length > 0) {
+		parts.push({ id: "tokens", text: tokenBits.join(" "), priority: 3 });
+	}
+
+	if (t.outputTokens > 0 && elapsedSec > 0) {
+		const rate = Math.round(t.outputTokens / elapsedSec);
+		parts.push({ id: "rate", text: `${rate} tok/s`, priority: 2 });
+	}
+
+	return fitParts(parts, Math.max(0, maxWidth));
+}

package/workflows/execute.ts

@@ -67,7 +67,7 @@ export function buildExecuteTransform(
 	cmd: SolyCommand,
 	state: SolyState,
 	interactiveRules: string[] = [],
-	opts: { agent?: string; useSolyWorker?: boolean } = {},
+	opts: { agent?: string } = {},
 ): ExecuteHandlerResult {
 	if (!state.exists) {
 		return {
@@ -233,7 +233,7 @@ Hard rules:
 \`
 })
 
-When the subagent completes, synthesize the result. Do not re-execute its work.`;
+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.`;
 		return { handled: true, transformedText: instruction };
 	}
 
@@ -286,7 +286,12 @@ When the subagent completes, synthesize the result. Do not re-execute its work.`
 	}
 
 	const isPlanLevel = target.plan != null;
-	const workflowName = isPlanLevel ? "execute-plan.md" : "execute-phase.md";
+	// Unified model: a phase with tasks/ executes those (dependency-ordered) via
+	// the task-centric workflow; legacy phases (plan files, no tasks) keep the
+	// wave/plan workflow.
+	const phaseTasks = phase.tasks ?? [];
+	const useTasks = !isPlanLevel && phaseTasks.length > 0;
+	const workflowName = isPlanLevel ? "execute-plan.md" : useTasks ? "execute-task.md" : "execute-phase.md";
 	const workflow = loadWorkflowMarkdown(workflowName);
 	if (!workflow) {
 		return {
@@ -331,12 +336,17 @@ When the subagent completes, synthesize the result. Do not re-execute its work.`
 	// workflow markdown verbatim so the LLM has full context.
 	const targetDesc = isPlanLevel
 		? `phase ${target.phase} plan ${String(target.plan).padStart(2, "0")}`
-		: `phase ${target.phase} (${phase.name}) — all ${phase.planCount} plan(s)`;
+		: useTasks
+			? `phase ${target.phase} (${phase.name}) — ${phaseTasks.length} task(s)`
+			: `phase ${target.phase} (${phase.name}) — all ${phase.planCount} plan(s)`;
 
 	const scopeBlock = isPlanLevel
 		? `Target: ONE plan = ${targetDesc}.
 The iteration context file lists the specific plan at section 6.`
-		: `Target: ${targetDesc}.
+		: useTasks
+			? `Target: ${targetDesc} — the unified task model.
+Execute the tasks under \`${phase.dir}/tasks/\`. Run only tasks whose \`depends-on\` are all satisfied (status: done), in dependency order — sequential is fine. Each task produces its own SUMMARY.md in its task dir and flips its PLAN.md frontmatter to \`status: done\`. The wave/plan language in the workflow below maps onto these tasks.`
+			: `Target: ${targetDesc}.
 The iteration context file lists all plans (their frontmatter) in section 6, grouped by wave.`;
 
 	const childRole = isPlanLevel
@@ -362,7 +372,7 @@ subagent({
   maxSubagentDepth: 1,  // worker must not spawn sub-sub-agents
   task: \`You are ${childRole}.
 
-Your job: ${isPlanLevel ? "execute ONE plan and produce 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 parallel execution"}.
 
 **FIRST ACTION — read the iteration context file:**
 \`\`\`
@@ -398,7 +408,7 @@ Hard rules:
 \`
 })
 
-When the subagent completes, synthesize the result and confirm STATE.md was updated. Do not re-execute its 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.`;
 
 	return { handled: true, transformedText: instruction };
 }

package/workflows/index.ts

@@ -23,6 +23,9 @@ import { buildResumeTransform } from "./resume.ts";
 import { showStatus, showLog, showDiff } from "./quick.ts";
 import { showDoctor, showIterations, showDiffIterations, showPhaseDelete, showTodos } from "./inspect.ts";
 import { buildPlanTransform, buildDiscussTransform } from "./planning.ts";
+import { createVerifyLoop, type VerifyState } from "./verify.ts";
+import { buildMigrateTransform } from "./migrate.ts";
+import type { ContextManager } from "../context-manager.ts";
 import type { SolyState } from "../core.js";
 import type { SolyConfig } from "../config.js";
 
@@ -39,18 +42,45 @@ export interface WorkflowsDeps {
 	/** Fired when a recognized soly verb is parsed (handled OR transformed).
 	 *  Used by the parent extension to reset drift counters etc. */
 	onWorkflowUsed?: () => void;
+	/** Shared owner of pi's `context` channel (for /verify fresh-context mode). */
+	contextManager: ContextManager;
+	/** Fired when the verify loop's state changes (drives the chrome top bar). */
+	onVerifyState?: (state: VerifyState) => void;
+	/** Set/clear the active workflow-mode label shown in the chrome top bar. */
+	setVerbLabel?: (verb: string | null) => void;
+}
+
+/** 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;
-	// The current agent is owned by the separate `pi-switch` extension.
-	// It writes `globalThis.__PI_SWITCH_AGENT__` (in-process) and
-	// `.soly/agent` (persisted). We read the in-process value first (fresh);
-	// fall back to "worker" if pi-switch isn't installed.
-	const getCurrentAgent = (): string => {
-		return (globalThis as { __PI_SWITCH_AGENT__?: string }).__PI_SWITCH_AGENT__ ?? "worker";
-	};
 
+	// Self-review loop ("soly verify"). Owns its own agent_end + input hooks;
+	// fresh-context mode rewrites the next LLM call through the context manager.
+	const verifyLoop = createVerifyLoop(pi, {
+		contextManager: deps.contextManager,
+		getConfig: () => getConfig().verify,
+		onState: (state) => deps.onVerifyState?.(state),
+	});
 	// Track whether we need to fire ctx.compact() at the end of the upcoming
 	// turn. Reset on every user input — only set if the user types
 	// "soly compact" (which expands to a handoff + compact request).
@@ -65,9 +95,15 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 		if (event.source !== "interactive") return;
 		if (event.text.trim().startsWith("/")) return;
 
+		// Any interactive input ends the previous workflow mode; a mode verb
+		// below re-sets it. Verify manages its own label via onVerifyState.
+		deps.setVerbLabel?.(null);
+
 		const cmd = parseSolyCommand(event.text);
 		if (!cmd) return;
 
+		if (MODE_VERBS.includes(cmd.verb)) deps.setVerbLabel?.(cmd.verb);
+
 		// Notify the parent extension that a soly verb was used
 		// (resets the drift counter, etc.). Fires for BOTH "handled"
 		// and "transform" actions — both are real workflow usage.
@@ -78,11 +114,9 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 		// ----- LLM-driven transforms -----
 
 		if (cmd.verb === "execute") {
-			const result = buildExecuteTransform(cmd, state, getInteractiveRules(), {
-				useSolyWorker: getConfig().agent.useSolyWorkerSubagents,
-			});
+			const result = buildExecuteTransform(cmd, state, getInteractiveRules());
 			if (!result.handled || !result.transformedText) return;
-			return { action: "transform", text: result.transformedText };
+			return { action: "transform", text: withSubagentPreflight(result.transformedText, getActiveTools()) };
 		}
 
 		if (cmd.verb === "pause" || cmd.verb === "compact") {
@@ -101,7 +135,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: result.transformedText };
+			return { action: "transform", text: withSubagentPreflight(result.transformedText, getActiveTools()) };
 		}
 
 		if (cmd.verb === "discuss") {
@@ -111,41 +145,54 @@ export function registerWorkflows(pi: ExtensionAPI, deps: WorkflowsDeps): void {
 			return { action: "transform", text: result.transformedText };
 		}
 
+		if (cmd.verb === "migrate") {
+			const result = buildMigrateTransform(state);
+			if (!result.handled || !result.transformedText) return;
+			return { action: "transform", text: result.transformedText };
+		}
+
+		if (cmd.verb === "verify") {
+			const sub = (cmd.args[0] ?? "").toLowerCase();
+			if (sub === "stop" || sub === "off") {
+				verifyLoop.stop(ctx, "stopped");
+			} else {
+				const maxArg = cmd.args.find((a) => /^\d+$/.test(a));
+				const fresh = cmd.args.some((a) => a === "fresh" || a === "--fresh");
+				verifyLoop.start(ctx, { max: maxArg ? parseInt(maxArg, 10) : undefined, fresh: fresh || undefined });
+			}
+			return { action: "handled" };
+		}
+
 		if (cmd.verb === "help") {
 			return {
 				action: "transform",
-				text: `soly subcommand picker (esc to cancel).
-
-Available verbs (all start with \`soly <verb>\` or use \`/soly <verb>\` in slash form):
-
-  position       — one-screen current position summary
-  state          — full STATE.md body
-  plan           — current PLAN.md body
-  context        — current phase CONTEXT.md
-  research       — current phase RESEARCH.md
-  roadmap        — ROADMAP.md body
-  progress       — progress bar + counts
-  phases         — list all phases with C/R markers
-  tasks          — list all tasks grouped by feature (new in v2)
-  task <id>      — show one task's PLAN + SUMMARY
-  features       — list all features (new in v2)
-  milestone      — show the active milestone document
-  log [N]        — last N (default 20) decisions from STATE.md
-  diff           — git status + uncommitted .soly/ changes
-  doctor         — health check: missing files, broken refs, stale iterations
-  iterations [N] — list recent iteration files
-  todos          — show pi-todo live list (.soly/todos.json or .pi-todos.json)
-  phase delete <N> — soft-delete a phase
-  reload         — re-read project state from disk
-  plan <N>       — produce PLAN.md for phase N
-  discuss <N>    — interactive discussion of phase N
-  execute <N>    — execute all plans in phase N (or \`execute N.MM\` for one plan)
-  pause          — write HANDOFF.json + .continue-here.md
-  compact        — pause + auto-compact session
-  resume [N]     — restore from handoff (scoped to phase N if given)
-  help           — this picker
-
-Unknown / missing verb? Use \`/soly\` (slash) for the picker.`,
+				text: `soly — workflow verbs (type \`soly <verb>\`):
+
+Lifecycle:
+  discuss <N>         — talk through phase N's decisions (interactive)
+  plan <N>            — produce PLAN.md for phase N
+  execute <N|N.MM>    — execute a phase or one plan (also <task-id>, --all, --feature)
+  verify [N] [fresh]  — self-review loop until "no issues" (max N; \`verify stop\` to exit)
+  pause / compact     — write handoff (compact also compresses the session)
+  resume [N]          — restore from handoff (scoped to phase N if given)
+
+Quick info (no LLM round-trip):
+  status              — position + progress + phases
+  log [N]             — last N decisions from STATE.md
+  diff                — git status + uncommitted .soly/ changes
+  doctor              — health check (missing files, broken refs, stale iterations)
+  iterations [N]      — recent iteration bundles
+  todos               — pi-todo live list
+  phase delete <N>    — soft-delete a phase
+
+Maintenance:
+  migrate             — convert a legacy layout (NN-PLAN files / features/) to phases/<N>/tasks/
+
+State inspection lives on the slash form — \`/soly <sub>\`:
+  position · state · plan · roadmap · progress · phases · tasks · task <id> ·
+  features · milestone · context · research · config · reload
+
+(\`/soly\` with no argument opens the interactive picker.)`,
 			};
 		}