@indigoai-us/hq-cli 5.292.0 → 5.293.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [5.293.0] — 2026-09-30
+- [HQ-CLI-HOOK-TIMEOUT-KIND] Group hook timeout events by normalized kind (`warning` or `exceeded`) across scripts; keep script and platform tags for triage. Existing per-script issues will stop receiving new events, and the lead handles their status.
+- `hq lanes move` now reports an already-on-target no-op without dispatching or changing the queued lane.
+- On Linux, `hq daemon run` sets XDG_RUNTIME_DIR for its services when the system unit left it unset, so `systemctl --user` from jobs-reconcile no longer fails with "Failed to connect to bus: No medium found".
+
+- With the default-off lanes.keep-alive-resume-blocked gate enabled, reconcile
+  resumes an opted-in blocked lead after 15 minutes when it has open stories and
+  no pending question. After two blocked resumes, it records another blocked
+  episode for operator review.
+- Lead autopilot dry runs no longer start workers, append repeat wakes, or write escalation records. Passed stories count as closed and canonical story-ledger lane objects are accepted.
+- Autopilot checks status paths against the lead company, scopes escalation deduplication to each lead, includes carried stories in stale-worker checks, and recovers locks left by reused PIDs.
+- The lead autopilot adds prompts for available grant slots, flat KPI reports, stale blockers, completed projects, stale worker ledgers, and stories without live lanes, with escalation after two unanswered wakes.
+
+- Preserve empty directory paths and modes in recorded corpus cases. The recorder rejects tree entries the case format cannot replay, and CI checks committed snapshots after a clean Git archive extraction.
+- Cross-Outpost resume and hire-grant dispatch verify the senior from the
+  senior's owning Outpost before signing the caller's grant context.
+
+### Added
+
+- Add `hq lanes ask --priority P0|P1|P2` and show question urgency in the queue; warn when omitted during the compatibility release.
+
+### Fixed
+
+- CI-only: keep the same-binary Node control case measured without applying performance regression thresholds.
+- Fix npm global self-updates, which have failed with MODULE_NOT_FOUND since 5.290.0. The update moved the hq-cli package aside and then started its installer through a supervisor script inside that package. It now runs the installer through a copy of the supervisor outside the package.
+
 ## [5.292.0] — 2026-09-30
 - Add native `hq core jobs reconcile` behind `core-native-jobs`, retaining the bundled shell rollback and scheduled-job helpers.
 - Behind the default-off `cli.staged-self-update` flag, an npm global self-update installs the new version beside the running package, checks that it answers `--version`, then swaps it in with two renames. The running `hq` stays on disk for the whole install, so services the daemon starts during an update no longer fail with "hq: command not found" or MODULE_NOT_FOUND. pnpm, Bun, Windows and linked installs keep the in-place update.

package/dist/command-catalog.generated.d.ts

@@ -8655,6 +8655,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--recommended <text>";
             readonly description: "Recommended option";
