@indigoai-us/hq-cli 5.290.0 → 5.292.0

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

@@ -0,0 +1,69 @@
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import type { LaneRecord } from "./types.js";
+export declare const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
+export declare const LEAD_AUTOPILOT_DEFAULT_ENABLED = false;
+export declare const LEAD_AUTOPILOT_REVIEW_DELAY_MS: number;
+export declare const LEAD_AUTOPILOT_FILL_DELAY_MS: number;
+export declare const LEAD_AUTOPILOT_PROMPT_LOOP = "personal/knowledge/team-lead-operating-loop.md";
+export interface RegisteredLead {
+    team: string;
+    lane: string;
+    host: string;
+    status: string;
+    prd: string;
+}
+export interface AutopilotWake {
+    condition: "review_finished_worker" | "fill_grant";
+    lead_lane: string;
+    story_id: string;
+    worker_lane?: string;
+    prompt: string;
+    fingerprint: string;
+}
+export interface AutopilotPassResult {
+    ok: true;
+    host: string;
+    evaluated: number;
+    sent: AutopilotWake[];
+    started: Array<{
+        lead_lane: string;
+        story_id: string;
+        worker_lane: string;
+    }>;
+    skipped: Array<{
+        lead_lane: string;
+        reason: string;
+    }>;
+}
+interface ProjectStory {
+    id: string;
+    status: string;
+    briefPath?: string;
+    laneIds?: string[];
+    updatedAt?: string;
+}
+export declare function planLeadAutopilotWakes(input: {
+    lead: LaneRecord;
+    children: readonly LaneRecord[];
+    stories: readonly ProjectStory[];
+    now: Date;
+    keepAliveResumed?: boolean;
+}): AutopilotWake[];
+export declare function runLeadAutopilotPass(input: {
+    hqRoot: string;
+    host: string;
+    hostname: string;
+    outpostId: string | null;
+    now: Date;
+    dryRun?: boolean;
+    readFlag?: typeof readLanesRegistryFlag;
+    keepAliveResumedLeads?: ReadonlySet<string>;
+    startWorker?: (input: {
+        lead: LaneRecord;
+        story: ProjectStory;
+    }) => Promise<{
+        lane_id: string;
+    }>;
+}): Promise<AutopilotPassResult>;
+export {};
+//# sourceMappingURL=autopilot.d.ts.map

package/dist/lib/lanes/autopilot.js

