devflow-kit 1.8.2 → 2.0.0

package/dist/core/plugins.js

@@ -0,0 +1,525 @@
+/**
+ * Shared plugin registry — single source of truth for all CLI commands.
+ */
+/**
+ * Namespace prefix for Devflow skills installed to ~/.claude/skills/.
+ * Skills are installed as `devflow:{skill-name}` to avoid collisions with
+ * other plugin ecosystems. Source dirs in src/assets/skills/ stay unprefixed.
+ */
+export const SKILL_NAMESPACE = 'devflow:';
+/**
+ * Add the `devflow:` namespace prefix to a bare skill name.
+ * No-op if already prefixed.
+ */
+export function prefixSkillName(name) {
+    return name.startsWith(SKILL_NAMESPACE) ? name : `${SKILL_NAMESPACE}${name}`;
+}
+/**
+ * Strip the `devflow:` namespace prefix from a skill name.
+ * No-op if not prefixed.
+ */
+export function unprefixSkillName(name) {
+    return name.startsWith(SKILL_NAMESPACE) ? name.slice(SKILL_NAMESPACE.length) : name;
+}
+/**
+ * Available Devflow plugins
+ */
+export const DEVFLOW_PLUGINS = [
+    {
+        name: 'devflow-core-skills',
+        description: 'Auto-activating quality enforcement skills - foundation layer for all Devflow plugins',
+        commands: [],
+        agents: ['learning'],
+        skills: ['apply-decisions', 'apply-feature-knowledge', 'software-design', 'docs-framework', 'git', 'boundary-validation', 'test-driven-development', 'testing', 'dependency-research'],
+        rules: ['security', 'engineering', 'quality', 'reliability'],
+    },
+    {
+        name: 'devflow-plan',
+        description: 'Unified design planning with gap analysis and design review',
+        commands: ['/plan'],
+        agents: ['git', 'skim', 'synthesize', 'design'],
+        skills: ['gap-analysis', 'design-review', 'patterns', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
+        rules: [],
+    },
+    {
+        name: 'devflow-implement',
+        description: 'Complete task implementation workflow - accepts plan documents, issues, or task descriptions',
+        commands: ['/implement'],
+        agents: ['git', 'code', 'simplify', 'scrutinize', 'evaluate', 'test', 'validate', 'knowledge'],
+        skills: ['patterns', 'qa', 'quality-gates', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
+        rules: [],
+    },
+    {
+        name: 'devflow-code-review',
+        description: 'Comprehensive code review with parallel specialized agents',
+        commands: ['/code-review'],
+        agents: ['git', 'review', 'synthesize'],
+        skills: ['architecture', 'complexity', 'consistency', 'database', 'dependencies', 'documentation', 'performance', 'regression', 'reliability', 'review-methodology', 'security', 'testing', 'worktree-support', 'apply-feature-knowledge'],
+        rules: [],
+    },
+    {
+        name: 'devflow-resolve',
+        description: 'Process and fix code review issues with blast-radius triage, Code agent fixes, and Validate agent verification',
+        commands: ['/resolve'],
+        agents: ['git', 'triage', 'code', 'simplify', 'validate', 'knowledge'],
+        skills: ['patterns', 'security', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge', 'apply-decisions'],
+        rules: [],
+    },
+    {
+        name: 'devflow-debug',
+        description: 'Debugging workflows with competing hypothesis investigation via parallel subagents',
+        commands: ['/debug'],
+        agents: ['git', 'synthesize', 'simplify', 'knowledge'],
+        skills: ['git', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
+        rules: [],
+    },
+    {
+        name: 'devflow-explore',
+        description: 'Codebase exploration with structured analysis and optional knowledge base creation',
+        commands: ['/explore'],
+        agents: ['skim', 'synthesize', 'knowledge'],
+        skills: ['worktree-support', 'apply-feature-knowledge', 'feature-knowledge'],
+        rules: [],
+    },
+    {
+        name: 'devflow-research',
+        description: 'Multi-type research with parallel Research agents and trust-aware synthesis',
+        commands: ['/research'],
+        agents: ['research', 'skim', 'synthesize', 'knowledge'],
+        skills: ['worktree-support', 'apply-feature-knowledge', 'feature-knowledge', 'research-codebase', 'research-external', 'research-market', 'research-competitor', 'research-technology'],
+        rules: [],
+    },
+    {
+        name: 'devflow-release',
+        description: 'Adaptive project release with learned configuration',
+        commands: ['/release'],
+        agents: ['git', 'validate'],
+        skills: ['git', 'worktree-support'],
+        rules: [],
+    },
+    {
+        name: 'devflow-self-review',
+        description: 'Self-review workflow: Simplify agent + Scrutinize agent for code quality',
+        commands: ['/self-review'],
+        agents: ['simplify', 'scrutinize', 'validate', 'knowledge'],
+        skills: ['quality-gates', 'software-design', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
+        rules: [],
+    },
+    {
+        name: 'devflow-bug-analysis',
+        description: 'Proactive bug finding with static and semantic analysis',
+        commands: ['/bug-analysis'],
+        agents: ['git', 'diagnose', 'synthesize'],
+        skills: [
+            'apply-decisions',
+            'apply-feature-knowledge',
+            'complexity',
+            'consistency',
+            'regression',
+            'reliability',
+            'security',
+            'worktree-support',
+        ],
+        rules: [],
+    },
+    {
+        name: 'devflow-ambient',
+        description: 'Orchestrator ambient mode — session charter, per-prompt reminder, plan handoff',
+        commands: [],
+        agents: ['code', 'validate', 'simplify', 'scrutinize', 'evaluate', 'test', 'skim', 'review', 'git', 'synthesize', 'triage', 'design', 'knowledge', 'research', 'learning'],
+        skills: [
+            'review-methodology',
+            'security',
+            'architecture',
+            'performance',
+            'complexity',
+            'consistency',
+            'reliability',
+            'regression',
+            'testing',
+            'database',
+            'dependencies',
+            'documentation',
+            'patterns',
+            'qa',
+            'worktree-support',
+            'gap-analysis',
+            'design-review',
+            'feature-knowledge',
+            'apply-feature-knowledge',
+        ],
+        rules: [],
+    },
+    {
+        name: 'devflow-dynamic',
+        description: 'Dynamic workflow recipes - dependency-aware tickets→plan→build delivery pipeline',
+        // Commands compiled from commands/*.mds at build time (build:mds).
+        commands: ['/dynamic-tickets', '/dynamic-plan', '/dynamic-build', '/dynamic-profile'],
+        agents: ['code', 'validate', 'simplify', 'scrutinize', 'evaluate', 'test', 'review', 'git', 'synthesize', 'knowledge', 'design'],
+        skills: ['apply-decisions', 'apply-feature-knowledge', 'worktree-support', 'docs-framework'],
+        optional: true,
+        rules: [],
+    },
+    {
+        name: 'devflow-typescript',
+        description: 'TypeScript language patterns - type safety, generics, utility types, type guards',
+        commands: [],
+        agents: [],
+        skills: ['typescript'],
+        optional: true,
+        rules: ['typescript'],
+    },
+    {
+        name: 'devflow-react',
+        description: 'React framework patterns - hooks, state management, composition, performance',
+        commands: [],
+        agents: [],
+        skills: ['react'],
+        optional: true,
+        rules: ['react'],
+    },
+    {
+        name: 'devflow-accessibility',
+        description: 'Web accessibility patterns - WCAG compliance, ARIA roles, keyboard navigation, focus management',
+        commands: [],
+        agents: [],
+        skills: ['accessibility'],
+        optional: true,
+        rules: ['accessibility'],
+    },
+    {
+        name: 'devflow-ui-design',
+        description: 'UI design patterns - typography, color systems, spacing, motion, responsive design',
+        commands: [],
+        agents: [],
+        skills: ['ui-design'],
+        optional: true,
+        rules: ['ui-design'],
+    },
+    {
+        name: 'devflow-go',
+        description: 'Go language patterns - error handling, interfaces, concurrency, package design',
+        commands: [],
+        agents: [],
+        skills: ['go'],
+        optional: true,
+        rules: ['go'],
+    },
+    {
+        name: 'devflow-java',
+        description: 'Java language patterns - records, sealed classes, composition, modern Java features',
+        commands: [],
+        agents: [],
+        skills: ['java'],
+        optional: true,
+        rules: ['java'],
+    },
+    {
+        name: 'devflow-python',
+        description: 'Python language patterns - type hints, protocols, dataclasses, async programming',
+        commands: [],
+        agents: [],
+        skills: ['python'],
+        optional: true,
+        rules: ['python'],
+    },
+    {
+        name: 'devflow-rust',
+        description: 'Rust language patterns - ownership, borrowing, error handling, type-driven design',
+        commands: [],
+        agents: [],
+        skills: ['rust'],
+        optional: true,
+        rules: ['rust'],
+    },
+];
+/**
+ * Deprecated plugin names from old installations.
+ * Maps old name → new name for migration during init.
+ */
+export const LEGACY_PLUGIN_NAMES = {
+    'devflow-frontend-design': 'devflow-ui-design',
+    'devflow-specify': 'devflow-plan',
+};
+/**
+ * Plugin names that have been deleted from the registry.
+ * Used during init to prune stale entries from users' manifests on partial
+ * reinstalls — the full-reinstall path writes installedPluginNames directly
+ * and cannot carry a deleted name. Entries can be removed after 2 major versions.
+ */
+export const DELETED_PLUGIN_NAMES = [
+    'devflow-audit-claude',
+    'devflow-compliance', // D-B2: converted to built-in feature (devflow compliance); skill/rule assets stay in src/assets/ under feature system management
+];
+/**
+ * Skills owned by the feature system — not any plugin in DEVFLOW_PLUGINS.
+ * These assets live in src/assets/skills/ and are managed by convergeComplianceArtifacts
+ * (compliance-install.ts) rather than the plugin registry or installViaFileCopy loop.
+ *
+ * Used by:
+ *   - uninstall.ts: union into prefixedSkillNames for full-uninstall and enumerateDryRunExtras
+ *   - uninstall.ts sweepDevflowNamespaces: union into knownNames to spare devflow:compliance
+ *     from the post-selective-uninstall sweep (nothing converges after selective uninstall)
+ *   - skills.ts: union into allSkills for shadow/unshadow/list
+ *   - tests: independent literal ['compliance'] (avoids EXCLUDED-as-oracle trap, PF-018)
+ *
+ * D-FO-1: FEATURE_OWNED_SKILLS must be disjoint from getAllSkillNames()
+ * (guarded by plugins.test.ts FEATURE_OWNED constants describe block).
+ */
+export const FEATURE_OWNED_SKILLS = ['compliance'];
+/**
+ * Rules owned by the feature system — not any plugin in DEVFLOW_PLUGINS.
+ * The compliance rule (src/assets/rules/compliance.md) is stamped and installed
+ * by convergeComplianceArtifacts, not by the plugin installer.
+ *
+ * Used by:
+ *   - rules.ts: union into allRules for shadow/unshadow/list
+ *   - tests: independent literal ['compliance'] (avoids EXCLUDED-as-oracle trap, PF-018)
+ *
+ * D-FO-2: FEATURE_OWNED_RULES must be disjoint from getAllRuleNames()
+ * (guarded by plugins.test.ts FEATURE_OWNED constants describe block).
+ */
+export const FEATURE_OWNED_RULES = ['compliance'];
+// ── Feature redirect ──────────────────────────────────────────────────────────
+/**
+ * Plugin names (and aliases) that have been converted to built-in features.
+ * These names are no longer valid plugin selections; the corresponding feature
+ * is now managed via `devflow compliance` (or similar) instead.
+ */
+const FEATURE_REDIRECTED_NAMES = new Set([
+    'devflow-compliance', // B2: converted to built-in feature; manage via `devflow compliance`
+    'compliance', // shorthand alias users may type
+]);
+/**
+ * Resolve feature redirects from a requested plugin list.
+ *
+ * Identifies retired plugin names (converted to built-in features), strips them
+ * from the list, and returns the remaining plugins along with a notice when any
+ * were found. Callers should:
+ *   1. Print `notice` when present.
+ *   2. Continue with `remaining` (pass to parsePluginSelection).
+ *   3. Exit only when `remaining` is empty (nothing else to install/uninstall).
+ *
+ * This prevents a mixed --plugin list like `devflow-implement,devflow-compliance`
+ * from silently no-oping: the compliance redirect fires, the notice is emitted,
+ * and devflow-implement is still installed/uninstalled correctly.
+ */
+export function resolveFeatureRedirect(requested) {
+    const redirected = [];
+    const remaining = [];
+    for (const name of requested) {
+        if (FEATURE_REDIRECTED_NAMES.has(name)) {
+            redirected.push(name);
+        }
+        else {
+            remaining.push(name);
+        }
+    }
+    const notice = redirected.length > 0
+        ? 'compliance is now a built-in feature — manage it with `devflow compliance`'
+        : undefined;
+    return { redirected, remaining, notice };
+}
+/**
+ * Parse a comma-separated plugin selection string into normalized plugin names.
+ * Validates against known plugins; returns invalid names as errors.
+ *
+ * D-MOVE: moved from src/cli/commands/init.ts so uninstall can share it
+ * without creating a command→command import cycle.
+ */
+export function parsePluginSelection(input, validPlugins) {
+    const selected = input.split(',').map(raw => {
+        const trimmed = raw.trim();
+        const normalized = trimmed.startsWith('devflow-') ? trimmed : `devflow-${trimmed}`;
+        return LEGACY_PLUGIN_NAMES[normalized] ?? normalized;
+    });
+    const validNames = validPlugins.map(pl => pl.name);
+    const invalid = selected.filter(name => !validNames.includes(name));
+    return { selected, invalid };
+}
+/**
+ * Deprecated command names from old installations.
+ * Used during init to clean up stale command files on upgrade.
+ */
+export const LEGACY_COMMAND_NAMES = [
+    'review',
+    'specify',
+    'specify-teams',
+];
+/**
+ * Derive unique command names (without leading /) from all plugins.
+ * Returns one entry per distinct command, preserving DEVFLOW_PLUGINS declaration order.
+ */
+export function getAllCommandNames() {
+    const commands = new Set();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const cmd of plugin.commands) {
+            commands.add(cmd.startsWith('/') ? cmd.slice(1) : cmd);
+        }
+    }
+    return [...commands];
+}
+/**
+ * Derive unique skill names from all plugins.
+ */
+export function getAllSkillNames() {
+    const skills = new Set();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const skill of plugin.skills) {
+            skills.add(skill);
+        }
+    }
+    return [...skills];
+}
+/**
+ * Derive unique agent names from all plugins.
+ */
+export function getAllAgentNames() {
+    const agents = new Set();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const agent of plugin.agents) {
+            agents.add(agent);
+        }
+    }
+    return [...agents];
+}
+/**
+ * Build maps of unique assets to their source plugin (first plugin that declares them).
+ * This ensures each skill/agent is copied only once during installation.
+ */
+export function buildAssetMaps(plugins) {
+    const skillsMap = new Map();
+    const agentsMap = new Map();
+    for (const plugin of plugins) {
+        for (const skill of plugin.skills) {
+            if (!skillsMap.has(skill)) {
+                skillsMap.set(skill, plugin.name);
+            }
+        }
+        for (const agent of plugin.agents) {
+            if (!agentsMap.has(agent)) {
+                agentsMap.set(agent, plugin.name);
+            }
+        }
+    }
+    return { skillsMap, agentsMap };
+}
+/**
+ * Build a skills map from ALL plugins (regardless of selection).
+ * Skills are tiny markdown files — always install all of them so commands
+ * (review, resolve) can spawn agents that depend on skills from other plugins.
+ */
+export function buildFullSkillsMap() {
+    const skillsMap = new Map();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const skill of plugin.skills) {
+            if (!skillsMap.has(skill)) {
+                skillsMap.set(skill, plugin.name);
+            }
+        }
+    }
+    return skillsMap;
+}
+/**
+ * Derive unique rule names from all plugins.
+ */
+export function getAllRuleNames() {
+    const rules = new Set();
+    for (const plugin of DEVFLOW_PLUGINS) {
+        for (const rule of plugin.rules) {
+            rules.add(rule);
+        }
+    }
+    return [...rules].sort();
+}
+/**
+ * Rule names must be lowercase letters, digits, and hyphens only.
+ * Defense-in-depth: prevents path traversal if names ever come from
+ * non-static sources (e.g., manifest reads or user overrides).
+ */
+export function isValidRuleName(name) {
+    return /^[a-z0-9-]+$/.test(name);
+}
+/**
+ * Build a map of rule name → owner plugin for SELECTED plugins only.
+ * Rules are plugin-scoped (unlike skills which install from all plugins).
+ * First plugin to declare a rule wins.
+ * Throws if any rule name fails the isValidRuleName check — catches
+ * misconfigured `DEVFLOW_PLUGINS` rules entries at map-build time rather than at
+ * path-construction time.
+ */
+export function buildRulesMap(plugins) {
+    const rulesMap = new Map();
+    for (const plugin of plugins) {
+        for (const rule of plugin.rules) {
+            if (!isValidRuleName(rule)) {
+                throw new Error(`Invalid rule name "${rule}" in plugin "${plugin.name}": must match /^[a-z0-9-]+$/`);
+            }
+            if (!rulesMap.has(rule)) {
+                rulesMap.set(rule, plugin.name);
+            }
+        }
+    }
+    return rulesMap;
+}
+/**
+ * Deprecated rule names from old installations.
+ * Used during init to clean up stale rule files on upgrade.
+ *
+ * Pruning: entries can be removed after 2 major versions.
+ */
+export const LEGACY_RULE_NAMES = [];
+/**
+ * Canonical display order for workflow commands shown at end of init.
+ * Mirrors the user-facing pipeline: research → explore → plan → implement →
+ * code-review → resolve → self-review → bug-analysis → debug → release →
+ * dynamic pipeline (dynamic-tickets → dynamic-plan → dynamic-build → dynamic-profile).
+ * Export so init.ts can import it rather than keeping a local copy.
+ */
+export const WORKFLOW_ORDER = [
+    '/research', '/explore', '/plan', '/implement',
+    '/code-review', '/resolve', '/self-review', '/bug-analysis',
+    '/debug', '/release',
+    '/dynamic-tickets', '/dynamic-plan', '/dynamic-build', '/dynamic-profile',
+];
+/**
+ * Plugin names excluded from the init multiselect buckets.
+ * These are always installed regardless of user selection:
+ *   - devflow-core-skills  (always installed, non-optional)
+ *   - devflow-ambient      (always installed, non-optional)
+ *
+ * Invariant: EXCLUDED ∩ optional === ∅ — no optional plugin may be excluded from
+ * the init UI without a re-init carry mechanism to preserve it across full reinstalls.
+ * Guarded by the structural invariant test in tests/plugins.test.ts.
+ */
+export const EXCLUDED = new Set(['devflow-core-skills', 'devflow-ambient']);
+/**
+ * Partition the selectable plugins into workflow (command-bearing) and language
+ * (command-less, optional language/ecosystem) buckets for the two-step init UI.
+ *
+ * Excluded from both buckets (not selectable at init):
+ *   - devflow-core-skills  (always installed)
+ *   - devflow-ambient      (always installed)
+ *
+ * Pure function — does not mutate the input array; preserves DEVFLOW_PLUGINS
+ * ordering within each bucket; deterministic; no I/O.
+ */
+export function partitionSelectablePlugins(plugins) {
+    const workflow = [];
+    const language = [];
+    for (const plugin of plugins) {
+        if (EXCLUDED.has(plugin.name))
+            continue;
+        if (plugin.commands.length > 0) {
+            workflow.push(plugin);
+        }
+        else {
+            // "language" bucket: command-less selectable plugins — language/ecosystem
+            // plugins (typescript, go, etc.).
+            // If a command-less plugin needs a distinct install group, add a category field.
+            language.push(plugin);
+        }
+    }
+    return { workflow, language };
+}
+//# sourceMappingURL=plugins.js.map

