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

package/dist/commands/lanes-checks.js

@@ -7,10 +7,11 @@ import { evaluateTrackerChecks } from "../lib/lanes/tracker-checks.js";
 import { LANE_STORE_UPGRADE_COMMAND, isLaneStoreVersionNewer, laneRecordPath, listLaneIds, listQuestionIds, questionRecordPath, readLane, readQuestion } from "../lib/lanes/store.js";
 import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
 import { sessionLiveness } from "../lib/lanes/liveness.js";
-import { findOrphanLanes, parseOrphanMinAge } from "../lib/lanes/orphans.js";
+import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
+import { DEFAULT_ORPHAN_USER_IDLE_HOURS, findOrphanLanes, parseOrphanMinAge, parseOrphanUserIdleHours, } from "../lib/lanes/orphans.js";
+import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
-import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -293,46 +294,176 @@ function readScopedLanes(root, company, projects) {
         return [readLane(root, id)];
     });
 }
-function readCompanyLanes(root, company, projectId) {
-    return listLaneIds(root).flatMap((id) => {
-        const file = laneRecordPath(root, id);
-        const metadata = readJsonObject(file);
-        if (metadata === null)
-            return fail("tracker_checks_input_unreadable", "Lane record could not be read while checking its scope", { path: file });
-        const laneCompany = isObject(metadata.company) ? metadata.company : null;
-        if (laneCompany?.slug !== company.slug || laneCompany.uid !== company.uid)
-            return [];
-        if (projectId !== undefined && !laneMetadataMatchesScope(metadata, company, new Set([projectId])))
-            return [];
-        return [readLane(root, id)];
-    });
-}
 function orphanSessionState(root, sessionId, now, deps) {
     if (deps.sessionState)
         return deps.sessionState(root, sessionId, now);
     return sessionLiveness(root, sessionId, { nowMs: now.getTime() });
 }