@@ -0,0 +1,418 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { appendDropboxMessage } from "./dropbox.js";
+import { LanesError } from "./errors.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { readAllLanes } from "./store.js";
+export const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
+export const LEAD_AUTOPILOT_DEFAULT_ENABLED = false;
+export const LEAD_AUTOPILOT_REVIEW_DELAY_MS = 15 * 60_000;
+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 isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonFile(filePath, code) {
+    let text;
+    try {
+        const stat = fs.lstatSync(filePath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("expected a regular file");
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        throw new LanesError(code, `Cannot read ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new LanesError(code, `Cannot parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { path: filePath });
+    }
+}
+function parseRegistry(hqRoot) {
+    const file = path.join(hqRoot, "workspace", "lane-briefs", "juniors.json");
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw new LanesError("lead_autopilot_registry_invalid", `Cannot inspect ${file}: ${error instanceof Error ? error.message : String(error)}`, { path: file });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: expected a regular file`, { path: file });
+    }
+    const raw = readJsonFile(file, "lead_autopilot_registry_invalid");
+    if (isRecord(raw) && raw.juniors === undefined && Array.isArray(raw.retired))
+        return [];
+    if (!isRecord(raw) || !Array.isArray(raw.juniors)) {
+        throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: juniors must be an array`, { path: file });
+    }
+    const rows = [];
+    for (const [index, value] of raw.juniors.entries()) {
+        if (!isRecord(value) || ["team", "lane", "host", "status", "prd"].some((key) => typeof value[key] !== "string" || !value[key].trim())) {
+            throw new LanesError("lead_autopilot_registry_invalid", `Invalid lead registry ${file}: juniors[${index}] must name team, lane, host, status, and prd`, { path: file, index });
+        }
+        rows.push(value);
+    }
+    return rows;
+}
+function registeredFilePath(hqRoot, relativePath, errorCode) {
+    const root = path.resolve(hqRoot);
+    const file = path.resolve(root, relativePath);
+    if (file === root || !file.startsWith(`${root}${path.sep}`)) {
+        throw new LanesError(errorCode, `Registered path escapes HQ root: ${relativePath}`, { path: relativePath });
+    }
+    try {
+        const realRoot = fs.realpathSync(root);
+        const realFile = fs.realpathSync(file);
+        if (realFile === realRoot || !realFile.startsWith(`${realRoot}${path.sep}`)) {
+            throw new LanesError(errorCode, `Registered path resolves outside HQ root: ${relativePath}`, { path: relativePath });
+        }
+    }
+    catch (error) {
+        if (error instanceof LanesError)
+            throw error;
+        throw new LanesError(errorCode, `Cannot resolve registered path ${relativePath}: ${error instanceof Error ? error.message : String(error)}`, { path: relativePath });
+    }
+    return file;
+}
+function projectStories(hqRoot, relativePath, companySlug, projectId) {
+    if (companySlug !== undefined) {
+        const expected = path.join("companies", companySlug, "projects", projectId, "prd.json");
+        if (path.normalize(relativePath) !== expected) {
+            throw new LanesError("lead_autopilot_tenant_mismatch", `Project registry path does not match lead ${companySlug}/${projectId}`, { path: relativePath, company: companySlug, project_id: projectId });
+        }
+    }
+    const file = registeredFilePath(hqRoot, relativePath, "lead_autopilot_project_path_invalid");
+    const raw = readJsonFile(file, "lead_autopilot_project_invalid");
+    const rows = isRecord(raw) ? raw.userStories ?? raw.stories : undefined;
+    if (!Array.isArray(rows)) {
+        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;
+        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.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 (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 });
+        }
+        if (typeof rawBrief === "string" && companySlug !== undefined) {
+            const normalizedBrief = path.normalize(rawBrief);
+            if (normalizedBrief.startsWith(`companies${path.sep}`) && !normalizedBrief.startsWith(path.join("companies", companySlug) + path.sep)) {
+                throw new LanesError("lead_autopilot_tenant_mismatch", `Story brief path does not match lead ${companySlug}/${projectId}`, { path: rawBrief, company: companySlug, project_id: projectId });
+            }
+        }
+        let briefPath;
+        if (typeof rawBrief === "string") {
+            briefPath = registeredFilePath(hqRoot, rawBrief, "lead_autopilot_story_brief_path_invalid");
+            try {
+                const briefStat = fs.lstatSync(briefPath);
+                if (!briefStat.isFile() || briefStat.isSymbolicLink())
+                    throw new Error("expected a regular file");
+            }
+            catch (error) {
+                throw new LanesError("lead_autopilot_story_brief_invalid", `Cannot read story brief ${rawBrief}: ${error instanceof Error ? error.message : String(error)}`, { path: rawBrief, story_id: story.id });
+            }
+        }
+        return {
+            id: story.id,
+            status,
+            ...(briefPath ? { briefPath } : {}),
+            ...(Array.isArray(story.lanes) ? { laneIds: story.lanes } : {}),
+            ...(typeof story.updated_at === "string" ? { updatedAt: story.updated_at } : {}),
+        };
+    });
+}
+function readStatus(hqRoot, relativePath) {
+    const file = registeredFilePath(hqRoot, relativePath, "lead_autopilot_status_path_invalid");
+    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;
+}
+export function planLeadAutopilotWakes(input) {
+    const { lead, children, stories, now } = input;
+    if (input.keepAliveResumed)
+        return [];
+    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))
+            return [];
+        const finishedAt = child.ended_at ?? child.updated_at;
+        const finishedMs = Date.parse(finishedAt);
+        if (!Number.isFinite(finishedMs) || now.getTime() - finishedMs < LEAD_AUTOPILOT_REVIEW_DELAY_MS)
+            return [];
+        return [{ laneId: child.lane_id, story, finishedAt }];
+    });
+    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)
+            return [];
+        const finishedMs = Date.parse(story.updatedAt);
+        if (!Number.isFinite(finishedMs) || now.getTime() - finishedMs < LEAD_AUTOPILOT_REVIEW_DELAY_MS)
+            return [];
+        return story.laneIds.filter((laneId) => !knownChildIds.has(laneId)).map((laneId) => ({ laneId, story, finishedAt: story.updatedAt }));
+    });
+    const overdueReviews = [...finishedReviews, ...missingReviews].sort((a, b) => a.laneId.localeCompare(b.laneId));
+    if (overdueReviews.length > 0) {
+        const fingerprint = `review:${overdueReviews.map(({ laneId, story, finishedAt }) => `${laneId}:${story.id}:${story.status}:${finishedAt}`).join(",")}`;
+        const reviewList = overdueReviews.map(({ laneId, story }) => `lane ${laneId} (story ${story.id}, status ${story.status})`).join("; ");
+        wakes.push({
+            condition: "review_finished_worker",
+            lead_lane: lead.lane_id,
+            story_id: overdueReviews.map(({ story }) => story.id).join(","),
+            ...(overdueReviews.length === 1 ? { worker_lane: overdueReviews[0].laneId } : {}),
+            fingerprint,
+            prompt: `Review finished worker ${overdueReviews.length === 1 ? "lane" : "lanes"}: ${reviewList}. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+        });
+    }
+    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));
+    if (readyStory && liveCount < (lead.hire_grant ?? 0)) {
+        const fingerprint = `fill:${readyStory.id}:${liveCount}:${lead.hire_grant ?? 0}`;
+        wakes.push({
+            condition: "fill_grant",
+            lead_lane: lead.lane_id,
+            story_id: readyStory.id,
+            fingerprint,
+            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}.`,
+        });
+    }
+    return wakes;
+}
+function readState(file) {
+    if (!fs.existsSync(file))
+        return { schema_version: "hq-lanes-autopilot-state.v1", sent: {} };
+    const value = readJsonFile(file, "lead_autopilot_state_invalid");
+    if (!isRecord(value) || value.schema_version !== "hq-lanes-autopilot-state.v1" || !isRecord(value.sent)) {
+        throw new LanesError("lead_autopilot_state_invalid", `Invalid autopilot state ${file}`, { path: file });
+    }
+    for (const [key, row] of Object.entries(value.sent)) {
+        if (!isRecord(row) || typeof row.fingerprint !== "string" || typeof row.at !== "string" ||
+            (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")) {
+            throw new LanesError("lead_autopilot_state_invalid", `Invalid autopilot state entry ${key}`, { path: file, key });
+        }
+    }
+    return value;
+}
+function writeState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(state, 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 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]));
+    const stateFile = path.join(hqRoot, "workspace", "lane-briefs", "autopilot-state.json");
+    const state = readState(stateFile);
+    for (const registered of leads) {
+        const lead = byId.get(registered.lane) ?? lanes.find((candidate) => candidate.lane_id.startsWith(`${registered.lane}_`));
+        if (!lead) {
+            result.skipped.push({ lead_lane: registered.lane, reason: "lead_lane_missing" });
+            continue;
+        }
+        if (lead.company === null) {
+            result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_company_unresolved" });
+            continue;
+        }
+        const registeredLocalHost = registered.host === "local" || registered.host === input.hostname;
+        if ((registeredLocalHost && (lead.host.kind !== "local" || lead.host.id !== input.hostname)) ||
+            (!registeredLocalHost && (lead.host.kind !== "outpost" || lead.host.id !== registered.host || input.outpostId !== registered.host))) {
+            result.skipped.push({ lead_lane: lead.lane_id, reason: "lead_host_mismatch" });
+            continue;
+        }
+        const enabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_FLAG, { company: lead.company });
+        if (!enabled) {
+            result.skipped.push({ lead_lane: lead.lane_id, reason: "flag_off" });
+            continue;
+        }
+        const status = readStatus(hqRoot, registered.status);
+        const statusUpdatedAt = typeof status.updated_at === "string" && Number.isFinite(Date.parse(status.updated_at))
+            ? new Date(Date.parse(status.updated_at)).toISOString()
+            : undefined;
+        result.evaluated += 1;
+        const stories = projectStories(hqRoot, registered.prd, lead.company.slug, lead.project_id);
+        const children = lanes.filter((lane) => lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
+        const planned = planLeadAutopilotWakes({
+            lead,
+            children,
+            stories,
+            now,
+            keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
+        });
+        let stateChanged = false;
+        const activeKeys = new Set(planned.map((wake) => `${lead.lane_id}:${wake.condition}`));
+        for (const key of Object.keys(state.sent)) {
+            if (key.startsWith(`${lead.lane_id}:`) && !activeKeys.has(key)) {
+                delete state.sent[key];
+                stateChanged = true;
+            }
+        }
+        for (const wake of planned) {
+            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)) {
+                        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) {
+                        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 };
+                            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 };
+                            stateChanged = true;
+                            result.started.push({ lead_lane: lead.lane_id, story_id: story.id, worker_lane: started.lane_id });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (!input.dryRun) {
+                appendDropboxMessage(hqRoot, lead.lane_id, {
+                    at: now.toISOString(),
+                    message_id: `lead-autopilot:${wake.fingerprint}`,
+                    kind: "system_notice",
+                    text: wake.prompt,
+                });
+                state.sent[key] = {
+                    fingerprint: wake.fingerprint,
+                    at: now.toISOString(),
+                    ...(statusUpdatedAt ? { status_updated_at: statusUpdatedAt } : {}),
+                };
+                stateChanged = true;
+            }
+            result.sent.push(wake);
+        }
+        if (!input.dryRun && stateChanged)
+            writeState(stateFile, state);
+    }
+    return result;
+}
+function reclaimStaleLock(lockPath) {
+    let before;
+    let text;
+    let after;
+    try {
+        before = fs.lstatSync(lockPath);
+        text = fs.readFileSync(lockPath, "utf8");
+        after = fs.lstatSync(lockPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        return false;
+    }
+    if (!before.isFile() || before.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino)
+        return false;
+    const pid = Number(text.split("\n", 1)[0]);
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        if (error.code !== "ESRCH")
+            return false;
+    }
+    try {
+        const current = fs.lstatSync(lockPath);
+        if (current.dev !== before.dev || current.ino !== before.ino)
+            return false;
+        fs.unlinkSync(lockPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        return false;
+    }
+}
+export async function runLeadAutopilotPass(input) {
+    if (input.dryRun)
+        return runLeadAutopilotPassUnlocked(input);
+    const lockPath = path.join(input.hqRoot, "workspace", "lane-briefs", "autopilot.lock");
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    let lockFd;
+    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");
+            break;
+        }
+        catch (error) {
+            if (error.code === "EEXIST" && attempt === 0 && reclaimStaleLock(lockPath))
+                continue;
+            if (error.code === "EEXIST") {
+                throw new LanesError("lead_autopilot_lock_busy", `Another autopilot pass owns ${lockPath}`, { path: lockPath });
+            }
+            throw new LanesError("lead_autopilot_lock_failed", `Cannot lock autopilot state: ${error instanceof Error ? error.message : String(error)}`, { path: lockPath });
+        }
+    }
+    if (lockFd === undefined)
+        throw new LanesError("lead_autopilot_lock_busy", `Another autopilot pass owns ${lockPath}`, { path: lockPath });
+    try {
+        return await runLeadAutopilotPassUnlocked(input);
+    }
+    finally {
+        try {
+            fs.closeSync(lockFd);
+        }
+        catch (error) {
+            process.stderr.write(`hq lanes autopilot: lock close failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        try {
+            fs.unlinkSync(lockPath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                process.stderr.write(`hq lanes autopilot: lock removal failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=autopilot.js.map

package/dist/lib/lanes/mesh-events.js

@@ -452,6 +452,8 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
     if (!company || !threadId)
         return;
     const patchStoryStatus = async (status) => {
+        if (!lane.project_id?.trim() || !lane.story_id?.trim())
+            return;
         const suppressions = opts.storyStatusSuppressions;
         const key = laneStoryStatusSuppressionKey(company, lane.project_id, lane.story_id);
         if (suppressions?.has(key))

package/dist/lib/lanes/store.js

@@ -529,6 +529,7 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.queued_reason,
         });
     }
+    let normalized;
     if (raw.queued_details !== undefined) {
         const details = raw.queued_details;
         if (details === null || typeof details !== "object" || Array.isArray(details) ||
@@ -549,11 +550,15 @@ export function parseLaneRecord(raw, filePath) {
                 });
             }
             if (raw.queued_reason !== "worker_profile_changed") {
-                throw new LaneSchemaError("queued_details requires queued_reason worker_profile_changed", {
-                    path: filePath,
-                    field: "queued_details",
-                    queued_reason: raw.queued_reason,
-                });
+                if (raw.queued_reason === undefined) {
+                    throw new LaneSchemaError("queued_details requires queued_reason worker_profile_changed", {
+                        path: filePath,
+                        field: "queued_details",
+                        queued_reason: raw.queued_reason,
+                    });
+                }
+                normalized = { ...raw };
+                delete normalized.queued_details;
             }
         }
         else if (detailsRecord.reason === "outpost_dispatch_unknown") {
@@ -831,7 +836,7 @@ export function parseLaneRecord(raw, filePath) {
     }
     // Spread-preserving: return the original object so unknown keys survive
     // a parse/rewrite cycle (spec §5.1 field-preservation).
-    return raw;
+    return (normalized ?? raw);
 }
 function parseLaneAccountSelection(value, filePath) {
     const failure = (field) => new LaneSchemaError(`Invalid account_selection.${field}`, {

package/dist/lib/mesh/api.js

@@ -387,6 +387,10 @@ export async function appendThreadEvent(token, companyUid, threadId, eventKind,
  * credential. This body never includes actorUid.
  */
 export async function patchStory(token, companyUid, projectId, storyId, patch) {
+    if (typeof projectId !== "string" || projectId.trim() === "" ||
+        typeof storyId !== "string" || storyId.trim() === "") {
+        throw new TypeError("Work Mesh projectId and storyId must be non-empty strings");
+    }
     const body = { companyUid };
     if (patch.status)
         body.status = patch.status;

package/dist/lib/mesh/live/daemon/state.d.ts

@@ -1,6 +1,7 @@
 /**
  * Daemon state.json under ~/.hq/work-mesh/daemon/ (0600, metadata-only).
  */
+import * as fs from "node:fs";
 import type { MqttConnectionState } from "./presence.js";
 import type { FlushSummary } from "../flush.js";
 import type { DroppedPresenceCompany } from "./credentials.js";
@@ -39,6 +40,11 @@ export interface DaemonStateFile {
 }
 export declare function defaultDaemonState(pid: number, now?: () => Date): DaemonStateFile;
 export declare function readDaemonState(dir: string): DaemonStateFile | null;
-export declare function writeDaemonState(dir: string, state: DaemonStateFile): void;
+interface WriteDaemonStateOptions {
+    renameSync?: typeof fs.renameSync;
+    sleepSync?: (ms: number) => void;
+}
+export declare function writeDaemonState(dir: string, state: DaemonStateFile, options?: WriteDaemonStateOptions): void;
 export declare function patchDaemonState(dir: string, patch: Partial<DaemonStateFile>, now?: () => Date): DaemonStateFile;
+export {};
 //# sourceMappingURL=state.d.ts.map

package/dist/lib/mesh/live/daemon/state.js

@@ -29,13 +29,45 @@ export function readDaemonState(dir) {
         return null;
     }
 }
-export function writeDaemonState(dir, state) {
+const DAEMON_STATE_RENAME_RETRY_DELAYS_MS = [20, 50, 100];
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)), 0, 0, ms);
+}
+function isTransientRenameContention(err) {
+    return err !== null && typeof err === "object" && "code" in err &&
+        (err.code === "EPERM" || err.code === "EBUSY");
+}
+export function writeDaemonState(dir, state, options = {}) {
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     const dest = daemonStatePath(dir);
     const tmp = path.join(dir, `.state.tmp.${process.pid}.${Date.now()}`);
     const body = `${JSON.stringify(state, null, 2)}\n`;
     fs.writeFileSync(tmp, body, { mode: 0o600 });
-    fs.renameSync(tmp, dest);
+    const renameSync = options.renameSync ?? fs.renameSync;
+    const waitSync = options.sleepSync ?? sleepSync;
+    try {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                renameSync(tmp, dest);
+                break;
+            }
+            catch (err) {
+                const delay = DAEMON_STATE_RENAME_RETRY_DELAYS_MS[attempt];
+                if (!isTransientRenameContention(err) || delay === undefined)
+                    throw err;
+                waitSync(delay);
+            }
+        }
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            /* Preserve the rename failure; the destination remains the prior complete state. */
+        }
+        throw err;
+    }
     try {
         fs.chmodSync(dest, 0o600);
     }