byterover-cli 1.8.0 → 2.0.0

package/dist/server/infra/daemon/idle-timeout-policy.d.ts

@@ -0,0 +1,38 @@
+import type { IIdleTimeoutPolicy } from '../../core/interfaces/daemon/i-idle-timeout-policy.js';
+export interface IdleTimeoutPolicyOptions {
+    readonly log: (message: string) => void;
+    readonly onIdle: () => void;
+    readonly timeoutMs?: number;
+}
+/**
+ * Tracks client connections to auto-shutdown the daemon
+ * after a period of inactivity.
+ *
+ * Fires `onIdle` when:
+ * - 0 clients connected
+ * - AND this has been the case for >= timeoutMs
+ *
+ * Uses event-driven direct timer: schedules exactly at `timeoutMs`
+ * when clientCount drops to 0. No polling — fires precisely on time.
+ */
+export declare class IdleTimeoutPolicy implements IIdleTimeoutPolicy {
+    private clientCount;
+    private isRunning;
+    private lastActivityAt;
+    private readonly log;
+    private readonly onIdle;
+    private timeoutId;
+    private readonly timeoutMs;
+    constructor(options: IdleTimeoutPolicyOptions);
+    getIdleStatus(): undefined | {
+        clientCount: number;
+        idleMs: number;
+        remainingMs: number;
+    };
+    onClientConnected(): void;
+    onClientDisconnected(): void;
+    start(): void;
+    stop(): void;
+    private fireIdle;
+    private reschedule;
+}

package/dist/server/infra/daemon/idle-timeout-policy.js

