@indigoai-us/hq-cli 5.273.0-alpha.0 → 5.273.0

package/dist/commands/daemon.d.ts

@@ -16,7 +16,6 @@
 import type { Command } from "commander";
 import { type LegacyUnit } from "../lib/daemon/legacy.js";
 import type { HostApp } from "../lib/daemon/supervisor.js";
-import { type SyncModeVaultClient } from "./sync-mode.js";
 import type { RunCommand } from "../lib/service-manager/launchd.js";
 export interface DaemonCommandDeps {
     env: NodeJS.ProcessEnv;
@@ -39,8 +38,6 @@ export interface DaemonCommandDeps {
     userHome: (user: string) => string;
     /** The pid is a live `hq daemon run`. */
     daemonAlive: (pid: number) => boolean;
-    /** Test seam for the company sync-mode commands. */
-    syncModeClient?: () => Promise<SyncModeVaultClient>;
     windowsUser?: string;
     windowsHeadlessLauncher?: string;
     systemUnitDir?: string;

package/dist/commands/daemon.js

@@ -18,7 +18,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { major as semverMajor, valid as validSemver } from "semver";
 import { DEFAULT_SERVICES, SERVICE_DESCRIPTIONS, enabledServices, hqCloudUnits } from "../lib/daemon/catalog.js";
-import { applyServiceToggle, effectiveSyncOwner, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
+import { applyServiceToggle, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
 import { daemonUnitInstalled } from "../lib/daemon/handoff.js";
 import { adoptLegacyUnits, readAdoptedUnits, restoreLegacyUnits } from "../lib/daemon/migrate.js";
 import { ROOT_REFUSAL, SYSTEM_UNIT_DIR, daemonRootRefusal, installDaemonUnit, installScopeFor, uninstallDaemonUnit, } from "../lib/daemon/install.js";
@@ -27,10 +27,7 @@ import { isDaemonProcess, runningDaemonPid } from "../lib/daemon/lock.js";
 import { bundledHqCloud } from "../lib/daemon/hq-cloud.js";
 import { MACHINE_TYPE_MARKER_PATH, detectMachineType, homeFromPasswd, } from "../lib/daemon/machine-type.js";
 import { daemonPaths } from "../lib/daemon/paths.js";
-import { processCommandLine } from "../lib/daemon/lock.js";
 import { writeControlRequest } from "../lib/daemon/requests.js";
-import { isSyncRunnerCommandLine, readWatchRunnerOwnerStatus, watchRunnerOwnerStatusPath } from "../lib/daemon/sync-runner.js";
-import { getSyncModeForCompany, setSyncMode } from "./sync-mode.js";
 import { resolveDefaultHqRoot } from "../utils/cognito-session.js";
 class DaemonCommandError extends Error {
 }
@@ -99,7 +96,6 @@ async function loadDefaults(over) {
         windowsUser: over.windowsUser ?? (platform === "win32" ? mesh.resolveWindowsUser(env) : ""),
         windowsHeadlessLauncher: over.windowsHeadlessLauncher ?? (platform === "win32" ? mesh.resolveWindowsHeadlessLauncher(env) : undefined),
         systemUnitDir: over.systemUnitDir ?? SYSTEM_UNIT_DIR,
-        syncModeClient: over.syncModeClient,
     };
 }
 function detect(d, flag, config) {
@@ -376,135 +372,6 @@ function queueRequest(d, request, what) {
     const running = runningDaemonPid(paths.lockPath, d.daemonAlive) !== null;
     d.out(running ? `Asked the daemon to ${what}.` : `Queued "${what}"; the daemon is not running, so it applies when it starts.`);
 }
-function daemonSyncModeClient(d) {
-    if (d.syncModeClient)
-        return d.syncModeClient();
-    return (async () => {
-        const [{ VaultClient }, { buildVaultConfig, ensureCognitoToken }] = await Promise.all([
-            import("@indigoai-us/hq-cloud"),
-            import("../utils/cognito-session.js"),
-        ]);
-        const token = await ensureCognitoToken();
-        return new VaultClient(buildVaultConfig(token));
-    })();
-}
-function daemonSyncStatus(d) {
-    const host = currentHost(d);
-    const { paths } = host;
-    const config = readDaemonConfig(paths.configPath);
-    const daemonPid = runningDaemonPid(paths.lockPath, d.daemonAlive);
-    const daemonState = daemonPid === null ? null : readState(paths);
-    const syncUnit = daemonState?.units.find((unit) => unit.id === "sync");
-    const hqRoot = config.hqRoot ?? d.env.HQ_ROOT?.trim();
-    let ownerStatusCandidate = null;
-    if (hqRoot) {
-        try {
-            ownerStatusCandidate = readWatchRunnerOwnerStatus(watchRunnerOwnerStatusPath(hqRoot, d.home, d.env));
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            d.err(`Could not read sync runner owner status; treating it as unavailable: ${detail}`);
-        }
-    }
-    const ownerCommandLine = ownerStatusCandidate
-        ? processCommandLine(ownerStatusCandidate.pid, { platform: d.platform, run: d.run })
-        : null;
-    const ownerStatus = ownerCommandLine && isSyncRunnerCommandLine(ownerCommandLine)
-        ? ownerStatusCandidate
-        : null;
-    return {
-        running: syncUnit?.status === "running",
-        paused: config.syncPaused === true,
-        syncOwner: effectiveSyncOwner(config, host.detected.type),
-        owner: ownerStatus?.owner ?? (syncUnit?.status === "running" ? "hq-daemon" : null),
-        runnerPid: ownerStatus?.pid ?? syncUnit?.pid ?? null,
-        hqCloudVersion: ownerStatus?.version ?? null,
-        lastHeartbeat: syncUnit?.lastHeartbeatAt ?? ownerStatus?.heartbeatAt ?? null,
-        lastPassResult: syncUnit?.lastPassResult ?? null,
-        unitStatus: syncUnit?.status ?? "not-running",
-        reason: syncUnit?.reason ?? null,
-        logPath: paths.unitLogPath("sync"),
-    };
-}
-async function runDaemonSyncStatus(d, opts) {
-    const status = daemonSyncStatus(d);
-    if (opts.json) {
-        d.out(JSON.stringify(status, null, 2));
-        return;
-    }
-    d.out(`Sync ${status.running ? "running" : status.unitStatus}${status.paused ? " (paused)" : ""}.`);
-    d.out(`Configured sync owner: ${status.syncOwner}.`);
-    d.out(`Owner: ${status.owner ?? "none"}; runner pid: ${status.runnerPid ?? "none"}; hq-cloud: ${status.hqCloudVersion ?? "unknown"}.`);
-    if (status.reason)
-        d.out(`Reason: ${status.reason}`);
-    d.out(`Log: ${status.logPath}`);
-}
-function queueDaemonSyncControl(d, request) {
-    const host = currentHost(d);
-    writeControlRequest(host.paths.requestsDir, request);
-    handOver(d, host);
-    return runningDaemonPid(host.paths.lockPath, d.daemonAlive) !== null;
-}
-async function runDaemonSyncNow(d, opts) {
-    const host = currentHost(d);
-    const config = readDaemonConfig(host.paths.configPath);
-    if (config.syncPaused)
-        throw new DaemonCommandError("sync is paused; run `hq daemon sync resume` first");
-    if (!enabledServices(host.detected.type, config).includes("sync")) {
-        throw new DaemonCommandError("sync is disabled for this machine; run `hq daemon enable sync` first");
-    }
-    const running = queueDaemonSyncControl(d, { action: "restart", unit: "sync" });
-    const result = { accepted: true, action: "restart-sync-runner", daemonRunning: running };
-    d.out(opts.json ? JSON.stringify(result, null, 2) : running ? "Asked the daemon to start a fresh sync pass." : "Queued a fresh sync pass for the next daemon start.");
-}
-async function runDaemonSyncPause(d, paused, opts) {
-    const host = currentHost(d);
-    const config = readDaemonConfig(host.paths.configPath);
-    if (config.syncPaused !== paused)
-        writeDaemonConfig(host.paths.configPath, { ...config, syncPaused: paused });
-    const daemonRunning = queueDaemonSyncControl(d, { action: "reconcile" });
-    const result = { paused, persisted: true, daemonRunning };
-    d.out(opts.json ? JSON.stringify(result, null, 2) : `Sync ${paused ? "paused" : "resumed"}${daemonRunning ? "" : "; the setting will apply when the daemon starts"}.`);
-}
-async function runDaemonSyncTakeOwnership(d, opts) {
-    const host = currentHost(d);
-    const config = readDaemonConfig(host.paths.configPath);
-    if (config.syncOwner !== "daemon")
-        writeDaemonConfig(host.paths.configPath, { ...config, syncOwner: "daemon" });
-    const daemonRunning = queueDaemonSyncControl(d, { action: "reconcile" });
-    const result = { syncOwner: "daemon", persisted: true, daemonRunning };
-    d.out(opts.json ? JSON.stringify(result, null, 2) : `Daemon sync ownership persisted${daemonRunning ? "; asked the daemon to reconcile" : "; it applies when the daemon starts"}.`);
-}
-async function runDaemonSyncModeGet(d, companySlug, opts) {
-    const result = await getSyncModeForCompany({ companySlug, vaultClient: await daemonSyncModeClient(d) });
-    const value = {
-        companySlug: result.companySlug,
-        membershipId: result.membershipId,
-        mode: result.config.syncMode,
-        isDefault: result.config.isDefault,
-        ...(result.config.updatedAt ? { updatedAt: result.config.updatedAt } : {}),
-    };
-    d.out(opts.json ? JSON.stringify(value, null, 2) : `${value.companySlug}: ${value.mode}${value.isDefault ? " (default)" : ""}`);
-}
-async function runDaemonSyncModeSet(d, companySlug, mode, opts) {
-    if (mode !== "all" && mode !== "shared") {
-        throw new DaemonCommandError(`Invalid sync mode '${mode}'. Use all or shared.`);
-    }
-    const result = await setSyncMode({
-        mode,
-        companySlug,
-        vaultClient: await daemonSyncModeClient(d),
-    });
-    const value = {
-        companySlug: result.companySlug,
-        membershipId: result.membershipId,
-        previousMode: result.previousMode,
-        mode: result.newMode,
-        isDefault: result.newConfig.isDefault,
-        ...(result.newConfig.updatedAt ? { updatedAt: result.newConfig.updatedAt } : {}),
-    };
-    d.out(opts.json ? JSON.stringify(value, null, 2) : `${value.companySlug}: ${value.previousMode} → ${value.mode}`);
-}
 async function runToggle(d, action, services) {
     const host = currentHost(d);
     const { paths } = host;
@@ -736,45 +603,6 @@ export function registerDaemonCommand(program, over = {}) {
         .description("Show the machine type and each service's state")
         .option("--json", "Print machine-readable JSON")
         .action(wrap((d, opts) => runStatus(d, opts)));
-    const sync = daemon
-        .command("sync")
-        .description("Inspect and control the daemon's company sync runner");
-    sync
-        .command("status")
-        .description("Show sync ownership, heartbeat, last pass and log path")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, opts) => runDaemonSyncStatus(d, opts)));
-    sync
-        .command("now")
-        .description("Start a fresh sync pass immediately")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, opts) => runDaemonSyncNow(d, opts)));
-    sync
-        .command("pause")
-        .description("Pause daemon sync until resumed")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, opts) => runDaemonSyncPause(d, true, opts)));
-    sync
-        .command("resume")
-        .description("Resume daemon sync after a pause")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, opts) => runDaemonSyncPause(d, false, opts)));
-    sync
-        .command("take-ownership")
-        .description("Persist daemon ownership of desktop sync and reconcile")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, opts) => runDaemonSyncTakeOwnership(d, opts)));
-    const mode = sync.command("mode").description("Read or change a company's sync footprint");
-    mode
-        .command("get <company>")
-        .description("Read a company's current all/shared sync mode")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, company, opts) => runDaemonSyncModeGet(d, company, opts)));
-    mode
-        .command("set <company> <mode>")
-        .description("Set a company's sync mode to all or shared")
-        .option("--json", "Print machine-readable JSON")
-        .action(wrap((d, company, mode, opts) => runDaemonSyncModeSet(d, company, mode, opts)));
     daemon
         .command("logs [unit]")
         .description("Print the supervisor log, or one service's log")

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