+        }, {
+            readonly flags: "--priority <P0|P1|P2>";
+            readonly description: "Urgency: P0 blocks now, P1 needed today, P2 can wait";
         }, {
             readonly flags: "--json";
             readonly description: "JSON on stdout (always)";

package/dist/command-catalog.generated.js

@@ -11171,6 +11171,10 @@ export const COMMAND_CATALOG = [
                         "flags": "--recommended <text>",
                         "description": "Recommended option"
                     },
+                    {
+                        "flags": "--priority <P0|P1|P2>",
+                        "description": "Urgency: P0 blocks now, P1 needed today, P2 can wait"
+                    },
                     {
                         "flags": "--json",
                         "description": "JSON on stdout (always)"

package/dist/commands/lanes-move.js

@@ -19,6 +19,38 @@ export function createLaneMoveHandlers(deps) {
             lane.last_host_report_at === undefined &&
             lane.pending_resume === undefined;
     }
+    function sameHost(a, b) {
+        return a.kind === b.kind && a.id === b.id;
+    }
+    function reportAlreadyOnTarget(lane) {
+        printJson({
+            ok: true,
+            action: "move",
+            lane_id: lane.lane_id,
+            state: lane.state,
+            host: lane.host,
+            account: lane.account ?? null,
+            moved: false,
+            reason: "already_on_target",
+            lane,
+        });
+    }
+    async function reportAlreadyOnTargetIfCurrent(hqRoot, laneId, provider, target, callerHost, runtimeHost, ctx) {
+        const current = await withLaneAdmissionLock(hqRoot, provider, async () => {
+            const lane = readLane(hqRoot, laneId);
+            if (!laneCanMoveBeforeStart(lane)) {
+                throw new LanesError(lane.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${lane.state}`, { lane_id: laneId, state: lane.state });
+            }
+            return sameHost(lane.host, target) ||
+                (laneRunsHere(lane, runtimeHost) && sameHost(callerHost, target))
+                ? lane
+                : undefined;
+        }, ctx.sleep);
+        if (current === undefined)
+            return false;
+        reportAlreadyOnTarget(current);
+        return true;
+    }
     function readLaneTimeout(hqRoot, laneId) {
         const raw = readJsonFile(timeoutPath(hqRoot, laneId));
         if (raw === null)
@@ -51,6 +83,22 @@ export function createLaneMoveHandlers(deps) {
             throw new LanesError(source.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${source.state}`, { lane_id: laneId, state: source.state });
         }
         const sourceHost = source.host;
+        const runtimeHost = reconcileHostFromCtx(ctx);
+        const runningHere = laneRunsHere(source, runtimeHost);
+        const callerHost = runtimeHost.outpostId
+            ? { kind: "outpost", id: runtimeHost.outpostId }
+            : { kind: "local", id: runtimeHost.hostname };
+        const explicitTarget = policy.kind === "local"
+            ? callerHost
+            : policy.kind === "outpost"
+                ? { kind: "outpost", id: policy.id }
+                : undefined;
+        if (explicitTarget !== undefined &&
+            (sameHost(sourceHost, explicitTarget) ||
+                (runningHere && sameHost(callerHost, explicitTarget)))) {
+            if (await reportAlreadyOnTargetIfCurrent(hqRoot, laneId, source.provider, explicitTarget, callerHost, runtimeHost, ctx))
+                return;
+        }
         const config = loadLanesConfig(hqRoot);
         const capacity = await loadHostCapacitySnapshots(ctx, hqRoot, config);
         let targetSnapshots = capacity.snapshots.filter((snapshot) => snapshot.host.kind !== sourceHost.kind || snapshot.host.id !== sourceHost.id);
@@ -69,8 +117,13 @@ export function createLaneMoveHandlers(deps) {
             ...(source.account !== undefined ? { account: source.account } : {}),
             ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
         });
+        if (sameHost(sourceHost, choice.host) ||
+            (runningHere && sameHost(callerHost, choice.host))) {
+            if (await reportAlreadyOnTargetIfCurrent(hqRoot, laneId, source.provider, choice.host, callerHost, runtimeHost, ctx))
+                return;
+        }
         let moved;
-        if (laneRunsHere(source, reconcileHostFromCtx(ctx))) {
+        if (runningHere) {
             moved = await commitLaneMove(ctx, laneId, choice.host, choice.account, placementEnabled);
         }
         else if (source.host.kind === "outpost") {

package/dist/commands/lanes-questions.js

@@ -475,6 +475,8 @@ export function createLaneQuestionsHandlers(deps) {
                 .map((q) => {
                 const row = {
                     ...q,
+                    priority: q.priority ?? null,
+                    priority_display: q.priority ?? "-",
                     audience: resolveAudience(hqRoot, q, ctx),
                     ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
                 };
@@ -503,6 +505,8 @@ export function createLaneQuestionsHandlers(deps) {
             })
                 .map(({ question: q, host, audience }) => ({
                 ...q,
+                priority: q.priority ?? null,
+                priority_display: q.priority ?? "-",
                 host,
                 audience,
                 ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),

package/dist/commands/lanes.d.ts

@@ -114,6 +114,8 @@ export declare function parseQuestionBody(raw: unknown): QuestionBody | null;
  */
 export declare const ASK_BACKOFF_MS: readonly [5000, 15000];
 export declare const ASK_ATTEMPTS: number;
+/** Flip to true in the next release to make --priority mandatory. */
+export declare const ASK_PRIORITY_REQUIRED = false;
 export declare function casUpdateQuestion(hqRoot: string, questionId: string, updater: (current: QuestionRecord) => QuestionRecord): QuestionRecord;
 export declare function casUpdateLane(hqRoot: string, laneId: string, updater: (current: LaneRecord) => LaneRecord): LaneRecord;
 /**

package/dist/commands/lanes.js

@@ -490,6 +490,67 @@ function mergeOwnerLaneHierarchy(supplied, ownerLanes) {
         byId.set(lane.lane_id, lane);
     return [...byId.values()];
 }
+function hierarchyWithRemoteSenior(hierarchy, remoteSenior) {
+    return [
+        ...hierarchy.filter((lane) => lane.lane_id !== remoteSenior.lane_id),
+        remoteSenior,
+    ];
+}
+async function readRemoteHireGrantSenior(ctx, hqRoot, seniorLaneId) {
+    if (!listLaneIds(hqRoot).includes(seniorLaneId))
+        return undefined;
+    const mirror = readLane(hqRoot, seniorLaneId);
+    if (mirror.host.kind !== "outpost" ||
+        laneRunsHere(mirror, reconcileHostFromCtx(ctx))) {
+        return undefined;
+    }
+    const outpostId = mirror.host.id;
+    const unavailable = (reason) => new LanesError("hire_grant_senior_unavailable", `Cannot verify senior lane ${seniorLaneId} from owning Outpost ${outpostId}; refusing hire-grant admission (${reason})`, { senior_lane_id: seniorLaneId, outpost_id: outpostId, reason });
+    let ownerRecords;
+    try {
+        ownerRecords = await readOutpostLaneRecords(ctx, outpostId, {
+            laneIds: [seniorLaneId],
+            snapshot: true,
+            strictSnapshot: true,
+        }, {}, { bypassCache: true });
+    }
+    catch (error) {
+        throw unavailable(isLanesError(error) ? error.error : "outpost_lane_list_unavailable");
+    }
+    const matches = ownerRecords.filter((lane) => lane.lane_id === seniorLaneId);
+    const owner = matches[0];
+    const ownerIsHostedByOutpost = owner !== undefined && ((owner.host.kind === "outpost" && owner.host.id === outpostId) ||
+        (owner.host.kind === "local" && owner.host.id.trim() !== ""));
+    if (matches.length !== 1 || owner === undefined || !ownerIsHostedByOutpost) {
+        throw unavailable(matches.length === 0
+            ? "owner_did_not_return_senior"
+            : matches.length > 1
+                ? "owner_returned_duplicate_seniors"
+                : "owner_senior_identity_mismatch");
+    }
+    try {
+        const mirrorCompany = resolveLaneCompany(hqRoot, mirror).company;
+        const ownerCompany = resolveLaneCompany(hqRoot, owner).company;
+        if ((ownerCompany?.uid ?? null) !== (mirrorCompany?.uid ?? null) ||
+            (ownerCompany?.slug ?? null) !== (mirrorCompany?.slug ?? null)) {
+            throw unavailable("owner_company_did_not_match_mirror");
+        }
+    }
+    catch (error) {
+        if (isLanesError(error) && error.error === "hire_grant_senior_unavailable")
+            throw error;
+        throw unavailable("owner_company_identity_unavailable");
+    }
+    return owner;
+}
+async function hierarchyWithVerifiedRemoteSenior(ctx, hqRoot, lane, hierarchy) {
+    if (lane.senior.kind !== "lane" || !lane.senior.id)
+        return [...hierarchy];
+    const remoteSenior = await readRemoteHireGrantSenior(ctx, hqRoot, lane.senior.id);
+    return remoteSenior === undefined
+        ? [...hierarchy]
+        : mergeOwnerLaneRecords(hierarchy, [remoteSenior]);
+}
 function mergeOwnerLaneRecords(supplied, ownerLanes) {
     const byId = new Map(supplied.map((lane) => [lane.lane_id, lane]));
     for (const lane of ownerLanes)
@@ -911,8 +972,18 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
         throw new LanesError("hire_grant_context_required", `Resume of Outpost lane ${lane.lane_id} requires the primary senior's hire-grant context`, { lane_id: lane.lane_id, senior_lane_id: lane.senior.id });
     }
     await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), new Set([lane.senior.id]));
+    const remoteSenior = grantContext === undefined
+        ? await readRemoteHireGrantSenior(ctx, hqRoot, lane.senior.id)
+        : undefined;
+    const suppliedHierarchy = grantContext?.hierarchy ?? (remoteSenior === undefined
+        ? undefined
+        : hierarchyWithRemoteSenior(loadAllLanes(hqRoot), remoteSenior));
     return withHireGrantAdmission(hqRoot, lane.senior.id, (snapshot) => {
         const current = readLane(hqRoot, lane.lane_id);
+        if (remoteSenior !== undefined &&
+            (current.senior.kind !== "lane" || current.senior.id !== remoteSenior.lane_id)) {
+            throw new LanesError("hire_grant_senior_changed", `Lane ${current.lane_id}'s senior changed while its owning Outpost was being checked`, { lane_id: current.lane_id, expected_senior_lane_id: remoteSenior.lane_id, current_senior: current.senior });
+        }
         if (grantContext !== undefined &&
             !sameHireGrantSenior(current.senior, grantContext.expected_senior)) {
             throw new LanesError("hire_grant_senior_changed", `Lane ${current.lane_id}'s senior changed before the Outpost resumed it`, {
@@ -929,7 +1000,7 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
         if (refusal !== null)
             throw refusal;
         return fn();
-    }, grantContext?.hierarchy);
+    }, suppliedHierarchy, remoteSenior === undefined ? undefined : new Set([remoteSenior.lane_id]));
 }
 const CAPACITY_PROBE_TIMEOUT_MS = 15_000;
 const MAX_PLACEMENT_OUTPOSTS = 16;
@@ -1205,8 +1276,11 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
     }
     return lanes;
 }
-async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}, dispatchOptions = {}) {
+async function readOutpostLaneRecords(ctx, outpostId, requestedQuery = {}, dispatchOptions = {}, options = {}) {
     const query = normalizedLaneListQuery(requestedQuery);
+    if (options.bypassCache === true) {
+        return readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions);
+    }
     let invocationMemo = outpostLaneListMemo.get(ctx);
     if (!invocationMemo) {
         invocationMemo = new OutpostSnapshotInvocationMemo();
@@ -2144,6 +2218,10 @@ function assertKnownOutpost(requested, known) {
  */
 export const ASK_BACKOFF_MS = [5_000, 15_000];
 export const ASK_ATTEMPTS = ASK_BACKOFF_MS.length + 1;
+/** Flip to true in the next release to make --priority mandatory. */
+export const ASK_PRIORITY_REQUIRED = false;
+const ASK_PRIORITY_WARNING = "--priority will be required in the next release.";
+const QUESTION_PRIORITIES = ["P0", "P1", "P2"];
 function withCasRetry(fn, attempts = 5) {
     let last;
     for (let i = 0; i < attempts; i += 1) {
@@ -3980,19 +4058,21 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
     let grantContext;
     let grantHierarchy;
     if (action === "grant") {
-        const hierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneRecords(ctx, outpostId, {
+        const ownerHierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneRecords(ctx, outpostId, {
             hierarchy: [lane.lane_id],
             snapshot: true,
         }));
+        const hierarchy = await hierarchyWithVerifiedRemoteSenior(ctx, ctx.hqRoot(), lane, ownerHierarchy);
         grantHierarchy = hierarchy;
         grantContext = createOutpostHireGrantContext(lane, hierarchy);
     }
     else if ((action === "resume" && lane.senior.kind === "lane") ||
         (action === "message" && (lane.senior.kind === "lane" || lane.senior.kind === "session"))) {
-        const hierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneRecords(ctx, outpostId, {
+        const ownerHierarchy = mergeOwnerLaneRecords(loadAllLanes(ctx.hqRoot()), await readOutpostLaneRecords(ctx, outpostId, {
             hierarchy: [lane.lane_id],
             snapshot: true,
         }));
+        const hierarchy = await hierarchyWithVerifiedRemoteSenior(ctx, ctx.hqRoot(), lane, ownerHierarchy);
         grantContext = createOutpostHireGrantContext(lane, hierarchy, action === "message" ? options.supersededMessageCallerId : undefined, action === "message" ? options.supersededMessageSessionId : undefined);
     }
     let dispatched;
@@ -5254,6 +5334,10 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
         }
         await refreshRemoteLaneMirrors(ctx, hqRoot, loadAllLanes(hqRoot), parentLaneIds);
     }
+    const remoteSenior = authorization === "senior" &&
+        initial.senior.kind === "lane" && initial.senior.id
+        ? await readRemoteHireGrantSenior(ctx, hqRoot, initial.senior.id)
+        : undefined;
     const updated = ctx.withGrantHireLocks(hqRoot, lockedLaneIds, () => {
         const current = readLane(hqRoot, laneId);
         const currentCallerAuthorization = authorization === "senior"
@@ -5270,11 +5354,18 @@ async function applyHireGrant(ctx, laneId, hireGrant, authorization, grantContex
             (!grantContext || !sameHireGrantSenior(current.senior, grantContext.expected_senior))) {
             throw new LanesError("hire_grant_senior_changed", `Lane ${laneId}'s senior changed before the Outpost applied the grant update`, { lane_id: laneId, current_senior: current.senior });
         }
-        const hierarchy = grantContext
+        if (remoteSenior !== undefined &&
+            (current.senior.kind !== "lane" || current.senior.id !== remoteSenior.lane_id)) {
+            throw new LanesError("hire_grant_senior_changed", `Lane ${current.lane_id}'s senior changed while its owning Outpost was being checked`, { lane_id: current.lane_id, expected_senior_lane_id: remoteSenior.lane_id, current_senior: current.senior });
+        }
+        const currentHierarchy = grantContext
             ? authorization === "ssm-owner-dispatch"
                 ? mergeOwnerLaneHierarchy(grantContext.hierarchy, loadAllLanes(hqRoot))
                 : grantContext.hierarchy
             : loadAllLanes(hqRoot);
+        const hierarchy = remoteSenior === undefined
+            ? currentHierarchy
+            : hierarchyWithRemoteSenior(currentHierarchy, remoteSenior);
         if (current.senior.kind === "lane") {
             if (!current.senior.id) {
                 throw new LanesError("hire_grant_senior_invalid", `Lane ${laneId} has a lane senior without an id`, {
@@ -7443,7 +7534,23 @@ export function interruptNotResumableWarning(laneId) {
     return `hq lanes: warning: lane ${laneId} was interrupted before its provider reported a session id, ` +
         `so hq lanes resume cannot continue it. Start a new lane for the remaining work.\n`;
 }
+function parseQuestionPriority(value) {
+    if (value === undefined) {
+        if (ASK_PRIORITY_REQUIRED) {
+            throw new LanesError("ask_priority_required", "--priority is required; choose P0, P1, or P2", {
+                allowed: [...QUESTION_PRIORITIES],
+            });
+        }
+        return undefined;
+    }
+    const normalized = value.toUpperCase();
+    if (!QUESTION_PRIORITIES.includes(normalized)) {
+        throw new LanesError("ask_priority_invalid", `Invalid --priority ${JSON.stringify(value)}. Allowed values: P0, P1, P2`, { allowed: [...QUESTION_PRIORITIES], value });
+    }
+    return normalized;
+}
 async function runAsk(ctx, opts) {
+    const priority = parseQuestionPriority(opts.priority);
     const hqRoot = ctx.hqRoot();
     const laneId = ctx.env.HQ_LANE_ID?.trim();
     if (!laneId) {
@@ -7482,6 +7589,7 @@ async function runAsk(ctx, opts) {
                 at,
                 activeCompany: questionCompany,
                 questionId,
+                priority,
             });
             questionId = withBody.question_id;
             await emitLaneMeshEvent(ctx, lane.mesh_company ?? lane.company, lane.thread_id, "lane_question", {
@@ -7496,12 +7604,16 @@ async function runAsk(ctx, opts) {
                     question_id: withBody.question_id,
                 });
             }
+            if (priority === undefined) {
+                process.stderr.write(`hq lanes ask: warning: ${ASK_PRIORITY_WARNING}\n`);
+            }
             printJson({
                 ok: true,
                 action: "ask",
                 question: withBody,
                 lane_id: lane.lane_id,
                 lane_state: lane.state,
+                ...(priority === undefined ? { warnings: [ASK_PRIORITY_WARNING] } : {}),
             });
             return;
         }
@@ -8493,6 +8605,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--context <text>", "Context for the audience")
         .option("--option <text>", "Answer choice (repeatable)", collectRepeatable)
         .option("--recommended <text>", "Recommended option")
+        .option("--priority <P0|P1|P2>", "Urgency: P0 blocks now, P1 needed today, P2 can wait")
+        .addHelpText("after", "\nThe audience may take up to 24 hours to answer; keep working meanwhile.\n")
         .action(wrap(async (opts) => {
         await runAsk(ctx, opts);
     }));

package/dist/lib/core-utils/sentry-report.js

@@ -677,13 +677,13 @@ function scrubbedSentryEnvelope(event, overrides, additionalTags = {}) {
         ...sentryEnvelope(event, overrides, additionalTags),
     }, {});
 }
-/** Keep all hook-timeout conditions together by script while retaining tags for triage. */
+/** Group hook-timeout conditions by normalized kind while retaining triage tags. */
 function hookTimeoutExceededOverrides(event) {
     if (!isHookTimeoutEvent(event))
         return undefined;
     return {
         level: "warning",
-        fingerprint: ["hook-timeout", hookScript(event.metadata)],
+        fingerprint: ["hook-timeout", hookTimeoutKind(event)],
     };
 }
 /**

package/dist/lib/daemon/run.d.ts

@@ -62,5 +62,16 @@ export declare function rotateLogs(logsDir: string, maxBytes?: number): number;
  * an on-failure unit down. The daemon's updater handles CLI updates.
  */
 export declare function unitProcessEnv(base: NodeJS.ProcessEnv, unit: UnitPlan): NodeJS.ProcessEnv;
+/**
+ * A systemd system unit starts the daemon as the login user without the
+ * variables a login session sets, so `systemctl --user` from its services
+ * cannot find the user bus ("Failed to connect to bus: No medium found").
+ * Point them at the user's runtime dir when it exists and nothing set one.
+ */
+export declare function withUserRuntimeDir(env: NodeJS.ProcessEnv, host: {
+    platform: NodeJS.Platform;
+    uid: number;
+    exists: (dir: string) => boolean;
+}): NodeJS.ProcessEnv;
 export declare function runDaemon(opts: RunDaemonOptions): Promise<number>;
 //# sourceMappingURL=run.d.ts.map

package/dist/lib/daemon/run.js

@@ -233,8 +233,24 @@ function isFifo(file) {
         return false;
     }
 }
+/**
+ * A systemd system unit starts the daemon as the login user without the
+ * variables a login session sets, so `systemctl --user` from its services
+ * cannot find the user bus ("Failed to connect to bus: No medium found").
+ * Point them at the user's runtime dir when it exists and nothing set one.
+ */
+export function withUserRuntimeDir(env, host) {
+    if (host.platform !== "linux" || host.uid === 0 || env.XDG_RUNTIME_DIR)
+        return env;
+    const dir = `/run/user/${host.uid}`;
+    return host.exists(dir) ? { ...env, XDG_RUNTIME_DIR: dir } : env;
+}
 export async function runDaemon(opts) {
-    const env = opts.env ?? process.env;
+    const env = withUserRuntimeDir(opts.env ?? process.env, {
+        platform: process.platform,
+        uid: process.getuid?.() ?? -1,
+        exists: fs.existsSync,
+    });
     const home = opts.home ?? os.homedir();
     const platform = process.platform;
     const paths = daemonPaths(home, env);

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

@@ -12,8 +12,9 @@ export interface RegisteredLead {
     status: string;
     prd: string;
 }
+export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane";
 export interface AutopilotWake {
-    condition: "review_finished_worker" | "fill_grant";
+    condition: AutopilotCondition;
     lead_lane: string;
     story_id: string;
     worker_lane?: string;
@@ -30,6 +31,14 @@ export interface AutopilotPassResult {
         story_id: string;
         worker_lane: string;
     }>;
+    escalated: Array<{
+        team: string;
+        lead_lane: string;
+        condition: AutopilotCondition;
+        story_id: string;
+        at: string;
+        fingerprint: string;
+    }>;
     skipped: Array<{
         lead_lane: string;
         reason: string;
@@ -38,15 +47,18 @@ export interface AutopilotPassResult {
 interface ProjectStory {
     id: string;
     status: string;
+    passes?: boolean;
     briefPath?: string;
     laneIds?: string[];
     updatedAt?: string;
+    externalBlocker?: string;
 }
 export declare function planLeadAutopilotWakes(input: {
     lead: LaneRecord;
     children: readonly LaneRecord[];
     stories: readonly ProjectStory[];
     now: Date;
+    managerStatus?: Record<string, unknown>;
     keepAliveResumed?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {