@indigoai-us/hq-cli 5.342.12 → 5.342.14

package/dist/commands/core-ontology-native.js

@@ -3,8 +3,10 @@ import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { resolveWindowsExecutable } from "../lib/bot/runtime/windows.js";
 import { runBundledScript } from "../utils/run-bundled-script.js";
 import { resolveBundledAsset } from "../utils/hq-roots.js";
+import { planResolvedCommandSpawn } from "../utils/windows-spawn.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
 import { runKnowledgePrefs } from "./core-knowledge-prefs.js";
 const FLAG = "core-native-ontology";
@@ -55,10 +57,23 @@ export function runOntologyNativeFast(args, _stdin, cwd, hqRoot, commandName) {
 }
 function runHq(args, output = "capture") {
     const executable = process.env.HQ_BIN || "hq";
-    const result = spawnSync(executable, args, {
+    const resolvedExecutable = process.platform === "win32" && !path.isAbsolute(executable) && !executable.includes(path.sep)
+        ? resolveWindowsExecutable(executable, process.env, (candidate) => {
+            try {
+                return fs.statSync(candidate).isFile();
+            }
+            catch {
+                return false;
+            }
+        }, process.cwd()) ?? executable
+        : executable;
+    const plan = planResolvedCommandSpawn(resolvedExecutable, args, process.env);
+    const result = spawnSync(plan.cmd, plan.args, {
         cwd: process.cwd(),
         env: process.env,
         encoding: "utf8",
+        shell: plan.shell,
+        ...(plan.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
         stdio: output === "ignore" ? ["ignore", "ignore", "ignore"] : ["ignore", "pipe", "ignore"],
     });
     return { status: result.status, stdout: typeof result.stdout === "string" ? result.stdout : "" };
@@ -522,7 +537,8 @@ export function gardenCommand(args, defaultRoot) {
                 source_ref: JSON.stringify(fm.source_ref || ""), created_at: String(fm.created_at || isoNow()),
             }, body, dryRun);
             report.signals_promoted += 1;
-            index.push({ signal_id: id, type, audience_key: key, path: path.relative(companyDir, outputFile) });
+            const outputPath = path.relative(companyDir, outputFile);
+            index.push({ signal_id: id, type, audience_key: key, path: process.platform === "win32" ? outputPath.replaceAll("\\", "/") : outputPath });
             if (key !== "company") {
                 const audienceFile = path.join(scopeDirectory, "_audience.yaml");
                 if (!fs.existsSync(audienceFile) && !dryRun) {

package/dist/commands/core-worker-share-native.js

@@ -56,7 +56,8 @@ function isRegularFile(filePath, fileSystem) {
     }
 }
 function readLink(filePath, fileSystem) {
-    return fileSystem.readlinkSync(filePath);
+    const target = fileSystem.readlinkSync(filePath);
+    return process.platform === "win32" ? target.replaceAll("\\", "/") : target;
 }
 function sameBytes(leftPath, rightPath, fileSystem) {
     try {

package/dist/commands/lanes-message.d.ts

@@ -1,6 +1,24 @@
-import { type Ctx, type LaneMessageHandlerDeps, type LaneMessageOptions } from "./lanes-shared.js";
+import { type Ctx, type LaneMessageHandlerDeps, type LaneMessageOptions, type LaneMessageResponse } from "./lanes-shared.js";
+export interface MonitorLaneMessagePayload {
+    text: string;
+    monitor_id: string;
+    description: string;
+    sequence: number;
+}
+export type MonitorLaneMessageResult = {
+    ok: true;
+    response: LaneMessageResponse | undefined;
+} | {
+    ok: false;
+    error: unknown;
+    errorCode: string;
+    message: string;
+};
+export declare function parseMonitorLaneMessagePayload(input: unknown): MonitorLaneMessagePayload;
+export declare function deliverMonitorLaneMessage(ctx: Ctx, laneId: string, input: unknown, runMessage: (ctx: Ctx, laneId: string, options: LaneMessageOptions) => Promise<LaneMessageResponse | undefined>): Promise<MonitorLaneMessageResult>;
 export declare function createLaneMessageHandlers(deps: LaneMessageHandlerDeps): {
-    runMessage: (ctx: Ctx, laneId: string, opts: LaneMessageOptions) => Promise<void>;
+    runMessage: (ctx: Ctx, laneId: string, opts: LaneMessageOptions) => Promise<LaneMessageResponse | undefined>;
+    deliverMonitorLaneMessage: (ctx: Ctx, laneId: string, input: unknown) => Promise<MonitorLaneMessageResult>;
     recoverQueuedMessages: (ctx: Ctx, laneId: string) => Promise<{
         action: "none" | "resumed" | "undeliverable";
         message_count: number;

package/dist/commands/lanes-message.js

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { appendCappedHistory, appendDropboxMessage, deliveryRefusalReason, dropboxInboxPath, laneAcceptsOperatorMessage, laneDeliveryMechanism, operatorMessageRefusalReason, providerSessionPortable, providerSupportsSessionResume, readLane, sessionNotPortableMessage, validateProjectStories, withLaneAdmissionLock } from "../lib/lanes/index.js";
-import { LanesError } from "../lib/lanes/errors.js";
+import { isLanesError, LanesError } from "../lib/lanes/errors.js";
+import { CompanySelectionError } from "../utils/company-selection-error.js";
 import { parseCliEffort } from "../lib/lanes/effort.js";
 import { parseOutpostHireGrantContext, sameHireGrantSenior } from "../lib/lanes/hire-grant-dispatch.js";
 import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
@@ -15,6 +16,60 @@ import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { lowDiskGuardEnabledForLane } from "../lib/lanes/disk-guard.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, callerMatchesSessionSenior, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
+export function parseMonitorLaneMessagePayload(input) {
+    let payload = input;
+    if (typeof input === "string") {
+        try {
+            payload = JSON.parse(input);
+        }
+        catch (err) {
+            throw new LanesError("monitor_lane_payload_invalid", `Monitor lane delivery payload is invalid JSON: ${err instanceof Error ? err.message : String(err)}.`, {});
+        }
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload must be an object.", {});
+    }
+    const value = payload;
+    if (typeof value.text !== "string" ||
+        typeof value.monitor_id !== "string" ||
+        typeof value.description !== "string" ||
+        !Number.isInteger(value.sequence) ||
+        Number(value.sequence) < 1) {
+        throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload is missing text, monitor metadata, or sequence.", {});
+    }
+    return {
+        text: value.text,
+        monitor_id: value.monitor_id,
+        description: value.description,
+        sequence: Number(value.sequence),
+    };
+}
+export async function deliverMonitorLaneMessage(ctx, laneId, input, runMessage) {
+    try {
+        const payload = parseMonitorLaneMessagePayload(input);
+        const response = await runMessage(ctx, laneId, {
+            text: payload.text,
+            monitorEvent: {
+                monitor_id: payload.monitor_id,
+                description: payload.description,
+                sequence: payload.sequence,
+            },
+            silent: true,
+        });
+        return { ok: true, response };
+    }
+    catch (error) {
+        const commandError = error instanceof CompanySelectionError
+            ? new LanesError("company_selection_failed", error.message)
+            : error;
+        return {
+            ok: false,
+            error: commandError,
+            errorCode: isLanesError(commandError) ? commandError.error : "internal",
+            message: commandError instanceof Error ? commandError.message : String(commandError),
+        };
+    }
+}
 export function createLaneMessageHandlers(deps) {
     const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, casUpdateLane, dispatchOutpostLaneCommand, dispatchPrimaryLaneMessage, drainHookStatusFor, laneIsHostedHere, laneWithRecoveredProviderSession, loadAllLanes, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveActiveQuestionCompany, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
     function currentSuccessorOf(lane, lanes, lineageAware, companyForLane) {
@@ -843,43 +898,45 @@ export function createLaneMessageHandlers(deps) {
                         ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
                         : null,
             ].filter((message) => message !== undefined && message !== null).join(" ") || null;
+            const response = {
+                ok: true,
+                action: "message",
+                lane_id: laneId,
+                message_id: messageId,
+                accepted: true,
+                delivered: false,
+                delivery: mechanism,
+                delivered_to: { host: lane.host.id, lane_id: laneId, mechanism },
+                delivery_status: deliveryStatus,
+                ...(queuedOnQuotaHold ? {
+                    queued_reason: "account_quota_held",
+                    quota_hold: {
+                        reason: "account_quota_held",
+                        quota_reset_at: quotaHoldDeferred?.quota_reset_at ?? null,
+                        model: quotaHoldDeferred?.model ?? null,
+                    },
+                } : {}),
+                inbox_path: mechanism === "dropbox" ? dropboxInboxPath(hqRoot, laneId) : null,
+                drain_hook: drainHook,
+                warning,
+                ...(questionCancellation === null ? {} : {
+                    cancelled_questions: questionCancellation.cancelled_question_ids,
+                    question_cancellation_failures: questionCancellation.failures,
+                }),
+                resumed_session_id: resumed?.last_resume?.session_id ?? null,
+                compaction: resumed?.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
+                    ? resumed.last_compaction
+                    : null,
+                account_move: move ? accountMoveSummary(move) : null,
+                project_id: next.project_id,
+                story_id: next.story_id,
+                stories: laneStories(next),
+                story_warning: storyWarning(next) ?? null,
+                lane: next,
+            };
             if (!opts.silent)
-                printJson({
-                    ok: true,
-                    action: "message",
-                    lane_id: laneId,
-                    message_id: messageId,
-                    accepted: true,
-                    delivered: false,
-                    delivery: mechanism,
-                    delivered_to: { host: lane.host.id, lane_id: laneId, mechanism },
-                    delivery_status: deliveryStatus,
-                    ...(queuedOnQuotaHold ? {
-                        queued_reason: "account_quota_held",
-                        quota_hold: {
-                            reason: "account_quota_held",
-                            quota_reset_at: quotaHoldDeferred?.quota_reset_at ?? null,
-                            model: quotaHoldDeferred?.model ?? null,
-                        },
-                    } : {}),
-                    inbox_path: mechanism === "dropbox" ? dropboxInboxPath(hqRoot, laneId) : null,
-                    drain_hook: drainHook,
-                    warning,
-                    ...(questionCancellation === null ? {} : {
-                        cancelled_questions: questionCancellation.cancelled_question_ids,
-                        question_cancellation_failures: questionCancellation.failures,
-                    }),
-                    resumed_session_id: resumed?.last_resume?.session_id ?? null,
-                    compaction: resumed?.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
-                        ? resumed.last_compaction
-                        : null,
-                    account_move: move ? accountMoveSummary(move) : null,
-                    project_id: next.project_id,
-                    story_id: next.story_id,
-                    stories: laneStories(next),
-                    story_warning: storyWarning(next) ?? null,
-                    lane: next,
-                });
+                printJson(response);
+            return response;
         }
         catch (err) {
             if (storySwitchRollback !== undefined && !storySwitchDeliveryStarted) {
@@ -994,6 +1051,10 @@ export function createLaneMessageHandlers(deps) {
             throw err;
         }
     }
-    return { runMessage, recoverQueuedMessages };
+    return {
+        runMessage,
+        deliverMonitorLaneMessage: (ctx, laneId, input) => deliverMonitorLaneMessage(ctx, laneId, input, runMessage),
+        recoverQueuedMessages,
+    };
 }
 //# sourceMappingURL=lanes-message.js.map

package/dist/commands/lanes-shared.d.ts

@@ -60,6 +60,7 @@ export interface LaneMessageOptions {
     /** Internal recovery claim is safe to archive once this callback runs. */
     onAccepted?: () => void;
 }
+export type LaneMessageResponse = Record<string, unknown>;
 export interface LaneResumeOptions {
     text?: string;
     fromFailed?: boolean;

package/dist/commands/lanes.d.ts

@@ -6,6 +6,7 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
+import type { MonitorLaneMessagePayload, MonitorLaneMessageResult } from "./lanes-message.js";
 import { type LanesMesh, type OutpostRouteIdentity, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
 export { CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lanes-shared.js";
@@ -105,6 +106,9 @@ export interface LanesCommandDeps {
     /** Test seam for the repository-merge-hold registry flag. */
     mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
+export type MonitorLaneMessageApi = (laneId: string, payload: MonitorLaneMessagePayload) => Promise<MonitorLaneMessageResult>;
+/** Build the same lane message handlers used by `hq lanes _monitor-message`, without a CLI process boundary. */
+export declare function createMonitorLaneMessageApi(hqRoot: string, cwd: string, env?: NodeJS.ProcessEnv): MonitorLaneMessageApi;
 export declare function parseSeniorRef(raw: string): SeniorRef;
 export declare function parseQuestionBody(raw: unknown): QuestionBody | null;
 /**

package/dist/commands/lanes.js

@@ -10,7 +10,7 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { Option } from "commander";
+import { Command, Option } from "commander";
 import { createLaneAccountsHandlers } from "./lanes-accounts.js";
 import { createLaneMessageHandlers } from "./lanes-message.js";
 import { createLaneMoveHandlers } from "./lanes-move.js";
@@ -34,6 +34,7 @@ import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
+import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
 import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
 import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
@@ -90,6 +91,20 @@ 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 };
+const monitorLaneMessageApis = new WeakMap();
+/** Build the same lane message handlers used by `hq lanes _monitor-message`, without a CLI process boundary. */
+export function createMonitorLaneMessageApi(hqRoot, cwd, env = process.env) {
+    const program = new Command();
+    registerLanesCommand(program, {
+        hqRoot: () => hqRoot,
+        cwd: () => cwd,
+        env: { ...env, HQ_ROOT: hqRoot },
+    });
+    const api = monitorLaneMessageApis.get(program);
+    if (!api)
+        throw new Error("Monitor lane message handler was not registered");
+    return api;
+}
 function withoutProviderHome(value) {
     if (Array.isArray(value))
         return value.map(withoutProviderHome);
@@ -8390,6 +8405,7 @@ export function registerLanesCommand(parent, deps = {}) {
         withResumeHireAdmission,
     };
     const messageHandlers = createLaneMessageHandlers(messageHandlerDeps);
+    monitorLaneMessageApis.set(parent, (laneId, payload) => messageHandlers.deliverMonitorLaneMessage(ctx, laneId, payload));
     const resumeHandlers = createLaneResumeHandlers({
         onLaneWorkerStarted: deps.onLaneWorkerStarted,
         archiveResumeMessage,
@@ -8681,13 +8697,13 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--for <change-type>", "envelope | question | state", collectRepeatable, [])
         .option("--timeout <seconds>", "Positive timeout in seconds")
         .option("--json", "JSON output")
-        .action(wrapText(async (opts) => watchHandlers.runWait(ctx, opts)));
+        .action(wrapText(async (opts) => runResidentCommandWithPackageLease("lanes-watch", () => watchHandlers.runWait(ctx, opts))));
     lanes
         .command("watch")
         .description("Watch lane state and question changes until all lanes are terminal")
         .argument("<lane-id...>", "Lane ids to watch")
         .option("--interval-ms <ms>", "Polling interval, bounded to 100ms–30s", "5000")
-        .action(wrapText(async (laneIds, opts) => watchHandlers.runWatch(ctx, laneIds, opts)));
+        .action(wrapText(async (laneIds, opts) => runResidentCommandWithPackageLease("lanes-watch", () => watchHandlers.runWatch(ctx, laneIds, opts))));
     lanes
         .command("monitor-check")
         .description("Check that active Claude senior lanes have live Monitor watch tasks")
@@ -8809,33 +8825,11 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("_monitor-message", { hidden: true })
         .argument("<lane-id>", "Lane id")
         .action(wrap(async (laneId) => {
-        const input = ctx.readStdin();
-        let payload;
-        try {
-            payload = JSON.parse(input);
-        }
-        catch (err) {
-            throw new LanesError("monitor_lane_payload_invalid", `Monitor lane delivery payload is invalid JSON: ${err instanceof Error ? err.message : String(err)}.`, {});
-        }
-        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-            throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload must be an object.", {});
-        }
-        const value = payload;
-        if (typeof value.text !== "string" ||
-            typeof value.monitor_id !== "string" ||
-            typeof value.description !== "string" ||
-            !Number.isInteger(value.sequence) ||
-            Number(value.sequence) < 1) {
-            throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload is missing text, monitor metadata, or sequence.", {});
-        }
-        await messageHandlers.runMessage(ctx, laneId, {
-            text: value.text,
-            monitorEvent: {
-                monitor_id: value.monitor_id,
-                description: value.description,
-                sequence: Number(value.sequence),
-            },
-        });
+        const result = await messageHandlers.deliverMonitorLaneMessage(ctx, laneId, ctx.readStdin());
+        if (!result.ok)
+            throw result.error;
+        if (result.response !== undefined)
+            printJson(result.response);
     }));
     lanes
         .command("resume")

package/dist/commands/mesh.js

@@ -56,6 +56,7 @@ import { deriveRemoteOwnerSlug, deriveRepoIdentityKey, } from "../lib/work-conte
 import { promptRepoCompany, } from "../lib/work-context/repo-prompt.js";
 import { requeueQuarantinedOutbox } from "../lib/work-context/outbox.js";
 import { handOffInstallHere } from "../lib/daemon/handoff.js";
+import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 export function formatCheckLines(threads, company, projectId) {
     if (threads.length === 0) {
         return ["Work mesh: no active project threads found."];
@@ -2108,7 +2109,7 @@ export function registerMeshCommand(program) {
         .command("run")
         .description("Start the single-instance daemon (pid lock, spool watch, presence)")
         .option("--hq-root <path>", "HQ tree root (else HQ_ROOT / persisted trusted roots); the Windows task passes this explicitly")
-        .action((opts) => wrap(() => runDaemonRun(opts))());
+        .action((opts) => wrap(() => runResidentCommandWithPackageLease("mesh-daemon", () => runDaemonRun(opts)))());
     daemon
         .command("install")
         .description("Install LaunchAgent (macOS), systemd user unit (Linux), or Scheduled Task (Windows)")

package/dist/commands/monitor.d.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import { drainDropboxAtPath } from "../lib/lanes/dropbox.js";
 import { recordMonitorTargetActivity, type MonitorMetadata, type MonitorState, type MonitorTarget, type MonitorProcessEntry, type MonitorRuntimeIdentity } from "../lib/monitor.js";
 import type { LaneCompanyRef, LaneProvider } from "../lib/lanes/types.js";
+import { createMonitorLaneMessageApi, type MonitorLaneMessageApi } from "./lanes.js";
 export declare function findSessionOwner(target: MonitorTarget, deps?: {
     env?: NodeJS.ProcessEnv;
     parentPid?: number;
@@ -21,13 +22,25 @@ export declare function runMonitorEnabledCommand(deps?: {
 }): Promise<number>;
 export declare function armText(meta: MonitorMetadata): string;
 export declare function resolveMonitorStartTarget(hqRoot: string, discovered: MonitorTarget, explicitlyProvided: boolean, runtime?: MonitorRuntimeIdentity): MonitorTarget;
-export declare function deliverNormalEvent(hqRoot: string, meta: MonitorMetadata, state: MonitorState, rawText: string): Promise<MonitorState>;
+export declare function invokeLaneMonitorMessage(hqRoot: string, meta: MonitorMetadata, sequence: number, text: string, inProcess?: MonitorLaneMessageApi): {
+    delivered: boolean;
+    outcome: string;
+} | Promise<{
+    delivered: boolean;
+    outcome: string;
+}>;
+export declare function deliverNormalEvent(hqRoot: string, meta: MonitorMetadata, state: MonitorState, rawText: string, inProcess?: MonitorLaneMessageApi): Promise<MonitorState>;
 export interface RunSupervisorDeps {
     resolveRoot?: () => string;
     monitorEnabled?: typeof monitorEnabled;
     deliver?: typeof deliverNormalEvent;
     spawn?: typeof spawn;
+    preloadResidentModules?: () => Promise<void>;
+    releasePackageUseLease?: () => void;
+    reportPreloadFailure?: (error: unknown) => void;
+    createLaneMessageApi?: typeof createMonitorLaneMessageApi;
 }
+export declare function preloadMonitorLaneMessageApi(hqRoot: string, meta: MonitorMetadata, deps?: Pick<RunSupervisorDeps, "preloadResidentModules" | "releasePackageUseLease" | "reportPreloadFailure" | "createLaneMessageApi">): Promise<MonitorLaneMessageApi | undefined>;
 export declare function runSupervisor(id: string, deps?: RunSupervisorDeps): Promise<void>;
 interface MonitorHookResult {
     stdout: string;

package/dist/commands/monitor.js

@@ -10,6 +10,9 @@ import { appendDropboxMessageAtPath, drainDropboxAtPath, formatDropboxMessages }
 import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
 import { MONITOR_FLAG, MONITOR_FLAG_DEFAULT, MONITOR_DEFAULT_CHECKIN_MS, MONITOR_DEFAULT_TIMEOUT_MS, MONITOR_POLL_INTERVAL_MS, MONITOR_BATCH_WINDOW_MS, MONITOR_MAX_EVENTS_PER_WINDOW, MONITOR_MAX_FLOOD_WINDOWS, MONITOR_RATE_WINDOW_MS, MONITOR_SCHEMA_VERSION, monitorDir, monitorSessionDir, monitorSessionHasActiveMarkerForOwner, monitorSessionHasActiveMarkers, monitorSessionHasWork, monitorSessionInboxHasEvents, monitorTargetKey, assertMonitorTimeoutCompatibility, parseMonitorDuration, parseMonitorTarget, detectMonitorTarget, findNearestMonitorRuntime, makeMonitorId, recordMonitorTargetDelivery, recordMonitorTargetActivity, recordMonitorTargetDeliveryAtPath, runMonitorCheckinTick, readMonitorPidLiveness, recordHookSessionMapping, resolveMappedSessionId, parseHookSessionId, withMonitorTargetLock, nextMonitorEventSequence, recordMonitorEventState, requestMonitorStop, nextMonitorTimeoutDelay } from "../lib/monitor.js";
 import { readProcStarttime } from "../lib/lanes/spawn.js";
+import { createMonitorLaneMessageApi } from "./lanes.js";
+import { releaseCurrentPackageUseLease, releasePackageUseLeaseAfterResidentPreload } from "../utils/package-use-lease.js";
+import { preloadResidentPackageModules, reportResidentPackagePreloadFailure, runResidentCommandWithPackageLease, } from "../utils/resident-package-preload.js";
 const RUNTIME_ENV = {
     claude: "CLAUDE_CODE_SESSION_ID",
     codex: "CODEX_THREAD_ID",
@@ -418,7 +421,7 @@ function removeActiveMarker(hqRoot, meta) {
         return;
     fs.rmSync(path.join(monitorSessionDir(hqRoot, meta.target.provider, meta.target.sessionId), "active", meta.monitor_id), { force: true });
 }
-async function deliverLaneEvent(hqRoot, meta, sequence, text) {
+async function deliverLaneEvent(hqRoot, meta, sequence, text, inProcess) {
     if (meta.target.kind !== "lane")
         throw new LanesError("monitor_lane_target_required", "Lane delivery requires a lane target.");
     const lane = tryReadLane(hqRoot, meta.target.laneId);
@@ -427,8 +430,8 @@ async function deliverLaneEvent(hqRoot, meta, sequence, text) {
     let dispatched;
     try {
         dispatched = await dispatchLaneDelivery(lane, {
-            dropbox: () => invokeLaneMonitorMessage(hqRoot, meta, sequence, text),
-            resume: () => invokeLaneMonitorMessage(hqRoot, meta, sequence, text),
+            dropbox: () => invokeLaneMonitorMessage(hqRoot, meta, sequence, text, inProcess),
+            resume: () => invokeLaneMonitorMessage(hqRoot, meta, sequence, text, inProcess),
         });
     }
     catch (err) {
@@ -438,9 +441,24 @@ async function deliverLaneEvent(hqRoot, meta, sequence, text) {
     }
     return { ...dispatched.value, outcome: `${dispatched.mechanism}:${dispatched.value.outcome}` };
 }
-function invokeLaneMonitorMessage(hqRoot, meta, sequence, text) {
+export function invokeLaneMonitorMessage(hqRoot, meta, sequence, text, inProcess) {
     if (meta.target.kind !== "lane")
         throw new LanesError("monitor_lane_target_required", "Lane delivery requires a lane target.");
+    if (inProcess) {
+        return inProcess(meta.target.laneId, { text, monitor_id: meta.monitor_id, description: meta.description, sequence })
+            .then((result) => {
+            if (!result.ok)
+                return { delivered: false, outcome: result.errorCode };
+            const response = result.response;
+            if (response === undefined) {
+                throw new LanesError("monitor_lane_delivery_invalid_response", "The lane delivery command returned invalid JSON: Unexpected end of JSON input.", {});
+            }
+            return {
+                delivered: response.accepted === true,
+                outcome: String(response.delivery_status ?? response.delivery ?? "accepted"),
+            };
+        });
+    }
     const cliEntrypoint = process.argv[1];
     if (!cliEntrypoint)
         throw new LanesError("monitor_cli_path_missing", "Could not locate the hq CLI entry point for lane delivery.");
@@ -488,16 +506,16 @@ function deliverSessionEvent(hqRoot, meta, sequence, text) {
     });
     return { delivered: true, outcome: "session_inbox" };
 }
-async function deliverTargetEvent(hqRoot, meta, sequence, text) {
+async function deliverTargetEvent(hqRoot, meta, sequence, text, inProcess) {
     return meta.target.kind === "lane"
-        ? deliverLaneEvent(hqRoot, meta, sequence, text)
+        ? deliverLaneEvent(hqRoot, meta, sequence, text, inProcess)
         : deliverSessionEvent(hqRoot, meta, sequence, text);
 }
-export async function deliverNormalEvent(hqRoot, meta, state, rawText) {
+export async function deliverNormalEvent(hqRoot, meta, state, rawText, inProcess) {
     return withMonitorTargetLock(hqRoot, meta.target_key, async (activityPath) => {
         const current = readJson(statePath(hqRoot, meta.monitor_id)) ?? state;
         const sequence = nextMonitorEventSequence(current);
-        const outcome = await deliverTargetEvent(hqRoot, meta, sequence, rawText);
+        const outcome = await deliverTargetEvent(hqRoot, meta, sequence, rawText, inProcess);
         const event = { seq: sequence, at: new Date().toISOString(), text: rawText, delivery: outcome.delivered ? "delivered" : `undeliverable:${outcome.outcome}` };
         const next = appendEventRecord(hqRoot, meta.monitor_id, current, event);
         if (outcome.delivered)
@@ -512,7 +530,7 @@ function targetEnded(hqRoot, meta) {
     const lane = tryReadLane(hqRoot, meta.target.laneId);
     return !lane || ["killed", "cancelled", "failed"].includes(lane.state);
 }
-async function monitorCheckin(hqRoot, meta, state) {
+async function monitorCheckin(hqRoot, meta, state, inProcess) {
     await runMonitorCheckinTick(hqRoot, meta.target_key, {
         now: () => new Date(),
         isWakeable: async (targetKey) => {
@@ -540,7 +558,7 @@ async function monitorCheckin(hqRoot, meta, state) {
                 return { delivered: false, outcome: "no_live_monitor" };
             const monitorState = readJson(statePath(hqRoot, monitor.monitor_id)) ?? state;
             const sequence = nextMonitorEventSequence(monitorState);
-            const outcome = await deliverTargetEvent(hqRoot, monitor, sequence, text);
+            const outcome = await deliverTargetEvent(hqRoot, monitor, sequence, text, inProcess);
             const event = { seq: sequence, at: new Date().toISOString(), text, delivery: outcome.delivered ? "delivered" : `undeliverable:${outcome.outcome}` };
             appendEventRecord(hqRoot, monitor.monitor_id, monitorState, event);
             return outcome;
@@ -557,6 +575,16 @@ function activeTargetMeta(hqRoot, targetKey) {
         return meta?.target_key === targetKey && state?.status === "running" && state.pid !== null && readMonitorPidLiveness(state.pid, state.starttime) ? [meta] : [];
     });
 }
+export async function preloadMonitorLaneMessageApi(hqRoot, meta, deps = {}) {
+    if (meta.target.kind !== "lane")
+        return undefined;
+    let laneMessageApi;
+    await releasePackageUseLeaseAfterResidentPreload(async () => {
+        await (deps.preloadResidentModules ?? (() => preloadResidentPackageModules("monitor-run")))();
+        laneMessageApi = (deps.createLaneMessageApi ?? createMonitorLaneMessageApi)(hqRoot, meta.cwd, process.env);
+    }, deps.reportPreloadFailure ?? reportResidentPackagePreloadFailure, deps.releasePackageUseLease ?? releaseCurrentPackageUseLease);
+    return laneMessageApi;
+}
 export async function runSupervisor(id, deps = {}) {
     const hqRoot = (deps.resolveRoot ?? resolveLanesHqRoot)();
     const dir = monitorDir(hqRoot, id);
@@ -569,6 +597,7 @@ export async function runSupervisor(id, deps = {}) {
         removeActiveMarker(hqRoot, meta);
         return;
     }
+    const laneMessageApi = await preloadMonitorLaneMessageApi(hqRoot, meta, deps);
     let state = { ...stateAtStart, status: "running", pid: process.pid, starttime: readProcStarttime(process.pid), started_at: new Date().toISOString() };
     writeJsonAtomic(statePath(hqRoot, id), state);
     let commandChild = null;
@@ -587,7 +616,7 @@ export async function runSupervisor(id, deps = {}) {
     let suppressed = 0;
     let floodWindows = 0;
     let checkinRunning = false;
-    const deliver = deps.deliver ?? deliverNormalEvent;
+    const deliver = deps.deliver ?? ((root, metadata, current, text) => deliverNormalEvent(root, metadata, current, text, laneMessageApi));
     const perWindowCap = (() => {
         const candidate = Number.parseInt(process.env.HQ_MONITOR_MAX_EVENTS_PER_WINDOW ?? "", 10);
         return Number.isInteger(candidate) && candidate > 0 ? candidate : MONITOR_MAX_EVENTS_PER_WINDOW;
@@ -711,7 +740,7 @@ export async function runSupervisor(id, deps = {}) {
         }
         if (!checkinRunning) {
             checkinRunning = true;
-            void monitorCheckin(hqRoot, meta, state)
+            void monitorCheckin(hqRoot, meta, state, laneMessageApi)
                 .then((next) => { state = next; })
                 .catch((err) => writeStderr(`check-in failed: ${errorPath(err)}\n`))
                 .finally(() => { checkinRunning = false; });
@@ -966,11 +995,11 @@ export function registerMonitorCommand(parent) {
     });
     monitor.command("wait", { hidden: true }).requiredOption("--provider <provider>")
         .action(async (options) => {
-        const result = await runMonitorHookSafely("wait", async () => {
+        const result = await runResidentCommandWithPackageLease("monitor-wait", () => runMonitorHookSafely("wait", async () => {
             if (options.provider !== "claude")
                 throw new LanesError("monitor_wait_provider_unsupported", "Only Claude Stop hooks can wait for session monitor events.", { provider: options.provider });
             return waitForSession(options.provider);
-        });
+        }));
         if (result.stdout)
             process.stdout.write(result.stdout);
         process.exitCode = result.exitCode;

package/dist/lib/core-utils/shell-display-path.d.ts

@@ -0,0 +1,3 @@
+/** Render a native path with the path spelling used by the bundled Bash scripts. */
+export declare function shellDisplayPath(value: string): string;
+//# sourceMappingURL=shell-display-path.d.ts.map

package/dist/lib/core-utils/shell-display-path.js

@@ -0,0 +1,12 @@
+import * as path from "node:path";
+/** Render a native path with the path spelling used by the bundled Bash scripts. */
+export function shellDisplayPath(value) {
+    if (process.platform !== "win32")
+        return value;
+    const absolute = path.win32.resolve(value);
+    const match = /^([A-Za-z]):[\\/](.*)$/.exec(absolute);
+    if (!match?.[1] || match[2] === undefined)
+        return value;
+    return `/${match[1].toLowerCase()}/${match[2].replaceAll("\\", "/")}`;
+}
+//# sourceMappingURL=shell-display-path.js.map