@indigoai-us/hq-cli 5.293.0 → 5.295.0

package/dist/commands/daemon.js

@@ -86,9 +86,9 @@ async function loadDefaults(over) {
                 fs.writeFileSync(p, text, { mode: 0o644 });
             }),
         legacyUnits: over.legacyUnits ??
-            (() => findLegacyUnits({
+            ((dir) => findLegacyUnits({
                 platform,
-                home,
+                home: dir ?? home,
                 existsSync: fs.existsSync,
                 listDir: (dir) => fs.readdirSync(dir),
                 windowsTaskExists: (task) => run("schtasks.exe", ["/Query", "/TN", task]).status === 0,
@@ -246,11 +246,25 @@ async function runInstall(d, opts) {
     }
     d.out(`Installed and started: ${result.unitPath}`);
 }
-function migrateDeps(d, paths) {
+/** Root acting for a box's login user needs that user's uid to reach their systemd manager. */
+function loginUid(d, user) {
+    const r = d.run("id", ["-u", user]);
+    const uid = Number(r.stdout.trim());
+    if (r.status !== 0 || !Number.isInteger(uid) || uid < 0 || r.stdout.trim() === "") {
+        throw new DaemonCommandError(`Could not look up the uid of ${user}.`);
+    }
+    return uid;
+}
+/** Where the older units are: a box's login user's home when root runs this for them. */
+function legacyUnitsFor(d, host) {
+    return d.isRoot && host.runAsUser ? d.legacyUnits(d.userHome(host.runAsUser)) : d.legacyUnits();
+}
+function migrateDeps(d, paths, runAsUser) {
     return {
         run: d.run,
         uid: d.uid,
         isRoot: d.isRoot,
+        userUnitsOwner: d.isRoot && runAsUser ? { user: runAsUser, uid: loginUid(d, runAsUser) } : undefined,
         adoptedDir: path.join(paths.root, "adopted"),
         recordPath: path.join(paths.root, "adopted.json"),
         // Box system units: root-owned, outside the login user's daemon folder (which handOver chowns to that user).
@@ -268,7 +282,8 @@ function unrestoredUnits(d, migrate) {
 async function runUninstall(d, opts) {
     const host = currentHost(d);
     const { paths, detected } = host;
-    const migrate = migrateDeps(d, paths);
+    // Only a restore acts on the login user's units.
+    const migrate = migrateDeps(d, paths, opts.restoreLegacy ? host.runAsUser : undefined);
     const adopted = unrestoredUnits(d, migrate);
     if (opts.purge && !opts.restoreLegacy && adopted.length > 0) {
         throw new DaemonCommandError(`hq daemon took over ${adopted.map((u) => u.unitId).join(", ")}, and their original units are kept in ${migrate.adoptedDir}. ` +
@@ -547,13 +562,13 @@ async function runPinHqCloud(d, version, opts) {
     d.out("Run `hq daemon trigger updater`; wait for the hq-cloud update or current-version message in `hq daemon logs updater`, then restart `hq daemon restart sync`, `hq daemon restart heartbeat`, and `hq daemon restart session-host`.");
 }
 async function runMigrate(d, opts) {
-    const units = d.legacyUnits();
+    const host = currentHost(d);
+    const units = legacyUnitsFor(d, host);
     if (units.length === 0) {
         d.out("No older HQ background units found. Nothing to migrate.");
         return;
     }
     if (opts.apply) {
-        const host = currentHost(d);
         // Stopping the older units with nothing installed to replace them would
         // leave their services off.
         const installed = daemonUnitInstalled({
@@ -565,7 +580,7 @@ async function runMigrate(d, opts) {
         if (!installed) {
             throw new DaemonCommandError("hq daemon is not installed here yet. Run `hq daemon install` first, then `hq daemon migrate --apply`.");
         }
-        const result = adoptLegacyUnits(units, migrateDeps(d, host.paths));
+        const result = adoptLegacyUnits(units, migrateDeps(d, host.paths, host.runAsUser));
         handOver(d, host);
         for (const a of result.adopted)
             d.out(`Took over ${a.unitId} from ${describeLegacyUnit(a)}`);

package/dist/commands/doctor.js

@@ -33,9 +33,6 @@ import { PARITY_FAMILY_ID, PARITY_FAMILY_TITLE, runParityReplay, } from "../lib/
 import { applyFixes } from "../lib/doctor/fix/apply.js";
 import { renderDoctorFixJson } from "../lib/doctor/fix/json-output.js";
 import { clientHealthReasonCodesEnabled as isActiveCompanyClientHealthReasonCodesEnabled, clientHealthReasonCodesEnabledForCompany, } from "../lib/doctor/client-health-reason-codes-flag.js";
-import { CLIENT_HEALTH_SENTRY_MAX_INPUT_BYTES, CLIENT_HEALTH_SENTRY_NOT_HANDLED_EXIT_CODE, handleClientHealthSentryReport, } from "../lib/doctor/client-health-sentry.js";
-import { clientHealthSentryDirectEnabled, clientHealthSentryDirectEnabledForCompany, } from "../lib/doctor/client-health-sentry-flag.js";
-import { reportClientHealthEvents } from "../lib/core-utils/sentry-report.js";
 import { isCompanyJournalSlug } from "../lib/doctor/checks/sync-health.js";
 import { readCompaniesManifestMap } from "../lib/work-context/repo-remote.js";
 import * as readline from "node:readline";
@@ -244,26 +241,6 @@ function createClientHealthReasonCodeCompanyResolver(hqRoot) {
         });
     };
 }
-function createClientHealthSentryCompanyResolver(hqRoot) {
-    const companies = readCompaniesManifestMap(hqRoot);
-    return async (companySlug) => {
-        if (companySlug === null)
-            return clientHealthSentryDirectEnabled();
-        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(companySlug))
-            return false;
-        const manifestUid = companies?.[companySlug]?.cloud_uid;
-        const activeSlug = process.env.HQ_COMPANY_SLUG?.trim() || "";
-        const activeUid = process.env.HQ_COMPANY_UID?.trim() || "";
-        const companyUid = typeof manifestUid === "string" && manifestUid.trim()
-            ? manifestUid.trim()
-            : companySlug === activeSlug
-                ? activeUid
-                : "";
-        if (!/^cmp_[A-Za-z0-9]{3,128}$/.test(companyUid))
-            return false;
-        return clientHealthSentryDirectEnabledForCompany({ companyUid, companySlug });
-    };
-}
 /** Register the top-level `hq doctor` command so it appears in `hq --help`. */
 export function registerDoctorCommand(program) {
     program
@@ -279,9 +256,6 @@ export function registerDoctorCommand(program) {
         .option("--only <families>", "Run only these comma-separated check families (e.g. hooks). Unknown names are rejected; --json then records the scope.")
         .option("--fix", "Apply the allowlisted safe repairs (backs up first; read-only without this flag).")
         .addOption(new Option("--client-health-report", "Resolve the opt-in hq-flags gate used by the client-health report hook.").hideHelp())
-        .addOption(new Option("--client-health-sentry", "Send the opt-in client-health Sentry report from a doctor JSON document.").hideHelp())
-        .addOption(new Option("--json-input <file>", "Doctor JSON input for the client-health report.").hideHelp())
-        .addOption(new Option("--client-health-fix-outcome <outcome>", "Safe fix outcome label for the client-health report.").hideHelp())
         .option("--yes", "Skip the interactive --fix confirmation (non-interactive use).")
         .option("--force", "Let --fix run despite uncommitted changes under .claude/, .codex/, or .grok/.")
         .action(async (opts) => {
@@ -298,54 +272,6 @@ export function registerDoctorCommand(program) {
             process.exitCode = 1;
             return;
         }
-        if (opts.clientHealthSentry === true) {
-            const hqRoot = resolveHqRoot();
-            if (!hqRoot || !opts.jsonInput) {
-                process.stderr.write("hq doctor --client-health-sentry requires an HQ root and --json-input.\n");
-                process.exitCode = 1;
-                return;
-            }
-            try {
-                const workspacePath = path.join(hqRoot, "workspace");
-                const workspaceStat = fs.lstatSync(workspacePath);
-                if (!workspaceStat.isDirectory() || workspaceStat.isSymbolicLink()) {
-                    throw new Error("workspace is not a local directory");
-                }
-                const statePath = path.join(hqRoot, "workspace", ".hq-client-health");
-                const stateStat = fs.lstatSync(statePath);
-                if (!stateStat.isDirectory() || stateStat.isSymbolicLink()) {
-                    throw new Error("client-health state is not a local directory");
-                }
-                const stateRoot = fs.realpathSync(statePath);
-                const inputPath = fs.realpathSync(opts.jsonInput);
-                const relativeInput = path.relative(stateRoot, inputPath);
-                if (relativeInput === ".." || relativeInput.startsWith(`..${path.sep}`) || path.isAbsolute(relativeInput)) {
-                    throw new Error("input path is outside client-health state");
-                }
-                if (fs.statSync(inputPath).size > CLIENT_HEALTH_SENTRY_MAX_INPUT_BYTES) {
-                    throw new Error("input exceeds client-health size limit");
-                }
-                const result = await handleClientHealthSentryReport({
-                    hqRoot,
-                    doctorJson: fs.readFileSync(inputPath, "utf8"),
-                    fixOutcome: opts.clientHealthFixOutcome ?? "not_auto_fixable",
-                }, {
-                    resolveFlagForCompany: createClientHealthSentryCompanyResolver(hqRoot),
-                    sendEvents: async (events) => (await reportClientHealthEvents(events)).code === 0,
-                });
-                process.exitCode =
-                    result === "not_handled"
-                        ? CLIENT_HEALTH_SENTRY_NOT_HANDLED_EXIT_CODE
-                        : result === "send_failed"
-                            ? 1
-                            : 0;
-            }
-            catch {
-                process.stderr.write("hq doctor --client-health-sentry could not handle the report.\n");
-                process.exitCode = 1;
-            }
-            return;
-        }
         // `--fix` is the only write path. It resolves the tree, applies the
         // allowlisted repairs behind a backup + confirmation, and returns its own
         // exit code; the read-only report below never runs in this branch.

package/dist/commands/lanes-autopilot.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import { type ReconcileHost } from "../lib/lanes/reconcile.js";
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export interface LaneAutopilotReportDeps {
+    hqRoot: () => string;
+    now: () => Date;
+    currentHost: () => ReconcileHost;
+}
+export declare function registerLaneAutopilotReportCommand(parent: Command, deps: LaneAutopilotReportDeps, wrap: WrapHandler): void;
+export {};
+//# sourceMappingURL=lanes-autopilot.d.ts.map

package/dist/commands/lanes-autopilot.js

@@ -0,0 +1,336 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { laneRunsHere } from "../lib/lanes/reconcile.js";
+import { listLaneReviews } from "../lib/lanes/reviews.js";
+import { readAllLanes } from "../lib/lanes/store.js";
+import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
+import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
+import { buildAutopilotMetricsReport, } from "../lib/lanes/autopilot-metrics.js";
+import { LanesError } from "../lib/lanes/errors.js";
+const OPERATOR_NUDGE_DEFECTS_REL = path.join("workspace", "lane-briefs", "operator-nudge-defects.jsonl");
+const JUNIORS_REL = path.join("workspace", "lane-briefs", "juniors.json");
+const DROPBOX_NAME = "dropbox";
+const RESUME_SUFFIX = ".resume.jsonl";
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeReadText(root, file, missingOk = false) {
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (err) {
+        if (missingOk && err.code === "ENOENT")
+            return null;
+        return fail("autopilot_metrics_input_unreadable", `Could not inspect report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        return fail("autopilot_metrics_input_invalid", "Report input must be a regular file", { path: file });
+    }
+    let realRoot;
+    let realFile;
+    try {
+        realRoot = fs.realpathSync(root);
+        realFile = fs.realpathSync(file);
+    }
+    catch (err) {
+        return fail("autopilot_metrics_input_unreadable", `Could not resolve report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    if (!realFile.startsWith(`${realRoot}${path.sep}`)) {
+        return fail("autopilot_metrics_input_invalid", "Report input must stay under the HQ root", { path: file });
+    }
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        return fail("autopilot_metrics_input_unreadable", `Could not read report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+}
+function parseJsonObject(root, file) {
+    const raw = safeReadText(root, file);
+    try {
+        const parsed = JSON.parse(raw ?? "");
+        if (isObject(parsed))
+            return parsed;
+    }
+    catch (err) {
+        return fail("autopilot_metrics_input_invalid", `Report input is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    return fail("autopilot_metrics_input_invalid", "Report input must be a JSON object", { path: file });
+}
+function isCurrentHostLabel(label, host) {
+    return label === "local" ? host.outpostId === null : label === host.outpostId || label === host.hostname;
+}
+function loadJuniors(root, host) {
+    const file = path.join(root, JUNIORS_REL);
+    const parsed = parseJsonObject(root, file);
+    if (!Array.isArray(parsed.juniors))
+        return fail("autopilot_metrics_input_invalid", "Team registry must contain a juniors array", { path: file });
+    const seen = new Set();
+    return parsed.juniors.flatMap((value, index) => {
+        if (!isObject(value) || typeof value.host !== "string" || !value.host.trim()) {
+            return fail("autopilot_metrics_input_invalid", "Team registry row must identify its host", { path: file, index });
+        }
+        if (!isCurrentHostLabel(value.host, host))
+            return [];
+        if (["team", "lane", "status", "prd"].some((field) => typeof value[field] !== "string" || !value[field].trim())) {
+            return fail("autopilot_metrics_input_invalid", "Selected team registry row must contain team, lane, status, and prd strings", { path: file, index });
+        }
+        const entry = value;
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(entry.team) || entry.lane.includes("/") || entry.lane.includes("\\")) {
+            return fail("autopilot_metrics_input_invalid", "Team registry row contains an unsafe team or lane id", { path: file, index });
+        }
+        if (seen.has(entry.lane))
+            return fail("autopilot_metrics_mapping_ambiguous", "A lead lane appears more than once in the selected host registry", { path: file, lane_id: entry.lane });
+        seen.add(entry.lane);
+        return [entry];
+    });
+}
+function projectPath(root, raw, registryPath) {
+    if (path.isAbsolute(raw))
+        return fail("autopilot_metrics_mapping_invalid", "Project path must be relative to the HQ root", { path: registryPath, project_path: raw });
+    const absolute = path.resolve(root, raw);
+    if (!absolute.startsWith(`${path.resolve(root)}${path.sep}`)) {
+        return fail("autopilot_metrics_mapping_invalid", "Project path must stay under the HQ root", { path: registryPath, project_path: raw });
+    }
+    return absolute;
+}
+function loadProject(root, projectId, rawPrd) {
+    const registryPath = path.join(root, JUNIORS_REL);
+    const file = projectPath(root, rawPrd, registryPath);
+    const parsed = parseJsonObject(root, file);
+    const storiesValue = parsed.userStories === undefined ? parsed.stories : parsed.userStories;
+    if (!Array.isArray(storiesValue))
+        return fail("autopilot_metrics_input_invalid", "Project must contain a userStories or stories array", { path: file });
+    const stories = storiesValue.map((value, index) => {
+        if (!isObject(value) || typeof value.id !== "string" || !value.id.trim()) {
+            return fail("autopilot_metrics_input_invalid", "Project story must have a non-empty id", { path: file, index });
+        }
+        return value;
+    });
+    return { project_id: projectId, stories };
+}
+function parseIso(value, field, file) {
+    const normalized = normalizeIsoTimestamp(value);
+    if (normalized !== null)
+        return normalized;
+    if (typeof value === "string") {
+        const minutePrecision = /^(\d{4}-\d\d-\d\dT\d\d:\d\d)(Z|[+-]\d\d:\d\d)$/.exec(value);
+        if (minutePrecision) {
+            const withSeconds = normalizeIsoTimestamp(`${minutePrecision[1]}:00${minutePrecision[2]}`);
+            if (withSeconds !== null)
+                return withSeconds;
+        }
+    }
+    return fail("autopilot_metrics_input_invalid", `${field} must be an ISO timestamp`, { path: file, field });
+}
+function readJsonl(root, file, missingOk = false) {
+    const text = safeReadText(root, file, missingOk);
+    if (text === null)
+        return [];
+    const records = [];
+    for (const [index, line] of text.split("\n").entries()) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            return fail("autopilot_metrics_input_invalid", `Report JSONL contains malformed JSON: ${err instanceof Error ? err.message : String(err)}`, { path: file, line: index + 1 });
+        }
+        if (!isObject(parsed))
+            return fail("autopilot_metrics_input_invalid", "Report JSONL rows must be objects", { path: file, line: index + 1 });
+        records.push(parsed);
+    }
+    return records;
+}
+function listRegularFiles(root, directory, output, depth = 0) {
+    let names;
+    try {
+        const stat = fs.lstatSync(directory);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            return fail("autopilot_metrics_input_invalid", "Report path must be a regular directory", { path: directory });
+        const realRoot = fs.realpathSync(root);
+        const realDirectory = fs.realpathSync(directory);
+        if (!realDirectory.startsWith(`${realRoot}${path.sep}`))
+            return fail("autopilot_metrics_input_invalid", "Report directory must stay under the HQ root", { path: directory });
+        names = fs.readdirSync(directory);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        if (err instanceof LanesError)
+            throw err;
+        return fail("autopilot_metrics_input_unreadable", `Could not list report directory: ${err instanceof Error ? err.message : String(err)}`, { path: directory });
+    }
+    for (const name of names) {
+        if (!name || name.startsWith("."))
+            continue;
+        const candidate = path.join(directory, name);
+        let stat;
+        try {
+            stat = fs.lstatSync(candidate);
+        }
+        catch (err) {
+            return fail("autopilot_metrics_input_unreadable", `Could not inspect report file: ${err instanceof Error ? err.message : String(err)}`, { path: candidate });
+        }
+        if (stat.isSymbolicLink())
+            return fail("autopilot_metrics_input_invalid", "Report directory may not contain symbolic links", { path: candidate });
+        if (stat.isFile() && name.endsWith(".jsonl"))
+            output.push(candidate);
+        else if (stat.isDirectory() && depth < 2)
+            listRegularFiles(root, candidate, output, depth + 1);
+    }
+}
+function readLeadMessages(root, laneId) {
+    const dropbox = path.join(root, LANES_RUNS_REL, laneId, DROPBOX_NAME);
+    const allFiles = [];
+    for (const name of ["draining", "inflight", "delivered", "undeliverable"])
+        listRegularFiles(root, path.join(dropbox, name), allFiles);
+    const inbox = path.join(dropbox, "inbox.jsonl");
+    try {
+        const stat = fs.lstatSync(inbox);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return fail("autopilot_metrics_input_invalid", "Lead inbox must be a regular file", { path: inbox });
+        allFiles.push(inbox);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    const seen = new Set();
+    const nudges = [];
+    const resumes = [];
+    for (const file of new Set(allFiles)) {
+        const resumeFile = file.endsWith(RESUME_SUFFIX);
+        for (const row of readJsonl(root, file)) {
+            // Undated records cannot be assigned to a report day, regardless of their file.
+            if (typeof row.at !== "string")
+                continue;
+            const at = parseIso(row.at, "at", file);
+            const text = typeof row.text === "string" ? row.text : "";
+            const messageId = typeof row.message_id === "string" ? row.message_id : `${at}\u0000${text}`;
+            if (!seen.has(messageId)) {
+                seen.add(messageId);
+                if (resumeFile || row.kind !== "monitor_event")
+                    nudges.push({ team: "", at });
+            }
+            if (resumeFile)
+                resumes.push({ lane_id: laneId, at });
+        }
+    }
+    return { nudges, resumes };
+}
+function loadNudgeDefects(root, selectedTeams) {
+    const file = path.join(root, OPERATOR_NUDGE_DEFECTS_REL);
+    return readJsonl(root, file, true).flatMap((row, index) => {
+        if (typeof row.team === "string" && !selectedTeams.has(row.team))
+            return [];
+        const defect = typeof row.defect === "string" && row.defect.trim() ? row.defect : row.why;
+        if (typeof row.team !== "string" || !row.team.trim() || typeof defect !== "string" || !defect.trim()) {
+            return fail("autopilot_metrics_input_invalid", "Nudge-defect row must contain at, team, and defect (or legacy why)", { path: file, line: index + 1 });
+        }
+        return [{ at: parseIso(row.at, "at", file), team: row.team, defect }];
+    });
+}
+function loadReviews(root) {
+    const listing = listLaneReviews(root);
+    if (listing.skipped > 0)
+        return fail("autopilot_metrics_review_record_invalid", "One or more lane review records could not be read", { skipped: listing.skipped });
+    return listing.reviews.flatMap((review) => review.history.map((entry) => ({
+        repo: entry.repo,
+        pr: entry.pr,
+        recorded_at: entry.recorded_at,
+        worker_lane: entry.worker_lane,
+    })));
+}
+function selectLeads(root, host) {
+    const juniors = loadJuniors(root, host);
+    const lanes = readAllLanes(root);
+    const leads = [];
+    const projects = [];
+    const laneIds = new Set();
+    const projectIds = new Set();
+    for (const entry of juniors) {
+        const matchingLanes = lanes.filter((candidate) => candidate.lane_id === entry.lane || candidate.lane_id.startsWith(`${entry.lane}_`));
+        const lane = matchingLanes.find((candidate) => laneRunsHere(candidate, host));
+        if (!lane) {
+            return fail("autopilot_metrics_lead_missing", "Registered lead lane could not be read on this host", { team: entry.team, lane_id: entry.lane });
+        }
+        if (laneIds.has(lane.lane_id))
+            return fail("autopilot_metrics_mapping_ambiguous", "A lead lane appears more than once in the host report", { lane_id: lane.lane_id });
+        const projectKey = JSON.stringify([lane.project_id, projectPath(root, entry.prd, path.join(root, JUNIORS_REL))]);
+        const lead = { team: entry.team, lane_id: lane.lane_id, project_id: projectKey };
+        leads.push(lead);
+        laneIds.add(lane.lane_id);
+        if (!projectIds.has(projectKey)) {
+            projects.push(loadProject(root, projectKey, entry.prd));
+            projectIds.add(projectKey);
+        }
+    }
+    return { leads, projects, laneIds };
+}
+function windowFromOptions(now, options) {
+    const until = normalizeIsoTimestamp(now.toISOString());
+    if (until === null)
+        return fail("autopilot_metrics_window_invalid", "Current time is invalid");
+    if (options.since !== undefined && options.days !== undefined)
+        return fail("autopilot_metrics_window_invalid", "Use either --since or --days, not both");
+    if (options.since !== undefined) {
+        const since = normalizeIsoTimestamp(options.since);
+        if (since === null || Date.parse(since) >= Date.parse(until))
+            return fail("autopilot_metrics_window_invalid", "--since must be an ISO timestamp before now", { since: options.since });
+        return { since, until };
+    }
+    const days = options.days === undefined ? 3 : Number(options.days);
+    if (!Number.isSafeInteger(days) || days < 1 || days > 366)
+        return fail("autopilot_metrics_window_invalid", "--days must be an integer from 1 to 366", { days: options.days });
+    return { since: new Date(Date.parse(until) - days * 24 * 60 * 60 * 1000).toISOString(), until };
+}
+function printJson(value) {
+    console.log(JSON.stringify(value));
+}
+export function registerLaneAutopilotReportCommand(parent, deps, wrap) {
+    const autopilot = parent.command("autopilot").description("Measure automated lead-lane follow-through");
+    autopilot.command("report")
+        .description("Report operator nudges, review latency, and idle slots with ready work")
+        .option("--since <iso>", "Include activity since this ISO timestamp")
+        .option("--days <n>", "Include the most recent number of days")
+        .option("--json", "Print JSON")
+        .action(wrap(async (options) => {
+        const root = deps.hqRoot();
+        const window = windowFromOptions(deps.now(), options);
+        const host = deps.currentHost();
+        const selected = selectLeads(root, host);
+        const lanes = readAllLanes(root);
+        const nudges = [];
+        const resumes = [];
+        for (const lead of selected.leads) {
+            const events = readLeadMessages(root, lead.lane_id);
+            nudges.push(...events.nudges.map((event) => ({ ...event, team: lead.team })));
+            resumes.push(...events.resumes);
+            const record = lanes.find((lane) => lane.lane_id === lead.lane_id);
+            const lastResume = record?.last_resume?.at;
+            if (lastResume && !resumes.some((resume) => resume.lane_id === lead.lane_id && resume.at === lastResume))
+                resumes.push({ lane_id: lead.lane_id, at: lastResume });
+        }
+        const reviewListing = loadReviews(root);
+        const defects = loadNudgeDefects(root, new Set(selected.leads.map((lead) => lead.team)));
+        const result = buildAutopilotMetricsReport({
+            ...window,
+            leads: selected.leads,
+            lanes: lanes,
+            projects: selected.projects,
+            reviews: reviewListing,
+            nudges,
+            nudgeDefects: defects,
+            seniorResumes: resumes,
+        });
+        printJson(result);
+    }));
+}
+//# sourceMappingURL=lanes-autopilot.js.map

package/dist/commands/lanes-message.js

@@ -10,12 +10,11 @@ import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, w
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
-import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, callerMatchesSessionSenior, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneMessageHandlers(deps) {
-    const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, casUpdateLane, dispatchOutpostLaneCommand, drainHookStatusFor, laneIsHostedHere, laneWithRecoveredProviderSession, loadAllLanes, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveActiveQuestionCompany, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
+    const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, casUpdateLane, dispatchOutpostLaneCommand, dispatchPrimaryLaneMessage, drainHookStatusFor, laneIsHostedHere, laneWithRecoveredProviderSession, loadAllLanes, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveActiveQuestionCompany, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
     function currentSuccessorOf(lane, lanes, lineageAware, companyForLane) {
         const validLanes = lanes.filter((candidate) => Number.isFinite(Date.parse(candidate.created_at)));
         const newestFirst = [...validLanes].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
@@ -221,7 +220,27 @@ export function createLaneMessageHandlers(deps) {
         if (!text) {
             throw new LanesError("missing_text", "--text is required", {});
         }
-        const resolution = await deps.resolveCommandLane(ctx, laneId);
+        let resolution;
+        try {
+            resolution = await deps.resolveCommandLane(ctx, laneId);
+        }
+        catch (err) {
+            const identity = ctx.readOutpostIdentity();
+            const failedOutpostIds = err instanceof LanesError ? err.details.failed_outpost_ids : undefined;
+            const probedOutpostIds = err instanceof LanesError ? err.details.probed_outpost_ids : undefined;
+            const primaryLookupFailed = Array.isArray(failedOutpostIds) && failedOutpostIds.includes("primary");
+            const primaryReportedMissing = Array.isArray(probedOutpostIds) && probedOutpostIds.includes("primary");
+            if (!(err instanceof LanesError) ||
+                err.error !== "lane_not_found" ||
+                identity.kind !== "id" ||
+                identity.id === "primary" ||
+                primaryLookupFailed ||
+                primaryReportedMissing) {
+                throw err;
+            }
+            await dispatchPrimaryLaneMessage(ctx, laneId, { ...opts, text });
+            return;
+        }
         let lane = resolution.lane;
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
             const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
@@ -465,7 +484,6 @@ export function createLaneMessageHandlers(deps) {
                 markAccepted();
             }
             else {
-                const managerStatusGateEnabled = await managerStatusGateEnabledForLane(hqRoot, lane, { env: ctx.env });
                 const dispatched = await dispatchLaneDelivery(lane, {
                     dropbox: () => {
                         // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
@@ -523,7 +541,6 @@ export function createLaneMessageHandlers(deps) {
                                 }
                                 const started = spawnLaneWorker(hqRoot, lane, {
                                     env: ctx.env,
-                                    managerStatusGateEnabled,
                                     modelDeps: {
                                         readFileSync: ctx.readFileSync,
                                         probe: ctx.probeProvider,
@@ -624,6 +641,7 @@ export function createLaneMessageHandlers(deps) {
                     accepted: true,
                     delivered: false,
                     delivery: mechanism,
+                    delivered_to: { host: lane.host.id, lane_id: laneId, mechanism },
                     delivery_status: deliveryStatus,
                     inbox_path: mechanism === "dropbox" ? dropboxInboxPath(hqRoot, laneId) : null,
                     drain_hook: drainHook,

package/dist/commands/lanes-questions.js

@@ -20,7 +20,7 @@ export function resolveAnswerChoice(choice, options, freeform) {
     throw new LanesError("off_menu_choice", `Choice ${JSON.stringify(choice)} is not on the menu. Pass --freeform to allow it.`, { choice, options });
 }
 export function createLaneQuestionsHandlers(deps) {
-    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionCompanyMatchesLane, casUpdateQuestion, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
+    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionAnswerAuthorized, assertQuestionCompanyMatchesLane, casUpdateQuestion, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
     function requireQuestionBody(hqRoot, question) {
         const body = readQuestionBody(hqRoot, question);
         if (!body) {
@@ -73,10 +73,11 @@ export function createLaneQuestionsHandlers(deps) {
             return;
         throw new LanesError("question_not_pending", `Question ${current.question_id} is ${current.status}`, { question_id: current.question_id, status: current.status });
     }
-    async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
+    async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options, lookupErrors = []) {
         if (lane.host.kind !== "outpost") {
             throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to answer its question`, { lane_id: lane.lane_id, question_id: questionId });
         }
+        assertQuestionAnswerAuthorized(ctx, lane);
         const outpostId = lane.host.id;
         let dispatched;
         try {
@@ -224,6 +225,7 @@ export function createLaneQuestionsHandlers(deps) {
             outpost_id: outpostId,
             outpost_command_id: dispatched.commandId,
             outpost_transport: "outposts_exec",
+            ...(lookupErrors.length > 0 ? { lookup_errors: lookupErrors } : {}),
         });
     }
     async function readOutpostQuestionDetail(ctx, owner) {
@@ -280,6 +282,7 @@ export function createLaneQuestionsHandlers(deps) {
     }
     async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
         const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
+            !laneIsHostedHere(ctx, lane) &&
             (!companyFilter ||
                 effectiveLaneQuestionCompany(lane, hqRoot) === null ||
                 questionCompanyRefMatches(effectiveLaneQuestionCompany(lane, hqRoot), companyFilter)));
@@ -584,13 +587,13 @@ export function createLaneQuestionsHandlers(deps) {
                 throw err;
             const company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
             const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
-            if (lookup.errors.length > 0) {
+            const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
+            if (matches.length === 0 && lookup.errors.length > 0) {
                 throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
                     question_id: questionId,
                     hosts: lookup.errors.map(({ host, error }) => ({ host, error })),
                 });
             }
-            const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
             if (matches.length === 0) {
                 const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
                 const otherCompanyMatch = allCompanyLookup.questions.find((entry) => entry.question.question_id === questionId);
@@ -620,7 +623,7 @@ export function createLaneQuestionsHandlers(deps) {
             await dispatchOutpostQuestionAnswer(ctx, owner.lane, questionId, {
                 ...opts,
                 company: questionListCompanyArg(ownerCompany),
-            });
+            }, lookup.errors);
             return;
         }
         await yieldEventLoop();