devflow-kit 2.0.1 → 2.1.0

package/dist/cli/commands/init-seed.js

@@ -4,7 +4,7 @@
  * Computes the initial state (seed) for init prompts from:
  * - The existing manifest (from a prior install)
  * - The project feature config (.devflow/config.json)
- * - The current settings.json snapshot (for viewMode)
+ * - The current settings.json snapshot (for view-mode resolution)
  * - The plugin registry
  *
  * All exported functions are pure — no I/O, no side effects.
@@ -13,7 +13,7 @@
  * beside init.ts in src/cli/commands/ rather than in src/core/ (which holds
  * agent-neutral, target-agnostic utilities).
  */
-import { resolveExistingViewMode, FLAG_REGISTRY } from '../../core/flags.js';
+import { resolveExistingViewMode, FLAG_REGISTRY, defaultValueOf, readViewMode, } from '../../core/flags.js';
 import { partitionSelectablePlugins } from '../../core/plugins.js';
 /** Registry defaults — all features enabled except proxy (advanced-only, off by default). */
 export const FEATURE_DEFAULTS = {
@@ -63,41 +63,43 @@ export function resolveSeedFeatures(manifest, projectConfig) {
     return { ambient, memory, hud, knowledge, learning, rules, proxy, compliance };
 }
 /**
- * Resolve the enabled flag set for the init seed.
+ * Resolve the flag record for the init seed.
  *
- * @param enabledFlags - Currently-enabled flag IDs from the manifest,
- *                       or null for a fresh install (no prior manifest).
- * @param knownFlags   - Snapshot of all flag IDs known at the last install
- *                       (manifest.features.knownFlags), or undefined when
- *                       the manifest pre-dates the snapshot feature.
- * @param registry     - Flag registry to consult; injectable for tests.
+ * Returns a FlagsRecord containing ALL registry flags at their resolved values.
+ * FlagsRecord key-presence encodes the "known" concept (ADR-014): present key =
+ * known at last install, absent key = new to this install → adopt default on seed.
+ *
+ * @param manifestFlags - FlagsRecord from the manifest, or null for fresh install.
+ * @param registry      - Flag registry to consult; injectable for tests.
  *
  * Rules:
- *   - null enabledFlags (fresh) → all default-ON flags in the registry
- *   - knownFlags === undefined (old manifest, migration) → return enabledFlags
- *     as-is; adopt nothing new (safe: user's prior choices preserved)
- *   - Otherwise → enabledFlags ∪ {default-ON flags whose id ∉ knownFlags}
- *     (newly added registry entries that the user never saw before are auto-adopted)
- *   - Default-OFF flags are NEVER auto-added regardless of knownFlags
+ *   - null manifestFlags (fresh install) → all flags at registry defaults
+ *   - Entry present                      → keep (coerceFlagValue is applied at read
+ *                                          time via sanitizeFlagsRecord; PF-023)
+ *   - Entry absent                       → adopt registry default (ADR-014)
+ *   - Unknown IDs from old manifest      → pass through unchanged (forward-compat)
+ *
+ * Applies ADR-014: absent key = unknown to this install → adopt default.
+ * view-mode is not set here; resolveInitSeed sets flags['view-mode'] after composing.
  */
-export function resolveSeedFlags(enabledFlags, knownFlags, registry = FLAG_REGISTRY) {
-    // Fresh install → all default-ON flags from the registry
-    if (enabledFlags === null) {
-        return registry.filter(f => f.defaultEnabled).map(f => f.id);
-    }
-    // Old manifest without a knownFlags snapshot → adopt nothing new
-    if (knownFlags === undefined) {
-        return [...enabledFlags];
+export function resolveSeedFlags(manifestFlags, registry = FLAG_REGISTRY) {
+    // Fresh install → all flags at registry defaults
+    if (manifestFlags === null) {
+        const result = {};
+        for (const flag of registry) {
+            result[flag.id] = defaultValueOf(flag); // single default-rule source (CONS-M2)
+        }
+        return result;
     }
-    // Re-init with a knownFlags snapshot: union existing + newly-added default-ON entries
-    const knownSet = new Set(knownFlags);
-    const result = new Set(enabledFlags);
+    // Existing install: copy present entries then adopt defaults for absent flags.
+    // Unknown IDs from the old manifest pass through unchanged (forward-compat).
+    const result = { ...manifestFlags };
     for (const flag of registry) {
-        if (flag.defaultEnabled && !knownSet.has(flag.id)) {
-            result.add(flag.id);
-        }
+        if (flag.id in result)
+            continue; // known → keep
+        result[flag.id] = defaultValueOf(flag); // single default-rule source (CONS-M2)
     }
-    return [...result];
+    return result;
 }
 /**
  * Resolve the plugin selection buckets for the init seed.
@@ -161,23 +163,40 @@ export function resolveSeedPlugins(manifestPlugins, knownPlugins, allPlugins) {
 /**
  * Compose the full init seed from manifest, project config, settings, and registry.
  *
- * viewMode priority: existing settings.json (non-default) → manifest → 'default'
+ * view-mode priority: existing settings.json (non-default) → manifest → 'default'.
+ * The resolved view mode is encoded into flags['view-mode'] so all flag state lives
+ * in one FlagsRecord (applying PF-015: fold before strip — the fold happens here).
  *
  * This is the single composition point; callers (init.ts hoist block) call this
- * once and pass `seed` down to Phase 4's prompt wiring.
+ * once and pass `seed` down to prompt wiring.
  */
 export function resolveInitSeed(seedManifest, seedConfig, settingsSnapshot, plugins) {
     const features = resolveSeedFeatures(seedManifest, seedConfig);
-    // null for a fresh install (no manifest); string[] from manifest otherwise
-    const enabledFlags = seedManifest !== null ? seedManifest.features.flags : null;
-    const flags = resolveSeedFlags(enabledFlags, seedManifest?.features.knownFlags);
+    // features.flags is FlagsRecord; null for fresh install (no manifest).
+    // seedManifest?.features.flags may be absent at runtime on very old manifests not yet
+    // healed — ?? null collapses to fresh-install behavior (all flags at registry defaults).
+    const manifestFlags = seedManifest?.features.flags ?? null;
+    const flags = resolveSeedFlags(manifestFlags);
     const manifestPlugins = seedManifest !== null ? seedManifest.plugins : null;
     const { workflowPlugins, languagePlugins } = resolveSeedPlugins(manifestPlugins, seedManifest?.knownPlugins, plugins);
-    // viewMode: non-default setting wins; else manifest; else 'default'
-    const viewMode = resolveExistingViewMode(settingsSnapshot) ??
-        seedManifest?.features.viewMode ??
-        'default';
-    return { features, flags, viewMode, workflowPlugins, languagePlugins };
+    // Encode the resolved view mode into flags['view-mode'] (PF-015: all flag state in FlagsRecord).
+    // Priority: existing settings.json (non-default) → flags['view-mode'] from manifest → 'default'.
+    // resolveExistingViewMode returns undefined when absent or 'default' — treated as no-opinion.
+    const existingViewMode = resolveExistingViewMode(settingsSnapshot);
+    const manifestViewMode = readViewMode(flags); // already in flags via resolveSeedFlags spread
+    let resolvedViewMode;
+    if (existingViewMode !== undefined) {
+        resolvedViewMode = existingViewMode; // settings.json non-default wins
+    }
+    else if (manifestViewMode !== 'default') {
+        resolvedViewMode = manifestViewMode; // manifest non-default wins
+    }
+    else {
+        resolvedViewMode = 'default'; // fall back to neutral
+    }
+    // Return a fresh spread rather than mutating flags in place — keeps this function pure
+    // per the module docblock and avoids aliasing if the caller inspects seed.flags.
+    return { features, flags: { ...flags, 'view-mode': resolvedViewMode }, workflowPlugins, languagePlugins };
 }
 /**
  * Resolve the three seed inputs under the --reset gate.
@@ -208,8 +227,7 @@ export function resolveResetGatedInputs(reset, manifest, projectConfig, settings
  * Per-key: `toggles.X ?? base.X` — an explicit CLI value (true/false) wins;
  * undefined means "user did not specify this flag, keep the seed value".
  *
- * Used in Phase 4 to honour --ambient/--no-ambient etc. passed alongside
- * --recommended.
+ * Applies explicit --ambient/--no-ambient etc. passed alongside --recommended.
  */
 export function applyCliToggles(base, toggles) {
     return {

package/dist/cli/commands/init.js

@@ -24,7 +24,7 @@ import { stripDevflowTeammateModeFromJson } from '../../core/teammate-mode-clean
 import { addHudStatusLine, removeHudStatusLine } from './hud.js';
 import { loadConfig as loadHudConfig, saveConfig as saveHudConfig } from '../../hud/config.js';
 import { readManifest, writeManifest, resolvePluginList, detectUpgrade } from '../../core/manifest.js';
-import { applyFlags, stripFlags, applyViewMode, stripViewMode, FLAG_REGISTRY, resolveExistingViewMode, resolveFinalViewMode } from '../../core/flags.js';
+import { convergeFlagsIntoSettings, countActiveFlags, readViewMode } from '../../core/flags.js';
 import { addContextHook, removeContextHook, hasContextHook } from './context.js';
 import { writeConfig, readConfigIfPresent } from '../../core/feature-config.js';
 import { resolveInitSeed, applyCliToggles, resolveResetGatedInputs } from './init-seed.js';
@@ -276,7 +276,7 @@ export const initCommand = new Command('init')
                 scope,
                 features: {
                     ambient: false, memory: false, hud: true, knowledge: false,
-                    learning: false, rules: false, flags: [], proxy: false,
+                    learning: false, rules: false, flags: {}, proxy: false,
                     compliance: existingHudManifest?.features.compliance ?? { enabled: false, frameworks: [] },
                 },
                 installedAt: now,
@@ -505,12 +505,11 @@ export const initCommand = new Command('init')
     // CLI override applied below in both Recommended and Advanced paths.
     let complianceEnabled = seed.features.compliance.enabled;
     let complianceFrameworks = seed.features.compliance.frameworks;
-    let enabledFlags = seed.flags;
-    let viewMode = seed.viewMode;
-    // viewModeExplicit: true when the user made an explicit interactive selection or --reset was passed.
-    // Used by resolveFinalViewMode to decide whether to clobber an externally-set /focus value.
-    // --reset forces viewMode back to 'default': resolveResetGatedInputs empties the settings snapshot
-    // so seed.viewMode collapses to 'default', and explicit=true makes that 'default' win at write time.
+    let enabledFlags = { ...seed.flags };
+    // viewModeExplicit: true when --reset is passed; signals resolveFinalViewMode to let the
+    // seed-time view-mode win over an externally-set value in settings.json.
+    // --reset empties the settings snapshot via resolveResetGatedInputs so seed.flags['view-mode']
+    // collapses to 'default', and explicit=true makes it take effect at settings write time.
     let viewModeExplicit = !!options.reset;
     let claudeignoreEnabled = !!earlyGitRoot;
     let discoveredProjects = [];
@@ -574,7 +573,7 @@ export const initCommand = new Command('init')
         proxyEnabled = effectiveFeatures.proxy;
         complianceEnabled = effectiveFeatures.compliance.enabled;
         complianceFrameworks = effectiveFeatures.compliance.frameworks;
-        // enabledFlags and viewMode are already initialised to seed values above.
+        // enabledFlags is already initialised to seed.flags above.
         // Compute safe-delete block synchronously so we know whether to fetch installed version
         if (profilePath && safeDeleteAvailable) {
             const trashCmd = safeDeleteInfo.command;
@@ -598,7 +597,7 @@ export const initCommand = new Command('init')
                 safeDeleteAction = 'install';
         }
         // Print summary
-        const defaultFlagCount = enabledFlags.length;
+        const defaultFlagCount = countActiveFlags(enabledFlags);
         const complianceSummary = formatComplianceSummary(complianceEnabled, complianceFrameworks);
         const summaryLines = [
             `Ambient mode:    ${ambientEnabled ? 'enabled' : 'disabled'}`,
@@ -609,8 +608,8 @@ export const initCommand = new Command('init')
             `Knowledge bases: ${knowledgeEnabled ? 'enabled' : 'disabled'}`,
             `Ext model routing: ${proxyEnabled ? 'enabled' : 'disabled'}`,
             `Compliance:      ${complianceSummary}`,
-            `View mode:       ${viewMode}`,
-            `Claude Code flags: ${defaultFlagCount} enabled`,
+            `View mode:       ${readViewMode(enabledFlags)}`,
+            `Claude Code flags: ${defaultFlagCount} configured`,
             `${claudeignoreEnabled ? '.claudeignore:   created' : ''}`,
             `${safeDeleteAction !== 'skip' ? 'Safe delete:     installed' : ''}`,
         ].filter(l => l.trim()).join('\n');
@@ -794,59 +793,15 @@ export const initCommand = new Command('init')
         // No third case in practice: on this path the predicate only returns false for a
         // CLI override (isTTY is guaranteed true by the non-TTY guard above). If it ever
         // did, the seed values assigned at declaration stand — which is the right default.
-        // Claude Code flags multiselect (advanced only)
-        const recommended = FLAG_REGISTRY.filter(f => f.defaultEnabled);
-        const optional = FLAG_REGISTRY.filter(f => !f.defaultEnabled);
-        const flagChoices = [
-            ...recommended.map(f => ({
-                value: f.id,
-                label: f.label,
-                hint: `${f.hint} · recommended`,
-            })),
-            { value: '_separator', label: color.dim('── Optional (skip if unsure) ──'), hint: '' },
-            ...optional.map(f => ({
-                value: f.id,
-                label: f.label,
-                hint: f.hint,
-            })),
-        ];
-        p.note('Recommended flags are pre-selected. Optional flags are for\n' +
-            'advanced users — if you don\'t recognize one, skip it.', 'Claude Code Flags');
-        const flagSelection = await p.multiselect({
-            message: 'Claude Code flags',
-            options: flagChoices,
-            // Pre-seeded from prior state; fresh installs start with all default-ON flags.
-            initialValues: seed.flags,
-            required: false,
-        });
-        if (p.isCancel(flagSelection)) {
-            p.cancel('Installation cancelled.');
-            process.exit(0);
-        }
-        enabledFlags = flagSelection.filter(id => id !== '_separator');
-        // View mode selector (advanced only)
-        p.note('Controls how much detail Claude Code shows in the transcript.\n' +
-            '• default — normal display with expandable tool output\n' +
-            '• verbose — shows everything including thinking blocks\n' +
-            '• focus — minimal: prompt, one-line tool summaries, final response', 'View Mode');
-        const viewModeChoice = await p.select({
-            message: 'View mode',
-            options: [
-                { value: 'default', label: 'Default', hint: 'expandable tool output · recommended' },
-                { value: 'verbose', label: 'Verbose', hint: 'shows everything including thinking' },
-                { value: 'focus', label: 'Focus', hint: 'minimal output, one-line summaries' },
-            ],
-            // Pre-seeded from prior state (fresh installs default to 'default').
-            initialValue: seed.viewMode,
-        });
-        if (p.isCancel(viewModeChoice)) {
-            p.cancel('Installation cancelled.');
-            process.exit(0);
+        /**
+         * D40: init applies seeded flag defaults non-interactively. Flags are customized
+         * exclusively via `devflow flags`; re-init preserves existing values and adopts
+         * registry defaults only for absent flags (ADR-014). No TUI is opened during init.
+         */
+        {
+            const activeCount = countActiveFlags(enabledFlags);
+            p.log.info(`Flags: ${activeCount} active — customize any time with 'devflow flags'`);
         }
-        viewMode = viewModeChoice;
-        // Mark as explicit: user actively selected this mode, so resolveFinalViewMode will
-        // let it win over an externally-set /focus value.
-        viewModeExplicit = true;
         // .claudeignore prompt
         if (earlyGitRoot) {
             if (scope === 'user') {
@@ -1431,17 +1386,21 @@ export const initCommand = new Command('init')
         content = removeDreamHook(content);
         // Strip Devflow-managed teammateMode ("auto"). User-set values (e.g. "tmux") are preserved.
         content = stripDevflowTeammateModeFromJson(content);
-        // Claude Code flags — strip all managed keys, then re-apply selected flags
-        content = stripFlags(content);
-        content = applyFlags(content, enabledFlags);
-        // Resolve the final viewMode to write.
-        // - explicit=true (interactive selection or --reset): selected value always wins
-        // - explicit=false (recommended/non-TTY): preserve an externally-set /focus value;
-        //   otherwise use the seeded viewMode (which already reflects the prior manifest value)
-        viewMode = resolveFinalViewMode(resolveExistingViewMode(content), viewMode, viewModeExplicit);
-        // View mode — strip then apply for upgrade safety
-        content = stripViewMode(content);
-        content = applyViewMode(content, viewMode);
+        // Claude Code flags — convergeFlagsIntoSettings is the single pipeline entry point
+        // (ARCH-H1, applies PF-015/PF-017/ADR-014): fold valued flags and view-mode from
+        // existing settings before strip, then strip all managed keys and apply the folded
+        // record. ownedRecord=existingManifest?.features.flags??null distinguishes keys
+        // devflow previously wrote (must not be overridden by fold) from keys newly adopted
+        // by resolveSeedFlags from registry defaults (may be overridden by fold to preserve
+        // user-set hand values — e.g., a hand-set concurrency of '8' survives upgrade).
+        {
+            const { settings: flaggedContent, record: foldedFlags } = convergeFlagsIntoSettings(content, enabledFlags, {
+                viewModeExplicit,
+                ownedRecord: existingManifest?.features.flags ?? null,
+            });
+            content = flaggedContent;
+            enabledFlags = foldedFlags;
+        }
         // Proxy hooks (SessionStart + UserPromptSubmit) — strip-then-add, idempotent.
         // Parse Settings once for the hook mutation; env mutation stays in string space.
         {
@@ -1755,11 +1714,9 @@ export const initCommand = new Command('init')
             knowledge: knowledgeEnabled,
             learning: learningEnabled,
             rules: rulesEnabled,
+            // FlagsRecord written directly — key-presence encodes "known" (ADR-014).
+            // view-mode is encoded as flags['view-mode'] (the resolved final value).
             flags: enabledFlags,
-            // Snapshot of known flag ids at this install — used by resolveSeedFlags on next init
-            // to detect new default-ON flags and auto-adopt them.
-            knownFlags: FLAG_REGISTRY.map(f => f.id),
-            viewMode,
             security: securityMode,
             // Final resolved value — may be forced off by preflight failure.
             proxy: proxyEnabled,

package/dist/cli/commands/proxy.js

@@ -98,22 +98,37 @@ function getDevflowVersion() {
 }
 // ─── Internal object helpers (used for single-pass atomic settings write) ────
 /**
- * Mutate a parsed Settings object in place: set ANTHROPIC_BASE_URL to our relay.
- * Returns true when the object was changed (used to detect if a write is needed).
+ * D-P4-1: Env var paired with ANTHROPIC_BASE_URL so Claude Code does not enforce
+ * its conservative context-window limit on relay-routed (non-Claude-model) sessions.
+ * Stripped together with the URL — always governed by URL ownership, never independently.
+ */
+const UNKNOWN_MODEL_WINDOW_ENV = 'CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT';
+/**
+ * Mutate a parsed Settings object in place: set ANTHROPIC_BASE_URL to our relay
+ * and set UNKNOWN_MODEL_WINDOW_ENV to '1'.
+ *
+ * D-P4-1: Each condition is evaluated independently (PF-015 — no short-circuit that
+ * skips the second write when the first reports no change).
+ *
+ * Returns true when the object was changed by either assignment.
  */
 function _applyProxyEnvToObject(settings, port) {
     const s = settings;
     s.env = s.env ?? {};
     const env = s.env;
     const newUrl = proxyBaseUrl(port);
-    if (env.ANTHROPIC_BASE_URL === newUrl)
-        return false;
+    // D-P4-1: evaluate each condition independently before combining (avoids PF-015 short-circuit)
+    const urlChanged = env.ANTHROPIC_BASE_URL !== newUrl;
+    const windowVarChanged = env[UNKNOWN_MODEL_WINDOW_ENV] !== '1';
     env.ANTHROPIC_BASE_URL = newUrl;
-    return true;
+    env[UNKNOWN_MODEL_WINDOW_ENV] = '1';
+    return urlChanged || windowVarChanged;
 }
 /**
- * Mutate a parsed Settings object in place: remove ANTHROPIC_BASE_URL only when
- * its value exactly matches our relay on the given managed port.
+ * Mutate a parsed Settings object in place: remove UNKNOWN_MODEL_WINDOW_ENV
+ * unconditionally (Devflow is its only producer — there is no foreign value to protect),
+ * and remove ANTHROPIC_BASE_URL only when it exactly matches our relay on the given
+ * managed port.
  *
  * Scoped to `managedPort` so a user's own localhost gateway (LiteLLM,
  * local Ollama proxy, etc.) on ANY other port is never clobbered.
@@ -123,19 +138,31 @@ function _applyProxyEnvToObject(settings, port) {
  *   - enable path   → the new port being applied (followed immediately by _applyProxyEnvToObject)
  *   - uninstall     → proxy.json.port (or DEFAULT_PROXY_PORT)
  *
- * Returns true when the object was changed.
+ * D-P4-1: URL ownership gates the URL delete only; the window var is always ours to
+ * remove (applies PF-015, ADR-003). Each outcome is evaluated into a local and OR-ed
+ * afterwards — never short-circuit composed inline (PF-015).
+ *
+ * Returns true when the object was changed by either deletion.
  */
 function _stripProxyEnvFromObject(settings, managedPort) {
     const s = settings;
     const env = s.env;
-    if (typeof env?.ANTHROPIC_BASE_URL !== 'string')
-        return false;
-    if (env.ANTHROPIC_BASE_URL !== proxyBaseUrl(managedPort))
+    if (!env)
         return false;
-    delete env.ANTHROPIC_BASE_URL;
+    // Devflow is the only producer of this var — always remove it, regardless of whether
+    // the URL is still ours. Port-scoping protects a FOREIGN url value; there is no
+    // foreign value of this key to protect. (applies PF-015, ADR-003)
+    const hadWindowVar = env[UNKNOWN_MODEL_WINDOW_ENV] !== undefined;
+    delete env[UNKNOWN_MODEL_WINDOW_ENV];
+    let removedUrl = false;
+    if (typeof env.ANTHROPIC_BASE_URL === 'string' &&
+        env.ANTHROPIC_BASE_URL === proxyBaseUrl(managedPort)) {
+        delete env.ANTHROPIC_BASE_URL;
+        removedUrl = true;
+    }
     if (Object.keys(env).length === 0)
         delete s.env;
-    return true;
+    return removedUrl || hadWindowVar; // OR the locals — never compose with || inline (PF-015)
 }
 /** Internal: add ensure-proxy hook to one event. Returns true when added. */
 function _ensureProxyHook(settings, eventName, hookCmd) {
@@ -1327,6 +1354,8 @@ async function runEnable(portOption) {
     s.message('Warming model cache...');
     await discoverExternalModels(cacheDir, logPath).catch(() => { });
     s.stop(color.green('External model routing enabled'));
+    // D-P4-1 / PF-022: applies-on-restart — env var takes effect only for new sessions
+    p.log.info(color.dim('Context-window enforcement disabled for relay-routed models — applies to new Claude Code sessions'));
     if (adopted) {
         p.log.info(`Relay already running on port ${port} — adopted`);
     }

package/dist/cli/commands/uninstall.js

@@ -23,7 +23,7 @@ import { detectShell, getProfilePath } from '../../core/safe-delete.js';
 import { isAlreadyInstalled, removeFromProfile } from '../../core/safe-delete-install.js';
 import { removeManagedSettings, stripUserDenyList, detectDenyState, DEVFLOW_HISTORICAL_DENY } from '../../targets/claude-code/post-install.js';
 import { writeFileAtomicExclusive } from '../../core/fs-atomic.js';
-import { stripFlags, stripViewMode } from '../../core/flags.js';
+import { stripFlags } from '../../core/flags.js';
 import { stripDevflowTeammateModeFromJson } from '../../core/teammate-mode-cleanup.js';
 import { getPackageRoot, isContainedIn } from '../../core/paths.js';
 /**
@@ -765,8 +765,7 @@ export async function runCleanupPhase(opts) {
             settingsContent = removeDreamHook(settingsContent);
             settingsContent = removeHudStatusLine(settingsContent);
             settingsContent = removeContextHook(settingsContent);
-            settingsContent = stripFlags(settingsContent);
-            settingsContent = stripViewMode(settingsContent);
+            settingsContent = stripFlags(settingsContent); // also strips viewMode via view-mode registry entry
             settingsContent = stripDevflowTeammateModeFromJson(settingsContent);
             // Remove proxy hooks and ANTHROPIC_BASE_URL env in a single parse-mutate-serialize pass.
             // REG-1: scope the URL strip to the port Devflow manages — use the pre-captured port

package/dist/cli/flags-view/index.js

@@ -0,0 +1,9 @@
+/**
+ * flags-view public barrel.
+ *
+ * Commands should import from this barrel to avoid coupling to internals.
+ */
+export { runFlagsTui } from './terminal.js';
+export { buildFlagRows, collectFlagRecord } from './state.js';
+export { computeViewportHeight, FIXED_ROWS } from './render.js';
+//# sourceMappingURL=index.js.map