@lumenflow/core 2.9.0 → 2.11.0

package/dist/orchestration-rules.js

@@ -127,7 +127,7 @@ const AGENT_TRIGGER_DESCRIPTIONS = {
 // No mandatory agent triggers for LumenFlow framework development.
 // Example for application-specific triggers:
 // 'security-auditor': 'supabase/migrations/**, auth/**, rls/**',
-// 'beacon-guardian': 'prompts/**, llm/**',
+// 'llm-reviewer': 'prompts/**, llm/**',
 };
 /**
  * WU-1542: Build a formatted error message for mandatory agent enforcement failures.

package/dist/prompt-linter.js

@@ -17,14 +17,14 @@ import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { glob } from 'glob';
 import yaml from 'yaml';
-import { EXIT_CODES, STRING_LITERALS } from './wu-constants.js';
+import { EXIT_CODES, STRING_LITERALS, LUMENFLOW_PATHS } from './wu-constants.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const ROOT_DIR = resolve(__dirname, '../..');
 // Default config path
 const DEFAULT_CONFIG_PATH = resolve(ROOT_DIR, 'config/prompts/linter.yml');
-// Telemetry cache path (for storing previous metrics)
-const METRICS_CACHE_PATH = resolve(ROOT_DIR, '.lumenflow/telemetry/prompt-metrics.json');
+// Telemetry cache path (for storing previous metrics) - WU-1430: Use centralized constant
+const METRICS_CACHE_PATH = resolve(ROOT_DIR, LUMENFLOW_PATHS.PROMPT_METRICS);
 /**
  * Load config from YAML file with fallback to defaults
  * @param {string} configPath - Path to config file (optional)
@@ -139,8 +139,8 @@ async function log(level, event, data, output = {}) {
         event,
         ...data,
     };
-    // For CLI, write to .lumenflow/telemetry/prompt-lint.ndjson
-    const ndjsonPath = resolve(ROOT_DIR, '.lumenflow/telemetry/prompt-lint.ndjson');
+    // For CLI, write to telemetry prompt lint file - WU-1430: Use centralized constant
+    const ndjsonPath = resolve(ROOT_DIR, LUMENFLOW_PATHS.PROMPT_LINT);
     const line = `${JSON.stringify(entry)}${STRING_LITERALS.NEWLINE}`;
     try {
         const dir = dirname(ndjsonPath);

package/dist/spawn-escalation.d.ts

@@ -52,7 +52,7 @@ export declare const SuggestedAction: Readonly<{
  *
  * @param {string} spawnId - ID of the stuck spawn
  * @param {Object} options - Options
- * @param {string} options.baseDir - Base directory for .beacon/
+ * @param {string} options.baseDir - Base directory for .lumenflow/
  * @param {boolean} [options.dryRun=false] - If true, returns signal without sending
  * @returns {Promise<EscalationResult>} Escalation result with signal details
  *
@@ -66,7 +66,7 @@ export declare const SuggestedAction: Readonly<{
  * console.log(`Signal sent: ${result.signalId}, action: ${result.signal.suggested_action}`);
  */
 export interface EscalateStuckSpawnOptions {
-    /** Base directory for .beacon/ */
+    /** Base directory for .lumenflow/ */
     baseDir?: string;
     /** If true, return spec only without sending signal */
     dryRun?: boolean;

package/dist/spawn-escalation.js

@@ -23,6 +23,7 @@ import path from 'node:path';
 import { SpawnRegistryStore } from './spawn-registry-store.js';
 import { SpawnStatus } from './spawn-registry-schema.js';
 import { RECOVERY_DIR_NAME } from './spawn-recovery.js';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
 let createSignal = null;
 try {
     const mod = await import('@lumenflow/memory/signal');
@@ -91,7 +92,8 @@ export const SuggestedAction = Object.freeze({
  * @returns {Promise<number>} Number of previous escalation attempts
  */
 async function countEscalationAttempts(baseDir, spawnId) {
-    const recoveryDir = path.join(baseDir, '.beacon', RECOVERY_DIR_NAME);
+    // WU-1421: Use LUMENFLOW_PATHS.BASE for consistency
+    const recoveryDir = path.join(baseDir, LUMENFLOW_PATHS.BASE, RECOVERY_DIR_NAME);
     try {
         const files = await fs.readdir(recoveryDir);
         const spawnFiles = files.filter((f) => f.startsWith(`${spawnId}-`) && f.endsWith('.json'));
@@ -138,7 +140,8 @@ function determineEscalationLevel(attempts) {
  * @returns {Promise<AuditLogEntry|null>} Audit log entry or null if not found
  */
 async function findEscalationAuditLog(baseDir, spawnId) {
-    const recoveryDir = path.join(baseDir, '.beacon', RECOVERY_DIR_NAME);
+    // WU-1421: Use LUMENFLOW_PATHS.BASE for consistency
+    const recoveryDir = path.join(baseDir, LUMENFLOW_PATHS.BASE, RECOVERY_DIR_NAME);
     try {
         const files = await fs.readdir(recoveryDir);
         // Filter files for this spawn ID, sorted by name (timestamp-based)
@@ -188,7 +191,8 @@ function buildSpawnFailureSignal(spawn, auditLog, attempts) {
 }
 export async function escalateStuckSpawn(spawnId, options = {}) {
     const { baseDir = process.cwd(), dryRun = false } = options;
-    const registryDir = path.join(baseDir, '.beacon', 'state');
+    // WU-1421: Use LUMENFLOW_PATHS.STATE_DIR for consistency
+    const registryDir = path.join(baseDir, LUMENFLOW_PATHS.STATE_DIR);
     // Load spawn registry
     const store = new SpawnRegistryStore(registryDir);
     try {

package/dist/spawn-monitor.js

@@ -26,6 +26,7 @@ import { SpawnStatus } from './spawn-registry-schema.js';
 import { isZombieLock, readLockMetadata } from './lane-lock.js';
 import { recoverStuckSpawn, RecoveryAction } from './spawn-recovery.js';
 import { escalateStuckSpawn, SPAWN_FAILURE_SIGNAL_TYPE, SuggestedAction, } from './spawn-escalation.js';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
 let loadSignals = null;
 let markSignalsAsRead = null;
 try {
@@ -163,7 +164,8 @@ export function detectStuckSpawns(spawns, thresholdMinutes = DEFAULT_THRESHOLD_M
 }
 export async function checkZombieLocks(options = {}) {
     const { baseDir = process.cwd() } = options;
-    const locksDir = path.join(baseDir, '.beacon', 'locks');
+    // WU-1421: Use LUMENFLOW_PATHS.LOCKS_DIR (same as lane-lock.ts) for consistency
+    const locksDir = path.join(baseDir, LUMENFLOW_PATHS.LOCKS_DIR);
     const zombies = [];
     try {
         // Check if locks directory exists

package/dist/state-doctor-core.d.ts

@@ -1,10 +1,11 @@
 /**
- * State Doctor Core (WU-1209)
+ * State Doctor Core (WU-1209, WU-1420)
  *
  * Integrity checker for LumenFlow state that detects:
  * - Orphaned WUs (done status but no stamp)
  * - Dangling signals (reference non-existent WUs)
  * - Broken memory relationships (events for missing WU specs)
+ * - Status mismatches between WU YAML and state store (WU-1420)
  *
  * Inspired by Beads bd doctor command.
  *
@@ -27,6 +28,8 @@ export declare const ISSUE_TYPES: {
     readonly DANGLING_SIGNAL: "dangling_signal";
     /** Event references a WU that doesn't exist */
     readonly BROKEN_EVENT: "broken_event";
+    /** WU YAML status differs from state store derived status (WU-1420) */
+    readonly STATUS_MISMATCH: "status_mismatch";
 };
 /**
  * Issue severity levels
@@ -72,6 +75,25 @@ export interface MockEvent {
     wuId: string;
     type: string;
     timestamp?: string;
+    lane?: string;
+    title?: string;
+    reason?: string;
+}
+/**
+ * Event to emit for fixing status mismatches (WU-1420)
+ */
+export interface EmitEventPayload {
+    wuId: string;
+    type: 'release' | 'complete';
+    reason?: string;
+    timestamp?: string;
+}
+/**
+ * Status mismatch details for fixing (WU-1420)
+ */
+export interface StatusMismatchDetails {
+    yamlStatus: string;
+    derivedStatus: string;
 }
 /**
  * Dependencies for state doctor (injectable for testing)
@@ -91,6 +113,8 @@ export interface StateDoctorDeps {
     removeEvent?: (wuId: string) => Promise<void>;
     /** Create a stamp for a WU (for --fix) */
     createStamp?: (wuId: string, title: string) => Promise<void>;
+    /** Emit an event to fix status mismatch (WU-1420) */
+    emitEvent?: (event: EmitEventPayload) => Promise<void>;
 }
 /**
  * A detected issue in the state
@@ -110,6 +134,8 @@ export interface DiagnosisIssue {
     suggestion: string;
     /** Whether this issue can be auto-fixed */
     canAutoFix: boolean;
+    /** Status mismatch details for fixing (WU-1420) */
+    statusMismatch?: StatusMismatchDetails;
 }
 /**
  * A fix error that occurred during auto-repair
@@ -134,6 +160,8 @@ export interface DiagnosisSummary {
     danglingSignals: number;
     /** Number of broken events */
     brokenEvents: number;
+    /** Number of status mismatches (WU-1420) */
+    statusMismatches: number;
     /** Total number of issues */
     totalIssues: number;
 }

package/dist/state-doctor-core.js

@@ -1,10 +1,11 @@
 /**
- * State Doctor Core (WU-1209)
+ * State Doctor Core (WU-1209, WU-1420)
  *
  * Integrity checker for LumenFlow state that detects:
  * - Orphaned WUs (done status but no stamp)
  * - Dangling signals (reference non-existent WUs)
  * - Broken memory relationships (events for missing WU specs)
+ * - Status mismatches between WU YAML and state store (WU-1420)
  *
  * Inspired by Beads bd doctor command.
  *
@@ -27,6 +28,8 @@ export const ISSUE_TYPES = {
     DANGLING_SIGNAL: 'dangling_signal',
     /** Event references a WU that doesn't exist */
     BROKEN_EVENT: 'broken_event',
+    /** WU YAML status differs from state store derived status (WU-1420) */
+    STATUS_MISMATCH: 'status_mismatch',
 };
 /**
  * Issue severity levels
@@ -39,6 +42,86 @@ export const ISSUE_SEVERITY = {
     /** Informational findings */
     INFO: 'info',
 };
+/**
+ * Derive WU status from events (WU-1420)
+ *
+ * Replays events to determine the current derived status:
+ * - claim/create -> in_progress
+ * - release -> ready
+ * - complete -> done
+ * - block -> blocked
+ * - unblock -> in_progress
+ *
+ * @param events - All events for this WU
+ * @returns Derived status or undefined if no events
+ */
+function deriveStatusFromEvents(events) {
+    if (events.length === 0) {
+        return undefined;
+    }
+    let status = undefined;
+    for (const event of events) {
+        switch (event.type) {
+            case 'claim':
+            case 'create':
+                status = 'in_progress';
+                break;
+            case 'release':
+                status = 'ready';
+                break;
+            case 'complete':
+                status = 'done';
+                break;
+            case 'block':
+                status = 'blocked';
+                break;
+            case 'unblock':
+                status = 'in_progress';
+                break;
+            // checkpoint doesn't change status
+        }
+    }
+    return status;
+}
+/**
+ * Detect status mismatches between WU YAML and state store (WU-1420)
+ *
+ * Compares the status field in WU YAML against the derived status from events.
+ * Only reports issues for WUs that have events in the state store.
+ */
+function detectStatusMismatches(wus, events) {
+    const issues = [];
+    // Group events by WU ID
+    const eventsByWu = new Map();
+    for (const event of events) {
+        const existing = eventsByWu.get(event.wuId) || [];
+        existing.push(event);
+        eventsByWu.set(event.wuId, existing);
+    }
+    for (const wu of wus) {
+        const wuEvents = eventsByWu.get(wu.id);
+        if (!wuEvents || wuEvents.length === 0) {
+            // No events for this WU - nothing to compare
+            continue;
+        }
+        const derivedStatus = deriveStatusFromEvents(wuEvents);
+        if (derivedStatus && derivedStatus !== wu.status) {
+            issues.push({
+                type: ISSUE_TYPES.STATUS_MISMATCH,
+                severity: ISSUE_SEVERITY.WARNING,
+                wuId: wu.id,
+                description: `WU ${wu.id} YAML status is '${wu.status}' but state store says '${derivedStatus}'`,
+                suggestion: `Emit corrective event using: pnpm state:doctor --fix`,
+                canAutoFix: true,
+                statusMismatch: {
+                    yamlStatus: wu.status,
+                    derivedStatus,
+                },
+            });
+        }
+    }
+    return issues;
+}
 /**
  * Detect orphaned WUs (done status but no stamp)
  */
@@ -114,6 +197,7 @@ function calculateSummary(issues) {
     let orphanedWUs = 0;
     let danglingSignals = 0;
     let brokenEvents = 0;
+    let statusMismatches = 0;
     for (const issue of issues) {
         switch (issue.type) {
             case ISSUE_TYPES.ORPHANED_WU:
@@ -125,15 +209,42 @@ function calculateSummary(issues) {
             case ISSUE_TYPES.BROKEN_EVENT:
                 brokenEvents++;
                 break;
+            case ISSUE_TYPES.STATUS_MISMATCH:
+                statusMismatches++;
+                break;
         }
     }
     return {
         orphanedWUs,
         danglingSignals,
         brokenEvents,
+        statusMismatches,
         totalIssues: issues.length,
     };
 }
+/**
+ * Determine the corrective event type for a status mismatch (WU-1420)
+ *
+ * When YAML says X but state says Y, emit event to transition state to X:
+ * - YAML=ready, state=in_progress -> emit release
+ * - YAML=done, state=in_progress -> emit complete
+ * - YAML=in_progress, state=ready -> cannot fix (would need claim with lane/title)
+ * - YAML=in_progress, state=done -> cannot fix (cannot un-complete)
+ */
+function getCorrectiveEventType(yamlStatus, derivedStatus) {
+    // Transition from in_progress to ready: emit release
+    if (yamlStatus === 'ready' && derivedStatus === 'in_progress') {
+        return 'release';
+    }
+    // Transition from in_progress to done: emit complete
+    if (yamlStatus === 'done' && derivedStatus === 'in_progress') {
+        return 'complete';
+    }
+    // Other transitions are not auto-fixable by emitting events
+    // - ready -> in_progress would need claim (requires lane/title context)
+    // - done -> in_progress would need to revert complete (not supported)
+    return null;
+}
 /**
  * Attempt to fix an issue
  */
@@ -159,6 +270,29 @@ async function fixIssue(issue, deps, wus) {
                     return { fixed: true };
                 }
                 return { fixed: false, error: 'No createStamp function provided' };
+            case ISSUE_TYPES.STATUS_MISMATCH: {
+                if (!deps.emitEvent) {
+                    return { fixed: false, error: 'No emitEvent function provided' };
+                }
+                if (!issue.wuId || !issue.statusMismatch) {
+                    return { fixed: false, error: 'Missing WU ID or status mismatch details' };
+                }
+                const { yamlStatus, derivedStatus } = issue.statusMismatch;
+                const eventType = getCorrectiveEventType(yamlStatus, derivedStatus);
+                if (!eventType) {
+                    return {
+                        fixed: false,
+                        error: `Cannot auto-fix: transition from '${derivedStatus}' to '${yamlStatus}' requires manual intervention`,
+                    };
+                }
+                await deps.emitEvent({
+                    wuId: issue.wuId,
+                    type: eventType,
+                    reason: `state:doctor --fix: reconciling state store with YAML status '${yamlStatus}'`,
+                    timestamp: new Date().toISOString(),
+                });
+                return { fixed: true };
+            }
             default:
                 return { fixed: false, error: `Unknown issue type: ${issue.type}` };
         }
@@ -229,7 +363,13 @@ export async function diagnoseState(_baseDir, deps, options = {}) {
     const orphanedWUissues = detectOrphanedWUs(wus, stampIds);
     const danglingSignalIssues = detectDanglingSignals(signals, wuIds);
     const brokenEventIssues = detectBrokenEvents(events, wuIds);
-    const issues = [...orphanedWUissues, ...danglingSignalIssues, ...brokenEventIssues];
+    const statusMismatchIssues = detectStatusMismatches(wus, events);
+    const issues = [
+        ...orphanedWUissues,
+        ...danglingSignalIssues,
+        ...brokenEventIssues,
+        ...statusMismatchIssues,
+    ];
     const summary = calculateSummary(issues);
     // Initialize result
     const result = {

package/dist/telemetry.js

@@ -8,11 +8,11 @@
 import { appendFileSync, mkdirSync, existsSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import path from 'node:path';
-import { BEACON_PATHS, FILE_EXTENSIONS, STDIO, STRING_LITERALS, } from './wu-constants.js';
-const TELEMETRY_DIR = BEACON_PATHS.TELEMETRY;
+import { LUMENFLOW_PATHS, FILE_EXTENSIONS, STDIO, STRING_LITERALS, } from './wu-constants.js';
+const TELEMETRY_DIR = LUMENFLOW_PATHS.TELEMETRY;
 const GATES_LOG = `${TELEMETRY_DIR}/gates${FILE_EXTENSIONS.NDJSON}`;
 const LLM_CLASSIFICATION_LOG = `${TELEMETRY_DIR}/llm-classification${FILE_EXTENSIONS.NDJSON}`;
-const FLOW_LOG = BEACON_PATHS.FLOW_LOG;
+const FLOW_LOG = LUMENFLOW_PATHS.FLOW_LOG;
 /**
  * Ensure telemetry directory exists
  */

package/dist/template-loader.js

@@ -19,8 +19,10 @@ import { join } from 'node:path';
 import matter from 'gray-matter';
 import yaml from 'yaml';
 import { createError, ErrorCodes } from './error-handler.js';
-const MANIFEST_PATH = '.lumenflow/templates/manifest.yaml';
-const TEMPLATES_DIR = '.lumenflow/templates/spawn-prompt';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
+/** WU-1430: Use centralized constants for template paths */
+const MANIFEST_PATH = LUMENFLOW_PATHS.TEMPLATE_MANIFEST;
+const TEMPLATES_DIR = LUMENFLOW_PATHS.SPAWN_PROMPT_DIR;
 /**
  * Validate a template entry from the manifest.
  * @throws If entry is missing required fields
@@ -172,7 +174,8 @@ export function loadTemplate(templatePath) {
 export function loadTemplatesWithOverrides(baseDir, clientName) {
     const templates = new Map();
     const baseTemplatesDir = join(baseDir, TEMPLATES_DIR);
-    const clientTemplatesDir = join(baseDir, `.lumenflow/templates.${clientName}/spawn-prompt`);
+    // WU-1430: Construct client templates path from constants
+    const clientTemplatesDir = join(baseDir, `${LUMENFLOW_PATHS.BASE}/templates.${clientName}/spawn-prompt`);
     // Load base templates first
     if (existsSync(baseTemplatesDir)) {
         loadTemplatesFromDir(baseTemplatesDir, templates);

package/dist/test-baseline.d.ts

@@ -13,8 +13,8 @@
  * @see https://lumenflow.dev/reference/test-ratchet/
  */
 import { z } from 'zod';
-/** Default path for the test baseline file */
-export declare const DEFAULT_BASELINE_PATH = ".lumenflow/test-baseline.json";
+/** Default path for the test baseline file (WU-1430: Use centralized constant) */
+export declare const DEFAULT_BASELINE_PATH: string;
 /** Environment variable to override baseline path */
 export declare const BASELINE_PATH_ENV = "LUMENFLOW_TEST_BASELINE";
 /** Current schema version */

package/dist/test-baseline.js

@@ -14,11 +14,12 @@
  */
 import { z } from 'zod';
 import { parseISO, isValid } from 'date-fns';
+import { LUMENFLOW_PATHS } from './wu-constants.js';
 // ============================================================================
 // Constants
 // ============================================================================
-/** Default path for the test baseline file */
-export const DEFAULT_BASELINE_PATH = '.lumenflow/test-baseline.json';
+/** Default path for the test baseline file (WU-1430: Use centralized constant) */
+export const DEFAULT_BASELINE_PATH = LUMENFLOW_PATHS.TEST_BASELINE;
 /** Environment variable to override baseline path */
 export const BASELINE_PATH_ENV = 'LUMENFLOW_TEST_BASELINE';
 /** Current schema version */

package/dist/wu-constants.d.ts

@@ -1021,6 +1021,7 @@ export declare const DIRECTORIES: {
     WORKTREES: string;
     AI: string;
     CLAUDE: string;
+    CLAUDE_HOOKS: string;
     DOCS: string;
     PACKAGES: string;
     TOOLS: string;
@@ -1030,6 +1031,43 @@ export declare const DIRECTORIES: {
     BACKLOG_PATH: string;
     STATUS_PATH: string;
 };
+/**
+ * Claude Code hook script constants (WU-1394)
+ *
+ * Centralized constants for Claude Code enforcement and recovery hooks.
+ * Used by enforcement-generator.ts, enforcement-sync.ts, and init.ts.
+ *
+ * @see packages/@lumenflow/cli/src/hooks/enforcement-generator.ts
+ * @see packages/@lumenflow/cli/src/hooks/enforcement-sync.ts
+ */
+export declare const CLAUDE_HOOKS: {
+    /** Hook script filenames */
+    readonly SCRIPTS: {
+        readonly ENFORCE_WORKTREE: "enforce-worktree.sh";
+        readonly REQUIRE_WU: "require-wu.sh";
+        readonly WARN_INCOMPLETE: "warn-incomplete.sh";
+        readonly PRE_COMPACT_CHECKPOINT: "pre-compact-checkpoint.sh";
+        readonly SESSION_START_RECOVERY: "session-start-recovery.sh";
+    };
+    /** Hook command path prefix (uses Claude Code's $CLAUDE_PROJECT_DIR variable) */
+    readonly PATH_PREFIX: "$CLAUDE_PROJECT_DIR/.claude/hooks";
+    /** Hook matchers for settings.json */
+    readonly MATCHERS: {
+        readonly ALL: ".*";
+        readonly WRITE_EDIT: "Write|Edit";
+        readonly COMPACT: "compact";
+        readonly RESUME: "resume";
+        readonly CLEAR: "clear";
+    };
+    /** Template paths (relative to templates directory) */
+    readonly TEMPLATES: {
+        readonly SETTINGS: "vendors/claude/.claude/settings.json.template";
+        readonly PRE_COMPACT: "vendors/claude/.claude/hooks/pre-compact-checkpoint.sh";
+        readonly SESSION_START: "vendors/claude/.claude/hooks/session-start-recovery.sh";
+    };
+};
+/** Build full hook command path from script name */
+export declare const getHookCommand: (scriptName: string) => string;
 /**
  * ESLint cache strategy values
  */
@@ -1125,7 +1163,7 @@ export declare const GIT_COMMAND_STRINGS: {
 export declare const PATH_PATTERNS: {
     /** Matches WU YAML paths in both legacy and current locations */
     WU_YAML: RegExp;
-    /** Matches stamp file paths (supports both .beacon and .lumenflow for migration) */
+    /** Matches stamp file paths */
     STAMP: RegExp;
 };
 /**
@@ -1240,8 +1278,6 @@ export declare const LOCK_DIR_NAME = ".lumenflow-locks";
  *
  * Centralized paths for .lumenflow directory structure to eliminate hardcoded strings.
  * Used by telemetry, agent-session, agent-incidents, memory, and commands-logger modules.
- *
- * @since 1.4.0 Renamed from BEACON_PATHS (WU-1075)
  */
 export declare const LUMENFLOW_PATHS: {
     /** Base directory for all LumenFlow runtime data */
@@ -1250,6 +1286,8 @@ export declare const LUMENFLOW_PATHS: {
     STATE_DIR: string;
     /** Stamp directory (WU completion markers) */
     STAMPS_DIR: string;
+    /** Archive directory for old WU events (WU-1430) */
+    ARCHIVE_DIR: string;
     /** Merge lock file (runtime coordination, WU-1747) */
     MERGE_LOCK: string;
     /** Base telemetry directory */
@@ -1280,60 +1318,30 @@ export declare const LUMENFLOW_PATHS: {
     LOCKS_DIR: string;
     /** Force bypass audit log */
     FORCE_BYPASSES: string;
-    /**
-     * WU-1174: Runtime lock directory for merge/cleanup locks
-     *
-     * These locks are transient and should NOT be created in the main checkout
-     * because wu:done runs from main. Using os.tmpdir() ensures:
-     * 1. Locks don't pollute the git working tree
-     * 2. Locks work across processes on the same machine
-     * 3. No "Working tree is not clean" errors if process crashes
-     *
-     * Note: Lane locks still use LOCKS_DIR (.lumenflow/locks) because they need
-     * to persist across sessions and be visible to other agents.
-     */
-    LOCK_DIR: string;
-};
-/**
- * @deprecated Use LUMENFLOW_PATHS instead. Will be removed in v2.0.
- */
-export declare const BEACON_PATHS: {
-    /** Base directory for all LumenFlow runtime data */
-    BASE: string;
-    /** WU state store directory */
-    STATE_DIR: string;
-    /** Stamp directory (WU completion markers) */
-    STAMPS_DIR: string;
-    /** Merge lock file (runtime coordination, WU-1747) */
-    MERGE_LOCK: string;
-    /** Base telemetry directory */
-    TELEMETRY: string;
-    /** Flow log file (WU flow events) */
-    FLOW_LOG: string;
-    /** Agent sessions directory */
-    SESSIONS: string;
-    /** Agent incidents directory */
-    INCIDENTS: string;
-    /** Git commands log file */
-    COMMANDS_LOG: string;
-    /** Memory layer directory */
-    MEMORY_DIR: string;
-    /** Memory layer JSONL file */
-    MEMORY_JSONL: string;
-    /** Audit log for tool calls */
-    AUDIT_LOG: string;
-    /** Feedback drafts directory */
-    FEEDBACK_DRAFTS: string;
-    /** Feedback index file */
-    FEEDBACK_INDEX: string;
-    /** Current session file */
-    SESSION_CURRENT: string;
-    /** WU events log */
-    WU_EVENTS: string;
-    /** Lock files directory (lane locks - persisted) */
-    LOCKS_DIR: string;
-    /** Force bypass audit log */
-    FORCE_BYPASSES: string;
+    /** Test baseline file for ratchet pattern (WU-1430) */
+    TEST_BASELINE: string;
+    /** Templates directory (WU-1430) */
+    TEMPLATES_DIR: string;
+    /** Spawn prompt templates (WU-1430) */
+    SPAWN_PROMPT_DIR: string;
+    /** Template manifest file (WU-1430) */
+    TEMPLATE_MANIFEST: string;
+    /** Skills directory for agent skills (WU-1430) */
+    SKILLS_DIR: string;
+    /** Agents directory for agent definitions (WU-1430) */
+    AGENTS_DIR: string;
+    /** Methodology log for spawn telemetry (WU-1430) */
+    METHODOLOGY_LOG: string;
+    /** Prompt metrics cache (WU-1430) */
+    PROMPT_METRICS: string;
+    /** Prompt lint results (WU-1430) */
+    PROMPT_LINT: string;
+    /** Recovery markers directory (WU-1430) */
+    RECOVERY_DIR: string;
+    /** Checkpoints directory (WU-1430) */
+    CHECKPOINTS_DIR: string;
+    /** Cache directory under user home (WU-1430) */
+    HOME_CACHE: string;
     /**
      * WU-1174: Runtime lock directory for merge/cleanup locks
      *
@@ -1405,6 +1413,10 @@ export declare const PATH_LITERALS: {
     PLAN_FILE_SUFFIX: string;
     /** Trailing slash regex pattern */
     TRAILING_SLASH_REGEX: RegExp;
+    /** .lumenflow path prefix for internal path detection (WU-1430) */
+    LUMENFLOW_PREFIX: string;
+    /** Current directory prefix for repo-internal paths (WU-1430) */
+    CURRENT_DIR_PREFIX: string;
 };
 /**
  * Slice lengths for path operations