-function orphanFindings(root, company, now, minAgeMinutes, deps, projectId) {
-    const candidates = readCompanyLanes(root, company, projectId);
-    const lanes = [...candidates];
-    const known = new Set(lanes.map((lane) => lane.lane_id));
-    for (const candidate of candidates) {
-        if (candidate.senior.kind !== "lane" || candidate.senior.id === undefined || known.has(candidate.senior.id))
+const MAX_ORPHAN_SENIOR_DEPTH = 64;
+function readOrphanLaneScopes(root) {
+    return new Map(listLaneIds(root).map((id) => {
+        const file = laneRecordPath(root, id);
+        const metadata = readJsonObject(file);
+        if (metadata === null)
+            return fail("tracker_checks_input_unreadable", "Lane record could not be read while resolving orphan scope", { path: file });
+        const companyRef = (value) => isObject(value) && typeof value.slug === "string" && typeof value.uid === "string"
+            ? { slug: value.slug, uid: value.uid }
+            : null;
+        const meshCompany = companyRef(metadata.mesh_company);
+        const lane = {
+            lane_id: id,
+            company: companyRef(metadata.company),
+            ...(meshCompany === null ? {} : { mesh_company: meshCompany }),
+            project_id: typeof metadata.project_id === "string" ? metadata.project_id : "",
+        };
+        const seniorLaneId = isObject(metadata.senior) && metadata.senior.kind === "lane" && typeof metadata.senior.id === "string"
+            ? metadata.senior.id
+            : undefined;
+        const projectIds = [lane.project_id];
+        if (Array.isArray(metadata.stories)) {
+            for (const story of metadata.stories) {
+                if (isObject(story) && typeof story.project_id === "string")
+                    projectIds.push(story.project_id);
+            }
+        }
+        return [id, { lane, ...(seniorLaneId === undefined ? {} : { seniorLaneId }), projectIds }];
+    }));
+}
+function orphanCompanyResolution(root, scope, scopesById) {
+    const direct = resolveLaneCompany(root, scope.lane);
+    if (direct.company !== null)
+        return direct;
+    const visited = new Set([scope.lane.lane_id]);
+    let current = scope;
+    for (let depth = 0; depth < MAX_ORPHAN_SENIOR_DEPTH; depth += 1) {
+        const seniorId = current.seniorLaneId;
+        if (seniorId === undefined)
+            break;
+        if (visited.has(seniorId))
+            break;
+        visited.add(seniorId);
+        const senior = scopesById.get(seniorId);
+        if (senior === undefined)
+            break;
+        const resolved = resolveLaneCompany(root, senior.lane);
+        if (resolved.company !== null)
+            return { company: resolved.company, source: "senior" };
+        current = senior;
+    }
+    return { company: null, source: "unresolved" };
+}
+function orphanLastActivityAt(root, lane) {
+    const updatedAt = Date.parse(lane.updated_at);
+    if (!Number.isFinite(updatedAt))
+        return Number.NaN;
+    const recordedEnvelopeAt = lane.last_envelope === undefined ? Number.NaN : Date.parse(lane.last_envelope.at);
+    let latest = Number.isFinite(recordedEnvelopeAt) ? Math.max(updatedAt, recordedEnvelopeAt) : updatedAt;
+    const envelopesDirectory = path.join(root, LANES_RUNS_REL, lane.lane_id, "envelopes");
+    let entries;
+    try {
+        entries = fs.readdirSync(envelopesDirectory, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return latest;
+        return fail("orphan_envelope_unreadable", "Lane envelope directory could not be read", { lane_id: lane.lane_id });
+    }
+    for (const entry of entries) {
+        if (!entry.name.endsWith(".json") || entry.name.startsWith("."))
             continue;
-        const file = laneRecordPath(root, candidate.senior.id);
-        const metadata = readJsonObject(file, "empty");
-        const laneCompany = metadata && isObject(metadata.company) ? metadata.company : null;
-        if (laneCompany?.slug !== company.slug || laneCompany.uid !== company.uid)
+        const file = path.join(envelopesDirectory, entry.name);
+        try {
+            const stat = fs.lstatSync(file);
+            if (stat.isFile() && !stat.isSymbolicLink() && Number.isFinite(stat.mtimeMs)) {
+                latest = Math.max(latest, stat.mtimeMs);
+            }
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            return fail("orphan_envelope_unreadable", "Lane envelope timestamp could not be read", { lane_id: lane.lane_id });
+        }
+    }
+    return latest;
+}
+function orphanLaneHasOpenStory(root, lane, company) {
+    const carriedStories = lane.stories ?? [];
+    const references = [];
+    const addReference = (project_id, story_id) => {
+        if (!references.some((reference) => reference.project_id === project_id && reference.story_id === story_id)) {
+            references.push({ project_id, story_id });
+        }
+    };
+    if (lane.story_id !== "")
+        addReference(lane.project_id, lane.story_id);
+    for (const story of carriedStories) {
+        addReference(story.project_id, story.story_id);
+        if (story.status !== "done")
+            return true;
+    }
+    if (references.length === 0)
+        return false;
+    if (company === null)
+        return true;
+    for (const reference of references) {
+        const resolution = resolveLaneCompany(root, {
+            lane_id: lane.lane_id,
+            company: lane.company,
+            project_id: reference.project_id,
+        });
+        if (resolution.company === null || resolution.company.slug !== company.slug || resolution.company.uid !== company.uid) {
+            return true;
+        }
+        const projectId = validSegment(reference.project_id, "project");
+        const prdPath = path.join(root, "companies", company.slug, "projects", projectId, "prd.json");
+        const stories = readProject(root, company.slug, prdPath, true).stories;
+        const matching = stories.filter((story) => story.id === reference.story_id);
+        if (matching.some((story) => !storyIsDone(story)))
+            return true;
+    }
+    return false;
+}
+function orphanFindings(root, company, now, minAgeMinutes, deps, projectId, unscoped = company === null, userIdleHours = DEFAULT_ORPHAN_USER_IDLE_HOURS) {
+    const scopesById = readOrphanLaneScopes(root);
+    const companyByLane = new Map();
+    const selectedScopes = [...scopesById.values()].filter((scope) => {
+        if (projectId !== undefined && !scope.projectIds.includes(projectId))
+            return false;
+        const rawCompany = scope.lane.company;
+        if (company !== null && rawCompany !== null && (rawCompany.slug !== company.slug || rawCompany.uid !== company.uid))
+            return false;
+        const resolution = orphanCompanyResolution(root, scope, scopesById);
+        companyByLane.set(scope.lane.lane_id, resolution);
+        if (unscoped)
+            return resolution.company === null;
+        return company !== null && resolution.company?.slug === company.slug && resolution.company.uid === company.uid;
+    });
+    const selectedLanes = selectedScopes.map((scope) => readLane(root, scope.lane.lane_id));
+    const candidates = selectedLanes.filter((lane) => projectId === undefined ||
+        lane.project_id === projectId || (lane.stories ?? []).some((story) => story.project_id === projectId));
+    const candidateIds = new Set(candidates.map((lane) => lane.lane_id));
+    const lanesForFinding = new Map(candidates.map((lane) => [lane.lane_id, lane]));
+    for (const lane of candidates) {
+        if (lane.senior.kind !== "lane" || lane.senior.id === undefined || lanesForFinding.has(lane.senior.id))
             continue;
-        lanes.push(readLane(root, candidate.senior.id));
-        known.add(candidate.senior.id);
+        if (scopesById.has(lane.senior.id))
+            lanesForFinding.set(lane.senior.id, readLane(root, lane.senior.id));
     }
     return findOrphanLanes({
-        lanes,
+        lanes: [...lanesForFinding.values()],
+        candidateLaneIds: candidateIds,
         now,
         minAgeMinutes,
+        userIdleHours,
         sessionState: (sessionId, at) => orphanSessionState(root, sessionId, at, deps),
-    }).filter((finding) => candidates.some((lane) => lane.lane_id === finding.lane_id));
+        lastActivityAt: (lane) => orphanLastActivityAt(root, lane),
+        hasOpenStory: (lane) => orphanLaneHasOpenStory(root, lane, companyByLane.get(lane.lane_id)?.company ?? null),
+    })
+        .filter((finding) => candidateIds.has(finding.lane_id))
+        .map((finding) => ({
+        ...finding,
+        company_source: companyByLane.get(finding.lane_id)?.source ?? "unresolved",
+    }));
 }
 function sameCompanyLane(lane, company) {
     return lane.company?.slug === company.slug && lane.company.uid === company.uid;
@@ -582,9 +713,6 @@ export async function resolveTrackerCompany(deps, requested) {
     const company = await deps.resolveCompany(requested);
     if (!company.slug)
         fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
-    if (!await deps.trackerEnabled(company)) {
-        fail("tracker_disabled", `hq lanes tracker commands require the ${LANES_TRACKER_FLAG} flag`, { company: company.slug });
-    }
     return company;
 }
 async function checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, now, deps) {
@@ -631,8 +759,8 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
         result: orphanedLanes.length === 0 ? "ok" : "failing",
         items: orphanedLanes.map((finding) => ({
             id: finding.lane_id,
-            reason: finding.senior_state === "missing" ? "missing_senior" :
-                finding.senior_state === "ended" ? "ended_session_senior" : "terminal_senior",
+            reason: finding.reason,
+            company_source: finding.company_source,
             senior: finding.senior,
             senior_state: finding.senior_state,
             age_minutes: finding.age_minutes,
@@ -648,7 +776,7 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
         checks,
     };
 }
-async function orphanReport(root, company, now, minAgeMinutes, deps, options) {
+async function orphanReport(root, company, now, minAgeMinutes, userIdleHours, deps, options) {
     const reason = options.reason?.trim();
     if (options.stop && !reason) {
         fail("orphan_stop_reason_required", "--stop requires a non-empty --reason", {});
@@ -658,39 +786,63 @@ async function orphanReport(root, company, now, minAgeMinutes, deps, options) {
     }
     if (reason !== undefined)
         assertNoSecretText("stop reason", reason);
-    const orphans = orphanFindings(root, company, now, minAgeMinutes, deps);
-    if (!options.stop) {
+    const unscoped = options.unscoped === true;
+    const orphans = orphanFindings(root, company, now, minAgeMinutes, deps, undefined, unscoped, userIdleHours);
+    const output = (action, stopped) => {
+        if (options.human) {
+            const companyText = unscoped ? "unscoped" : company?.slug ?? "unknown";
+            console.log(`company: ${companyText}`);
+            console.log("lane_id\tsenior\tsenior_state\treason\tcompany_source\tage_minutes\taccount\thost");
+            for (const finding of orphans) {
+                console.log([
+                    finding.lane_id,
+                    `${finding.senior.kind}:${finding.senior.id ?? ""}`,
+                    finding.senior_state,
+                    finding.reason,
+                    finding.company_source,
+                    finding.age_minutes,
+                    finding.account ?? "",
+                    `${finding.host.kind}:${finding.host.id}`,
+                ].join("\t"));
+            }
+            if (orphans.length === 0)
+                console.log("(none)");
+            if (stopped !== undefined) {
+                console.log("stopped:");
+                for (const entry of stopped)
+                    console.log(`${entry.lane_id}\t${entry.state}`);
+            }
+            return;
+        }
         console.log(JSON.stringify({
             ok: true,
-            action: "orphans",
-            company: company.slug,
+            action,
+            company: company?.slug ?? null,
+            ...(unscoped ? { unscoped: true } : {}),
             generated_at: now.toISOString(),
             min_age_minutes: minAgeMinutes,
+            user_idle_hours: userIdleHours,
+            ...(reason === undefined ? {} : { reason }),
             orphans,
+            ...(stopped === undefined ? {} : { stopped }),
         }, null, 2));
+    };
+    if (!options.stop) {
+        output("orphans");
         return;
     }
     if (!deps.stopLane)
         fail("orphan_stop_unavailable", "The normal lane stop path is unavailable", {});
     const stopped = [];
     for (const finding of orphans) {
-        const fresh = orphanFindings(root, company, deps.now(), minAgeMinutes, deps)
+        const fresh = orphanFindings(root, company, deps.now(), minAgeMinutes, deps, undefined, unscoped, userIdleHours)
             .find((candidate) => candidate.lane_id === finding.lane_id);
         if (!fresh)
             continue;
         await deps.stopLane(finding.lane_id, reason);
         stopped.push({ lane_id: finding.lane_id, state: readLane(root, finding.lane_id).state });
     }
-    console.log(JSON.stringify({
-        ok: true,
-        action: "orphans.stop",
-        company: company.slug,
-        generated_at: now.toISOString(),
-        min_age_minutes: minAgeMinutes,
-        reason,
-        orphans,
-        stopped,
-    }, null, 2));
+    output("orphans.stop", stopped);
 }
 export function registerLaneChecksCommand(parent, deps, wrap) {
     parent.command("checks")
@@ -713,16 +865,27 @@ export function registerLaneChecksCommand(parent, deps, wrap) {
             process.exitCode = 2;
     }));
     parent.command("orphans")
-        .description("Report lanes whose lane or session senior has ended")
+        .description("Report lanes whose senior has ended or gone idle")
         .option("--company <slug>", "Select the company by slug")
         .option("--min-age <minutes>", "Minimum orphan lane age in minutes (default: 30)")
+        .option("--user-idle-hours <hours>", "Idle hours for user-senior lanes (default: 72)")
+        .option("--unscoped", "Report candidates whose company cannot be resolved")
         .option("--stop", "Stop the reported lanes through their normal owner path")
         .option("--reason <text>", "Required audit reason when --stop is set")
+        .option("--json", "Print machine-readable JSON")
+        .option("--human", "Print a human-readable table")
         .action(wrap(async (options) => {
-        const company = await deps.resolveCompany(options.company);
+        if (options.unscoped && options.company !== undefined) {
+            fail("orphan_scope_conflict", "--unscoped cannot be combined with --company", {});
+        }
+        if (options.human && options.json) {
+            fail("conflicting_output_format", "Choose either --json or --human output", {});
+        }
+        const company = options.unscoped ? null : await deps.resolveCompany(options.company);
         const root = deps.hqRoot();
         const minAgeMinutes = parseOrphanMinAge(options.minAge);
-        await orphanReport(root, company, deps.now(), minAgeMinutes, deps, options);
+        const userIdleHours = parseOrphanUserIdleHours(options.userIdleHours);
+        await orphanReport(root, company, deps.now(), minAgeMinutes, userIdleHours, deps, options);
     }));
 }
 //# sourceMappingURL=lanes-checks.js.map

package/dist/commands/lanes-hold.js

@@ -547,13 +547,23 @@ export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
             let reviewContext = null;
             if (holdFlagOff) {
                 reviewContext = await reviewCheckContext(hqRoot, deps);
-                if (!reviewContext) {
+            }
+            let parsed;
+            try {
+                parsed = parseMergeCommands(options.command);
+            }
+            catch (error) {
+                if (holdFlagOff && !reviewContext) {
                     printJson({ ok: true, hold_enforcement: "off" });
                     return;
                 }
+                throw error;
             }
-            const parsed = parseMergeCommands(options.command);
             repoUnresolved = parsed.targets.some((target) => target.repo === null);
+            if (holdFlagOff && !reviewContext && !parsed.unparseableMerge) {
+                printJson({ ok: true, hold_enforcement: "off" });
+                return;
+            }
             const repos = parsed.targets.flatMap((target) => target.repo === null ? [] : [target.repo]);
             const now = deps.now();
             if (!holdFlagOff) {
@@ -581,6 +591,29 @@ export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
                     return;
                 }
             }
+            if (parsed.unparseableMerge) {
+                const activeHolds = listHolds(hqRoot)
+                    .filter((existing) => holdView(existing, now).active);
+                let deniedUnresolvedHold;
+                for (const existing of activeHolds) {
+                    const enabled = await (deps.mergeHoldEnabled ?? ((company) => readLanesRegistryFlag(LANES_REPO_MERGE_HOLD_FLAG, { company, env: deps.env })))(existing.company);
+                    if (enabled) {
+                        deniedUnresolvedHold ??= existing;
+                    }
+                    else {
+                        gateWasOff = true;
+                    }
+                }
+                if (deniedUnresolvedHold) {
+                    printJson({
+                        ok: false,
+                        error: "repo_hold_command_invalid",
+                        repo_unresolved: true,
+                    });
+                    process.exitCode = 3;
+                    return;
+                }
+            }
             reviewContext ??= await reviewCheckContext(hqRoot, deps);
             if (reviewContext) {
                 const reviewCheck = checkReviewTargets(hqRoot, reviewContext, parsed.targets);
@@ -589,6 +622,11 @@ export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
                     process.exitCode = 3;
                     return;
                 }
+                if (parsed.unparseableMerge) {
+                    printJson({ ok: false, error: "review_record_missing", repo_unresolved: true });
+                    process.exitCode = 3;
+                    return;
+                }
                 reviewUnresolved = reviewCheck.unresolved;
             }
             printJson({

package/dist/commands/lanes-message.js

@@ -3,38 +3,115 @@ 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 { parseCliEffort } from "../lib/lanes/effort.js";
-import { parseOutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
+import { parseOutpostHireGrantContext, sameHireGrantSenior } from "../lib/lanes/hire-grant-dispatch.js";
 import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
 import { dropboxInboxHasMessages, drainDropbox, formatDropboxMessages, formatMonitorEvent, requeueDropboxMessages } from "../lib/lanes/dropbox.js";
 import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, writeWatcherDecision } from "../lib/lanes/watcher.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
-import { keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, keepAliveSupersededBy, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneMessageHandlers(deps) {
     const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, casUpdateLane, dispatchOutpostLaneCommand, drainHookStatusFor, laneIsHostedHere, laneWithRecoveredProviderSession, loadAllLanes, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveActiveQuestionCompany, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
-    async function messageLaneExclusion(ctx, lane) {
+    function currentSuccessorOf(lane, lanes, lineageAware, companyForLane) {
+        const validLanes = lanes.filter((candidate) => Number.isFinite(Date.parse(candidate.created_at)));
+        const newestFirst = [...validLanes].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
+        const visited = new Set([lane.lane_id]);
+        let current = lane;
+        for (let depth = 0; depth < validLanes.length; depth += 1) {
+            const next = keepAliveSupersededBy(current, newestFirst, lineageAware, companyForLane);
+            if (!next || visited.has(next.lane_id))
+                break;
+            current = next;
+            visited.add(next.lane_id);
+        }
+        return current.lane_id === lane.lane_id ? undefined : current;
+    }
+    function callerMayMessageSupersededLane(ctx, lane, lanes, lineageAware, companyForLane, callerLaneIdOverride) {
+        if (lane.senior.kind !== "lane")
+            return false;
+        const callerLaneId = callerLaneIdOverride ?? ctx.env.HQ_LANE_ID?.trim();
+        if (!callerLaneId)
+            return false;
+        const senior = lanes.find((candidate) => candidate.lane_id === lane.senior.id);
+        const caller = lanes.find((candidate) => candidate.lane_id === callerLaneId);
+        if (!senior || !caller)
+            return false;
+        const workerCompany = companyForLane(lane);
+        const seniorCompany = companyForLane(senior);
+        const callerCompany = companyForLane(caller);
+        const projectId = lane.project_id;
+        if (!workerCompany ||
+            seniorCompany?.uid !== workerCompany.uid ||
+            callerCompany?.uid !== workerCompany.uid ||
+            !projectId ||
+            senior.project_id !== projectId ||
+            caller.project_id !== projectId)
+            return false;
+        if (caller.lane_id === senior.lane_id)
+            return true;
+        const projectLanes = lanes.filter((candidate) => companyForLane(candidate)?.uid === workerCompany.uid && candidate.project_id === projectId);
+        return currentSuccessorOf(lane, projectLanes, lineageAware, companyForLane)?.lane_id === caller.lane_id;
+    }
+    function keepAliveLaneFromSnapshot(snapshot) {
+        if (snapshot.created_at === undefined || !Object.hasOwn(snapshot, "company"))
+            return undefined;
+        return {
+            lane_id: snapshot.lane_id,
+            created_at: snapshot.created_at,
+            senior: snapshot.senior,
+            company: snapshot.company ?? null,
+            project_id: snapshot.project_id ?? "",
+            ...(snapshot.worker_profile === undefined ? {} : { worker_profile: snapshot.worker_profile }),
+            ...(snapshot.hire_grant === undefined ? {} : { hire_grant: snapshot.hire_grant }),
+        };
+    }
+    async function messageLaneExclusion(ctx, lane, grantContext) {
         if (lane.state === "killed" || lane.state === "cancelled") {
             return { lane, exclusion: lane.state };
         }
-        const hqRoot = ctx.hqRoot();
+        const companyForLane = (candidate) => resolveLaneCompany(ctx.hqRoot(), candidate).company;
         const lineageAware = await readLanesRegistryFlag(LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, {
-            company: resolveLaneCompany(hqRoot, lane).company ?? undefined,
+            company: companyForLane(lane),
             env: ctx.env,
         });
-        const currentLane = readLane(hqRoot, lane.lane_id);
+        const currentLane = readLane(ctx.hqRoot(), lane.lane_id);
         if (currentLane.state === "killed" || currentLane.state === "cancelled") {
             return { lane: currentLane, exclusion: currentLane.state };
         }
-        const lanes = loadAllLanes(hqRoot);
-        const retiredLaneIds = loadRetiredLaneIds(hqRoot);
-        return {
-            lane: currentLane,
-            exclusion: keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware),
-        };
+        const localLanes = loadAllLanes(ctx.hqRoot());
+        let lanes = localLanes;
+        const retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
+        const dispatchedCallerId = grantContext?.superseded_message_caller_id;
+        const dispatchedContextAuthorized = grantContext !== undefined &&
+            dispatchedCallerId !== undefined &&
+            ctx.isSsmOwnerDispatch() &&
+            sameHireGrantSenior(grantContext.expected_senior, currentLane.senior);
+        if (dispatchedContextAuthorized && grantContext) {
+            const merged = new Map(localLanes.map((record) => [record.lane_id, record]));
+            for (const snapshot of grantContext.hierarchy) {
+                const contextLane = keepAliveLaneFromSnapshot(snapshot);
+                if (contextLane)
+                    merged.set(contextLane.lane_id, contextLane);
+            }
+            merged.set(currentLane.lane_id, currentLane);
+            lanes = [...merged.values()];
+        }
+        const exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+        const callerLaneId = dispatchedContextAuthorized ? dispatchedCallerId : undefined;
+        if (exclusion === "superseded" && callerMayMessageSupersededLane(ctx, currentLane, lanes, lineageAware, companyForLane, callerLaneId)) {
+            return {
+                lane: currentLane,
+                exclusion: undefined,
+                ...(!dispatchedContextAuthorized && ctx.env.HQ_LANE_ID?.trim()
+                    ? { supersededMessageCallerId: ctx.env.HQ_LANE_ID.trim() }
+                    : {}),
+            };
+        }
+        return { lane: currentLane, exclusion };
     }
     function recordMessageUndeliverable(ctx, lane, reason, messageCount) {
         writeWatcherDecision(watcherOutLogPath(ctx.hqRoot(), lane.lane_id), {
@@ -68,7 +145,14 @@ export function createLaneMessageHandlers(deps) {
         const resolution = await deps.resolveCommandLane(ctx, laneId);
         let lane = resolution.lane;
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
-            await dispatchOutpostLaneCommand(ctx, lane, "message", opts, resolution.remoteOnly
+            const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
+            const supersededMessageCallerId = callerLaneId === undefined || resolution.remoteOnly
+                ? undefined
+                : (await messageLaneExclusion(ctx, lane)).supersededMessageCallerId;
+            await dispatchOutpostLaneCommand(ctx, lane, "message", {
+                ...opts,
+                ...(supersededMessageCallerId === undefined ? {} : { supersededMessageCallerId }),
+            }, resolution.remoteOnly
                 ? { syncPrimary: false, expectedOwnerHost: resolution.ownerHost }
                 : undefined);
             return;
@@ -115,7 +199,7 @@ export function createLaneMessageHandlers(deps) {
             }
         }
         try {
-            const eligibility = await messageLaneExclusion(ctx, lane);
+            const eligibility = await messageLaneExclusion(ctx, lane, hireGrantContext);
             lane = eligibility.lane;
             const exclusion = eligibility.exclusion;
             if (exclusion !== undefined) {

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

@@ -0,0 +1,12 @@
+import type { Ctx, LaneMoveHandlerDeps } from "./lanes-shared.js";
+export declare function createLaneMoveHandlers(deps: LaneMoveHandlerDeps): {
+    runMove: (ctx: Ctx, laneId: string, opts: {
+        placement?: string;
+    }) => Promise<void>;
+    runMoveTarget: (ctx: Ctx, laneId: string, opts: {
+        hostKind?: string;
+        hostId?: string;
+        account?: string;
+    }) => Promise<void>;
+};
+//# sourceMappingURL=lanes-move.d.ts.map