package/dist/core/project-paths.js

@@ -0,0 +1,159 @@
+/**
+ * @file project-paths.ts
+ *
+ * Centralized path construction for all project-relative directories and files.
+ *
+ * DESIGN: Every function takes `projectRoot: string` (an absolute path to the
+ * git repository root or worktree root) and returns an absolute path string.
+ * All construction uses `path.join()` — no string concatenation.
+ *
+ * ARCHITECTURE: This module is the single source of truth for path layout.
+ *
+ * CJS COUNTERPART: src/assets/scripts/hooks/lib/project-paths.cjs must mirror this file
+ * exactly. Keep them in sync when adding or changing functions.
+ */
+import * as path from 'path';
+// ---------------------------------------------------------------------------
+// Core directories
+// ---------------------------------------------------------------------------
+/** .devflow/memory/ — working memory root */
+export function getMemoryDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'memory');
+}
+/** .devflow/learning/ — learning state root */
+export function getLearningDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning');
+}
+/** .devflow/features/ — per-feature knowledge bases */
+export function getFeaturesDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'features');
+}
+/** .devflow/docs/ — generated documentation artifacts */
+export function getDocsDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'docs');
+}
+// ---------------------------------------------------------------------------
+// Feature config (neutral .devflow root — not inside learning/)
+// ---------------------------------------------------------------------------
+/** .devflow/config.json — feature toggles {memory, learning, knowledge} */
+export function getFeatureConfigPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'config.json');
+}
+// ---------------------------------------------------------------------------
+// Learning queue files
+// ---------------------------------------------------------------------------
+/** .devflow/learning/.pending-turns.jsonl — decisions detection queue */
+export function getLearningPendingTurnsPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', '.pending-turns.jsonl');
+}
+/** .devflow/learning/.pending-turns.processing — atomic claim held by the Learning agent while processing */
+export function getLearningPendingTurnsProcessingPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', '.pending-turns.processing');
+}
+// ---------------------------------------------------------------------------
+// Learning content files
+// ---------------------------------------------------------------------------
+/** .devflow/learning/decisions.md */
+export function getDecisionsFilePath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'decisions.md');
+}
+/** .devflow/learning/pitfalls.md */
+export function getPitfallsFilePath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'pitfalls.md');
+}
+/** .devflow/learning/learning.json — project-level learning agent tuning config */
+export function getLearningTuningConfigPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'learning.json');
+}
+/** .devflow/learning/decisions-ledger.jsonl — anchored ledger rows (single source of truth for rendering) */
+export function getDecisionsLedgerPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'decisions-ledger.jsonl');
+}
+/** .devflow/learning/decisions-log.jsonl */
+export function getDecisionsLogPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'decisions-log.jsonl');
+}
+/** .devflow/learning/decisions-log.archive.jsonl — rotated-out stale observing rows (gitignored) */
+export function getDecisionsArchivePath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'decisions-log.archive.jsonl');
+}
+/** .devflow/learning/.decisions.lock — mkdir-based lock directory */
+export function getDecisionsLockDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', '.decisions.lock');
+}
+/** .devflow/learning/.decisions-usage.json */
+export function getDecisionsUsagePath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', '.decisions-usage.json');
+}
+/** .devflow/learning/.decisions-usage.lock/ — mkdir-based lock directory for usage file */
+export function getDecisionsUsageLockDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', '.decisions-usage.lock');
+}
+/** .devflow/learning/index.md — pre-rendered compact index written by render-decisions.cjs */
+export function getDecisionsIndexPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', 'index.md');
+}
+/** .devflow/learning/.observations.lock — mkdir-based lock directory for observation log writes */
+export function getObservationsLockDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'learning', '.observations.lock');
+}
+// ---------------------------------------------------------------------------
+// Memory / working-memory files
+// ---------------------------------------------------------------------------
+/** .devflow/memory/WORKING-MEMORY.md */
+export function getWorkingMemoryPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'memory', 'WORKING-MEMORY.md');
+}
+/** .devflow/memory/backup.json — pre-compact git state snapshot */
+export function getBackupPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'memory', 'backup.json');
+}
+/** .devflow/memory/.pending-turns.jsonl — queue of captured turns */
+export function getPendingTurnsPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'memory', '.pending-turns.jsonl');
+}
+/** .devflow/memory/.pending-turns.processing — atomic handoff during processing */
+export function getPendingTurnsProcessingPath(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'memory', '.pending-turns.processing');
+}
+/** .devflow/memory/.pending-turns.lock — mutex for queue operations */
+export function getPendingTurnsLockDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'memory', '.pending-turns.lock');
+}
+// ---------------------------------------------------------------------------
+// Docs files
+// ---------------------------------------------------------------------------
+/** .devflow/docs/reviews/ */
+export function getReviewsDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'docs', 'reviews');
+}
+/** .devflow/docs/design/ */
+export function getDesignDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'docs', 'design');
+}
+/** .devflow/docs/research/ */
+export function getResearchDir(projectRoot) {
+    return path.join(projectRoot, '.devflow', 'docs', 'research');
+}
+/** .devflow/docs/handoff-{branchSlug}.md — Code agent phase handoff artifact */
+export function getHandoffPath(projectRoot, branchSlug) {
+    return path.join(projectRoot, '.devflow', 'docs', `handoff-${branchSlug}.md`);
+}
+// ---------------------------------------------------------------------------
+// Gitignore entries (returned as string arrays for updateGitignore callers)
+// ---------------------------------------------------------------------------
+/**
+ * The canonical list of generic gitignore entries Devflow adds to a project's
+ * root .gitignore for LOCAL-scope installs. Currently just `.claude/`.
+ *
+ * `.devflow/` is intentionally NOT here: it is managed by ensureDevflowGitignore
+ * (TS) / ensure-root-gitignore (hook), which write the feature-knowledge carve-out
+ * for ALL scopes. Adding a bare `.devflow/` here would append a wholesale-ignore
+ * line after the carve-out and re-bury it (last match wins in .gitignore).
+ *
+ * CJS mirror: src/assets/scripts/hooks/lib/project-paths.cjs getGitignoreEntries().
+ */
+export function getGitignoreEntries() {
+    return ['.claude/'];
+}
+//# sourceMappingURL=project-paths.js.map