@@ -4,7 +4,6 @@ import type { LaneCompanyRef, QuestionRecord } from "../lib/lanes/types.js";
 export interface LaneChecksDeps {
     hqRoot: () => string;
     resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
-    trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     now: () => Date;
     stopLane?: (laneId: string, reason: string) => Promise<void>;
     sessionState?: (root: string, sessionId: string, now: Date) => string | null;

package/dist/commands/lanes-checks.js

@@ -7,10 +7,11 @@ import { evaluateTrackerChecks } from "../lib/lanes/tracker-checks.js";
 import { LANE_STORE_UPGRADE_COMMAND, isLaneStoreVersionNewer, laneRecordPath, listLaneIds, listQuestionIds, questionRecordPath, readLane, readQuestion } from "../lib/lanes/store.js";
 import { createLocalTrackerStore } from "../lib/lanes/tracker-store.js";
 import { sessionLiveness } from "../lib/lanes/liveness.js";
-import { findOrphanLanes, parseOrphanMinAge } from "../lib/lanes/orphans.js";
+import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
+import { DEFAULT_ORPHAN_USER_IDLE_HOURS, findOrphanLanes, parseOrphanMinAge, parseOrphanUserIdleHours, } from "../lib/lanes/orphans.js";
+import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
-import { LANES_TRACKER_FLAG } from "./lanes-tracker.js";
 function fail(error, message, details = {}) {
     throw new LanesError(error, message, details);
 }
@@ -293,46 +294,176 @@ function readScopedLanes(root, company, projects) {
         return [readLane(root, id)];
     });
 }
