@indigoai-us/hq-cli 5.253.0 → 5.255.0

package/dist/commands/lanes.js

@@ -15,6 +15,7 @@ import { createLaneAccountsHandlers } from "./lanes-accounts.js";
 import { createLaneMessageHandlers } from "./lanes-message.js";
 import { createLaneQuestionsHandlers } from "./lanes-questions.js";
 import { createLaneResumeHandlers } from "./lanes-resume.js";
+import { createLaneWatchHandlers } from "./lanes-watch.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import { registerOutpostPrunerCommand } from "./outpost-pruner.js";
 import { registerLaneChecksCommand } from "./lanes-checks.js";
@@ -45,18 +46,18 @@ import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
-import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
-import { LANE_WAIT_INVALID_INPUT_EXIT_CODE, LANE_WAIT_TIMEOUT_EXIT_CODE, runLaneWait, } from "../lib/lanes/wait.js";
 import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
+import { managerStatusGateEnabledForLane, resolveManagerStatusGateForLane, } from "../lib/lanes/manager-status-gate.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
 import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
@@ -1195,180 +1196,6 @@ function assertPlacementEnabled(ctx) {
 function loadAllQuestions(hqRoot) {
     return listQuestionIds(hqRoot).map((id) => readQuestion(hqRoot, id));
 }
-const MONITOR_ACTIVE_LANE_STATES = new Set([
-    "running",
-    "queued",
-    "awaiting_input",
-    "blocked",
-]);
-function resolveMonitorEngine(requested, env) {
-    const value = requested?.trim().toLowerCase() ||
-        env.HQ_CONDUCT_ENGINE?.trim().toLowerCase() ||
-        "claude";
-    if (!MONITOR_ENGINES.includes(value)) {
-        throw new LanesError("monitor_invalid_engine", `Unknown monitor-check engine ${JSON.stringify(value)}. Accepted: ${MONITOR_ENGINES.join(", ")}`, { accepted: [...MONITOR_ENGINES], value });
-    }
-    return value;
-}
-async function runWatch(ctx, laneIds, opts) {
-    const rawInterval = opts.intervalMs === undefined ? undefined : Number(opts.intervalMs);
-    const hqRoot = ctx.hqRoot();
-    await runLaneWatch(hqRoot, laneIds, {
-        intervalMs: rawInterval,
-        sleep: ctx.sleep,
-        keepAliveEnabled: (lane) => readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
-            company: lane.company,
-            env: ctx.env,
-        }),
-        readAccountStatuses: async (lanes) => {
-            if (lanes.length === 0)
-                return [];
-            const config = loadLanesConfig(hqRoot);
-            const currentHost = laneHostFromCtx(ctx);
-            const currentHostname = ctx.hostname().trim();
-            const isCurrentHost = (host) => (host.kind === currentHost.kind && host.id === currentHost.id) ||
-                (host.kind === "local" && host.id === currentHostname);
-            const remoteOutpostIds = [...new Set(lanes
-                    .filter((lane) => lane.host.kind === "outpost" && !isCurrentHost(lane.host))
-                    .map((lane) => lane.host.id))];
-            const remoteOutposts = await Promise.all(remoteOutpostIds.map(async (id) => [id, await readOutpostCapacity(ctx, id)]));
-            const outpostSnapshots = new Map(remoteOutposts);
-            const remoteLocalLanes = lanes.filter((lane) => lane.host.kind === "local" && !isCurrentHost(lane.host));
-            const remoteLocalHosts = remoteLocalLanes.length > 0
-                ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
-                : undefined;
-            const localStatusCache = new Map();
-            return lanes.map((lane) => {
-                if (config.providers[lane.provider].accounts[lane.account] === undefined) {
-                    throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
-                }
-                let loggedIn;
-                if (isCurrentHost(lane.host)) {
-                    const key = JSON.stringify([lane.provider, lane.account, currentHost.kind, currentHost.id]);
-                    if (!localStatusCache.has(key)) {
-                        localStatusCache.set(key, accountStatus(lane.provider, lane.account, config, {
-                            existsSync: ctx.existsSync,
-                            probe: ctx.probeProvider,
-                            env: ctx.env,
-                            hostname: currentHostname,
-                        }).logged_in);
-                    }
-                    loggedIn = localStatusCache.get(key);
-                }
-                else if (lane.host.kind === "outpost") {
-                    loggedIn = outpostSnapshots.get(lane.host.id)?.providers[lane.provider].accounts[lane.account]?.logged_in;
-                }
-                else {
-                    const snapshot = remoteLocalHosts?.snapshots.find((candidate) => candidate.capacity.host.kind === lane.host.kind &&
-                        candidate.capacity.host.id === lane.host.id);
-                    if (!snapshot) {
-                        const gap = remoteLocalHosts?.unavailableHosts.find((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
-                        throw new LanesError("watch_account_host_unavailable", `Cannot check ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}${gap ? `: ${gap.reason}` : ""}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
-                    }
-                    loggedIn = snapshot.capacity.providers[lane.provider].accounts[lane.account]?.logged_in;
-                }
-                if (loggedIn === undefined) {
-                    throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
-                }
-                return {
-                    lane_id: lane.lane_id,
-                    provider: lane.provider,
-                    account: lane.account,
-                    host: lane.host,
-                    logged_in: loggedIn,
-                };
-            });
-        },
-        writeLine: (line) => console.log(opts.json ? JSON.stringify({ event: line }) : line),
-        writeAccountEvent: (event) => console.log(opts.json ? JSON.stringify(event) : `account_logged_out provider=${event.provider} account=${event.account} host=${event.host.kind}:${event.host.id} lane_ids=${event.lane_ids.join(",")}`),
-        writeError: (line) => process.stderr.write(`${line}\n`),
-    });
-    return 0;
-}
-function monitorCallsForLaneIds(laneIds) {
-    const calls = [];
-    for (let offset = 0; offset < laneIds.length; offset += MAX_WATCHED_LANES) {
-        const chunk = laneIds.slice(offset, offset + MAX_WATCHED_LANES);
-        calls.push({
-            command: `hq lanes watch ${chunk.join(" ")}`,
-            timeout_ms: MONITOR_MAX_TIMEOUT_MS,
-            persistent: true,
-        });
-    }
-    return calls;
-}
-async function runMonitorCheck(ctx, opts) {
-    if (opts.reminder) {
-        console.log(monitorReminderText());
-        return 0;
-    }
-    const sessionId = opts.session?.trim();
-    if (!sessionId) {
-        throw new LanesError("monitor_session_required", "hq lanes monitor-check requires --session <id> unless --reminder is used");
-    }
-    const engine = resolveMonitorEngine(opts.engine, ctx.env);
-    const activeLanes = loadAllLanes(ctx.hqRoot()).filter((lane) => lane.senior.kind === "session" &&
-        lane.senior.id === sessionId &&
-        MONITOR_ACTIVE_LANE_STATES.has(lane.state));
-    if (engine !== "claude") {
-        if (opts.json) {
-            printJson({
-                ok: true,
-                action: "monitor-check",
-                session_id: sessionId,
-                engine,
-                active_lane_ids: activeLanes.map((lane) => lane.lane_id),
-                covered_lane_ids: [],
-                uncovered_lane_ids: [],
-                skipped: "engine_has_no_claude_monitor",
-            });
-        }
-        return 0;
-    }
-    if (activeLanes.length === 0) {
-        if (opts.json) {
-            printJson({
-                ok: true,
-                action: "monitor-check",
-                session_id: sessionId,
-                engine,
-                active_lane_ids: [],
-                covered_lane_ids: [],
-                uncovered_lane_ids: [],
-            });
-        }
-        return 0;
-    }
-    const evidence = await ctx.monitorEvidence(sessionId);
-    if (evidence.sessionId !== sessionId) {
-        throw new LanesError("monitor_evidence_session_mismatch", `Monitor evidence was for ${JSON.stringify(evidence.sessionId)}, expected ${JSON.stringify(sessionId)}`);
-    }
-    const covered = coveredLaneIds(evidence, ctx.now());
-    const activeIds = activeLanes.map((lane) => lane.lane_id);
-    const uncovered = activeIds.filter((laneId) => !covered.has(laneId));
-    const monitorCalls = monitorCallsForLaneIds(uncovered);
-    if (opts.json) {
-        printJson({
-            ok: uncovered.length === 0,
-            action: "monitor-check",
-            session_id: sessionId,
-            engine,
-            active_lane_ids: activeIds,
-            covered_lane_ids: activeIds.filter((laneId) => covered.has(laneId)),
-            uncovered_lane_ids: uncovered,
-            monitor_call: monitorCalls.length === 1 ? monitorCalls[0] : null,
-            monitor_calls: monitorCalls,
-        });
-    }
-    else if (uncovered.length > 0) {
-        for (const laneId of uncovered)
-            console.log(`uncovered lane: ${laneId}`);
-        for (const monitorCall of monitorCalls) {
-            console.log(`Monitor(command=${JSON.stringify(monitorCall.command)}, timeout_ms=${monitorCall.timeout_ms}, persistent=true)`);
-        }
-    }
-    return uncovered.length > 0 ? MONITOR_UNCOVERED_EXIT_CODE : 0;
-}
 function sessionMetaPath(hqRoot, sessionId) {
     return path.join(hqRoot, "workspace", "sessions", sessionId, "meta.yaml");
 }
@@ -1857,37 +1684,6 @@ function assertKnownOutpost(requested, known) {
  */
 export const ASK_BACKOFF_MS = [5_000, 15_000];
 export const ASK_ATTEMPTS = ASK_BACKOFF_MS.length + 1;
-function laneWaitHumanLine(result) {
-    const details = Object.entries(result.change)
-        .filter(([key]) => key !== "type")
-        .map(([key, value]) => `${key}=${String(value)}`)
-        .join(" ");
-    return `lane=${result.lane_id} change=${result.change.type}${details ? ` ${details}` : ""} at=${result.at}`;
-}
-async function runWait(ctx, opts) {
-    const timeoutSeconds = opts.timeout === undefined ? Number.NaN : Number(opts.timeout);
-    try {
-        const result = await runLaneWait(ctx.hqRoot(), opts.any ?? [], opts.for ?? [], timeoutSeconds * 1000, { now: ctx.now, sleep: ctx.sleep });
-        if (result) {
-            console.log(opts.json ? JSON.stringify(result) : laneWaitHumanLine(result));
-            return 0;
-        }
-        console.log(opts.json
-            ? JSON.stringify({ ok: false, error: "wait_timeout" })
-            : "wait_timeout");
-        return LANE_WAIT_TIMEOUT_EXIT_CODE;
-    }
-    catch (err) {
-        if (!isLanesError(err) || err.error !== "wait_invalid_input")
-            throw err;
-        const output = { ok: false, error: err.error, message: err.message };
-        if (opts.json)
-            console.log(JSON.stringify(output));
-        else
-            process.stderr.write(`${err.message}\n`);
-        return LANE_WAIT_INVALID_INPUT_EXIT_CODE;
-    }
-}
 function withCasRetry(fn, attempts = 5) {
     let last;
     for (let i = 0; i < attempts; i += 1) {
@@ -3072,6 +2868,7 @@ async function runCreate(ctx, opts) {
     if (admission.action === "start") {
         started = spawnLaneWorker(hqRoot, lane, {
             env: ctx.env,
+            managerStatusGateEnabled: await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env }),
             modelDeps: {
                 readFileSync: ctx.readFileSync,
                 probe: ctx.probeProvider,
@@ -4043,6 +3840,7 @@ async function runPickup(ctx, opts) {
         try {
             return spawnLaneWorker(hqRoot, current, {
                 env: ctx.env,
+                managerStatusGateEnabled: await managerStatusGateEnabledForLane(hqRoot, current, { env: ctx.env }),
                 modelDeps: {
                     readFileSync: ctx.readFileSync,
                     probe: ctx.probeProvider,
@@ -4724,6 +4522,8 @@ async function runShow(ctx, laneId) {
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
     const keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
+    const managerStatusGate = await resolveManagerStatusGateForLane(hqRoot, storedLane, { env: ctx.env });
+    const managerStatusTarget = managerStatusGate.target;
     printJson({
         ok: true,
         action: "show",
@@ -4762,6 +4562,22 @@ async function runShow(ctx, laneId) {
             next_eligible_at: lane.keep_alive_next_eligible_at ?? null,
             exhausted_at: lane.keep_alive_exhausted_at ?? null,
         },
+        manager_status_gate: managerStatusGate.error !== undefined
+            ? {
+                status_path: null,
+                skipped: null,
+                consecutive_misses: storedLane.status_gate?.consecutive_misses ?? 0,
+                error: managerStatusGate.error,
+            }
+            : managerStatusTarget?.manager
+                ? {
+                    status_path: managerStatusTarget.statusPath ?? null,
+                    skipped: managerStatusTarget.skipped === "no_juniors_row"
+                        ? "no_declared_status_file"
+                        : null,
+                    consecutive_misses: storedLane.status_gate?.consecutive_misses ?? 0,
+                }
+                : null,
         last_message_at: lane.last_message_at ?? null,
         last_compaction: lane.last_compaction
             ? { ...lane.last_compaction, after: compactionAfterUsage(storedLane) }
@@ -5221,6 +5037,7 @@ async function runAdmit(ctx, laneId, opts) {
         }
         const started = spawnLaneWorker(hqRoot, lane, {
             env: ctx.env,
+            managerStatusGateEnabled: await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env }),
             modelDeps: {
                 readFileSync: ctx.readFileSync,
                 probe: ctx.probeProvider,
@@ -7028,6 +6845,14 @@ export function registerLanesCommand(parent, deps = {}) {
         validateResumeProfileModel,
         withResumeHireAdmission,
     });
+    const watchHandlerDeps = {
+        laneHostFromCtx,
+        loadAllLanes,
+        loadClaudeBalanceHostSnapshots,
+        printJson,
+        readOutpostCapacity,
+    };
+    const watchHandlers = createLaneWatchHandlers(watchHandlerDeps);
     const lanes = parent
         .command("lanes", { hidden: true })
         .description("Create, supervise, and steer worker lanes; routed decision queue");
@@ -7231,13 +7056,13 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--for <change-type>", "envelope | question | state", collectRepeatable, [])
         .option("--timeout <seconds>", "Positive timeout in seconds")
         .option("--json", "JSON output")
-        .action(wrapText(async (opts) => runWait(ctx, opts)));
+        .action(wrapText(async (opts) => watchHandlers.runWait(ctx, opts)));
     lanes
         .command("watch")
         .description("Watch lane state and question changes until all lanes are terminal")
         .argument("<lane-id...>", "Lane ids to watch")
         .option("--interval-ms <ms>", "Polling interval, bounded to 100ms–30s", "5000")
-        .action(wrapText(async (laneIds, opts) => runWatch(ctx, laneIds, opts)));
+        .action(wrapText(async (laneIds, opts) => watchHandlers.runWatch(ctx, laneIds, opts)));
     lanes
         .command("monitor-check")
         .description("Check that active Claude senior lanes have live Monitor watch tasks")
@@ -7245,7 +7070,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--engine <engine>", "claude | codex | grok; defaults to HQ_CONDUCT_ENGINE or claude")
         .option("--reminder", "Print the senior Monitor reminder text")
         .option("--json", "JSON on stdout")
-        .action(wrapText(async (opts) => runMonitorCheck(ctx, opts)));
+        .action(wrapText(async (opts) => watchHandlers.runMonitorCheck(ctx, opts)));
     lanes
         .command("show")
         .description("Show one lane")

package/dist/lib/db/remote-sql.d.ts

@@ -1,8 +1,8 @@
 /**
- * Remote SQL via secrets-exec style injection (US-010).
+ * Remote SQL helper with injected credentials and executor (US-010).
  *
  * Connection string never appears in argv, logs, or stdout.
- * Local remains default when --remote is absent (handled by command layer).
+ * The CLI command does not currently wire this helper to a remote executor.
  */
 export interface RemoteSqlOptions {
     company: string;

package/dist/lib/db/remote-sql.js

@@ -1,8 +1,8 @@
 /**
- * Remote SQL via secrets-exec style injection (US-010).
+ * Remote SQL helper with injected credentials and executor (US-010).
  *
  * Connection string never appears in argv, logs, or stdout.
- * Local remains default when --remote is absent (handled by command layer).
+ * The CLI command does not currently wire this helper to a remote executor.
  */
 function assertNoLeak(label, value) {
     const s = typeof value === "string" ? value : JSON.stringify(value);
@@ -23,7 +23,7 @@ export async function runRemoteSql(opts) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : "no remote binding";
-        throw new Error(`remote SQL unavailable: ${msg}. Run \`hq db provision --company ${opts.company}\` first.`);
+        throw new Error(`remote SQL unavailable: ${msg}`);
     }
     assertNoLeak("connection config", config);
     if (!opts.execute) {

package/dist/lib/lanes/checked-company-path.d.ts

@@ -0,0 +1,3 @@
+/** The shared HQ/company path validation used by lane tracker mappings. */
+export declare function checkCompanyPath(root: string, company: string, file: string, detailsPath: string): string;
+//# sourceMappingURL=checked-company-path.d.ts.map

package/dist/lib/lanes/checked-company-path.js

@@ -0,0 +1,39 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+function fail(error, message, details) {
+    throw new LanesError(error, message, details);
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+/** The shared HQ/company path validation used by lane tracker mappings. */
+export function checkCompanyPath(root, company, file, detailsPath) {
+    if (path.isAbsolute(file))
+        return fail("tracker_checks_mapping_invalid", "Mapped path must be relative to the HQ root", { path: detailsPath });
+    const absolute = path.resolve(root, file);
+    const rootReal = fs.realpathSync(root);
+    if (!isWithin(rootReal, absolute))
+        return fail("tracker_checks_mapping_invalid", "Mapped path escapes the HQ root", { path: detailsPath });
+    const relative = path.relative(rootReal, absolute).split(path.sep);
+    if (relative[0] === "companies" && relative[1] !== company) {
+        return fail("tracker_checks_mapping_invalid", "Mapped path crosses the active company boundary", { path: detailsPath });
+    }
+    try {
+        const real = fs.realpathSync(absolute);
+        if (!isWithin(rootReal, real))
+            return fail("tracker_checks_mapping_invalid", "Mapped path resolves outside the HQ root", { path: detailsPath });
+        const realRelative = path.relative(rootReal, real).split(path.sep);
+        if (realRelative[0] === "companies" && realRelative[1] !== company) {
+            return fail("tracker_checks_mapping_invalid", "Mapped path resolves into another company", { path: detailsPath });
+        }
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            return fail("tracker_checks_mapping_unreadable", `Mapped path could not be checked: ${err instanceof Error ? err.message : String(err)}`, { path: absolute });
+        }
+    }
+    return absolute;
+}
+//# sourceMappingURL=checked-company-path.js.map

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

@@ -1,4 +1,4 @@
-import type { LaneRecord, QuestionRecord } from "./types.js";
+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;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
@@ -7,6 +7,8 @@ export declare const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
 export declare const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS: number;
+/** 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_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"]>;

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

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { dropboxInboxHasMessages } from "./dropbox.js";
-import { listQuestionIds, readQuestion } from "./store.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;
 /** Missing or unreadable registry values retain the legacy supersession behavior. */
@@ -11,6 +11,61 @@ export const LANE_SUPERSESSION_LINEAGE_AWARE_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
 export const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS = 5 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS = 60 * 60 * 1000;
+/** Persist a manager status miss and queue its one bounded follow-up turn. */
+export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText) {
+    return retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
+        const gate = current.status_gate;
+        if (gate === undefined || gate.turn_id !== entry.turn_id)
+            return current;
+        const history = current.status_gate_history ?? [];
+        if (history.some((prior) => prior.event === "status_missed" && prior.turn_id === entry.turn_id)) {
+            return current;
+        }
+        const consecutiveMisses = gate.consecutive_misses + 1;
+        let resumeSkippedReason;
+        if (current.state === "blocked")
+            resumeSkippedReason = "blocked";
+        else if (current.state === "awaiting_input")
+            resumeSkippedReason = "open_question";
+        else if (consecutiveMisses > 1)
+            resumeSkippedReason = "miss_limit";
+        else if (!current.provider_session_id)
+            resumeSkippedReason = "no_provider_session";
+        const resumeQueued = resumeSkippedReason === undefined &&
+            (current.state === "done" || current.state === "interrupted" || current.state === "failed");
+        const missed = {
+            event: "status_missed",
+            ...entry,
+            ...(resumeQueued ? { resume_queued: true } : {}),
+            ...(resumeSkippedReason !== undefined ? { resume_skipped_reason: resumeSkippedReason } : {}),
+        };
+        const next = {
+            ...current,
+            status_gate: { ...gate, consecutive_misses: consecutiveMisses },
+            status_gate_history: appendCappedHistory(history, missed),
+        };
+        if (!resumeQueued || !current.provider_session_id)
+            return next;
+        const resumedFrom = current.state;
+        return {
+            ...next,
+            state: "queued",
+            queued_reason: undefined,
+            queued_at: entry.at,
+            admission_reserved_at: undefined,
+            terminal_reason: undefined,
+            terminal_details: undefined,
+            pending_resume: {
+                session_id: current.provider_session_id,
+                trigger: "resume",
+                resumed_from: resumedFrom,
+                text: resumeText,
+                compact: true,
+                at: entry.at,
+            },
+        };
+    });
+}
 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_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.";
 /**

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

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