@aperant/framework 0.8.1 → 0.8.6

package/src/cli/commands/init.mjs

@@ -1250,12 +1250,15 @@ export async function cmdInit(projectDir, extraArgs = []) {
 			}
 		}
 
-		// FRAMEWORK-BUG-021 — sweep the legacy `.agents/skills/` codex tree
+		// FRAMEWORK-BUG-021 — sweep the legacy `.codex/` codex tree
 		// BEFORE the install pipeline runs so the install can re-stamp
-		// `.codex/` against a clean slate. Only fires when codex is in the
-		// requested runtime set and `--keep-legacy` was not passed; the
-		// helper itself is conservative (no-op on managed installs, no-op
-		// when no legacy framework files are present).
+		// `.agents/skills/<folder>/SKILL.md` (Codex CLI's documented
+		// surface, per https://developers.openai.com/codex/skills) against
+		// a clean slate. Only fires when codex is in the requested runtime
+		// set and `--keep-legacy` was not passed; the helper itself is
+		// conservative (no-op on managed installs, no-op when no legacy
+		// framework files are present). The v0.8.2 inversion is
+		// documented in `runtime-migrate.mjs:7-12`.
 		let legacyCleanup = null
 		if (effectiveAnswers.runtimes.includes('codex')) {
 			if (parsedFlags.keepLegacy) {
@@ -1265,7 +1268,7 @@ export async function cmdInit(projectDir, extraArgs = []) {
 				legacyCleanup = { runtime: 'codex', ...cleanup }
 				if (cleanup.ran && cleanup.retained.length > 0) {
 					process.stderr.write(
-						`[apt-tools] legacy_cleanup retained ${cleanup.retained.length} user-added path(s) under .agents/skills/: ${cleanup.retained.join(', ')}\n`,
+						`[apt-tools] legacy_cleanup retained ${cleanup.retained.length} user-added path(s) under .codex/: ${cleanup.retained.join(', ')}\n`,
 					)
 				}
 			}

package/src/cli/commands/install-from-source.mjs

@@ -0,0 +1 @@
+export { cmdInstallFromSource } from '../install/install-from-source.mjs'

package/src/cli/commands/modes.mjs

@@ -1,5 +1,5 @@
 /**
- * commands/modes.mjs — `apt-tools modes list` (Pocock adoption ST-13, AC12).
+ * commands/modes.mjs — `apt-tools modes list`.
  *
  * Power-user discoverability tool. Returns a JSON envelope with one
  * record per discovered skill, exposing modes / flags / content-formats /

package/src/cli/commands/route.mjs

@@ -28,7 +28,11 @@ import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { getTaskIsolationConfig, getTrustedSkillSources } from '../config/load.mjs'
+import {
+	getTaskIsolationConfig,
+	getTrustedSkillSources,
+	loadMergedProjectConfig,
+} from '../config/load.mjs'
 import '../gate/gates/index.mjs'
 import * as gateRegistry from '../gate/registry.mjs'
 import { detectHost, SUPPORTED_HOSTS } from '../host/detect.mjs'
@@ -264,6 +268,19 @@ export function cmdRoute(projectDir, extraArgs) {
 		else if (f === 'debug') track_override = 'DEBUG'
 	}
 
+	// FRAMEWORK-RFC-001 — consent signal for spar pipeline auto-inject.
+	// Reads merged config (config.json ∪ config.local.json) via the same
+	// helper apt-setup writes through. AUDIT-001 — spar fields live in
+	// .aperant/config.local.json, not shared config. Resolved once and
+	// folded into the envelope by both classify branches below.
+	// `loadMergedProjectConfig` returns null when no shared config exists
+	// (first-time init path) — treat as consent-off + no partner.
+	const merged = loadMergedProjectConfig(targetDir) ?? {}
+	const sparEnabled = merged.spar?.enabled === true
+	const sparPartner = merged.spar?.partner ?? null
+	const userPassedExplicitSparGates =
+		rawInput.includes('--spar-gates') || flags.some((f) => f.startsWith('spar-gates'))
+
 	const taskDescription = normalizeAptInvocation(rawInput.replace(/--\w+/g, '').trim())
 
 	const configPath = join(targetDir, '.aperant', 'config.json')
@@ -399,6 +416,17 @@ export function cmdRoute(projectDir, extraArgs) {
 		const agentName = spawnAgent ? index.agentOf(primarySkill) || 'apt-planner' : null
 		const options = buildTrackOptions(track)
 		const gate_preview = previewGatesFor(primarySkill)
+		// FRAMEWORK-RFC-001 — flag-override path: track is known deterministically,
+		// so we can resolve the spar gate string inline and emit it directly.
+		// QUICK/DEBUG are Fast-Path-exempt — no inject. User-passed --spar-gates
+		// wins over consent (no double-inject). Field omitted entirely when null
+		// so the envelope stays byte-equivalent for users who never opted in.
+		let spar_inject_gates = null
+		if (sparEnabled && !userPassedExplicitSparGates) {
+			if (track === 'STANDARD') spar_inject_gates = 'plan'
+			else if (track === 'DEEP') spar_inject_gates = 'plan,execute'
+			// QUICK / DEBUG → stays null
+		}
 		return ok({
 			status: 'ok',
 			command: 'route',
@@ -417,6 +445,7 @@ export function cmdRoute(projectDir, extraArgs) {
 			task_isolation,
 			update_check,
 			...(gate_preview ? { gate_preview } : {}),
+			...(spar_inject_gates ? { spar_inject_gates } : {}),
 			classification: {
 				source: 'flag-override',
 				reason: `Explicit --${track_override.toLowerCase()} flag`,
@@ -467,6 +496,18 @@ export function cmdRoute(projectDir, extraArgs) {
 					reason:
 						'Track and skill classification deferred to the host LLM; see classification_meta.trust_notice.',
 				},
+				// FRAMEWORK-RFC-001 — host model composes --spar-gates from these
+				// signals + its track classification per apt/SKILL.md MODE: classify
+				// Step 4. Field is absent when consent is off (envelope stays slim).
+				...(sparEnabled
+					? {
+							spar_consent: {
+								enabled: true,
+								partner: sparPartner,
+								user_passed_explicit_gates: userPassedExplicitSparGates,
+							},
+						}
+					: {}),
 			},
 		})
 	} catch (e) {

package/src/cli/commands/triage.mjs

@@ -1,5 +1,5 @@
 /**
- * commands/triage.mjs — `apt-tools triage` (Pocock adoption ST-10, AC9).
+ * commands/triage.mjs — `apt-tools triage`.
  *
  * 5-state triage state machine with extensible metadata for v2 OSS
  * contributor primitives. Backend-configured: writes to

package/src/cli/config/load.mjs

@@ -361,11 +361,17 @@ export function getTrustedSkillSources(projectDir, cli) {
 	)
 	if (existsSync(consumerSkills)) defaults.push(consumerSkills)
 	// 4. Host CLI's installed runtime skills — only when the router knows
-	// which runtime it's in. Some hosts (codex, claude-code) install into
-	// .codex/skills / .claude/skills etc; the router picks skills from
+	// which runtime it's in. Some hosts (claude-code, gemini, …) install into
+	// .claude/skills / .gemini/skills etc; the router picks skills from
 	// the host-local directory so per-runtime transforms are honored.
+	//
+	// Codex is excluded: its transform strips frontmatter to {name, description}
+	// for codex validator compliance, and that stripped form fails the
+	// router's SkillFrontmatterSchema (contract.mjs). The canonical + kernel
+	// roots above still serve routing on Codex hosts (they carry the fat
+	// frontmatter the schema requires).
 	const installRoot = cli ? cliToInstallRoot(cli) : null
-	if (installRoot) {
+	if (installRoot && cli !== 'codex') {
 		const runtimeSkills = join(targetDir, installRoot, 'skills')
 		if (existsSync(runtimeSkills)) defaults.push(runtimeSkills)
 	}

package/src/cli/coordination/auto-emit-artifact-ready.mjs

@@ -7,7 +7,7 @@
  * postcondition of `apt-tools commit`. This closes the Conductor v2 gap
  * exposed during live verification 2026-05-15: the planner's QUICK /
  * SIMPLE track is hard-exempt from "new interaction discipline"
- * (Pocock Fast Path Guarantee ID-05), so the markdown emit step was
+ * (Aperant Fast Path Guarantee ID-05), so the markdown emit step was
  * never executed for tasks router-classified as simple. The fleet
  * never saw artifact.ready, the PlanReadyCard never auto-promoted.
  *

package/src/cli/coordination/event-schema.mjs

@@ -42,6 +42,10 @@ const CONDUCTOR_OPS = new Set([
 	'conductor.action.executed',
 	'conductor.action.gate_blocked',
 	'conductor.boot_reconciled',
+	// AC21 — MCP-server consent decisions audited to .aperant/events/*.jsonl
+	'mcp-consent.approved',
+	'mcp-consent.denied',
+	'mcp-consent.tofu-reprompt',
 ])
 
 /** Allowed values for `phase.changed.to` — PTY busy/idle only. */
@@ -133,6 +137,21 @@ export function validateConductorEvent(op, data) {
 				'blocked_reason',
 			])
 
+		// AC21 — MCP server consent audit. Three ops share the same
+		// payload shape: who approved/denied which server, with which
+		// configHash, at what time. session_id is a session-scoped string
+		// (chat-session row id).
+		case 'mcp-consent.approved':
+		case 'mcp-consent.denied':
+		case 'mcp-consent.tofu-reprompt':
+			return requireFields(op, d, [
+				'server_id',
+				'config_sha256',
+				'decided_at',
+				'decided_by',
+				'session_id',
+			])
+
 		case 'conductor.boot_reconciled': {
 			// Fleet-wide event — numeric fields only. All optional but if
 			// present must be finite numbers (zero allowed).

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

@@ -0,0 +1,273 @@
+/**
+ * coverage-check/user-outcomes.mjs — `## User Outcomes` PRD section parser.
+ *
+ * Pure, file-IO-free. Mirrors the `coverage-check/acceptance-criteria.mjs`
+ * pattern: takes spec.md content as a string and returns a structured
+ * `{header_present, body_kind, epic?, outcomes[], validation_warnings?}`
+ * envelope the coverage-check command consumes.
+ *
+ * The `## User Outcomes` section is the verify-proof input contract
+ * introduced in v0.8.6 (spec.md §ID-01 / §ID-07). The grammar:
+ *
+ *   ## User Outcomes
+ *
+ *   **Epic:** {one-sentence headline}
+ *
+ *   - **ON** [surface]: {prose}
+ *   - **ON** [surface]: {prose} *(requires ON N)*
+ *
+ *   (refactor-only escape — INSTEAD of the outcome list:)
+ *   _No user-observable changes — pure refactor._
+ *
+ * `surface` is the closed set: electron | web | cli | api | electron+web.
+ *
+ * **Positional ID synthesis (§ID-07 / M1).** The parser counts outcome
+ * rows in document order and synthesizes `id = "O" + (i+1)`. The literal
+ * `**ON**` regex stays — IDs are NOT author-written. The `requires N`
+ * digit captured from `*(requires ON N)*` is validated against the set
+ * of synthesized IDs; on mismatch the parser emits a
+ * `validation_warnings[]` entry of kind `unknown_requires_target`,
+ * skips the dep edge, but still includes the outcome row.
+ *
+ * See packages/framework/skills/apt-plan/SKILL.md Section 5.B for the
+ * authoring contract.
+ */
+
+const VALID_SURFACES = new Set(['electron', 'web', 'cli', 'api', '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*$/
+
+/**
+ * @typedef {Object} UserOutcome
+ * @property {string} id                — synthesized positional ID (O1, O2, ...)
+ * @property {('electron'|'web'|'cli'|'api'|'electron+web')} surface
+ * @property {string} text              — outcome prose (sans the surface tag and requires suffix)
+ * @property {number} [requires]        — the digit captured from `*(requires ON N)*`, when present and valid
+ */
+
+/**
+ * @typedef {Object} ValidationWarning
+ * @property {'unknown_requires_target'} kind
+ * @property {string} outcome_id        — synthesized ID of the outcome carrying the bad `requires`
+ * @property {number} requires          — the offending digit
+ * @property {string} reason            — human-readable explanation
+ */
+
+/**
+ * @typedef {Object} UserOutcomesParseResult
+ * @property {boolean} header_present
+ * @property {('absent'|'empty'|'empty-with-note'|'outcomes')} body_kind
+ * @property {string} [epic]
+ * @property {UserOutcome[]} outcomes
+ * @property {ValidationWarning[]} [validation_warnings]
+ */
+
+/**
+ * Parse the `## User Outcomes` section from a spec.md string.
+ *
+ * @param {string} specContent
+ * @returns {UserOutcomesParseResult}
+ */
+export function parseUserOutcomes(specContent) {
+	if (typeof specContent !== 'string' || specContent.length === 0) {
+		return { header_present: false, body_kind: 'absent', outcomes: [] }
+	}
+
+	const lines = specContent.split('\n')
+
+	// Find the `## User Outcomes` heading + scope to its body (until the next
+	// heading of equal or lower depth).
+	let headingLine = -1
+	let headingLevel = 0
+	for (let i = 0; i < lines.length; i++) {
+		const m = lines[i].trim().match(HEADING_RE)
+		if (m && USER_OUTCOMES_HEADING_RE.test(m[2])) {
+			headingLine = i
+			headingLevel = m[1].length
+			break
+		}
+	}
+
+	if (headingLine === -1) {
+		return { header_present: false, body_kind: 'absent', outcomes: [] }
+	}
+
+	// Collect body lines from heading+1 until the next heading of ANY
+	// depth. The User Outcomes section is intentionally flat — a
+	// downstream sub-heading (e.g. `### Acceptance Criteria` following
+	// directly without a `## ` separator) ends the body. This matches
+	// how authors write the section and avoids accidentally pulling
+	// stray prose from later sections into the outcomes pool.
+	const bodyLines = []
+	for (let i = headingLine + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim()
+		if (HEADING_RE.test(trimmed)) break
+		bodyLines.push(lines[i])
+	}
+
+	// Classify body shape.
+	const nonBlank = bodyLines.map((l) => l.trim()).filter((l) => l.length > 0)
+
+	if (nonBlank.length === 0) {
+		return { header_present: true, body_kind: 'empty', outcomes: [] }
+	}
+
+	// Empty-with-note escape — body MUST contain only the verbatim
+	// italic-underscore-em-dash-period sentinel (other lines may exist
+	// only if they are the Epic header or blank — but the spec says the
+	// sentinel REPLACES the outcome list, so we require it to be the only
+	// non-blank line OR the only non-Epic non-blank line).
+	let epic
+	const sentinelLines = []
+	const outcomeLines = []
+	for (const line of nonBlank) {
+		const epicMatch = line.match(EPIC_RE)
+		if (epicMatch) {
+			epic = epicMatch[1].trim()
+			continue
+		}
+		if (EMPTY_WITH_NOTE_RE.test(line)) {
+			sentinelLines.push(line)
+			continue
+		}
+		outcomeLines.push(line)
+	}
+
+	// If the sentinel is present and there are NO outcome lines, this is
+	// the empty-with-note branch. The sentinel may co-exist with an Epic
+	// header — that's not required but not forbidden either.
+	if (sentinelLines.length > 0 && outcomeLines.length === 0) {
+		/** @type {UserOutcomesParseResult} */
+		const result = {
+			header_present: true,
+			body_kind: 'empty-with-note',
+			outcomes: [],
+		}
+		if (epic) result.epic = epic
+		return result
+	}
+
+	// If neither the sentinel nor any outcome rows are present, the body
+	// is effectively empty (header present, no parseable content).
+	if (outcomeLines.length === 0) {
+		/** @type {UserOutcomesParseResult} */
+		const result = {
+			header_present: true,
+			body_kind: 'empty',
+			outcomes: [],
+		}
+		if (epic) result.epic = epic
+		return result
+	}
+
+	// Parse outcome rows in document order. Skip non-matching lines (e.g.
+	// stray prose between outcomes) — they don't count as outcomes.
+	/** @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 })
+		}
+		outcomes.push(outcome)
+	}
+
+	if (outcomes.length === 0) {
+		// Header present, prose present, but no parseable `**ON**` rows —
+		// effectively empty.
+		/** @type {UserOutcomesParseResult} */
+		const result = {
+			header_present: true,
+			body_kind: 'empty',
+			outcomes: [],
+		}
+		if (epic) result.epic = epic
+		return result
+	}
+
+	// Validate `requires` cross-refs against the set of synthesized IDs.
+	/** @type {ValidationWarning[]} */
+	const warnings = []
+	for (const r of rawRequires) {
+		if (r.requires >= 1 && r.requires <= outcomes.length) {
+			outcomes[r.outcomeIndex].requires = r.requires
+		} else {
+			warnings.push({
+				kind: 'unknown_requires_target',
+				outcome_id: outcomes[r.outcomeIndex].id,
+				requires: r.requires,
+				reason: `requires ON ${r.requires} but only ${outcomes.length} outcome(s) parsed`,
+			})
+		}
+	}
+
+	/** @type {UserOutcomesParseResult} */
+	const result = {
+		header_present: true,
+		body_kind: 'outcomes',
+		outcomes,
+	}
+	if (epic) result.epic = epic
+	if (warnings.length > 0) result.validation_warnings = warnings
+	return result
+}
+
+/**
+ * Compute the coverage-check gate result for a parsed user-outcomes
+ * envelope. Per §ID-07 table — warn-not-block in v0.8.x, hard-block in
+ * v0.9.0.
+ *
+ *  | header_present | body_kind         | v0.8.x | v0.9.0 |
+ *  |----------------|-------------------|--------|--------|
+ *  | false          | —                 | warn   | block  |
+ *  | true           | empty-with-note   | pass   | pass   |
+ *  | true           | outcomes (≥1)     | pass   | pass   |
+ *  | true           | empty             | block  | block  |
+ *
+ * @param {UserOutcomesParseResult} parsed
+ * @param {string} frameworkVersion — semver string from the kernel's package.json (e.g. "0.8.6")
+ * @returns {('pass'|'warn'|'block')}
+ */
+export function userOutcomesGateResult(parsed, frameworkVersion) {
+	if (parsed.body_kind === 'empty-with-note' || parsed.body_kind === 'outcomes') {
+		return 'pass'
+	}
+	if (parsed.body_kind === 'empty') {
+		// Header present, body empty — author started the section and forgot
+		// to fill it in. Block at every version.
+		return 'block'
+	}
+	// Missing header (body_kind: 'absent'). Warn in 0.8.x, block in 0.9.0+.
+	const major = parseFrameworkMajorMinor(frameworkVersion)
+	if (major === null) return 'warn'
+	const { major: maj, minor: min } = major
+	if (maj > 0 || (maj === 0 && min >= 9)) return 'block'
+	return 'warn'
+}
+
+/**
+ * Parse the leading `major.minor` of a semver string. Returns null on
+ * malformed input (caller treats as "warn" — fail-soft).
+ *
+ * @param {string} version
+ * @returns {{major: number, minor: number} | null}
+ */
+function parseFrameworkMajorMinor(version) {
+	if (typeof version !== 'string') return null
+	const m = version.match(/^(\d+)\.(\d+)/)
+	if (!m) return null
+	return { major: Number.parseInt(m[1], 10), minor: Number.parseInt(m[2], 10) }
+}

package/src/cli/dispatch.mjs

@@ -53,7 +53,9 @@ import { cmdDesignScan } from './commands/design-scan.mjs'
 import { cmdDesignTemplate } from './commands/design-template.mjs'
 import { cmdDesignValidate } from './commands/design-validate.mjs'
 import { cmdDetectProject } from './commands/detect-project.mjs'
+import { cmdDetectRuntime } from './commands/detect-runtime.mjs'
 import { cmdDocsAudit } from './commands/docs-audit.mjs'
+import { cmdDriverDoctor } from './commands/driver-doctor.mjs'
 import { cmdEditCheck } from './commands/edit-check.mjs'
 import { cmdEffects } from './commands/effects.mjs'
 import { cmdEvent } from './commands/event.mjs'
@@ -64,6 +66,7 @@ import { cmdHealthCheck } from './commands/health-check.mjs'
 import { cmdHostDetect, cmdReconcile } from './commands/host-detect.mjs'
 import { cmdInit } from './commands/init.mjs'
 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 { cmdPersonas } from './commands/personas.mjs'
@@ -213,6 +216,18 @@ export const DISPATCH = {
 	'state-update': (args) => wrap(cmdStateUpdate)(args[1], args.slice(2)),
 	'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)),
+	driver: (args) => {
+		// `apt-tools driver doctor <project-dir>` — only subcommand for now.
+		if (args[1] === 'doctor') return wrap(cmdDriverDoctor)(args[2], args.slice(3))
+		return wrap(() => ({
+			envelope: {
+				status: 'error',
+				error: `Usage: apt-tools driver doctor <project-dir>. 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)),
@@ -232,6 +247,7 @@ export const DISPATCH = {
 	'detect-worktree': (args) => wrap(cmdDetectWorktree)(args[1]),
 	template: (args) => wrap(cmdTemplate)(args[1]),
 	'check-version': (args) => wrap(cmdCheckVersion)(args[1]),
+	'install-from-source': (args) => wrap(cmdInstallFromSource)(args[1]),
 	'health-check': (args) => wrap(cmdHealthCheck)(args[1]),
 	route: (args) => wrap(cmdRoute)(args[1], args.slice(2)),
 	statusline: (args) => wrap(cmdStatusline)(args[1], args.slice(2)),
@@ -287,7 +303,7 @@ export const DISPATCH = {
 	},
 	'plan-approval': (args) => wrap(cmdPlanApproval)(args[1], args[2], args.slice(3)),
 
-	// ---- Pocock adoption (ST-5, ST-6, ST-10, ST-13) artifact writers + discoverability ----
+	// ---- Aperant adoption (ST-5, ST-6, ST-10, ST-13) artifact writers + discoverability ----
 	context: (args) => wrap(cmdContext)(args[1], args[2], args.slice(3)),
 	adr: (args) => wrap(cmdAdr)(args[1], args[2], args.slice(3)),
 	triage: (args) => wrap(cmdTriage)(args[1], args[2], args.slice(3)),

package/src/cli/gate/context.mjs

@@ -11,7 +11,13 @@
  *     taskId:       string,
  *     taskDir:      string,          // <sharedRoot>/.aperant/tasks/<taskId>/
  *     taskRecord:   object | null,   // state.active_tasks[taskId] (or null)
- *     config:       object           // .aperant/config.json (empty {} if none)
+ *     config:       object,          // .aperant/config.json (empty {} if none)
+ *     profile:      'lite' | 'full-pipeline'
+ *                                    // derived from taskRecord.track:
+ *                                    //   QUICK | DEBUG    → 'lite'
+ *                                    //   STANDARD | DEEP  → 'full-pipeline'
+ *                                    //   null taskRecord  → 'full-pipeline'
+ *                                    //                       (fail-closed)
  *   }
  *
  * The builder is side-effect-free — it never writes state, never mutates the
@@ -24,6 +30,8 @@ import { createCoordinationStore } from '../coordination/store.mjs'
 
 const SAFE_TASK_ID_PATTERN = /^[a-zA-Z0-9_-]+$/
 
+const KNOWN_TRACKS = new Set(['QUICK', 'STANDARD', 'DEEP', 'DEBUG'])
+
 function readJsonIfExists(path) {
 	if (!existsSync(path)) return null
 	try {
@@ -81,6 +89,16 @@ export function buildGateContext(projectRoot, taskId) {
 		config = readJsonIfExists(join(absRoot, '.aperant', 'config.json')) ?? {}
 	}
 
+	if (taskRecord?.track && !KNOWN_TRACKS.has(taskRecord.track)) {
+		process.stderr.write(
+			`[apt:gate] WARNING: unrecognized track "${taskRecord.track}" — defaulting to full-pipeline. ` +
+				`Expected one of: ${[...KNOWN_TRACKS].join(', ')}.\n`,
+		)
+	}
+
+	const profile =
+		taskRecord?.track === 'QUICK' || taskRecord?.track === 'DEBUG' ? 'lite' : 'full-pipeline'
+
 	return {
 		projectRoot: absRoot,
 		sharedRoot,
@@ -88,5 +106,6 @@ export function buildGateContext(projectRoot, taskId) {
 		taskDir,
 		taskRecord,
 		config,
+		profile,
 	}
 }

package/src/cli/gate/gates/consistency-check.mjs

@@ -23,6 +23,7 @@ const gate = {
 	description: 'Cross-artifact consistency (spec/plan/review/qa/progress) has no error drift.',
 	severity: 'blocking',
 	skills: ['ship'],
+	applies_to_profile: (ctx) => ctx.profile === 'full-pipeline',
 	async check(ctx) {
 		const inputs = [
 			join(ctx.taskDir, 'spec.md'),

package/src/cli/gate/gates/review-clean.mjs

@@ -26,6 +26,7 @@ const gate = {
 	description: 'review.json has no unresolved critical/major findings (skipped if absent)',
 	severity: 'blocking',
 	skills: ['ship'],
+	applies_to_profile: (ctx) => ctx.profile === 'full-pipeline',
 	async check(ctx) {
 		const path = join(ctx.taskDir, 'review.json')
 		const inputs = [path]

package/src/cli/gate/gates/verify-approved.mjs

@@ -53,6 +53,7 @@ const gate = {
 		'qa_signoff.json exists with verdict === "approved" (or "approved-with-notes" when configured)',
 	severity: 'blocking',
 	skills: ['ship'],
+	applies_to_profile: (ctx) => ctx.profile === 'full-pipeline',
 	async check(ctx) {
 		const path = join(ctx.taskDir, 'qa_signoff.json')
 		const inputs = [path]

package/src/cli/gate/registry.mjs

@@ -10,7 +10,12 @@
  *     description: string,                // human-readable one-liner
  *     severity:    'blocking' | 'warn',   // blocking gates halt the skill
  *     skills:      string[],              // skills this gate fires for
- *     check:       async (ctx) => GateVerdict
+ *     check:       async (ctx) => GateVerdict,
+ *     applies_to_profile?: (ctx) => boolean // optional; when present and
+ *                                         // returns false, the gate is
+ *                                         // skipped before cache lookup or
+ *                                         // check() invocation. Omit to
+ *                                         // apply universally (default).
  *   }
  *
  * A GateVerdict is:
@@ -57,6 +62,11 @@ export function registerGate(gate) {
 	if (typeof gate.check !== 'function') {
 		throw new Error(`registerGate(${gate.id}): check must be a function`)
 	}
+	if (gate.applies_to_profile !== undefined && typeof gate.applies_to_profile !== 'function') {
+		throw new Error(
+			`registerGate(${gate.id}): applies_to_profile, when present, must be a function`,
+		)
+	}
 	registry.set(gate.id, gate)
 	return gate
 }

package/src/cli/host/detect.mjs

@@ -345,6 +345,6 @@ function detectRawCli(partner, pathEntries, exists) {
 function rawCliInvocation(partner) {
 	if (partner === 'codex') return 'codex exec'
 	if (partner === 'claude') return 'claude -p'
-	if (partner === 'gemini') return 'gemini -m'
+	if (partner === 'gemini') return 'gemini'
 	return partner
 }