-function readCompanyLanes(root, company, projectId) {
-    return listLaneIds(root).flatMap((id) => {
-        const file = laneRecordPath(root, id);
-        const metadata = readJsonObject(file);
-        if (metadata === null)
-            return fail("tracker_checks_input_unreadable", "Lane record could not be read while checking its scope", { path: file });
-        const laneCompany = isObject(metadata.company) ? metadata.company : null;
-        if (laneCompany?.slug !== company.slug || laneCompany.uid !== company.uid)
-            return [];
-        if (projectId !== undefined && !laneMetadataMatchesScope(metadata, company, new Set([projectId])))
-            return [];
-        return [readLane(root, id)];
-    });
-}
 function orphanSessionState(root, sessionId, now, deps) {
     if (deps.sessionState)
         return deps.sessionState(root, sessionId, now);
     return sessionLiveness(root, sessionId, { nowMs: now.getTime() });
 }
-function orphanFindings(root, company, now, minAgeMinutes, deps, projectId) {
-    const candidates = readCompanyLanes(root, company, projectId);
-    const lanes = [...candidates];
-    const known = new Set(lanes.map((lane) => lane.lane_id));
-    for (const candidate of candidates) {
-        if (candidate.senior.kind !== "lane" || candidate.senior.id === undefined || known.has(candidate.senior.id))
+const MAX_ORPHAN_SENIOR_DEPTH = 64;
+function readOrphanLaneScopes(root) {
+    return new Map(listLaneIds(root).map((id) => {
+        const file = laneRecordPath(root, id);
+        const metadata = readJsonObject(file);
+        if (metadata === null)
+            return fail("tracker_checks_input_unreadable", "Lane record could not be read while resolving orphan scope", { path: file });
+        const companyRef = (value) => isObject(value) && typeof value.slug === "string" && typeof value.uid === "string"
+            ? { slug: value.slug, uid: value.uid }
+            : null;
+        const meshCompany = companyRef(metadata.mesh_company);
+        const lane = {
+            lane_id: id,
+            company: companyRef(metadata.company),
+            ...(meshCompany === null ? {} : { mesh_company: meshCompany }),
+            project_id: typeof metadata.project_id === "string" ? metadata.project_id : "",
+        };
+        const seniorLaneId = isObject(metadata.senior) && metadata.senior.kind === "lane" && typeof metadata.senior.id === "string"
+            ? metadata.senior.id
+            : undefined;
+        const projectIds = [lane.project_id];
+        if (Array.isArray(metadata.stories)) {
+            for (const story of metadata.stories) {
+                if (isObject(story) && typeof story.project_id === "string")
+                    projectIds.push(story.project_id);
+            }
+        }
+        return [id, { lane, ...(seniorLaneId === undefined ? {} : { seniorLaneId }), projectIds }];
+    }));
+}
+function orphanCompanyResolution(root, scope, scopesById) {
+    const direct = resolveLaneCompany(root, scope.lane);
+    if (direct.company !== null)
+        return direct;
+    const visited = new Set([scope.lane.lane_id]);
+    let current = scope;
+    for (let depth = 0; depth < MAX_ORPHAN_SENIOR_DEPTH; depth += 1) {
+        const seniorId = current.seniorLaneId;
+        if (seniorId === undefined)
+            break;
+        if (visited.has(seniorId))
+            break;
+        visited.add(seniorId);
+        const senior = scopesById.get(seniorId);
+        if (senior === undefined)
+            break;
+        const resolved = resolveLaneCompany(root, senior.lane);
+        if (resolved.company !== null)
+            return { company: resolved.company, source: "senior" };
+        current = senior;
+    }
+    return { company: null, source: "unresolved" };
+}
+function orphanLastActivityAt(root, lane) {
+    const updatedAt = Date.parse(lane.updated_at);
+    if (!Number.isFinite(updatedAt))
+        return Number.NaN;
+    const recordedEnvelopeAt = lane.last_envelope === undefined ? Number.NaN : Date.parse(lane.last_envelope.at);
+    let latest = Number.isFinite(recordedEnvelopeAt) ? Math.max(updatedAt, recordedEnvelopeAt) : updatedAt;
+    const envelopesDirectory = path.join(root, LANES_RUNS_REL, lane.lane_id, "envelopes");
+    let entries;
+    try {
+        entries = fs.readdirSync(envelopesDirectory, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return latest;
+        return fail("orphan_envelope_unreadable", "Lane envelope directory could not be read", { lane_id: lane.lane_id });
+    }
+    for (const entry of entries) {
+        if (!entry.name.endsWith(".json") || entry.name.startsWith("."))
             continue;
-        const file = laneRecordPath(root, candidate.senior.id);
-        const metadata = readJsonObject(file, "empty");
-        const laneCompany = metadata && isObject(metadata.company) ? metadata.company : null;
-        if (laneCompany?.slug !== company.slug || laneCompany.uid !== company.uid)
+        const file = path.join(envelopesDirectory, entry.name);
+        try {
+            const stat = fs.lstatSync(file);
+            if (stat.isFile() && !stat.isSymbolicLink() && Number.isFinite(stat.mtimeMs)) {
+                latest = Math.max(latest, stat.mtimeMs);
+            }
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            return fail("orphan_envelope_unreadable", "Lane envelope timestamp could not be read", { lane_id: lane.lane_id });
+        }
+    }
+    return latest;
+}
+function orphanLaneHasOpenStory(root, lane, company) {
+    const carriedStories = lane.stories ?? [];
+    const references = [];
+    const addReference = (project_id, story_id) => {
+        if (!references.some((reference) => reference.project_id === project_id && reference.story_id === story_id)) {
+            references.push({ project_id, story_id });
+        }
+    };
+    if (lane.story_id !== "")
+        addReference(lane.project_id, lane.story_id);
+    for (const story of carriedStories) {
+        addReference(story.project_id, story.story_id);
+        if (story.status !== "done")
+            return true;
+    }
+    if (references.length === 0)
+        return false;
+    if (company === null)
+        return true;
+    for (const reference of references) {
+        const resolution = resolveLaneCompany(root, {
+            lane_id: lane.lane_id,
+            company: lane.company,
+            project_id: reference.project_id,
+        });
+        if (resolution.company === null || resolution.company.slug !== company.slug || resolution.company.uid !== company.uid) {
+            return true;
+        }
+        const projectId = validSegment(reference.project_id, "project");
+        const prdPath = path.join(root, "companies", company.slug, "projects", projectId, "prd.json");
+        const stories = readProject(root, company.slug, prdPath, true).stories;
+        const matching = stories.filter((story) => story.id === reference.story_id);
+        if (matching.some((story) => !storyIsDone(story)))
+            return true;
+    }
+    return false;
+}
+function orphanFindings(root, company, now, minAgeMinutes, deps, projectId, unscoped = company === null, userIdleHours = DEFAULT_ORPHAN_USER_IDLE_HOURS) {
+    const scopesById = readOrphanLaneScopes(root);
+    const companyByLane = new Map();
+    const selectedScopes = [...scopesById.values()].filter((scope) => {
+        if (projectId !== undefined && !scope.projectIds.includes(projectId))
+            return false;
+        const rawCompany = scope.lane.company;
+        if (company !== null && rawCompany !== null && (rawCompany.slug !== company.slug || rawCompany.uid !== company.uid))
+            return false;
+        const resolution = orphanCompanyResolution(root, scope, scopesById);
+        companyByLane.set(scope.lane.lane_id, resolution);
+        if (unscoped)
+            return resolution.company === null;
+        return company !== null && resolution.company?.slug === company.slug && resolution.company.uid === company.uid;
+    });
+    const selectedLanes = selectedScopes.map((scope) => readLane(root, scope.lane.lane_id));
+    const candidates = selectedLanes.filter((lane) => projectId === undefined ||
+        lane.project_id === projectId || (lane.stories ?? []).some((story) => story.project_id === projectId));
+    const candidateIds = new Set(candidates.map((lane) => lane.lane_id));
+    const lanesForFinding = new Map(candidates.map((lane) => [lane.lane_id, lane]));
+    for (const lane of candidates) {
+        if (lane.senior.kind !== "lane" || lane.senior.id === undefined || lanesForFinding.has(lane.senior.id))
             continue;
-        lanes.push(readLane(root, candidate.senior.id));
-        known.add(candidate.senior.id);
+        if (scopesById.has(lane.senior.id))
+            lanesForFinding.set(lane.senior.id, readLane(root, lane.senior.id));
     }
     return findOrphanLanes({
-        lanes,
+        lanes: [...lanesForFinding.values()],
+        candidateLaneIds: candidateIds,
         now,
         minAgeMinutes,
+        userIdleHours,
         sessionState: (sessionId, at) => orphanSessionState(root, sessionId, at, deps),
-    }).filter((finding) => candidates.some((lane) => lane.lane_id === finding.lane_id));
+        lastActivityAt: (lane) => orphanLastActivityAt(root, lane),
+        hasOpenStory: (lane) => orphanLaneHasOpenStory(root, lane, companyByLane.get(lane.lane_id)?.company ?? null),
+    })
+        .filter((finding) => candidateIds.has(finding.lane_id))
+        .map((finding) => ({
+        ...finding,
+        company_source: companyByLane.get(finding.lane_id)?.source ?? "unresolved",
+    }));
 }
 function sameCompanyLane(lane, company) {
     return lane.company?.slug === company.slug && lane.company.uid === company.uid;
@@ -582,9 +713,6 @@ export async function resolveTrackerCompany(deps, requested) {
     const company = await deps.resolveCompany(requested);
     if (!company.slug)
         fail("tracker_company_unresolved", "The active HQ company could not be resolved", {});
-    if (!await deps.trackerEnabled(company)) {
-        fail("tracker_disabled", `hq lanes tracker commands require the ${LANES_TRACKER_FLAG} flag`, { company: company.slug });
-    }
     return company;
 }
 async function checkReport(root, company, projects, directiveProjects, projectFilter, minAgeMinutes, now, deps) {
@@ -631,8 +759,8 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
         result: orphanedLanes.length === 0 ? "ok" : "failing",
         items: orphanedLanes.map((finding) => ({
             id: finding.lane_id,
-            reason: finding.senior_state === "missing" ? "missing_senior" :
-                finding.senior_state === "ended" ? "ended_session_senior" : "terminal_senior",
+            reason: finding.reason,
+            company_source: finding.company_source,
             senior: finding.senior,
             senior_state: finding.senior_state,
             age_minutes: finding.age_minutes,
@@ -648,7 +776,7 @@ async function checkReport(root, company, projects, directiveProjects, projectFi
         checks,
     };
 }
-async function orphanReport(root, company, now, minAgeMinutes, deps, options) {
+async function orphanReport(root, company, now, minAgeMinutes, userIdleHours, deps, options) {
     const reason = options.reason?.trim();
     if (options.stop && !reason) {
         fail("orphan_stop_reason_required", "--stop requires a non-empty --reason", {});
@@ -658,39 +786,63 @@ async function orphanReport(root, company, now, minAgeMinutes, deps, options) {
     }
     if (reason !== undefined)
         assertNoSecretText("stop reason", reason);
-    const orphans = orphanFindings(root, company, now, minAgeMinutes, deps);
-    if (!options.stop) {
+    const unscoped = options.unscoped === true;
+    const orphans = orphanFindings(root, company, now, minAgeMinutes, deps, undefined, unscoped, userIdleHours);
+    const output = (action, stopped) => {
+        if (options.human) {
+            const companyText = unscoped ? "unscoped" : company?.slug ?? "unknown";
+            console.log(`company: ${companyText}`);
+            console.log("lane_id\tsenior\tsenior_state\treason\tcompany_source\tage_minutes\taccount\thost");
+            for (const finding of orphans) {
+                console.log([
+                    finding.lane_id,
+                    `${finding.senior.kind}:${finding.senior.id ?? ""}`,
+                    finding.senior_state,
+                    finding.reason,
+                    finding.company_source,
+                    finding.age_minutes,
+                    finding.account ?? "",
+                    `${finding.host.kind}:${finding.host.id}`,
+                ].join("\t"));
+            }
+            if (orphans.length === 0)
+                console.log("(none)");
+            if (stopped !== undefined) {
+                console.log("stopped:");
+                for (const entry of stopped)
+                    console.log(`${entry.lane_id}\t${entry.state}`);
+            }
+            return;
+        }
         console.log(JSON.stringify({
             ok: true,
-            action: "orphans",
-            company: company.slug,
+            action,
+            company: company?.slug ?? null,
+            ...(unscoped ? { unscoped: true } : {}),
             generated_at: now.toISOString(),
             min_age_minutes: minAgeMinutes,
+            user_idle_hours: userIdleHours,
+            ...(reason === undefined ? {} : { reason }),
             orphans,
+            ...(stopped === undefined ? {} : { stopped }),
         }, null, 2));
+    };
+    if (!options.stop) {
+        output("orphans");
         return;
     }
     if (!deps.stopLane)
         fail("orphan_stop_unavailable", "The normal lane stop path is unavailable", {});
     const stopped = [];
     for (const finding of orphans) {
-        const fresh = orphanFindings(root, company, deps.now(), minAgeMinutes, deps)
+        const fresh = orphanFindings(root, company, deps.now(), minAgeMinutes, deps, undefined, unscoped, userIdleHours)
             .find((candidate) => candidate.lane_id === finding.lane_id);
         if (!fresh)
             continue;
         await deps.stopLane(finding.lane_id, reason);
         stopped.push({ lane_id: finding.lane_id, state: readLane(root, finding.lane_id).state });
     }
-    console.log(JSON.stringify({
-        ok: true,
-        action: "orphans.stop",
-        company: company.slug,
-        generated_at: now.toISOString(),
-        min_age_minutes: minAgeMinutes,
-        reason,
-        orphans,
-        stopped,
-    }, null, 2));
+    output("orphans.stop", stopped);
 }
 export function registerLaneChecksCommand(parent, deps, wrap) {
     parent.command("checks")
@@ -713,16 +865,27 @@ export function registerLaneChecksCommand(parent, deps, wrap) {
             process.exitCode = 2;
     }));
     parent.command("orphans")
-        .description("Report lanes whose lane or session senior has ended")
+        .description("Report lanes whose senior has ended or gone idle")
         .option("--company <slug>", "Select the company by slug")
         .option("--min-age <minutes>", "Minimum orphan lane age in minutes (default: 30)")
+        .option("--user-idle-hours <hours>", "Idle hours for user-senior lanes (default: 72)")
+        .option("--unscoped", "Report candidates whose company cannot be resolved")
         .option("--stop", "Stop the reported lanes through their normal owner path")
         .option("--reason <text>", "Required audit reason when --stop is set")
+        .option("--json", "Print machine-readable JSON")
+        .option("--human", "Print a human-readable table")
         .action(wrap(async (options) => {
-        const company = await deps.resolveCompany(options.company);
+        if (options.unscoped && options.company !== undefined) {
+            fail("orphan_scope_conflict", "--unscoped cannot be combined with --company", {});
+        }
+        if (options.human && options.json) {
+            fail("conflicting_output_format", "Choose either --json or --human output", {});
+        }
+        const company = options.unscoped ? null : await deps.resolveCompany(options.company);
         const root = deps.hqRoot();
         const minAgeMinutes = parseOrphanMinAge(options.minAge);
-        await orphanReport(root, company, deps.now(), minAgeMinutes, deps, options);
+        const userIdleHours = parseOrphanUserIdleHours(options.userIdleHours);
+        await orphanReport(root, company, deps.now(), minAgeMinutes, userIdleHours, deps, options);
     }));
 }
 //# sourceMappingURL=lanes-checks.js.map

package/dist/commands/lanes-hold.js

@@ -547,13 +547,23 @@ export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
             let reviewContext = null;
             if (holdFlagOff) {
                 reviewContext = await reviewCheckContext(hqRoot, deps);
-                if (!reviewContext) {
+            }
+            let parsed;
+            try {
+                parsed = parseMergeCommands(options.command);
+            }
+            catch (error) {
+                if (holdFlagOff && !reviewContext) {
                     printJson({ ok: true, hold_enforcement: "off" });
                     return;
                 }
+                throw error;
             }
-            const parsed = parseMergeCommands(options.command);
             repoUnresolved = parsed.targets.some((target) => target.repo === null);
+            if (holdFlagOff && !reviewContext && !parsed.unparseableMerge) {
+                printJson({ ok: true, hold_enforcement: "off" });
+                return;
+            }
             const repos = parsed.targets.flatMap((target) => target.repo === null ? [] : [target.repo]);
             const now = deps.now();
             if (!holdFlagOff) {
@@ -581,6 +591,29 @@ export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
                     return;
                 }
             }
+            if (parsed.unparseableMerge) {
+                const activeHolds = listHolds(hqRoot)
+                    .filter((existing) => holdView(existing, now).active);
+                let deniedUnresolvedHold;
+                for (const existing of activeHolds) {
+                    const enabled = await (deps.mergeHoldEnabled ?? ((company) => readLanesRegistryFlag(LANES_REPO_MERGE_HOLD_FLAG, { company, env: deps.env })))(existing.company);
+                    if (enabled) {
+                        deniedUnresolvedHold ??= existing;
+                    }
+                    else {
+                        gateWasOff = true;
+                    }
+                }
+                if (deniedUnresolvedHold) {
+                    printJson({
+                        ok: false,
+                        error: "repo_hold_command_invalid",
+                        repo_unresolved: true,
+                    });
+                    process.exitCode = 3;
+                    return;
+                }
+            }
             reviewContext ??= await reviewCheckContext(hqRoot, deps);
             if (reviewContext) {
                 const reviewCheck = checkReviewTargets(hqRoot, reviewContext, parsed.targets);
@@ -589,6 +622,11 @@ export function registerLaneRepoMergeHoldCommand(lanes, deps, wrap) {
                     process.exitCode = 3;
                     return;
                 }
+                if (parsed.unparseableMerge) {
+                    printJson({ ok: false, error: "review_record_missing", repo_unresolved: true });
+                    process.exitCode = 3;
+                    return;
+                }
                 reviewUnresolved = reviewCheck.unresolved;
             }
             printJson({