devflow-kit 1.8.3 → 2.0.1

package/dist/core/agent-models.js

@@ -0,0 +1,556 @@
+/**
+ * Agent model mapping engine — schema, persistence, and convergence for the
+ * per-agent model configuration feature.
+ *
+ * applies ADR-013: pure core-layer module, no Claude Code adapter concerns.
+ * avoids PF-014: all fallible operations return Result, no process.exit().
+ *
+ * Mapping file: ~/.devflow/agent-models.json
+ *   { version: 1, agents: { [name]: { model?, effort? } } }
+ *   Deviations-only: omit an agent to inherit its shipped default.
+ *   Unknown agent names are tolerated and preserved on save (plugin may not be installed).
+ *   Invalid effort values are dropped with a warning.
+ *
+ * Dormancy semantics:
+ *   A mapping entry whose model is an external GPT model (classified via
+ *   isDormantExternalModel — the complement of isClaudeModelName) materializes
+ *   into frontmatter ONLY when proxyEnabled=true. When the proxy is disabled,
+ *   the entry stays saved but the SHIPPED DEFAULT model is applied instead.
+ *   Effort is orthogonal — it ALWAYS applies regardless of proxy state.
+ *
+ * Dependency direction:
+ *   core/proxy-state ← core/agent-models ← cli commands
+ *   (no cycles)
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { writeFileAtomicExclusive } from './fs-atomic.js';
+import { isDormantExternalModel } from './external-models.js';
+import { rewriteAgentFrontmatter, readFrontmatterModel, isValidModelName } from './agent-frontmatter.js';
+import { agentsDir } from './assets.js';
+import { getAllAgentNames } from './plugins.js';
+import { mdEntryName, mdFileName } from './orphan-sweep.js';
+import { isContainedIn } from './paths.js';
+function Ok(value) {
+    return { ok: true, value };
+}
+function Err(error) {
+    return { ok: false, error };
+}
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * Valid effort level identifiers.
+ * Invalid values are dropped with a warning on mapping read.
+ */
+export const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Membership set typed as ReadonlySet<string> so .has() accepts a plain
+ * string argument without a cast — TypeScript's Set<T>.has() requires T, and
+ * EFFORT_LEVELS[number] is a literal union, not string (applies ADR-003).
+ */
+const EFFORT_LEVELS_SET = new Set(EFFORT_LEVELS);
+// ---------------------------------------------------------------------------
+// Key migration
+// ---------------------------------------------------------------------------
+/**
+ * Maps old agent keys (form A slugs) to their canonical replacement keys.
+ *
+ * 13 agents renamed from noun form (coder, reviewer, …) to action-verb form
+ * (code, review, …). The canonicalise-agent-keys-v1 migration in migrations.ts
+ * calls canonicaliseAgentKeys() to rewrite ~/.devflow/agent-models.json on the
+ * user's first init after upgrading.
+ *
+ * PROTOTYPE SAFETY: Object.create(null) prevents prototype-pollution.
+ * Every lookup MUST use Object.hasOwn — never key in LEGACY_AGENT_KEYS or
+ * direct bracket access. `--set constructor` would otherwise return a function
+ * that flows into path.join (the object-literal lookup on argv trap).
+ *
+ * DORMANCY: entries here are stored whether or not the key rename has been
+ * applied to the file yet. canonicaliseAgentKeys() is idempotent, so
+ * double-execution from concurrent sessions is a harmless no-op — the second
+ * run finds the file already migrated and makes zero writes.
+ */
+export const LEGACY_AGENT_KEYS = Object.assign(Object.create(null), {
+    // Phase 4 — agent-action-verbs rename (old slug → new slug)
+    'coder': 'code',
+    'designer': 'design',
+    'evaluator': 'evaluate',
+    'researcher': 'research',
+    'reviewer': 'review',
+    'scrutinizer': 'scrutinize',
+    'simplifier': 'simplify',
+    'skimmer': 'skim',
+    'synthesizer': 'synthesize',
+    'tester': 'test',
+    'triager': 'triage',
+    'validator': 'validate',
+    'bug-analyzer': 'diagnose',
+});
+/**
+ * Canonicalise agent keys in a raw agents map by applying LEGACY_AGENT_KEYS.
+ *
+ * For each old key found in the map:
+ *   - If the new (canonical) key is NOT already present: rename old → new.
+ *   - If the new key IS already present (collision): new wins, old dropped, one warning.
+ *
+ * Collision detection is against the ORIGINAL map so results are order-independent.
+ *
+ * The function is pure and idempotent: calling it twice on the same input
+ * produces the same result as calling it once (idempotent under concurrent execution).
+ *
+ * __proto__ is skipped on both read and write sides — setting it would mutate
+ * the prototype instead of creating a property, violating byte-identity.
+ *
+ * @param rawAgents - The `agents` field from the raw JSON file (any value types).
+ * @param onWarning - Optional callback for collision warnings.
+ * @returns { agents, didMutate, renamed, dropped, guardDropped } — caller persists iff didMutate is true.
+ *   renamed: legacy keys successfully renamed to their canonical form.
+ *   dropped: legacy keys dropped due to canonical-key collision (new value wins).
+ *   guardDropped: legacy keys dropped due to prototype-pollution guard (distinct from collision).
+ */
+export function canonicaliseAgentKeys(rawAgents, onWarning) {
+    const warn = onWarning ?? (() => undefined);
+    const renamed = [];
+    const dropped = [];
+    const guardDropped = [];
+    // Fast path: no legacy keys defined — skip without reading input.
+    if (Object.keys(LEGACY_AGENT_KEYS).length === 0) {
+        return { agents: rawAgents, didMutate: false, renamed, dropped, guardDropped };
+    }
+    // Snapshot the original keys for collision detection (order-independent result).
+    const originalKeys = new Set(Object.keys(rawAgents));
+    const result = { ...rawAgents };
+    let didMutate = false;
+    for (const oldKey of originalKeys) {
+        // Skip the __proto__ old-key: iteration is safe but we must never rename or
+        // assign it — even reading result['__proto__'] would touch the prototype chain.
+        // If LEGACY_AGENT_KEYS declares it, treat as a guard-drop (removes the own
+        // property that spread may have copied, and records the truthful outcome).
+        if (oldKey === '__proto__') {
+            if (Object.hasOwn(LEGACY_AGENT_KEYS, '__proto__')) {
+                // Reflect.deleteProperty safely removes the own '__proto__' property
+                // (created by spread's [[DefineOwnProperty]]) without touching the prototype chain.
+                Reflect.deleteProperty(result, '__proto__');
+                guardDropped.push('__proto__');
+                didMutate = true;
+            }
+            continue;
+        }
+        if (!Object.hasOwn(LEGACY_AGENT_KEYS, oldKey))
+            continue;
+        const newKey = LEGACY_AGENT_KEYS[oldKey];
+        // Guard new key: creating an own property named __proto__ would silently
+        // set the prototype chain instead. Drop and remove the old key without creating target.
+        // This is a pollution-guard drop, not a collision drop — report under guardDropped.
+        if (newKey === '__proto__') {
+            guardDropped.push(oldKey);
+            delete result[oldKey];
+            didMutate = true;
+            continue;
+        }
+        if (originalKeys.has(newKey)) {
+            // Collision: new (canonical) key already present → new wins, old dropped.
+            // Warning is surfaced by the caller's structured dropped-block (e.g. migrations.ts)
+            // to avoid printing the same collision twice in two different vocabularies (F8).
+            dropped.push(oldKey);
+        }
+        else {
+            result[newKey] = result[oldKey];
+            renamed.push(oldKey);
+        }
+        // Remove the legacy key regardless of collision outcome.
+        delete result[oldKey];
+        didMutate = true;
+    }
+    return { agents: result, didMutate, renamed, dropped, guardDropped };
+}
+/**
+ * Read and validate the agent-models.json envelope for migration purposes.
+ *
+ * Returns a discriminated result:
+ *   skip — file absent, empty, or agents field absent; caller is a no-op.
+ *   warn — IO error, JSON parse failure, or structural violation; caller
+ *           pushes the message to its warnings array (no migration prefix here).
+ *   ok   — envelope and rawAgents are validated and ready for canonicalisation.
+ *
+ * Does NOT apply canonicaliseAgentKeys — that is the migration's responsibility.
+ * Raw read (not readAgentMapping) intentionally avoids dropping unknown fields
+ * on a round-trip (parseRawEnvelope discipline: read raw, validate defensively).
+ *
+ * Pure I/O; does not mutate the file.
+ */
+export async function parseAgentMappingEnvelope(filePath) {
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return { kind: 'skip' };
+        return { kind: 'warn', message: `cannot read ${filePath}: ${err.message}` };
+    }
+    // Strip BOM (U+FEFF) — some Windows editors prepend it to JSON files.
+    const content = raw.charCodeAt(0) === 0xFEFF ? raw.slice(1) : raw;
+    if (content.trim() === '')
+        return { kind: 'skip' };
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return { kind: 'warn', message: `${filePath} contains invalid JSON — skipping` };
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return { kind: 'warn', message: `${filePath} is not a JSON object — skipping` };
+    }
+    const envelope = parsed;
+    const rawAgents = envelope['agents'];
+    if (rawAgents === undefined || rawAgents === null) {
+        return { kind: 'skip' }; // no agents field → nothing to migrate
+    }
+    if (typeof rawAgents !== 'object' || Array.isArray(rawAgents)) {
+        return { kind: 'warn', message: `${filePath} has non-object agents field — skipping` };
+    }
+    return { kind: 'ok', envelope, rawAgents: rawAgents };
+}
+/**
+ * Read and tolerantly parse ~/.devflow/agent-models.json.
+ * Returns an empty mapping when the file is missing.
+ * Drops invalid effort values with a warning; preserves unknown agent names.
+ */
+export async function readAgentMapping(devflowDir, opts) {
+    const filePath = path.join(devflowDir, 'agent-models.json');
+    const warn = opts?.onWarning ?? (() => undefined);
+    // parseAgentMappingEnvelope handles I/O, BOM-strip, JSON parse, and shape
+    // validation — shared with the migration path so BOM tolerance is consistent.
+    const envelope = await parseAgentMappingEnvelope(filePath);
+    if (envelope.kind === 'skip')
+        return Ok({ version: 1, agents: {} });
+    if (envelope.kind === 'warn') {
+        // A non-object agents field (e.g. agents:[]) is treated as empty mapping — graceful
+        // degradation matches the prior inline logic and avoids Err for a recoverable state.
+        // All other warn cases (IO error, bad JSON, root non-object) are hard errors.
+        if (envelope.message.includes('non-object agents field')) {
+            return Ok({ version: 1, agents: {} });
+        }
+        return Err(envelope.message);
+    }
+    // ok arm: iterate rawAgents and validate per-entry fields.
+    const agents = {};
+    for (const [name, entry] of Object.entries(envelope.rawAgents)) {
+        if (typeof entry !== 'object' || entry === null)
+            continue;
+        const raw = entry;
+        const mapping = {};
+        if (typeof raw.model === 'string') {
+            // Tighten to the same charset used by rewriteAgentFrontmatter.
+            // The effort field is enum-validated below; model must be equally strict.
+            // An invalid entry is dropped with a warning rather than silently
+            // persisting and permanently poisoning that agent on every reapply.
+            if (isValidModelName(raw.model)) {
+                mapping.model = raw.model;
+            }
+            else {
+                warn(`agent-models: invalid-model name for agent "${name}" — dropping entry`);
+            }
+        }
+        if (typeof raw.effort === 'string') {
+            if (EFFORT_LEVELS_SET.has(raw.effort)) {
+                // Sound narrowing: has() proved membership; EffortLevel is a literal
+                // subtype of string so the assertion is not a compensating cast.
+                mapping.effort = raw.effort;
+            }
+            else {
+                warn(`agent-models: dropping invalid effort "${raw.effort}" for agent "${name}"`);
+            }
+        }
+        agents[name] = mapping;
+    }
+    // Apply key migration: old keys (e.g. 'coder', 'reviewer') are transparently renamed
+    // on every read, covering all four call sites (agents.ts --set, proxy.ts, init.ts × 2).
+    // Generic T=AgentMapping is inferred — no compensating cast needed.
+    const { agents: migratedAgents } = canonicaliseAgentKeys(agents, warn);
+    return Ok({ version: 1, agents: migratedAgents });
+}
+// ---------------------------------------------------------------------------
+// readInstalledAgentNames
+// ---------------------------------------------------------------------------
+/**
+ * Return the set of agent names currently installed in `installDir`.
+ *
+ * Uses a single fs.readdir call — O(dir) not O(agents) — replacing the
+ * previous per-name fs.access loop (T8 assertion: exactly ONE readdir,
+ * ZERO fs.access calls).
+ *
+ * A missing directory returns an empty set rather than throwing (ENOENT is
+ * not an error — the install dir may not exist on a fresh machine before
+ * `devflow init` runs). Any other OS error also returns an empty set
+ * (degrade-not-throw per PF-009) — a transient or misconfigured path must
+ * not prevent the TUI or --list from starting.
+ *
+ * @param installDir - Path to ~/.claude/agents/devflow (or equivalent).
+ */
+export async function readInstalledAgentNames(installDir) {
+    try {
+        const entries = await fs.readdir(installDir);
+        return new Set(entries
+            .map(mdEntryName)
+            .filter((n) => n !== null));
+    }
+    catch {
+        return new Set();
+    }
+}
+// ---------------------------------------------------------------------------
+// saveAgentMapping
+// ---------------------------------------------------------------------------
+/**
+ * Atomically write the agent mapping to ~/.devflow/agent-models.json.
+ * Creates the directory if needed.
+ */
+export async function saveAgentMapping(devflowDir, mapping) {
+    const filePath = path.join(devflowDir, 'agent-models.json');
+    try {
+        await fs.mkdir(devflowDir, { recursive: true });
+        await writeFileAtomicExclusive(filePath, JSON.stringify(mapping, null, 2) + '\n');
+        return Ok(undefined);
+    }
+    catch (err) {
+        return Err(`Failed to write agent-models.json: ${err.message}`);
+    }
+}
+/**
+ * Compute the effective model/effort for an agent, applying dormancy semantics.
+ *
+ * Dormancy rule (plan D5):
+ *   If the mapping entry's model is an external GPT model (classified via
+ *   isDormantExternalModel) AND proxyEnabled is false → the entry is DORMANT.
+ *   The shipped default model is used instead. The entry remains saved.
+ *
+ * Effort is ALWAYS applied regardless of proxy state.
+ *
+ * Pure function — no I/O.
+ *
+ * @param agentName - The agent's short name (e.g., 'code').
+ * @param mapping - The full mapping file.
+ * @param shippedDefaults - Map of agent name → shipped default model.
+ * @param proxyEnabled - Whether the Devflow proxy is currently active.
+ */
+export function resolveEffective(agentName, mapping, shippedDefaults, proxyEnabled) {
+    const entry = mapping.agents[agentName];
+    let model;
+    if (entry?.model !== undefined) {
+        // Dormant: external model configured but proxy is off → fall back to shipped default.
+        model = isDormantExternalModel(entry.model, proxyEnabled)
+            ? shippedDefaults[agentName]
+            : entry.model;
+    }
+    else {
+        // No mapping entry → use shipped default.
+        model = shippedDefaults[agentName];
+    }
+    const effort = entry?.effort;
+    return { model, effort };
+}
+// ---------------------------------------------------------------------------
+// loadShippedDefaults
+// ---------------------------------------------------------------------------
+/**
+ * Load shipped default models from the source agent files.
+ * Reads every file in agentsDir() and parses the frontmatter model field.
+ * Unknown or malformed files are silently skipped.
+ */
+export async function loadShippedDefaults() {
+    const sourceDir = agentsDir();
+    const defaults = {};
+    let entries;
+    try {
+        entries = await fs.readdir(sourceDir);
+    }
+    catch {
+        return defaults;
+    }
+    const pairs = await Promise.all(entries.map(async (file) => {
+        const agentName = mdEntryName(file);
+        if (agentName === null)
+            return null;
+        try {
+            const content = await fs.readFile(path.join(sourceDir, file), 'utf-8');
+            const result = readFrontmatterModel(content);
+            if (result.ok && result.value) {
+                return [agentName, result.value];
+            }
+        }
+        catch {
+            // Silently skip unreadable files
+        }
+        return null;
+    }));
+    for (const pair of pairs) {
+        if (pair !== null) {
+            defaults[pair[0]] = pair[1];
+        }
+    }
+    return defaults;
+}
+/**
+ * Idempotent convergence function: walk every installed agent file and
+ * rewrite frontmatter model/effort to match the effective mapping.
+ *
+ * - Reads shipped defaults LIVE from src/assets/agents/ sources.
+ * - Gets the agent name list from the registry (getAllAgentNames()) plus
+ *   any mapping entries for agents not in the registry.
+ * - Missing installed files → skip silently (recorded in skippedMissing).
+ * - Malformed frontmatter → warn and leave file untouched.
+ * - DOES NOT store previousModel anywhere (plan D4): computes from shipped defaults.
+ */
+export async function reapplyAgentMapping(opts) {
+    const warnings = [];
+    const warn = (msg) => {
+        warnings.push(msg);
+        opts.onWarning?.(msg);
+    };
+    const mappingResult = await readAgentMapping(opts.devflowDir, { onWarning: warn });
+    if (!mappingResult.ok) {
+        warn(`reapplyAgentMapping: failed to read mapping — ${mappingResult.error}`);
+        return { updated: [], unchanged: [], skippedMissing: [], invalidMapping: [], warnings };
+    }
+    const mapping = mappingResult.value;
+    const shippedDefaults = await loadShippedDefaults();
+    // Build the union of: all registered agent names + all names in the mapping
+    // (so agents not yet in the registry but configured are also processed).
+    const registryNames = new Set(getAllAgentNames());
+    const mappingNames = new Set(Object.keys(mapping.agents));
+    const allNames = new Set([...registryNames, ...mappingNames]);
+    // Stable iteration order — Set preserves insertion order, array fixes it for the map.
+    const allNamesList = [...allNames];
+    const perResults = await Promise.all(allNamesList.map(async (agentName) => {
+        const localWarnings = [];
+        // Emit to callback immediately for live feedback; collect for deterministic aggregation.
+        const localWarn = (msg) => {
+            localWarnings.push(msg);
+            opts.onWarning?.(msg);
+        };
+        const installPath = path.join(opts.installDir, mdFileName(agentName));
+        // Guard: reject mapping keys that would read/write outside the install directory.
+        // A corrupted or adversarial agent-models.json could contain path-traversal keys
+        // such as '../../etc/passwd'; this check prevents any filesystem access beyond
+        // opts.installDir. Per PF-009 (degrade-not-throw), this emits a warning and skips gracefully.
+        if (!isContainedIn(opts.installDir, mdFileName(agentName))) {
+            localWarn(`reapplyAgentMapping: agent name "${agentName}" resolves outside the install ` +
+                `directory — skipped (containment guard)`);
+            return { bucket: 'skipped', localWarnings };
+        }
+        let currentContent;
+        try {
+            currentContent = await fs.readFile(installPath, 'utf-8');
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'ENOENT') {
+                localWarn(`reapplyAgentMapping: cannot read ${agentName}.md — ${err.message}`);
+            }
+            return { bucket: 'skipped', localWarnings };
+        }
+        const effective = resolveEffective(agentName, mapping, shippedDefaults, opts.proxyEnabled);
+        if (effective.model === undefined) {
+            // No shipped default and no mapping → nothing to write
+            return { bucket: 'unchanged', localWarnings };
+        }
+        const rewriteResult = rewriteAgentFrontmatter(currentContent, {
+            model: effective.model,
+            effort: effective.effort ?? null,
+        });
+        if (!rewriteResult.ok) {
+            if (rewriteResult.error === 'invalid-model') {
+                // The invalid model came from agent-models.json (the mapping),
+                // not from the installed .md file. Name the real artifact so the user
+                // knows where to look; file under invalidMapping (not skippedMissing).
+                localWarn(`reapplyAgentMapping: invalid-model name in agent-models.json for "${agentName}" — skipping`);
+                return { bucket: 'invalid-mapping', localWarnings };
+            }
+            localWarn(`reapplyAgentMapping: malformed frontmatter in ${agentName}.md (${rewriteResult.error}) — skipping`);
+            return { bucket: 'skipped', localWarnings }; // treated as unprocessable
+        }
+        if (!rewriteResult.value.changed) {
+            return { bucket: 'unchanged', localWarnings };
+        }
+        try {
+            await writeFileAtomicExclusive(installPath, rewriteResult.value.content);
+            return { bucket: 'updated', localWarnings };
+        }
+        catch (err) {
+            localWarn(`reapplyAgentMapping: failed to write ${agentName}.md — ${err.message}`);
+            return { bucket: 'write-error', localWarnings };
+        }
+    }));
+    // Aggregate in allNamesList order — deterministic warning order and bucket assignment.
+    const updated = [];
+    const unchanged = [];
+    const skippedMissing = [];
+    const invalidMapping = [];
+    for (let i = 0; i < allNamesList.length; i++) {
+        const agentName = allNamesList[i];
+        const { bucket, localWarnings } = perResults[i];
+        warnings.push(...localWarnings);
+        switch (bucket) {
+            case 'updated':
+                updated.push(agentName);
+                break;
+            case 'unchanged':
+                unchanged.push(agentName);
+                break;
+            case 'skipped':
+                skippedMissing.push(agentName);
+                break;
+            case 'invalid-mapping':
+                invalidMapping.push(agentName);
+                break;
+            case 'write-error': break; // warning already emitted; no bucket (original semantics)
+        }
+    }
+    return { updated, unchanged, skippedMissing, invalidMapping, warnings };
+}
+/**
+ * Revert all installed agent files to their shipped default models.
+ * Equivalent to reapplyAgentMapping({proxyEnabled: false}).
+ *
+ * Used by: proxy --disable, uninstall pre-cleanup.
+ */
+export async function revertExternalAgents(opts) {
+    return reapplyAgentMapping({
+        installDir: opts.installDir,
+        devflowDir: opts.devflowDir,
+        proxyEnabled: false,
+        onWarning: opts.onWarning,
+    });
+}
+// ---------------------------------------------------------------------------
+// countExternalMappedAgents
+// ---------------------------------------------------------------------------
+/**
+ * Count the number of mapping entries whose model requires the Devflow proxy
+ * (i.e., is not a Claude model name and not 'default').
+ *
+ * Uses the complement predicate (isClaudeModelName — isDormantExternalModel's
+ * building block) so that alias-shaped names are correctly counted as
+ * external — preventing "External-mapped agents: none" when a user has
+ * pinned every agent to a non-Claude alias (avoids AC-C6 live-correctness
+ * bug where discovery-driven counting would miss such entries).
+ *
+ * Used by: proxy --status display.
+ * Pure function — no I/O.
+ */
+export function countExternalMappedAgents(mapping) {
+    let count = 0;
+    for (const entry of Object.values(mapping.agents)) {
+        if (isDormantExternalModel(entry.model, false)) {
+            count++;
+        }
+    }
+    return count;
+}
+//# sourceMappingURL=agent-models.js.map

