visionclaw 0.1.219-beta.0 → 0.1.219-dev.codex-issue-2805-worker-runtime.1

package/dist/threads/thread-task-runtime.d.ts

@@ -1,354 +0,0 @@
-/**
- * ThreadTaskRuntime (issue #1996, PR 3): the one object the live loop talks
- * to. It owns this process's {@link ThreadTaskStore} and
- * {@link ThreadTaskController} for the thread it serves — the default thread
- * in the main process, a business thread in its worker.
- *
- * Hot-path rule: every method is fail-safe. A store, controller or model
- * error is logged and swallowed; it must never break message handling, a
- * wake or a reply. The cost of a failure is a missed task update that the
- * next run can still recover from the persisted events, never a lost message.
- */
-import type { VisionClawConfig } from "../config/types.js";
-import { type CommandMessage } from "../channels/interface.js";
-import { type MessageQueue } from "../channels/queue.js";
-import { type TaskEventInput, type TaskStatus, type ThreadTask } from "./task-contracts.js";
-import { type SidecarModel } from "./task-sidecar.js";
-import { type ThreadTaskControllerOptions } from "./thread-task-controller.js";
-/**
- * How long a fast reply waits for the sidecar before it settles for
- * "received". Added in front of the fast responder's own 5 s budget.
- */
-export declare const REGISTRATION_WAIT_MS = 6000;
-/**
- * How long a lifecycle boundary waits for the sidecar to catch up (#1996 PR 4).
- * Wake end is short because the next message waits behind it; compaction,
- * refresh and handoff are already slow.
- */
-export declare const RECONCILE_WAIT_MS: {
-    readonly wakeEnd: 5000;
-    readonly handoff: 8000;
-    readonly boundary: 10000;
-};
-export type ReconcilePhase = "wake_end" | "handoff" | "compaction" | "refresh" | "stop";
-/** `meta.kind` of a queued resume (PR 5). A system row: no fast reply, watchdog or gate reply. */
-export declare const TASK_RESUME_KIND = "thread-task-resume";
-/** A resume pass waits for the sidecar to catch up; if it cannot, it retries after this. */
-export declare const RESUME_RETRY_MS = 60000;
-/** How the loop lets the runtime queue and start resumes. */
-export interface ResumeHooks {
-    queue: Pick<MessageQueue, "enqueue">;
-    /** A wake is running or work is queued; the end of that wake starts the next pass. */
-    isBusy: () => boolean;
-    /** Execution is stopped (service gate, league hold); the pass retries later. */
-    isGated: () => boolean;
-    /** Wake the loop after a resume was queued (works with proactive wake off). */
-    wake: () => void;
-}
-/** The queue, as `/stop` needs it: read and drop rows that are still pending. */
-export type StopQueue = Pick<MessageQueue, "snapshot" | "remove" | "markHandled">;
-/** What `/stop` did. */
-export interface StopOutcome {
-    /** Tasks moved to `cancelled`. */
-    cancelled: ThreadTask[];
-    /** Queued owner messages dropped before they could become tasks. */
-    droppedQueued: number;
-}
-/** What `close_thread_task` did: the closed task, or why it was refused. */
-export type CloseTaskOutcome = {
-    ok: true;
-    task: ThreadTask;
-} | {
-    ok: false;
-    reason: string;
-};
-/** What a resume pass did; for logs and tests. */
-export interface ResumeOutcome {
-    /** Resumes handed to the queue in this pass (new or re-sent reservations). */
-    queued: string[];
-}
-/** Where a reconcile left the consume position relative to its target. */
-export interface ReconcileOutcome {
-    reached: boolean;
-    /** Latest event seq when the boundary was hit. */
-    target: number;
-    position: number;
-}
-export interface ThreadTaskRuntimeOptions {
-    threadId: string;
-    /** Worker instance id in workers (same fence as the queue); a per-process id in the main process. */
-    writerId: string;
-    config: VisionClawConfig;
-    /** Overrides for tests. */
-    dbPath?: string;
-    model?: SidecarModel;
-    controller?: Partial<ThreadTaskControllerOptions>;
-}
-/** What a fast reply may claim about a batch of messages. */
-export interface RegistrationOutcome {
-    /** Every message's event is durable, so the request survives a crash. */
-    recorded: boolean;
-    /** Open tasks whose sources include one of the messages, after the sidecar ran. */
-    registered: ThreadTask[];
-}
-export declare class ThreadTaskRuntime {
-    readonly threadId: string;
-    private readonly store;
-    private readonly controller;
-    /**
-     * Latest event seq when this process started. A task whose last committed
-     * change came from events up to here was moved by a previous process.
-     */
-    private readonly startSeq;
-    /** Resumes this process accepted, by task id: a resume runs once per task per process. Released when its message goes back on the queue. */
-    private readonly resumesAccepted;
-    private closed;
-    private resumeHooks;
-    private resumeRetry;
-    private resumeRunning;
-    /** Do not schedule recovery while /stop folds evidence before cancellation. */
-    private stopRequests;
-    private constructor();
-    /**
-     * Open the thread's store next to its queue.db, take the writer slot and
-     * start the controller (which picks up events a previous process left).
-     * Returns null instead of throwing: without a runtime the agent runs
-     * exactly as before.
-     */
-    static start(options: ThreadTaskRuntimeOptions): ThreadTaskRuntime | null;
-    /**
-     * Persist owner messages as events. Idempotent per message (queue dedup
-     * key), so a redelivered message, the watchdog and the wake path can all
-     * call it. Returns false if any message could not be recorded.
-     */
-    recordMessages(messages: readonly CommandMessage[], options?: {
-        notify?: boolean;
-    }): boolean;
-    /** Persist an execution event (response, tool result, todo update, status report). */
-    recordExecution(input: TaskEventInput): void;
-    /**
-     * Record the messages, then wait up to `waitMs` for the sidecar to consume
-     * them. `registered` lists the open tasks the commit tied to these messages;
-     * empty means a reply may only acknowledge receipt.
-     *
-     * A run that started before these events cannot commit them (it snapshotted
-     * its batch), and a batch is a contiguous prefix, so the message may need
-     * more than one run: an execution-event backlog in front of it is folded
-     * first. The loop therefore waits for this message's events to be consumed,
-     * not for a single run, and stops as soon as the deadline passes or a run
-     * fails (the controller keeps retrying those events on its own schedule).
-     */
-    registerMessages(messages: readonly CommandMessage[], waitMs?: number): Promise<RegistrationOutcome>;
-    /** `close()` may run while a wait awaits; a method read is not narrowed away. */
-    private isClosed;
-    /** Open tasks already tied to any of these messages (no model call). */
-    tasksForMessages(messages: readonly CommandMessage[]): ThreadTask[];
-    /** Tasks of this thread for the query tool; `[]` on error. */
-    listTasks(statuses?: readonly TaskStatus[]): ThreadTask[];
-    /**
-     * Let the sidecar fold every event up to the latest one (the explicit
-     * position of this boundary), waiting at most `waitMs`. No events past the
-     * position means no model call. On timeout, budget exhaustion or failure
-     * the events simply stay unconsumed: the controller keeps retrying them,
-     * and {@link contextBlock} shows them raw to the next recovery.
-     */
-    reconcile(phase: ReconcilePhase, waitMs: number): Promise<ReconcileOutcome>;
-    /**
-     * Tasks a previous process left `in_progress`: their last change came from
-     * events recorded before this process started. That includes a task those
-     * events only move to `in_progress` when this process folds them at
-     * startup (the sidecar batches, so a crash usually leaves some). Once this
-     * process's own events move the task, it is no longer interrupted.
-     * TODO: a startup fold whose batch also holds events of this process
-     * stamps the task with the later seq and drops the flag early.
-     */
-    interruptedTaskIds(): Set<string>;
-    /** The recovery context for this thread, or null when it owes nothing. Never throws. */
-    contextBlock(): string | null;
-    /**
-     * Queue a resume for the next runnable task (PR 5), so the thread keeps
-     * working without a new owner message. Crash-safe in three steps:
-     * reserve the delivery record (`recovery:<task>:v<version>`), enqueue a
-     * system message whose id is that key, then mark it delivered. A crash
-     * before the enqueue leaves a reservation that the next pass re-sends; a
-     * crash after it is harmless because the queue dedups the id. A resume
-     * that was already delivered is never queued again for the same version.
-     *
-     * Never throws. Returns what it queued.
-     */
-    deliverResumes(queue: Pick<MessageQueue, "enqueue">, now?: number): ResumeOutcome;
-    /**
-     * Whether a dequeued resume may still run (the re-check before execution).
-     * Yes when its task is still pending at the version it was queued for and
-     * is due: a cancel, modification, wait or block since then makes it stale.
-     * Also yes, once per task per process, when a previous process left the
-     * task `in_progress` ({@link interruptedTaskIds}): that is a resume replayed
-     * after a crash, or one queued for the interrupted task. Its version is not
-     * compared, because folding the previous process's last events at startup
-     * bumps it.
-     *
-     * The "once" test is against {@link resumesAccepted}, which a requeue
-     * releases ({@link releaseResume}): an accepted resume whose message went
-     * back on the queue must still run when it is dequeued again, or the
-     * interrupted task keeps its only recovery row forever.
-     * Fail-closed: any error means no.
-     */
-    isResumeRunnable(msg: CommandMessage, now?: number): boolean;
-    /**
-     * The re-check at dequeue: {@link isResumeRunnable}, and if yes, record
-     * that this process is now working on the task so a second copy of its
-     * resume is stale.
-     */
-    acceptResume(msg: CommandMessage, now?: number): boolean;
-    /**
-     * The resume was accepted but its message went back on the queue (a failed
-     * inject, an orphaned injection, a failed wake). Takes the acceptance back
-     * so the next dequeue may run it. Safe for any message: not a resume, or
-     * never accepted, does nothing. #2664 review P1-B.
-     */
-    releaseResume(messages: readonly CommandMessage[]): void;
-    /** Install the loop's hooks. Resumes are only queued once this is set. */
-    enableResumes(hooks: ResumeHooks): void;
-    /**
-     * The owner sent `/stop` (option B, owner 10-04): cancel every unfinished
-     * task of this thread. Cancelled is a stored status, so nothing queued
-     * starts on its own, a restart cannot bring it back, and resumes already
-     * queued are retired at dequeue.
-     *
-     * Fold pre-stop events first (bounded by `waitMs`) so recorded completion
-     * evidence can close tasks before cancellation. Remaining open tasks and
-     * tasks created from messages just before `/stop` are then cancelled.
-     * Tasks from messages after the `/stop` are kept. Returns every
-     * cancelled task, for the reply. Never throws.
-     * TODO: a fold that misses `waitMs` (or more than {@link STOP_EVENTS}
-     * unfolded events) can still create a task from a pre-stop message later.
-     */
-    cancelOpenTasks(waitMs?: number, queue?: StopQueue): Promise<StopOutcome>;
-    private cancelOpenTasksAtStop;
-    /**
-     * Drop queued owner messages: rows not claimed by a wake, that are not
-     * system rows (a resume, or the stop command itself) and that the task
-     * sidecar would read as owner input. Returns how many were dropped.
-     * Fail-safe: a row that cannot be read is left alone.
-     */
-    private dropQueuedMessages;
-    /**
-     * Commit `cancelled` for these tasks without consuming any event, so the
-     * sidecar still folds everything. Read and commit run in one synchronous
-     * stretch, so no sidecar commit lands between them; a sidecar call in
-     * flight hits a version conflict and re-reads.
-     */
-    private cancelTasks;
-    /**
-     * Close one open task of this thread for the agent's `close_thread_task`
-     * tool (#2822). The sidecar completes a task only with evidence from the
-     * batch it folds, so finished work it missed stayed open and kept being
-     * resumed; this is the explicit way out. Commits like {@link cancelTasks}:
-     * no event is consumed, and a sidecar call in flight hits a version
-     * conflict and re-reads. Never throws.
-     */
-    closeTask(input: {
-        taskId: string;
-        status: "completed" | "cancelled";
-        summary: string;
-        evidenceRef: string;
-    }): CloseTaskOutcome;
-    /**
-     * Fold the events up to now, then queue the next runnable task. Called at
-     * wake end and at startup; never throws and never blocks the caller's
-     * loop. Without the fold a task the wake just finished could still look
-     * pending, so a pass that cannot catch up delivers nothing and retries
-     * after {@link RESUME_RETRY_MS} instead. A fold that needs a slow sidecar
-     * call therefore starts the next task about a minute later, not at once.
-     */
-    requestResume(waitMs?: number): Promise<ResumeOutcome>;
-    private scheduleResumeRetry;
-    private clearResumeRetry;
-    /** Enqueue one reserved resume and mark it delivered. False when nothing was handed over. */
-    private enqueueResume;
-    /** Events not yet folded into tasks (the sidecar is behind or failing). */
-    pendingEventCount(): number;
-    close(graceMs?: number): Promise<void>;
-    private safeNotify;
-}
-/**
- * A task whose checkpoint lists nothing remaining and no blockers: the work
- * is done but the sidecar did not complete it (no evidence in its batch).
- * Resuming it only wakes the agent to find nothing to do (#2822). A task
- * with no checkpoint yet has not been worked on, so it still resumes.
- * TODO: a checkpoint that empties `remaining` too early stops auto-resume;
- * the task stays open and visible in the context block.
- */
-export declare function hasNoRemainingWork(task: Pick<ThreadTask, "checkpoint">): boolean;
-/** True for a queued thread-task resume row. */
-export declare function isTaskResumeMessage(msg: CommandMessage): boolean;
-/**
- * The re-check before execution, at every place a wake takes rows off the
- * queue: a resume whose task was cancelled, changed, put on hold or already
- * started since it was queued is retired unexecuted. Without a runtime (the
- * switch was turned off) every resume is stale. Returns true when retired.
- */
-export declare function retireStaleResume(queue: Pick<MessageQueue, "markHandled">, runtime: ThreadTaskRuntime | null, msg: CommandMessage): boolean;
-/**
- * Messages the task store tracks: anything from a real channel. System
- * messages (heartbeats, internal continuations) and external-wake markers
- * carry no owner request. Email and group chats are included; the sidecar
- * decides whether they hold a request.
- */
-export declare function isTaskRelevantMessage(msg: CommandMessage): boolean;
-/**
- * The end-of-wake handoff (issue #1996 PR 1 rule): a claim is released as
- * handled only after its message is a durable task event, so the follow-up
- * belongs to the task store instead of vanishing with the queue row.
- *
- * Fail-safe: if recording fails the claims are still released. The agent
- * already processed them in this wake; replaying them would redo the work.
- * The error is logged. `handled` never means a task is completed.
- */
-export declare function releaseClaimsAfterRecording(queue: Pick<MessageQueue, "currentCycleClaims" | "markAllInFlightHandled">, runtime: ThreadTaskRuntime | null): void;
-/**
- * Wake end. A wake cut short by an engine failover restart leaves its claims
- * in flight for the replacement process (issue #2519) and folds nothing.
- * Otherwise release the claims, fold this wake's events into the
- * checkpoints and queue the next runnable task (PR 5). Not awaited: the
- * session keeps its transcript, so the loop need not hold the next message
- * for it. Bounded; leftovers stay unconsumed and the next wake's context
- * shows them raw.
- */
-export declare function endWakeThreadTasks(queue: Pick<MessageQueue, "currentCycleClaims" | "markAllInFlightHandled">, runtime: ThreadTaskRuntime | null, options: {
-    failoverRestartPending: boolean;
-}): void;
-/**
- * Engine-neutral execution events. Both engines feed the same stream
- * handler, so these are called from there. Each id is unique per call, so
- * keys never collide across wakes or retries.
- */
-export declare const executionEvents: {
-    toolResult(toolUseId: string, toolName: string, output: string, isError: boolean): TaskEventInput | null;
-    todos(toolUseId: string, todos: readonly {
-        content: string;
-        status: string;
-    }[]): TaskEventInput | null;
-    response(turnId: string, text: string): TaskEventInput | null;
-    /** What the agent told the owner through notify_user: an explicit status report. */
-    statusReport(toolUseId: string, message: string): TaskEventInput | null;
-};
-/**
- * The fast responder's reading of a batch, as one candidate event. It shares
- * the message's dedup key, so the sidecar's origin key matches the message's
- * and the same task is never created twice. Only for a single-message batch:
- * a brief over several messages cannot be keyed to the right one, and the
- * messages themselves are already events.
- */
-export declare function fastResponderCandidate(messages: readonly CommandMessage[], brief: unknown): TaskEventInput | null;
-/** Record the fast responder's brief as a candidate event. Never throws. */
-export declare function recordFastResponderCandidate(messages: readonly CommandMessage[], brief: unknown): void;
-/** Record an execution event on the process runtime, if there is one. Never throws. */
-export declare function recordExecutionEvent(input: TaskEventInput | null): void;
-/** The process runtime's recovery context, or null without a runtime (then nothing is injected). */
-export declare function buildThreadTaskContext(): string | null;
-/** Bounded reconcile on the process runtime; resolves immediately without one. */
-export declare function reconcileThreadTasks(phase: ReconcilePhase, waitMs?: number): Promise<void>;
-export declare function setThreadTaskRuntime(runtime: ThreadTaskRuntime | null): void;
-export declare function getThreadTaskRuntime(): ThreadTaskRuntime | null;
-//# sourceMappingURL=thread-task-runtime.d.ts.map

package/dist/threads/thread-task-runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"thread-task-runtime.d.ts","sourceRoot":"","sources":["../../src/threads/thread-task-runtime.ts"],"names":[],"mappings":"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"}