@indigoai-us/hq-cli 5.268.0 → 5.269.0

package/dist/commands/lanes.js

@@ -23,6 +23,7 @@ import { registerLaneChecksCommand } from "./lanes-checks.js";
 import { registerLaneReportCommands } from "./lanes-report.js";
 import { registerLaneTrackerImportCommand } from "./lanes-import.js";
 import { registerLaneRepoMergeHoldCommand } from "./lanes-hold.js";
+import { registerLaneReviewCommand } from "./lanes-review.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
@@ -47,6 +48,7 @@ import { CompanySelectionError } from "../utils/company-selection-error.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
+import { listLaneReviews } from "../lib/lanes/reviews.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
@@ -291,6 +293,7 @@ function resolveDeps(deps = {}) {
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
         laneTrackerEnabled: deps.laneTrackerEnabled ?? defaultLaneTrackerEnabled,
+        mergeReviewEnabled: deps.mergeReviewEnabled,
         trackerActor: deps.trackerActor ?? defaultTrackerActor,
     };
 }
@@ -4541,10 +4544,26 @@ async function runShow(ctx, laneId) {
         env: ctx.env,
         now: ctx.now().getTime(),
     });
+    const laneIsSenior = allLanes.some((item) => item.senior.kind === "lane" && item.senior.id === laneId);
+    const now = ctx.now().getTime();
+    const reviewListing = laneIsSenior
+        ? listLaneReviews(hqRoot, laneId)
+        : { reviews: [], skipped: 0 };
+    if (reviewListing.skipped > 0) {
+        console.error(`hq lanes show: skipped ${reviewListing.skipped} invalid or unreadable review item(s)`);
+    }
+    const recentReviews = reviewListing.reviews
+        .filter((item) => {
+        const recordedAt = Date.parse(item.recorded_at);
+        return recordedAt >= now - 24 * 60 * 60 * 1000 && recordedAt <= now;
+    })
+        .slice(0, 20)
+        .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
     printJson({
         ok: true,
         action: "show",
         lane,
+        ...(laneIsSenior ? { reviews: recentReviews, reviews_skipped: reviewListing.skipped } : {}),
         ...hire,
         overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
         stalled: Boolean(lane.stalled),
@@ -4741,7 +4760,7 @@ async function runKeepAlive(ctx, laneId, opts) {
         const initialLane = readLane(hqRoot, laneId);
         assertKeepAliveChangeAllowed(ctx, initialLane, laneId);
         lineageAware = await readLanesRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, {
-            company: initialLane.company,
+            company: resolveLaneCompany(hqRoot, initialLane).company ?? undefined,
             env: ctx.env,
         });
     }
@@ -6927,6 +6946,12 @@ export function registerLanesCommand(parent, deps = {}) {
         resolveCompany: ctx.resolveCompany,
         now: ctx.now,
         env: ctx.env,
+        mergeReviewEnabled: ctx.mergeReviewEnabled,
+    }, wrap);
+    registerLaneReviewCommand(lanes, {
+        hqRoot: ctx.hqRoot,
+        env: ctx.env,
+        now: ctx.now,
     }, wrap);
     registerOutpostPrunerCommand(lanes);
     registerLaneKpisCommand(lanes, { hqRoot: ctx.hqRoot, now: ctx.now, wrap });

package/dist/lib/lanes/blocker-freshness.js

@@ -4,6 +4,7 @@ import { LanesError } from "./errors.js";
 import { DEFAULT_BLOCKER_FRESHNESS_HOURS, loadLanesConfig } from "./config.js";
 import { resolveManagerStatusTarget } from "./manager-status-gate.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { resolveLaneCompany } from "./lane-company.js";
 import { assertNoSecretText } from "./text-scan.js";
 export const BLOCKER_FRESHNESS_FLAG = "lanes.blocker-freshness";
 export const BLOCKER_FRESHNESS_DEFAULT_HOURS = DEFAULT_BLOCKER_FRESHNESS_HOURS;
