@indigoai-us/hq-cli 5.345.54 → 5.345.56

package/dist/lib/lanes/dropbox.js

@@ -14,6 +14,8 @@ import { LanesError } from "./errors.js";
 import { MESSAGE_COMPACTION_REPLAY_NOTE, MESSAGE_REPLAY_STATE_NAME, readMessageReplayState, updateMessageReplayTranscript, writeMessageReplayState, } from "./message-replay.js";
 import { LANES_RUNS_REL, readProcStarttime } from "./spawn.js";
 import { tryReadLane } from "./store.js";
+import { readLanesRegistryFlagFailOpen } from "./registry-flag.js";
+import { LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG } from "./flag-keys.js";
 export const DROPBOX_DIR = "dropbox";
 export const INBOX_NAME = "inbox.jsonl";
 export const DRAINING_DIR = "draining";
@@ -426,6 +428,9 @@ export function hookAdditionalContextJson(messages, hookEventName = "PreToolUse"
         },
     })}\n`;
 }
+function hookStopBlockJson(reason) {
+    return `${JSON.stringify({ decision: "block", reason })}\n`;
+}
 function replayStatePath(hqRoot, laneId) {
     return path.join(dropboxDir(hqRoot, laneId), MESSAGE_REPLAY_STATE_NAME);
 }
@@ -465,14 +470,47 @@ export async function runDrainHook(env, input = {}, deps = {}) {
             stderr: "hq-lanes-drain: HQ_ROOT is unset while HQ_LANE_ID is set\n",
         };
     }
-    // Liveness first: a failed drain must still leave proof the worker called
-    // a tool. A failure here is reported, never fatal to delivery.
-    let stderr = "";
-    try {
-        recordToolActivity(hqRoot, laneId);
+    const hookEvent = input.hook_event_name ?? input.hookEventName ?? "PreToolUse";
+    if (hookEvent !== "PreToolUse" && hookEvent !== "PostToolUse" && hookEvent !== "Stop") {
+        return { exitCode: 0, stdout: "", stderr: "" };
     }
-    catch (err) {
-        stderr += `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
+    // Grok invokes lifecycle hooks, but their output cannot reach the model.
+    // Preserve queued messages for its next deliverable PreToolUse event.
+    if (env.HQ_LANE_PROVIDER === "grok" && hookEvent !== "PreToolUse") {
+        return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    const hasQueuedMessages = dropboxInboxHasMessages(hqRoot, laneId);
+    if (hookEvent === "Stop" && !hasQueuedMessages) {
+        return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    if ((hookEvent === "PostToolUse" || hookEvent === "Stop") && hasQueuedMessages) {
+        const lane = (deps.readLane ?? tryReadLane)(hqRoot, laneId);
+        const company = lane?.mesh_company ?? lane?.company ?? undefined;
+        let enabled = true;
+        try {
+            enabled = deps.readLifecycleDeliveryFlag
+                ? await deps.readLifecycleDeliveryFlag()
+                : await readLanesRegistryFlagFailOpen(LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG, {
+                    ...(company ? { company } : {}),
+                    env,
+                });
+        }
+        catch (err) {
+            process.stderr.write(`hq-lanes-drain: lifecycle delivery flag read failed open: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+        if (!enabled)
+            return { exitCode: 0, stdout: "", stderr: "" };
+    }
+    // PreToolUse remains the tool-activity liveness touch used by watcher.ts.
+    // PostToolUse and Stop add delivery opportunities without extra liveness writes.
+    let stderr = "";
+    if (hookEvent === "PreToolUse") {
+        try {
+            recordToolActivity(hqRoot, laneId);
+        }
+        catch (err) {
+            stderr += `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
+        }
     }
     try {
         const turnId = env.HQ_LANE_TURN_ID ?? "";
@@ -515,15 +553,22 @@ export async function runDrainHook(env, input = {}, deps = {}) {
             }
         }
         if (replayNote && replayed && replayed.length > 0) {
+            const formatted = `${replayNote}\n\n${formatDropboxMessages(replayed)}`;
             return {
                 exitCode: 0,
-                stdout: hookAdditionalContextJson(replayed, "PreToolUse", replayNote),
+                stdout: hookEvent === "Stop"
+                    ? hookStopBlockJson(formatted)
+                    : hookAdditionalContextJson(replayed, hookEvent, replayNote),
                 stderr,
             };
         }
         if (messages.length === 0)
             return { exitCode: 0, stdout: "", stderr };
-        return { exitCode: 0, stdout: hookAdditionalContextJson(messages), stderr };
+        const formatted = formatDropboxMessages(messages);
+        if (hookEvent === "Stop") {
+            return { exitCode: 0, stdout: hookStopBlockJson(formatted), stderr };
+        }
+        return { exitCode: 0, stdout: hookAdditionalContextJson(messages, hookEvent), stderr };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/lib/lanes/flag-keys.d.ts

@@ -30,4 +30,14 @@ export declare const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot
 export declare const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
 /** Allows a Claude lane to leave an exhausted profile account pin for an eligible account. */
 export declare const LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG = "lanes.profile-pin-exhausted-fallback";
+/** Kill switch for PostToolUse and Stop drop-box delivery. Default on. */
+export declare const LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG = "lanes.dropbox-lifecycle-delivery";
+/** Kill switch for bounded local status fields in lane list/show JSON. Default on. */
+export declare const LANE_STATUS_ROW_FIELDS_FLAG = "lanes.status-row-fields";
+/** Enables conduct-mode SessionStart bootstrapping (defaults on; operator kill switch). */
+export declare const LANE_CONDUCT_SESSION_START_FLAG = "lanes.conduct-session-start";
+/** Kill switch for stopping local orphan lane process trees; off means report-only. */
+export declare const LANE_REAP_STOP_FLAG = "lanes.reap-stop";
+/** Enables same-senior worker lane continuity on create; keep ON as the kill switch default. */
+export declare const LANE_WORKER_CONTINUITY_FLAG = "lanes.worker-continuity";
 //# sourceMappingURL=flag-keys.d.ts.map

package/dist/lib/lanes/flag-keys.js

@@ -30,4 +30,14 @@ export const LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG = "lanes.autopilot-outpost
 export const LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG = "lanes.orphaned-bare-id-dropbox-repair";
 /** Allows a Claude lane to leave an exhausted profile account pin for an eligible account. */
 export const LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG = "lanes.profile-pin-exhausted-fallback";
+/** Kill switch for PostToolUse and Stop drop-box delivery. Default on. */
+export const LANE_DROPBOX_LIFECYCLE_DELIVERY_FLAG = "lanes.dropbox-lifecycle-delivery";
+/** Kill switch for bounded local status fields in lane list/show JSON. Default on. */
+export const LANE_STATUS_ROW_FIELDS_FLAG = "lanes.status-row-fields";
+/** Enables conduct-mode SessionStart bootstrapping (defaults on; operator kill switch). */
+export const LANE_CONDUCT_SESSION_START_FLAG = "lanes.conduct-session-start";
+/** Kill switch for stopping local orphan lane process trees; off means report-only. */
+export const LANE_REAP_STOP_FLAG = "lanes.reap-stop";
+/** Enables same-senior worker lane continuity on create; keep ON as the kill switch default. */
+export const LANE_WORKER_CONTINUITY_FLAG = "lanes.worker-continuity";
 //# sourceMappingURL=flag-keys.js.map

package/dist/lib/lanes/hooks-install.d.ts

@@ -6,15 +6,18 @@
  * registers nothing:
  *
  * - grok reads every `*.json` under `$GROK_HOME/hooks/`, so the registration
- *   file in that directory is the registration.
+ *   file in that directory is the registration. Grok passive events cannot
+ *   inject model-facing context or block, so its drain stays on PreToolUse.
  * - claude reads `$CLAUDE_CONFIG_DIR/settings.json` and nothing under
- *   `hooks/`. The registration is merged into the `hooks.PreToolUse` array of
- *   that file.
- * - codex reads `$CODEX_HOME/config.toml` (`[[hooks.PreToolUse]]`, gated by
- *   `[features] hooks = true`). The registration is appended to that file.
+ *   `hooks/`. The registration is merged into PreToolUse, PostToolUse, and
+ *   Stop arrays in that file.
+ * - codex reads `$CODEX_HOME/config.toml` (`[[hooks.<Event>]]`, gated by
+ *   `[features] hooks = true`). The registration is appended for all three
+ *   delivery events.
  *
- * Every registration merge keeps what the operator already has and is a
- * no-op when the entry is present, because this runs on every spawn.
+ * Claude and Codex register all three delivery events. Grok registers only
+ * PreToolUse because its PostToolUse and Stop output cannot reach the model.
+ * Registration merges keep existing operator hooks and are idempotent.
  * Never merges into hq-hq-bridge.json / hq-hq-bridge.sh.
  */
 import type { LaneProvider } from "./types.js";
@@ -40,9 +43,9 @@ export interface DrainHookInstallResult {
     files: string[];
     registration: DrainHookRegistration;
 }
-export declare function drainHookCommand(_shPath?: string): string;
+export declare function drainHookCommand(_shPath?: string, provider?: LaneProvider): string;
 export declare function drainHookShPath(providerHome: string): string;
-export declare function renderDrainHookJson(shPath: string): string;
+export declare function renderDrainHookJson(shPath: string, provider?: LaneProvider): string;
 export interface MergeResult {
     text: string;
     changed: boolean;
@@ -56,9 +59,9 @@ export interface MergeResult {
 export declare function mergeClaudeSettingsHook(existingText: string | null, command: string, settingsPath: string, legacyCommand?: string): MergeResult;
 /**
  * Codex: hooks come from `config.toml` in the codex home. The drain is
- * appended as one `[[hooks.PreToolUse]]` table and `[features] hooks = true`
+ * appended to PreToolUse, PostToolUse, and Stop, and `[features] hooks = true`
  * is ensured. Edits are textual so comments and unrelated tables are kept
- * byte for byte; the result is re-parsed and must contain the registration,
+ * byte for byte; the result is re-parsed and must contain every registration,
  * otherwise nothing is written.
  */
 export declare function mergeCodexConfigHook(existingText: string | null, command: string, configPath: string, legacyCommand?: string): MergeResult;

package/dist/lib/lanes/hooks-install.js

@@ -6,15 +6,18 @@
  * registers nothing:
  *
  * - grok reads every `*.json` under `$GROK_HOME/hooks/`, so the registration
- *   file in that directory is the registration.
+ *   file in that directory is the registration. Grok passive events cannot
+ *   inject model-facing context or block, so its drain stays on PreToolUse.
  * - claude reads `$CLAUDE_CONFIG_DIR/settings.json` and nothing under
- *   `hooks/`. The registration is merged into the `hooks.PreToolUse` array of
- *   that file.
- * - codex reads `$CODEX_HOME/config.toml` (`[[hooks.PreToolUse]]`, gated by
- *   `[features] hooks = true`). The registration is appended to that file.
+ *   `hooks/`. The registration is merged into PreToolUse, PostToolUse, and
+ *   Stop arrays in that file.
+ * - codex reads `$CODEX_HOME/config.toml` (`[[hooks.<Event>]]`, gated by
+ *   `[features] hooks = true`). The registration is appended for all three
+ *   delivery events.
  *
- * Every registration merge keeps what the operator already has and is a
- * no-op when the entry is present, because this runs on every spawn.
+ * Claude and Codex register all three delivery events. Grok registers only
+ * PreToolUse because its PostToolUse and Stop output cannot reach the model.
+ * Registration merges keep existing operator hooks and are idempotent.
  * Never merges into hq-hq-bridge.json / hq-hq-bridge.sh.
  */
 import * as fs from "node:fs";
@@ -44,8 +47,9 @@ export const PROVIDER_REGISTRATION_KIND = {
     codex: "config_toml",
     grok: "hooks_dir",
 };
-export function drainHookCommand(_shPath) {
-    return `${shellQuote(process.execPath)} ${shellQuote(drainHookEntryPath())}`;
+export function drainHookCommand(_shPath, provider) {
+    const providerEnv = provider === "grok" ? "HQ_LANE_PROVIDER=grok " : "";
+    return `${providerEnv}${shellQuote(process.execPath)} ${shellQuote(drainHookEntryPath())}`;
 }
 function legacyDrainHookCommand(shPath) {
     return `bash ${shPath}`;
@@ -148,7 +152,10 @@ function isInstalledDrainEntry(entryPath) {
 function drainCommandsMatch(candidate, expected) {
     if (candidate === expected)
         return true;
-    const argv = parseShellQuotedArguments(candidate);
+    const withoutProviderEnv = candidate.startsWith("HQ_LANE_PROVIDER=grok ")
+        ? candidate.slice("HQ_LANE_PROVIDER=grok ".length)
+        : candidate;
+    const argv = parseShellQuotedArguments(withoutProviderEnv);
     if (argv === null || argv.length !== 2)
         return false;
     if (path.parse(argv[0]).name.toLowerCase() !== "node")
@@ -170,7 +177,9 @@ function groupsContainDrainCommand(groups, expected) {
     });
 }
 function tomlHasDrainCommand(parsed, expected) {
-    return isPlainObject(parsed.hooks) && groupsContainDrainCommand(parsed.hooks.PreToolUse, expected);
+    const hooks = isPlainObject(parsed.hooks) ? parsed.hooks : null;
+    return hooks !== null &&
+        ["PreToolUse", "PostToolUse", "Stop"].every((event) => groupsContainDrainCommand(hooks[event], expected));
 }
 function removeCommandFromGroups(groups, command) {
     let changed = false;
@@ -187,22 +196,14 @@ function removeCommandFromGroups(groups, command) {
     });
     return { groups: next, changed };
 }
-export function renderDrainHookJson(shPath) {
-    return `${JSON.stringify({
-        hooks: {
-            PreToolUse: [
-                {
-                    hooks: [
-                        {
-                            type: "command",
-                            command: drainHookCommand(shPath),
-                            timeout: DRAIN_HOOK_TIMEOUT_SECONDS,
-                        },
-                    ],
-                },
-            ],
-        },
-    }, null, 2)}\n`;
+export function renderDrainHookJson(shPath, provider = "grok") {
+    const command = drainHookCommand(shPath, provider);
+    const registration = {
+        hooks: Object.fromEntries(["PreToolUse"].map((event) => [event, [
+                { hooks: [{ type: "command", command, timeout: DRAIN_HOOK_TIMEOUT_SECONDS }] },
+            ]])),
+    };
+    return `${JSON.stringify(registration, null, 2)}\n`;
 }
 /**
  * Claude Code: `settings.json` is the one file it reads hooks from. Merge the
@@ -227,27 +228,35 @@ export function mergeClaudeSettingsHook(existingText, command, settingsPath, leg
     if (!isPlainObject(hooks)) {
         throw new LanesError("settings_unparseable", `${settingsPath} has a non-object "hooks" key; refusing to rewrite it`, { path: settingsPath });
     }
-    const pre = hooks.PreToolUse === undefined ? [] : hooks.PreToolUse;
+    const events = ["PreToolUse", "PostToolUse", "Stop"];
+    const eventGroups = new Map();
+    for (const event of events) {
+        const groups = hooks[event] === undefined ? [] : hooks[event];
+        if (!Array.isArray(groups)) {
+            throw new LanesError("settings_unparseable", `${settingsPath} has a non-array "hooks.${event}"; refusing to rewrite it`, { path: settingsPath });
+        }
+        eventGroups.set(event, groups);
+    }
+    const pre = eventGroups.get("PreToolUse");
     if (!Array.isArray(pre)) {
         throw new LanesError("settings_unparseable", `${settingsPath} has a non-array "hooks.PreToolUse"; refusing to rewrite it`, { path: settingsPath });
     }
     const migration = legacyCommand && legacyCommand !== command
         ? removeCommandFromGroups(pre, legacyCommand)
         : { groups: pre, changed: false };
-    if (groupsContainCommand(migration.groups, command) && !migration.changed) {
+    const allRegistered = events.every((event) => groupsContainCommand(eventGroups.get(event), command));
+    if (allRegistered && !migration.changed) {
         return { text: existingText ?? "", changed: false };
     }
-    const nextPre = groupsContainCommand(migration.groups, command)
-        ? migration.groups
-        : [
-            ...migration.groups,
-            {
-                hooks: [
-                    { type: "command", command, timeout: DRAIN_HOOK_TIMEOUT_SECONDS },
-                ],
-            },
+    const nextHooks = { ...hooks };
+    for (const event of events) {
+        const groups = event === "PreToolUse" ? migration.groups : eventGroups.get(event);
+        nextHooks[event] = groupsContainCommand(groups, command) ? groups : [
+            ...groups,
+            { hooks: [{ type: "command", command, timeout: DRAIN_HOOK_TIMEOUT_SECONDS }] },
         ];
-    const nextRoot = { ...root, hooks: { ...hooks, PreToolUse: nextPre } };
+    }
+    const nextRoot = { ...root, hooks: nextHooks };
     return { text: `${JSON.stringify(nextRoot, null, 2)}\n`, changed: true };
 }
 function tomlBasicString(value) {
@@ -424,9 +433,9 @@ function enableTomlHooksFeature(text) {
 }
 /**
  * Codex: hooks come from `config.toml` in the codex home. The drain is
- * appended as one `[[hooks.PreToolUse]]` table and `[features] hooks = true`
+ * appended to PreToolUse, PostToolUse, and Stop, and `[features] hooks = true`
  * is ensured. Edits are textual so comments and unrelated tables are kept
- * byte for byte; the result is re-parsed and must contain the registration,
+ * byte for byte; the result is re-parsed and must contain every registration,
  * otherwise nothing is written.
  */
 export function mergeCodexConfigHook(existingText, command, configPath, legacyCommand) {
@@ -435,7 +444,8 @@ export function mergeCodexConfigHook(existingText, command, configPath, legacyCo
     const migration = removeLegacyCodexHook(original, parsed, legacyCommand, configPath);
     const textAfterMigration = migration.text;
     const current = parseTomlOrThrow(textAfterMigration, configPath, "after legacy hook removal");
-    const hasCommand = tomlHasCommand(current, command);
+    const hasPreToolCommand = tomlHasCommand(current, command);
+    const hasCommand = tomlHasDrainCommand(current, command);
     const featureOn = tomlHooksFeatureEnabled(current);
     if (hasCommand && featureOn && !migration.changed) {
         return { text: original, changed: false };
@@ -443,7 +453,7 @@ export function mergeCodexConfigHook(existingText, command, configPath, legacyCo
     let text = textAfterMigration;
     if (!featureOn)
         text = enableTomlHooksFeature(text);
-    if (!hasCommand) {
+    if (!hasPreToolCommand) {
         const sep = text === "" || text.endsWith("\n") ? "" : "\n";
         text =
             `${text}${sep}\n` +
@@ -455,8 +465,18 @@ export function mergeCodexConfigHook(existingText, command, configPath, legacyCo
                 `command = ${tomlBasicString(command)}\n` +
                 `timeout = ${DRAIN_HOOK_TIMEOUT_SECONDS}\n`;
     }
+    for (const event of ["PostToolUse", "Stop"]) {
+        if (isPlainObject(current.hooks) && groupsContainCommand(current.hooks[event], command))
+            continue;
+        const sep = text === "" || text.endsWith("\n") ? "" : "\n";
+        text += `${sep}\n# hq lanes: drop-box delivery\n[[hooks.${event}]]\nmatcher = ".*"\n\n[[hooks.${event}.hooks]]\ntype = "command"\ncommand = ${tomlBasicString(command)}\ntimeout = ${DRAIN_HOOK_TIMEOUT_SECONDS}\n`;
+    }
     const check = parseTomlOrThrow(text, configPath, "after merge");
-    if (!tomlHasCommand(check, command) || !tomlHooksFeatureEnabled(check)) {
+    if (!tomlHasCommand(check, command) ||
+        !isPlainObject(check.hooks) ||
+        !groupsContainCommand(check.hooks.PostToolUse, command) ||
+        !groupsContainCommand(check.hooks.Stop, command) ||
+        !tomlHooksFeatureEnabled(check)) {
         throw new LanesError("config_toml_merge_failed", `Merged ${configPath} does not carry the drain registration; refusing to write it`, { path: configPath, command });
     }
     return { text, changed: true };
@@ -479,7 +499,7 @@ export function probeDrainHookRegistration(provider, providerHome) {
     const parsed = parseLaneProvider(provider);
     const kind = PROVIDER_REGISTRATION_KIND[parsed];
     const regPath = drainHookRegistrationPath(parsed, providerHome);
-    const command = drainHookCommand(drainHookShPath(providerHome));
+    const command = drainHookCommand(drainHookShPath(providerHome), parsed);
     const text = readTextIfExists(regPath);
     const base = { kind, path: regPath, command, file_present: text !== null };
     if (text === null)
@@ -493,11 +513,11 @@ export function probeDrainHookRegistration(provider, providerHome) {
             };
         }
         const json = JSON.parse(text);
+        const hooks = isPlainObject(json) && isPlainObject(json.hooks) ? json.hooks : null;
         return {
             ...base,
-            registered: isPlainObject(json) &&
-                isPlainObject(json.hooks) &&
-                groupsContainDrainCommand(json.hooks.PreToolUse, command),
+            registered: hooks !== null &&
+                (parsed === "grok" ? ["PreToolUse"] : ["PreToolUse", "PostToolUse", "Stop"]).every((event) => groupsContainDrainCommand(hooks[event], command)),
         };
     }
     catch (err) {
@@ -508,9 +528,9 @@ export function probeDrainHookRegistration(provider, providerHome) {
 function registerDrainHook(provider, providerHome, shPath) {
     const kind = PROVIDER_REGISTRATION_KIND[provider];
     const regPath = drainHookRegistrationPath(provider, providerHome);
-    const command = drainHookCommand(shPath);
+    const command = drainHookCommand(shPath, provider);
     if (kind === "hooks_dir") {
-        const changed = writeIfChanged(regPath, renderDrainHookJson(shPath), 0o644);
+        const changed = writeIfChanged(regPath, renderDrainHookJson(shPath, provider), 0o644);
         return { kind, path: regPath, command, changed };
     }
     const existing = readTextIfExists(regPath);

package/dist/lib/lanes/monitor.js

@@ -422,7 +422,7 @@ export function monitorReminderText() {
         "For active Claude senior lanes, arm one live Claude Code Monitor task per uncovered lane:",
         'Monitor(command="hq lanes watch <lane-id>...", timeout_ms=1800000, persistent=true)',
         "Use `hq lanes monitor-check --session <id>` to verify coverage. `persistent=true` is requested where the installed Monitor tool honors it; Claude Code caps Monitor tasks at 30 minutes, so re-arm after expiry.",
-        "The caller must pass `--engine codex` or `--engine grok` (or set HQ_CONDUCT_ENGINE) for sessions whose engine has no Claude Monitor tool; those engines are never required to provide one.",
+        "The caller must pass `--engine codex` or `--engine grok` (or set HQ_LANE_ENGINE; deprecated alias HQ_CONDUCT_ENGINE) for sessions whose engine has no Claude Monitor tool; those engines are never required to provide one.",
     ].join("\n");
 }
 //# sourceMappingURL=monitor.js.map

package/dist/lib/lanes/reaper.d.ts

@@ -0,0 +1,58 @@
+import type { LaneRecord } from "./types.js";
+export declare const DEFAULT_REAP_MIN_AGE_MINUTES = 120;
+export declare const REAP_SINGLE_FLIGHT_LOCK_STALE_MS: number;
+export declare const REAP_RECENT_SWEEP_MS: number;
+export interface ReapProcess {
+    pid: number;
+    ppid: number;
+    args: string;
+}
+export interface ReapFinding {
+    lane_id: string;
+    orphaned: boolean;
+    reason: string;
+    age_minutes: number;
+    session_id?: string;
+    pid?: number;
+    process_starttime?: number | null;
+    would_stop?: boolean;
+    stopped?: boolean;
+    stop_complete?: boolean;
+    stop_error?: string;
+    stale_state?: string[];
+}
+export interface ReapDeps {
+    now?: () => Date;
+    hostname?: () => string;
+    processes?: () => ReapProcess[];
+    isAlive?: (pid: number) => boolean;
+    readStarttime?: (pid: number) => number | null;
+    sessionState?: (root: string, sessionId: string, now: Date) => string | null;
+    stopEnabled?: (lane: LaneRecord) => Promise<boolean> | boolean;
+    stopLane?: (laneId: string, reason: string) => Promise<void>;
+    sleep?: (ms: number) => void;
+}
+export declare function parseReapMinAge(value: string | undefined): number;
+export declare function isProcessRunning(pid: number): boolean;
+export declare function classifyLocalLanes(root: string, now: Date, minAgeMinutes: number, deps?: ReapDeps): Promise<ReapFinding[]>;
+export interface ReapOptions {
+    minAgeMinutes: number;
+    stop: boolean;
+    applyStaleState: boolean;
+    reason: string;
+    json: boolean;
+}
+export interface ReapSummary {
+    ok: true;
+    action: "lanes.reap";
+    generated_at: string;
+    min_age_minutes: number;
+    mode: "report" | "apply_stale_state" | "stop";
+    stop_enabled: boolean;
+    skipped?: "already_running" | "recent_sweep";
+    lanes: ReapFinding[];
+}
+export declare function reapLocalLanes(root: string, options: ReapOptions, deps?: ReapDeps): Promise<ReapSummary>;
+/** Internal alias used by session-start hooks; it has no shell or OS-specific dependency. */
+export declare const runSessionStartReap: typeof reapLocalLanes;
+//# sourceMappingURL=reaper.d.ts.map