@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/lib/lanes/liveness.js

@@ -1,396 +0,0 @@
-/**
- * Session liveness from the work-mesh spool (spec §9).
- *
- * Source: ~/.hq/work-mesh/spool.jsonl, events session_start / turn_start /
- * turn_end / session_end keyed by session id. Nothing latches, including
- * `ended` — a later event for a reused id supersedes session_end.
- *
- * An index is a single compact file (workspace/lanes/sessions/index.json).
- * This module never stats workspace/sessions/.
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { workMeshSpoolPath, workMeshRoot } from "../mesh/live/paths.js";
-import { daemonDir, daemonStatePath } from "../mesh/live/daemon/paths.js";
-import { LanesError } from "./errors.js";
-import { effectiveAccountHome } from "./account-home.js";
-import { DEFAULT_LIVE_WITHIN_MS, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, loadLanesConfig, } from "./config.js";
-import { lanesStoreRoot } from "./store.js";
-export const LIVE_WITHIN_MS = DEFAULT_LIVE_WITHIN_MS;
-export const TURN_START_LOST_MS = DEFAULT_TURN_START_LOST_MS;
-export const SILENT_LOST_MS = DEFAULT_SILENT_LOST_MS;
-export const LIVENESS_EVENT_KINDS = [
-    "session_start",
-    "turn_start",
-    "turn_end",
-    "session_end",
-];
-export function defaultLivenessDeps() {
-    return {
-        now: () => Date.now(),
-        homedir: () => os.homedir(),
-        env: process.env,
-        readFileSync: (file, encoding) => fs.readFileSync(file, encoding),
-        writeFileSync: fs.writeFileSync.bind(fs),
-        renameSync: fs.renameSync.bind(fs),
-        unlinkSync: fs.unlinkSync.bind(fs),
-        existsSync: (file) => fs.existsSync(file),
-        mkdirSync: fs.mkdirSync.bind(fs),
-        statSync: (file) => fs.statSync(file),
-        lstatSync: (file) => fs.lstatSync(file),
-        readdirSync: fs.readdirSync.bind(fs),
-        hostname: () => os.hostname(),
-    };
-}
-export function defaultSpoolPath(deps = defaultLivenessDeps()) {
-    return workMeshSpoolPath(workMeshRoot(deps.homedir(), deps.env));
-}
-export function livenessIndexPath(hqRoot) {
-    return path.join(lanesStoreRoot(hqRoot), "sessions", "index.json");
-}
-function isPlainObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/**
- * Classify one session from its last spool event. `ended` is not latched:
- * a later event for the same id is classified from that later event.
- *
- * Mid-turn (`turn_start` younger than 2h) stays `live` even after the 10
- * minute recency window — spec §9's prose treats that as working, not idle.
- * `session_end` as the last event is `ended` even when recent (fast path).
- */
-export function classifySessionLiveness(entry, nowMs, presenceConnected = false, windows = {
-    live_within_ms: LIVE_WITHIN_MS,
-    turn_start_lost_ms: TURN_START_LOST_MS,
-    silent_lost_ms: SILENT_LOST_MS,
-}) {
-    const at = Date.parse(entry.lastAt);
-    const age = Number.isFinite(at) ? nowMs - at : Number.POSITIVE_INFINITY;
-    const kind = entry.lastKind;
-    if (kind === "session_end")
-        return "ended";
-    // Box-wide MQTT connected is not per-session presence. A crashed
-    // mid-turn session must still become `lost` so §6.8 can advance.
-    void presenceConnected;
-    if (kind === "turn_start" && age < windows.turn_start_lost_ms)
-        return "live";
-    if (age <= windows.live_within_ms)
-        return "live";
-    if (kind === "turn_start" && age >= windows.turn_start_lost_ms)
-        return "lost";
-    if (age >= windows.silent_lost_ms)
-        return "lost";
-    if (kind === "turn_end")
-        return "idle";
-    return "idle";
-}
-/**
- * Use recent Claude transcript file activity when a session has no mesh event
- * entry. This reads file metadata only; transcript contents are never opened.
- * If a session transcript exists in more than one configured home, the newest
- * mtime is the activity signal. A stale or absent transcript remains unknown
- * and is not evidence of an end.
- */
-export function unindexedClaudeSessionLiveness(sessionId, nowMs, windows, deps = defaultLivenessDeps(), configuredHomes = []) {
-    if (sessionId.length === 0 ||
-        sessionId.trim() !== sessionId ||
-        sessionId === "." ||
-        sessionId === ".." ||
-        /[\\/\0]/.test(sessionId)) {
-        throw new LanesError("session_activity_invalid_id", "Cannot inspect Claude activity for an invalid session id", { session_id: sessionId });
-    }
-    const homes = [
-        deps.env.CLAUDE_CONFIG_DIR?.trim(),
-        path.join(deps.homedir(), ".claude"),
-        ...configuredHomes,
-    ].filter((home) => typeof home === "string" && home.trim() !== "");
-    const projectsDirs = [...new Set(homes.map((home) => path.resolve(home, "projects")))];
-    let activityAt = null;
-    for (const projectsDir of projectsDirs) {
-        let projects;
-        try {
-            projects = deps.readdirSync(projectsDir, { withFileTypes: true });
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                continue;
-            throw new LanesError("session_activity_unreadable", `Cannot inspect Claude project activity: ${err instanceof Error ? err.message : String(err)}`, { path: projectsDir });
-        }
-        for (const project of projects) {
-            if (!project.isDirectory() || project.isSymbolicLink())
-                continue;
-            const transcriptPath = path.join(projectsDir, project.name, `${sessionId}.jsonl`);
-            let transcript;
-            try {
-                transcript = deps.lstatSync(transcriptPath);
-            }
-            catch (err) {
-                if (err.code === "ENOENT")
-                    continue;
-                throw new LanesError("session_activity_unreadable", `Cannot inspect Claude session activity: ${err instanceof Error ? err.message : String(err)}`, { path: transcriptPath });
-            }
-            if (!transcript.isFile() || transcript.isSymbolicLink())
-                continue;
-            if (!Number.isFinite(transcript.mtimeMs)) {
-                throw new LanesError("session_activity_unreadable", `Cannot inspect Claude session activity: invalid modification time`, { path: transcriptPath });
-            }
-            activityAt = Math.max(activityAt ?? Number.NEGATIVE_INFINITY, transcript.mtimeMs);
-        }
-    }
-    if (activityAt === null)
-        return null;
-    const ageMs = nowMs - activityAt;
-    return ageMs >= 0 && ageMs <= windows.live_within_ms ? "live" : null;
-}
-export function ingestSpoolLine(line, sessions, lineNo) {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return;
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch (err) {
-        process.stderr.write(`lanes liveness: skipping malformed spool line ${lineNo}: ${err instanceof Error ? err.message : String(err)}\n`);
-        return;
-    }
-    if (!isPlainObject(parsed))
-        return;
-    const sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : "";
-    const kind = typeof parsed.kind === "string" ? parsed.kind : "";
-    const at = typeof parsed.at === "string" ? parsed.at : "";
-    if (!sessionId || !kind || !at)
-        return;
-    if (!Number.isFinite(Date.parse(at))) {
-        process.stderr.write(`lanes liveness: skipping spool line ${lineNo} with unparseable at\n`);
-        return;
-    }
-    const existing = sessions[sessionId];
-    const seq = typeof parsed.seq === "number" ? parsed.seq : undefined;
-    if (existing) {
-        const existingAt = Date.parse(existing.lastAt);
-        const nextAt = Date.parse(at);
-        if (nextAt < existingAt)
-            return;
-        if (nextAt === existingAt &&
-            seq !== undefined &&
-            existing.lastSeq !== undefined &&
-            seq < existing.lastSeq) {
-            return;
-        }
-    }
-    const entry = { sessionId, lastKind: kind, lastAt: at };
-    if (seq !== undefined)
-        entry.lastSeq = seq;
-    sessions[sessionId] = entry;
-}
-export function buildLivenessIndexFromSpool(spoolContents, meta) {
-    const sessions = {};
-    const lines = spoolContents.split("\n");
-    for (let i = 0; i < lines.length; i += 1) {
-        ingestSpoolLine(lines[i] ?? "", sessions, i + 1);
-    }
-    return {
-        schema_version: "hq-lane-liveness-index.v1",
-        built_at: meta.built_at,
-        spool_path: meta.spool_path,
-        spool_bytes: meta.spool_bytes,
-        spool_mtime_ms: meta.spool_mtime_ms,
-        sessions,
-    };
-}
-function atomicWriteJson(target, value, deps) {
-    const dir = path.dirname(target);
-    deps.mkdirSync(dir, { recursive: true });
-    const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        deps.writeFileSync(tmp, `${JSON.stringify(value)}\n`, { encoding: "utf8" });
-        deps.renameSync(tmp, target);
-    }
-    catch (err) {
-        try {
-            deps.unlinkSync(tmp);
-        }
-        catch (unlinkErr) {
-            const code = unlinkErr.code;
-            if (code !== "ENOENT") {
-                process.stderr.write(`lanes liveness: unlink tmp failed for ${tmp}: ${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}\n`);
-            }
-        }
-        throw err;
-    }
-}
-export function rebuildLivenessIndex(hqRoot, spoolPath, deps = defaultLivenessDeps()) {
-    let contents;
-    let st;
-    try {
-        st = deps.statSync(spoolPath);
-        contents = deps.readFileSync(spoolPath, "utf8");
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === "ENOENT") {
-            const empty = {
-                schema_version: "hq-lane-liveness-index.v1",
-                built_at: new Date(deps.now()).toISOString(),
-                spool_path: spoolPath,
-                spool_bytes: 0,
-                spool_mtime_ms: 0,
-                sessions: {},
-            };
-            atomicWriteJson(livenessIndexPath(hqRoot), empty, deps);
-            return empty;
-        }
-        throw err;
-    }
-    const index = buildLivenessIndexFromSpool(contents, {
-        spool_path: spoolPath,
-        spool_bytes: st.size,
-        spool_mtime_ms: Math.floor(st.mtimeMs),
-        built_at: new Date(deps.now()).toISOString(),
-    });
-    atomicWriteJson(livenessIndexPath(hqRoot), index, deps);
-    return index;
-}
-export function readLivenessIndex(hqRoot, deps = defaultLivenessDeps()) {
-    const filePath = livenessIndexPath(hqRoot);
-    if (!deps.existsSync(filePath))
-        return null;
-    let raw;
-    try {
-        raw = deps.readFileSync(filePath, "utf8");
-    }
-    catch (err) {
-        process.stderr.write(`lanes liveness: failed to read index ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!isPlainObject(parsed) || parsed.schema_version !== "hq-lane-liveness-index.v1") {
-            throw new Error(`unexpected liveness index schema in ${filePath}`);
-        }
-        if (!isPlainObject(parsed.sessions)) {
-            throw new Error(`liveness index sessions map missing in ${filePath}`);
-        }
-        return parsed;
-    }
-    catch (err) {
-        process.stderr.write(`lanes liveness: invalid index ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-}
-/**
- * Return the compact index, rebuilding from the spool when missing or stale.
- * Never walks workspace/sessions/.
- */
-export function loadLivenessIndex(hqRoot, spoolPath, deps = defaultLivenessDeps(), persist = true) {
-    const spool = spoolPath ?? defaultSpoolPath(deps);
-    const existing = (() => {
-        try {
-            return readLivenessIndex(hqRoot, deps);
-        }
-        catch (err) {
-            process.stderr.write(`lanes liveness: rebuilding after invalid index: ${err instanceof Error ? err.message : String(err)}\n`);
-            return null;
-        }
-    })();
-    if (existing) {
-        try {
-            const st = deps.statSync(spool);
-            if (existing.spool_path === spool &&
-                existing.spool_bytes === st.size &&
-                existing.spool_mtime_ms === Math.floor(st.mtimeMs)) {
-                return existing;
-            }
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== "ENOENT")
-                throw err;
-            if (existing.spool_bytes === 0)
-                return existing;
-        }
-    }
-    if (!persist) {
-        let contents = "";
-        let stSize = 0;
-        let stMtime = 0;
-        try {
-            const st = deps.statSync(spool);
-            stSize = st.size;
-            stMtime = Math.floor(st.mtimeMs);
-            contents = deps.readFileSync(spool, "utf8");
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== "ENOENT")
-                throw err;
-        }
-        return buildLivenessIndexFromSpool(contents, {
-            spool_path: spool,
-            spool_bytes: stSize,
-            spool_mtime_ms: stMtime,
-            built_at: new Date(deps.now()).toISOString(),
-        });
-    }
-    return rebuildLivenessIndex(hqRoot, spool, deps);
-}
-/**
- * Spec §9: a session is also `live` when the mesh daemon reports presence
- * connected, not only from the spool. Missing state file → not connected.
- * Unreadable or corrupt state is an error (unknown must not resolve to healthy).
- */
-export function readDaemonPresenceConnected(deps = defaultLivenessDeps()) {
-    const statePath = daemonStatePath(daemonDir(undefined, deps.homedir(), deps.env));
-    if (!deps.existsSync(statePath))
-        return false;
-    let raw;
-    try {
-        raw = deps.readFileSync(statePath, "utf8");
-    }
-    catch (err) {
-        process.stderr.write(`lanes liveness: failed to read daemon state ${statePath}: ${err instanceof Error ? err.message : String(err)}\n`);
-        throw err;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        throw new LanesError("daemon_presence_unreadable", `Mesh daemon state ${statePath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, { path: statePath });
-    }
-    if (!isPlainObject(parsed)) {
-        throw new LanesError("daemon_presence_unreadable", `Mesh daemon state ${statePath} is not an object`, { path: statePath });
-    }
-    if (parsed.v !== 1) {
-        throw new LanesError("daemon_presence_unreadable", `Mesh daemon state ${statePath} has unexpected v ${JSON.stringify(parsed.v)}`, { path: statePath, v: parsed.v });
-    }
-    return parsed.mqttState === "connected";
-}
-export function sessionLiveness(hqRoot, sessionId, opts = {}) {
-    const deps = opts.deps ?? defaultLivenessDeps();
-    const index = loadLivenessIndex(hqRoot, opts.spoolPath, deps);
-    const entry = index.sessions[sessionId];
-    const config = loadLanesConfig(hqRoot);
-    const windows = opts.windows ?? config.liveness;
-    if (!entry) {
-        return unindexedClaudeSessionLiveness(sessionId, opts.nowMs ?? deps.now(), windows, deps, Object.values(config.providers.claude.accounts).map((account) => effectiveAccountHome(account, deps.hostname?.()).home));
-    }
-    const presenceConnected = opts.presenceConnected ?? readDaemonPresenceConnected(deps);
-    return classifySessionLiveness(entry, opts.nowMs ?? deps.now(), presenceConnected, windows);
-}
-export function listSessionLiveness(hqRoot, opts = {}) {
-    const deps = opts.deps ?? defaultLivenessDeps();
-    const index = loadLivenessIndex(hqRoot, opts.spoolPath, deps);
-    const nowMs = opts.nowMs ?? deps.now();
-    const windows = opts.windows ?? loadLanesConfig(hqRoot).liveness;
-    const presenceConnected = opts.presenceConnected ?? readDaemonPresenceConnected(deps);
-    return Object.values(index.sessions).map((entry) => ({
-        sessionId: entry.sessionId,
-        state: classifySessionLiveness(entry, nowMs, presenceConnected, windows),
-        lastKind: entry.lastKind,
-        lastAt: entry.lastAt,
-    }));
-}
-//# sourceMappingURL=liveness.js.map

package/dist/lib/lanes/machine-identity.d.ts

@@ -1,34 +0,0 @@
-/**
- * Shared machine identity for Outpost self-target refusal (spec §5.2).
- *
- * One function, one fallback order, used by both the creating side
- * (`origin_host` stamp) and the executing side (setup-time compare).
- * EC2 instance id from IMDS, then hostname. Unresolvable is a status,
- * never a guessed id.
- *
- * Only Outpost lane create and Outpost lane setup may call this. A local
- * lane must not touch IMDS / the network.
- */
-export declare const IMDS_HOST = "169.254.169.254";
-export declare const IMDS_TOKEN_URL = "http://169.254.169.254/latest/api/token";
-export declare const IMDS_INSTANCE_ID_URL = "http://169.254.169.254/latest/meta-data/instance-id";
-export declare const IMDS_TIMEOUT_MS = 250;
-export type MachineIdentity = {
-    status: "ok";
-    id: string;
-    source: "imds" | "hostname";
-    imds?: string | null;
-    hostname?: string | null;
-} | {
-    status: "unresolvable";
-    reason: string;
-};
-export interface MachineIdentityDeps {
-    /** Returns the IMDS instance id, or null when IMDS is unavailable. */
-    readImdsInstanceId?: () => string | null;
-    hostname?: () => string;
-}
-/** IMDSv2 token then instance-id. Any failure is null, not a thrown guess. */
-export declare function defaultReadImdsInstanceId(): string | null;
-export declare function resolveMachineIdentity(deps?: MachineIdentityDeps): MachineIdentity;
-//# sourceMappingURL=machine-identity.d.ts.map

package/dist/lib/lanes/machine-identity.js

@@ -1,92 +0,0 @@
-/**
- * Shared machine identity for Outpost self-target refusal (spec §5.2).
- *
- * One function, one fallback order, used by both the creating side
- * (`origin_host` stamp) and the executing side (setup-time compare).
- * EC2 instance id from IMDS, then hostname. Unresolvable is a status,
- * never a guessed id.
- *
- * Only Outpost lane create and Outpost lane setup may call this. A local
- * lane must not touch IMDS / the network.
- */
-import { spawnSync } from "node:child_process";
-import * as os from "node:os";
-export const IMDS_HOST = "169.254.169.254";
-export const IMDS_TOKEN_URL = `http://${IMDS_HOST}/latest/api/token`;
-export const IMDS_INSTANCE_ID_URL = `http://${IMDS_HOST}/latest/meta-data/instance-id`;
-export const IMDS_TIMEOUT_MS = 250;
-function curlImds(method, url, headers) {
-    const args = ["-sS", "-f", "-m", "1", "-X", method];
-    for (const [key, value] of Object.entries(headers)) {
-        args.push("-H", `${key}: ${value}`);
-    }
-    args.push(url);
-    try {
-        const result = spawnSync("curl", args, {
-            encoding: "utf8",
-            timeout: IMDS_TIMEOUT_MS,
-        });
-        if (result.error || result.status !== 0)
-            return null;
-        const body = (result.stdout ?? "").trim();
-        return body.length > 0 ? body : null;
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes: IMDS request failed for ${url}: ${err instanceof Error ? err.message : String(err)}\n`);
-        return null;
-    }
-}
-/** IMDSv2 token then instance-id. Any failure is null, not a thrown guess. */
-export function defaultReadImdsInstanceId() {
-    const token = curlImds("PUT", IMDS_TOKEN_URL, {
-        "X-aws-ec2-metadata-token-ttl-seconds": "60",
-    });
-    if (!token)
-        return null;
-    return curlImds("GET", IMDS_INSTANCE_ID_URL, {
-        "X-aws-ec2-metadata-token": token,
-    });
-}
-export function resolveMachineIdentity(deps = {}) {
-    const readImds = deps.readImdsInstanceId ?? defaultReadImdsInstanceId;
-    let imdsId = null;
-    try {
-        const raw = readImds();
-        imdsId = typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes: IMDS identity lookup failed: ${err instanceof Error ? err.message : String(err)}\n`);
-    }
-    let hostname = null;
-    try {
-        const hostnameFn = deps.hostname ?? (() => os.hostname());
-        const host = hostnameFn();
-        hostname = typeof host === "string" && host.trim() !== "" ? host.trim() : null;
-    }
-    catch (err) {
-        process.stderr.write(`hq lanes: hostname identity lookup failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        if (!imdsId) {
-            return {
-                status: "unresolvable",
-                reason: err instanceof Error ? err.message : String(err),
-            };
-        }
-    }
-    if (imdsId) {
-        return { status: "ok", id: imdsId, source: "imds", imds: imdsId, hostname };
-    }
-    if (hostname) {
-        return {
-            status: "ok",
-            id: hostname,
-            source: "hostname",
-            imds: null,
-            hostname,
-        };
-    }
-    return {
-        status: "unresolvable",
-        reason: "IMDS unavailable and hostname empty",
-    };
-}
-//# sourceMappingURL=machine-identity.js.map

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

@@ -1,17 +0,0 @@
-import type { LaneRecord, ManagerStatusGate } from "./types.js";
-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;
-}
-/** Resolve manager identity and the single declared status file, if present. */
-export declare function resolveManagerStatusTarget(root: string, lane: LaneRecord): ManagerStatusTarget;
-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

package/dist/lib/lanes/manager-status-gate.js

@@ -1,133 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { checkCompanyPath } from "./checked-company-path.js";
-import { LanesError } from "./errors.js";
-import { resolveLaneCompany } from "./lane-company.js";
-function isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function invalidMapping(message, filePath, details = {}) {
-    throw new LanesError("manager_status_mapping_invalid", message, { path: filePath, ...details });
-}
-function readJuniors(root) {
-    const filePath = path.join(root, "workspace", "lane-briefs", "juniors.json");
-    let raw;
-    try {
-        const stat = fs.lstatSync(filePath);
-        if (!stat.isFile() || stat.isSymbolicLink())
-            invalidMapping("juniors.json must be a regular file", filePath);
-        raw = fs.readFileSync(filePath, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return { filePath, rows: [] };
-        if (err instanceof LanesError)
-            throw err;
-        throw new LanesError("manager_status_mapping_unreadable", `Cannot read manager mapping ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        invalidMapping("juniors.json contains invalid JSON", filePath);
-    }
-    if (!isObject(parsed) || !Array.isArray(parsed.juniors))
-        invalidMapping("juniors.json must contain a juniors array", filePath);
-    const rows = [];
-    for (const [index, row] of parsed.juniors.entries()) {
-        if (!isObject(row))
-            invalidMapping(`juniors[${index}] must be an object`, filePath, { index });
-        rows.push(row);
-    }
-    return { filePath, rows };
-}
-function matchesLane(rowLane, laneId) {
-    const row = rowLane.trim();
-    const bareLaneId = laneId.split("_", 1)[0] ?? "";
-    return row === laneId || row === bareLaneId;
-}
-/** Resolve manager identity and the single declared status file, if present. */
-export function resolveManagerStatusTarget(root, lane) {
-    const directIdentity = lane.story_id === "MANAGER"
-        ? "story_id"
-        : lane.worker_profile?.endsWith("-manager") === true
-            ? "worker_profile"
-            : undefined;
-    const registry = readJuniors(root);
-    const matches = [];
-    for (const [index, row] of registry.rows.entries()) {
-        if (typeof row.lane !== "string")
-            invalidMapping(`juniors[${index}].lane must be a string`, registry.filePath, { index });
-        if (matchesLane(row.lane, lane.lane_id))
-            matches.push(row);
-    }
-    if (matches.length > 1)
-        invalidMapping("More than one juniors row maps to this manager lane", registry.filePath, { lane_id: lane.lane_id });
-    const row = matches[0];
-    if (row === undefined) {
-        return directIdentity
-            ? { manager: true, identified_by: directIdentity, skipped: "no_juniors_row" }
-            : { manager: false };
-    }
-    for (const field of ["team", "lane", "host", "status", "prd"]) {
-        if (typeof row[field] !== "string" || row[field].trim() === "") {
-            invalidMapping(`Matched juniors row needs a non-empty ${field}`, registry.filePath, { lane_id: lane.lane_id, field });
-        }
-    }
-    const company = resolveLaneCompany(root, lane).company?.slug ?? "";
-    const statusPath = checkCompanyPath(root, company, row.status, registry.filePath);
-    return {
-        manager: true,
-        identified_by: directIdentity ?? "juniors",
-        statusPath,
-    };
-}
-export function readStatusSnapshot(filePath) {
-    let stat;
-    try {
-        stat = fs.statSync(filePath);
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return { mtime: null, updatedAt: null };
-        throw new LanesError("manager_status_unreadable", `Cannot stat manager status ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
-    }
-    if (!stat.isFile())
-        throw new LanesError("manager_status_invalid", `Manager status path is not a file: ${filePath}`, { path: filePath });
-    let updatedAt = null;
-    try {
-        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-        if (isObject(parsed) && typeof parsed.updated_at === "string")
-            updatedAt = parsed.updated_at;
-    }
-    catch (err) {
-        if (!(err instanceof SyntaxError)) {
-            if (err.code === "ENOENT")
-                return { mtime: null, updatedAt: null };
-            throw new LanesError("manager_status_unreadable", `Cannot read manager status ${filePath}: ${err instanceof Error ? err.message : String(err)}`, { path: filePath });
-        }
-    }
-    return { mtime: stat.mtimeMs, updatedAt };
-}
-export function managerStatusGateHeartbeat(root, lane, turnId, turnStartedAt) {
-    resolveLaneCompany(root, lane);
-    const target = resolveManagerStatusTarget(root, lane);
-    if (!target.manager || target.statusPath === undefined)
-        return undefined;
-    const snapshot = readStatusSnapshot(target.statusPath);
-    return {
-        turn_started_at: turnStartedAt,
-        status_mtime_at_start: snapshot.mtime,
-        status_updated_at_at_start: snapshot.updatedAt,
-        status_path: target.statusPath,
-        turn_id: turnId,
-        consecutive_misses: lane.status_gate?.consecutive_misses ?? 0,
-    };
-}
-export function managerStatusWasWritten(gate, snapshot) {
-    const startedAt = Date.parse(gate.turn_started_at);
-    return ((snapshot.mtime !== null && Number.isFinite(startedAt) && snapshot.mtime > startedAt) ||
-        snapshot.updatedAt !== gate.status_updated_at_at_start);
-}
-//# sourceMappingURL=manager-status-gate.js.map

package/dist/lib/lanes/merge-command.d.ts

@@ -1,15 +0,0 @@
-export interface MergeCommandTarget {
-    kind: "pr" | "api" | "graphql" | "git";
-    repo: string | null;
-    pr: number | null;
-    pinnedHead: string | null;
-    unresolvedReason: string | null;
-}
-export interface MergeCommandParseResult {
-    targets: MergeCommandTarget[];
-    unresolved: boolean;
-    unparseableMerge: boolean;
-}
-export declare function canonicalRepo(raw: string): string;
-export declare function parseMergeCommands(command: string): MergeCommandParseResult;
-//# sourceMappingURL=merge-command.d.ts.map