package/dist/core/agent-state.js

@@ -0,0 +1,44 @@
+/**
+ * Agent installation-state classification.
+ *
+ * Single source of truth for the STATE column shared by `--list` and the TUI.
+ * Centralised here (core layer) per ADR-013 so neither cli/commands nor
+ * cli/agents-view owns the vocabulary.
+ *
+ * applies ADR-013: pure core-layer module, no CLI-adapter concerns.
+ */
+import { isDormantExternalModel } from './external-models.js';
+// ---------------------------------------------------------------------------
+// AGENT_STATE_LABELS
+// ---------------------------------------------------------------------------
+/**
+ * Display labels for each {@link AgentState}, shared by `--list` and the TUI
+ * so the two surfaces cannot drift from each other.
+ *
+ * Apply colour at each call site; this map holds bare text only.
+ */
+export const AGENT_STATE_LABELS = {
+    'active': 'active',
+    'saved-inactive': 'saved-inactive',
+    'not-installed': 'not installed',
+    'unknown': 'unknown',
+};
+/**
+ * Classify an agent row's install state.
+ *
+ * Single source of truth shared by `--list` and the TUI so the two surfaces
+ * cannot drift. The four-way result drives the STATE column in render.ts and
+ * the STATE column in --list output.
+ *
+ * Pure function, no I/O.
+ */
+export function classifyAgentState({ configured, proxyEnabled, installed, inRegistry, }) {
+    if (!inRegistry)
+        return 'unknown';
+    if (!installed)
+        return 'not-installed';
+    if (isDormantExternalModel(configured, proxyEnabled))
+        return 'saved-inactive';
+    return 'active';
+}
+//# sourceMappingURL=agent-state.js.map