@@ -0,0 +1,91 @@
+import { SERVER_IDLE_TIMEOUT_MS } from '../../constants.js';
+/**
+ * Tracks client connections to auto-shutdown the daemon
+ * after a period of inactivity.
+ *
+ * Fires `onIdle` when:
+ * - 0 clients connected
+ * - AND this has been the case for >= timeoutMs
+ *
+ * Uses event-driven direct timer: schedules exactly at `timeoutMs`
+ * when clientCount drops to 0. No polling — fires precisely on time.
+ */
+export class IdleTimeoutPolicy {
+    clientCount = 0;
+    isRunning = false;
+    lastActivityAt = Date.now();
+    log;
+    onIdle;
+    timeoutId;
+    timeoutMs;
+    constructor(options) {
+        this.log = options.log;
+        this.onIdle = options.onIdle;
+        this.timeoutMs = options.timeoutMs ?? SERVER_IDLE_TIMEOUT_MS;
+    }
+    getIdleStatus() {
+        if (this.clientCount > 0)
+            return undefined;
+        const idleMs = Date.now() - this.lastActivityAt;
+        const remainingMs = Math.max(0, this.timeoutMs - idleMs);
+        return { clientCount: this.clientCount, idleMs, remainingMs };
+    }
+    onClientConnected() {
+        this.clientCount++;
+        this.lastActivityAt = Date.now();
+        this.reschedule();
+    }
+    onClientDisconnected() {
+        this.clientCount = Math.max(0, this.clientCount - 1);
+        this.lastActivityAt = Date.now();
+        this.reschedule();
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lastActivityAt = Date.now();
+        this.log('Idle timeout policy started');
+        this.reschedule();
+    }
+    stop() {
+        if (!this.isRunning)
+            return;
+        this.isRunning = false;
+        if (this.timeoutId !== undefined) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = undefined;
+        }
+        this.log('Idle timeout policy stopped');
+    }
+    fireIdle() {
+        if (!this.isRunning || this.clientCount > 0)
+            return;
+        this.log(`Idle for ${Math.round(this.timeoutMs / 1000)}s with no clients`);
+        try {
+            this.onIdle();
+        }
+        catch (error) {
+            this.log(`onIdle callback failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Safety net: re-schedule in case onIdle's shutdown fails.
+        // If onIdle() triggered shutdown → stop() was called → isRunning is false.
+        // Only re-schedule if still running (i.e. shutdown didn't happen).
+        if (this.isRunning) {
+            this.timeoutId = setTimeout(() => this.fireIdle(), this.timeoutMs);
+        }
+    }
+    reschedule() {
+        if (!this.isRunning)
+            return;
+        // Clear existing timer
+        if (this.timeoutId !== undefined) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = undefined;
+        }
+        // Schedule shutdown timer only when no clients are connected
+        if (this.clientCount === 0) {
+            this.timeoutId = setTimeout(() => this.fireIdle(), this.timeoutMs);
+        }
+    }
+}

package/dist/server/infra/daemon/index.d.ts

@@ -0,0 +1,5 @@
+export * from './daemon-resilience.js';
+export * from './heartbeat.js';
+export * from './idle-timeout-policy.js';
+export * from './port-selector.js';
+export * from './shutdown-handler.js';

package/dist/server/infra/daemon/index.js

@@ -0,0 +1,11 @@
+// Daemon infrastructure — classes and utilities for the daemon process.
+// For interfaces (IDaemonResilience, etc.), use core/interfaces/daemon/
+// brv-server.ts is excluded — it's a process entry point, not a library.
+//
+// Daemon lifecycle (connectToDaemon, ensureDaemonRunning, discoverDaemon,
+// GlobalInstanceManager, SpawnLock) has moved to @campfirein/brv-transport-client.
+export * from './daemon-resilience.js';
+export * from './heartbeat.js';
+export * from './idle-timeout-policy.js';
+export * from './port-selector.js';
+export * from './shutdown-handler.js';

package/dist/server/infra/daemon/port-selector.d.ts

@@ -0,0 +1,28 @@
+export type SelectDaemonPortResult = {
+    port: number;
+    success: true;
+} | {
+    reason: 'all_ports_occupied';
+    success: false;
+};
+export type PortSelectionOptions = {
+    batchSize?: number;
+    checker?: (port: number) => Promise<boolean>;
+    maxAttempts?: number;
+    portMax?: number;
+    portMin?: number;
+};
+/**
+ * Selects a port for the daemon server using parallel batch checking.
+ *
+ * Strategy: random batch parallel scan across dynamic port range (49152-65535).
+ * 1. Generate a batch of random candidate ports
+ * 2. Check all candidates in parallel
+ * 3. Return first available port
+ * 4. If none available, repeat with a new batch
+ * 5. Return failure after max attempts exhausted
+ *
+ * Uses IANA dynamic/private port range (49152-65535) for cross-platform
+ * compatibility (macOS, Windows, Linux, WSL, WSL2, Docker).
+ */
+export declare function selectDaemonPort(options?: PortSelectionOptions): Promise<SelectDaemonPortResult>;

package/dist/server/infra/daemon/port-selector.js

@@ -0,0 +1,45 @@
+import { DYNAMIC_PORT_MAX, DYNAMIC_PORT_MIN, PORT_BATCH_SIZE, PORT_MAX_ATTEMPTS } from '../../constants.js';
+import { isPortAvailable } from '../transport/port-utils.js';
+/**
+ * Generates an array of unique random port numbers within the given range.
+ */
+function generateRandomPorts(count, min, max) {
+    const range = max - min + 1;
+    const safeCount = Math.min(count, range);
+    const ports = new Set();
+    while (ports.size < safeCount) {
+        ports.add(min + Math.floor(Math.random() * range));
+    }
+    return [...ports];
+}
+/**
+ * Selects a port for the daemon server using parallel batch checking.
+ *
+ * Strategy: random batch parallel scan across dynamic port range (49152-65535).
+ * 1. Generate a batch of random candidate ports
+ * 2. Check all candidates in parallel
+ * 3. Return first available port
+ * 4. If none available, repeat with a new batch
+ * 5. Return failure after max attempts exhausted
+ *
+ * Uses IANA dynamic/private port range (49152-65535) for cross-platform
+ * compatibility (macOS, Windows, Linux, WSL, WSL2, Docker).
+ */
+export async function selectDaemonPort(options) {
+    const portMin = options?.portMin ?? DYNAMIC_PORT_MIN;
+    const portMax = options?.portMax ?? DYNAMIC_PORT_MAX;
+    const batchSize = options?.batchSize ?? PORT_BATCH_SIZE;
+    const maxAttempts = options?.maxAttempts ?? PORT_MAX_ATTEMPTS;
+    const checker = options?.checker ?? isPortAvailable;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const candidates = generateRandomPorts(batchSize, portMin, portMax);
+        // Check all candidates in parallel for speed
+        // eslint-disable-next-line no-await-in-loop
+        const results = await Promise.all(candidates.map(async (port) => ({ available: await checker(port), port })));
+        const found = results.find((r) => r.available);
+        if (found) {
+            return { port: found.port, success: true };
+        }
+    }
+    return { reason: 'all_ports_occupied', success: false };
+}

package/dist/server/infra/daemon/project-task-queue.d.ts

@@ -0,0 +1,54 @@
+import type { TaskExecute } from '../../core/domain/transport/schemas.js';
+type ProjectTaskQueueOptions = {
+    log?: (message: string) => void;
+};
+/**
+ * Per-project FIFO task queue for the daemon agent pool.
+ *
+ * Each project gets its own queue. Tasks are dequeued one at a time
+ * per project (agents execute sequentially within a project).
+ * Cross-project tasks execute in parallel.
+ *
+ * The pool coordinates which project queues to drain based on
+ * agent availability.
+ *
+ * Not persisted: daemon restart clears all queues.
+ * Clients reconnect and re-submit tasks.
+ */
+export declare class ProjectTaskQueue {
+    private readonly log;
+    private readonly queues;
+    constructor(options?: ProjectTaskQueueOptions);
+    /**
+     * Cancel a task by taskId across all projects.
+     * @returns true if the task was found and removed
+     */
+    cancel(taskId: string): boolean;
+    /**
+     * Clear all queues.
+     */
+    clear(): void;
+    /**
+     * Dequeue the next task for a project.
+     * @returns The next task or undefined if queue is empty
+     */
+    dequeue(projectPath: string): TaskExecute | undefined;
+    /**
+     * Enqueue a task for a project.
+     * @returns Queue position (1-based), or -1 if taskId already queued (dedup)
+     */
+    enqueue(projectPath: string, task: TaskExecute): number;
+    /**
+     * Get all projects that have queued tasks.
+     */
+    getProjectsWithTasks(): string[];
+    /**
+     * Get the number of queued tasks for a project.
+     */
+    getQueueLength(projectPath: string): number;
+    /**
+     * Check if any project has waiting tasks.
+     */
+    hasWaitingTasks(): boolean;
+}
+export {};

package/dist/server/infra/daemon/project-task-queue.js

@@ -0,0 +1,103 @@
+/**
+ * Per-project FIFO task queue for the daemon agent pool.
+ *
+ * Each project gets its own queue. Tasks are dequeued one at a time
+ * per project (agents execute sequentially within a project).
+ * Cross-project tasks execute in parallel.
+ *
+ * The pool coordinates which project queues to drain based on
+ * agent availability.
+ *
+ * Not persisted: daemon restart clears all queues.
+ * Clients reconnect and re-submit tasks.
+ */
+export class ProjectTaskQueue {
+    log;
+    queues = new Map();
+    constructor(options) {
+        this.log = options?.log ?? (() => { });
+    }
+    /**
+     * Cancel a task by taskId across all projects.
+     * @returns true if the task was found and removed
+     */
+    cancel(taskId) {
+        for (const [projectPath, queue] of this.queues) {
+            const index = queue.findIndex((q) => q.task.taskId === taskId);
+            if (index !== -1) {
+                queue.splice(index, 1);
+                if (queue.length === 0)
+                    this.queues.delete(projectPath);
+                this.log(`Cancelled queued task ${taskId} from ${projectPath}`);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Clear all queues.
+     */
+    clear() {
+        this.queues.clear();
+    }
+    /**
+     * Dequeue the next task for a project.
+     * @returns The next task or undefined if queue is empty
+     */
+    dequeue(projectPath) {
+        const queue = this.queues.get(projectPath);
+        if (!queue || queue.length === 0)
+            return undefined;
+        const item = queue.shift();
+        if (queue.length === 0) {
+            this.queues.delete(projectPath);
+        }
+        return item?.task;
+    }
+    /**
+     * Enqueue a task for a project.
+     * @returns Queue position (1-based), or -1 if taskId already queued (dedup)
+     */
+    enqueue(projectPath, task) {
+        let queue = this.queues.get(projectPath);
+        if (!queue) {
+            queue = [];
+            this.queues.set(projectPath, queue);
+        }
+        // Dedup: reject if taskId already in queue
+        if (queue.some((q) => q.task.taskId === task.taskId)) {
+            this.log(`Task ${task.taskId} already queued for ${projectPath}`);
+            return -1;
+        }
+        queue.push({ enqueuedAt: Date.now(), task });
+        this.log(`Task ${task.taskId} queued for ${projectPath} (position=${queue.length})`);
+        return queue.length;
+    }
+    /**
+     * Get all projects that have queued tasks.
+     */
+    getProjectsWithTasks() {
+        const result = [];
+        for (const [projectPath, queue] of this.queues) {
+            if (queue.length > 0)
+                result.push(projectPath);
+        }
+        return result;
+    }
+    /**
+     * Get the number of queued tasks for a project.
+     */
+    getQueueLength(projectPath) {
+        return this.queues.get(projectPath)?.length ?? 0;
+    }
+    /**
+     * Check if any project has waiting tasks.
+     */
+    hasWaitingTasks() {
+        for (const queue of this.queues.values()) {
+            if (queue.length > 0)
+                return true;
+        }
+        return false;
+    }
+}

package/dist/server/infra/daemon/session-resolver.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Session Resolver — Determines which session to use when an agent starts.
+ *
+ * Resolution strategy:
+ * 1. Read active session pointer from metadata store
+ * 2. If active + stale (PID dead / processToken mismatch):
+ *    a. Mark interrupted (best-effort, always)
+ *    b. Check provider compatibility — skip resume if provider changed
+ *    c. Resume it
+ * 3. If active + not stale (another live process): create new
+ * 4. If no active or any error: create new (fail-safe)
+ *
+ * Every read is wrapped in try/catch — any error falls back to a new session
+ * so the user is never blocked.
+ */
+import type { SessionMetadataStore } from '../../../agent/infra/session/session-metadata-store.js';
+export type SessionResolution = {
+    isResume: boolean;
+    sessionId: string;
+};
+export declare function resolveSessionId(options: {
+    currentProviderId?: string;
+    log: (msg: string) => void;
+    metadataStore: SessionMetadataStore;
+    newSessionId: string;
+}): Promise<SessionResolution>;

package/dist/server/infra/daemon/session-resolver.js

@@ -0,0 +1,88 @@
+/**
+ * Session Resolver — Determines which session to use when an agent starts.
+ *
+ * Resolution strategy:
+ * 1. Read active session pointer from metadata store
+ * 2. If active + stale (PID dead / processToken mismatch):
+ *    a. Mark interrupted (best-effort, always)
+ *    b. Check provider compatibility — skip resume if provider changed
+ *    c. Resume it
+ * 3. If active + not stale (another live process): create new
+ * 4. If no active or any error: create new (fail-safe)
+ *
+ * Every read is wrapped in try/catch — any error falls back to a new session
+ * so the user is never blocked.
+ */
+export async function resolveSessionId(options) {
+    const { currentProviderId, log, metadataStore, newSessionId } = options;
+    try {
+        const active = await metadataStore.getActiveSession();
+        if (!active) {
+            return { isResume: false, sessionId: newSessionId };
+        }
+        // Active session exists — check if the owning process is still alive
+        let isStale;
+        try {
+            isStale = await metadataStore.isActiveSessionStale();
+        }
+        catch {
+            // Can't determine staleness — safer to create new
+            log('Could not check session staleness, creating new session');
+            return { isResume: false, sessionId: newSessionId };
+        }
+        if (isStale) {
+            // Always mark stale session as interrupted (best-effort, regardless of resume decision)
+            try {
+                await metadataStore.markSessionInterrupted(active.sessionId);
+            }
+            catch {
+                log(`Could not mark session ${active.sessionId} as interrupted`);
+            }
+            // Check provider compatibility before resuming
+            if (currentProviderId) {
+                const skip = await shouldSkipResumeForProviderChange({
+                    currentProviderId,
+                    log,
+                    metadataStore,
+                    sessionId: active.sessionId,
+                });
+                if (skip)
+                    return { isResume: false, sessionId: newSessionId };
+            }
+            log(`Resuming stale session: ${active.sessionId}`);
+            return { isResume: true, sessionId: active.sessionId };
+        }
+        // Another live process owns this session — create new
+        log(`Active session owned by another process (pid=${active.pid}), creating new`);
+        return { isResume: false, sessionId: newSessionId };
+    }
+    catch (error) {
+        // Top-level catch: any unexpected error falls back to new session
+        log(`Session resolve error, creating new: ${error instanceof Error ? error.message : String(error)}`);
+        return { isResume: false, sessionId: newSessionId };
+    }
+}
+/**
+ * Check if a stale session's provider is compatible with the current provider.
+ * Returns true if resume should be skipped (provider mismatch or read error).
+ * Pure check — does NOT modify session state (caller handles markSessionInterrupted).
+ *
+ * Loading history from a different provider causes tool_use_id format mismatches
+ * (e.g., ByteRover IDs sent to Anthropic API).
+ */
+async function shouldSkipResumeForProviderChange(options) {
+    const { currentProviderId, log, metadataStore, sessionId } = options;
+    try {
+        const metadata = await metadataStore.getSession(sessionId);
+        if (metadata?.providerId && metadata.providerId !== currentProviderId) {
+            log(`Provider mismatch: session used '${metadata.providerId}', ` +
+                `current is '${currentProviderId}', creating new session`);
+            return true;
+        }
+        return false;
+    }
+    catch {
+        log('Could not read session metadata for provider check, creating new session');
+        return true;
+    }
+}

package/dist/server/infra/daemon/shutdown-handler.d.ts

@@ -0,0 +1,42 @@
+import type { IGlobalInstanceManager } from '@campfirein/brv-transport-client';
+import type { IAgentPool } from '../../core/interfaces/agent/i-agent-pool.js';
+import type { IAgentIdleTimeoutPolicy } from '../../core/interfaces/daemon/i-agent-idle-timeout-policy.js';
+import type { IDaemonResilience } from '../../core/interfaces/daemon/i-daemon-resilience.js';
+import type { IHeartbeatWriter } from '../../core/interfaces/daemon/i-heartbeat-writer.js';
+import type { IIdleTimeoutPolicy } from '../../core/interfaces/daemon/i-idle-timeout-policy.js';
+import type { IShutdownHandler } from '../../core/interfaces/daemon/i-shutdown-handler.js';
+import type { ITransportServer } from '../../core/interfaces/transport/i-transport-server.js';
+export interface ShutdownHandlerDeps {
+    readonly agentIdleTimeoutPolicy?: IAgentIdleTimeoutPolicy;
+    readonly agentPool?: IAgentPool;
+    readonly daemonResilience: IDaemonResilience;
+    readonly heartbeatWriter: IHeartbeatWriter;
+    readonly idleTimeoutPolicy: IIdleTimeoutPolicy;
+    readonly instanceManager: IGlobalInstanceManager;
+    readonly log: (message: string) => void;
+    readonly transportServer: ITransportServer;
+}
+/**
+ * Ordered graceful shutdown handler for the daemon.
+ *
+ * Shutdown sequence (8 steps):
+ * 1. Stop server idle timeout checks
+ * 2. Stop agent idle timeout checks
+ * 3. Uninstall resilience handlers
+ * 4. Stop heartbeat writer (stops writes, file becomes stale naturally)
+ * 5. Stop agent pool (SIGTERM child processes, wait for exit)
+ * 6. Stop transport server (disconnect sockets, close HTTP server)
+ * 7. Release daemon.json
+ * 8. Schedule force exit safety net
+ *
+ * Agent pool is stopped BEFORE transport server so agents can use
+ * their transport connections for graceful shutdown signaling.
+ * Transport is stopped BEFORE releasing daemon.json to prevent
+ * another daemon binding the same port while sockets are still closing.
+ */
+export declare class ShutdownHandler implements IShutdownHandler {
+    private readonly deps;
+    private isShuttingDown;
+    constructor(deps: ShutdownHandlerDeps);
+    shutdown(): Promise<void>;
+}

package/dist/server/infra/daemon/shutdown-handler.js

@@ -0,0 +1,101 @@
+import { SHUTDOWN_FORCE_EXIT_MS, TRANSPORT_STOP_TIMEOUT_MS } from '../../constants.js';
+/**
+ * Ordered graceful shutdown handler for the daemon.
+ *
+ * Shutdown sequence (8 steps):
+ * 1. Stop server idle timeout checks
+ * 2. Stop agent idle timeout checks
+ * 3. Uninstall resilience handlers
+ * 4. Stop heartbeat writer (stops writes, file becomes stale naturally)
+ * 5. Stop agent pool (SIGTERM child processes, wait for exit)
+ * 6. Stop transport server (disconnect sockets, close HTTP server)
+ * 7. Release daemon.json
+ * 8. Schedule force exit safety net
+ *
+ * Agent pool is stopped BEFORE transport server so agents can use
+ * their transport connections for graceful shutdown signaling.
+ * Transport is stopped BEFORE releasing daemon.json to prevent
+ * another daemon binding the same port while sockets are still closing.
+ */
+export class ShutdownHandler {
+    deps;
+    isShuttingDown = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async shutdown() {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
+        const { agentIdleTimeoutPolicy, daemonResilience, heartbeatWriter, idleTimeoutPolicy, instanceManager, log, transportServer, } = this.deps;
+        log('Shutdown initiated');
+        // Step 1. Stop idle timeout checks (server-level)
+        try {
+            idleTimeoutPolicy.stop();
+        }
+        catch (error) {
+            log(`Error stopping idle timeout: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Step 2. Stop agent idle timeout checks
+        if (agentIdleTimeoutPolicy) {
+            try {
+                agentIdleTimeoutPolicy.stop();
+            }
+            catch (error) {
+                log(`Error stopping agent idle timeout: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Step 3. Uninstall resilience handlers
+        try {
+            daemonResilience.uninstall();
+        }
+        catch (error) {
+            log(`Error uninstalling resilience: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Step 4. Stop heartbeat (file becomes stale naturally)
+        try {
+            heartbeatWriter.stop();
+        }
+        catch (error) {
+            log(`Error stopping heartbeat: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Step 5. Stop agent pool (SIGTERM all child processes, wait for exit)
+        //    Must happen before transport server stops — agents need the
+        //    transport connection for graceful shutdown signaling.
+        if (this.deps.agentPool) {
+            try {
+                await this.deps.agentPool.shutdown();
+            }
+            catch (error) {
+                log(`Error shutting down agent pool: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Step 6. Stop transport server (disconnect all sockets, close HTTP)
+        //    Wrapped in Promise.race with timeout to prevent hanging — if Socket.IO
+        //    blocks (e.g., waiting for in-flight responses), we proceed with remaining
+        //    cleanup steps instead of relying solely on the force-exit safety net
+        //    (which would skip instance lock release via process.exit).
+        try {
+            await Promise.race([
+                transportServer.stop(),
+                new Promise((resolve) => {
+                    setTimeout(resolve, TRANSPORT_STOP_TIMEOUT_MS);
+                }),
+            ]);
+        }
+        catch (error) {
+            log(`Error stopping transport: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Step 7. Release daemon.json
+        try {
+            instanceManager.release();
+        }
+        catch (error) {
+            log(`Error releasing instance: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        log('Shutdown complete');
+        // Step 8. Safety net: force exit if event loop hasn't drained
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        setTimeout(() => process.exit(0), SHUTDOWN_FORCE_EXIT_MS).unref();
+    }
+}

package/dist/server/infra/executor/curate-executor.d.ts

@@ -1,4 +1,5 @@
 import type { ICipherAgent } from '../../../agent/core/interfaces/i-cipher-agent.js';
+import type { CurationStatus } from '../../core/domain/entities/curation-status.js';
 import type { CurateExecuteOptions, ICurateExecutor } from '../../core/interfaces/executor/i-curate-executor.js';
 import { type FileContentReader } from '../../utils/file-content-reader.js';
 /**
@@ -8,8 +9,8 @@ import { type FileContentReader } from '../../utils/file-content-reader.js';
  * It's an Executor that wraps agent.execute() with curate-specific options.
  *
  * Architecture:
- * - TaskProcessor injects the long-lived CipherAgent
- * - Event streaming is handled by agent-worker (subscribes to agentEventBus)
+ * - AgentProcess injects the long-lived CipherAgent
+ * - Event streaming is handled by agent-process (subscribes to agentEventBus)
  * - Transport handles task lifecycle (task:started, task:completed, task:error)
  * - Executor focuses solely on curate execution
  */
@@ -22,6 +23,8 @@ export declare class CurateExecutor implements ICurateExecutor {
     private static readonly MAX_LINES_PER_FILE;
     /** Maximum pages to extract for PDFs */
     private static readonly MAX_PDF_PAGES;
+    /** Last curation status — available for future status-check command */
+    lastStatus?: CurationStatus;
     private readonly fileContentReader;
     constructor(fileContentReader?: FileContentReader);
     executeWithAgent(agent: ICipherAgent, options: CurateExecuteOptions): Promise<string>;
@@ -33,6 +36,11 @@ export declare class CurateExecutor implements ICurateExecutor {
      * Get human-readable label for file type.
      */
     private getFileTypeLabel;
+    /**
+     * Parse curation status from the agent response.
+     * Extracts JSON status block if present, otherwise infers from response text.
+     */
+    private parseCurationStatus;
     /**
      * Process file paths from --files flag.
      * Now reads file contents directly using FileContentReader.