@claude-flow/cli 3.27.4 → 3.29.0

package/dist/src/services/event-stream.js

@@ -0,0 +1,27 @@
+/**
+ * NDJSON Event Stream for CLI --stream mode
+ *
+ * Emits newline-delimited JSON events to stdout for consumption
+ * by Claude Code's Monitor tool. Each event includes schema versioning.
+ *
+ * @see ADR-091: NDJSON event streaming infrastructure
+ */
+import { randomBytes } from 'crypto';
+/** Generate a short unique run ID (e.g. run_m1abc_3f2a1b) */
+export function createRunId() {
+    return `run_${Date.now().toString(36)}_${randomBytes(3).toString('hex')}`;
+}
+/** Write one NDJSON line to stdout with schema and timestamp auto-populated */
+export function emitEvent(event) {
+    const full = Object.assign({ schema: 'ruflo.event.v1', ts: new Date().toISOString() }, event);
+    process.stdout.write(JSON.stringify(full) + '\n');
+}
+/** Convenience wrapper that binds a runId to an emitter */
+export function createEventEmitter(runId) {
+    return {
+        emit(event, data) {
+            emitEvent({ runId, event, ...data });
+        },
+    };
+}
+//# sourceMappingURL=event-stream.js.map

package/dist/src/services/global-ai-budget.d.ts

