@aperant/framework 0.13.0 → 0.15.0

package/src/cli/commands/event.mjs

@@ -8,9 +8,9 @@ import { join, resolve } from 'node:path'
 import { readLifecycleEventsForDay } from '../coordination/event-log.mjs'
 import { validateConductorEvent } from '../coordination/event-schema.mjs'
 import { createCoordinationStore } from '../coordination/store.mjs'
-import { detectWorktree } from '../git/worktree-detect.mjs'
 import { parseFlags } from '../util/args.mjs'
 import { err, ok } from '../util/result.mjs'
+import { resolveMainRepoRoot } from '../util/state-paths.mjs'
 
 // QUA-003 / PRF-002 — single source of truth for valid event types.
 // VALID_EVENT_TYPES is the authoritative list; CI_WATCH_EVENT_TYPES is the O(1)
@@ -88,9 +88,11 @@ export function cmdEvent(subcommand, projectDir, extraArgs) {
 	if (!projectDir) return err('Usage: apt-tools event ' + subcommand + ' <project-dir> [flags]')
 
 	const targetDir = resolve(projectDir)
-	// Use shared event dir (coordinates across worktrees via git common dir, same as locks)
-	const wt = detectWorktree(targetDir)
-	const eventsBase = wt.is_worktree && wt.main_repo_root ? wt.main_repo_root : targetDir
+	// Use shared event dir (coordinates across worktrees, same as locks). This is
+	// a SEPARATE policy wrapper over the shared resolveMainRepoRoot mechanism
+	// (state-fork-fix ID-03) — events do NOT follow resolveStateDir's Phase-2
+	// home relocation, so the resolution stays distinct from resolveStateDir.
+	const eventsBase = resolveMainRepoRoot(targetDir)
 	const eventsDir = join(eventsBase, '.aperant', 'events')
 	mkdirSync(eventsDir, { recursive: true })
 

package/src/cli/commands/fan-out.mjs

@@ -14,6 +14,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 import { parseFlags } from '../util/args.mjs'
 import { err, ok } from '../util/result.mjs'
+import { resolveMainRepoRoot } from '../util/state-paths.mjs'
 
 const ID_PATTERN = /^[a-z0-9_-]+$/i
 
@@ -35,7 +36,8 @@ function parseIdList(raw) {
 }
 
 function readState(targetDir) {
-	const statePath = join(targetDir, '.aperant', 'state.json')
+	// state-fork-fix: ephemeral state read resolves to the main board.
+	const statePath = join(resolveMainRepoRoot(targetDir), '.aperant', 'state.json')
 	if (!existsSync(statePath)) return null
 	try {
 		return JSON.parse(readFileSync(statePath, 'utf-8'))

package/src/cli/commands/features-audit.mjs

@@ -30,6 +30,7 @@ import { loadDocsPolicy, matchSurfaceToPolicy } from '../docs-audit/policy.mjs'
 import { applyStubPatches, auditFeatureRegistry } from '../features/registry-audit.mjs'
 import { parseFlags } from '../util/args.mjs'
 import { err, ok } from '../util/result.mjs'
+import { resolveMainRepoRoot } from '../util/state-paths.mjs'
 
 const TERMINAL_PHASES = new Set(['completed', 'cancelled', 'closed', 'shipped', 'merged'])
 
@@ -138,7 +139,11 @@ function isWorktreeRoot(projectDir) {
 }
 
 function readActiveTasks(projectDir) {
-	const statePath = join(projectDir, '.aperant', 'state.json')
+	// state-fork-fix: read the AUTHORITATIVE main board — readActiveTasks finds
+	// each task's worktree_path for the BUG-025b feature-write redirect, so it
+	// MUST read main or the redirect-target lookup itself forks. (The feature
+	// WRITE path / resolveWriteRoot stays untouched.)
+	const statePath = join(resolveMainRepoRoot(projectDir), '.aperant', 'state.json')
 	if (!existsSync(statePath)) return {}
 	try {
 		const parsed = JSON.parse(readFileSync(statePath, 'utf-8'))

package/src/cli/commands/followups.mjs

@@ -0,0 +1,303 @@
+/**
+ * commands/followups.mjs — `apt-tools followups` (G45).
+ *
+ * The deterministic surface for the per-task follow-ups ledger
+ * ({task_dir}/followups.json). Three subcommands:
+ *
+ *   apt-tools followups check <project-dir> --task-id <id>
+ *     Derive the expected candidate universe (Out of Scope ∪ raw review rows ∪
+ *     qa findings) and report what the ledger is missing / unadjudicated /
+ *     unfixed / undispositioned. Exits 1 when the story is dishonest.
+ *
+ *   apt-tools followups disposition <project-dir> --task-id <id> --row <row-id>
+ *       --kind <filed_task|executed_commit|parked_note|dropped_by_user> --ref <ref>
+ *       [--reason <text>]
+ *     Flip a row to `dispositioned` with the validated disposition record
+ *     (atomic write). `dropped_by_user` additionally requires --reason.
+ *
+ *   apt-tools followups policy <project-dir> --task-id <id>
+ *     Return the effective disposition policy (ask | file | chain +
+ *     max_chain_depth) from config.followups when set, else autonomy-derived.
+ *
+ * Shared-root resolution + taskDir + taskRecord + config all come from
+ * buildGateContext so a worktree-resident invocation reads/writes the same
+ * followups.json the gates read (the L5 worktree concern, plan-approval.mjs).
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { parseUserOutcomes } from '../coverage-check/user-outcomes.mjs'
+import {
+	computeMissingExpected,
+	deriveExpectedCandidates,
+	validateOutcomeRefs,
+} from '../followups/derive.mjs'
+import {
+	DISPOSITION_KINDS,
+	listLoadBearingUnfixed,
+	listUnadjudicatedOpen,
+	listUndispositioned,
+	parseFollowups,
+} from '../followups/schema.mjs'
+import { buildGateContext } from '../gate/context.mjs'
+import { parseFlags } from '../util/args.mjs'
+import { atomicWriteJson, readJsonIfExists } from '../util/io.mjs'
+import { err, exitWith, ok } from '../util/result.mjs'
+
+const SUBCOMMANDS = new Set(['check', 'disposition', 'policy'])
+
+function readTextIfExists(path) {
+	if (!existsSync(path)) return null
+	try {
+		return readFileSync(path, 'utf-8')
+	} catch {
+		return null
+	}
+}
+
+/**
+ * Entry: `apt-tools followups <subcommand> <project-dir> [flags]`.
+ */
+export function cmdFollowups(subcommand, projectDir, extraArgs) {
+	if (!subcommand || !SUBCOMMANDS.has(subcommand)) {
+		return err(
+			'Usage: apt-tools followups <check|disposition|policy> <project-dir> --task-id <id> [...]',
+			1,
+			{ command: 'followups' },
+		)
+	}
+	if (!projectDir) {
+		return err('project-dir is required', 1, { command: `followups-${subcommand}` })
+	}
+	const absProjectDir = resolve(projectDir)
+	if (!existsSync(absProjectDir)) {
+		return err(`project directory not found: ${absProjectDir}`, 1, {
+			command: `followups-${subcommand}`,
+		})
+	}
+
+	const flags = parseFlags(extraArgs ?? [])
+	const taskId = flags.get('task-id')
+	if (typeof taskId !== 'string' || taskId.trim() === '') {
+		return err('--task-id <id> is required', 1, { command: `followups-${subcommand}` })
+	}
+
+	let ctx
+	try {
+		ctx = buildGateContext(absProjectDir, taskId)
+	} catch (e) {
+		return err(`task not found: ${taskId} (${e?.message ?? String(e)})`, 1, {
+			command: `followups-${subcommand}`,
+		})
+	}
+
+	if (subcommand === 'check') return doCheck(ctx)
+	if (subcommand === 'disposition') return doDisposition(ctx, flags)
+	return doPolicy(ctx)
+}
+
+/**
+ * `followups check` — the deterministic adjudication-readiness envelope (AC5).
+ */
+function doCheck(ctx) {
+	const followupsPath = join(ctx.taskDir, 'followups.json')
+	const specPath = join(ctx.taskDir, 'spec.md')
+	const reviewPath = join(ctx.taskDir, 'review.json')
+	const qaPath = join(ctx.taskDir, 'qa_signoff.json')
+
+	const specContent = readTextIfExists(specPath)
+	const review = readJsonIfExists(reviewPath)
+	const qa = readJsonIfExists(qaPath)
+
+	const candidates = deriveExpectedCandidates({ specContent, review, qa })
+	const ledgerDoc = readJsonIfExists(followupsPath)
+	const ledger_present = ledgerDoc !== null
+
+	const parsed = parseFollowups(ledgerDoc ?? { rows: [] })
+	const parsedOutcomes = parseUserOutcomes(specContent ?? '')
+
+	const missing_expected = computeMissingExpected(candidates, parsed.rows)
+	const invalid_outcome_refs = validateOutcomeRefs(parsed.rows, parsedOutcomes)
+	const unadjudicated_open = listUnadjudicatedOpen(parsed)
+	const load_bearing_unfixed = listLoadBearingUnfixed(parsed)
+	const undispositioned = listUndispositioned(parsed)
+
+	// Exit 1 when the ledger is absent while candidates exist (adoption forcing
+	// function), or when derivation/schema/outcome-ref validation fails. The
+	// unadjudicated / load-bearing / undispositioned lists are reported but do
+	// NOT fail `check` directly — those are gate concerns (ship gate / close
+	// gate) so an in-progress verify pass can iterate without `check` flapping.
+	const derivationFailure =
+		(!ledger_present && candidates.length > 0) ||
+		missing_expected.length > 0 ||
+		invalid_outcome_refs.length > 0 ||
+		parsed.schema_errors.length > 0
+
+	const envelope = {
+		status: derivationFailure ? 'fail' : 'ok',
+		command: 'followups-check',
+		task_id: ctx.taskId,
+		ledger_present,
+		expected_total: candidates.length,
+		ledger_rows: parsed.rows.length,
+		schema_errors: parsed.schema_errors,
+		missing_expected,
+		invalid_outcome_refs,
+		unadjudicated_open: unadjudicated_open.map(rowSummary),
+		load_bearing_unfixed: load_bearing_unfixed.map(rowSummary),
+		undispositioned: undispositioned.map(rowSummary),
+	}
+	return exitWith(envelope, derivationFailure ? 1 : 0)
+}
+
+/**
+ * `followups disposition` — flip a row to dispositioned (AC7).
+ */
+function doDisposition(ctx, flags) {
+	const rowId = flags.get('row')
+	if (typeof rowId !== 'string' || rowId.trim() === '') {
+		return err('--row <row-id> is required', 1, { command: 'followups-disposition' })
+	}
+	const kind = flags.get('kind')
+	if (!DISPOSITION_KINDS.has(kind)) {
+		return err(`--kind must be one of: ${[...DISPOSITION_KINDS].join(', ')}`, 1, {
+			command: 'followups-disposition',
+		})
+	}
+	const ref = flags.get('ref')
+	if (typeof ref !== 'string' || ref.trim() === '') {
+		return err('--ref <ref> is required (non-empty)', 1, { command: 'followups-disposition' })
+	}
+	const reasonRaw = flags.get('reason')
+	const reason = typeof reasonRaw === 'string' ? reasonRaw : null
+	if (kind === 'dropped_by_user' && !reason) {
+		return err('--kind dropped_by_user requires --reason "<text>"', 1, {
+			command: 'followups-disposition',
+		})
+	}
+
+	const followupsPath = join(ctx.taskDir, 'followups.json')
+	const ledgerDoc = readJsonIfExists(followupsPath)
+	if (ledgerDoc === null) {
+		return err(`followups.json not found for ${ctx.taskId}`, 1, {
+			command: 'followups-disposition',
+		})
+	}
+	const parsed = parseFollowups(ledgerDoc)
+	// Fail closed on schema errors: the write-back below re-serializes only the
+	// validated `parsed.rows`, so a single malformed row elsewhere in the ledger
+	// would be silently dropped when dispositioning a different row. Refuse and
+	// surface the errors so the operator fixes them first (no silent data loss).
+	if (parsed.schema_errors.length > 0) {
+		return err(
+			`followups.json has ${parsed.schema_errors.length} malformed row(s) — fix them before dispositioning (a write-back would drop them)`,
+			1,
+			{ command: 'followups-disposition', schema_errors: parsed.schema_errors },
+		)
+	}
+	const target = parsed.rows.find((r) => r.id === rowId)
+	if (!target) {
+		return err(`unknown row id: ${rowId}`, 1, {
+			command: 'followups-disposition',
+			known_rows: parsed.rows.map((r) => r.id),
+		})
+	}
+
+	// Atomic flip: re-serialize the full validated row set with the target's
+	// status + disposition updated. The on-disk shape is `{ rows: [...] }`.
+	const disposition = { kind, ref, ...(reason ? { reason } : {}) }
+	const nextRows = parsed.rows.map((r) =>
+		r.id === rowId ? { ...r, status: 'dispositioned', disposition } : r,
+	)
+	atomicWriteJson(followupsPath, { rows: nextRows })
+
+	return ok({
+		status: 'ok',
+		command: 'followups-disposition',
+		task_id: ctx.taskId,
+		row: rowId,
+		disposition,
+	})
+}
+
+/**
+ * `followups policy` — effective disposition policy (AC8 / ID-11).
+ */
+function doPolicy(ctx) {
+	const followupsCfg = ctx.config?.followups ?? {}
+	const explicit = followupsCfg.after_close
+
+	// Resolve the autonomy level: task record first, then config default, else 1.
+	const autonomy =
+		typeof ctx.taskRecord?.autonomy === 'number'
+			? ctx.taskRecord.autonomy
+			: typeof ctx.config?.autonomy?.default === 'number'
+				? ctx.config.autonomy.default
+				: 1
+
+	let after_close
+	let source
+	if (explicit === 'ask' || explicit === 'file' || explicit === 'chain') {
+		after_close = explicit
+		source = 'config'
+	} else {
+		after_close = autonomy <= 1 ? 'ask' : autonomy === 2 ? 'file' : 'chain'
+		source = 'autonomy'
+	}
+
+	// max_chain_depth: default 1; clamp values > 1 to 1 with a warning (v1).
+	let max_chain_depth = 1
+	let clamp_warning = null
+	const rawDepth = followupsCfg.max_chain_depth
+	if (typeof rawDepth === 'number' && Number.isFinite(rawDepth)) {
+		if (rawDepth > 1) {
+			clamp_warning = `max_chain_depth ${rawDepth} clamped to 1 (v1 supports depth-1 only)`
+		} else if (rawDepth >= 1) {
+			max_chain_depth = 1
+		} else {
+			// depth < 1 means no chaining; degrade chain → file.
+			max_chain_depth = 0
+		}
+	}
+
+	// Anti-perpetual-motion: degrade chain → file when the CURRENT task's
+	// triage.json marks it as already a chained descendant at/over the cap.
+	const triagePath = join(ctx.taskDir, 'triage.json')
+	const triage = readJsonIfExists(triagePath)
+	const chainDepth = triage?.extra?.followups_chain?.depth
+	let degraded = false
+	if (after_close === 'chain' && typeof chainDepth === 'number' && chainDepth >= max_chain_depth) {
+		after_close = 'file'
+		degraded = true
+	}
+	// A 0 max_chain_depth (depth < 1 config) also degrades chain → file.
+	if (after_close === 'chain' && max_chain_depth < 1) {
+		after_close = 'file'
+		degraded = true
+	}
+
+	const envelope = {
+		status: 'ok',
+		command: 'followups-policy',
+		task_id: ctx.taskId,
+		after_close,
+		max_chain_depth,
+		source,
+		autonomy,
+	}
+	if (clamp_warning) envelope.warning = clamp_warning
+	if (degraded) envelope.degraded_from_chain = true
+	return ok(envelope)
+}
+
+function rowSummary(r) {
+	return {
+		id: r.id,
+		title: r.title,
+		status: r.status,
+		class_proposed: r.class_proposed,
+		verdict: r.adjudication?.verdict ?? null,
+		disposition_kind: r.disposition?.kind ?? null,
+	}
+}

package/src/cli/commands/health-check.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url'
 import { getSharedLockDir } from '../util/project.mjs'
 import { err, ok } from '../util/result.mjs'
 import { readSkillInstallState } from '../util/skill-installs.mjs'
+import { resolveMainRepoRoot } from '../util/state-paths.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -70,7 +71,8 @@ export function cmdHealthCheck(projectDir) {
 	}
 
 	// 2. Check for stale active_task in state.json
-	const statePath = join(aperantDir, 'state.json')
+	// state-fork-fix: state.json is EPHEMERAL — resolve to the main board.
+	const statePath = join(resolveMainRepoRoot(targetDir), '.aperant', 'state.json')
 	if (existsSync(statePath)) {
 		try {
 			const state = JSON.parse(readFileSync(statePath, 'utf-8'))

package/src/cli/commands/merge-detect.mjs

@@ -0,0 +1,203 @@
+/**
+ * commands/merge-detect.mjs — conflict envelope + on-disk marker reader for
+ * apt:merge-conflict-resolution.
+ *
+ * Two read-only subcommands, both pure git inspection — NO history rewrite,
+ * NO `git merge`, NO `git rebase`, NO index mutation. The SKILL.md prose owns
+ * every state change; this primitive only OBSERVES.
+ *
+ *   apt-tools merge detect <project-dir> [--base <ref>] [--head <ref>]
+ *       Trial-merge probe via `git merge-tree --write-tree --no-messages`.
+ *       Reuses the EXACT detection from audit-branch-current.mjs (`gitTry`,
+ *       `parseConflictPaths`, `isGitVersionTooOld`) — no reinvented detection.
+ *       --base defaults to `origin/main`; --head defaults to `HEAD`. Returns
+ *       { mergeable, conflicts_preview?, audit_warning? }. `mergeable: null`
+ *       on an unprobeable git (too old / invocation error) so the caller can
+ *       fall back gracefully rather than asserting clean.
+ *
+ *   apt-tools merge markers <project-dir>
+ *       Lists files that carry on-disk conflict markers (the state AFTER a
+ *       real `git merge`/`git rebase` left the worktree conflicted) and reads
+ *       each file's full content so the executing agent can resolve the
+ *       markers inline. Source of truth for "is the merge conflicted" is
+ *       `git diff --name-only --diff-filter=U` (unmerged paths). Returns
+ *       { conflicted, files: [{ path, content }] }. Empty `conflicted` means
+ *       a clean tree — nothing to resolve.
+ *
+ * Why agent-inline (not a programmatic resolver): the framework CLI is
+ * self-contained ESM and MUST NOT import @aperant/core (it declares no such
+ * dep — see runtime-capabilities.mjs:5). The LLM driving the CLI reads the
+ * markers this command surfaces and resolves them, then re-probes via
+ * `detect`. See GitHub issue #390 for the architecture decision.
+ *
+ * @internal
+ */
+
+import { readFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { err, ok } from '../util/result.mjs'
+import { gitTry, isGitVersionTooOld, parseConflictPaths } from './audit-branch-current.mjs'
+import { mergeIntegrate } from './merge-integrate.mjs'
+
+/**
+ * Parse `--<name> <value>` (or `--<name>=<value>`) from extraArgs.
+ *
+ * @param {string[]} extraArgs
+ * @param {string} name
+ * @param {string} fallback
+ * @returns {string}
+ */
+function parseFlag(extraArgs, name, fallback) {
+	const long = `--${name}`
+	const eq = `--${name}=`
+	for (let i = 0; i < extraArgs.length; i++) {
+		const a = extraArgs[i]
+		if (a === long && i + 1 < extraArgs.length) return extraArgs[i + 1]
+		if (a.startsWith(eq)) return a.slice(eq.length)
+	}
+	return fallback
+}
+
+/**
+ * `apt-tools merge detect` — trial-merge mergeability probe.
+ *
+ * @param {string} targetDir
+ * @param {string[]} extraArgs
+ * @returns {import('../util/result.mjs').CommandResult}
+ */
+function mergeDetect(targetDir, extraArgs) {
+	const base = parseFlag(extraArgs, 'base', 'origin/main')
+	const head = parseFlag(extraArgs, 'head', 'HEAD')
+
+	const probe = gitTry(targetDir, ['merge-tree', '--write-tree', '--no-messages', head, base])
+
+	/** @type {boolean | null} */
+	let mergeable
+	/** @type {string[] | undefined} */
+	let conflictsPreview
+	/** @type {string | undefined} */
+	let auditWarning
+
+	if (probe.ok) {
+		// Documented merge-tree exit-code semantics: 0 = clean.
+		mergeable = true
+	} else if (probe.code === 1 && probe.stdout.trim().length > 0) {
+		// 1 = conflict, BUT only when stdout carried the conflict report
+		// (the tree-OID line + per-stage paths). A bad ref also exits 1 with
+		// EMPTY stdout and the error on stderr (e.g. "<ref> - not something we
+		// can merge") — that is a probe failure, not a clean-merge conflict, so
+		// we fall through to the merge-tree-probe-failed branch below.
+		mergeable = false
+		conflictsPreview = parseConflictPaths(probe.stdout)
+	} else if (isGitVersionTooOld(probe.stderr)) {
+		mergeable = null
+		auditWarning = 'git-version-too-old'
+	} else {
+		// Other = invocation error (bad ref, not a repo, etc.).
+		mergeable = null
+		auditWarning = 'merge-tree-probe-failed'
+	}
+
+	const envelope = {
+		status: 'ok',
+		command: 'merge-detect',
+		projectDir: targetDir,
+		base,
+		head,
+		mergeable,
+	}
+	if (conflictsPreview && conflictsPreview.length > 0) {
+		envelope.conflicts_preview = conflictsPreview
+	}
+	if (auditWarning) {
+		envelope.audit_warning = auditWarning
+		if (probe.stderr.trim()) {
+			envelope.warnings = [probe.stderr.trim().slice(0, 200)]
+		}
+	}
+	return ok(envelope)
+}
+
+/**
+ * `apt-tools merge markers` — read on-disk conflict markers from the unmerged
+ * worktree so the agent can resolve them inline.
+ *
+ * @param {string} targetDir
+ * @returns {import('../util/result.mjs').CommandResult}
+ */
+function mergeMarkers(targetDir) {
+	// Unmerged paths (stage > 0) are the authoritative "conflicted file" set.
+	const unmerged = gitTry(targetDir, ['diff', '--name-only', '--diff-filter=U'])
+	if (!unmerged.ok) {
+		return ok({
+			status: 'ok',
+			command: 'merge-markers',
+			projectDir: targetDir,
+			conflicted: [],
+			files: [],
+			warnings: [`git diff failed: ${unmerged.stderr.trim().slice(0, 200) || 'unknown error'}`],
+		})
+	}
+
+	const conflicted = unmerged.stdout
+		.split('\n')
+		.map((l) => l.trim())
+		.filter((l) => l.length > 0)
+
+	const files = []
+	const warnings = []
+	for (const path of conflicted) {
+		try {
+			const content = readFileSync(join(targetDir, path), 'utf-8')
+			files.push({ path, content })
+		} catch (e) {
+			warnings.push(`could not read ${path}: ${e?.message ?? String(e)}`)
+		}
+	}
+
+	const envelope = {
+		status: 'ok',
+		command: 'merge-markers',
+		projectDir: targetDir,
+		conflicted,
+		files,
+	}
+	if (warnings.length > 0) envelope.warnings = warnings
+	return ok(envelope)
+}
+
+/**
+ * Dispatch an `apt-tools merge <subcommand>` call.
+ *
+ * @param {string} subcommand
+ * @param {string} projectDir
+ * @param {string[]} [extraArgs]
+ * @returns {import('../util/result.mjs').CommandResult}
+ *
+ * @internal
+ */
+export function cmdMerge(subcommand, projectDir, extraArgs = []) {
+	if (!subcommand) {
+		return err('Usage: apt-tools merge <detect|markers|integrate> <project-dir> [flags]')
+	}
+	if (!projectDir) {
+		return err(`Usage: apt-tools merge ${subcommand} <project-dir> [flags]`)
+	}
+	const targetDir = resolve(projectDir)
+	switch (subcommand) {
+		case 'detect':
+			return mergeDetect(targetDir, extraArgs)
+		case 'markers':
+			return mergeMarkers(targetDir)
+		case 'integrate':
+			return mergeIntegrate(targetDir, extraArgs)
+		default:
+			return err(
+				`Unknown merge subcommand: ${subcommand}. Expected 'detect', 'markers', or 'integrate'.`,
+			)
+	}
+}
+
+// Test-only exports for unit-level coverage (not part of the public CLI
+// contract).
+export { mergeDetect as __mergeDetectForTests, mergeMarkers as __mergeMarkersForTests }