devflow-kit 1.8.2 → 2.0.0

package/dist/cli/commands/ambient.js

@@ -0,0 +1,231 @@
+import { Command } from 'commander';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import { getClaudeDirectory, getDevFlowDirectory } from '../../targets/claude-code/claude-paths.js';
+import { syncManifestFeature } from '../../core/manifest.js';
+import { writeFileAtomicExclusive } from '../../core/fs-atomic.js';
+const PREAMBLE_HOOK_MARKER = 'preamble';
+const LEGACY_HOOK_MARKER = 'ambient-prompt';
+/** Stale marker from previous installs — cleaned on disable/re-enable */
+const CLASSIFICATION_HOOK_MARKER = 'session-start-classification';
+/** SessionStart orchestrator charter hook — presence-gated by ambient toggle */
+const ORCHESTRATOR_HOOK_MARKER = 'session-start-orchestrator';
+/**
+ * Path where the legacy commands rule was installed.
+ * The commands rule was removed — this path now exists only to purge the
+ * legacy file from prior installs. Managed by ambient.ts directly (not the
+ * plugin rules system), so only ambient enable/disable/init paths clean it up.
+ */
+export const COMMANDS_RULE_PATH = path.join(os.homedir(), '.claude', 'rules', 'devflow', 'commands.md');
+/** Filter hook entries from a parsed Settings object for a given event. Returns true if any were removed. */
+function filterHookEntries(settings, eventName, shouldRemove) {
+    if (!settings.hooks?.[eventName])
+        return false;
+    const before = settings.hooks[eventName].length;
+    settings.hooks[eventName] = settings.hooks[eventName].filter((matcher) => !shouldRemove(matcher));
+    if (settings.hooks[eventName].length === before)
+        return false;
+    if (settings.hooks[eventName].length === 0) {
+        delete settings.hooks[eventName];
+    }
+    if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    return true;
+}
+/** Add a hook entry for an event if the marker is not already present. Returns true when an entry was added. */
+function ensureHook(settings, eventName, marker, entry) {
+    if (settings.hooks?.[eventName]?.some((m) => m.hooks.some((h) => h.command.includes(marker)))) {
+        return false;
+    }
+    settings.hooks ??= {};
+    settings.hooks[eventName] ??= [];
+    settings.hooks[eventName].push(entry);
+    return true;
+}
+function isLegacy(matcher) {
+    return matcher.hooks.some((h) => h.command.includes(LEGACY_HOOK_MARKER));
+}
+function isAmbient(matcher) {
+    return matcher.hooks.some((h) => h.command.includes(PREAMBLE_HOOK_MARKER) || h.command.includes(LEGACY_HOOK_MARKER));
+}
+function isClassification(matcher) {
+    return matcher.hooks.some((h) => h.command.includes(CLASSIFICATION_HOOK_MARKER));
+}
+function isOrchestrator(matcher) {
+    return matcher.hooks.some((h) => h.command.includes(ORCHESTRATOR_HOOK_MARKER));
+}
+/**
+ * Remove the legacy commands awareness rule file left by prior installs.
+ * Idempotent — no-op if the file does not exist.
+ * Fail-safe: swallows ALL errors (ENOENT, EACCES, EPERM, EROFS, etc.).
+ * This is best-effort cleanup of a deprecated file; it must never abort
+ * the primary operation (hook write or settings.json update) that calls it.
+ */
+export async function removeLegacyCommandsRule() {
+    try {
+        await fs.unlink(COMMANDS_RULE_PATH);
+    }
+    catch {
+        // Intentionally swallow all errors — cleanup is best-effort.
+        // ENOENT = already gone (idempotent); EACCES/EPERM/EROFS = unwritable
+        // filesystem. Neither should abort the caller's primary operation.
+    }
+}
+/**
+ * Add the ambient hooks (preamble UserPromptSubmit + session-start-orchestrator SessionStart)
+ * and remove any legacy commands rule. Removes any legacy `ambient-prompt` hook first.
+ * Idempotent — each hook is checked before adding so enable repairs partial states.
+ * Legacy rule purge runs unconditionally to ensure stale files are always cleaned up.
+ */
+export async function addAmbientHook(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    const removedLegacy = filterHookEntries(settings, 'UserPromptSubmit', isLegacy);
+    // Sweep stale classification hook from prior installs — symmetric with removeAmbientHook
+    const removedClassification = filterHookEntries(settings, 'SessionStart', isClassification);
+    const addedPreamble = ensureHook(settings, 'UserPromptSubmit', PREAMBLE_HOOK_MARKER, { hooks: [{ type: 'command', command: path.join(devflowDir, 'scripts', 'hooks', 'run-hook') + ' preamble', timeout: 5 }] });
+    const addedOrchestrator = ensureHook(settings, 'SessionStart', ORCHESTRATOR_HOOK_MARKER, { hooks: [{ type: 'command', command: path.join(devflowDir, 'scripts', 'hooks', 'run-hook') + ' session-start-orchestrator', timeout: 10 }] });
+    // Purge legacy commands rule (runs before early-return so stale files are always removed)
+    await removeLegacyCommandsRule();
+    if (!removedLegacy && !removedClassification && !addedPreamble && !addedOrchestrator)
+        return settingsJson;
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove the ambient hooks from settings JSON and purge any legacy commands rule.
+ * Removes preamble + legacy from UserPromptSubmit.
+ * Removes session-start-orchestrator from SessionStart.
+ * Also removes stale SessionStart classification hook from previous installs.
+ * Purges legacy COMMANDS_RULE_PATH if present (runs before early-return).
+ * Idempotent — returns unchanged JSON if no ambient hooks were present.
+ * Preserves other hooks. Cleans empty arrays/objects.
+ */
+export async function removeAmbientHook(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    const removedPrompt = filterHookEntries(settings, 'UserPromptSubmit', isAmbient);
+    const removedOrchestrator = filterHookEntries(settings, 'SessionStart', isOrchestrator);
+    // Clean up stale classification hooks from previous installs (no longer registered)
+    const removedClassification = filterHookEntries(settings, 'SessionStart', isClassification);
+    // Purge legacy commands rule (runs before early-return so stale files are always removed)
+    await removeLegacyCommandsRule();
+    if (!removedPrompt && !removedOrchestrator && !removedClassification)
+        return settingsJson;
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if the ambient hook (legacy or current) is registered in settings JSON or parsed Settings object.
+ * Preamble-authoritative: returns true iff the UserPromptSubmit preamble hook is present.
+ * Orchestrator-only (without preamble) is broken partial state → treated as disabled.
+ */
+export function hasAmbientHook(input) {
+    const settings = typeof input === 'string' ? JSON.parse(input) : input;
+    return settings.hooks?.UserPromptSubmit?.some((matcher) => matcher.hooks.some((h) => h.command.includes(PREAMBLE_HOOK_MARKER) || h.command.includes(LEGACY_HOOK_MARKER))) ?? false;
+}
+/**
+ * Check if the orchestrator SessionStart hook is present in settings JSON or parsed Settings object.
+ */
+function hasOrchestratorHook(input) {
+    const settings = typeof input === 'string' ? JSON.parse(input) : input;
+    return settings.hooks?.SessionStart?.some((matcher) => matcher.hooks.some((h) => h.command.includes(ORCHESTRATOR_HOOK_MARKER))) ?? false;
+}
+export const ambientCommand = new Command('ambient')
+    .description('Enable or disable ambient mode (orchestrator charter + plan handoff)')
+    .option('--enable', 'Register ambient mode hooks')
+    .option('--disable', 'Remove ambient mode hooks')
+    .option('--status', 'Check if ambient mode is enabled')
+    .action(async (options) => {
+    const hasFlag = options.enable || options.disable || options.status;
+    if (!hasFlag) {
+        p.intro(color.bgMagenta(color.white(' Ambient Mode ')));
+        p.note(`${color.cyan('devflow ambient --enable')}   Register orchestrator hooks\n` +
+            `${color.cyan('devflow ambient --disable')}  Remove orchestrator hooks\n` +
+            `${color.cyan('devflow ambient --status')}   Check current state`, 'Usage');
+        return;
+    }
+    const claudeDir = getClaudeDirectory();
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let settingsContent;
+    try {
+        settingsContent = await fs.readFile(settingsPath, 'utf-8');
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+        if (options.status) {
+            p.log.info('Ambient mode: disabled (no settings.json found)');
+            return;
+        }
+        // Create minimal settings.json
+        settingsContent = '{}';
+    }
+    // Parse settings once, guarded against corrupt files.
+    // hasAmbientHook / hasOrchestratorHook accept Settings directly to avoid re-parsing.
+    let parsedSettings;
+    try {
+        parsedSettings = JSON.parse(settingsContent);
+    }
+    catch (err) {
+        p.log.error(`Could not parse settings.json: ${err.message}`);
+        return;
+    }
+    if (options.status) {
+        const enabled = hasAmbientHook(parsedSettings);
+        const hasOrchestrator = hasOrchestratorHook(parsedSettings);
+        const repairHint = enabled !== hasOrchestrator
+            ? ` ${color.dim('(partial — run devflow ambient --enable to repair)')}`
+            : '';
+        if (enabled) {
+            p.log.info(`Ambient mode: ${color.green('enabled')}${repairHint}`);
+        }
+        else {
+            p.log.info(`Ambient mode: ${color.dim('disabled')}${repairHint}`);
+        }
+        return;
+    }
+    // Resolve devflow scripts directory.
+    // Primary: getDevFlowDirectory() — purpose-built, not coupled to hook path layout.
+    // Fallback: infer from Stop hook command path (legacy installs where getDevFlowDirectory
+    //   may not yet reflect the correct location).
+    let devflowDir = getDevFlowDirectory();
+    try {
+        const stopHook = parsedSettings.hooks?.Stop?.[0]?.hooks?.[0]?.command;
+        if (stopHook) {
+            const hookBinary = stopHook.split(' ')[0];
+            const inferred = path.resolve(hookBinary, '..', '..', '..');
+            // Only use inferred path when it differs from the canonical default —
+            // this handles legacy installs where the hook was installed to a non-standard location.
+            if (inferred !== devflowDir) {
+                devflowDir = inferred;
+            }
+        }
+    }
+    catch (err) {
+        p.log.warn(`Could not resolve devflow directory from Stop hook: ${err.message}`);
+    }
+    if (options.enable) {
+        const updated = await addAmbientHook(settingsContent, devflowDir);
+        if (updated === settingsContent) {
+            // Both hooks already present — addAmbientHook purges any legacy rule anyway
+            p.log.info('Ambient mode already enabled');
+            return;
+        }
+        await writeFileAtomicExclusive(settingsPath, updated);
+        await syncManifestFeature(getDevFlowDirectory(), 'ambient', true);
+        p.log.success('Ambient mode enabled — orchestrator hooks registered');
+        p.log.info(color.dim('Charter at session start, reminder per prompt, plan handoffs auto-run devflow:implement (git repos only)'));
+    }
+    if (options.disable) {
+        const updated = await removeAmbientHook(settingsContent);
+        if (updated === settingsContent) {
+            p.log.info('Ambient mode already disabled');
+            return;
+        }
+        await writeFileAtomicExclusive(settingsPath, updated);
+        await syncManifestFeature(getDevFlowDirectory(), 'ambient', false);
+        p.log.success('Ambient mode disabled — hooks removed');
+    }
+});
+//# sourceMappingURL=ambient.js.map

package/dist/cli/commands/capture.js

@@ -0,0 +1,133 @@
+import * as path from 'path';
+// ─── Capture hook utilities ────────────────────────────────────────────────
+//
+// The capture bundle (capture-prompt, capture-turn, capture-question) is
+// always-on, like session-start-context (context.ts) — registered
+// unconditionally by init, removed by uninstall. There is no per-feature
+// toggle: capture hooks only append to the memory/learning queues, gated
+// per-queue internally by each script's own feature-config read (see
+// queue-append's queue_read_gates). Follows the context.ts add/remove/has
+// pattern rather than memory.ts's toggle pattern.
+//
+// IMPORTANT — Stop-array ordering contract: capture-turn MUST be registered
+// BEFORE memory-worker in the Stop hook array (see memory.ts). Settings.json
+// hook arrays run in array order, and memory-worker's throttle/spawn decision
+// assumes the current turn has already been appended to the queue by
+// capture-turn earlier in the same Stop event (append-before-spawn). This
+// module only ever pushes capture-turn; callers (init.ts) must register the
+// capture bundle before the memory bundle to preserve this ordering.
+const CAPTURE_PROMPT_MARKER = 'capture-prompt';
+const CAPTURE_TURN_MARKER = 'capture-turn';
+const CAPTURE_QUESTION_MARKER = 'capture-question';
+const CAPTURE_QUESTION_MATCHER = 'AskUserQuestion';
+/**
+ * Map of hook event type → filename marker for the capture hooks.
+ * Three hooks total: UserPromptSubmit, Stop, PostToolUse (matcher-scoped).
+ */
+const CAPTURE_HOOK_CONFIG = {
+    UserPromptSubmit: CAPTURE_PROMPT_MARKER,
+    Stop: CAPTURE_TURN_MARKER,
+    PostToolUse: CAPTURE_QUESTION_MARKER,
+};
+/**
+ * Add all 3 capture hooks (UserPromptSubmit, Stop, PostToolUse) to settings JSON.
+ * Idempotent — skips hooks that already exist. Returns unchanged JSON if all 3 present.
+ * The PostToolUse entry is scoped with `matcher: "AskUserQuestion"` so it only fires
+ * for AskUserQuestion tool calls.
+ */
+export function addCaptureHooks(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    if (hasCaptureHooks(settings)) {
+        return settingsJson;
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    for (const [hookType, marker] of Object.entries(CAPTURE_HOOK_CONFIG)) {
+        const existing = settings.hooks[hookType] ?? [];
+        const alreadyPresent = existing.some((matcher) => matcher.hooks.some((h) => h.command.includes(marker)));
+        if (!alreadyPresent) {
+            const hookCommand = path.join(devflowDir, 'scripts', 'hooks', 'run-hook') + ` ${marker}`;
+            const newEntry = {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookCommand,
+                        timeout: 10,
+                    },
+                ],
+            };
+            if (hookType === 'PostToolUse') {
+                newEntry.matcher = CAPTURE_QUESTION_MATCHER;
+            }
+            if (!settings.hooks[hookType]) {
+                settings.hooks[hookType] = [];
+            }
+            settings.hooks[hookType].push(newEntry);
+        }
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove all capture hooks (UserPromptSubmit, Stop, PostToolUse) from settings JSON.
+ * Accepts either a JSON string or a parsed Settings object.
+ * Idempotent — returns unchanged JSON if no capture hooks present.
+ * Preserves non-capture hooks (e.g. ambient preamble on UserPromptSubmit, memory-worker on Stop).
+ */
+export function removeCaptureHooks(input) {
+    // No-change return must match the formatted style of the mutating return
+    // below (2-space indent + trailing newline) so object callers can't
+    // observe a different representation depending on whether a change
+    // happened. String input is returned byte-identical (no re-formatting).
+    const settingsJson = typeof input === 'string' ? input : JSON.stringify(input, null, 2) + '\n';
+    const settings = typeof input === 'string' ? JSON.parse(input) : structuredClone(input);
+    if (!settings.hooks) {
+        return settingsJson;
+    }
+    let changed = false;
+    for (const [hookType, marker] of Object.entries(CAPTURE_HOOK_CONFIG)) {
+        if (!settings.hooks[hookType]) {
+            continue;
+        }
+        const before = settings.hooks[hookType].length;
+        settings.hooks[hookType] = settings.hooks[hookType].filter((matcher) => !matcher.hooks.some((h) => h.command.includes(marker)));
+        if (settings.hooks[hookType].length !== before) {
+            changed = true;
+        }
+        if (settings.hooks[hookType].length === 0) {
+            delete settings.hooks[hookType];
+        }
+    }
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    if (!changed) {
+        return settingsJson;
+    }
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if ALL 3 capture hooks are registered in settings JSON or parsed Settings object.
+ */
+export function hasCaptureHooks(input) {
+    return countCaptureHooks(input) === Object.keys(CAPTURE_HOOK_CONFIG).length;
+}
+/**
+ * Count how many of the 3 capture hooks are present (0-3).
+ * Accepts either a JSON string or a parsed Settings object.
+ */
+export function countCaptureHooks(input) {
+    const settings = typeof input === 'string' ? JSON.parse(input) : input;
+    if (!settings.hooks) {
+        return 0;
+    }
+    let count = 0;
+    for (const [hookType, marker] of Object.entries(CAPTURE_HOOK_CONFIG)) {
+        const matchers = settings.hooks[hookType] ?? [];
+        if (matchers.some((matcher) => matcher.hooks.some((h) => h.command.includes(marker)))) {
+            count++;
+        }
+    }
+    return count;
+}
+//# sourceMappingURL=capture.js.map

package/dist/cli/commands/compliance-prompts.js

@@ -0,0 +1,174 @@
+/**
+ * Compliance prompt helpers for devflow init.
+ *
+ * CLI-layer module (ADR-013): prompt-rendering logic lives in src/cli/commands/,
+ * core business logic stays in src/core/compliance.ts.
+ *
+ * Applies PF-029: every wizard gate keys on `modePromptShown` (was the Setup-mode
+ * p.select prompt actually shown?), never on the mode name, so --recommended (flag,
+ * no prompt) and the non-TTY fallback preserve their promptless contracts.
+ * Applies PF-014: runComplianceStep never calls process.exit() or throws — callers
+ * own the cancel idiom (p.cancel + process.exit(0)), keeping try/finally cleanup safe.
+ */
+import * as p from '@clack/prompts';
+import { COMPLIANCE_FRAMEWORKS } from '../../core/compliance.js';
+// ── Shared prompt content ──────────────────────────────────────────────────────
+/** Message shown on the compliance framework multiselect prompt. */
+export const FRAMEWORK_SELECT_MESSAGE = 'Select compliance frameworks (Enter to skip — generic controls only)';
+/** Build clack multiselect/select options for the compliance framework list. */
+export function frameworkChoices() {
+    return COMPLIANCE_FRAMEWORKS.map(fw => ({
+        value: fw.id,
+        label: fw.label,
+        hint: fw.hint,
+    }));
+}
+/**
+ * Format a padded framework catalogue suitable for a clack note body.
+ * Produces: `  gdpr       — General Data Protection Regulation`
+ */
+export function formatFrameworkCatalogue() {
+    return 'Valid framework IDs:\n' +
+        COMPLIANCE_FRAMEWORKS.map(fw => `  ${fw.id.padEnd(10)} — ${fw.hint}`).join('\n');
+}
+/**
+ * Format compliance state for the Recommended-mode summary line and note header.
+ *
+ * Pure function — no I/O, no side effects.
+ * Canonical source lives here; init.ts re-exports it for backward compatibility
+ * (tests/init-logic.test.ts imports from init.ts).
+ */
+export function formatComplianceSummary(enabled, frameworks) {
+    if (!enabled)
+        return 'disabled';
+    if (frameworks.length > 0)
+        return `enabled (${frameworks.join(', ')})`;
+    return 'enabled (generic controls only)';
+}
+// ── Gate predicate ─────────────────────────────────────────────────────────────
+/**
+ * Determines whether the compliance wizard step should run for a given init invocation.
+ *
+ * Gate table (per PF-029: key on modePromptShown, never on the mode name):
+ *
+ *   --recommended flag / !isTTY fallback             → no (promptless contract preserved)
+ *   Interactive mode-prompt → Recommended             → yes (modePromptShown=true)
+ *   --advanced flag / re-init (banner path)           → yes (mode='advanced', isTTY=true)
+ *   Interactive mode-prompt → Advanced                → yes (modePromptShown=true)
+ *   Any path with --compliance / --no-compliance      → no (hasCliOverride wins)
+ *
+ * Pure predicate — no side effects, fully testable without a TTY.
+ */
+export function shouldRunComplianceStep(input) {
+    if (input.hasCliOverride)
+        return false;
+    if (!input.isTTY)
+        return false;
+    // Advanced path: non-TTY has already exit-1'd, so isTTY=true here → always run.
+    // Covers: --advanced flag, re-init banner path, interactive-prompt → advanced.
+    if (input.mode === 'advanced')
+        return true;
+    // Recommended path: only run when the Setup-mode p.select actually ran
+    // (user made an active choice). --recommended flag and !isTTY fallback never set
+    // modePromptShown=true, preserving their promptless contracts.
+    return input.modePromptShown;
+}
+/**
+ * Build the real (clack) CompliancePromptIO adapter.
+ * Translates clack's cancel symbol into the PromptOutcome discriminated union.
+ */
+export function buildClackCompliancePrompts() {
+    return {
+        note: (message, title) => p.note(message, title),
+        select: async (opts) => {
+            const result = await p.select({
+                message: opts.message,
+                options: opts.options,
+                initialValue: opts.initialValue,
+            });
+            if (p.isCancel(result))
+                return { kind: 'cancel' };
+            return { kind: 'value', value: result };
+        },
+        multiselect: async (opts) => {
+            const result = await p.multiselect({
+                message: opts.message,
+                options: opts.options,
+                initialValues: opts.initialValues,
+                required: opts.required,
+            });
+            if (p.isCancel(result))
+                return { kind: 'cancel' };
+            return { kind: 'value', value: result };
+        },
+    };
+}
+/**
+ * Run the compliance wizard step.
+ *
+ * Flow:
+ *   1. Note — "Current setting: …" header then the framework catalogue.
+ *   2. Enable select — labeled Yes / No with hints (seeded from prior state);
+ *      p.select is immune to Enter-through muscle memory while still preserving
+ *      the seeded value (ambient-prompt style — per PF-029).
+ *   3. If Yes — framework multiselect (seeded, required:false).
+ *
+ * Returns:
+ *   {kind:'resolved', state, messages} — step completed; `state` is the chosen
+ *     ComplianceFeatureState; `messages` are emitted by the caller.
+ *   {kind:'cancelled'} — user pressed Escape; caller runs p.cancel + process.exit(0).
+ *
+ * Invariants (PF-014):
+ *   - Never calls process.exit(), never throws.
+ *   - Returned arrays never alias seed arrays (defensive copies throughout).
+ *   - All I/O is routed through the `prompts` parameter (injectable for tests).
+ */
+export async function runComplianceStep(opts) {
+    const { seed, prompts } = opts;
+    const currentStr = formatComplianceSummary(seed.enabled, seed.frameworks);
+    prompts.note(`Current setting: ${currentStr}\n\n` +
+        'Stamps the compliance rule with active framework labels and installs\n' +
+        'framework reference files into the compliance skill. Only the\n' +
+        'frameworks you select are included — zero selection = generic controls.\n\n' +
+        formatFrameworkCatalogue(), 'Compliance');
+    const enableOutcome = await prompts.select({
+        message: 'Enable compliance?',
+        options: [
+            { value: true, label: 'Yes', hint: 'stamps frameworks into the compliance rule and skill' },
+            { value: false, label: 'No', hint: 'enable later with devflow compliance --enable' },
+        ],
+        initialValue: seed.enabled,
+    });
+    if (enableOutcome.kind === 'cancel')
+        return { kind: 'cancelled' };
+    const enabled = enableOutcome.value;
+    if (!enabled) {
+        return {
+            kind: 'resolved',
+            // Never alias seed.frameworks — defensive copy (PF-014).
+            state: { enabled: false, frameworks: [...seed.frameworks] },
+            messages: [{
+                    level: 'info',
+                    text: 'Compliance: disabled — enable later with devflow compliance --enable',
+                }],
+        };
+    }
+    // enabled=true: show framework multiselect
+    const multiselectOutcome = await prompts.multiselect({
+        message: FRAMEWORK_SELECT_MESSAGE,
+        options: frameworkChoices(),
+        // Defensive copy: never alias seed.frameworks (PF-014).
+        initialValues: [...seed.frameworks],
+        required: false,
+    });
+    if (multiselectOutcome.kind === 'cancel')
+        return { kind: 'cancelled' };
+    const frameworks = multiselectOutcome.value;
+    const fwLabel = frameworks.length > 0 ? frameworks.join(', ') : 'generic controls only';
+    return {
+        kind: 'resolved',
+        state: { enabled: true, frameworks },
+        messages: [{ level: 'success', text: `Compliance: enabled (${fwLabel})` }],
+    };
+}
+//# sourceMappingURL=compliance-prompts.js.map