@indigoai-us/hq-cli 5.293.0 → 5.295.0

package/dist/lib/lanes/autopilot-metrics.d.ts

@@ -0,0 +1,99 @@
+export interface AutopilotMetricsLead {
+    team: string;
+    lane_id: string;
+    project_id: string;
+}
+export interface AutopilotMetricsLane {
+    lane_id: string;
+    project_id: string;
+    story_id: string;
+    senior: {
+        kind: string;
+        id?: string;
+    };
+    state: string;
+    created_at: string;
+    updated_at?: string;
+    ended_at?: string;
+    hire_grant?: number;
+    last_resume?: {
+        at?: string;
+    };
+    last_envelope?: {
+        at?: string;
+        artifacts?: unknown[];
+    };
+}
+export interface AutopilotMetricsStory {
+    id: string;
+    state?: string;
+    status?: string;
+    created_at?: string;
+    updated_at?: string;
+    prs?: unknown[];
+    lanes?: unknown[];
+}
+export interface AutopilotMetricsProject {
+    project_id: string;
+    stories: readonly AutopilotMetricsStory[];
+}
+export interface AutopilotMetricsNudge {
+    team: string;
+    at: string;
+}
+export interface AutopilotMetricsReview {
+    repo: string;
+    pr: number;
+    recorded_at: string;
+    worker_lane?: string | null;
+}
+export interface AutopilotMetricsResume {
+    lane_id: string;
+    at: string;
+}
+export interface AutopilotMetricsDefect {
+    at: string;
+    team: string;
+    defect: string;
+}
+export interface BuildAutopilotMetricsReportInput {
+    since: string;
+    until: string;
+    leads: readonly AutopilotMetricsLead[];
+    lanes: readonly AutopilotMetricsLane[];
+    projects: readonly AutopilotMetricsProject[];
+    reviews: readonly AutopilotMetricsReview[];
+    nudges: readonly AutopilotMetricsNudge[];
+    nudgeDefects: readonly AutopilotMetricsDefect[];
+    seniorResumes: readonly AutopilotMetricsResume[];
+}
+export interface AutopilotMetricsDay {
+    team: string;
+    day: string;
+    operator_nudges: number;
+    reviewed_lanes: number;
+    review_latency_minutes_total: number;
+    review_latency_minutes_average: number | null;
+    idle_slot_minutes_ready_work: number;
+}
+export interface AutopilotReviewLatency {
+    team: string;
+    lane_id: string;
+    story_id: string;
+    finished_at: string;
+    reviewed_at: string;
+    minutes: number;
+    end_event: "review_record" | "senior_resume" | "story_closed";
+}
+export interface AutopilotNudgeDefect extends AutopilotMetricsDefect {
+    wake: null;
+}
+export interface AutopilotMetricsReport {
+    since: string;
+    until: string;
+    days: AutopilotMetricsDay[];
+    review_latencies: AutopilotReviewLatency[];
+    nudge_defects: AutopilotNudgeDefect[];
+}
+export declare function buildAutopilotMetricsReport(input: BuildAutopilotMetricsReportInput): AutopilotMetricsReport;
+//# sourceMappingURL=autopilot-metrics.d.ts.map

package/dist/lib/lanes/autopilot-metrics.js

