@indigoai-us/hq-cli 5.273.0-alpha.0 → 5.273.0

package/dist/lib/lanes/hire-grant-dispatch.d.ts

@@ -5,15 +5,20 @@ export interface HireGrantLaneSnapshot {
     state: LaneState;
     senior: SeniorRef;
     hire_grant?: number;
+    created_at?: string;
+    company?: LaneRecord["company"];
+    project_id?: string;
+    worker_profile?: string;
 }
 export interface OutpostHireGrantContext {
     schema_version: typeof HIRE_GRANT_CONTEXT_SCHEMA;
     enforcement_enabled: boolean;
     expected_senior: SeniorRef;
     hierarchy: HireGrantLaneSnapshot[];
+    superseded_message_caller_id?: string;
 }
 /** Encode only the owner-relevant hierarchy from the primary's complete store. */
-export declare function createOutpostHireGrantContext(target: LaneRecord, lanes: readonly LaneRecord[]): string;
+export declare function createOutpostHireGrantContext(target: LaneRecord, lanes: readonly LaneRecord[], supersededMessageCallerId?: string): string;
 /** Decode and validate an owner grant context, binding it to the target lane. */
 export declare function parseOutpostHireGrantContext(encoded: string, targetLaneId: string): OutpostHireGrantContext;
 export declare function sameHireGrantSenior(a: SeniorRef, b: SeniorRef): boolean;

package/dist/lib/lanes/hire-grant-dispatch.js

@@ -20,11 +20,17 @@ function snapshot(lane) {
         lane_id: lane.lane_id,
         state: lane.state,
         senior: copySenior(lane.senior),
+        created_at: lane.created_at,
+        ...(lane.company === undefined
+            ? {}
+            : { company: lane.company === null ? null : { ...lane.company } }),
+        ...(lane.project_id === undefined ? {} : { project_id: lane.project_id }),
+        ...(lane.worker_profile === undefined ? {} : { worker_profile: lane.worker_profile }),
         ...(lane.hire_grant === undefined ? {} : { hire_grant: lane.hire_grant }),
     };
 }
 /** Encode only the owner-relevant hierarchy from the primary's complete store. */
