@ricsam/r5d-worker 0.0.107 → 0.0.109

package/dist/types/plan-lint.d.ts

@@ -0,0 +1,16 @@
+export interface PlanLintError {
+    planId: string;
+    message: string;
+    severity: "warning" | "error";
+    line?: number;
+}
+export interface PlanLintResult {
+    type: "plan_lint";
+    errors: PlanLintError[];
+    errorCount: number;
+    warningCount: number;
+    lintedPlanCount: number;
+}
+export declare function lintPlanContent(planId: string, content: string): PlanLintError[];
+export declare function lintPlans(plansDir: string, glob?: string): Promise<PlanLintResult>;
+export declare function formatPlanLintErrors(errors: PlanLintError[]): string;

package/dist/types/plan-parser.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Markdown plan parser.
+ *
+ * Plans are plain Markdown files. The only structured region is the first
+ * "## Tasks" section, which contains checkbox task lines.
+ */
+export declare const PLAN_TASK_ID_REGEX: RegExp;
+export declare const PLAN_TASK_LINE_REGEX: RegExp;
+export declare const PLAN_TASKS_HEADING_REGEX: RegExp;
+export interface PlanTask {
+    id: string;
+    description: string;
+    checked: boolean;
+    lineNumber: number;
+}
+export interface ParsedPlan {
+    id: string;
+    title: string;
+    content: string;
+    tasks: PlanTask[];
+    currentTask: PlanTask | null;
+    complete: boolean;
+    tasksStartLine: number | null;
+    tasksEndLine: number | null;
+}
+export type ParsedMarkdownPlan = ParsedPlan;
+export declare function getPlanMetadata(content: string): {
+    title: string;
+};
+export declare function getTasksSectionRange(content: string): {
+    startIndex: number;
+    endIndex: number;
+} | null;
+export declare function parseMarkdownPlan(content: string, planId: string): ParsedPlan;
+export declare const parsePlan: typeof parseMarkdownPlan;
+export declare function createPlanMarkdown(planId: string, title?: string): string;
+export declare function updateTaskCheckbox(content: string, taskId: string, checked: boolean): string;
+export declare function formatPlanTitle(planId: string): string;

package/dist/types/plan-paths.d.ts

@@ -0,0 +1,36 @@
+type PlanTarget = {
+    type: "project";
+} | {
+    type: "workspace";
+    rootProfile: "visible_projects" | "canonical_sync";
+};
+export declare const PLAN_EXTENSION = ".plan.md";
+export declare function validatePlanId(planId: string): void;
+export declare function assertPlanTarget(target: PlanTarget): void;
+export declare function getWorkerPlansPath(target: PlanTarget): string;
+/** The same worker path is used in prompts, injected reads, and file tools. */
+export declare function getWorkerPlanPath(target: PlanTarget, planId: string): string;
+export type WorkerReadPlanInput = {
+    planId: string;
+    createIfMissing: boolean;
+};
+export type WorkerLintPlansInput = {
+    glob?: string;
+};
+export type WorkerUpdatePlanTaskInput = {
+    planId: string;
+    taskId: string;
+    checked: boolean;
+};
+export type WorkerLintPlansResult = {
+    type: "lint_plans";
+    content: string;
+};
+export type WorkerUpdatePlanTaskResult = {
+    type: "update_task_status";
+    planId: string;
+    taskId: string;
+    checked: boolean;
+    message: string;
+};
+export {};

package/dist/types/recovery-output-window.d.ts

@@ -0,0 +1,19 @@
+import type { WorkerOutputOffsets } from "./recovery-protocol";
+export type WorkerOutputFrame = {
+    type: "exec_output";
+    runId: string;
+    stream: "stdout" | "stderr";
+    offset: number;
+    data: string;
+};
+/** Bound outstanding application bytes, including data already buffered by the server's socket. */
+export declare class WorkerOutputWindow {
+    private readonly windowBytes;
+    private sent;
+    private acknowledged;
+    private outstanding;
+    constructor(windowBytes?: number);
+    reset(cursors: WorkerOutputOffsets[]): void;
+    send(frame: WorkerOutputFrame, send: (frame: WorkerOutputFrame) => boolean, bufferedAmount?: number): boolean;
+    acknowledge(runId: string, stream: "stdout" | "stderr", offset: number): void;
+}

package/dist/types/recovery-protocol.d.ts