package/dist/core/assets.js

@@ -0,0 +1,39 @@
+import { join } from 'path';
+import { getPackageRoot } from './paths.js';
+/**
+ * Flat skills source directory: src/assets/skills/{name}/
+ * All plugins' skills live here directly (no per-plugin subdirectory).
+ */
+export function skillsDir() {
+    return join(getPackageRoot(), 'src', 'assets', 'skills');
+}
+/**
+ * Flat agents source directory: src/assets/agents/{name}.md
+ * All plugins' agents live here directly.
+ */
+export function agentsDir() {
+    return join(getPackageRoot(), 'src', 'assets', 'agents');
+}
+/**
+ * Flat rules source directory: src/assets/rules/{name}.md
+ * All plugins' rules live here directly (no per-plugin subdirectory).
+ */
+export function rulesDir() {
+    return join(getPackageRoot(), 'src', 'assets', 'rules');
+}
+/**
+ * Scripts source directory: src/assets/scripts/
+ * Contains hooks/ and hud.sh shipped with devflow.
+ */
+export function scriptsDir() {
+    return join(getPackageRoot(), 'src', 'assets', 'scripts');
+}
+/**
+ * Compiled commands directory: dist/commands/
+ * Single lookup directory for installed commands — .mds compile output
+ * plus verbatim hand-authored .md copies.
+ */
+export function commandsDir() {
+    return join(getPackageRoot(), 'dist', 'commands');
+}
+//# sourceMappingURL=assets.js.map