@indigoai-us/hq-cli 5.287.0 → 5.289.0

package/dist/commands/lanes.js

@@ -79,6 +79,7 @@ export { MAX_LANE_DEPTH };
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 export const LANE_REMOTE_MIRROR_SYNC_FLAG = "lanes.remote-done-mirror";
 const REMOTE_MIRROR_REFRESH_BATCH_SIZE = 100;
+const REMOTE_LANE_NOT_FOUND_GRACE_MS = 15 * 60_000;
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
 export { LANE_OUTPOST_SNAPSHOT_CACHE_FLAG };
@@ -1129,6 +1130,7 @@ function normalizedLaneListQuery(query) {
         ...(hierarchy === undefined ? {} : { hierarchy }),
         ...(query.snapshot ? { snapshot: true } : {}),
         ...(query.strictSnapshot ? { strictSnapshot: true } : {}),
+        ...(query.includeForeignHostRows ? { includeForeignHostRows: true } : {}),
     };
 }
 async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions = {}) {
@@ -1191,7 +1193,7 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
         // Outpost's own store, so preserve those local identities for accounting.
         const hasLocalHostIdentity = rowHost.kind === "local" &&
             typeof rowHost.id === "string" && rowHost.id.trim() !== "";
-        if (!belongsToOutpost && !hasLocalHostIdentity)
+        if (!belongsToOutpost && !hasLocalHostIdentity && !query.includeForeignHostRows)
             continue;
         try {
             lanes.push(parseLaneRecord(normalizeLaneRecordView(raw)));
@@ -1216,6 +1218,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
     const result = {
         updated: new Map(),
         unverifiedRemote: new Map(),
+        missingOnOwner: new Map(),
     };
     const host = reconcileHostFromCtx(ctx);
     if (ctx.env.HQ_LANES_REMOTE_READ === "1" || parentLaneIds?.size === 0)
@@ -1285,6 +1288,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                 laneIds: batch.map((lane) => lane.lane_id),
                 snapshot: true,
                 strictSnapshot: true,
+                includeForeignHostRows: true,
             });
         }
         catch (error) {
@@ -1306,6 +1310,8 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                 !ownerIsHostedByOutpost ||
                 (owner.company?.uid ?? null) !== (mirror.company?.uid ?? null) ||
                 (owner.company?.slug ?? null) !== (mirror.company?.slug ?? null)) {
+                if (matches.length === 0)
+                    result.missingOnOwner.set(mirror.lane_id, mirror);
                 const detail = matches.length === 0
                     ? "owner did not return the requested lane"
                     : matches.length > 1
@@ -1329,6 +1335,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
             }
             const needsUpdate = before.state !== owner.state ||
                 before.queued_reason !== (owner.state === "queued" ? owner.queued_reason : undefined) ||