@@ -0,0 +1,59 @@
+/** The application protocol survives replacement of its WebSocket transport. */
+export declare const WORKER_RESUMABLE_PROTOCOL: 1;
+export declare const WORKER_RECOVERY_TIMEOUT_MS: number;
+export type WorkerOperationRecovery = {
+    requestId: string;
+    runId?: string;
+    sessionId?: string;
+    requestType?: string;
+    state: "accepted" | "preparing" | "running" | "completed" | "unknown";
+};
+export type WorkerOutputOffsets = {
+    runId: string;
+    stdoutBytes: number;
+    stderrBytes: number;
+};
+export type WorkerRecoveryServerMessage = {
+    type: "recovery_request";
+    recoveryId: string;
+    requests: string[];
+    outputOffsets: WorkerOutputOffsets[];
+} | {
+    type: "recovery_ready";
+    recoveryId: string;
+    leaseMs: number;
+} | {
+    type: "operation_result_ack";
+    requestId: string;
+} | {
+    type: "exec_output_ack";
+    runId: string;
+    stream: "stdout" | "stderr";
+    nextOffset: number;
+} | {
+    type: "worker_execution_lease";
+    leaseMs: number;
+} | {
+    type: "cancel_session";
+    sessionId: string;
+    cancellationId: string;
+};
+export type WorkerRecoveryClientMessage = {
+    type: "recovery_state";
+    recoveryId: string;
+    runtimeId: string;
+    ledgerId: string;
+    operations: WorkerOperationRecovery[];
+} | {
+    type: "recovery_complete";
+    recoveryId: string;
+} | {
+    type: "operation_received";
+    requestId: string;
+} | {
+    type: "operation_completed";
+    requestId: string;
+} | {
+    type: "cancel_session_ack";
+    cancellationId: string;
+};

package/dist/types/recovery-store.d.ts

@@ -0,0 +1,38 @@
+import type { WorkerOperationRecovery, WorkerOutputOffsets } from "./recovery-protocol";
+type Message = {
+    type: string;
+    [key: string]: unknown;
+};
+/** Stable semantic identity, independent of JSON key order and transport request aliases. */
+export declare function workerOperationDigest(message: Message): string;
+/** The receipt is committed before a handler can mutate anything. Unknown crash outcomes never replay effects. */
+export declare class WorkerRecoveryStore {
+    private readonly db;
+    readonly ledgerId: string;
+    constructor(filename: string);
+    close(): void;
+    private row;
+    admit(message: Message & {
+        requestId: string;
+    }): "new" | "duplicate" | "unknown" | "conflict";
+    isUnknown(requestId: string): boolean;
+    unknown(requestId: string): void;
+    unknownRun(runId: string): void;
+    record(message: Message): Message;
+    operations(): WorkerOperationRecovery[];
+    response(requestId: string): Message | undefined;
+    responses(requestIds: string[]): Message[];
+    lengths(runId: string): {
+        stdoutBytes: number;
+        stderrBytes: number;
+    };
+    outputCursors(): WorkerOutputOffsets[];
+    output(offsets?: WorkerOutputOffsets[]): Generator<Message>;
+    terminals(): Message[];
+    acknowledgeOutput(runId: string, stream: "stdout" | "stderr", offset: number): void;
+    acknowledgeResult(requestId: string): void;
+    acknowledgeTerminal(runId: string): void;
+    cancelSession(sessionId: string): void;
+    isRequestCancelled(requestId: string): boolean;
+}
+export {};

package/dist/types/supervisor.d.ts

@@ -5,6 +5,7 @@ export declare const WORKER_RECONNECT_EXIT_CODE = 76;
 export declare const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
 export declare const WORKER_RECONNECT_DELAY_MS = 2000;
 export declare const WORKER_RECONNECT_JITTER_MS = 3000;
+export declare const WORKER_RECONNECT_MAX_DELAY_MS = 30000;
 type RuntimeProcess = KillableSubprocess;
 export type RuntimeSpawner = (argv: string[], options: {
     stdin: "inherit";
@@ -16,7 +17,7 @@ export type RuntimeSpawner = (argv: string[], options: {
 export type RuntimeDelay = (delayMs: number) => Promise<void>;
 export type RuntimeReaper = (runtime: RuntimeProcess) => Promise<void>;
 export type RuntimeReconnectDelay = () => number;
-export declare function workerReconnectDelayMs(random?: () => number): number;
+export declare function workerReconnectDelayMs(random?: () => number, attempt?: number): number;
 export declare function isRetryableWorkerServerStatus(status: number): boolean;
 export declare function superviseWorkerRuntime(argv: string[], env?: Record<string, string | undefined>, spawnRuntime?: RuntimeSpawner, waitBeforeReconnect?: RuntimeDelay, reapCredentialRuntime?: RuntimeReaper, reconnectDelay?: RuntimeReconnectDelay): Promise<number>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.107",
+  "version": "0.0.109",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,8 @@
     "r5d-worker": "dist/cjs/main.cjs"
   },
   "dependencies": {
-    "node-pty": "^1.1.0"
+    "node-pty": "^1.1.0",
+    "picomatch": "^4.0.3"
   },
   "files": [
     "dist",