@@ -100,7 +101,7 @@ export async function resolveBlockerFreshnessForLane(root, lane, options = {}) {
     let flagEnabled;
     try {
         flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(BLOCKER_FRESHNESS_FLAG, {
-            company: lane.company ?? lane.mesh_company ?? undefined,
+            company: resolveLaneCompany(root, lane).company ?? undefined,
             env: options.env,
         });
     }

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

@@ -206,20 +206,23 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
     const companyOf = companyForLane ?? ((candidate) => candidate.company);
     const laneCompany = companyOf(lane);
     const lanesById = new Map(lanes.map((candidate) => [candidate.lane_id, candidate]));
-    const targetAncestorIds = new Set();
-    if (lineageAware) {
-        let parentLaneId = lane.senior.kind === "lane" ? lane.senior.id : undefined;
-        while (parentLaneId) {
-            if (targetAncestorIds.has(parentLaneId))
-                break;
-            targetAncestorIds.add(parentLaneId);
-            const parent = lanesById.get(parentLaneId);
-            parentLaneId = parent?.senior.kind === "lane" ? parent.senior.id : undefined;
+    lanesById.set(lane.lane_id, lane);
+    const sessionOwners = new Map();
+    for (const owner of lanesById.values()) {
+        for (const sessionId of recordedLaneSessionIds(owner)) {
+            const owners = sessionOwners.get(sessionId) ?? new Set();
+            owners.add(owner.lane_id);
+            sessionOwners.set(sessionId, owners);
         }
     }
+    const targetAncestorIds = lineageAware
+        ? laneAncestorsFrom(lane.senior, lanesById, sessionOwners)
+        : new Set();
     return lanes.find((candidate) => {
         if (candidate.lane_id === lane.lane_id || Date.parse(candidate.created_at) <= createdAt)
             return false;
+        if (candidate.state === "cancelled" || candidate.state === "killed" || candidate.state === "failed")
+            return false;
         const candidateCompany = companyOf(candidate);
         const sameCompany = laneCompany === null
             ? candidateCompany === null
@@ -229,17 +232,8 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
         if (lineageAware && targetAncestorIds.has(candidate.lane_id))
             return false;
         // Any descendant is part of this lead's work tree, not a replacement lead.
-        let parentLaneId = candidate.senior.kind === "lane" ? candidate.senior.id : undefined;
-        const visitedLaneIds = new Set();
-        while (parentLaneId) {
-            if (parentLaneId === lane.lane_id)
-                return false;
-            if (visitedLaneIds.has(parentLaneId))
-                break;
-            visitedLaneIds.add(parentLaneId);
-            const parent = lanesById.get(parentLaneId);
-            parentLaneId = parent?.senior.kind === "lane" ? parent.senior.id : undefined;
-        }
+        if (laneAncestorsFrom(candidate.senior, lanesById, sessionOwners).has(lane.lane_id))
+            return false;
         const sameLaneSenior = lane.senior.kind === "lane" &&
             candidate.senior.kind === "lane" &&
             candidate.senior.id === lane.senior.id;
@@ -252,6 +246,41 @@ export function keepAliveSupersededBy(lane, lanes, lineageAware = LANE_SUPERSESS
         return sameProfile || projectLead;
     });
 }
+/** Session ids durable lane records still identify as spawn/resume sessions. */
+function recordedLaneSessionIds(lane) {
+    return [lane.provider_session_id, lane.last_resume?.session_id].filter((sessionId) => typeof sessionId === "string" && sessionId.trim().length > 0);
+}
+/** Follow both lane seniors and session seniors back to the lane that owns each session. */
+function laneAncestorsFrom(senior, lanesById, sessionOwners) {
+    const laneIds = new Set();
+    const sessionIds = new Set();
+    const pending = [senior];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        if (current.kind === "lane") {
+            const laneId = current.id;
+            if (typeof laneId !== "string" || laneId.trim().length === 0 || laneIds.has(laneId))
+                continue;
+            laneIds.add(laneId);
+            const parent = lanesById.get(laneId);
+            if (parent !== undefined)
+                pending.push(parent.senior);
+            continue;
+        }
+        if (current.kind !== "session")
+            continue;
+        const sessionId = current.id;
+        if (typeof sessionId !== "string" || sessionId.trim().length === 0 || sessionIds.has(sessionId))
+            continue;
+        sessionIds.add(sessionId);
+        for (const ownerLaneId of sessionOwners.get(sessionId) ?? []) {
+            pending.push({ kind: "lane", id: ownerLaneId });
+        }
+    }
+    return laneIds;
+}
 export function keepAliveExclusion(lane, lanes, retiredLaneIds, lineageAware = LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED, companyForLane) {
     if (isRetiredLaneId(lane.lane_id, retiredLaneIds))
         return "retired";

package/dist/lib/lanes/kr-freshness.js

@@ -5,6 +5,7 @@ import { DEFAULT_KR_FRESHNESS_HOURS, loadLanesConfig } from "./config.js";
 import { LanesError } from "./errors.js";
 import { resolveManagerStatusTarget } from "./manager-status-gate.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
+import { resolveLaneCompany } from "./lane-company.js";
 import { assertNoSecretText } from "./text-scan.js";
 export const KR_FRESHNESS_FLAG = "lanes.kr-freshness";
 export const KR_FRESHNESS_DEFAULT_HOURS = DEFAULT_KR_FRESHNESS_HOURS;
@@ -327,7 +328,7 @@ export async function resolveKrFreshnessForLane(root, lane, options = {}) {
     let flagEnabled;
     try {
         flagEnabled = await (options.readFlag ?? readLanesRegistryFlag)(KR_FRESHNESS_FLAG, {
-            company: lane.company ?? lane.mesh_company ?? undefined,
+            company: resolveLaneCompany(root, lane).company ?? undefined,
             env: options.env,
         });
     }
@@ -378,7 +379,7 @@ export async function resolveKrFreshnessForShow(root, lane, options = {}) {
     let enabled;
     try {
         enabled = await (options.readFlag ?? readLanesRegistryFlag)(KR_FRESHNESS_FLAG, {
-            company: lane.company ?? lane.mesh_company ?? undefined,
+            company: resolveLaneCompany(root, lane).company ?? undefined,
             env: options.env,
         });
     }

package/dist/lib/lanes/lane-company.d.ts

@@ -1,9 +1,10 @@
 import type { LaneCompanyRef, LaneRecord } from "./types.js";
-export type LaneCompanySource = "lane" | "project" | "unresolved";
+export type LaneCompanySource = "lane" | "mesh_company" | "project" | "unresolved";
 export interface LaneCompanyResolution {
     company: LaneCompanyRef | null;
     source: LaneCompanySource;
 }
 /** Resolve a lane's company without inferring ownership from its worker or caller. */
-export declare function resolveLaneCompany(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company" | "project_id">): LaneCompanyResolution;
+export declare function resolveLaneCompany(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company" | "mesh_company" | "project_id">): LaneCompanyResolution;
+export declare function laneCompanyUidSource(source: LaneCompanySource): string | undefined;
 //# sourceMappingURL=lane-company.d.ts.map

package/dist/lib/lanes/lane-company.js

@@ -2,10 +2,15 @@ import { resolveProjectQuestionCompany } from "./questions.js";
 import { LanesError } from "./errors.js";
 /** Resolve a lane's company without inferring ownership from its worker or caller. */
 export function resolveLaneCompany(hqRoot, lane) {
-    const slug = typeof lane.company?.slug === "string" ? lane.company.slug.trim() : "";
-    const uid = typeof lane.company?.uid === "string" ? lane.company.uid.trim() : "";
-    if (slug && uid) {
-        return { company: { slug, uid }, source: "lane" };
+    const laneCompanySlug = typeof lane.company?.slug === "string" ? lane.company.slug.trim() : "";
+    const laneCompanyUid = typeof lane.company?.uid === "string" ? lane.company.uid.trim() : "";
+    if (laneCompanySlug && laneCompanyUid) {
+        return { company: { slug: laneCompanySlug, uid: laneCompanyUid }, source: "lane" };
+    }
+    const meshCompanySlug = typeof lane.mesh_company?.slug === "string" ? lane.mesh_company.slug.trim() : "";
+    const meshCompanyUid = typeof lane.mesh_company?.uid === "string" ? lane.mesh_company.uid.trim() : "";
+    if (meshCompanySlug && meshCompanyUid) {
+        return { company: { slug: meshCompanySlug, uid: meshCompanyUid }, source: "mesh_company" };
     }
     let projectCompany;
     try {
@@ -21,4 +26,16 @@ export function resolveLaneCompany(hqRoot, lane) {
         ? { company: projectCompany, source: "project" }
         : { company: null, source: "unresolved" };
 }
+export function laneCompanyUidSource(source) {
+    switch (source) {
+        case "lane":
+            return "lane.company.uid";
+        case "mesh_company":
+            return "lane.mesh_company.uid";
+        case "project":
+            return "project.cloud_uid";
+        case "unresolved":
+            return undefined;
+    }
+}
 //# sourceMappingURL=lane-company.js.map

package/dist/lib/lanes/manager-status-gate.js

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { checkCompanyPath } from "./checked-company-path.js";
 import { LanesError } from "./errors.js";
+import { laneCompanyUidSource, resolveLaneCompany } from "./lane-company.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 export const MANAGER_STATUS_GATE_FLAG = "lanes.manager-status-gate";
 function isObject(value) {
@@ -84,7 +85,7 @@ export function resolveManagerStatusTarget(root, lane) {
             invalidMapping(`Matched juniors row needs a non-empty ${field}`, registry.filePath, { lane_id: lane.lane_id, field });
         }
     }
-    const company = lane.company?.slug ?? lane.mesh_company?.slug ?? "";
+    const company = resolveLaneCompany(root, lane).company?.slug ?? "";
     const statusPath = checkCompanyPath(root, company, row.status, registry.filePath);
     return {
         manager: true,
@@ -96,11 +97,12 @@ export async function resolveManagerStatusGateForLane(root, lane, options = {})
     const reportError = options.onError ?? ((err) => logManagerStatusGateFailure(lane, err));
     let enabled;
     try {
-        const company = lane.company ?? lane.mesh_company ?? undefined;
+        const resolution = resolveLaneCompany(root, lane);
+        const company = resolution.company ?? undefined;
         enabled = await (options.readFlag ?? readLanesRegistryFlag)(MANAGER_STATUS_GATE_FLAG, {
             company,
             ...(company ? {
-                companyUidSource: lane.company ? "lane.company.uid" : "lane.mesh_company.uid",
+                companyUidSource: laneCompanyUidSource(resolution.source),
             } : {}),
             env: options.env,
         });

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

@@ -0,0 +1,14 @@
+export interface MergeCommandTarget {
+    kind: "pr" | "api" | "graphql" | "git";
+    repo: string | null;
+    pr: number | null;
+    pinnedHead: string | null;
+    unresolvedReason: string | null;
+}
+export interface MergeCommandParseResult {
+    targets: MergeCommandTarget[];
+    unresolved: boolean;
+}
+export declare function canonicalRepo(raw: string): string;
+export declare function parseMergeCommands(command: string): MergeCommandParseResult;
+//# sourceMappingURL=merge-command.d.ts.map

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

@@ -0,0 +1,363 @@
+import { LanesError } from "./errors.js";
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+export function canonicalRepo(raw) {
+    const value = raw.trim();
+    const parts = value.split("/");
+    if (parts.length !== 2) {
+        return fail("repo_hold_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    const [owner, repository] = parts;
+    if (!owner || !repository ||
+        !/^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(owner) ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repository) ||
+        owner === "." || owner === ".." || repository === "." || repository === "..") {
+        return fail("repo_hold_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    return `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+}
+function splitCommandChain(command) {
+    const segments = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index] ?? "";
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            current += character;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += character;
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            current += character;
+            continue;
+        }
+        if (character === ";" || character === "|") {
+            segments.push(current.trim());
+            current = "";
+            if (character === "|" && command[index + 1] === "|")
+                index += 1;
+            continue;
+        }
+        if (character === "&" && command[index + 1] === "&") {
+            segments.push(current.trim());
+            current = "";
+            index += 1;
+            continue;
+        }
+        current += character;
+    }
+    if (quote !== null || escaped) {
+        return fail("repo_hold_command_invalid", "Command has an unclosed quote or escape");
+    }
+    segments.push(current.trim());
+    return segments.filter(Boolean);
+}
+function shellWords(segment) {
+    const words = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const character of segment) {
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            else
+                current += character;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (current)
+                words.push(current);
+            current = "";
+            continue;
+        }
+        current += character;
+    }
+    if (escaped)
+        current += "\\";
+    if (current)
+        words.push(current);
+    return words;
+}
+function optionRepo(words) {
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if ((word === "-R" || word === "--repo") && words[index + 1])
+            return words[index + 1] ?? null;
+        if (word.startsWith("--repo="))
+            return word.slice("--repo=".length);
+        if (word.startsWith("-R") && word.length > 2)
+            return word.slice(2);
+    }
+    return null;
+}
+function ghPrSubcommand(words) {
+    const groupIndex = words.indexOf("pr", 1);
+    if (groupIndex < 0)
+        return null;
+    for (let index = groupIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "-R" || word === "--repo" || word === "--hostname") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--repo=") || (word.startsWith("-R") && word.length > 2))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return { subcommandIndex: index, subcommand: word };
+    }
+    return { subcommandIndex: words.length, subcommand: null };
+}
+const SHELL_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const PR_MERGE_VALUE_OPTIONS = new Set([
+    "-A", "--author-email", "-b", "--body", "-F", "--body-file",
+    "--match-head-commit", "-t", "--subject",
+]);
+function skipEnvOptions(words, start) {
+    let index = start + 1;
+    while (index < words.length) {
+        const word = words[index] ?? "";
+        if (SHELL_ASSIGNMENT.test(word)) {
+            index += 1;
+            continue;
+        }
+        if (word === "-i" || word === "--ignore-environment") {
+            index += 1;
+            continue;
+        }
+        if (word === "-u" || word === "--unset" || word === "-C" || word === "--chdir") {
+            index += 2;
+            continue;
+        }
+        if (word.startsWith("--unset=") || word.startsWith("--chdir=")) {
+            index += 1;
+            continue;
+        }
+        if (word === "--")
+            return index + 1;
+        if (word.startsWith("-")) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function skipTimeoutOptions(words, start) {
+    let index = start + 1;
+    while (index < words.length) {
+        const word = words[index] ?? "";
+        if (word === "--") {
+            index += 1;
+            break;
+        }
+        if (word === "-k" || word === "--kill-after" || word === "-s" || word === "--signal") {
+            index += 2;
+            continue;
+        }
+        if (word.startsWith("--kill-after=") || word.startsWith("--signal=")) {
+            index += 1;
+            continue;
+        }
+        if (word === "--preserve-status" || word === "--foreground" || word === "--verbose" || word === "-v") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-")) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return Math.min(index + 1, words.length);
+}
+function unwrapCommand(words) {
+    let index = 0;
+    while (index < words.length) {
+        if (SHELL_ASSIGNMENT.test(words[index] ?? "")) {
+            index += 1;
+            continue;
+        }
+        if (words[index] === "env") {
+            index = skipEnvOptions(words, index);
+            continue;
+        }
+        if (words[index] === "timeout") {
+            index = skipTimeoutOptions(words, index);
+            continue;
+        }
+        break;
+    }
+    return words.slice(index);
+}
+function parsePullUrl(raw) {
+    if (!/^https?:\/\//i.test(raw))
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    const match = /^\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/.exec(url.pathname);
+    if (!match)
+        return null;
+    try {
+        const pr = Number(match[3]);
+        if (!Number.isSafeInteger(pr) || pr <= 0)
+            return null;
+        return { repo: canonicalRepo(`${decodeURIComponent(match[1] ?? "")}/${decodeURIComponent(match[2] ?? "")}`), pr };
+    }
+    catch (error) {
+        if (error instanceof LanesError && error.error === "repo_hold_repo_invalid") {
+            return fail("repo_hold_repo_invalid", "Pull request URL has an invalid repository", { field: "repo" });
+        }
+        throw error;
+    }
+}
+function pinnedHead(words, start = 0) {
+    for (let index = start; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "--match-head-commit")
+            return words[index + 1]?.trim().toLowerCase() || null;
+        if (word.startsWith("--match-head-commit="))
+            return word.slice("--match-head-commit=".length).trim().toLowerCase() || null;
+        if (word === "-f" || word === "-F" || word === "--field" || word === "--raw-field") {
+            const value = words[index + 1] ?? "";
+            if (value.startsWith("sha="))
+                return value.slice(4).trim().toLowerCase() || null;
+            index += 1;
+            continue;
+        }
+        for (const prefix of ["-fsha=", "-Fsha=", "--field=sha=", "--raw-field=sha="]) {
+            if (word.startsWith(prefix))
+                return word.slice(prefix.length).trim().toLowerCase() || null;
+        }
+    }
+    return null;
+}
+function prMergeTarget(words, subcommandIndex) {
+    const rawRepo = optionRepo(words);
+    let rawNumber = null;
+    let urlTarget = null;
+    const start = subcommandIndex + 1;
+    for (let index = start; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (PR_MERGE_VALUE_OPTIONS.has(word)) {
+            index += 1;
+            continue;
+        }
+        if (["-R", "--repo", "--hostname"].includes(word)) {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--repo=") || (word.startsWith("-R") && word.length > 2) || word.startsWith("--match-head-commit="))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        urlTarget = parsePullUrl(word);
+        if (urlTarget)
+            break;
+        rawNumber = word;
+        break;
+    }
+    const repo = rawRepo ? canonicalRepo(rawRepo) : urlTarget?.repo ?? null;
+    const pr = urlTarget?.pr ?? (rawNumber && /^\d+$/.test(rawNumber) && Number.isSafeInteger(Number(rawNumber)) && Number(rawNumber) > 0
+        ? Number(rawNumber)
+        : null);
+    const reason = repo === null
+        ? "repository could not be resolved without a pull request URL or --repo"
+        : pr === null
+            ? "pull request number could not be resolved"
+            : null;
+    return { kind: "pr", repo, pr, pinnedHead: pinnedHead(words, start), unresolvedReason: reason };
+}
+function apiMergeTarget(words, apiIndex) {
+    const rest = words.slice(apiIndex + 1);
+    const graphql = rest.includes("graphql");
+    if (graphql && rest.some((word) => word.includes("mergePullRequest"))) {
+        return {
+            kind: "graphql",
+            repo: null,
+            pr: null,
+            pinnedHead: pinnedHead(rest),
+            unresolvedReason: "GraphQL mergePullRequest identifies a node id, not a pull request number",
+        };
+    }
+    for (const word of rest) {
+        const match = /^(?:https?:\/\/api\.github\.com)?\/?repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)\/merge\/?$/.exec(word);
+        if (!match)
+            continue;
+        const pr = Number(match[3]);
+        if (!Number.isSafeInteger(pr) || pr <= 0)
+            break;
+        return {
+            kind: "api",
+            repo: canonicalRepo(`${match[1]}/${match[2]}`),
+            pr,
+            pinnedHead: pinnedHead(rest),
+            unresolvedReason: null,
+        };
+    }
+    return null;
+}
+function parseSegment(segment) {
+    const words = unwrapCommand(shellWords(segment));
+    if (words[0] === "git" && words.slice(1).includes("merge")) {
+        return {
+            kind: "git",
+            repo: null,
+            pr: null,
+            pinnedHead: null,
+            unresolvedReason: "git merge does not identify a pull request",
+        };
+    }
+    if (words[0] !== "gh")
+        return null;
+    const pr = ghPrSubcommand(words);
+    if (pr?.subcommand === "merge")
+        return prMergeTarget(words, pr.subcommandIndex);
+    const apiIndex = words.indexOf("api", 1);
+    if (apiIndex < 0)
+        return null;
+    return apiMergeTarget(words, apiIndex);
+}
+export function parseMergeCommands(command) {
+    const targets = splitCommandChain(command)
+        .map(parseSegment)
+        .filter((target) => target !== null);
+    return {
+        targets,
+        unresolved: targets.some((target) => target.unresolvedReason !== null),
+    };
+}
+//# sourceMappingURL=merge-command.js.map