+                JSON.stringify(before.queued_details) !== JSON.stringify(owner.state === "queued" ? owner.queued_details : undefined) ||
                 before.ended_at !== endedAt ||
                 before.envelope_summary !== envelopeSummary ||
                 (isTerminalLaneState(owner.state) && (JSON.stringify(before.last_envelope) !== JSON.stringify(owner.last_envelope) ||
@@ -1348,6 +1355,7 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds) {
                     ...current,
                     state: owner.state,
                     queued_reason: owner.state === "queued" ? owner.queued_reason : undefined,
+                    queued_details: owner.state === "queued" ? owner.queued_details : undefined,
                     ended_at: endedAt,
                     envelope_summary: envelopeSummary,
                     ...(isTerminalLaneState(owner.state) ? {
@@ -2445,6 +2453,47 @@ function markDispatchFailure(hqRoot, laneId, details) {
         };
     });
 }
+function retainQueuedOutpostAfterUnknownDelivery(hqRoot, laneId, outpostId, commandId) {
+    return casUpdateLane(hqRoot, laneId, (current) => {
+        if (current.state !== "queued" ||
+            current.host.kind !== "outpost" ||
+            current.host.id !== outpostId)
+            return current;
+        return {
+            ...current,
+            queued_details: {
+                reason: "outpost_dispatch_unknown",
+                outcome_unknown: true,
+                command_id: commandId,
+            },
+        };
+    });
+}
+function markRemoteLaneLost(hqRoot, laneId, outpostId, at, writer, operatorReason, expectedVersion) {
+    return retryUpdateLane(hqRoot, laneId, writer, (current) => {
+        if (current.host.kind !== "outpost" ||
+            current.host.id !== outpostId ||
+            (expectedVersion !== undefined && current.version !== expectedVersion) ||
+            isTerminalLaneState(current.state))
+            return current;
+        return {
+            ...current,
+            state: "failed",
+            queued_reason: undefined,
+            queued_details: undefined,
+            terminal_reason: "remote_lost",
+            terminal_details: {
+                outpost_id: outpostId,
+                owner_error: "lane_not_found",
+                ...(operatorReason === undefined ? {} : { operator_reason: operatorReason }),
+            },
+            stop_history: [
+                ...(current.stop_history ?? []),
+                { at, reason: "remote_lost" },
+            ],
+        };
+    });
+}
 /**
  * The CAS updater a pickup failure applies. A lane that is already terminal
  * for any reason (a cancel that landed after the caller's last read, an
@@ -3528,6 +3577,22 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 exit_code: dispatched.exitCode,
             });
         }
+        const commandId = dispatched.commandId?.trim();
+        if (dispatched.done !== true || !commandId) {
+            const details = {
+                outpost_id: outpostId,
+                lane_id: lane.lane_id,
+                command_id: commandId || null,
+                status: dispatched.status,
+                done: dispatched.done ?? false,
+                exit_code: dispatched.exitCode,
+                outcome_unknown: true,
+            };
+            throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not confirm pickup for lane ${lane.lane_id}; the queued lane will be reconciled against its owner`, {
+                ...details,
+                state: retainQueuedOutpostAfterUnknownDelivery(hqRoot, lane.lane_id, outpostId, commandId || null).state,
+            });
+        }
         const stdoutTrimmed = dispatched.stdout.trim();
         if (remote === null && stdoutTrimmed !== "" && dispatched.status !== "Success") {
             if (preserveQueuedOnFailure) {
@@ -3606,6 +3671,9 @@ async function dispatchCreatedOutpostLane(ctx, input) {
     catch (err) {
         if (preserveQueuedOnFailure)
             throw err;
+        if (isLanesError(err) && err.error === "outpost_delivery_unconfirmed" && err.details.outcome_unknown === true) {
+            throw err;
+        }
         if (isLanesError(err) &&
             err.error === DISPATCH_TERMINAL_REASON &&
             readLane(hqRoot, lane.lane_id).state === "failed") {
@@ -3792,6 +3860,29 @@ function authorizeResumeProfileRepin(ctx, lane, profile, encodedContext) {
                 : workerProfileHashMismatch(lane, profile);
         }
     }
+    if (lane.state === "queued" && lane.queued_reason === "worker_profile_changed" && profile !== undefined) {
+        // The hash is for the executing Outpost's profile copy, not the primary
+        // host's copy. Only the lane senior (or its authorized owner dispatch) may
+        // clear this hold after resolving that local copy.
+        if (lane.host.kind !== "outpost" || lane.worker_profile !== profile.id) {
+            throw new LanesError("worker_profile_hash_mismatch", `Queued profile recovery for lane ${lane.lane_id} must use its original Outpost worker profile`, {
+                lane_id: lane.lane_id,
+                worker: profile.id,
+                lane_worker: lane.worker_profile ?? null,
+                outpost: lane.host.kind === "outpost" ? lane.host.id : null,
+            });
+        }
+        if (ssmOwnerDispatch) {
+            if (context === undefined)
+                throw workerProfileHashMismatch(lane, profile);
+        }
+        else {
+            const callerAuthorization = callerSeniorAuthorization(ctx, lane.senior);
+            if (!callerAuthorization.authorized) {
+                throw workerProfileHashMismatch(lane, profile, callerAuthorization);
+            }
+        }
+    }
     if (profile === undefined ||
         (lane.host.kind !== "outpost" && !(ssmOwnerDispatch && laneGrantTargetHostedHere(ctx, lane))) ||
         lane.worker_profile_hash === profile.profile.contentHash) {
@@ -4059,7 +4150,13 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
                                 remote.lane !== null &&
                                 typeof remote.lane === "object" &&
                                 !Array.isArray(remote.lane) &&
-                                remote.lane.state === "queued")));
+                                remote.lane.state === "queued") ||
+                            (remote.delivery_status === "queued_for_reconcile" &&
+                                remote.lane !== null &&
+                                typeof remote.lane === "object" &&
+                                !Array.isArray(remote.lane) &&
+                                remote.lane.state === "queued" &&
+                                remote.lane.queued_reason !== "worker_profile_changed")));
     if (!resultConfirmed) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without a confirmed ${action} result for lane ${lane.lane_id}`, {
             lane_id: lane.lane_id,
@@ -4522,7 +4619,7 @@ async function runList(ctx, opts, fastRouteFlags) {
     }
     const remoteRead = ctx.env[REMOTE_LANE_READ_ENV] === "1";
     const remoteRefresh = remoteRead
-        ? { updated: new Map(), unverifiedRemote: new Map() }
+        ? { updated: new Map(), unverifiedRemote: new Map(), missingOnOwner: new Map() }
         : await refreshRemoteLaneMirrors(ctx, hqRoot, laneSource, new Set(selectedLanes
             .filter((lane) => !isTerminalLaneState(lane.state))
             .map((lane) => lane.lane_id)));
@@ -5853,6 +5950,7 @@ function recordResumeSetup(ctx, lane, input) {
         input.keepAlive === undefined &&
         input.cliModel === undefined &&
         input.meshCompany === undefined &&
+        input.clearWorkerProfileChangedQueue !== true &&
         lane.keep_alive_blocked_reason !== "terminal_state")
         return lane;
     return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => {
@@ -5862,12 +5960,28 @@ function recordResumeSetup(ctx, lane, input) {
         if (input.profileRepin !== undefined) {
             assertResumeProfileRepinStillAuthorized(ctx, current, input.profileRepin);
         }
+        if (input.clearWorkerProfileChangedQueue === true && (current.state !== "queued" ||
+            current.queued_reason !== "worker_profile_changed" ||
+            input.profile === undefined ||
+            current.worker_profile !== input.profile.id ||
+            (current.worker_profile_hash !== input.profile.profile.contentHash && input.profileRepin === undefined))) {
+            throw new LanesError("lane_resume_setup_conflict", `Lane ${lane.lane_id} is no longer eligible for worker-profile recovery; run the recovery command again`, {
+                lane_id: lane.lane_id,
+                state: current.state,
+                queued_reason: current.queued_reason ?? null,
+            });
+        }
         const next = { ...current };
         // An operator resume takes the lane out of the terminal state reconcile
         // recorded, so keep-alive may continue it again after this turn.
         if (next.keep_alive_blocked_reason === "terminal_state")
             next.keep_alive_blocked_reason = undefined;
         applyResumeProfileAndEffort(current, next, { ...input, at: ctx.now().toISOString() });
+        if (input.clearWorkerProfileChangedQueue === true) {
+            next.queued_reason = undefined;
+            next.queued_details = undefined;
+            next.admission_reserved_at = undefined;
+        }
         if (input.cliModel !== undefined) {
             next.model = input.cliModel.trim();
             next.model_source = "cli";
@@ -6989,11 +7103,21 @@ async function readOutpostTerminalLane(ctx, laneId, outpostId, stopCommandId, wa
         commandId,
     };
 }
+function isDefiniteOutpostLaneNotFound(dispatched, laneId, ownerError) {
+    return dispatched.done === true &&
+        Boolean(dispatched.commandId?.trim()) &&
+        dispatched.status === "Failed" &&
+        dispatched.exitCode !== null &&
+        dispatched.exitCode !== 0 &&
+        ownerError?.error === "lane_not_found" &&
+        ownerError.details.lane_id === laneId;
+}
 async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
     if (lane.host.kind !== "outpost") {
         throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch stop to`, { lane_id: lane.lane_id });
     }
     const outpostId = lane.host.id;
+    const hqRoot = ctx.hqRoot();
     const waitMs = outpostSingleLaneWaitMs(ctx.env);
     let dispatched;
     try {
@@ -7017,7 +7141,36 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
             required_option: "--reason",
         });
     }
+    const commandId = dispatched.commandId?.trim();
     const ownerError = ownerErrorFromOutput(dispatched.stdout);
+    if (isDefiniteOutpostLaneNotFound(dispatched, lane.lane_id, ownerError)) {
+        const at = ctx.now().toISOString();
+        const updated = markRemoteLaneLost(ctx.hqRoot(), lane.lane_id, outpostId, at, "command", reason);
+        if (updated.terminal_reason !== "remote_lost") {
+            throw new LanesError("already_terminal", `Lane ${lane.lane_id} became terminal before its missing Outpost record could be marked remote_lost`, { lane_id: lane.lane_id, state: updated.state });
+        }
+        const cancelled = cancelPendingQuestionsForLane(hqRoot, lane.lane_id, at, "remote_lost");
+        await emitLaneTerminalStateSoft(ctx, updated);
+        if (!quiet)
+            printJson({
+                ok: true,
+                action: "stop",
+                reason: "remote_lost",
+                lane: updated,
+                terminal: true,
+                resumable: false,
+                cancelled_questions: cancelled.map((question) => question.question_id),
+                outpost_id: outpostId,
+                outpost_command_id: commandId,
+                outpost_result: {
+                    state: "failed",
+                    reason: "remote_lost",
+                    status: dispatched.status,
+                    exit_code: dispatched.exitCode,
+                },
+            });
+        return;
+    }
     if (ownerError) {
         throw new LanesError("outpost_dispatch_failed", `Outpost ${outpostId} rejected the stop command: ${ownerError.message}`, {
             lane_id: lane.lane_id,
@@ -7029,7 +7182,6 @@ async function dispatchOutpostLaneStop(ctx, lane, reason, quiet = false) {
             owner_error: ownerError,
         });
     }
-    const commandId = dispatched.commandId?.trim();
     if (dispatched.done !== true || !commandId) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return a completed stop command for lane ${lane.lane_id}`, {
             lane_id: lane.lane_id,
@@ -7513,8 +7665,42 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
     const fromEnv = ctx.env.HQ_ROOT?.trim();
     const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
     const mirrorRefresh = opts.dryRun
-        ? { updated: new Map(), unverifiedRemote: new Map() }
+        ? {
+            updated: new Map(),
+            unverifiedRemote: new Map(),
+            missingOnOwner: new Map(),
+        }
         : await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot));
+    const remoteLost = [];
+    const remoteLostErrors = [];
+    if (!opts.dryRun && mirrorRefresh.missingOnOwner.size > 0) {
+        const at = ctx.now().toISOString();
+        const nowMs = Date.parse(at);
+        for (const [laneId, mirror] of mirrorRefresh.missingOnOwner) {
+            const createdAtMs = Date.parse(mirror.created_at);
+            if (!Number.isFinite(createdAtMs) ||
+                nowMs - createdAtMs < REMOTE_LANE_NOT_FOUND_GRACE_MS)
+                continue;
+            try {
+                const updated = markRemoteLaneLost(hqRoot, laneId, mirror.host.id, at, "reconcile", undefined, mirror.version);
+                if (updated.terminal_reason !== "remote_lost") {
+                    if (updated.version !== mirror.version) {
+                        mirrorRefresh.unverifiedRemote.set(laneId, "mirror changed after the owner snapshot");
+                    }
+                    continue;
+                }
+                remoteLost.push({ id: laneId, reason: "remote_lost" });
+                cancelPendingQuestionsForLane(hqRoot, laneId, at, "remote_lost");
+                await emitLaneTerminalStateSoft(ctx, updated);
+            }
+            catch (err) {
+                remoteLostErrors.push({
+                    laneId,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
     const summary = await runReconcilePass(hqRoot, {
         now: ctx.now,
         host: reconcileHostFromCtx(ctx),
@@ -7630,10 +7816,22 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
             }
         },
     });
+    for (const failure of remoteLostErrors) {
+        summary.errors.push({
+            code: "remote_lane_terminalize_failed",
+            message: `Could not mark remote lane ${failure.laneId} lost: ${failure.message}`,
+        });
+        summary.ok = false;
+    }
+    const terminalizedRemoteIds = new Set(remoteLost.map(({ id }) => id));
     printJson({
         ...summary,
+        ...(remoteLost.length > 0 ? { remote_lost: remoteLost } : {}),
         ...(mirrorRefresh.unverifiedRemote.size > 0
-            ? { unverified_remote_lanes: [...mirrorRefresh.unverifiedRemote.keys()] }
+            ? {
+                unverified_remote_lanes: [...mirrorRefresh.unverifiedRemote.keys()]
+                    .filter((id) => !terminalizedRemoteIds.has(id)),
+            }
             : {}),
     });
     if (!summary.ok) {

package/dist/lanes-drain-hook.d.ts

@@ -1,2 +1,14 @@
+import type { LaneDrainHookInput } from "./lib/lanes/dropbox.js";
+interface DrainHookResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type DropboxModule = typeof import("./lib/lanes/dropbox.js");
+export interface DrainHookRunnerDeps {
+    /** Test seam for proving the steady-state path does not load the drainer. */
+    loadDropbox?: () => Promise<Pick<DropboxModule, "runDrainHook">>;
+}
+export declare function runLaneDrainHook(env: NodeJS.ProcessEnv, input?: LaneDrainHookInput, inputError?: string, deps?: DrainHookRunnerDeps): Promise<DrainHookResult>;
 export {};
 //# sourceMappingURL=lanes-drain-hook.d.ts.map