@@ -0,0 +1,301 @@
+import { isTerminalLaneState } from "./types.js";
+const MINUTE_MS = 60_000;
+const CLOSED_STORY_STATES = new Set(["done", "dropped"]);
+function timestamp(value) {
+    if (typeof value !== "string")
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function round(value) {
+    return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function dayKey(at) {
+    return new Date(at).toISOString().slice(0, 10);
+}
+function utcDays(since, until) {
+    const days = [];
+    let current = Date.UTC(new Date(since).getUTCFullYear(), new Date(since).getUTCMonth(), new Date(since).getUTCDate());
+    const last = Date.UTC(new Date(until).getUTCFullYear(), new Date(until).getUTCMonth(), new Date(until).getUTCDate());
+    while (current <= last) {
+        days.push(new Date(current).toISOString().slice(0, 10));
+        current += 24 * 60 * MINUTE_MS;
+    }
+    return days;
+}
+function storyState(story) {
+    return typeof story.state === "string" ? story.state : typeof story.status === "string" ? story.status : undefined;
+}
+function storyPrReferences(story) {
+    const refs = [...(story.prs ?? [])];
+    if (!Array.isArray(story.lanes))
+        return refs;
+    for (const entry of story.lanes) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const record = entry;
+        if (Array.isArray(record.prs))
+            refs.push(...record.prs);
+        if (Array.isArray(record.history)) {
+            for (const historyEntry of record.history) {
+                if (historyEntry && typeof historyEntry === "object" && !Array.isArray(historyEntry)) {
+                    const prs = historyEntry.prs;
+                    if (Array.isArray(prs))
+                        refs.push(...prs);
+                }
+            }
+        }
+    }
+    return refs;
+}
+function prReferenceMatches(value, review) {
+    if (typeof value === "number")
+        return value === review.pr;
+    if (typeof value !== "string") {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const record = value;
+        if (record.number === review.pr)
+            return true;
+        return [record.url, record.html_url, record.ref].some((ref) => prReferenceMatches(ref, review));
+    }
+    const text = value.trim();
+    if (text === `#${review.pr}` || text === String(review.pr))
+        return true;
+    const pull = text.match(/^https?:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)(?:\/|$)/i);
+    return pull !== null && pull[1]?.toLowerCase() === review.repo.toLowerCase() && Number(pull[2]) === review.pr;
+}
+function reviewMatchesLane(review, lane, story) {
+    if (review.worker_lane !== undefined && review.worker_lane !== null)
+        return review.worker_lane === lane.lane_id;
+    return [...(story ? storyPrReferences(story) : []), ...(lane.last_envelope?.artifacts ?? [])]
+        .some((ref) => prReferenceMatches(ref, review));
+}
+function matchingStory(project, storyId) {
+    return project?.stories.find((story) => story.id === storyId);
+}
+function stateAtHistoryEntry(entry) {
+    return typeof entry.state === "string" ? entry.state : undefined;
+}
+function storyLaneHistory(story, laneId) {
+    if (!story || !Array.isArray(story.lanes))
+        return [];
+    for (const value of story.lanes) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const entry = value;
+        if (entry.lane_id === laneId && Array.isArray(entry.history)) {
+            return entry.history.filter((history) => history !== null && typeof history === "object" && !Array.isArray(history));
+        }
+    }
+    return [];
+}
+function laneTerminalAt(lane) {
+    const ended = timestamp(lane.ended_at);
+    if (ended !== null)
+        return ended;
+    const envelopeAt = timestamp(lane.last_envelope?.at);
+    if (envelopeAt !== null)
+        return envelopeAt;
+    return isTerminalLaneState(lane.state) ? timestamp(lane.updated_at) : null;
+}
+function reviewCandidates(input, lead, lane, story) {
+    const candidates = [];
+    for (const review of input.reviews) {
+        const at = timestamp(review.recorded_at);
+        if (at !== null && reviewMatchesLane(review, lane, story))
+            candidates.push({ at, event: "review_record" });
+    }
+    for (const resume of input.seniorResumes) {
+        const at = timestamp(resume.at);
+        if (resume.lane_id === lead.lane_id && at !== null)
+            candidates.push({ at, event: "senior_resume" });
+    }
+    if (story && CLOSED_STORY_STATES.has(storyState(story) ?? "")) {
+        const at = timestamp(story.updated_at);
+        if (at !== null)
+            candidates.push({ at, event: "story_closed" });
+    }
+    return candidates;
+}
+function idleIntervalsForLane(lane, story, until) {
+    const created = timestamp(lane.created_at);
+    if (created === null)
+        return [];
+    const history = storyLaneHistory(story, lane.lane_id)
+        .map((entry) => ({ at: timestamp(typeof entry.at === "string" ? entry.at : undefined), state: stateAtHistoryEntry(entry), terminal: entry.terminal === true }))
+        .filter((entry) => entry.at !== null && entry.at >= created)
+        .sort((a, b) => a.at - b.at);
+    if (history.length === 0) {
+        const terminal = isTerminalLaneState(lane.state);
+        const ended = timestamp(lane.ended_at) ?? (terminal ? timestamp(lane.last_envelope?.at) ?? timestamp(lane.updated_at) : null) ?? until;
+        return ended > created ? [{ start: created, end: Math.min(ended, until) }] : [];
+    }
+    const intervals = [];
+    let active = true;
+    let start = created;
+    for (const event of history) {
+        const isTerminal = event.terminal || (event.state !== undefined && isTerminalLaneState(event.state));
+        if (isTerminal && active) {
+            if (event.at > start)
+                intervals.push({ start, end: event.at });
+            active = false;
+        }
+        else if (!isTerminal && !active) {
+            start = event.at;
+            active = true;
+        }
+    }
+    if (active) {
+        const terminal = isTerminalLaneState(lane.state);
+        const ended = timestamp(lane.ended_at) ?? (terminal ? timestamp(lane.last_envelope?.at) ?? timestamp(lane.updated_at) : null) ?? until;
+        if (ended > start)
+            intervals.push({ start, end: Math.min(ended, until) });
+    }
+    return intervals;
+}
+function overlaps(interval, start, end) {
+    return interval.start <= start && interval.end >= end;
+}
+function readyStoryIntervals(story, until) {
+    const created = timestamp(story.created_at);
+    const updated = timestamp(story.updated_at);
+    const state = storyState(story);
+    if (state === "todo") {
+        const start = updated ?? created;
+        return start !== null && start < until ? [{ start, end: until }] : [];
+    }
+    if (created !== null && updated !== null && updated > created)
+        return [{ start: created, end: updated }];
+    return [];
+}
+function idleSlotMinutes(input, lead, leadLane, project, children, start, end) {
+    if (!leadLane || project === undefined)
+        return 0;
+    const grant = Math.max(0, leadLane.hire_grant ?? 0);
+    if (grant === 0)
+        return 0;
+    const readyIntervals = project.stories.flatMap((story) => readyStoryIntervals(story, end));
+    if (readyIntervals.length === 0)
+        return 0;
+    const leadStory = matchingStory(project, leadLane.story_id);
+    const leadIntervals = idleIntervalsForLane(leadLane, leadStory, end);
+    if (leadIntervals.length === 0)
+        return 0;
+    const childIntervals = children.flatMap((child) => {
+        const story = matchingStory(project, child.story_id);
+        return idleIntervalsForLane(child, story, end);
+    });
+    const boundaries = new Set([start, end]);
+    for (const interval of [...childIntervals, ...readyIntervals, ...leadIntervals]) {
+        if (interval.start > start && interval.start < end)
+            boundaries.add(interval.start);
+        if (interval.end > start && interval.end < end)
+            boundaries.add(interval.end);
+    }
+    const sorted = [...boundaries].sort((a, b) => a - b);
+    let total = 0;
+    for (let index = 0; index < sorted.length - 1; index += 1) {
+        const segmentStart = sorted[index];
+        const segmentEnd = sorted[index + 1];
+        if (segmentStart === undefined || segmentEnd === undefined || segmentEnd <= segmentStart)
+            continue;
+        if (!readyIntervals.some((interval) => overlaps(interval, segmentStart, segmentEnd)))
+            continue;
+        if (!leadIntervals.some((interval) => overlaps(interval, segmentStart, segmentEnd)))
+            continue;
+        const live = childIntervals.filter((interval) => overlaps(interval, segmentStart, segmentEnd)).length;
+        total += Math.max(0, grant - live) * (segmentEnd - segmentStart) / MINUTE_MS;
+    }
+    return round(total);
+}
+export function buildAutopilotMetricsReport(input) {
+    const since = timestamp(input.since);
+    const until = timestamp(input.until);
+    if (since === null || until === null || since >= until) {
+        throw new Error("autopilot_metrics_window_invalid: since and until must be valid timestamps with since before until");
+    }
+    const days = utcDays(since, until);
+    const rows = new Map();
+    for (const lead of input.leads) {
+        for (const day of days) {
+            rows.set(`${lead.team}\u0000${day}`, {
+                team: lead.team,
+                day,
+                operator_nudges: 0,
+                reviewed_lanes: 0,
+                review_latency_minutes_total: 0,
+                review_latency_minutes_average: null,
+                idle_slot_minutes_ready_work: 0,
+            });
+        }
+    }
+    for (const nudge of input.nudges) {
+        const at = timestamp(nudge.at);
+        if (at === null || at < since || at > until)
+            continue;
+        const row = rows.get(`${nudge.team}\u0000${dayKey(at)}`);
+        if (row)
+            row.operator_nudges += 1;
+    }
+    const projectById = new Map(input.projects.map((project) => [project.project_id, project]));
+    const reviewLatencies = [];
+    for (const lead of input.leads) {
+        const leadLane = input.lanes.find((lane) => lane.lane_id === lead.lane_id);
+        const project = projectById.get(lead.project_id);
+        const children = input.lanes.filter((lane) => lane.lane_id !== lead.lane_id && lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
+        for (const lane of children) {
+            const finishedAt = laneTerminalAt(lane);
+            if (finishedAt === null || finishedAt < since || finishedAt > until)
+                continue;
+            const story = matchingStory(project, lane.story_id);
+            const first = reviewCandidates(input, lead, lane, story)
+                .filter((event) => event.at >= finishedAt && event.at <= until)
+                .sort((a, b) => a.at - b.at)[0];
+            if (!first)
+                continue;
+            reviewLatencies.push({
+                team: lead.team,
+                lane_id: lane.lane_id,
+                story_id: lane.story_id,
+                finished_at: new Date(finishedAt).toISOString(),
+                reviewed_at: new Date(first.at).toISOString(),
+                minutes: round((first.at - finishedAt) / MINUTE_MS),
+                end_event: first.event,
+            });
+        }
+        for (const day of days) {
+            const dayStart = Math.max(since, Date.parse(`${day}T00:00:00.000Z`));
+            const dayEnd = Math.min(until, Date.parse(`${day}T00:00:00.000Z`) + 24 * 60 * MINUTE_MS);
+            const idle = idleSlotMinutes(input, lead, leadLane, project, children, dayStart, dayEnd);
+            const row = rows.get(`${lead.team}\u0000${day}`);
+            if (row)
+                row.idle_slot_minutes_ready_work = round(row.idle_slot_minutes_ready_work + idle);
+        }
+    }
+    for (const latency of reviewLatencies) {
+        const row = rows.get(`${latency.team}\u0000${dayKey(Date.parse(latency.finished_at))}`);
+        if (!row)
+            continue;
+        row.reviewed_lanes += 1;
+        row.review_latency_minutes_total = round(row.review_latency_minutes_total + latency.minutes);
+        row.review_latency_minutes_average = round(row.review_latency_minutes_total / row.reviewed_lanes);
+    }
+    const selectedTeams = new Set(input.leads.map((lead) => lead.team));
+    const nudgeDefects = input.nudgeDefects
+        .filter((defect) => {
+        if (!selectedTeams.has(defect.team))
+            return false;
+        const at = timestamp(defect.at);
+        return at !== null && at >= since && at <= until;
+    })
+        .map((defect) => ({ ...defect, wake: null }));
+    return {
+        since: new Date(since).toISOString(),
+        until: new Date(until).toISOString(),
+        days: [...rows.values()].sort((a, b) => a.day.localeCompare(b.day) || a.team.localeCompare(b.team)),
+        review_latencies: reviewLatencies.sort((a, b) => a.finished_at.localeCompare(b.finished_at) || a.lane_id.localeCompare(b.lane_id)),
+        nudge_defects: nudgeDefects,
+    };
+}
+//# sourceMappingURL=autopilot-metrics.js.map

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

@@ -1,3 +1,5 @@
 /** hq-flags keys used by lane list and placement behavior. */
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Enables one automatic continuation after a missing-envelope repair. */
+export declare const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
 //# sourceMappingURL=flag-keys.d.ts.map

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

@@ -1,3 +1,5 @@
 /** hq-flags keys used by lane list and placement behavior. */
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+/** Enables one automatic continuation after a missing-envelope repair. */
+export const LANE_ENVELOPE_REPAIR_CONTINUE_FLAG = "lanes.envelope-repair-continue";
 //# sourceMappingURL=flag-keys.js.map

package/dist/lib/lanes/manager-status-gate.d.ts

@@ -1,6 +1,4 @@
-import { readLanesRegistryFlag } from "./registry-flag.js";
 import type { LaneRecord, ManagerStatusGate } from "./types.js";
-export declare const MANAGER_STATUS_GATE_FLAG = "lanes.manager-status-gate";
 export interface ManagerStatusTarget {
     manager: boolean;
     identified_by?: "story_id" | "worker_profile" | "juniors";
@@ -11,23 +9,8 @@ export interface StatusSnapshot {
     mtime: number | null;
     updatedAt: string | null;
 }
-export interface ManagerStatusGateResolution {
-    enabled: boolean;
-    target?: ManagerStatusTarget;
-    error?: string;
-}
 /** Resolve manager identity and the single declared status file, if present. */
 export declare function resolveManagerStatusTarget(root: string, lane: LaneRecord): ManagerStatusTarget;
-export declare function resolveManagerStatusGateForLane(root: string, lane: LaneRecord, options?: {
-    env?: NodeJS.ProcessEnv;
-    readFlag?: typeof readLanesRegistryFlag;
-    onError?: (error: unknown) => void;
-}): Promise<ManagerStatusGateResolution>;
-export declare function managerStatusGateEnabledForLane(root: string, lane: LaneRecord, options?: {
-    env?: NodeJS.ProcessEnv;
-    readFlag?: typeof readLanesRegistryFlag;
-    onError?: (error: unknown) => void;
-}): Promise<boolean>;
 export declare function readStatusSnapshot(filePath: string): StatusSnapshot;
 export declare function managerStatusGateHeartbeat(root: string, lane: LaneRecord, turnId: string, turnStartedAt: string): ManagerStatusGate | undefined;
 export declare function managerStatusWasWritten(gate: ManagerStatusGate, snapshot: StatusSnapshot): boolean;

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

@@ -2,9 +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";
+import { resolveLaneCompany } from "./lane-company.js";
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -49,14 +47,6 @@ function matchesLane(rowLane, laneId) {
     const bareLaneId = laneId.split("_", 1)[0] ?? "";
     return row === laneId || row === bareLaneId;
 }
-function managerStatusGateErrorCode(err) {
-    return err instanceof LanesError ? err.error : "manager_status_gate_unavailable";
-}
-function logManagerStatusGateFailure(lane, err) {
-    const code = managerStatusGateErrorCode(err);
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`hq lanes: manager status gate disabled for ${lane.lane_id}: ${code}: ${message}\n`);
-}
 /** Resolve manager identity and the single declared status file, if present. */
 export function resolveManagerStatusTarget(root, lane) {
     const directIdentity = lane.story_id === "MANAGER"
@@ -93,38 +83,6 @@ export function resolveManagerStatusTarget(root, lane) {
         statusPath,
     };
 }
-export async function resolveManagerStatusGateForLane(root, lane, options = {}) {
-    const reportError = options.onError ?? ((err) => logManagerStatusGateFailure(lane, err));
-    let enabled;
-    try {
-        const resolution = resolveLaneCompany(root, lane);
-        const company = resolution.company ?? undefined;
-        enabled = await (options.readFlag ?? readLanesRegistryFlag)(MANAGER_STATUS_GATE_FLAG, {
-            company,
-            ...(company ? {
-                companyUidSource: laneCompanyUidSource(resolution.source),
-            } : {}),
-            env: options.env,
-        });
-    }
-    catch (err) {
-        reportError(err);
-        return { enabled: false, error: managerStatusGateErrorCode(err) };
-    }
-    if (!enabled)
-        return { enabled: false };
-    try {
-        const target = resolveManagerStatusTarget(root, lane);
-        return { enabled: target.manager && target.statusPath !== undefined, target };
-    }
-    catch (err) {
-        reportError(err);
-        return { enabled: false, error: managerStatusGateErrorCode(err) };
-    }
-}
-export async function managerStatusGateEnabledForLane(root, lane, options = {}) {
-    return (await resolveManagerStatusGateForLane(root, lane, options)).enabled;
-}
 export function readStatusSnapshot(filePath) {
     let stat;
     try {
@@ -153,6 +111,7 @@ export function readStatusSnapshot(filePath) {
     return { mtime: stat.mtimeMs, updatedAt };
 }
 export function managerStatusGateHeartbeat(root, lane, turnId, turnStartedAt) {
+    resolveLaneCompany(root, lane);
     const target = resolveManagerStatusTarget(root, lane);
     if (!target.manager || target.statusPath === undefined)
         return undefined;

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -49,6 +49,8 @@ export interface OutpostLaneCommand {
     compact?: boolean;
     tail?: string;
     json?: boolean;
+    callerLaneId?: string;
+    callerSessionId?: string;
 }
 export declare function buildOutpostQuestionAnswerCommand(input: {
     questionId: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -190,7 +190,13 @@ export function buildOutpostLaneCommand(input) {
         args.push("--tail", input.tail);
     if (input.action === "logs" && input.json === true)
         args.push("--json");
-    return withRemoteHqDir(joinCommandParts(args));
+    const callerLaneId = input.callerLaneId?.trim();
+    const callerSessionId = input.callerSessionId?.trim();
+    const callerEnv = [
+        callerLaneId ? `HQ_LANE_ID=${callerLaneId}` : undefined,
+        callerSessionId ? `HQ_SESSION_ID=${callerSessionId}` : undefined,
+    ].filter((value) => value !== undefined);
+    return withRemoteHqDir(joinCommandParts(callerEnv.length > 0 ? ["env", ...callerEnv, ...args] : args));
 }
 /** True when a remote CLI exited after rejecting the forwarded effort flag. */
 export function outpostRejectedEffortOption(result) {

package/dist/lib/lanes/outpost-hire-cache.d.ts

@@ -1,5 +1,4 @@
 export declare const OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS = 60000;
-export declare const LANE_OUTPOST_SNAPSHOT_CACHE_FLAG = "lanes.outpost-snapshot-cache";
 export interface OutpostHireSummary {
     hire_grant: number;
     hire_alive_children: number;

package/dist/lib/lanes/outpost-hire-cache.js

@@ -2,7 +2,6 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 export const OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS = 60_000;
-export const LANE_OUTPOST_SNAPSHOT_CACHE_FLAG = "lanes.outpost-snapshot-cache";
 const CACHE_RELATIVE_PATH = path.join("workspace", "lanes-runs", ".cache", "outpost-hire-summaries.json");
 export function outpostHireSummaryCachePath(hqRoot) {
     return path.join(hqRoot, CACHE_RELATIVE_PATH);

package/dist/lib/lanes/outpost-snapshot-memo.d.ts

@@ -0,0 +1,6 @@
+/** Deduplicates identical remote snapshot queries within one command invocation. */
+export declare class OutpostSnapshotInvocationMemo {
+    private readonly requests;
+    getOrCreate<T>(outpostId: string, query: unknown, fetch: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=outpost-snapshot-memo.d.ts.map

package/dist/lib/lanes/outpost-snapshot-memo.js

@@ -0,0 +1,14 @@
+/** Deduplicates identical remote snapshot queries within one command invocation. */
+export class OutpostSnapshotInvocationMemo {
+    requests = new Map();
+    getOrCreate(outpostId, query, fetch) {
+        const key = JSON.stringify([outpostId, query]);
+        const existing = this.requests.get(key);
+        if (existing)
+            return existing;
+        const request = fetch();
+        this.requests.set(key, request);
+        return request;
+    }
+}
+//# sourceMappingURL=outpost-snapshot-memo.js.map

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

@@ -11,7 +11,7 @@ import { type ThrottleDeps, type CpuBusyObservation } from "./throttle.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 import { type RunawayProcessInfo } from "./runaway-tool-guard.js";
 import { type KeepAliveBlockedReason } from "./keep-alive.js";
-import type { LaneCompanyRef, LaneRecord, LivenessState, QueuedReason, QuestionRecord, SeniorRef } from "./types.js";
+import type { LaneCompanyRef, LaneAccountSelection, LaneRecord, LivenessState, QueuedReason, QuestionRecord, SeniorRef } from "./types.js";
 import { type LaneMesh } from "./mesh-events.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
 export declare const QUESTION_AGE_MS: number;
@@ -86,8 +86,6 @@ export interface ReconcileDeps {
     skipAdmissionWithoutCpuSample?: boolean;
     /** Flag reader seam used to assert rollout reads happen before admission locks. */
     readRegistryFlag?: typeof readLanesRegistryFlag;
-    /** Pre-read manager gate decisions, scoped to each lane for this pass. */
-    managerStatusGateByLane?: ReadonlyMap<string, boolean>;
     /** Active-company fallback for questions raised from an unscoped lane. */
     resolveQuestionActiveCompany?: () => Promise<LaneCompanyRef>;
     /** Resume queued messages after this pass wins a local dead-worker CAS. */
@@ -102,6 +100,7 @@ export interface ReconcileDeps {
     prepareKeepAliveClaudeResume?: (lane: LaneRecord) => Promise<{
         lane: LaneRecord;
         selectionFailure?: string;
+        accountSelection?: LaneAccountSelection;
     }>;
     /** Process-table snapshot seam for the opt-in runaway-search guard. */
     runawayToolProcessLister?: () => readonly RunawayProcessInfo[];