@indigoai-us/hq-cli 5.292.0 → 5.294.0

package/dist/lib/lanes/autopilot.js

@@ -11,6 +11,9 @@ export const LEAD_AUTOPILOT_FILL_DELAY_MS = 15 * 60_000;
 export const LEAD_AUTOPILOT_PROMPT_LOOP = "personal/knowledge/team-lead-operating-loop.md";
 const LIVE_STATES = new Set(["running", "queued", "awaiting_input", "blocked"]);
 const OPEN_STORY_STATES = new Set(["todo", "queued", "in_progress", "review", "blocked"]);
+function isOpenProjectStory(story) {
+    return story.passes !== true && OPEN_STORY_STATES.has(story.status);
+}
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -95,18 +98,25 @@ function projectStories(hqRoot, relativePath, companySlug, projectId) {
         throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: userStories or stories must be an array`, { path: file });
     }
     return rows.map((story, index) => {
-        const status = isRecord(story) ? story.status ?? story.state : undefined;
+        const rawStatus = isRecord(story) ? story.status ?? story.state : undefined;
+        const status = isRecord(story) && story.passes === true ? "done" : rawStatus;
         if (!isRecord(story) || typeof story.id !== "string" || typeof status !== "string") {
             throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] needs string id and status/state`, { path: file, index });
         }
         const sourceRef = isRecord(story.source) ? story.source.ref : undefined;
         const rawBrief = story.brief_path ?? story.brief_file ?? sourceRef;
