@aperant/framework 0.11.0 → 0.12.1

package/src/cli/commands/recipe-diff.mjs

@@ -0,0 +1,81 @@
+/**
+ * commands/recipe-diff.mjs — `apt-tools recipe-diff <projectDir> [--format json|md]`.
+ *
+ * Loads bundled recipes, runs the pattern-matcher against the adopter's
+ * runtime + package.json to pick a recipe, then calls generateRecipeDiff
+ * to emit the Markdown body.
+ *
+ * Exit codes:
+ *   0 — success (envelope.status:'ok')
+ *   1 — no-recipe-match (envelope.status:'error', code:'E_NO_RECIPE')
+ *
+ * Output:
+ *   default / --format json → JSON envelope to stdout
+ *   --format md             → raw Markdown body to stdout
+ */
+
+import { parseFlags } from '../util/args.mjs'
+import { err, exitWith, ok, rawText } from '../util/result.mjs'
+import { loadRuntimeCapabilities } from '../util/runtime-capabilities.mjs'
+import { matchPatternForProject } from '../verify-proof/sandbox/pattern-matcher.mjs'
+import { generateRecipeDiff } from '../verify-proof/sandbox/recipe-diff.mjs'
+import { discoverBundledRecipes } from '../verify-proof/sandbox/sandbox-config.mjs'
+
+/**
+ * @param {string} projectDir
+ * @param {string[]} [extra]
+ */
+export function cmdRecipeDiff(projectDir, extra = []) {
+	if (!projectDir) return err('Usage: apt-tools recipe-diff <project-dir> [--format json|md]')
+
+	const flags = parseFlags(extra)
+	const formatFlag = flags.get('format') ?? 'json'
+	if (formatFlag !== 'json' && formatFlag !== 'md') {
+		return err(`recipe-diff: --format must be 'json' or 'md', got '${formatFlag}'`)
+	}
+
+	const recipes = discoverBundledRecipes()
+	const runtime = loadRuntimeCapabilities(projectDir)
+
+	// recipeId can be passed explicitly via --recipe; otherwise we match.
+	const explicitRecipeId = flags.get('recipe') ?? null
+	let recipeId
+	let matchReason
+	if (explicitRecipeId) {
+		recipeId = explicitRecipeId
+		matchReason = 'explicit'
+	} else {
+		const match = matchPatternForProject(projectDir, runtime, recipes)
+		recipeId = match.recipeId
+		matchReason = match.reason
+	}
+
+	if (!recipeId) {
+		const envelope = {
+			status: 'error',
+			command: 'recipe-diff',
+			code: 'E_NO_RECIPE',
+			reason: matchReason,
+			runtime,
+			docs: 'docs/verify-proof-sandbox-patterns.md',
+		}
+		return exitWith(envelope, 1)
+	}
+
+	const diff = generateRecipeDiff({ projectDir, recipeId, recipes })
+
+	if (formatFlag === 'md') {
+		const exitCode = diff.envelope.status === 'ok' ? 0 : 1
+		return rawText(diff.body, exitCode)
+	}
+
+	return ok({
+		status: 'ok',
+		command: 'recipe-diff',
+		project_dir: projectDir,
+		recipe_id: recipeId,
+		match_reason: matchReason,
+		runtime,
+		...diff,
+	})
+}

package/src/cli/commands/roadmap.mjs

@@ -11,6 +11,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSy
 import { basename, join, resolve } from 'node:path'
 import { selfStageCommittableWrites } from '../artifacts/self-stage.mjs'
 import { getDefaultOwner, getGitIdentity } from '../git/identity.mjs'
