@kici-dev/orchestrator 0.1.14 → 0.1.16

package/dist/stale-detector/stale-run-detector.d.ts

@@ -23,6 +23,8 @@ import type { ScalerManager } from '../scaler/manager.js';
 import type { Dispatcher } from '../agent/dispatcher.js';
 import type { AgentRegistry } from '../agent/registry.js';
 import type { HeldRunStore } from '../environments/held-runs.js';
+import type { StepApprovalBridge } from '../approvals/step-approval-bridge.js';
+import type { AccessLogWriter } from '../audit/access-log.js';
 export interface StaleRunDetectorDeps {
     db: Kysely<Database>;
     executionTracker: ExecutionTracker;
@@ -36,6 +38,12 @@ export interface StaleRunDetectorDeps {
     scanIntervalMs: number;
     /** Held run store for expiring overdue held runs. Optional -- if not set, held run cleanup is skipped. */
     heldRunStore?: HeldRunStore;
+    /** Step-approval bridge — notified when a step-scoped hold expires so the waiting agent fails the step. Optional. */
+    stepApprovalBridge?: StepApprovalBridge;
+    /** Fail a whole run when a job/workflow-scoped approval hold expires. Optional. */
+    failRun?: (runId: string, reason: string) => Promise<void>;
+    /** Access-log writer for the orchestrator audit stream. Optional -- if not set, expiry audit rows (`held_run.expire`) are skipped. */
+    accessLogWriter?: AccessLogWriter;
 }
 export declare class StaleRunDetector {
     private readonly db;
@@ -47,8 +55,18 @@ export declare class StaleRunDetector {
     private readonly staleThresholdMs;
     private readonly scanIntervalMs;
     private readonly heldRunStore?;
+    private readonly stepApprovalBridge?;
+    private readonly failRun?;
+    private readonly accessLogWriter?;
     private interval;
     constructor(deps: StaleRunDetectorDeps);
+    /**
+     * Expire overdue approval holds. Routes each overdue hold by scope BEFORE the
+     * bulk status flip: step-scoped holds notify the waiting agent (which fails
+     * the step), job/workflow-scoped holds fail the whole run. Then the bulk
+     * `expireOverdue()` flips every overdue row to `expired`.
+     */
+    private expireOverdueHolds;
     /**
      * Clean up orphaned jobs left in 'recovering' state from a previous orchestrator instance.
      *

package/dist/stale-detector/workflow-deadline-detector.d.ts

@@ -0,0 +1,49 @@
+/**
+ * WorkflowDeadlineDetector: periodic DB scanner enforcing the workflow-level
+ * run deadline.
+ *
+ * A workflow `timeout` caps the whole run's wall-clock across all jobs.
+ * Because jobs span multiple agents, the cap is a run-level deadline owned by
+ * the orchestrator. This scanner finds non-terminal runs whose
+ * `started_at + workflow_timeout_ms` has passed and cancels them through the
+ * canonical run-cancel path, recording the distinct
+ * TimeoutReason.workflow_timeout so the dashboard labels the run "timed out"
+ * rather than a generic cancel.
+ */
+import { type Kysely } from 'kysely';
+import type { Database } from '../db/types.js';
+import type { JobQueue } from '../queue/job-queue.js';
+export interface WorkflowDeadlineDetectorDeps {
+    db: Kysely<Database>;
+    /**
+     * Canonical "cancel this whole run with a reason" callback — the same
+     * implementation the user-initiated `kici cancel` route uses
+     * (cancelRunWithReason bound to the orchestrator's deps).
+     */
+    cancelRun: (runId: string, reason: string) => Promise<unknown>;
+    jobQueue: JobQueue;
+    /** How often to scan in ms. Default supplied by the caller (reuses the stale-detector interval). */
+    scanIntervalMs: number;
+}
+export declare class WorkflowDeadlineDetector {
+    private readonly db;
+    private readonly cancelRun;
+    private readonly jobQueue;
+    private readonly scanIntervalMs;
+    private interval;
+    constructor(deps: WorkflowDeadlineDetectorDeps);
+    /**
+     * Start the detector: an immediate scan (crash recovery — catch runs that
+     * blew their deadline while the orchestrator was down), then periodic scans.
+     */
+    start(): Promise<void>;
+    stop(): void;
+    /**
+     * Run a single deadline scan: find non-terminal runs with a configured
+     * workflow timeout whose `started_at + workflow_timeout_ms` has passed and
+     * cancel each one.
+     */
+    scan(): Promise<void>;
+    private cancelOverdueRun;
+}
+//# sourceMappingURL=workflow-deadline-detector.d.ts.map