-        if (story.lanes !== undefined && (!Array.isArray(story.lanes) || story.lanes.some((laneId) => typeof laneId !== "string" || !laneId.trim()))) {
-            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] lanes must be an array of non-empty lane IDs`, { path: file, index });
+        if (story.lanes !== undefined && (!Array.isArray(story.lanes) || story.lanes.some((lane) => typeof lane === "string" ? !lane.trim() : !isRecord(lane) || typeof lane.lane_id !== "string" || !lane.lane_id.trim()))) {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] lanes must contain lane IDs or lane_id objects`, { path: file, index });
         }
         if (story.updated_at !== undefined && (typeof story.updated_at !== "string" || !Number.isFinite(Date.parse(story.updated_at)))) {
             throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] updated_at must be a valid timestamp`, { path: file, index });
         }
+        if (story.lane !== undefined && story.lane !== null && typeof story.lane !== "string") {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] lane must be a string`, { path: file, index });
+        }
+        if (story.external_blocker !== undefined && (typeof story.external_blocker !== "string" || !story.external_blocker.trim())) {
+            throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] external_blocker must be a non-empty string`, { path: file, index });
+        }
         if (rawBrief !== undefined && (typeof rawBrief !== "string" || !rawBrief.trim())) {
             throw new LanesError("lead_autopilot_project_invalid", `Invalid project ${file}: stories[${index}] brief path must be a non-empty string`, { path: file, index });
         }
@@ -131,30 +141,96 @@ function projectStories(hqRoot, relativePath, companySlug, projectId) {
         return {
             id: story.id,
             status,
+            ...(story.passes === true ? { passes: true } : {}),
             ...(briefPath ? { briefPath } : {}),
-            ...(Array.isArray(story.lanes) ? { laneIds: story.lanes } : {}),
+            ...(Array.isArray(story.lanes) ? { laneIds: story.lanes.map((lane) => typeof lane === "string" ? lane : lane.lane_id) } : typeof story.lane === "string" && story.lane.trim() ? { laneIds: [story.lane] } : story.lane === "" ? { laneIds: [] } : {}),
             ...(typeof story.updated_at === "string" ? { updatedAt: story.updated_at } : {}),
+            ...(typeof story.external_blocker === "string" ? { externalBlocker: story.external_blocker } : {}),
         };
     });
 }
-function readStatus(hqRoot, relativePath) {
-    const file = registeredFilePath(hqRoot, relativePath, "lead_autopilot_status_path_invalid");
+function readStatus(hqRoot, relativePath, companySlug) {
+    if (path.isAbsolute(relativePath)) {
+        throw new LanesError("lead_autopilot_status_path_invalid", `Registered status path must be relative to the HQ root: ${relativePath}`, { path: relativePath });
+    }
+    const root = path.resolve(hqRoot);
+    const file = registeredFilePath(root, relativePath, "lead_autopilot_status_path_invalid");
+    const assertCompanyBoundary = (candidate) => {
+        const relative = path.relative(root, candidate).split(path.sep);
+        if (relative[0] === "companies" && relative[1] !== companySlug) {
+            throw new LanesError("lead_autopilot_tenant_mismatch", `Manager status path does not match lead company ${companySlug}`, { path: relativePath, company: companySlug });
+        }
+    };
+    assertCompanyBoundary(path.resolve(root, relativePath));
+    assertCompanyBoundary(fs.realpathSync(file));
     const status = readJsonFile(file, "lead_autopilot_status_invalid");
     if (!isRecord(status))
         throw new LanesError("lead_autopilot_status_invalid", `Invalid manager status ${file}: expected an object`, { path: file });
     return status;
 }
+function parseOkrReports(status) {
+    const raw = status.okr_reports;
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw)) {
+        throw new LanesError("lead_autopilot_okr_reports_invalid", "Manager status okr_reports must be an array");
+    }
+    return raw.map((value, index) => {
+        if (!isRecord(value) || typeof value.at !== "string" || !Number.isFinite(Date.parse(value.at)) || !Array.isArray(value.kpis) || !Array.isArray(value.okrs)) {
+            throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}] must include at, kpis, and okrs`);
+        }
+        const parseLines = (rows, kind) => rows.map((row, lineIndex) => {
+            if (!isRecord(row) || typeof row.id !== "string" || !row.id.trim()) {
+                throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}].${kind.toLowerCase()}s[${lineIndex}] needs an id`);
+            }
+            const text = typeof row.line === "string" ? row.line : typeof row.name === "string" ? row.name : typeof row.objective === "string" ? row.objective : "";
+            if (!text.trim()) {
+                throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}].${kind.toLowerCase()}s[${lineIndex}] needs a line, name, or objective`);
+            }
+            if ((row.value !== undefined && (typeof row.value !== "number" || !Number.isFinite(row.value))) ||
+                (row.moved !== undefined && (typeof row.moved !== "number" || !Number.isFinite(row.moved)))) {
+                throw new LanesError("lead_autopilot_okr_reports_invalid", `Manager status okr_reports[${index}].${kind.toLowerCase()}s[${lineIndex}] has invalid numeric progress`);
+            }
+            return { id: row.id, line: text, ...(typeof row.value === "number" ? { value: row.value } : {}), ...(typeof row.moved === "number" ? { moved: row.moved } : {}) };
+        });
+        return { at: value.at, kpis: parseLines(value.kpis, "KPI"), okrs: parseLines(value.okrs, "OKR") };
+    }).sort((a, b) => a.at.localeCompare(b.at));
+}
+function statusBlockers(status) {
+    const raw = status.blockers;
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw))
+        throw new LanesError("lead_autopilot_status_invalid", "Manager status blockers must be an array");
+    return raw.map((value, index) => {
+        if (!isRecord(value) || typeof value.id !== "string" || !value.id.trim()) {
+            throw new LanesError("lead_autopilot_status_invalid", `Manager status blockers[${index}] needs a non-empty id`);
+        }
+        return value;
+    });
+}
+function leastMoved(lines, priorLines = []) {
+    const priorById = new Map(priorLines.map((line) => [line.id, line]));
+    return [...lines].sort((a, b) => {
+        const moved = (line) => line.moved !== undefined ? Math.abs(line.moved) :
+            line.value !== undefined && priorById.get(line.id)?.value !== undefined ? Math.abs(line.value - priorById.get(line.id).value) : 0;
+        return moved(a) - moved(b) || a.id.localeCompare(b.id);
+    })[0];
+}
 export function planLeadAutopilotWakes(input) {
     const { lead, children, stories, now } = input;
     if (input.keepAliveResumed)
         return [];
+    const status = input.managerStatus ?? {};
+    const reports = parseOkrReports(status);
+    const blockers = statusBlockers(status);
     const byStory = new Map(stories.map((story) => [story.id, story]));
     const wakes = [];
     const finishedReviews = children.flatMap((child) => {
         if (!["done", "blocked", "failed", "interrupted"].includes(child.state))
             return [];
         const story = byStory.get(child.story_id);
-        if (!story || !OPEN_STORY_STATES.has(story.status))
+        if (!story || !isOpenProjectStory(story))
             return [];
         const finishedAt = child.ended_at ?? child.updated_at;
         const finishedMs = Date.parse(finishedAt);
@@ -164,7 +240,7 @@ export function planLeadAutopilotWakes(input) {
     });
     const knownChildIds = new Set(children.map((child) => child.lane_id));
     const missingReviews = stories.flatMap((story) => {
-        if (!OPEN_STORY_STATES.has(story.status) || !story.updatedAt || !story.laneIds)
+        if (!isOpenProjectStory(story) || !story.updatedAt || !story.laneIds)
             return [];
         const finishedMs = Date.parse(story.updatedAt);
         if (!Number.isFinite(finishedMs) || now.getTime() - finishedMs < LEAD_AUTOPILOT_REVIEW_DELAY_MS)
@@ -187,7 +263,7 @@ export function planLeadAutopilotWakes(input) {
     const liveChildren = children.filter((child) => LIVE_STATES.has(child.state));
     const liveCount = liveChildren.length;
     const assigned = new Set(liveChildren.flatMap((child) => [child.story_id, ...(child.stories ?? []).map((story) => story.story_id)]));
-    const readyStory = stories.find((story) => story.status === "todo" && !assigned.has(story.id));
+    const readyStory = stories.find((story) => story.status === "todo" && !story.passes && !assigned.has(story.id));
     if (readyStory && liveCount < (lead.hire_grant ?? 0)) {
         const fingerprint = `fill:${readyStory.id}:${liveCount}:${lead.hire_grant ?? 0}`;
         wakes.push({
@@ -198,6 +274,84 @@ export function planLeadAutopilotWakes(input) {
             prompt: `Start a worker for ready story ${readyStory.id}. You have ${liveCount} live workers against a grant of ${lead.hire_grant ?? 0}. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
         });
     }
+    const hasFreeSlots = liveCount < (lead.hire_grant ?? 0);
+    if (hasFreeSlots && !readyStory) {
+        const latest = reports.at(-1);
+        const previous = reports.at(-2);
+        const kpiLine = latest ? leastMoved(latest.kpis, previous?.kpis) : undefined;
+        const okrLine = latest ? leastMoved(latest.okrs, previous?.okrs) : undefined;
+        const kpiText = kpiLine?.line ?? "no KPI line in the latest OKR report";
+        const okrText = okrLine?.line ?? "no OKR line in the latest OKR report";
+        const fingerprint = `plan:${latest?.at ?? "no-report"}:${kpiLine?.id ?? "no-kpi"}:${okrLine?.id ?? "no-okr"}:${stories.map((story) => `${story.id}:${story.status}`).sort().join(",")}`;
+        wakes.push({ condition: "plan_free_slots", lead_lane: lead.lane_id, story_id: "planning", fingerprint,
+            prompt: `You have ${liveCount} live workers against a grant of ${lead.hire_grant ?? 0} and no ready stories. Plan work against the least-moved KPI line: ${kpiText}; and OKR line: ${okrText}. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    if (reports.length >= 2) {
+        const latest = reports.at(-1);
+        const prior = new Map(reports.at(-2).kpis.filter((line) => line.value !== undefined).map((line) => [line.id, line]));
+        const flat = latest.kpis.filter((line) => line.value !== undefined && prior.get(line.id)?.value === line.value);
+        if (flat.length > 0) {
+            const line = flat.map((item) => `${item.line} (${item.value})`).join("; ");
+            const fingerprint = `flat-kpi:${latest.at}:${flat.map((item) => `${item.id}:${item.value}`).join(",")}`;
+            wakes.push({ condition: "flat_kpi", lead_lane: lead.lane_id, story_id: flat.map((item) => item.id).join(","), fingerprint,
+                prompt: `KPI line(s) remained flat across the two latest OKR reports: ${line}. Re-plan the affected line(s). Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+        }
+    }
+    const staleBlockers = blockers.filter((blocker) => {
+        const blockerStatus = blocker.status ?? blocker.state;
+        const resolved = blockerStatus === "resolved" || blocker.resolved_at !== undefined && blocker.resolved_at !== null;
+        const owner = typeof blocker.unblock_owner === "string" ? blocker.unblock_owner : blocker.owner;
+        const due = blocker.unblock_by ?? blocker.unblock_at ?? blocker.due_at;
+        const ownerMissing = typeof owner !== "string" || !owner.trim();
+        const dueMissing = typeof due !== "string" || !Number.isFinite(Date.parse(due));
+        return resolved || ownerMissing || dueMissing;
+    });
+    if (staleBlockers.length > 0) {
+        const labels = staleBlockers.map((blocker) => `${String(blocker.id)}${typeof blocker.what === "string" ? ` (${blocker.what})` : ""}`).join("; ");
+        const fingerprint = `blockers:${staleBlockers.map((blocker) => `${String(blocker.id)}:${String(blocker.status ?? blocker.state ?? "")}:${String(blocker.resolved_at ?? "")}:${String(blocker.unblock_owner ?? blocker.owner ?? "")}:${String(blocker.unblock_by ?? blocker.unblock_at ?? blocker.due_at ?? "")}`).join(",")}`;
+        wakes.push({ condition: "blocker_record_needs_update", lead_lane: lead.lane_id, story_id: staleBlockers.map((blocker) => String(blocker.id)).join(","), fingerprint,
+            prompt: `Fix blocker records still listed as resolved or missing an unblock owner/time: ${labels}. Move resolved blockers out of blockers, and give every open blocker an owner and time. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    if (stories.length > 0 && stories.every((story) => story.passes === true || story.status === "done" || story.status === "dropped" ||
+        ((story.status === "parked" || story.status === "blocked") && Boolean(story.externalBlocker)))) {
+        const fingerprint = `project-close:${stories.map((story) => `${story.id}:${story.status}:${story.externalBlocker ?? ""}`).sort().join(",")}`;
+        wakes.push({ condition: "project_ready_to_close", lead_lane: lead.lane_id, story_id: stories.map((story) => story.id).join(","), fingerprint,
+            prompt: `Every story is done, dropped, or parked on a named external blocker. Write the final report and mark the project complete. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    const staleLedger = stories.flatMap((story) => {
+        if (story.status !== "in_progress" || !story.updatedAt || !story.laneIds)
+            return [];
+        const updated = Date.parse(story.updatedAt);
+        if (!Number.isFinite(updated) || now.getTime() - updated <= 30 * 60_000)
+            return [];
+        return story.laneIds.flatMap((laneId) => {
+            const worker = children.find((child) => child.lane_id === laneId && child.state === "running" &&
+                (child.story_id === story.id || (child.stories ?? []).some((carried) => carried.story_id === story.id)));
+            return worker ? [{ story, worker }] : [];
+        });
+    }).sort((a, b) => a.story.id.localeCompare(b.story.id) || a.worker.lane_id.localeCompare(b.worker.lane_id));
+    if (staleLedger.length > 0) {
+        const labels = staleLedger.map(({ story, worker }) => `${story.id} (lane ${worker.lane_id}, ledger updated ${story.updatedAt})`).join("; ");
+        const fingerprint = `stale-ledger:${staleLedger.map(({ story, worker }) => `${story.id}:${worker.lane_id}:${story.updatedAt}`).join(",")}`;
+        wakes.push({ condition: "stale_worker_ledger", lead_lane: lead.lane_id, story_id: staleLedger.map(({ story }) => story.id).join(","), worker_lane: staleLedger.length === 1 ? staleLedger[0].worker.lane_id : undefined, fingerprint,
+            prompt: `A running worker has made no ledger update in over 30 minutes: ${labels}. Check the worker and update the story ledger. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
+    const withoutLiveLane = stories.flatMap((story) => {
+        if (story.status !== "in_progress")
+            return [];
+        const laneIds = story.laneIds ?? [];
+        const live = laneIds.filter((laneId) => children.some((child) => child.lane_id === laneId && LIVE_STATES.has(child.state)));
+        if (live.length > 0)
+            return [];
+        const detail = laneIds.length === 0 ? "empty lane assignment" : `no live lane among ${laneIds.join(", ")}`;
+        return [{ story, laneIds, detail }];
+    }).sort((a, b) => a.story.id.localeCompare(b.story.id));
+    if (withoutLiveLane.length > 0) {
+        const labels = withoutLiveLane.map(({ story, detail }) => `${story.id} (${detail})`).join("; ");
+        const fingerprint = `missing-worker:${withoutLiveLane.map(({ story, detail }) => `${story.id}:${story.updatedAt ?? ""}:${detail}`).join(",")}`;
+        wakes.push({ condition: "story_without_live_lane", lead_lane: lead.lane_id, story_id: withoutLiveLane.map(({ story }) => story.id).join(","), fingerprint,
+            prompt: `In-progress story has no live worker lane: ${labels}. Relaunch a worker or set the story to waiting/blocked with its wake. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.` });
+    }
     return wakes;
 }
 function readState(file) {
@@ -212,7 +366,10 @@ function readState(file) {
             (row.status_updated_at !== undefined && typeof row.status_updated_at !== "string") ||
             (row.acted !== undefined && typeof row.acted !== "boolean") ||
             (row.auto_started !== undefined && typeof row.auto_started !== "boolean") ||
-            (row.worker_lane !== undefined && typeof row.worker_lane !== "string")) {
+            (row.worker_lane !== undefined && typeof row.worker_lane !== "string") ||
+            (row.wake_count !== undefined && (!Number.isSafeInteger(row.wake_count) || row.wake_count < 1)) ||
+            (row.last_wake_at !== undefined && typeof row.last_wake_at !== "string") ||
+            (row.escalated_at !== undefined && typeof row.escalated_at !== "string")) {
             throw new LanesError("lead_autopilot_state_invalid", `Invalid autopilot state entry ${key}`, { path: file, key });
         }
     }
@@ -224,9 +381,31 @@ function writeState(file, state) {
     fs.writeFileSync(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
     fs.renameSync(temp, file);
 }
+function recordOperatorEscalation(hqRoot, record) {
+    const file = path.join(hqRoot, "workspace", "lane-briefs", "ops-board-state.json");
+    let state = {};
+    if (fs.existsSync(file)) {
+        const value = readJsonFile(file, "lead_autopilot_escalation_record_invalid");
+        if (!isRecord(value))
+            throw new LanesError("lead_autopilot_escalation_record_invalid", `Invalid operator board state ${file}`);
+        state = value;
+    }
+    const current = state.autopilot_escalations;
+    if (current !== undefined && (!Array.isArray(current) || current.some((item) => !isRecord(item)))) {
+        throw new LanesError("lead_autopilot_escalation_record_invalid", `Invalid autopilot escalations in ${file}`);
+    }
+    const rows = (current ?? []);
+    if (rows.some((item) => item.lead_lane === record.lead_lane && item.fingerprint === record.fingerprint))
+        return;
+    const next = { ...state, autopilot_escalations: [...rows, record] };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
 async function runLeadAutopilotPassUnlocked(input) {
     const { hqRoot, host, now } = input;
-    const result = { ok: true, host, evaluated: 0, sent: [], started: [], skipped: [] };
+    const result = { ok: true, host, evaluated: 0, sent: [], started: [], escalated: [], skipped: [] };
     const leads = parseRegistry(hqRoot).filter((lead) => lead.host === host || (host === "local" && lead.host === input.hostname));
     const lanes = readAllLanes(hqRoot);
     const byId = new Map(lanes.map((lane) => [lane.lane_id, lane]));
@@ -253,7 +432,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             result.skipped.push({ lead_lane: lead.lane_id, reason: "flag_off" });
             continue;
         }
-        const status = readStatus(hqRoot, registered.status);
+        const status = readStatus(hqRoot, registered.status, lead.company.slug);
         const statusUpdatedAt = typeof status.updated_at === "string" && Number.isFinite(Date.parse(status.updated_at))
             ? new Date(Date.parse(status.updated_at)).toISOString()
             : undefined;
@@ -265,6 +444,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             children,
             stories,
             now,
+            managerStatus: status,
             keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
         });
         let stateChanged = false;
@@ -279,36 +459,69 @@ async function runLeadAutopilotPassUnlocked(input) {
             const key = `${lead.lane_id}:${wake.condition}`;
             const prior = state.sent[key];
             if (prior?.fingerprint === wake.fingerprint) {
-                if (wake.condition === "fill_grant" && input.startWorker && !prior.acted && !prior.auto_started) {
-                    const wakeAt = Date.parse(prior.at);
-                    if (!Number.isFinite(wakeAt)) {
+                if (input.dryRun)
+                    continue;
+                let current = prior;
+                const lastWakeAt = Date.parse(prior.last_wake_at ?? prior.at);
+                if (!Number.isFinite(lastWakeAt)) {
+                    throw new LanesError("lead_autopilot_state_invalid", `Invalid wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                }
+                if (statusUpdatedAt === undefined || prior.status_updated_at === undefined) {
+                    throw new LanesError("lead_autopilot_status_activity_unverifiable", `Cannot verify whether lead ${lead.lane_id} acted after its autopilot wake`, { lead_lane: lead.lane_id, story_id: wake.story_id });
+                }
+                if (!prior.acted && Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at)) {
+                    current = { ...prior, acted: true };
+                    state.sent[key] = current;
+                    stateChanged = true;
+                }
+                if (wake.condition === "fill_grant" && input.startWorker && !current.acted && !current.auto_started) {
+                    const firstWakeAt = Date.parse(current.at);
+                    if (!Number.isFinite(firstWakeAt)) {
                         throw new LanesError("lead_autopilot_state_invalid", `Invalid fill-grant wake time for ${lead.lane_id}`, { lead_lane: lead.lane_id, story_id: wake.story_id });
                     }
-                    if (statusUpdatedAt === undefined || prior.status_updated_at === undefined) {
-                        throw new LanesError("lead_autopilot_status_activity_unverifiable", `Cannot verify whether lead ${lead.lane_id} acted after its fill-grant wake`, { lead_lane: lead.lane_id, story_id: wake.story_id });
-                    }
-                    if (Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at)) {
-                        state.sent[key] = { ...prior, acted: true };
-                        stateChanged = true;
-                    }
-                    else if (now.getTime() - wakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
+                    if (now.getTime() - firstWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
                         const story = stories.find((candidate) => candidate.id === wake.story_id && candidate.status === "todo");
                         if (!story?.briefPath) {
                             throw new LanesError("lead_autopilot_story_brief_missing", `Cannot auto-start story ${wake.story_id}: its project record has no valid brief path`, { lead_lane: lead.lane_id, story_id: wake.story_id, project_id: lead.project_id });
                         }
                         if (lead.state !== "running" && lead.state !== "queued") {
-                            state.sent[key] = { ...prior, acted: true };
+                            current = { ...current, acted: true };
+                            state.sent[key] = current;
                             stateChanged = true;
                             result.skipped.push({ lead_lane: lead.lane_id, reason: "auto_start_lead_not_active" });
                         }
                         else {
                             const started = await input.startWorker({ lead, story });
-                            state.sent[key] = { ...prior, auto_started: true, worker_lane: started.lane_id };
+                            current = { ...current, auto_started: true, worker_lane: started.lane_id };
+                            state.sent[key] = current;
                             stateChanged = true;
                             result.started.push({ lead_lane: lead.lane_id, story_id: story.id, worker_lane: started.lane_id });
                         }
                     }
                 }
+                if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= LEAD_AUTOPILOT_FILL_DELAY_MS) {
+                    const wakeCount = current.wake_count ?? 1;
+                    if (wakeCount < 2) {
+                        appendDropboxMessage(hqRoot, lead.lane_id, {
+                            at: now.toISOString(),
+                            message_id: `lead-autopilot:${wake.fingerprint}:wake-2`,
+                            kind: "system_notice",
+                            text: wake.prompt,
+                        });
+                        current = { ...current, wake_count: 2, last_wake_at: now.toISOString() };
+                        state.sent[key] = current;
+                        stateChanged = true;
+                        result.sent.push(wake);
+                    }
+                    else {
+                        const escalation = { team: registered.team, lead_lane: lead.lane_id, condition: wake.condition, story_id: wake.story_id, at: now.toISOString(), fingerprint: wake.fingerprint };
+                        recordOperatorEscalation(hqRoot, escalation);
+                        current = { ...current, escalated_at: now.toISOString() };
+                        state.sent[key] = current;
+                        stateChanged = true;
+                        result.escalated.push(escalation);
+                    }
+                }
                 continue;
             }
             if (!input.dryRun) {
@@ -322,6 +535,8 @@ async function runLeadAutopilotPassUnlocked(input) {
                     fingerprint: wake.fingerprint,
                     at: now.toISOString(),
                     ...(statusUpdatedAt ? { status_updated_at: statusUpdatedAt } : {}),
+                    wake_count: 1,
+                    last_wake_at: now.toISOString(),
                 };
                 stateChanged = true;
             }
@@ -332,6 +547,17 @@ async function runLeadAutopilotPassUnlocked(input) {
     }
     return result;
 }
+const LEAD_AUTOPILOT_STALE_LOCK_MAX_AGE_MS = 60 * 60_000;
+function processStartIdentity(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const fields = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+        return fields[19] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 function reclaimStaleLock(lockPath) {
     let before;
     let text;
@@ -348,17 +574,34 @@ function reclaimStaleLock(lockPath) {
     }
     if (!before.isFile() || before.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino)
         return false;
-    const pid = Number(text.split("\n", 1)[0]);
+    const [pidText, createdAt, recordedStartIdentity] = text.split("\n");
+    const pid = Number(pidText);
     if (!Number.isSafeInteger(pid) || pid < 1)
         return false;
+    let dead = false;
     try {
         process.kill(pid, 0);
-        return false;
+        const currentStartIdentity = processStartIdentity(pid);
+        if (recordedStartIdentity && currentStartIdentity) {
+            if (recordedStartIdentity !== currentStartIdentity)
+                dead = true;
+            else
+                return false;
+        }
+        else {
+            const createdMs = Date.parse(createdAt ?? "");
+            if (!Number.isFinite(createdMs) || Date.now() - createdMs < LEAD_AUTOPILOT_STALE_LOCK_MAX_AGE_MS)
+                return false;
+            dead = true;
+        }
     }
     catch (error) {
         if (error.code !== "ESRCH")
             return false;
+        dead = true;
     }
+    if (!dead)
+        return false;
     try {
         const current = fs.lstatSync(lockPath);
         if (current.dev !== before.dev || current.ino !== before.ino)
@@ -381,7 +624,7 @@ export async function runLeadAutopilotPass(input) {
     for (let attempt = 0; attempt < 2; attempt += 1) {
         try {
             lockFd = fs.openSync(lockPath, "wx", 0o600);
-            fs.writeFileSync(lockFd, `${process.pid}\n${input.now.toISOString()}\n`, "utf8");
+            fs.writeFileSync(lockFd, `${process.pid}\n${input.now.toISOString()}\n${processStartIdentity(process.pid) ?? ""}\n`, "utf8");
             break;
         }
         catch (error) {

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

@@ -13,7 +13,7 @@ export interface HireGrantAdmissionSnapshot {
 export declare function terminalChildResumeHireGrantError(current: LaneRecord, snapshot: HireGrantAdmissionSnapshot): LanesError | null;
 export declare function hireGrantCapacityError(parent: LaneHireGrantRow, children: readonly LaneHireGrantRow[]): LanesError;
 /** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
-export declare function withHireGrantAdmission<T>(hqRoot: string, parentLaneId: string, fn: (snapshot: HireGrantAdmissionSnapshot) => T, suppliedHierarchy?: readonly LaneHireGrantRow[]): T;
+export declare function withHireGrantAdmission<T>(hqRoot: string, parentLaneId: string, fn: (snapshot: HireGrantAdmissionSnapshot) => T, suppliedHierarchy?: readonly LaneHireGrantRow[], preferSuppliedLaneIds?: ReadonlySet<string>): T;
 export interface HireGrantBackfillRow {
     lane_id: string;
     existing_grant: number | null;

package/dist/lib/lanes/grants.js

@@ -72,7 +72,7 @@ export function hireGrantCapacityError(parent, children) {
     });
 }
 /** Keep the occupancy snapshot and the resulting lane write in one parent-lock scope. */
-export function withHireGrantAdmission(hqRoot, parentLaneId, fn, suppliedHierarchy) {
+export function withHireGrantAdmission(hqRoot, parentLaneId, fn, suppliedHierarchy, preferSuppliedLaneIds = new Set()) {
     return withLaneHireLocks(hqRoot, [parentLaneId], () => {
         const ownerLanes = listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
         let allLanes;
@@ -83,10 +83,12 @@ export function withHireGrantAdmission(hqRoot, parentLaneId, fn, suppliedHierarc
         }
         else {
             const byId = new Map(suppliedHierarchy.map((lane) => [lane.lane_id, lane]));
-            // The owner copy is authoritative for every lane it stores; the supplied
-            // primary snapshot fills only hierarchy rows that live on another host.
-            for (const lane of ownerLanes)
-                byId.set(lane.lane_id, lane);
+            // The owner copy is authoritative for every lane it stores unless the
+            // caller supplied a freshly verified owner snapshot for that lane.
+            for (const lane of ownerLanes) {
+                if (!preferSuppliedLaneIds.has(lane.lane_id))
+                    byId.set(lane.lane_id, lane);
+            }
             allLanes = [...byId.values()];
             const suppliedParent = byId.get(parentLaneId);
             if (!suppliedParent) {

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

@@ -10,7 +10,7 @@ export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export type { HostCapacityAccount, HostCapacityProvider, HostCapacitySnapshot, HostPlacementChoice, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneAccountSelection, LaneAccountSelectionConsidered, LaneAccountSelectionHostCount, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, WorkerProfileRepinHistoryEntry, LaneSettingsHistoryEntry, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneAccountSelection, LaneAccountSelectionConsidered, LaneAccountSelectionHostCount, LaneEnvelope, LaneHost, LaneProvider, LanePlacementPolicy, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionPriority, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, WorkerProfileRepinHistoryEntry, LaneSettingsHistoryEntry, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
 export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";

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

@@ -1,6 +1,9 @@
 import type { LaneRecord, ManagerStatusGateHistoryEntry, QuestionRecord } from "./types.js";
 export declare const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export declare const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
+export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS: number;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export declare const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";
 export declare const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
@@ -20,10 +23,12 @@ export interface LaneTerminalResumeResult {
 export declare function queueLaneTerminalResume(current: LaneRecord, at: string, resumeText: string, options?: {
     allowResume?: boolean;
     mergeExisting?: boolean;
+    allowBlockedResume?: boolean;
 }): LaneTerminalResumeResult;
 /** Persist a manager status miss and queue its one bounded follow-up turn. */
 export declare function queueManagerStatusGateResume(hqRoot: string, laneId: string, entry: Omit<ManagerStatusGateHistoryEntry, "event" | "resume_queued" | "resume_skipped_reason">, resumeText: string): LaneRecord;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT = "You ended blocked with no pending question. Record the event you wait on in waiting_on, re-check each blocker, and continue the next unblocked story.";
 export declare const LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT = "Automatic keep-alive resume: your previous turn was interrupted by a provider process exit. Check your last state before continuing. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 export type KeepAliveBlockedReason = NonNullable<LaneRecord["keep_alive_blocked_reason"]>;
 /** The latest terminal envelope fields used by both watch and reconcile. */

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

@@ -5,6 +5,9 @@ import { dropboxInboxHasMessages } from "./dropbox.js";
 import { appendCappedHistory, listQuestionIds, readQuestion, retryUpdateLane } from "./store.js";
 export const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
+export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS = 15 * 60 * 1000;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
 export const LANE_SUPERSESSION_LINEAGE_AWARE_FLAG = "lanes.supersession-lineage-aware";
 export const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
@@ -28,16 +31,17 @@ export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
             resumeQueued: true,
         };
     }
-    if (current.state === "blocked")
+    if (current.state === "blocked" && options.allowBlockedResume !== true)
         return { lane: current, resumeQueued: false, resumeSkippedReason: "blocked" };
     if (current.state === "awaiting_input")
         return { lane: current, resumeQueued: false, resumeSkippedReason: "open_question" };
     if (options.allowResume === false)
         return { lane: current, resumeQueued: false, resumeSkippedReason: "miss_limit" };
-    if (current.state !== "done" && current.state !== "interrupted" && current.state !== "failed") {
+    if (current.state !== "done" && current.state !== "interrupted" && current.state !== "failed" && !(current.state === "blocked" && options.allowBlockedResume === true)) {
         return { lane: current, resumeQueued: false };
     }
-    if (!current.provider_session_id) {
+    const sessionId = current.provider_session_id ?? current.last_resume?.session_id;
+    if (!sessionId) {
         return { lane: current, resumeQueued: false, resumeSkippedReason: "no_provider_session" };
     }
     return {
@@ -51,7 +55,7 @@ export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
             terminal_reason: undefined,
             terminal_details: undefined,
             pending_resume: {
-                session_id: current.provider_session_id,
+                session_id: sessionId,
                 trigger: "resume",
                 resumed_from: current.state,
                 text: resumeText,
@@ -92,6 +96,7 @@ export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText)
     });
 }
 export const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+export const LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT = "You ended blocked with no pending question. Record the event you wait on in waiting_on, re-check each blocker, and continue the next unblocked story.";
 export const LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT = "Automatic keep-alive resume: your previous turn was interrupted by a provider process exit. Check your last state before continuing. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 /** Shared done-state policy used by watch, reconcile, and the show command. */
 export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork) {

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

@@ -3,7 +3,7 @@
  * path and for envelope `decision: "ask"` ingestion. Two writers here would
  * drift on hop, origin, raised_via, body store, and routing_history.
  */
-import { type LaneEnvelope, type LaneRecord, type LaneCompanyRef, type QuestionBodyStore, type QuestionKind, type QuestionRecord, type RaisedVia } from "./types.js";
+import { type LaneEnvelope, type LaneRecord, type LaneCompanyRef, type QuestionBodyStore, type QuestionKind, type QuestionPriority, type QuestionRecord, type RaisedVia } from "./types.js";
 export interface QuestionBody {
     question: string;
     context: string;
@@ -42,6 +42,7 @@ export interface RaiseLaneQuestionInput {
     at: string;
     activeCompany?: LaneCompanyRef | null;
     questionId?: string;
+    priority?: QuestionPriority;
 }
 /**
  * Persist one question the way `hq lanes ask` does: createQuestion, write the

package/dist/lib/lanes/questions.js

@@ -172,6 +172,7 @@ export function raiseLaneQuestion(input) {
             story_id: input.lane.story_id,
             thread_id: input.lane.thread_id,
             raised_via: input.raisedVia,
+            ...(input.priority ? { priority: input.priority } : {}),
             asked_at: input.at,
             origin: { kind: "lane", id: input.lane.lane_id },
             hop: 1,
@@ -191,6 +192,7 @@ export function raiseLaneQuestion(input) {
                 story_id: input.lane.story_id,
                 thread_id: input.lane.thread_id,
                 raised_via: input.raisedVia,
+                ...(input.priority ? { priority: input.priority } : {}),
                 asked_at: input.at,
                 origin: { kind: "lane", id: input.lane.lane_id },
                 hop: 1,