+import { dispatchRoadmapWrite } from '../roadmap/backend-adapter.mjs'
 import { runConvexMirror } from '../roadmap/convex-mirror.mjs'
 import {
 	loadRoadmapForScope as ioLoadRoadmapForScope,
@@ -197,6 +198,34 @@ async function cmdRoadmapImpl(subcommand, projectDir, extraArgs) {
 		return defaultScope
 	}
 
+	// Task 26-05-26 subtask 2.4 — `.aperant/config.json :: roadmap.backend`
+	// dispatch. Called at the top of each write-side subcommand. When the
+	// configured backend is `cloud-mcp` AND the dispatch succeeds (or fails
+	// with a structured error), we surface that envelope and short-circuit
+	// the existing markdown file-write path. When the backend is `markdown`
+	// (the Fast Path Guarantee default), the dispatcher returns
+	// `delegated:false` and the subcommand proceeds with the existing
+	// markdown writes verbatim — byte-identical to pre-2.4 behaviour.
+	async function maybeDelegate(subcommand, args) {
+		const fetchImpl =
+			cmdRoadmap._injectedFetch !== undefined ? cmdRoadmap._injectedFetch : undefined
+		const decision = await dispatchRoadmapWrite(targetDir, subcommand, args, { fetchImpl })
+		if (decision.delegated === false) return null
+		if (decision.status === 'error') {
+			return err(decision.error, decision.code === 401 ? 1 : 1, {
+				command: `roadmap-${subcommand}`,
+				backend: 'cloud-mcp',
+			})
+		}
+		return ok({
+			status: 'ok',
+			command: `roadmap-${subcommand}`,
+			backend: 'cloud-mcp',
+			delegated: true,
+			result: decision.result,
+		})
+	}
+
 	// C28 D-07 — cascade-null helper. The scanning of affected tasks is
 	// inlined at each destructive roadmap path so the scan + mutate can run
 	// under a single `withFileLock(state.json)` and close the TOCTOU window.
@@ -357,6 +386,9 @@ async function cmdRoadmapImpl(subcommand, projectDir, extraArgs) {
 			const scope = (flags.get('scope') || 'project').trim() || 'project'
 			if (!id || !title) throw new RoadmapUsageError('Required: --id <id> --title <title>')
 
+			const delegated = await maybeDelegate('add-milestone', { id, title, goal, scope })
+			if (delegated) return delegated
+
 			// Auto-init the scope if its roadmap file doesn't exist yet.
 			const { jsonPath } = scopePaths(scope)
 			if (!existsSync(jsonPath)) {
@@ -402,6 +434,15 @@ async function cmdRoadmapImpl(subcommand, projectDir, extraArgs) {
 			if (!milestoneId || !id || !title)
 				throw new RoadmapUsageError('Required: --milestone <id> --id <id> --title <title>')
 
+			const delegated = await maybeDelegate('add-phase', {
+				milestoneId,
+				id,
+				title,
+				description: flags.get('description') || '',
+				status: flags.get('status') || 'planned',
+			})
+			if (delegated) return delegated
+
 			const scope = resolveScope({ milestoneId })
 			const roadmap = loadRoadmap(scope)
 			const milestone = roadmap.milestones.find((m) => m.id === milestoneId)
@@ -445,6 +486,13 @@ async function cmdRoadmapImpl(subcommand, projectDir, extraArgs) {
 			if (!milestoneId || !phaseId || !status)
 				throw new RoadmapUsageError('Required: --milestone <id> --phase <id> --status <status>')
 
+			const delegated = await maybeDelegate('set-phase-status', {
+				milestoneId,
+				phaseId,
+				status,
+			})
+			if (delegated) return delegated
+
 			// C28 D-07 — `deleted` is the destructive path that triggers orphan
 			// block + cascade-null. All other statuses are non-destructive.
 			const validStatuses = ['planned', 'in-progress', 'completed', 'blocked', 'skipped', 'deleted']
@@ -602,6 +650,9 @@ async function cmdRoadmapImpl(subcommand, projectDir, extraArgs) {
 			const phaseId = flags.get('phase')
 			if (!milestoneId || !phaseId)
 				throw new RoadmapUsageError('Required: --milestone <id> --phase <id>')
+
+			const delegated = await maybeDelegate('delete-phase', { milestoneId, phaseId })
+			if (delegated) return delegated
 			const force = extraArgs.includes('--force')
 			const reason = flags.get('reason') || null
 			if (force && !reason) {
@@ -698,6 +749,9 @@ async function cmdRoadmapImpl(subcommand, projectDir, extraArgs) {
 		case 'delete-milestone': {
 			const milestoneId = flags.get('id') || flags.get('milestone')
 			if (!milestoneId) throw new RoadmapUsageError('Required: --id <milestone-id>')
+
+			const delegated = await maybeDelegate('delete-milestone', { milestoneId })
+			if (delegated) return delegated
 			const force = extraArgs.includes('--force')
 			const reason = flags.get('reason') || null
 			if (force && !reason) {

package/src/cli/commands/verify-sandbox.mjs

@@ -0,0 +1,231 @@
+/**
+ * commands/verify-sandbox.mjs — `apt-tools verify-sandbox <projectDir>`.
+ *
+ * Drives runSelfTest() then atomically writes
+ * .aperant/state/verify-proof-sandbox-verified.json with the v2-shaped
+ * verdict envelope. On win32, short-circuits to a platform_unsupported
+ * verdict WITHOUT spawning child processes (ID-06 v1 supported floor =
+ * darwin + linux).
+ *
+ * The state file is written for BOTH verified-true and verified-false
+ * outcomes (ID-02 — no silent state mutation). The sandbox gate at
+ * apt-verify-proof/SKILL.md Step 2c (subtask 5.1) reads this file.
+ */
+
+import { join, resolve } from 'node:path'
+import { atomicWriteJson } from '../util/atomic-write.mjs'
+import { withFileLock } from '../util/fs-lock.mjs'
+import { err, exitWith, ok } from '../util/result.mjs'
+import { loadRuntimeCapabilities } from '../util/runtime-capabilities.mjs'
+import { matchPatternForProject } from '../verify-proof/sandbox/pattern-matcher.mjs'
+import {
+	discoverBundledRecipes,
+	readSandboxConfig,
+} from '../verify-proof/sandbox/sandbox-config.mjs'
+import { runSelfTest } from '../verify-proof/sandbox/self-test.mjs'
+
+/**
+ * @param {string} projectDir
+ * @param {string[]} [extra]
+ */
+export async function cmdVerifySandbox(projectDir, _extra = []) {
+	if (!projectDir) return err('Usage: apt-tools verify-sandbox <project-dir>')
+
+	const target = resolve(projectDir)
+	const platform = process.platform
+	const statePath = join(target, '.aperant', 'state', 'verify-proof-sandbox-verified.json')
+	const at = new Date().toISOString()
+
+	const host = {
+		platform,
+		arch: process.arch,
+		nodeVersion: process.version,
+	}
+
+	// Resolve recipeId from config or runtime detection.
+	const sandboxCfg = readSandboxConfig(target)
+	const recipes = discoverBundledRecipes()
+	let recipeId = sandboxCfg?.recipeId ?? null
+	let recipeVersion = sandboxCfg?.recipeVersion ?? null
+	if (!recipeId) {
+		const runtime = loadRuntimeCapabilities(target)
+		const match = matchPatternForProject(target, runtime, recipes)
+		recipeId = match.recipeId
+	}
+	// Always populate recipeVersion from bundled recipes when absent — covers
+	// the case where config pins recipeId but omits recipeVersion (LOG-003).
+	if (recipeId && !recipeVersion) {
+		recipeVersion = recipes.find((r) => r.recipeId === recipeId)?.recipeVersion ?? null
+	}
+
+	// win32 short-circuit (AC12, ID-06 v1 floor).
+	if (platform === 'win32') {
+		const envelope = {
+			verified: false,
+			verdict: 'needs_human',
+			reason: 'platform_unsupported',
+			recipeId,
+			recipeVersion,
+			verifiedAt: at,
+			host,
+		}
+		const writeErr = writeStateFile(statePath, envelope)
+		if (writeErr) {
+			return exitWith(
+				{
+					status: 'error',
+					command: 'verify-sandbox',
+					code: 'E_STATE_WRITE_FAILED',
+					verdict: 'needs_human',
+					reason: 'state_write_failed',
+					cause: writeErr.message,
+					project_dir: target,
+					state_path: statePath,
+				},
+				1,
+			)
+		}
+		return ok({
+			status: 'ok',
+			command: 'verify-sandbox',
+			project_dir: target,
+			state_path: statePath,
+			...envelope,
+		})
+	}
+
+	if (!recipeId) {
+		const envelope = {
+			verified: false,
+			verdict: 'needs_human',
+			reason: 'no_recipe_available',
+			recipeId: null,
+			recipeVersion: null,
+			verifiedAt: at,
+			host,
+		}
+		const writeErr = writeStateFile(statePath, envelope)
+		if (writeErr) {
+			return exitWith(
+				{
+					status: 'error',
+					command: 'verify-sandbox',
+					code: 'E_STATE_WRITE_FAILED',
+					verdict: 'needs_human',
+					reason: 'state_write_failed',
+					cause: writeErr.message,
+					project_dir: target,
+					state_path: statePath,
+				},
+				1,
+			)
+		}
+		return exitWith(
+			{
+				status: 'error',
+				command: 'verify-sandbox',
+				code: 'E_NO_RECIPE',
+				project_dir: target,
+				state_path: statePath,
+				...envelope,
+			},
+			1,
+		)
+	}
+
+	let result
+	try {
+		result = await runSelfTest({ projectDir: target, recipeId, recipes })
+	} catch (e) {
+		const envelope = {
+			verified: false,
+			verdict: 'needs_human',
+			reason: 'self_test_failed_app_init_timeout',
+			recipeId,
+			recipeVersion,
+			verifiedAt: at,
+			host,
+			error: e?.message ?? String(e),
+		}
+		const writeErr = writeStateFile(statePath, envelope)
+		if (writeErr) {
+			return exitWith(
+				{
+					status: 'error',
+					command: 'verify-sandbox',
+					code: 'E_STATE_WRITE_FAILED',
+					verdict: 'needs_human',
+					reason: 'state_write_failed',
+					cause: writeErr.message,
+					project_dir: target,
+					state_path: statePath,
+				},
+				1,
+			)
+		}
+		return exitWith(
+			{
+				status: 'error',
+				command: 'verify-sandbox',
+				project_dir: target,
+				state_path: statePath,
+				...envelope,
+			},
+			1,
+		)
+	}
+
+	const envelope = {
+		verified: result.verified,
+		verdict: result.verdict,
+		reason: result.reason,
+		recipeId,
+		recipeVersion,
+		verifiedAt: at,
+		host,
+		durationMs: result.durationMs,
+	}
+	const writeErr = writeStateFile(statePath, envelope)
+	if (writeErr) {
+		return exitWith(
+			{
+				status: 'error',
+				command: 'verify-sandbox',
+				code: 'E_STATE_WRITE_FAILED',
+				verdict: 'needs_human',
+				reason: 'state_write_failed',
+				cause: writeErr.message,
+				project_dir: target,
+				state_path: statePath,
+			},
+			1,
+		)
+	}
+
+	const exitCode = result.verified ? 0 : 1
+	return exitWith(
+		{
+			status: result.verified ? 'ok' : 'error',
+			command: 'verify-sandbox',
+			project_dir: target,
+			state_path: statePath,
+			...envelope,
+		},
+		exitCode,
+	)
+}
+
+/**
+ * Write the verdict envelope to the state file under a file lock.
+ * Returns null on success, or an Error if the lock or write fails.
+ */
+function writeStateFile(statePath, envelope) {
+	try {
+		withFileLock(statePath, () => {
+			atomicWriteJson(statePath, envelope)
+		})
+		return null
+	} catch (e) {
+		return e instanceof Error ? e : new Error(String(e))
+	}
+}

package/src/cli/consistency/parse-qa.mjs

@@ -7,13 +7,17 @@
  *   - flat findings: findings: [{severity}]
  *   - legacy `issues: [{severity}]`
  *
- * Verdict closed set: {approved, approved-with-notes, rejected, needs-changes}.
- * Anything else -> 'unknown'. Accepts legacy `status` as a fallback field name.
+ * v0.9.0 (verify-proof-v2-outcome-walker_27-05-26) — verdict closed set is
+ * `{approved, rejected, needs_human, needs-changes}`. `approved_with_notes`
+ * is DELETED (no shim) — reading a legacy `approved_with_notes` /
+ * `approved-with-notes` value throws a clear migration error pointing at
+ * the framework CHANGELOG entry. Anything else maps to `'unknown'`.
+ * Accepts legacy `status` as a fallback field name.
  *
  * Output: {verdict, findings: [{severity, title, status, file}]}
  */
 
-const KNOWN_VERDICTS = new Set(['approved', 'approved-with-notes', 'rejected', 'needs-changes'])
+const KNOWN_VERDICTS = new Set(['approved', 'rejected', 'needs-human', 'needs-changes'])
 
 const SEVERITY_MAP = {
 	critical: 'critical',
@@ -56,7 +60,19 @@ function normalizeVerdict(v) {
 	const k = v.toLowerCase().trim()
 	// normalize common spellings
 	const canonical = k.replace(/_/g, '-')
-	return KNOWN_VERDICTS.has(canonical) ? canonical : 'unknown'
+	// v0.9.0 migration: approved_with_notes / approved-with-notes is
+	// DELETED with no shim. Crash loudly so the consumer task is
+	// re-run, not silently re-mapped to `approved`.
+	if (canonical === 'approved-with-notes') {
+		throw new Error(
+			"qa_signoff.json carries the legacy verdict 'approved_with_notes' (or 'approved-with-notes'). " +
+				"This verdict is removed in framework v0.9.0+ (see packages/framework/CHANGELOG.md :: 'verify-proof v2 — outcome walker + two-gate verdict'). " +
+				'Re-run verify-proof on this task to mint a fresh qa_signoff.json with the new {approved, rejected, needs_human} enum.',
+		)
+	}
+	// Accept both snake_case and kebab-case for needs_human.
+	const needsHuman = canonical === 'needs-human' ? 'needs-human' : canonical
+	return KNOWN_VERDICTS.has(needsHuman) ? needsHuman : 'unknown'
 }
 
 function collectRaw(qa) {

package/src/cli/consistency/rules/r5-verdict-consistency.mjs

@@ -3,13 +3,15 @@
  * consistency/rules/r5-verdict-consistency.mjs — R5 (C15).
  *
  * Fails when:
- *   - qa.verdict === 'approved' or 'approved-with-notes' AND review has >=1
- *     unresolved critical or major finding
- *   - qa.verdict === 'rejected' AND qa has no findings at all AND review has
- *     zero unresolved findings (rejected-without-evidence)
+ *   - qa.verdict === 'approved' AND review has >=1 unresolved critical or
+ *     major finding.
+ *   - qa.verdict === 'rejected' AND qa has no findings at all AND review
+ *     has zero unresolved findings (rejected-without-evidence).
  *
- * `approved-with-notes` no longer escapes unresolved critical or major
- * findings (G42 Phase 1). It still passes for lower-severity issues.
+ * v0.9.0 (verify-proof-v2-outcome-walker_27-05-26) — the legacy
+ * `approved-with-notes` branch is REMOVED. The verdict enum is the closed
+ * set `{approved, rejected, needs_human}`. Reading a legacy verdict
+ * crashes in parseQaSignoff before this rule executes.
  *
  * Severity: error. Stages: verify, ship.
  */
@@ -30,10 +32,7 @@ const rule = {
 		const unresolvedBlocking = reviewFindings.filter(
 			(f) => (f.severity === 'critical' || f.severity === 'major') && f.status !== 'fixed',
 		)
-		if (
-			(verdict === 'approved' || verdict === 'approved-with-notes') &&
-			unresolvedBlocking.length > 0
-		) {
+		if (verdict === 'approved' && unresolvedBlocking.length > 0) {
 			return {
 				status: 'fail',
 				drift: [
@@ -43,11 +42,10 @@ const rule = {
 							id: f.id,
 							title: f.title,
 						})),
-						reason:
-							'approved/approved-with-notes verdict with unresolved critical or major finding(s) (G42 Phase 1)',
+						reason: 'approved verdict with unresolved critical or major finding(s) (G42 Phase 1)',
 					},
 				],
-				reason: `approved/approved-with-notes verdict contradicts ${unresolvedBlocking.length} unresolved critical/major finding(s)`,
+				reason: `approved verdict contradicts ${unresolvedBlocking.length} unresolved critical/major finding(s)`,
 			}
 		}
 		if (verdict === 'rejected') {

package/src/cli/coverage-check/user-outcomes.mjs

@@ -33,20 +33,21 @@
  * authoring contract.
  */
 
-const VALID_SURFACES = new Set(['electron', 'web', 'cli', 'api', 'electron+web'])
+const VALID_SURFACES = new Set(['electron', 'web', 'cli', 'api', 'mobile', 'electron+web'])
 
 const HEADING_RE = /^(#{1,6})\s+(.*)$/
 const USER_OUTCOMES_HEADING_RE = /^user\s+outcomes\s*$/i
 const EPIC_RE = /^\*\*Epic:\*\*\s+(.+)$/
 const EMPTY_WITH_NOTE_RE = /^_No user-observable changes — pure refactor\._\s*$/
 const OUTCOME_RE =
-	/^-\s+\*\*ON\*\*\s+\[(electron|web|cli|api|electron\+web)\]:\s+(.+?)(\s+\*\(requires\s+ON\s+(\d+)\)\*)?\s*$/
+	/^-\s+\*\*ON\*\*\s+\[(electron|web|cli|api|mobile|electron\+web)\]:\s+(.+?)(\s+\*\(requires\s+ON\s+(\d+)\)\*)?\s*$/
 
 /**
  * @typedef {Object} UserOutcome
  * @property {string} id                — synthesized positional ID (O1, O2, ...)
- * @property {('electron'|'web'|'cli'|'api'|'electron+web')} surface
+ * @property {('electron'|'web'|'cli'|'api'|'mobile'|'electron+web')} surface
  * @property {string} text              — outcome prose (sans the surface tag and requires suffix)
+ * @property {string[]} inferred        — v0.9.0 — indented child bullets under the parent outcome (raw prose, no further parsing). Defaults to [] when no children are present.
  * @property {number} [requires]        — the digit captured from `*(requires ON N)*`, when present and valid
  */
 
@@ -165,24 +166,58 @@ export function parseUserOutcomes(specContent) {
 		return result
 	}
 
-	// Parse outcome rows in document order. Skip non-matching lines (e.g.
-	// stray prose between outcomes) — they don't count as outcomes.
+	// Parse outcome rows in document order. v0.9.0 — walk the raw body lines
+	// (not the trimmed `outcomeLines`) so we preserve indentation of child
+	// bullets. A `**ON**` parent row is followed by zero or more indented
+	// child bullets (lines starting with at least 2 spaces + `- `); those
+	// children attach to the parent as `inferred: string[]` (raw prose, no
+	// further parsing). The children block ends at the next `**ON**` row,
+	// a non-indented line, or a section terminator (blank line followed by
+	// another non-bullet non-blank line is fine; the next `**ON**` always
+	// resets ownership).
 	/** @type {UserOutcome[]} */
 	const outcomes = []
 	const rawRequires = []
-	for (const line of outcomeLines) {
-		const m = line.match(OUTCOME_RE)
-		if (!m) continue
-		const surface = /** @type {UserOutcome['surface']} */ (m[1])
-		if (!VALID_SURFACES.has(surface)) continue
-		const text = m[2].trim()
-		const id = 'O' + (outcomes.length + 1)
-		const outcome = /** @type {UserOutcome} */ ({ id, surface, text })
-		if (m[4]) {
-			const n = Number.parseInt(m[4], 10)
-			rawRequires.push({ outcomeIndex: outcomes.length, requires: n })
+	const CHILD_RE = /^(?: {2}|\t)+- (.+)$/
+	let currentOutcomeIndex = -1
+	for (let i = 0; i < bodyLines.length; i++) {
+		const rawLine = bodyLines[i]
+		const trimmed = rawLine.trim()
+		if (trimmed.length === 0) {
+			// Blank lines don't close the parent — children may resume after
+			// a blank line (loose-list markdown). The next non-blank line
+			// decides ownership.
+			continue
+		}
+		const onMatch = trimmed.match(OUTCOME_RE)
+		if (onMatch) {
+			const surface = /** @type {UserOutcome['surface']} */ (onMatch[1])
+			if (!VALID_SURFACES.has(surface)) {
+				currentOutcomeIndex = -1
+				continue
+			}
+			const text = onMatch[2].trim()
+			const id = 'O' + (outcomes.length + 1)
+			const outcome = /** @type {UserOutcome} */ ({ id, surface, text, inferred: [] })
+			if (onMatch[4]) {
+				const n = Number.parseInt(onMatch[4], 10)
+				rawRequires.push({ outcomeIndex: outcomes.length, requires: n })
+			}
+			outcomes.push(outcome)
+			currentOutcomeIndex = outcomes.length - 1
+			continue
+		}
+		// Non-`**ON**` non-blank line. If it's an indented child bullet AND
+		// we have a current outcome, attach it. Otherwise (e.g. Epic line,
+		// sentinel, stray prose), drop ownership.
+		const childMatch = rawLine.match(CHILD_RE)
+		if (childMatch && currentOutcomeIndex >= 0) {
+			outcomes[currentOutcomeIndex].inferred.push(childMatch[1].trim())
+			continue
 		}
-		outcomes.push(outcome)
+		// Non-indented, non-`**ON**` line — closes the current outcome's
+		// child block. (The next `**ON**` will start a new block.)
+		currentOutcomeIndex = -1
 	}
 
 	if (outcomes.length === 0) {

package/src/cli/dispatch.mjs

@@ -36,6 +36,7 @@
 
 import { cmdActive } from './commands/active.mjs'
 import { cmdAdr } from './commands/adr.mjs'
+// cmdApplyRecipe — loaded lazily in the dispatch handler (Fast Path PRF-001)
 import { cmdAudit } from './commands/audit.mjs'
 import { cmdAuthorSkill } from './commands/author-skill.mjs'
 import { cmdBootstrap } from './commands/bootstrap.mjs'
@@ -70,12 +71,14 @@ import { cmdInitState } from './commands/init-state.mjs'
 import { cmdInstallFromSource } from './commands/install-from-source.mjs'
 import { cmdLock } from './commands/lock.mjs'
 import { cmdMigratePrReviews } from './commands/migrate-pr-reviews.mjs'
+import { cmdMobilePrepare } from './commands/mobile-prepare.mjs'
 import { cmdPersonas } from './commands/personas.mjs'
 import { cmdPlanApproval } from './commands/plan-approval.mjs'
 import { cmdPrReview } from './commands/pr-review.mjs'
 import { cmdPrecompactHook } from './commands/precompact-hook.mjs'
 import { cmdProductContext } from './commands/product-context.mjs'
 import { cmdProfile } from './commands/profile.mjs'
+// cmdRecipeDiff — loaded lazily in the dispatch handler (Fast Path PRF-001)
 import { cmdReleaseNotes } from './commands/release-notes.mjs'
 import { cmdRiskCheck } from './commands/risk-check.mjs'
 import { cmdRoadmap } from './commands/roadmap.mjs'
@@ -98,6 +101,7 @@ import { cmdValidateEvidence } from './commands/validate-evidence.mjs'
 import { cmdVariantGallery } from './commands/variant-gallery.mjs'
 import { cmdVariantPick } from './commands/variant-pick.mjs'
 import { cmdVariantPool } from './commands/variant-pool.mjs'
+// cmdVerifySandbox — loaded lazily in the dispatch handler (Fast Path PRF-001)
 import { cmdVitestDoctor } from './commands/vitest-doctor.mjs'
 import { cmdWave } from './commands/wave.mjs'
 import { cmdWfrun } from './commands/wfrun.mjs'
@@ -219,6 +223,18 @@ export const DISPATCH = {
 	'state-artifacts': (args) => wrap(cmdStateArtifacts)(args[1], args.slice(2)),
 	'detect-project': (args) => wrap(cmdDetectProject)(args[1]),
 	'detect-runtime': (args) => wrap(cmdDetectRuntime)(args[1], args.slice(2)),
+	'recipe-diff': async (args) => {
+		const { cmdRecipeDiff } = await import('./commands/recipe-diff.mjs')
+		return wrap(cmdRecipeDiff)(args[1], args.slice(2))
+	},
+	'apply-recipe': async (args) => {
+		const { cmdApplyRecipe } = await import('./commands/apply-recipe.mjs')
+		return wrap(cmdApplyRecipe)(args[1], args.slice(2))
+	},
+	'verify-sandbox': async (args) => {
+		const { cmdVerifySandbox } = await import('./commands/verify-sandbox.mjs')
+		return wrap(cmdVerifySandbox)(args[1], args.slice(2))
+	},
 	driver: (args) => {
 		// `apt-tools driver doctor <project-dir>` — only subcommand for now.
 		if (args[1] === 'doctor') return wrap(cmdDriverDoctor)(args[2], args.slice(3))
@@ -230,6 +246,17 @@ export const DISPATCH = {
 			exitCode: 1,
 		}))()
 	},
+	mobile: (args) => {
+		// `apt-tools mobile prepare <project-dir> --platform <ios|android> [--mode <expo|native>] [--device <id>]`
+		if (args[1] === 'prepare') return wrap(cmdMobilePrepare)(args[2], args.slice(3))
+		return wrap(() => ({
+			envelope: {
+				status: 'error',
+				error: `Usage: apt-tools mobile prepare <project-dir> --platform <ios|android>. Unknown subcommand: ${args[1] ?? '(none)'}`,
+			},
+			exitCode: 1,
+		}))()
+	},
 	'features-audit': (args) => wrap(cmdFeaturesAudit)(args[1], args.slice(2)),
 	'init-state': (args) => wrap(cmdInitState)(args[1], args.slice(2)),
 	'risk-check': (args) => wrap(cmdRiskCheck)(args[1], args.slice(2)),