@@ -80,6 +80,31 @@ export declare class GlobalAiBudget {
      * daemon pauses ALL autonomous Claude launches for the cooldown window.
      */
     recordQuotaError(detail: string): Promise<void>;
+    /**
+     * #2661 root-fix — manual pause, via `ruflo daemon budget pause`. Distinct
+     * from the automatic quota-error circuit breaker only in duration (open-
+     * ended, until explicitly resumed, instead of a fixed cooldown) and
+     * reason text — the enforcement path in reserve() is identical, so a
+     * manual pause is just as hard a stop as a quota-triggered one.
+     */
+    pause(reason?: string): Promise<void>;
+    /** #2661 root-fix — `ruflo daemon budget resume`. Clears ANY pause (manual or quota-triggered). */
+    resume(): Promise<void>;
+    /**
+     * #2661 root-fix — structured per-launch token telemetry. Best-effort,
+     * receipt-only: usage is recorded as a distinct receipt keyed by permitId
+     * rather than mutated into the launch ledger, so a usage-recording failure
+     * can never corrupt the budget-enforcement ledger. Only operational
+     * metadata — never prompts or source content.
+     */
+    recordUsage(permitId: string | undefined, usage: {
+        workerType: string;
+        model: string;
+        inputTokens?: number;
+        outputTokens?: number;
+        durationMs?: number;
+        costUsd?: number;
+    }): void;
     /** Snapshot for `daemon status` / diagnostics. */
     getUsage(): {
         lastHour: number;

package/dist/src/services/global-ai-budget.js

@@ -221,6 +221,62 @@ export class GlobalAiBudget {
             unlock?.();
         }
     }
+    /**
+     * #2661 root-fix — manual pause, via `ruflo daemon budget pause`. Distinct
+     * from the automatic quota-error circuit breaker only in duration (open-
+     * ended, until explicitly resumed, instead of a fixed cooldown) and
+     * reason text — the enforcement path in reserve() is identical, so a
+     * manual pause is just as hard a stop as a quota-triggered one.
+     */
+    async pause(reason) {
+        let unlock = null;
+        try {
+            unlock = await this.acquireLock();
+            const now = Date.now();
+            const ledger = this.readLedger(now);
+            // Sentinel far-future timestamp rather than a real duration — resume()
+            // is the only thing that clears it. year ~2255, safely beyond any
+            // realistic process lifetime, and still a valid finite JS timestamp.
+            ledger.pausedUntil = 9_000_000_000_000;
+            ledger.pauseReason = (reason ?? 'manual pause (ruflo daemon budget pause)').slice(0, 200);
+            this.writeLedger(ledger);
+            this.appendReceipt({ event: 'manual-pause', at: now, reason: ledger.pauseReason });
+        }
+        finally {
+            unlock?.();
+        }
+    }
+    /** #2661 root-fix — `ruflo daemon budget resume`. Clears ANY pause (manual or quota-triggered). */
+    async resume() {
+        let unlock = null;
+        try {
+            unlock = await this.acquireLock();
+            const now = Date.now();
+            const ledger = this.readLedger(now);
+            const wasPaused = ledger.pausedUntil !== undefined && ledger.pausedUntil > now;
+            ledger.pausedUntil = undefined;
+            ledger.pauseReason = undefined;
+            this.writeLedger(ledger);
+            if (wasPaused) {
+                this.appendReceipt({ event: 'manual-resume', at: now });
+            }
+        }
+        finally {
+            unlock?.();
+        }
+    }
+    /**
+     * #2661 root-fix — structured per-launch token telemetry. Best-effort,
+     * receipt-only: usage is recorded as a distinct receipt keyed by permitId
+     * rather than mutated into the launch ledger, so a usage-recording failure
+     * can never corrupt the budget-enforcement ledger. Only operational
+     * metadata — never prompts or source content.
+     */
+    recordUsage(permitId, usage) {
+        if (!permitId || permitId.startsWith('bypass_'))
+            return;
+        this.appendReceipt({ event: 'usage', at: Date.now(), permitId, ...usage });
+    }
     /** Snapshot for `daemon status` / diagnostics. */
     getUsage() {
         try {

package/dist/src/services/headless-worker-executor.d.ts

@@ -119,6 +119,10 @@ export interface HeadlessExecutionResult {
     durationMs: number;
     /** Estimated tokens used (if available) */
     tokensUsed?: number;
+    /** #2661 root-fix — structured usage, when `claude --print --output-format json` exposed it. */
+    inputTokens?: number;
+    outputTokens?: number;
+    costUsd?: number;
     /** Model used for execution */
     model: string;
     /** Sandbox mode used */
@@ -190,6 +194,23 @@ export declare function isLocalWorker(type: WorkerType): type is LocalWorkerType
  * Get model ID from model type
  */
 export declare function getModelId(model: ModelType): string;
+export interface ClaudePrintEnvelope {
+    result: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    costUsd?: number;
+    durationMs?: number;
+}
+/**
+ * #2661 root-fix — best-effort parse of `claude --print --output-format
+ * json`'s response envelope. Deliberately lenient: probes a couple of
+ * plausible field-name shapes (the CLI's JSON schema is not a versioned
+ * public contract) and returns null on anything unexpected rather than
+ * throwing, so a schema mismatch degrades to "no usage captured" — the
+ * caller then falls back to the raw stdout text, exactly today's behavior.
+ * Exported for direct unit testing without spawning a real process.
+ */
+export declare function parseClaudePrintJsonEnvelope(raw: string): ClaudePrintEnvelope | null;
 /**
  * Get worker configuration by type
  */

package/dist/src/services/headless-worker-executor.js

@@ -78,18 +78,18 @@ export const HEADLESS_WORKER_CONFIGS = {
         description: 'AI-powered security analysis',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze this codebase for security vulnerabilities:
-- Check for hardcoded secrets (API keys, passwords)
-- Identify SQL injection risks
-- Find XSS vulnerabilities
-- Check for insecure dependencies
-- Identify authentication/authorization issues
-
-Provide a JSON report with:
-{
-  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
-  "riskScore": 0-100,
-  "recommendations": ["..."]
+            promptTemplate: `Analyze this codebase for security vulnerabilities:
+- Check for hardcoded secrets (API keys, passwords)
+- Identify SQL injection risks
+- Find XSS vulnerabilities
+- Check for insecure dependencies
+- Identify authentication/authorization issues
+
+Provide a JSON report with:
+{
+  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
+  "riskScore": 0-100,
+  "recommendations": ["..."]
 }`,
             sandbox: 'strict',
             model: 'haiku',
@@ -106,13 +106,13 @@ Provide a JSON report with:
         description: 'AI optimization suggestions',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze this codebase for performance optimizations:
-- Identify N+1 query patterns
-- Find unnecessary re-renders in React
-- Suggest caching opportunities
-- Identify memory leaks
-- Find redundant computations
-
+            promptTemplate: `Analyze this codebase for performance optimizations:
+- Identify N+1 query patterns
+- Find unnecessary re-renders in React
+- Suggest caching opportunities
+- Identify memory leaks
+- Find redundant computations
+
 Provide actionable suggestions with code examples.`,
             sandbox: 'permissive',
             model: 'sonnet',
@@ -129,13 +129,13 @@ Provide actionable suggestions with code examples.`,
         description: 'AI test gap analysis',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze test coverage and identify gaps:
-- Find untested functions and classes
-- Identify edge cases not covered
-- Suggest new test scenarios
-- Check for missing error handling tests
-- Identify integration test gaps
-
+            promptTemplate: `Analyze test coverage and identify gaps:
+- Find untested functions and classes
+- Identify edge cases not covered
+- Suggest new test scenarios
+- Check for missing error handling tests
+- Identify integration test gaps
+
 For each gap, provide a test skeleton.`,
             sandbox: 'permissive',
             model: 'sonnet',
@@ -152,13 +152,13 @@ For each gap, provide a test skeleton.`,
         description: 'AI documentation generation',
         enabled: false,
         headless: {
-            promptTemplate: `Generate documentation for undocumented code:
-- Add JSDoc comments to functions
-- Create README sections for modules
-- Document API endpoints
-- Add inline comments for complex logic
-- Generate usage examples
-
+            promptTemplate: `Generate documentation for undocumented code:
+- Add JSDoc comments to functions
+- Create README sections for modules
+- Document API endpoints
+- Add inline comments for complex logic
+- Generate usage examples
+
 Focus on public APIs and exported functions.`,
             sandbox: 'permissive',
             model: 'haiku',
@@ -175,19 +175,19 @@ Focus on public APIs and exported functions.`,
         description: 'Deep knowledge acquisition',
         enabled: false,
         headless: {
-            promptTemplate: `Deeply analyze this codebase to learn:
-- Architectural patterns used
-- Coding conventions
-- Domain-specific terminology
-- Common patterns and idioms
-- Team preferences
-
-Provide insights as JSON:
-{
-  "architecture": { "patterns": [...], "style": "..." },
-  "conventions": { "naming": "...", "formatting": "..." },
-  "domains": ["..."],
-  "insights": ["..."]
+            promptTemplate: `Deeply analyze this codebase to learn:
+- Architectural patterns used
+- Coding conventions
+- Domain-specific terminology
+- Common patterns and idioms
+- Team preferences
+
+Provide insights as JSON:
+{
+  "architecture": { "patterns": [...], "style": "..." },
+  "conventions": { "naming": "...", "formatting": "..." },
+  "domains": ["..."],
+  "insights": ["..."]
 }`,
             sandbox: 'strict',
             model: 'opus',
@@ -204,13 +204,13 @@ Provide insights as JSON:
         description: 'AI refactoring suggestions',
         enabled: false,
         headless: {
-            promptTemplate: `Suggest refactoring opportunities:
-- Identify code duplication
-- Suggest better abstractions
-- Find opportunities for design patterns
-- Identify overly complex functions
-- Suggest module reorganization
-
+            promptTemplate: `Suggest refactoring opportunities:
+- Identify code duplication
+- Suggest better abstractions
+- Find opportunities for design patterns
+- Identify overly complex functions
+- Suggest module reorganization
+
 Provide before/after code examples.`,
             sandbox: 'permissive',
             model: 'sonnet',
@@ -227,13 +227,13 @@ Provide before/after code examples.`,
         description: 'Deep code analysis',
         enabled: false,
         headless: {
-            promptTemplate: `Perform deep analysis of this codebase:
-- Understand data flow
-- Map dependencies
-- Identify architectural issues
-- Find potential bugs
-- Analyze error handling
-
+            promptTemplate: `Perform deep analysis of this codebase:
+- Understand data flow
+- Map dependencies
+- Identify architectural issues
+- Find potential bugs
+- Analyze error handling
+
 Provide comprehensive report.`,
             sandbox: 'strict',
             model: 'opus',
@@ -250,18 +250,18 @@ Provide comprehensive report.`,
         description: 'Predictive preloading',
         enabled: false,
         headless: {
-            promptTemplate: `Based on recent activity, predict what the developer needs:
-- Files likely to be edited next
-- Tests that should be run
-- Documentation to reference
-- Dependencies to check
-
-Provide preload suggestions as JSON:
-{
-  "filesToPreload": ["..."],
-  "testsToRun": ["..."],
-  "docsToReference": ["..."],
-  "confidence": 0.0-1.0
+            promptTemplate: `Based on recent activity, predict what the developer needs:
+- Files likely to be edited next
+- Tests that should be run
+- Documentation to reference
+- Dependencies to check
+
+Provide preload suggestions as JSON:
+{
+  "filesToPreload": ["..."],
+  "testsToRun": ["..."],
+  "docsToReference": ["..."],
+  "confidence": 0.0-1.0
 }`,
             sandbox: 'strict',
             model: 'haiku',
@@ -336,6 +336,42 @@ export function isLocalWorker(type) {
 export function getModelId(model) {
     return MODEL_IDS[model];
 }
+/**
+ * #2661 root-fix — best-effort parse of `claude --print --output-format
+ * json`'s response envelope. Deliberately lenient: probes a couple of
+ * plausible field-name shapes (the CLI's JSON schema is not a versioned
+ * public contract) and returns null on anything unexpected rather than
+ * throwing, so a schema mismatch degrades to "no usage captured" — the
+ * caller then falls back to the raw stdout text, exactly today's behavior.
+ * Exported for direct unit testing without spawning a real process.
+ */
+export function parseClaudePrintJsonEnvelope(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed[0] !== '{')
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const obj = parsed;
+    const result = typeof obj.result === 'string' ? obj.result : undefined;
+    if (result === undefined)
+        return null; // not the envelope shape we expect
+    const usage = (obj.usage && typeof obj.usage === 'object') ? obj.usage : undefined;
+    const numOrUndef = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+    return {
+        result,
+        inputTokens: numOrUndef(usage?.input_tokens ?? usage?.inputTokens),
+        outputTokens: numOrUndef(usage?.output_tokens ?? usage?.outputTokens),
+        costUsd: numOrUndef(obj.total_cost_usd ?? obj.cost_usd ?? obj.totalCostUsd),
+        durationMs: numOrUndef(obj.duration_ms ?? obj.durationMs),
+    };
+}
 /**
  * Get worker configuration by type
  */
@@ -721,6 +757,9 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                 parsedOutput,
                 durationMs: Date.now() - startTime,
                 tokensUsed: result.tokensUsed,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                costUsd: result.costUsd,
                 model: headless.model || 'sonnet',
                 sandboxMode: headless.sandbox,
                 workerType,
@@ -730,6 +769,17 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             };
             // Log result
             this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
+            // #2661 root-fix — structured per-launch telemetry, receipted
+            // regardless of success/failure (a failed launch still spent
+            // whatever tokens it spent before erroring).
+            budget.recordUsage(permit.permitId, {
+                workerType,
+                model,
+                inputTokens: result.inputTokens,
+                outputTokens: result.outputTokens,
+                durationMs: result.apiDurationMs ?? executionResult.durationMs,
+                costUsd: result.costUsd,
+            });
             // #2661 invariant 5 — record the success so sibling worktrees at the
             // same HEAD skip this job for the rest of the freshness window.
             if (result.success) {
@@ -930,20 +980,20 @@ export class HeadlessWorkerExecutor extends EventEmitter {
      */
     buildPrompt(template, context) {
         if (!context) {
-            return `${template}
-
-## Instructions
-
+            return `${template}
+
+## Instructions
+
 Analyze the codebase and provide your response following the format specified in the task.`;
         }
-        return `${template}
-
-## Codebase Context
-
-${context}
-
-## Instructions
-
+        return `${template}
+
+## Codebase Context
+
+${context}
+
+## Instructions
+
 Analyze the above codebase context and provide your response following the format specified in the task.`;
     }
     /**
@@ -988,7 +1038,15 @@ Analyze the above codebase context and provide your response following the forma
             // diagnosed as a 5-second redispatch + subprocess-table growth.
             // `detached: true` puts the child in its own process group so we
             // can signal the whole tree with `process.kill(-pid, sig)`.
-            const child = spawn('claude', ['--print'], {
+            // #2661 root-fix — structured usage telemetry. `--output-format json`
+            // wraps the response in an envelope carrying `result` (the actual
+            // text — what `output` must still contain, unchanged for every
+            // existing downstream parser) alongside `usage`/cost/duration
+            // metadata. Parsing is lenient (parseClaudePrintJsonEnvelope below)
+            // and ALWAYS falls back to the raw text on any mismatch — a schema
+            // surprise from an older/newer `claude` CLI must degrade to exactly
+            // today's behavior (no usage captured), never break analysis output.
+            const child = spawn('claude', ['--print', '--output-format', 'json'], {
                 cwd: this.projectRoot,
                 env,
                 stdio: ['pipe', 'pipe', 'pipe'],
@@ -1068,9 +1126,17 @@ Analyze the above codebase context and provide your response following the forma
                     return;
                 resolved = true;
                 cleanup();
+                const envelope = parseClaudePrintJsonEnvelope(stdout);
                 resolve({
                     success: code === 0,
-                    output: stdout || stderr,
+                    output: envelope?.result ?? stdout ?? stderr,
+                    inputTokens: envelope?.inputTokens,
+                    outputTokens: envelope?.outputTokens,
+                    tokensUsed: envelope
+                        ? (envelope.inputTokens ?? 0) + (envelope.outputTokens ?? 0)
+                        : undefined,
+                    costUsd: envelope?.costUsd,
+                    apiDurationMs: envelope?.durationMs,
                     error: code !== 0 ? stderr || `Process exited with code ${code}` : undefined,
                 });
             });

package/dist/src/services/loop-worker-runner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ADR-091 Phase 2 -- Stateless Loop Worker Runner
+ *
+ * Designed for /loop execution: runs a single worker iteration and returns
+ * metadata that the caller can use with ScheduleWakeup.
+ */
+export interface LoopWorkerResult {
+    workerType: string;
+    success: boolean;
+    suggestedDelay: number;
+    reason: string;
+    loopPrompt: string;
+    metrics?: Record<string, unknown>;
+}
+export declare function runLoopWorker(workerType: string): Promise<LoopWorkerResult>;
+//# sourceMappingURL=loop-worker-runner.d.ts.map

package/dist/src/services/loop-worker-runner.js

@@ -0,0 +1,34 @@
+/**
+ * ADR-091 Phase 2 -- Stateless Loop Worker Runner
+ *
+ * Designed for /loop execution: runs a single worker iteration and returns
+ * metadata that the caller can use with ScheduleWakeup.
+ */
+import { execSync } from 'child_process';
+import { getCacheWarmDelay } from './runtime-capabilities.js';
+export async function runLoopWorker(workerType) {
+    const startMs = Date.now();
+    let success = false;
+    let reason = '';
+    try {
+        const safeWorkerType = workerType.replace(/[^a-zA-Z0-9_-]/g, '');
+        const stdout = execSync(`npx @claude-flow/cli hooks worker dispatch --trigger ${safeWorkerType}`, { encoding: 'utf-8', timeout: 120_000, stdio: ['ignore', 'pipe', 'pipe'] });
+        success = true;
+        reason = stdout.trim().slice(0, 200) || `${workerType} completed`;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        reason = `${workerType} failed: ${msg.slice(0, 200)}`;
+    }
+    const durationMs = Date.now() - startMs;
+    const suggestedDelay = getCacheWarmDelay();
+    return {
+        workerType,
+        success,
+        suggestedDelay,
+        reason,
+        loopPrompt: `Run ${workerType} worker and report results`,
+        metrics: { durationMs, timestamp: new Date().toISOString() },
+    };
+}
+//# sourceMappingURL=loop-worker-runner.js.map

package/dist/src/services/memory-distillation.js

@@ -116,10 +116,10 @@ export async function runDistillation(options) {
             return { ...report, corrupt: true, skipped: 'memory DB reports corruption — run recoverMemoryDatabase first' };
         }
         // M0: incremental cursor table (per namespace, by monotonic rowid).
-        db.exec(`CREATE TABLE IF NOT EXISTS distill_state (
-      namespace TEXT PRIMARY KEY,
-      last_rowid INTEGER NOT NULL DEFAULT 0,
-      last_run_at INTEGER
+        db.exec(`CREATE TABLE IF NOT EXISTS distill_state (
+      namespace TEXT PRIMARY KEY,
+      last_rowid INTEGER NOT NULL DEFAULT 0,
+      last_run_at INTEGER
     )`);
         // Which namespaces to process.
         const nsAll = db.prepare("SELECT DISTINCT COALESCE(namespace,'default') AS ns FROM memory_entries WHERE embedding IS NOT NULL").all().map(r => r.ns);

package/dist/src/services/repo-supervisor.d.ts

@@ -0,0 +1,70 @@
+/**
+ * #2661 root-fix — one repository-level supervisor.
+ *
+ * Ten worktree daemons of the same repository independently deciding "is it
+ * time to run audit/optimize/testgaps" every tick is the redundant-scheduler
+ * half of the original cardinality bug — the budget ledger and job dedup
+ * (global-ai-budget.ts, ai-job-dedup.ts) already bound and dedupe the actual
+ * `claude --print` spend, but every daemon still runs its own timer and its
+ * own "should I launch" decision. This module elects exactly ONE daemon per
+ * repositoryId to own the recurring AI-worker schedule; every other worktree
+ * of that repository stays a lease-only participant (workspace-lease.ts) —
+ * it keeps running its cheap, $0 local-only workers (map/consolidate/backup)
+ * on its own schedule, but does not attempt headless (`claude --print`)
+ * execution for its recurring ticks. An explicit `daemon trigger --headless`
+ * in a non-supervisor worktree is still honored (still budget/dedup-gated) —
+ * this module only governs the unattended recurring schedule.
+ *
+ * Election is a simple lock-protected takeover, same pattern as
+ * global-ai-budget.ts:
+ *   - No record, a dead PID, or a stale heartbeat (>SUPERVISOR_STALE_MS) →
+ *     the calling daemon takes over.
+ *   - A live supervisor with a fresh heartbeat → the calling daemon is not
+ *     elected; it does nothing (never overwrites a healthy supervisor).
+ *
+ * The registry lives under the user's home directory so every worktree's
+ * daemon can see it:
+ *
+ *   ~/.claude-flow/supervisors/<repositoryId>.json
+ */
+export declare const SUPERVISOR_STALE_MS: number;
+export interface SupervisorRecord {
+    worktreeRoot: string;
+    pid: number;
+    electedAt: number;
+    lastHeartbeat: number;
+}
+export interface SupervisorElectionResult {
+    isSupervisor: boolean;
+    record: SupervisorRecord | null;
+}
+export declare class RepoSupervisorRegistry {
+    private readonly dir;
+    constructor(options?: {
+        baseDir?: string;
+    });
+    private fileFor;
+    private ensureDir;
+    private withLock;
+    private readRecord;
+    private writeRecord;
+    private isStale;
+    /**
+     * Attempt election (or renewal, if this process already holds it). Safe
+     * and cheap to call on every daemon tick — a no-op write when nothing
+     * needs to change would still cost a lock+read+write, so callers should
+     * still throttle to their own heartbeat cadence rather than calling this
+     * per-worker-tick.
+     */
+    electOrRenew(repositoryId: string, worktreeRoot: string): Promise<SupervisorElectionResult>;
+    /** Cheap read-only check — does NOT renew or elect. */
+    isSupervisor(repositoryId: string, worktreeRoot: string): boolean;
+    /** Release supervisor status on graceful shutdown, so the next tick elsewhere can take over promptly. Best-effort. */
+    release(repositoryId: string, worktreeRoot: string): Promise<void>;
+    /** Snapshot for `daemon status --all`. Read-only, never mutates. */
+    getRecord(repositoryId: string): SupervisorRecord | null;
+}
+export declare function getRepoSupervisorRegistry(): RepoSupervisorRegistry;
+/** Test hook: reset the singleton (e.g. after changing RUFLO_AI_BUDGET_DIR). */
+export declare function resetRepoSupervisorRegistryForTests(): void;
+//# sourceMappingURL=repo-supervisor.d.ts.map