-export function createOutpostHireGrantContext(target, lanes) {
+export function createOutpostHireGrantContext(target, lanes, supersededMessageCallerId) {
     const current = lanes.find((lane) => lane.lane_id === target.lane_id);
     if (!current || !sameSenior(current.senior, target.senior)) {
         throw new LanesError("hire_grant_hierarchy_unavailable", `Cannot build an authoritative hire-grant hierarchy for lane ${target.lane_id}`, { lane_id: target.lane_id });
@@ -45,6 +51,20 @@ export function createOutpostHireGrantContext(target, lanes) {
     for (const child of aliveDirectChildren(lanes, current.lane_id)) {
         relevant.set(child.lane_id, child);
     }
+    if (supersededMessageCallerId !== undefined) {
+        const messageCaller = lanes.find((lane) => lane.lane_id === supersededMessageCallerId);
+        const companyUid = current.company?.uid;
+        const projectId = current.project_id;
+        if (!messageCaller || !companyUid || !projectId ||
+            messageCaller.company?.uid !== companyUid || messageCaller.project_id !== projectId) {
+            throw new LanesError("hire_grant_message_caller_invalid", `Cannot include an unverified message caller ${supersededMessageCallerId} in lane ${target.lane_id}'s Outpost context`, { lane_id: target.lane_id, caller_lane_id: supersededMessageCallerId });
+        }
+        for (const candidate of lanes) {
+            if (candidate.company?.uid === companyUid && candidate.project_id === projectId) {
+                relevant.set(candidate.lane_id, candidate);
+            }
+        }
+    }
     const hierarchy = [...relevant.values()]
         .map(snapshot)
         .sort((a, b) => a.lane_id.localeCompare(b.lane_id));
@@ -56,6 +76,9 @@ export function createOutpostHireGrantContext(target, lanes) {
         enforcement_enabled: true,
         expected_senior: copySenior(current.senior),
         hierarchy,
+        ...(supersededMessageCallerId === undefined
+            ? {}
+            : { superseded_message_caller_id: supersededMessageCallerId }),
     };
     const encoded = Buffer.from(JSON.stringify(context), "utf8").toString("base64url");
     if (Buffer.byteLength(encoded, "utf8") > MAX_CONTEXT_BYTES) {
@@ -86,7 +109,9 @@ function parseLaneSnapshot(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         return null;
     const record = value;
-    if (Object.keys(record).some((key) => !["lane_id", "state", "senior", "hire_grant"].includes(key)))
+    if (Object.keys(record).some((key) => ![
+        "lane_id", "state", "senior", "hire_grant", "created_at", "company", "project_id", "worker_profile",
+    ].includes(key)))
         return null;
     if (typeof record.lane_id !== "string" || !record.lane_id.trim())
         return null;
@@ -99,11 +124,44 @@ function parseLaneSnapshot(value) {
         (typeof record.hire_grant !== "number" || !Number.isSafeInteger(record.hire_grant) || record.hire_grant < 0)) {
         return null;
     }
+    if (record.created_at !== undefined &&
+        (typeof record.created_at !== "string" || !record.created_at.trim() || !Number.isFinite(Date.parse(record.created_at)))) {
+        return null;
+    }
+    if (record.project_id !== undefined &&
+        (typeof record.project_id !== "string" || !record.project_id.trim() || record.project_id.trim() !== record.project_id)) {
+        return null;
+    }
+    if (record.worker_profile !== undefined &&
+        (typeof record.worker_profile !== "string" || !record.worker_profile.trim())) {
+        return null;
+    }
+    let company;
+    if (Object.hasOwn(record, "company")) {
+        if (record.company === null) {
+            company = null;
+        }
+        else if (record.company !== null && typeof record.company === "object" && !Array.isArray(record.company)) {
+            const companyRecord = record.company;
+            if (Object.keys(companyRecord).some((key) => key !== "slug" && key !== "uid") ||
+                typeof companyRecord.slug !== "string" || !companyRecord.slug.trim() ||
+                typeof companyRecord.uid !== "string" || !companyRecord.uid.trim())
+                return null;
+            company = { slug: companyRecord.slug, uid: companyRecord.uid };
+        }
+        else {
+            return null;
+        }
+    }
     return {
         lane_id: record.lane_id,
         state: record.state,
         senior,
         ...(record.hire_grant === undefined ? {} : { hire_grant: record.hire_grant }),
+        ...(record.created_at === undefined ? {} : { created_at: record.created_at }),
+        ...(company === undefined ? {} : { company }),
+        ...(record.project_id === undefined ? {} : { project_id: record.project_id }),
+        ...(record.worker_profile === undefined ? {} : { worker_profile: record.worker_profile }),
     };
 }
 /** Decode and validate an owner grant context, binding it to the target lane. */
@@ -125,7 +183,7 @@ export function parseOutpostHireGrantContext(encoded, targetLaneId) {
         throw contextError("Outpost grant context must be an object");
     }
     const record = raw;
-    if (Object.keys(record).some((key) => !["schema_version", "enforcement_enabled", "expected_senior", "hierarchy"].includes(key))) {
+    if (Object.keys(record).some((key) => !["schema_version", "enforcement_enabled", "expected_senior", "hierarchy", "superseded_message_caller_id"].includes(key))) {
         throw contextError("Outpost grant context contains unknown fields");
     }
     if (record.schema_version !== HIRE_GRANT_CONTEXT_SCHEMA ||
@@ -135,6 +193,11 @@ export function parseOutpostHireGrantContext(encoded, targetLaneId) {
         throw contextError("Outpost grant context has an unsupported or incomplete shape");
     }
     const expectedSenior = parseSenior(record.expected_senior);
+    const messageCallerId = record.superseded_message_caller_id;
+    if (messageCallerId !== undefined &&
+        (typeof messageCallerId !== "string" || !messageCallerId.trim() || messageCallerId.trim() !== messageCallerId)) {
+        throw contextError("Outpost grant context contains an invalid superseded-message caller");
+    }
     const hierarchy = record.hierarchy.map(parseLaneSnapshot);
     if (!expectedSenior || hierarchy.some((lane) => lane === null)) {
         throw contextError("Outpost grant context contains an invalid senior or lane snapshot");
@@ -152,11 +215,23 @@ export function parseOutpostHireGrantContext(encoded, targetLaneId) {
         (!expectedSenior.id || !byId.has(expectedSenior.id))) {
         throw contextError("Outpost grant context is missing the target's senior lane");
     }
+    if (messageCallerId !== undefined && !byId.has(messageCallerId)) {
+        throw contextError("Outpost grant context is missing its superseded-message caller lane");
+    }
+    if (messageCallerId !== undefined) {
+        const caller = byId.get(messageCallerId);
+        if (snapshots.some((lane) => lane.created_at === undefined || !Object.hasOwn(lane, "company")) ||
+            !target.company?.uid || !target.project_id ||
+            caller?.company?.uid !== target.company.uid || caller.project_id !== target.project_id) {
+            throw contextError("Outpost grant context is missing its superseded-message hierarchy metadata");
+        }
+    }
     return {
         schema_version: HIRE_GRANT_CONTEXT_SCHEMA,
         enforcement_enabled: record.enforcement_enabled,
         expected_senior: expectedSenior,
         hierarchy: snapshots,
+        ...(messageCallerId === undefined ? {} : { superseded_message_caller_id: messageCallerId }),
     };
 }
 export function sameHireGrantSenior(a, b) {

package/dist/lib/lanes/keep-alive.d.ts

@@ -7,6 +7,7 @@ export declare const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
 export declare const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS: number;
+export type KeepAliveLane = Pick<LaneRecord, "lane_id" | "created_at" | "senior" | "company" | "project_id"> & Partial<Pick<LaneRecord, "mesh_company" | "worker_profile" | "hire_grant" | "provider_session_id" | "last_resume" | "state">>;
 export interface LaneTerminalResumeResult {
     lane: LaneRecord;
     resumeQueued: boolean;
@@ -40,7 +41,7 @@ export declare function retiredLaneRegistryPath(hqRoot: string): string;
 export declare function loadRetiredLaneIds(hqRoot: string): ReadonlySet<string>;
 /** IDs may be stored bare or with an owner-host suffix after an underscore. */
 export declare function isRetiredLaneId(laneId: string, retiredLaneIds: ReadonlySet<string>): boolean;
-export declare function keepAliveSupersededBy(lane: LaneRecord, lanes: readonly LaneRecord[], lineageAware?: boolean, companyForLane?: (lane: LaneRecord) => LaneRecord["company"]): LaneRecord | undefined;
-export declare function keepAliveExclusion(lane: LaneRecord, lanes: readonly LaneRecord[], retiredLaneIds: ReadonlySet<string>, lineageAware?: boolean, companyForLane?: (lane: LaneRecord) => LaneRecord["company"]): "retired" | "superseded" | undefined;
+export declare function keepAliveSupersededBy<T extends KeepAliveLane>(lane: T, lanes: readonly T[], lineageAware?: boolean, companyForLane?: (lane: T) => T["company"]): T | undefined;
+export declare function keepAliveExclusion<T extends KeepAliveLane>(lane: T, lanes: readonly T[], retiredLaneIds: ReadonlySet<string>, lineageAware?: boolean, companyForLane?: (lane: T) => T["company"]): "retired" | "superseded" | undefined;
 export declare function leadLaneKeepAliveBackoffMs(attempt: number): number;
 //# sourceMappingURL=keep-alive.d.ts.map

package/dist/lib/lanes/keep-alive.js

@@ -204,7 +204,7 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
     if (!Number.isFinite(createdAt))
         return undefined;
     const companyOf = companyForLane ?? ((candidate) => candidate.company);
-    const laneCompany = companyOf(lane);
+    const laneCompany = companyOf(lane) ?? null;
     const lanesById = new Map(lanes.map((candidate) => [candidate.lane_id, candidate]));
     lanesById.set(lane.lane_id, lane);
     const sessionOwners = new Map();
@@ -223,7 +223,7 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
             return false;
         if (candidate.state === "cancelled" || candidate.state === "killed" || candidate.state === "failed")
             return false;
-        const candidateCompany = companyOf(candidate);
+        const candidateCompany = companyOf(candidate) ?? null;
         const sameCompany = laneCompany === null
             ? candidateCompany === null
             : candidateCompany?.uid === laneCompany.uid;

package/dist/lib/lanes/merge-command.d.ts

@@ -8,6 +8,7 @@ export interface MergeCommandTarget {
 export interface MergeCommandParseResult {
     targets: MergeCommandTarget[];
     unresolved: boolean;
+    unparseableMerge: boolean;
 }
 export declare function canonicalRepo(raw: string): string;
 export declare function parseMergeCommands(command: string): MergeCommandParseResult;

package/dist/lib/lanes/merge-command.js

@@ -1,4 +1,6 @@
+import * as path from "node:path";
 import { LanesError } from "./errors.js";
+const MAX_COMMAND_WRAPPER_DEPTH = 4;
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -45,11 +47,13 @@ function splitCommandChain(command) {
             current += character;
             continue;
         }
-        if (character === ";" || character === "|") {
+        if (character === ";" || character === "|" || character === "\n" || character === "\r") {
             segments.push(current.trim());
             current = "";
             if (character === "|" && command[index + 1] === "|")
                 index += 1;
+            if (character === "\r" && command[index + 1] === "\n")
+                index += 1;
             continue;
         }
         if (character === "&" && command[index + 1] === "&") {
@@ -69,16 +73,26 @@ function splitCommandChain(command) {
 function shellWords(segment) {
     const words = [];
     let current = "";
+    let wordStarted = false;
     let quote = null;
     let escaped = false;
+    const finishWord = () => {
+        if (!wordStarted)
+            return;
+        words.push(current);
+        current = "";
+        wordStarted = false;
+    };
     for (const character of segment) {
         if (escaped) {
             current += character;
+            wordStarted = true;
             escaped = false;
             continue;
         }
         if (character === "\\" && quote !== "'") {
             escaped = true;
+            wordStarted = true;
             continue;
         }
         if (quote) {
@@ -86,24 +100,24 @@ function shellWords(segment) {
                 quote = null;
             else
                 current += character;
+            wordStarted = true;
             continue;
         }
         if (character === "'" || character === "\"") {
             quote = character;
+            wordStarted = true;
             continue;
         }
         if (/\s/.test(character)) {
-            if (current)
-                words.push(current);
-            current = "";
+            finishWord();
             continue;
         }
         current += character;
+        wordStarted = true;
     }
-    if (escaped)
-        current += "\\";
-    if (current)
-        words.push(current);
+    if (quote !== null || escaped)
+        return fail("repo_hold_command_invalid", "Command has an unclosed quote or escape");
+    finishWord();
     return words;
 }
 function optionRepo(words) {
@@ -163,10 +177,8 @@ function skipEnvOptions(words, start) {
         }
         if (word === "--")
             return index + 1;
-        if (word.startsWith("-")) {
-            index += 1;
-            continue;
-        }
+        if (word.startsWith("-"))
+            return -1;
         break;
     }
     return index;
@@ -191,32 +203,223 @@ function skipTimeoutOptions(words, start) {
             index += 1;
             continue;
         }
-        if (word.startsWith("-")) {
-            index += 1;
-            continue;
-        }
+        if (word.startsWith("-"))
+            return -1;
         break;
     }
-    return Math.min(index + 1, words.length);
+    const duration = words[index];
+    if (!duration || !/^(?:\d+(?:\.\d*)?|\.\d+)(?:s|m|h|d)?$/.test(duration))
+        return -1;
+    index += 1;
+    if (words[index] === "--")
+        index += 1;
+    return index < words.length ? index : -1;
 }
-function unwrapCommand(words) {
-    let index = 0;
+const SHELL_SHORT_OPTIONS = new Set(["a", "b", "B", "C", "e", "E", "f", "h", "H", "i", "k", "l", "m", "n", "p", "P", "r", "s", "t", "T", "u", "v", "x"]);
+const SHELL_LONG_OPTIONS = new Set([
+    "--interactive", "--login", "--noprofile", "--norc", "--posix", "--restricted",
+    "--verbose", "--noediting", "--debugger",
+]);
+const SHELL_LONG_VALUE_OPTIONS = new Set(["--rcfile", "--init-file", "--emulate"]);
+function shellCommandWrapper(words) {
+    let index = 1;
     while (index < words.length) {
-        if (SHELL_ASSIGNMENT.test(words[index] ?? "")) {
+        const option = words[index] ?? "";
+        if (option === "--")
+            return null;
+        if (SHELL_LONG_VALUE_OPTIONS.has(option)) {
+            if (!words[index + 1])
+                return { kind: "invalid" };
+            index += 2;
+            continue;
+        }
+        if ([...SHELL_LONG_VALUE_OPTIONS].some((name) => option.startsWith(`${name}=`))) {
             index += 1;
             continue;
         }
-        if (words[index] === "env") {
-            index = skipEnvOptions(words, index);
+        if (SHELL_LONG_OPTIONS.has(option)) {
+            index += 1;
             continue;
         }
-        if (words[index] === "timeout") {
-            index = skipTimeoutOptions(words, index);
+        if (option.startsWith("--"))
+            return { kind: "invalid" };
+        if ((option.startsWith("-") || option.startsWith("+")) && option.length > 1) {
+            const flags = option.slice(1);
+            let consumedOptionValue = false;
+            for (let flagIndex = 0; flagIndex < flags.length; flagIndex += 1) {
+                const flag = flags[flagIndex] ?? "";
+                if (flag === "c") {
+                    const script = words[index + 1];
+                    return script === undefined ? { kind: "invalid" } : { kind: "script", script };
+                }
+                if (flag === "o" || flag === "O") {
+                    if (flagIndex + 1 < flags.length) {
+                        index += 1;
+                        consumedOptionValue = true;
+                        break;
+                    }
+                    if (!words[index + 1])
+                        return { kind: "invalid" };
+                    index += 2;
+                    consumedOptionValue = true;
+                    break;
+                }
+                if (!SHELL_SHORT_OPTIONS.has(flag))
+                    return { kind: "invalid" };
+            }
+            if (!consumedOptionValue)
+                index += 1;
             continue;
         }
-        break;
+        return null;
+    }
+    return null;
+}
+function commandWrapper(words) {
+    const command = path.basename(words[0] ?? "").toLowerCase();
+    if (["bash", "sh", "zsh"].includes(command))
+        return shellCommandWrapper(words);
+    if (command === "sudo") {
+        let index = 1;
+        while (index < words.length) {
+            const option = words[index] ?? "";
+            if (option === "--") {
+                index += 1;
+                break;
+            }
+            if (option === "-u" || option === "--user") {
+                if (!words[index + 1])
+                    return { kind: "invalid" };
+                index += 2;
+                continue;
+            }
+            if (option.startsWith("--user=") || /^-u.+/.test(option)) {
+                index += 1;
+                continue;
+            }
+            if (["-A", "-b", "-E", "-H", "-K", "-k", "-n", "-P", "-S", "-V", "--askpass", "--background", "--preserve-env", "--set-home", "--remove-timestamp", "--reset-timestamp", "--non-interactive", "--preserve-groups", "--stdin", "--version"].includes(option)) {
+                index += 1;
+                continue;
+            }
+            if (option.startsWith("-"))
+                return { kind: "invalid" };
+            break;
+        }
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "command") {
+        let index = 1;
+        while (words[index] === "-p")
+            index += 1;
+        if (words[index] === "--")
+            index += 1;
+        if (words[index]?.startsWith("-"))
+            return { kind: "invalid" };
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
     }
-    return words.slice(index);
+    if (command === "env") {
+        const index = skipEnvOptions(words, 0);
+        if (index < 0)
+            return { kind: "invalid" };
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "timeout") {
+        const index = skipTimeoutOptions(words, 0);
+        return index >= 0 ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "nice") {
+        let index = 1;
+        while (index < words.length) {
+            const option = words[index] ?? "";
+            if (option === "--") {
+                index += 1;
+                break;
+            }
+            if (option === "-n" || option === "--adjustment") {
+                if (!/^-?\d+$/.test(words[index + 1] ?? ""))
+                    return { kind: "invalid" };
+                index += 2;
+                continue;
+            }
+            if (/^--adjustment=-?\d+$/.test(option) || /^-\d+$/.test(option)) {
+                index += 1;
+                continue;
+            }
+            if (option.startsWith("-"))
+                return { kind: "invalid" };
+            break;
+        }
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "nohup") {
+        const index = words[1] === "--" ? 2 : 1;
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    return null;
+}
+function containsMergeCandidate(command) {
+    // This lossy scan only decides whether malformed input resembles a merge;
+    // the parser never uses it to recover a command or target.
+    const words = command.replace(/["'`\\]/g, " ").match(/\S+/g) ?? [];
+    const valueOptions = new Set([
+        "-R", "--repo", "--hostname", "--config", "--cache", "--jq", "--template",
+        "--preview", "--http-unix-socket", "--git-protocol",
+    ]);
+    for (let index = 0; index < words.length; index += 1) {
+        if (words[index]?.toLowerCase() !== "gh")
+            continue;
+        let subcommandIndex = index + 1;
+        while (subcommandIndex < words.length) {
+            const word = words[subcommandIndex] ?? "";
+            if (word === "--")
+                break;
+            if (valueOptions.has(word)) {
+                if (subcommandIndex + 1 >= words.length)
+                    break;
+                subcommandIndex += 2;
+                continue;
+            }
+            if (word.startsWith("--repo=") || word.startsWith("--hostname=") || /^-R.+/.test(word)) {
+                subcommandIndex += 1;
+                continue;
+            }
+            if (word.startsWith("-")) {
+                subcommandIndex += 1;
+                continue;
+            }
+            break;
+        }
+        const subcommand = words[subcommandIndex];
+        if (subcommand === "pr") {
+            let actionIndex = subcommandIndex + 1;
+            while (actionIndex < words.length) {
+                const word = words[actionIndex] ?? "";
+                if (word === "--")
+                    break;
+                if (valueOptions.has(word)) {
+                    if (actionIndex + 1 >= words.length)
+                        break;
+                    actionIndex += 2;
+                    continue;
+                }
+                if (word.startsWith("--repo=") || word.startsWith("--hostname=") || /^-R.+/.test(word)) {
+                    actionIndex += 1;
+                    continue;
+                }
+                if (word.startsWith("-")) {
+                    actionIndex += 1;
+                    continue;
+                }
+                break;
+            }
+            if (words[actionIndex] === "merge")
+                return true;
+        }
+        if (subcommand === "api" && words.slice(subcommandIndex + 1).some((word) => /\/merge\b/i.test(word) || /\bmergePullRequest\b/i.test(word))) {
+            return true;
+        }
+    }
+    return false;
 }
 function parsePullUrl(raw) {
     if (!/^https?:\/\//i.test(raw))
@@ -330,8 +533,7 @@ function apiMergeTarget(words, apiIndex) {
     }
     return null;
 }
-function parseSegment(segment) {
-    const words = unwrapCommand(shellWords(segment));
+function parseSegmentWords(words) {
     if (words[0] === "git" && words.slice(1).includes("merge")) {
         return {
             kind: "git",
@@ -351,13 +553,77 @@ function parseSegment(segment) {
         return null;
     return apiMergeTarget(words, apiIndex);
 }
+function unparseableMergeTarget() {
+    return {
+        kind: "pr",
+        repo: null,
+        pr: null,
+        pinnedHead: null,
+        unresolvedReason: "merge command could not be parsed safely",
+    };
+}
+function recordUnparseableMerge(state) {
+    state.unparseableMerge = true;
+    state.targets.push(unparseableMergeTarget());
+}
+function parseCommandWords(words, source, depth, state) {
+    let commandWords = words;
+    while (SHELL_ASSIGNMENT.test(commandWords[0] ?? ""))
+        commandWords = commandWords.slice(1);
+    if (commandWords.length === 0)
+        return;
+    const wrapper = commandWrapper(commandWords);
+    if (wrapper) {
+        if (wrapper.kind === "invalid" || depth >= MAX_COMMAND_WRAPPER_DEPTH) {
+            if (containsMergeCandidate(source))
+                recordUnparseableMerge(state);
+            return;
+        }
+        if (wrapper.kind === "script") {
+            parseCommandList(wrapper.script, depth + 1, state);
+            return;
+        }
+        parseCommandWords(wrapper.words, source, depth + 1, state);
+        return;
+    }
+    const target = parseSegmentWords(commandWords);
+    if (target)
+        state.targets.push(target);
+}
+function parseCommandList(command, depth, state) {
+    let segments;
+    try {
+        segments = splitCommandChain(command);
+    }
+    catch (error) {
+        if (error instanceof LanesError && error.error === "repo_hold_command_invalid" && containsMergeCandidate(command)) {
+            recordUnparseableMerge(state);
+            return;
+        }
+        throw error;
+    }
+    for (const segment of segments) {
+        let words;
+        try {
+            words = shellWords(segment);
+        }
+        catch (error) {
+            if (error instanceof LanesError && error.error === "repo_hold_command_invalid" && containsMergeCandidate(segment)) {
+                recordUnparseableMerge(state);
+                continue;
+            }
+            throw error;
+        }
+        parseCommandWords(words, segment, depth, state);
+    }
+}
 export function parseMergeCommands(command) {
-    const targets = splitCommandChain(command)
-        .map(parseSegment)
-        .filter((target) => target !== null);
+    const state = { targets: [], unparseableMerge: false };
+    parseCommandList(command, 0, state);
     return {
-        targets,
-        unresolved: targets.some((target) => target.unresolvedReason !== null),
+        targets: state.targets,
+        unresolved: state.targets.some((target) => target.unresolvedReason !== null),
+        unparseableMerge: state.unparseableMerge,
     };
 }
 //# sourceMappingURL=merge-command.js.map

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

@@ -1,5 +1,6 @@
 import { type LaneRecord, type SeniorRef } from "./types.js";
 export declare const DEFAULT_ORPHAN_MIN_AGE_MINUTES = 30;
+export declare const DEFAULT_ORPHAN_USER_IDLE_HOURS = 72;
 export interface OrphanLaneFinding {
     lane_id: string;
     senior: SeniorRef;
@@ -7,12 +8,18 @@ export interface OrphanLaneFinding {
     age_minutes: number;
     account: string | null;
     host: LaneRecord["host"];
+    reason: "senior_ended" | "senior_missing" | "user_idle";
 }
 export declare function parseOrphanMinAge(value: string | undefined): number;
+export declare function parseOrphanUserIdleHours(value: string | undefined): number;
 export declare function findOrphanLanes(input: {
     lanes: readonly LaneRecord[];
+    candidateLaneIds: ReadonlySet<string>;
     now: Date;
     minAgeMinutes: number;
+    userIdleHours: number;
     sessionState: (sessionId: string, now: Date) => string | null;
+    lastActivityAt: (lane: LaneRecord) => number;
+    hasOpenStory: (lane: LaneRecord) => boolean;
 }): OrphanLaneFinding[];
 //# sourceMappingURL=orphans.d.ts.map