@lumenflow/core 1.0.0

package/dist/prompt-linter.js

@@ -0,0 +1,312 @@
+/**
+ * Prompt Linter with 3-Tier Token Budget Enforcement
+ *
+ * Enforces token budget constraints on LLM prompts:
+ * - BLOCK: >450 tokens OR +>120 delta (exit 1)
+ * - WARN: ≥400 tokens OR +>50 delta (continue, log warning)
+ * - LOG: Always log tokenCount, delta, hash, top 3 longest lines
+ *
+ * Uses proper telemetry via getLogger() (no console spam).
+ *
+ * Part of WU-676: Single-Call LLM Orchestrator token budget enforcement.
+ */
+import { analyzePrompt, getLongestLines } from './token-counter.js';
+import { readFile, writeFile, mkdir, appendFile, access } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+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';
+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, '.beacon/telemetry/prompt-metrics.json');
+/**
+ * Load config from YAML file with fallback to defaults
+ * @param {string} configPath - Path to config file (optional)
+ * @returns {Object} Configuration object
+ */
+export function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+    // Default configuration (fallback if file missing or invalid)
+    const defaults = {
+        version: 1,
+        token_budgets: {
+            default: {
+                hard_cap: 450,
+                warn_threshold: 400,
+            },
+            retry: {
+                hard_cap: 150,
+            },
+        },
+        delta_budgets: {
+            warn: 50,
+            block: 120,
+        },
+        retry_pattern: 'retry',
+    };
+    try {
+        if (!existsSync(configPath)) {
+            // Config file not found, use defaults
+            return defaults;
+        }
+        const content = readFileSync(configPath, { encoding: 'utf-8' });
+        const parsed = yaml.parse(content);
+        // Merge parsed config with defaults (handles incomplete configs)
+        return {
+            version: parsed.version ?? defaults.version,
+            token_budgets: {
+                default: {
+                    hard_cap: parsed.token_budgets?.default?.hard_cap ?? defaults.token_budgets.default.hard_cap,
+                    warn_threshold: parsed.token_budgets?.default?.warn_threshold ??
+                        defaults.token_budgets.default.warn_threshold,
+                },
+                retry: {
+                    hard_cap: parsed.token_budgets?.retry?.hard_cap ?? defaults.token_budgets.retry.hard_cap,
+                },
+            },
+            delta_budgets: {
+                warn: parsed.delta_budgets?.warn ?? defaults.delta_budgets.warn,
+                block: parsed.delta_budgets?.block ?? defaults.delta_budgets.block,
+            },
+            retry_pattern: parsed.retry_pattern ?? defaults.retry_pattern,
+        };
+    }
+    catch (_error) {
+        // YAML parsing error or other failure, use defaults
+        console.error(`⚠️  Failed to load config from ${configPath}: ${_error.message}`);
+        console.error(`   Using default token budgets.`);
+        return defaults;
+    }
+}
+/**
+ * Load previous metrics from cache
+ * @returns {Promise<Object>} Previous metrics by file path
+ */
+async function loadPreviousMetrics() {
+    try {
+        const fileExists = await access(METRICS_CACHE_PATH)
+            .then(() => true)
+            .catch(() => false);
+        if (fileExists) {
+            const data = await readFile(METRICS_CACHE_PATH, { encoding: 'utf-8' });
+            return JSON.parse(data);
+        }
+    }
+    catch {
+        // Ignore errors, return empty metrics
+    }
+    return {};
+}
+/**
+ * Save current metrics to cache
+ * @param {Object} metrics - Metrics by file path
+ * @returns {Promise<void>}
+ */
+async function savemetrics(metrics) {
+    try {
+        const dir = dirname(METRICS_CACHE_PATH);
+        const dirExists = await access(dir)
+            .then(() => true)
+            .catch(() => false);
+        if (!dirExists) {
+            await mkdir(dir, { recursive: true });
+        }
+        await writeFile(METRICS_CACHE_PATH, JSON.stringify(metrics, null, 2));
+    }
+    catch {
+        // Ignore errors (cache is optional)
+    }
+}
+/**
+ * Log via proper telemetry (simulated getLogger for CLI context)
+ * In production, this would use apps/web/src/lib/logger.ts
+ * @param {string} level - Log level (info, warn, error)
+ * @param {string} event - Event name
+ * @param {Object} data - Structured data
+ * @param {LogOutputOptions} [output] - Output mode
+ * @returns {Promise<void>}
+ */
+async function log(level, event, data, output = {}) {
+    const timestamp = new Date().toISOString();
+    const entry = {
+        timestamp,
+        level,
+        event,
+        ...data,
+    };
+    // For CLI, write to .beacon/telemetry/prompt-lint.ndjson
+    const ndjsonPath = resolve(ROOT_DIR, '.beacon/telemetry/prompt-lint.ndjson');
+    const line = `${JSON.stringify(entry)}${STRING_LITERALS.NEWLINE}`;
+    try {
+        const dir = dirname(ndjsonPath);
+        const dirExists = await access(dir)
+            .then(() => true)
+            .catch(() => false);
+        if (!dirExists) {
+            await mkdir(dir, { recursive: true });
+        }
+        await appendFile(ndjsonPath, line);
+    }
+    catch {
+        // Fallback to stderr if file write fails
+        console.error(JSON.stringify(entry));
+    }
+    const shouldPrintToConsole = output.verbose ? true : output.quiet ? level !== 'info' : true;
+    // Also output human-readable to stderr
+    const levelEmoji = {
+        info: '📊',
+        warn: '⚠️ ',
+        error: '❌',
+    }[level] || '  ';
+    if (shouldPrintToConsole) {
+        const message = `${levelEmoji} [${event}] ${data.file || ''} ${data.tokenCount ? `${data.tokenCount} tokens` : ''}`;
+        console.error(message);
+        if (data.delta !== undefined) {
+            console.error(`   Delta: ${data.delta > 0 ? '+' : ''}${data.delta} tokens`);
+        }
+        if (data.message) {
+            console.error(`   ${data.message}`);
+        }
+    }
+}
+/**
+ * Lint a single prompt file
+ * @param {string} filePath - Absolute path to prompt file
+ * @param {Object} previousMetrics - Previous metrics for delta calculation
+ * @param {string} mode - Mode (pre-commit, pre-push, ci, local)
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {{quiet?: boolean, verbose?: boolean}} output - Output mode
+ * @returns {Promise<{passed: boolean, tokenCount: number, delta: number, hash: string}>}
+ */
+async function lintPromptFile(filePath, previousMetrics, mode, config, output) {
+    // Analyze prompt
+    const { tokenCount, hash, text } = analyzePrompt(filePath);
+    // Calculate delta from previous metrics
+    const previous = previousMetrics[filePath];
+    const delta = previous ? tokenCount - previous.tokenCount : 0;
+    // Determine cap based on file name and config pattern
+    const isRetryPrompt = filePath.includes(config.retry_pattern);
+    const cap = isRetryPrompt
+        ? config.token_budgets.retry.hard_cap
+        : config.token_budgets.default.hard_cap;
+    // Get top 3 longest lines for cleanup targeting
+    const longestLines = getLongestLines(text, 3);
+    // BLOCK: hard cap or sudden bloat
+    if (tokenCount > cap || delta > config.delta_budgets.block) {
+        await log('error', 'prompt.lint.blocked', {
+            file: filePath,
+            tokenCount,
+            delta,
+            hash,
+            cap,
+            mode,
+            message: `Exceeds ${cap} token cap or delta >${config.delta_budgets.block}`,
+            longestLines: longestLines.map((l) => `Line ${l.number}: ${l.length} chars`),
+        }, output);
+        return { passed: false, tokenCount, delta, hash };
+    }
+    // WARN: approaching cap or gradual creep
+    if (tokenCount >= config.token_budgets.default.warn_threshold ||
+        delta > config.delta_budgets.warn) {
+        await log('warn', 'prompt.lint.warning', {
+            file: filePath,
+            tokenCount,
+            delta,
+            hash,
+            threshold: config.token_budgets.default.warn_threshold,
+            mode,
+            message: 'Approaching token budget cap',
+            longestLines: longestLines.map((l) => `Line ${l.number}: ${l.length} chars`),
+        }, output);
+    }
+    // LOG: always log metrics
+    await log('info', 'prompt.lint.measured', {
+        file: filePath,
+        tokenCount,
+        delta,
+        hash,
+        mode,
+        longestLines: longestLines.map((l) => `Line ${l.number}: ${l.length} chars`),
+    }, output);
+    return { passed: true, tokenCount, delta, hash };
+}
+/**
+ * Main linter function
+ * @param {string[]} filePaths - Prompt files to lint (optional, finds all if empty)
+ * @param {string} mode - Mode (pre-commit, pre-push, ci, local)
+ * @param {string} configPath - Optional config file path
+ * @param {LintPromptsOptions} [options] - Output options
+ * @returns {Promise<{passed: boolean, results: Array, config: Object}>}
+ */
+export async function lintPrompts(filePaths = [], mode = 'local', configPath = undefined, options = {}) {
+    // Load configuration
+    const config = loadConfig(configPath);
+    const output = { quiet: options.quiet === true, verbose: options.verbose === true };
+    // If no files provided, find all orchestrator prompt files (WU-676 scope only)
+    if (filePaths.length === 0) {
+        const pattern = 'packages/@patientpath/prompts/orchestrator-*/**/*.yaml';
+        filePaths = await glob(pattern, { cwd: ROOT_DIR, absolute: true });
+    }
+    // Load previous metrics for delta calculation
+    const previousMetrics = await loadPreviousMetrics();
+    // Lint each file
+    const results = [];
+    let allPassed = true;
+    for (const filePath of filePaths) {
+        const result = await lintPromptFile(filePath, previousMetrics, mode, config, output);
+        results.push({ filePath, ...result });
+        if (!result.passed) {
+            allPassed = false;
+        }
+        // Update metrics cache
+        previousMetrics[filePath] = {
+            tokenCount: result.tokenCount,
+            hash: result.hash,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // Save updated metrics
+    await savemetrics(previousMetrics);
+    return { passed: allPassed, results, config };
+}
+/**
+ * CLI entry point
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const modeFlag = args.find((arg) => arg.startsWith('--mode='));
+    const mode = modeFlag ? modeFlag.split('=')[1] : 'local';
+    const quiet = args.includes('--quiet');
+    const verbose = args.includes('--verbose');
+    // Get files to lint (from args or find all)
+    const files = args.filter((arg) => !arg.startsWith('--'));
+    console.error(`\n🔍 Linting prompts (mode: ${mode})...\n`);
+    const { passed, results, config } = await lintPrompts(files, mode, undefined, { quiet, verbose });
+    // Summary
+    const total = results.length;
+    const blocked = results.filter((r) => !r.passed).length;
+    const warned = results.filter((r) => r.passed && r.tokenCount >= config.token_budgets.default.warn_threshold).length;
+    console.error(`\n📋 Summary: ${total} prompts analyzed`);
+    if (blocked > 0) {
+        console.error(`   ❌ ${blocked} BLOCKED (>${config.token_budgets.default.hard_cap} tokens or delta >${config.delta_budgets.block})`);
+    }
+    if (warned > 0) {
+        console.error(`   ⚠️  ${warned} WARNING (≥${config.token_budgets.default.warn_threshold} tokens or delta >${config.delta_budgets.warn})`);
+    }
+    if (blocked === 0 && warned === 0) {
+        console.error(`   ✅ All prompts within budget`);
+    }
+    process.exit(passed ? EXIT_CODES.SUCCESS : EXIT_CODES.ERROR);
+}
+// Run CLI if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error('Prompt linter failed:', error);
+        process.exit(EXIT_CODES.ERROR);
+    });
+}

package/dist/prompt-monitor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Nightly Prompt Monitor
+ *
+ * Monitors all prompts for token budget drift and hash changes.
+ * Designed to run as a GitHub Actions cron job (nightly at 2 AM).
+ *
+ * Logs to .beacon/telemetry/prompt-nightly.ndjson and Axiom.
+ * Alerts if:
+ * - Any prompt ≥400 tokens (approaching cap)
+ * - Any delta >50 tokens since yesterday
+ * - rules_hash changed outside a WU (unintentional drift)
+ *
+ * Part of WU-676: Single-Call LLM Orchestrator token budget enforcement.
+ */
+export {};

package/dist/prompt-monitor.js

@@ -0,0 +1,205 @@
+/**
+ * Nightly Prompt Monitor
+ *
+ * Monitors all prompts for token budget drift and hash changes.
+ * Designed to run as a GitHub Actions cron job (nightly at 2 AM).
+ *
+ * Logs to .beacon/telemetry/prompt-nightly.ndjson and Axiom.
+ * Alerts if:
+ * - Any prompt ≥400 tokens (approaching cap)
+ * - Any delta >50 tokens since yesterday
+ * - rules_hash changed outside a WU (unintentional drift)
+ *
+ * Part of WU-676: Single-Call LLM Orchestrator token budget enforcement.
+ */
+import { analyzePrompt } from './token-counter.js';
+import { readFile, writeFile, mkdir, appendFile, access } from 'node:fs/promises';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { glob } from 'glob';
+import { EXIT_CODES, STRING_LITERALS } from './wu-constants.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = resolve(__dirname, '../..');
+// Paths
+const YESTERDAY_METRICS_PATH = resolve(ROOT_DIR, '.beacon/telemetry/prompt-metrics-yesterday.json');
+const TODAY_METRICS_PATH = resolve(ROOT_DIR, '.beacon/telemetry/prompt-metrics.json');
+const NDJSON_LOG_PATH = resolve(ROOT_DIR, '.beacon/telemetry/prompt-nightly.ndjson');
+// Alert thresholds
+const WARN_THRESHOLD = 400;
+const DELTA_THRESHOLD = 50;
+/**
+ * Load yesterday's metrics
+ */
+async function loadYesterdayMetrics() {
+    try {
+        const exists = await access(YESTERDAY_METRICS_PATH)
+            .then(() => true)
+            .catch(() => false);
+        if (exists) {
+            const data = await readFile(YESTERDAY_METRICS_PATH, { encoding: 'utf-8' });
+            return JSON.parse(data);
+        }
+    }
+    catch (error) {
+        console.error('Failed to load yesterday metrics:', error);
+    }
+    return {};
+}
+/**
+ * Save today's metrics
+ */
+async function saveMetrics(metrics) {
+    try {
+        const dir = dirname(TODAY_METRICS_PATH);
+        const dirExists = await access(dir)
+            .then(() => true)
+            .catch(() => false);
+        if (!dirExists) {
+            await mkdir(dir, { recursive: true });
+        }
+        await writeFile(TODAY_METRICS_PATH, JSON.stringify(metrics, null, 2));
+    }
+    catch (error) {
+        console.error('Failed to save metrics:', error);
+    }
+}
+/**
+ * Log to NDJSON
+ */
+async function log(event, data) {
+    const entry = {
+        timestamp: new Date().toISOString(),
+        event,
+        ...data,
+    };
+    const line = `${JSON.stringify(entry)}${STRING_LITERALS.NEWLINE}`;
+    try {
+        const dir = dirname(NDJSON_LOG_PATH);
+        const dirExists = await access(dir)
+            .then(() => true)
+            .catch(() => false);
+        if (!dirExists) {
+            await mkdir(dir, { recursive: true });
+        }
+        await appendFile(NDJSON_LOG_PATH, line);
+    }
+    catch (error) {
+        console.error('Failed to log:', error);
+    }
+    // Also output to stdout for GitHub Actions logs
+    console.log(JSON.stringify(entry));
+}
+/**
+ * Main monitor function
+ */
+async function monitor() {
+    console.log('\n🌙 Nightly Prompt Monitor Starting...\n');
+    // Find all prompt files
+    const pattern = 'packages/@patientpath/prompts/**/*.yaml';
+    const promptFiles = await glob(pattern, { cwd: ROOT_DIR, absolute: true });
+    console.log(`Found ${promptFiles.length} prompt files to analyze\n`);
+    // Load yesterday's metrics for delta calculation
+    const yesterdayMetrics = await loadYesterdayMetrics();
+    const todayMetrics = {};
+    let totalAlerts = 0;
+    for (const filePath of promptFiles) {
+        try {
+            const { tokenCount, hash } = analyzePrompt(filePath);
+            const yesterday = yesterdayMetrics[filePath];
+            // Calculate delta
+            const delta = yesterday ? tokenCount - yesterday.tokenCount : 0;
+            const hashChanged = yesterday ? hash !== yesterday.hash : false;
+            // Store today's metrics
+            todayMetrics[filePath] = {
+                tokenCount,
+                hash,
+                timestamp: new Date().toISOString(),
+            };
+            // Log metrics
+            await log('prompt.nightly.metrics', {
+                prompt: filePath,
+                tokenCount,
+                hash,
+                delta,
+                hashChanged,
+            });
+            // Alert: approaching cap
+            if (tokenCount >= WARN_THRESHOLD) {
+                totalAlerts++;
+                await log('prompt.nightly.approaching_cap', {
+                    prompt: filePath,
+                    tokenCount,
+                    cap: 450,
+                    message: `Prompt at ${tokenCount} tokens (approaching 450 cap)`,
+                });
+                console.error(`⚠️  ${filePath}: ${tokenCount} tokens (approaching cap)`);
+            }
+            // Alert: significant delta
+            if (Math.abs(delta) > DELTA_THRESHOLD) {
+                totalAlerts++;
+                await log('prompt.nightly.significant_delta', {
+                    prompt: filePath,
+                    tokenCount,
+                    delta,
+                    message: `Delta ${delta > 0 ? '+' : ''}${delta} tokens exceeds threshold`,
+                });
+                console.error(`⚠️  ${filePath}: Delta ${delta > 0 ? '+' : ''}${delta} tokens`);
+            }
+            // Alert: hash changed
+            if (hashChanged) {
+                totalAlerts++;
+                await log('prompt.nightly.hash_changed', {
+                    prompt: filePath,
+                    oldHash: yesterday.hash,
+                    newHash: hash,
+                    message: 'Prompt hash changed - investigate if intentional',
+                });
+                console.error(`⚠️  ${filePath}: Hash changed (${yesterday.hash} → ${hash})`);
+            }
+            // Success log (no alerts)
+            if (tokenCount < WARN_THRESHOLD && Math.abs(delta) <= DELTA_THRESHOLD && !hashChanged) {
+                console.log(`✅ ${filePath}: ${tokenCount} tokens (delta: ${delta})`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Failed to analyze ${filePath}:`, error);
+            await log('prompt.nightly.analysis_failed', {
+                prompt: filePath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Save today's metrics for tomorrow's delta calculation
+    await saveMetrics(todayMetrics);
+    // Rotate metrics (today becomes yesterday)
+    const todayExists = await access(TODAY_METRICS_PATH)
+        .then(() => true)
+        .catch(() => false);
+    if (todayExists) {
+        try {
+            const todayData = await readFile(TODAY_METRICS_PATH, { encoding: 'utf-8' });
+            await writeFile(YESTERDAY_METRICS_PATH, todayData);
+        }
+        catch (error) {
+            console.error('Failed to rotate metrics:', error);
+        }
+    }
+    // Summary
+    console.log(`\n📊 Nightly Monitor Complete`);
+    console.log(`   Total prompts: ${promptFiles.length}`);
+    console.log(`   Alerts: ${totalAlerts}`);
+    if (totalAlerts > 0) {
+        console.log(`\n⚠️  Review alerts above and investigate if changes were intentional\n`);
+        process.exit(EXIT_CODES.ERROR); // Exit with error to trigger GitHub Actions notification
+    }
+    else {
+        console.log(`\n✅ All prompts within budget and stable\n`);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+}
+// Run monitor
+monitor().catch((error) => {
+    console.error('Nightly monitor failed:', error);
+    process.exit(EXIT_CODES.ERROR);
+});

package/dist/rebase-artifact-cleanup.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Rebase Artifact Cleanup
+ *
+ * Detects and cleans up completion artifacts (stamps, status=done)
+ * that appear in worktree after rebasing from main.
+ *
+ * This prevents contradictory state where an in_progress WU has
+ * completion markers from a previous completion cycle on main.
+ *
+ * Part of WU-1371: Post-rebase artifact cleanup
+ * WU-1449: Extended to handle backlog/status duplicates after rebase
+ *
+ * @see {@link tools/wu-done.mjs} - Creates completion artifacts
+ * @see {@link tools/lib/stamp-utils.mjs} - Stamp file utilities
+ * @see {@link tools/lib/wu-recovery.mjs} - Related zombie state handling
+ */
+/**
+ * Detect rebased completion artifacts in a worktree
+ *
+ * WU-1817: Now verifies artifacts exist on origin/main before flagging.
+ * Only artifacts that exist on BOTH worktree AND origin/main are true
+ * rebased artifacts. Artifacts that exist only locally (created by the
+ * lane branch itself) should NOT be cleaned - this was the WU-1816 bug.
+ *
+ * Checks for:
+ * 1. Stamp files (.beacon/stamps/WU-{id}.done) that exist on origin/main
+ * 2. WU YAML with status=done that also has status=done on origin/main
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @param {string} wuId - WU ID (e.g., 'WU-1371')
+ * @param {object} gitAdapter - Git adapter instance with raw() method
+ * @returns {Promise<object>} Detection result
+ * @returns {string[]} result.stamps - Array of detected stamp file paths (only if on origin/main)
+ * @returns {boolean} result.yamlStatusDone - True if YAML has status=done AND origin/main has done
+ * @returns {boolean} result.hasArtifacts - True if any rebased artifacts detected
+ *
+ * @example
+ * const result = await detectRebasedArtifacts(worktreePath, wuId, gitAdapter);
+ * if (result.hasArtifacts) {
+ *   console.log('Found rebased artifacts, cleaning up...');
+ * }
+ */
+export declare function detectRebasedArtifacts(worktreePath: any, wuId: any, gitAdapter: any): Promise<{
+    stamps: any[];
+    yamlStatusDone: boolean;
+    hasArtifacts: boolean;
+}>;
+/**
+ * Clean up rebased completion artifacts from a worktree
+ *
+ * Actions:
+ * 1. Remove stamp files that shouldn't exist
+ * 2. Reset YAML status from done to in_progress
+ * 3. Remove locked and completed_at fields from YAML
+ * 4. Log warnings explaining cleanup actions
+ *
+ * Idempotent: Safe to call multiple times, won't throw if artifacts don't exist.
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @param {string} wuId - WU ID (e.g., 'WU-1371')
+ * @returns {Promise<object>} Cleanup result
+ * @returns {string[]} result.stampsCleaned - WU IDs whose stamps were removed
+ * @returns {boolean} result.yamlReset - True if YAML status was reset
+ * @returns {string[]} result.errors - Any errors encountered (non-fatal)
+ * @returns {boolean} result.cleaned - True if any cleanup was performed
+ *
+ * @example
+ * const result = await cleanupRebasedArtifacts(worktreePath, wuId);
+ * if (result.cleaned) {
+ *   console.log('Cleaned rebased artifacts:', result);
+ * }
+ */
+export declare function cleanupRebasedArtifacts(worktreePath: any, wuId: any): Promise<{
+    stampsCleaned: any[];
+    yamlReset: boolean;
+    backlogCleaned: boolean;
+    statusCleaned: boolean;
+    errors: any[];
+    cleaned: boolean;
+}>;
+/**
+ * Detect WU duplicates in backlog/status files after rebase
+ *
+ * Checks if a WU appears in both:
+ * - "In Progress" AND "Done" sections of backlog.md
+ * - "In Progress" AND "Completed" sections of status.md
+ *
+ * This state occurs when main advanced with WU completion,
+ * then rebase merged main's "Done" state into the worktree
+ * while the worktree already had the WU in "In Progress".
+ *
+ * Part of WU-1449: Extend rebase cleanup to remove backlog/status duplicates
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @param {string} wuId - WU ID (e.g., 'WU-1449')
+ * @returns {Promise<object>} Detection result
+ * @returns {boolean} result.backlogDuplicate - True if WU in both In Progress and Done in backlog.md
+ * @returns {boolean} result.statusDuplicate - True if WU in both In Progress and Completed in status.md
+ * @returns {boolean} result.hasDuplicates - True if any duplicates detected
+ *
+ * @example
+ * const result = await detectBacklogDuplicates(worktreePath, wuId);
+ * if (result.hasDuplicates) {
+ *   console.log('Found backlog duplicates, cleaning up...');
+ * }
+ */
+export declare function detectBacklogDuplicates(worktreePath: any, wuId: any): Promise<{
+    backlogDuplicate: boolean;
+    statusDuplicate: boolean;
+    hasDuplicates: boolean;
+}>;
+/**
+ * Remove WU from In Progress sections when already in Done/Completed after rebase
+ *
+ * This handles the specific case where:
+ * 1. WU is completing (wu:done in progress)
+ * 2. Auto-rebase pulls main's completion state
+ * 3. WU now appears in BOTH In Progress AND Done sections
+ * 4. This function removes the duplicate from In Progress (keeps Done)
+ *
+ * Applies to both backlog.md and status.md.
+ * Idempotent: Safe to call multiple times.
+ *
+ * Part of WU-1449: Extend rebase cleanup to remove backlog/status duplicates
+ *
+ * @param {string} worktreePath - Path to the worktree directory
+ * @param {string} wuId - WU ID (e.g., 'WU-1449')
+ * @returns {Promise<object>} Cleanup result
+ * @returns {boolean} result.backlogCleaned - True if WU removed from backlog.md In Progress
+ * @returns {boolean} result.statusCleaned - True if WU removed from status.md In Progress
+ * @returns {boolean} result.cleaned - True if any cleanup was performed
+ * @returns {string[]} result.errors - Any errors encountered (non-fatal)
+ *
+ * @example
+ * const result = await deduplicateBacklogAfterRebase(worktreePath, wuId);
+ * if (result.cleaned) {
+ *   console.log('Cleaned backlog duplicates:', result);
+ * }
+ */
+export declare function deduplicateBacklogAfterRebase(worktreePath: any, wuId: any): Promise<{
+    backlogCleaned: boolean;
+    statusCleaned: boolean;
+    cleaned: boolean;
+    errors: any[];
+}>;