@aitne/daemon 0.1.2 → 0.1.4

package/dist/services/delegated-backend-invoker.js

@@ -1,5 +1,5 @@
-import { createHash, randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { filterDeniedToolsForBackend, getAgentDayDateStr, } from "@aitne/shared";
 import { createLogger } from "../logging.js";
@@ -11,6 +11,9 @@ import { buildRetryFollowup, buildTaskPrompt, classifyStructuredOutput, compileS
 import { DelegatedTaskResultCache, execScope, integrationVersionFor, runScope, } from "./delegated-task-result-cache.js";
 import { DelegatedTaskSessionPool, SESSION_POOL_TEMPDIR_PREFIX, } from "./delegated-task-session-pool.js";
 import { readRuntimeState, writeRuntimeState, } from "../db/runtime-state.js";
+import { LegacyOneShotLease, mergeCost, readFileSyncIfExists, stripCodeFences, zeroCost, } from "./delegated-invoker-utils.js";
+import { completeTaskHeader, recordAction, recordTaskHeaderInProgress, recordTaskToolStep, } from "./delegated-invoker-audit.js";
+import { buildCacheHitRunResult, buildCacheHitTaskResult, } from "./delegated-invoker-cache-hits.js";
 const logger = createLogger("delegated-proxy-invoker");
 export class DelegatedBackendInvoker {
     deps;
@@ -174,7 +177,7 @@ export class DelegatedBackendInvoker {
             // Queue saturation — surfaces as 503 in the route handler. Don't
             // create a tempdir, don't materialize anything. Cost row is still
             // written (zero-cost) so the dashboard sees a saturation event.
-            this.recordAction({
+            recordAction(this.deps.db, {
                 backendId: fastCheck.backendId,
                 modelId: fastCheck.modelId,
                 params,
@@ -205,7 +208,7 @@ export class DelegatedBackendInvoker {
             this.releasePermit();
             const nowIso = new Date(this.now()).toISOString();
             const message = `integration state changed during queue wait: ${liveCheck.message}`;
-            this.recordAction({
+            recordAction(this.deps.db, {
                 backendId: liveCheck.backendId ?? fastCheck.backendId,
                 modelId: fastCheck.modelId,
                 params,
@@ -294,7 +297,7 @@ export class DelegatedBackendInvoker {
         }
         const completedAtIso = new Date(this.now()).toISOString();
         if (unimplemented) {
-            this.recordAction({
+            recordAction(this.deps.db, {
                 backendId,
                 modelId,
                 params,
@@ -314,7 +317,7 @@ export class DelegatedBackendInvoker {
             };
         }
         if (unhandledMessage !== null) {
-            this.recordAction({
+            recordAction(this.deps.db, {
                 backendId,
                 modelId,
                 params,
@@ -336,7 +339,7 @@ export class DelegatedBackendInvoker {
         if (!toolResult) {
             // Defensive: should not happen unless runDelegatedTool resolved with
             // null/undefined, which violates the contract.
-            this.recordAction({
+            recordAction(this.deps.db, {
                 backendId,
                 modelId,
                 params,
@@ -356,7 +359,7 @@ export class DelegatedBackendInvoker {
             };
         }
         if (toolResult.ok) {
-            this.recordAction({
+            recordAction(this.deps.db, {
                 backendId,
                 modelId,
                 params,
@@ -373,7 +376,7 @@ export class DelegatedBackendInvoker {
                 modelId,
             };
         }
-        this.recordAction({
+        recordAction(this.deps.db, {
             backendId,
             modelId,
             params,
@@ -403,10 +406,17 @@ export class DelegatedBackendInvoker {
      */
     resolvePreconditions(integrationKey, modelOverride) {
         const state = readIntegrations(this.deps.db)[integrationKey];
+        // INTEGRATION_NATIVE_MODE_DESIGN.md §17 (Phase B1 file list) — the
+        // invoker must defensively reject every non-delegated mode, including
+        // the new `native` mode. A flip from delegated to native during a
+        // queued task would otherwise resolve through this path with stale
+        // state; failing here forces the caller to re-route through the
+        // native MCP surface (§3.3 invariant: native MUST NOT call the
+        // daemon proxy).
         if (!state || state.mode !== "delegated" || !state.delegatedBackend) {
             return {
                 ok: false,
-                message: `integration '${integrationKey}' is not in delegated mode (mode=${state?.mode ?? "missing"}, delegatedBackend=${state?.delegatedBackend ?? "null"})`,
+                message: `integration '${integrationKey}' is not in delegated mode (mode=${state?.mode ?? "missing"}, delegatedBackend=${state?.delegatedBackend ?? "null"}, nativeBackend=${state?.nativeBackend ?? "null"})`,
             };
         }
         const backendId = state.delegatedBackend;
@@ -518,57 +528,13 @@ export class DelegatedBackendInvoker {
         mkdirSync(dirname(target), { recursive: true });
         writeFileSync(target, body, "utf-8");
     }
-    // ── Cost / agent_actions persistence ────────────────────────────────────
-    recordAction(args) {
-        const detail = {
-            integrationKey: args.params.integrationKey,
-            toolName: args.params.toolName,
-            toolArgsHash: hashArgs(args.params.toolArgs),
-            ...(args.errorClass ? { errorClass: args.errorClass } : {}),
-        };
-        try {
-            this.deps.db
-                .prepare(
-            // datetime(@started_at) coerces ISO-8601 input into SQLite's
-            // canonical 'YYYY-MM-DD HH:MM:SS' so this row sorts correctly
-            // alongside rows written via datetime('now') elsewhere — without
-            // it, mixed formats break ORDER BY started_at.
-            `INSERT INTO agent_actions (
-             event_id, action_type, trigger, model_used,
-             cost_usd, tokens_input, tokens_output,
-             cache_creation_tokens, cache_read_tokens,
-             duration_ms, num_turns, result, detail,
-             started_at, completed_at, error, backend, cost_source
-           ) VALUES (
-             @event_id, 'delegated_proxy.invoke', @trigger, @model_used,
-             @cost_usd, @tokens_input, @tokens_output,
-             @cache_creation_tokens, @cache_read_tokens,
-             @duration_ms, @num_turns, @result, @detail,
-             datetime(@started_at), datetime(@completed_at), @error, @backend, 'sdk'
-           )`)
-                .run({
-                event_id: args.params.parentEventId ?? null,
-                trigger: args.params.parentProcessKey ?? null,
-                model_used: args.modelId,
-                cost_usd: args.cost.costUsd,
-                tokens_input: args.cost.tokensInput,
-                tokens_output: args.cost.tokensOutput,
-                cache_creation_tokens: args.cost.cacheCreationTokens,
-                cache_read_tokens: args.cost.cacheReadTokens,
-                duration_ms: args.cost.durationMs,
-                num_turns: args.cost.numTurns,
-                result: args.result,
-                detail: JSON.stringify(detail),
-                started_at: args.startedAt,
-                completed_at: args.completedAt,
-                error: args.errorMessage ?? null,
-                backend: args.backendId,
-            });
-        }
-        catch (err) {
-            logger.error({ err, integrationKey: args.params.integrationKey }, "failed to record delegated_proxy.invoke action");
-        }
-    }
+    // The five `agent_actions` row-writers (recordAction,
+    // recordCacheHitAuditRow, recordTaskHeaderInProgress, completeTaskHeader,
+    // recordTaskToolStep) live in `delegated-invoker-audit.ts`; the two
+    // cache-hit result builders (buildCacheHitTaskResult /
+    // buildCacheHitRunResult) live in `delegated-invoker-cache-hits.ts`.
+    // Call sites pass `this.deps.db` and `this.now` explicitly — see
+    // file-split-plan.md §9.
     // ── Model resolution ────────────────────────────────────────────────────
     resolveModel(state, integrationKey, backendId, modelOverride) {
         // Caller-side override (cadence path passes medium tier — see
@@ -701,11 +667,12 @@ export class DelegatedBackendInvoker {
                 };
                 const hit = cache.get(cacheKey);
                 if (hit) {
-                    return this.buildCacheHitTaskResult({
+                    return buildCacheHitTaskResult(this.deps.db, {
                         params,
                         hit,
                         backendId: fastCheck.backendId,
                         modelId: fastCheck.modelId,
+                        now: this.now,
                     });
                 }
             }
@@ -823,7 +790,7 @@ export class DelegatedBackendInvoker {
         const taskHash = hashTaskArgs(params.task);
         const schemaHash = hashTaskArgs(params.outputSchema);
         // §11.1 — write header row BEFORE spawn so step rows can FK to its id.
-        const headerId = this.recordTaskHeaderInProgress({
+        const headerId = recordTaskHeaderInProgress(this.deps.db, {
             actionType: "delegated_task.exec",
             backendId,
             modelId,
@@ -913,7 +880,7 @@ export class DelegatedBackendInvoker {
                         structuredOutputEnabled,
                         ...(wrappedSchema ? { wrappedSchema } : {}),
                         onToolStep: (step) => {
-                            this.recordTaskToolStep({
+                            recordTaskToolStep(this.deps.db, {
                                 parentTaskActionId: headerId,
                                 backendId,
                                 modelId,
@@ -1224,7 +1191,7 @@ export class DelegatedBackendInvoker {
             }
         }
         // §11.1 — finalise the header row.
-        this.completeTaskHeader({
+        completeTaskHeader(this.deps.db, {
             headerId,
             result: outcome?.ok ? "success" : "failed",
             cost: aggregatedCost,
@@ -1282,56 +1249,6 @@ export class DelegatedBackendInvoker {
         }
         return outcome;
     }
-    /**
-     * §13 Phase 3.3 — synthesize a `TaskInvokeResult` from a cache hit and
-     * write the corresponding `delegated_task.exec` audit row with cost 0
-     * and `detail.cacheHit=true`. Cache hits do not consume the per-day
-     * quota (the quota counts subprocess invocations) and do not acquire a
-     * concurrency permit (looked up before `acquirePermit`).
-     */
-    buildCacheHitTaskResult(args) {
-        const nowIso = new Date(this.now()).toISOString();
-        const taskHash = hashTaskArgs(args.params.task);
-        const schemaHash = hashTaskArgs(args.params.outputSchema);
-        this.recordCacheHitAuditRow({
-            actionType: "delegated_task.exec",
-            backendId: args.backendId,
-            modelId: args.modelId,
-            ...(args.params.parentEventId !== undefined
-                ? { parentEventId: args.params.parentEventId }
-                : {}),
-            ...(args.params.parentProcessKey !== undefined
-                ? { parentProcessKey: args.params.parentProcessKey }
-                : {}),
-            timestamp: nowIso,
-            toolCallCount: args.hit.trace.length,
-            detail: {
-                integrationKey: args.params.integrationKey,
-                delegatedBackend: args.backendId,
-                taskHash,
-                schemaHash,
-                cacheHit: true,
-                toolCallCount: args.hit.trace.length,
-                retried: false,
-                // §11.2 — cache hits are gated on the original outcome being
-                // non-confirmation (see Phase 3.3 cache guard); record this
-                // explicitly so the metric aggregator's schema stays uniform
-                // across live + cache-hit rows.
-                needsConfirmation: false,
-            },
-        });
-        return {
-            ok: true,
-            result: args.hit.result,
-            needsConfirmation: false,
-            confirmationPlan: null,
-            cost: zeroCost(),
-            trace: args.hit.trace,
-            backendId: args.backendId,
-            modelId: args.modelId,
-            retried: false,
-        };
-    }
     /**
      * DELEGATED-TASK-MODE-DESIGN.md §4.2 — Phase 2 generic task mode.
      * Mirror of `task()` but with no `integrationKey`: the caller pins
@@ -1422,11 +1339,12 @@ export class DelegatedBackendInvoker {
                 };
                 const hit = cache.get(cacheKey);
                 if (hit) {
-                    return this.buildCacheHitRunResult({
+                    return buildCacheHitRunResult(this.deps.db, {
                         params,
                         hit,
                         backendId,
                         modelId: runModelId,
+                        now: this.now,
                     });
                 }
             }
@@ -1517,7 +1435,7 @@ export class DelegatedBackendInvoker {
         const schemaHash = hashTaskArgs(params.outputSchema);
         const allowedToolsHash = hashTaskArgs(allowedTools);
         // §11.1 — header row BEFORE spawn so step rows can FK to it.
-        const headerId = this.recordTaskHeaderInProgress({
+        const headerId = recordTaskHeaderInProgress(this.deps.db, {
             actionType: "delegated_task.run",
             backendId,
             modelId,
@@ -1594,7 +1512,7 @@ export class DelegatedBackendInvoker {
                         structuredOutputEnabled,
                         ...(wrappedSchema ? { wrappedSchema } : {}),
                         onToolStep: (step) => {
-                            this.recordTaskToolStep({
+                            recordTaskToolStep(this.deps.db, {
                                 parentTaskActionId: headerId,
                                 backendId,
                                 modelId,
@@ -1873,7 +1791,7 @@ export class DelegatedBackendInvoker {
             }
         }
         // §11.1 — finalise the header row.
-        this.completeTaskHeader({
+        completeTaskHeader(this.deps.db, {
             headerId,
             result: outcome?.ok ? "success" : "failed",
             cost: aggregatedCost,
@@ -1925,52 +1843,6 @@ export class DelegatedBackendInvoker {
         }
         return outcome;
     }
-    /**
-     * §13 Phase 3.3 — cache-hit synthesizer for `/run`. Same shape as
-     * `buildCacheHitTaskResult` but writes a `delegated_task.run` audit row.
-     */
-    buildCacheHitRunResult(args) {
-        const nowIso = new Date(this.now()).toISOString();
-        const taskHash = hashTaskArgs(args.params.task);
-        const schemaHash = hashTaskArgs(args.params.outputSchema);
-        const allowedToolsHash = hashTaskArgs(args.params.allowedTools);
-        this.recordCacheHitAuditRow({
-            actionType: "delegated_task.run",
-            backendId: args.backendId,
-            modelId: args.modelId,
-            ...(args.params.parentEventId !== undefined
-                ? { parentEventId: args.params.parentEventId }
-                : {}),
-            ...(args.params.parentProcessKey !== undefined
-                ? { parentProcessKey: args.params.parentProcessKey }
-                : {}),
-            timestamp: nowIso,
-            toolCallCount: args.hit.trace.length,
-            detail: {
-                delegatedBackend: args.backendId,
-                taskHash,
-                schemaHash,
-                allowedToolsHash,
-                allowedToolsCount: args.params.allowedTools.length,
-                cacheHit: true,
-                toolCallCount: args.hit.trace.length,
-                retried: false,
-                // §11.2 — see /exec equivalent.
-                needsConfirmation: false,
-            },
-        });
-        return {
-            ok: true,
-            result: args.hit.result,
-            needsConfirmation: false,
-            confirmationPlan: null,
-            cost: zeroCost(),
-            trace: args.hit.trace,
-            backendId: args.backendId,
-            modelId: args.modelId,
-            retried: false,
-        };
-    }
     /**
      * Resolve the model for a task-mode call.
      *
@@ -2039,181 +1911,6 @@ export class DelegatedBackendInvoker {
             logger.warn({ err }, "failed to increment delegated task quota counter");
         }
     }
-    // ── agent_actions header / step persistence ───────────────────────────────
-    /**
-     * §13 Phase 3.3 — single-shot INSERT for cache-hit audit rows. Cache
-     * hits don't go through the in-progress → complete two-step lifecycle
-     * (the outcome is known synchronously), so this writes one row with
-     * `result='success'`, `cost_usd=0`, `cost_source='cache'` for clean
-     * dashboard cost-source filtering.
-     */
-    recordCacheHitAuditRow(args) {
-        try {
-            const result = this.deps.db
-                .prepare(`INSERT INTO agent_actions (
-             event_id, action_type, trigger, model_used,
-             cost_usd, tokens_input, tokens_output,
-             cache_creation_tokens, cache_read_tokens,
-             duration_ms, num_turns, result, detail,
-             started_at, completed_at, error, backend, cost_source
-           ) VALUES (
-             @event_id, @action_type, @trigger, @model_used,
-             0, 0, 0, 0, 0,
-             0, @num_turns, 'success', @detail,
-             datetime(@ts), datetime(@ts), NULL, @backend, 'cache'
-           )`)
-                .run({
-                event_id: args.parentEventId ?? null,
-                action_type: args.actionType,
-                trigger: args.parentProcessKey ?? null,
-                model_used: args.modelId,
-                num_turns: args.toolCallCount,
-                detail: JSON.stringify(args.detail),
-                ts: args.timestamp,
-                backend: args.backendId,
-            });
-            return Number(result.lastInsertRowid);
-        }
-        catch (err) {
-            logger.error({ err, actionType: args.actionType, detail: args.detail }, "failed to write delegated_task cache-hit audit row");
-            return -1;
-        }
-    }
-    recordTaskHeaderInProgress(args) {
-        try {
-            const result = this.deps.db
-                .prepare(`INSERT INTO agent_actions (
-             event_id, action_type, trigger, model_used,
-             cost_usd, tokens_input, tokens_output,
-             cache_creation_tokens, cache_read_tokens,
-             duration_ms, num_turns, result, detail,
-             started_at, completed_at, error, backend, cost_source
-           ) VALUES (
-             @event_id, @action_type, @trigger, @model_used,
-             0, 0, 0, 0, 0,
-             0, 0, 'in_progress', @detail,
-             datetime(@started_at), NULL, NULL, @backend, 'sdk'
-           )`)
-                .run({
-                event_id: args.parentEventId ?? null,
-                action_type: args.actionType,
-                trigger: args.parentProcessKey ?? null,
-                model_used: args.modelId,
-                detail: JSON.stringify(args.detail),
-                started_at: args.startedAt,
-                backend: args.backendId,
-            });
-            return Number(result.lastInsertRowid);
-        }
-        catch (err) {
-            logger.error({ err, actionType: args.actionType, detail: args.detail }, "failed to write delegated_task header row");
-            return -1;
-        }
-    }
-    completeTaskHeader(args) {
-        if (args.headerId < 0)
-            return;
-        try {
-            this.deps.db
-                .prepare(`UPDATE agent_actions SET
-             result = @result,
-             cost_usd = @cost_usd,
-             tokens_input = @tokens_input,
-             tokens_output = @tokens_output,
-             cache_creation_tokens = @cache_creation_tokens,
-             cache_read_tokens = @cache_read_tokens,
-             duration_ms = @duration_ms,
-             num_turns = @num_turns,
-             completed_at = datetime(@completed_at),
-             error = @error,
-             detail = @detail
-           WHERE id = @id`)
-                .run({
-                id: args.headerId,
-                result: args.result,
-                cost_usd: args.cost.costUsd,
-                tokens_input: args.cost.tokensInput,
-                tokens_output: args.cost.tokensOutput,
-                cache_creation_tokens: args.cost.cacheCreationTokens,
-                cache_read_tokens: args.cost.cacheReadTokens,
-                duration_ms: args.cost.durationMs,
-                num_turns: args.cost.numTurns,
-                completed_at: args.completedAt,
-                error: args.errorMessage,
-                detail: JSON.stringify(args.detail),
-            });
-        }
-        catch (err) {
-            logger.error({ err, headerId: args.headerId }, "failed to update delegated_task.exec header row");
-        }
-    }
-    recordTaskToolStep(args) {
-        try {
-            this.deps.db
-                .prepare(`INSERT INTO agent_actions (
-             action_type, trigger, model_used,
-             cost_usd, tokens_input, tokens_output,
-             cache_creation_tokens, cache_read_tokens,
-             duration_ms, num_turns, result, detail,
-             started_at, completed_at, error, backend, cost_source
-           ) VALUES (
-             'delegated_task.tool_step', NULL, @model_used,
-             @cost_usd, @tokens_input, @tokens_output,
-             0, 0,
-             @duration_ms, 1, @result, @detail,
-             datetime('now'), datetime('now'), @error, @backend, 'sdk'
-           )`)
-                .run({
-                model_used: args.modelId,
-                cost_usd: args.step.costUsd,
-                tokens_input: args.step.tokensInput,
-                tokens_output: args.step.tokensOutput,
-                duration_ms: args.step.durationMs,
-                result: args.step.status === "ok" ? "success" : "failed",
-                detail: JSON.stringify({
-                    ...(args.integrationKey ? { integrationKey: args.integrationKey } : {}),
-                    toolName: args.step.toolName,
-                    toolArgsHash: hashTaskArgs(args.step.toolArgs),
-                    toolStatus: args.step.status,
-                    parentTaskActionId: args.parentTaskActionId,
-                }),
-                error: args.step.status === "error" ? "tool_step_error" : null,
-                backend: args.backendId,
-            });
-        }
-        catch (err) {
-            logger.warn({ err, parentTaskActionId: args.parentTaskActionId }, "failed to write delegated_task.tool_step row");
-        }
-    }
-}
-/**
- * §13 Phase 3.2 — synthetic lease used when pooling is disabled. Implements
- * the same `release()` / `discard()` shape as `SessionPoolLease` so the
- * task() / run() loop doesn't have to branch on whether pooling is active.
- * Both methods clean up the tempdir (no TTL semantics — there's no pool
- * to return to).
- */
-class LegacyOneShotLease {
-    sessionDir;
-    cleanup;
-    fromPool = false;
-    released = false;
-    constructor(sessionDir, cleanup) {
-        this.sessionDir = sessionDir;
-        this.cleanup = cleanup;
-    }
-    release() {
-        if (this.released)
-            return;
-        this.released = true;
-        this.cleanup();
-    }
-    discard() {
-        if (this.released)
-            return;
-        this.released = true;
-        this.cleanup();
-    }
 }
 const FALLBACK_PROXY_PROFILE = `# Delegated Proxy
 
@@ -2223,150 +1920,14 @@ exception: if the named tool's schema is not yet loaded, call ToolSearch
 to load it, then immediately call the named tool. Do not browse other
 tools. If the tool errors, return the error verbatim.
 `;
-function readFileSyncIfExists(path) {
-    if (!existsSync(path))
-        return null;
-    return readFileSync(path, "utf-8");
-}
-function hashArgs(args) {
-    try {
-        const serialized = JSON.stringify(args ?? null);
-        return createHash("sha256")
-            .update(serialized)
-            .digest("hex")
-            .slice(0, 16);
-    }
-    catch {
-        return "unhashable";
-    }
-}
-function zeroCost() {
-    return {
-        tokensInput: 0,
-        tokensOutput: 0,
-        cacheCreationTokens: 0,
-        cacheReadTokens: 0,
-        costUsd: 0,
-        durationMs: 0,
-        numTurns: 0,
-    };
-}
-function mergeCost(a, b) {
-    return {
-        tokensInput: a.tokensInput + b.tokensInput,
-        tokensOutput: a.tokensOutput + b.tokensOutput,
-        cacheCreationTokens: a.cacheCreationTokens + b.cacheCreationTokens,
-        cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
-        costUsd: a.costUsd + b.costUsd,
-        durationMs: a.durationMs + b.durationMs,
-        numTurns: a.numTurns + b.numTurns,
-    };
-}
-/**
- * Local copy of the runtime helper's fence stripper to avoid cycle —
- * `delegated-task-runtime.ts` already exports the canonical version, but
- * importing it here would cycle (the runtime imports types from this
- * file's `agent-core.ts` chain). Tiny duplication is the cleanest fix.
- */
-function stripCodeFences(input) {
-    let s = input.trim();
-    const fenceRe = /^```(?:json|JSON|jsonc|JSONC)?\s*\r?\n([\s\S]*?)\r?\n```$/;
-    const m = s.match(fenceRe);
-    if (m)
-        return m[1];
-    s = s.replace(/^```(?:json|JSON|jsonc|JSONC)?\s*\r?\n/, "");
-    s = s.replace(/\r?\n```\s*$/, "");
-    return s;
-}
 /**
  * DELEGATED-TASK-MODE-DESIGN.md §8.3 — runtime_state key for the per-day
  * task-mode quota counter. Resets at the agent-day boundary; mirrors the
  * Gemini per-day request counter shape.
  */
 const DELEGATED_TASK_COUNT_STATE_KEY = "delegated_task_count_today";
-/**
- * DELEGATED-TASK-MODE-DESIGN.md §11.1 crash safety — boot-time janitor
- * that flips orphaned `delegated_task.exec` rows older than `maxAgeMs`
- * (default 5 min) from `result='in_progress'` to `result='failed'` with
- * `error='subprocess_orphaned'`. Without this, a daemon crash mid-task
- * leaves the row in flight forever and poisons the dashboard's "in-flight
- * task" counter.
- *
- * Returns the number of rows updated.
- */
-export function runDelegatedTaskOrphanJanitor(db, options = {}) {
-    const maxAgeMs = options.maxAgeMs ?? DELEGATED_PROXY_DEFAULTS.janitorMaxAgeMs;
-    const cutoffMs = (options.now?.() ?? Date.now()) - maxAgeMs;
-    const cutoffIso = new Date(cutoffMs).toISOString();
-    try {
-        const result = db
-            .prepare(`UPDATE agent_actions SET
-           result = 'failed',
-           error = 'subprocess_orphaned',
-           completed_at = datetime('now')
-         WHERE action_type IN ('delegated_task.exec', 'delegated_task.run', 'delegated_task.tool_step')
-           AND result = 'in_progress'
-           AND started_at < datetime(?)`)
-            .run(cutoffIso);
-        if (result.changes > 0) {
-            logger.info({ changes: result.changes }, "delegated task janitor: closed orphaned in-progress rows");
-        }
-        return result.changes;
-    }
-    catch (err) {
-        logger.warn({ err }, "delegated task janitor: SQL update failed");
-        return 0;
-    }
-}
-/**
- * Boot-time janitor — scans the sessions root for orphan `proxy-*` dirs
- * older than the configured threshold and removes them. Covers the SIGKILL
- * mid-call case the per-call `finally` cannot. Safe to call before any
- * invocations have happened.
- *
- * Returns the number of directories removed (for logging at startup).
- */
-export function runProxyTempdirJanitor(dataDir, options = {}) {
-    const now = options.now ?? Date.now;
-    const maxAgeMs = options.maxAgeMs ?? DELEGATED_PROXY_DEFAULTS.janitorMaxAgeMs;
-    const root = join(dataDir, "agent-sessions");
-    if (!existsSync(root))
-        return 0;
-    let removed = 0;
-    let entries;
-    try {
-        entries = readdirSync(root);
-    }
-    catch (err) {
-        logger.warn({ err, root }, "proxy janitor: readdir failed");
-        return 0;
-    }
-    for (const entry of entries) {
-        if (!entry.startsWith(DELEGATED_PROXY_DEFAULTS.tempdirPrefix))
-            continue;
-        const path = join(root, entry);
-        let stat;
-        try {
-            stat = statSync(path);
-        }
-        catch {
-            continue;
-        }
-        if (!stat.isDirectory())
-            continue;
-        if (now() - stat.mtimeMs < maxAgeMs)
-            continue;
-        try {
-            rmSync(path, { recursive: true, force: true });
-            removed++;
-        }
-        catch (err) {
-            logger.warn({ err, path }, "proxy janitor: rm failed");
-        }
-    }
-    if (removed > 0) {
-        logger.info({ removed }, "proxy janitor: removed orphan tempdirs");
-    }
-    return removed;
-}
+// Boot-time janitors live in `delegated-invoker-janitors.ts`. Re-export
+// here so `index.ts` and tests that import from this module keep working
+// without an import-path churn — see file-split-plan.md §6.
+export { runDelegatedTaskOrphanJanitor, runProxyTempdirJanitor, } from "./delegated-invoker-janitors.js";
 //# sourceMappingURL=delegated-backend-invoker.js.map