package/dist/lanes-drain-hook.js

@@ -1,6 +1,8 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MESSAGE_REPLAY_STATE_NAME, readMessageReplayState, updateMessageReplayTranscript, writeMessageReplayState, } from "./lib/lanes/message-replay.js";
 function parseHookInput(text) {
     if (text.trim() === "")
         return {};
@@ -72,38 +74,34 @@ function dropboxMayNeedDrain(box) {
     }
     return false;
 }
-function replayMayNeedWork(box, turnId, input) {
+function replayMayNeedWork(box, turnId, input, env) {
     if (!/^[A-Za-z0-9-]{1,80}$/.test(turnId))
         return false;
-    if (input.transcript_path)
-        return true;
-    let text;
-    const statePath = path.join(box, "message-compaction-replay.json");
+    const statePath = path.join(box, MESSAGE_REPLAY_STATE_NAME);
+    let state;
+    let hasLegacyFlag = false;
     try {
-        text = fs.readFileSync(statePath, "utf8");
+        state = readMessageReplayState(statePath, turnId, () => {
+            hasLegacyFlag = true;
+        });
     }
     catch {
         // Keep the existing named replay error behavior for missing or unreadable state.
         return true;
     }
+    if (hasLegacyFlag || !input.transcript_path)
+        return hasLegacyFlag;
+    if (!state.provider)
+        return true;
     try {
-        const parsed = JSON.parse(text);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        const update = updateMessageReplayTranscript(state, input.transcript_path, state.provider, env);
+        if (update === "compacted")
             return true;
-        const state = parsed;
-        if (state.schema_version !== 1 ||
-            state.turn_id !== turnId ||
-            (state.last_compaction_marker !== null &&
-                (!Number.isSafeInteger(state.last_compaction_marker) || Number(state.last_compaction_marker) < 0)) ||
-            (state.transcript_offset !== undefined &&
-                (!Number.isSafeInteger(state.transcript_offset) || Number(state.transcript_offset) < 0)) ||
-            (state.transcript_path !== undefined && typeof state.transcript_path !== "string") ||
-            state.flag_enabled !== undefined) {
-            return true;
-        }
+        writeMessageReplayState(statePath, state);
         return false;
     }
     catch {
+        // The full path preserves the existing named replay error reporting.
         return true;
     }
 }
@@ -125,52 +123,42 @@ function recordToolActivity(hqRoot, laneId) {
         return `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
     }
 }
-function finish(result, inputError) {
+function finish(result) {
     if (result.stdout)
         process.stdout.write(result.stdout);
-    if (inputError || result.stderr)
-        process.stderr.write(`${inputError}${result.stderr}`);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
     process.exitCode = result.exitCode;
 }
-async function runFullPath(input, inputError) {
-    const { runDrainHook } = await import("./lib/lanes/dropbox.js");
-    finish(await runDrainHook(process.env, input), inputError);
+async function runFullPath(env, input, deps) {
+    const loadDropbox = deps.loadDropbox ?? (() => import("./lib/lanes/dropbox.js"));
+    const { runDrainHook } = await loadDropbox();
+    return runDrainHook(env, input);
 }
-async function main() {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(Buffer.from(chunk));
-    const text = Buffer.concat(chunks).toString("utf8");
-    let input = {};
-    let inputError = "";
-    try {
-        input = parseHookInput(text);
-    }
-    catch (err) {
-        inputError = `hq-lanes-drain: ${err instanceof Error ? err.message : String(err)}\n`;
-    }
-    const laneId = process.env.HQ_LANE_ID ?? "";
+export async function runLaneDrainHook(env, input = {}, inputError = "", deps = {}) {
+    const withInputError = (result) => ({
+        ...result,
+        stderr: `${inputError}${result.stderr}`,
+    });
+    const laneId = env.HQ_LANE_ID ?? "";
     if (laneId === "") {
-        finish({ exitCode: 0, stdout: "", stderr: "" }, inputError);
-        return;
+        return withInputError({ exitCode: 0, stdout: "", stderr: "" });
     }
-    const hqRoot = process.env.HQ_ROOT ?? "";
+    const hqRoot = env.HQ_ROOT ?? "";
     if (hqRoot === "" || !laneIdIsSafe(laneId)) {
-        await runFullPath(input, inputError);
-        return;
+        return withInputError(await runFullPath(env, input, deps));
     }
     const box = path.join(hqRoot, "workspace", "lanes-runs", laneId, "dropbox");
     let noWork = false;
     try {
         noWork = !dropboxMayNeedDrain(box) &&
-            !replayMayNeedWork(box, process.env.HQ_LANE_TURN_ID ?? "", input);
+            !replayMayNeedWork(box, env.HQ_LANE_TURN_ID ?? "", input, env);
     }
     catch {
         // Filesystem uncertainty must use the full path so it retains its named errors.
     }
     if (!noWork) {
-        await runFullPath(input, inputError);
-        return;
+        return withInputError(await runFullPath(env, input, deps));
     }
     let stderr = recordToolActivity(hqRoot, laneId);
     const directories = [
@@ -186,14 +174,30 @@ async function main() {
     catch (err) {
         const message = `Failed to open drop box ${box}: ${err instanceof Error ? err.message : String(err)}`;
         stderr += `hq-lanes-drain: ${message}\n`;
-        finish({ exitCode: 1, stdout: "", stderr }, inputError);
-        return;
+        return withInputError({ exitCode: 1, stdout: "", stderr });
+    }
+    return withInputError({ exitCode: 0, stdout: "", stderr });
+}
+async function main() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    const text = Buffer.concat(chunks).toString("utf8");
+    let input = {};
+    let inputError = "";
+    try {
+        input = parseHookInput(text);
     }
-    finish({ exitCode: 0, stdout: "", stderr }, inputError);
+    catch (err) {
+        inputError = `hq-lanes-drain: ${err instanceof Error ? err.message : String(err)}\n`;
+    }
+    finish(await runLaneDrainHook(process.env, input, inputError));
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        process.stderr.write(`hq-lanes-drain: hook_runner_failed: ${err instanceof Error ? err.message : String(err)}\n`);
+        // A hook runner failure must not stop the provider's requested tool call.
+        process.exitCode = 0;
+    });
 }
-main().catch((err) => {
-    process.stderr.write(`hq-lanes-drain: hook_runner_failed: ${err instanceof Error ? err.message : String(err)}\n`);
-    // A hook runner failure must not stop the provider's requested tool call.
-    process.exitCode = 0;
-});
 //# sourceMappingURL=lanes-drain-hook.js.map