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

package/dist/lib/lanes/orphans.js

@@ -1,6 +1,7 @@
 import { LanesError } from "./errors.js";
 import { isTerminalLaneState } from "./types.js";
 export const DEFAULT_ORPHAN_MIN_AGE_MINUTES = 30;
+export const DEFAULT_ORPHAN_USER_IDLE_HOURS = 72;
 const LIVE_LANE_STATES = new Set(["running", "queued", "blocked", "awaiting_input"]);
 export function parseOrphanMinAge(value) {
     if (value === undefined)
@@ -14,6 +15,18 @@ export function parseOrphanMinAge(value) {
     }
     return minutes;
 }
+export function parseOrphanUserIdleHours(value) {
+    if (value === undefined)
+        return DEFAULT_ORPHAN_USER_IDLE_HOURS;
+    if (!/^(0|[1-9]\d*)$/.test(value)) {
+        throw new LanesError("orphan_user_idle_hours_invalid", "User-senior idle hours must be a non-negative whole number", { value });
+    }
+    const hours = Number(value);
+    if (!Number.isSafeInteger(hours) || hours > Math.floor(Number.MAX_SAFE_INTEGER / 3_600_000)) {
+        throw new LanesError("orphan_user_idle_hours_invalid", "User-senior idle hours are outside the supported range", { value });
+    }
+    return hours;
+}
 export function findOrphanLanes(input) {
     const nowMs = input.now.getTime();
     if (!Number.isFinite(nowMs)) {
@@ -21,12 +34,24 @@ export function findOrphanLanes(input) {
     }
     const byId = new Map(input.lanes.map((lane) => [lane.lane_id, lane]));
     const minAgeMs = input.minAgeMinutes * 60_000;
+    const userIdleMs = input.userIdleHours * 3_600_000;
     const findings = [];
     for (const lane of input.lanes) {
+        if (!input.candidateLaneIds.has(lane.lane_id))
+            continue;
         if (!LIVE_LANE_STATES.has(lane.state))
             continue;
-        if (lane.keep_alive_standing === true || lane.senior.kind === "user")
+        if (lane.keep_alive_standing === true)
             continue;
+        let userLastActivity;
+        if (lane.senior.kind === "user") {
+            userLastActivity = input.lastActivityAt(lane);
+            if (!Number.isFinite(userLastActivity)) {
+                throw new LanesError("orphan_lane_timestamp_invalid", `Lane ${lane.lane_id} has an invalid last activity timestamp`, { lane_id: lane.lane_id, field: "last_activity" });
+            }
+            if (userLastActivity > nowMs || nowMs - userLastActivity < userIdleMs || input.hasOpenStory(lane))
+                continue;
+        }
         const createdAt = Date.parse(lane.created_at);
         if (!Number.isFinite(createdAt)) {
             throw new LanesError("orphan_lane_timestamp_invalid", `Lane ${lane.lane_id} has an invalid created_at timestamp`, { lane_id: lane.lane_id, field: "created_at" });
@@ -38,20 +63,29 @@ export function findOrphanLanes(input) {
         if (ageMs < minAgeMs)
             continue;
         let seniorState;
-        if (lane.senior.kind === "lane") {
+        let reason;
+        if (lane.senior.kind === "user") {
+            seniorState = "user_idle";
+            reason = "user_idle";
+        }
+        else if (lane.senior.kind === "lane") {
             const senior = byId.get(lane.senior.id ?? "");
             if (!senior) {
                 seniorState = "missing";
+                reason = "senior_missing";
             }
             else if (isTerminalLaneState(senior.state)) {
                 seniorState = senior.state;
+                reason = "senior_ended";
             }
         }
         else if (lane.senior.kind === "session" && lane.senior.id !== undefined) {
-            if (input.sessionState(lane.senior.id, input.now) === "ended")
+            if (input.sessionState(lane.senior.id, input.now) === "ended") {
                 seniorState = "ended";
+                reason = "senior_ended";
+            }
         }
-        if (seniorState === undefined)
+        if (seniorState === undefined || reason === undefined)
             continue;
         findings.push({
             lane_id: lane.lane_id,
@@ -60,6 +94,7 @@ export function findOrphanLanes(input) {
             age_minutes: Math.floor(ageMs / 60_000),
             account: lane.account ?? null,
             host: { ...lane.host },
+            reason,
         });
     }
     return findings.sort((a, b) => b.age_minutes - a.age_minutes || a.lane_id.localeCompare(b.lane_id));

package/dist/lib/lanes/tracker-store.d.ts

@@ -10,25 +10,9 @@ export interface TrackerRecord {
     updated_at: string;
     [key: string]: unknown;
 }
-export interface TrackerRecordInput {
-    kind: TrackerKind;
-    id?: string;
-    company: string;
-    project_id: string;
-    [key: string]: unknown;
-}
-export type StoreValue<T> = T | Promise<T>;
-export interface TrackerStore {
-    read(kind: TrackerKind, id: string): StoreValue<TrackerRecord | null>;
-    list(kind: TrackerKind): StoreValue<TrackerRecord[]>;
-    create(record: TrackerRecordInput): StoreValue<TrackerRecord>;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): StoreValue<TrackerRecord>;
-}
-export interface LocalTrackerStore extends TrackerStore {
+export interface LocalTrackerStore {
     read(kind: TrackerKind, id: string): TrackerRecord | null;
     list(kind: TrackerKind): TrackerRecord[];
-    create(record: TrackerRecordInput): TrackerRecord;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): TrackerRecord;
 }
-export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): LocalTrackerStore;
+export declare function createLocalTrackerStore(projectDirectory: string): LocalTrackerStore;
 //# sourceMappingURL=tracker-store.d.ts.map

package/dist/lib/lanes/tracker-store.js

@@ -1,6 +1,5 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { randomUUID } from "node:crypto";
 import { LanesError } from "./errors.js";
 const KIND_SET = new Set(["blocker", "kpi", "okr", "directive"]);
 const ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
@@ -18,25 +17,6 @@ function recordPath(root, kind, id) {
         throw storeError("tracker_kind_invalid", "Unknown tracker record kind", { kind });
     return path.join(root, kind, `${id}.json`);
 }
-function assertRealDirectory(directory) {
-    try {
-        const stat = fs.lstatSync(directory);
-        if (!stat.isDirectory() || stat.isSymbolicLink()) {
-            throw storeError("tracker_store_path_invalid", "Tracker storage path must be a real directory", { path: directory });
-        }
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-        fs.mkdirSync(directory, { mode: 0o700 });
-    }
-}
-function ensureKindDirectory(root, kind) {
-    assertRealDirectory(root);
-    const directory = path.join(root, kind);
-    assertRealDirectory(directory);
-    return directory;
-}
 function existingKindDirectory(root, kind) {
     try {
         const rootStat = fs.lstatSync(root);
@@ -86,105 +66,7 @@ function parseRecord(text, expectedKind, id, file) {
     }
     return record;
 }
-function writeExclusive(file, contents) {
-    const dir = path.dirname(file);
-    const temp = path.join(dir, `.${path.basename(file)}.${randomUUID()}.tmp`);
-    try {
-        fs.writeFileSync(temp, contents, { encoding: "utf8", flag: "wx", mode: 0o600 });
-        // link is an atomic create-if-absent operation; rename would overwrite a
-        // concurrent creator's record if a generated id ever collided.
-        fs.linkSync(temp, file);
-    }
-    catch (err) {
-        if (err.code === "EEXIST") {
-            throw storeError("tracker_record_exists", "Tracker record id already exists", { path: file });
-        }
-        throw err;
-    }
-    finally {
-        removeTempFile(temp);
-    }
-}
-function removeTempFile(file) {
-    try {
-        fs.unlinkSync(file);
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-    }
-}
-function withRecordLock(file, action) {
-    const lock = `${file}.lock`;
-    let fd;
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-        try {
-            fd = fs.openSync(lock, "wx", 0o600);
-            fs.writeSync(fd, `${process.pid}\n`);
-            break;
-        }
-        catch (err) {
-            if (err.code !== "EEXIST")
-                throw err;
-            // Recover a lock only when it is old and its owner is gone. Rechecking
-            // inode and mtime before unlinking avoids deleting a freshly replaced lock.
-            let first;
-            try {
-                first = fs.lstatSync(lock);
-            }
-            catch (statError) {
-                if (statError.code === "ENOENT")
-                    continue;
-                throw statError;
-            }
-            if (Date.now() - first.mtimeMs < 5 * 60_000) {
-                throw storeError("tracker_write_busy", "Tracker record is being updated; retry the command", { path: file });
-            }
-            let owner = null;
-            try {
-                const raw = fs.readFileSync(lock, "utf8").trim();
-                const parsed = Number(raw);
-                if (Number.isSafeInteger(parsed) && parsed > 0)
-                    owner = parsed;
-            }
-            catch (readError) {
-                if (readError.code !== "ENOENT")
-                    throw readError;
-            }
-            if (owner !== null) {
-                try {
-                    process.kill(owner, 0);
-                    throw storeError("tracker_write_busy", "Tracker record is being updated; retry the command", { path: file });
-                }
-                catch (probeError) {
-                    if (probeError instanceof LanesError)
-                        throw probeError;
-                    if (probeError.code !== "ESRCH")
-                        throw probeError;
-                }
-            }
-            try {
-                const second = fs.lstatSync(lock);
-                if (second.ino === first.ino && second.dev === first.dev && second.mtimeMs === first.mtimeMs)
-                    fs.unlinkSync(lock);
-            }
-            catch (unlinkError) {
-                if (unlinkError.code !== "ENOENT")
-                    throw unlinkError;
-            }
-        }
-    }
-    if (fd === undefined)
-        throw storeError("tracker_write_busy", "Tracker record is being updated; retry the command", { path: file });
-    try {
-        return action();
-    }
-    finally {
-        fs.closeSync(fd);
-        fs.unlinkSync(lock);
-    }
-}
-export function createLocalTrackerStore(projectDirectory, now = () => new Date()) {
+export function createLocalTrackerStore(projectDirectory) {
     const root = path.join(projectDirectory, "tracker");
     const read = (kind, id) => {
         const file = recordPath(root, kind, id);
@@ -219,59 +101,6 @@ export function createLocalTrackerStore(projectDirectory, now = () => new Date()
                 .filter((record) => record !== null)
                 .sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
         },
-        create(input) {
-            const kind = input.kind;
-            const directory = ensureKindDirectory(root, kind);
-            const id = typeof input.id === "string" && input.id ? input.id : randomUUID();
-            const time = now().toISOString();
-            const record = {
-                ...input,
-                schema_version: "hq-lanes-tracker-record.v1",
-                kind,
-                id,
-                company: input.company,
-                project_id: input.project_id,
-                version: 1,
-                created_at: time,
-                updated_at: time,
-            };
-            writeExclusive(path.join(directory, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`);
-            return record;
-        },
-        update(kind, id, expectedVersion, change) {
-            const file = recordPath(root, kind, id);
-            const directory = ensureKindDirectory(root, kind);
-            return withRecordLock(file, () => {
-                const current = read(kind, id);
-                if (!current)
-                    throw storeError("tracker_record_not_found", `Tracker ${kind} record ${id} was not found`, { kind, id });
-                if (current.version !== expectedVersion) {
-                    throw storeError("tracker_version_conflict", `Tracker record version conflict: expected ${expectedVersion}, found ${current.version}`, {
-                        kind, id, expected: expectedVersion, actual: current.version,
-                    });
-                }
-                const changed = change(current);
-                if (changed.id !== current.id || changed.kind !== current.kind || changed.company !== current.company || changed.project_id !== current.project_id || changed.created_at !== current.created_at) {
-                    throw storeError("tracker_update_invalid", "Tracker update cannot change record identity", { kind, id });
-                }
-                const next = {
-                    ...changed,
-                    schema_version: "hq-lanes-tracker-record.v1",
-                    version: current.version + 1,
-                    created_at: current.created_at,
-                    updated_at: now().toISOString(),
-                };
-                const temp = path.join(directory, `.${id}.${randomUUID()}.tmp`);
-                try {
-                    fs.writeFileSync(temp, `${JSON.stringify(next, null, 2)}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
-                    fs.renameSync(temp, file);
-                }
-                finally {
-                    removeTempFile(temp);
-                }
-                return next;
-            });
-        },
     };
 }
 //# sourceMappingURL=tracker-store.js.map

package/dist/lib/scaffold-cli-floor.d.ts

@@ -0,0 +1,9 @@
+export declare const SCAFFOLD_CLI_UPGRADE_COMMAND = "npm install -g @indigoai-us/hq-cli@latest";
+export type ScaffoldCliFloorComparison = {
+    status: "pass" | "fail" | "warn" | "skip";
+    message: string;
+    remediation?: string;
+};
+/** Compare an installed CLI version with the scaffold's supported floor. */
+export declare function compareScaffoldCliFloor(required: unknown, currentVersion: string): ScaffoldCliFloorComparison;
+//# sourceMappingURL=scaffold-cli-floor.d.ts.map

package/dist/lib/scaffold-cli-floor.js

@@ -0,0 +1,50 @@
+import semver from "semver";
+export const SCAFFOLD_CLI_UPGRADE_COMMAND = "npm install -g @indigoai-us/hq-cli@latest";
+const MINIMUM_VERSION_RANGE = /^>=(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+/** Compare an installed CLI version with the scaffold's supported floor. */
+export function compareScaffoldCliFloor(required, currentVersion) {
+    if (required === undefined) {
+        return {
+            status: "skip",
+            message: "No requiresHqCli floor is declared.",
+        };
+    }
+    const renderedRequired = renderValue(required);
+    if (typeof required !== "string" ||
+        !MINIMUM_VERSION_RANGE.test(required) ||
+        !semver.validRange(required)) {
+        return {
+            status: "warn",
+            message: `requiresHqCli has unsupported value ${renderedRequired}; expected a range in the form \">=X.Y.Z\".`,
+        };
+    }
+    if (!semver.valid(currentVersion)) {
+        return {
+            status: "warn",
+            message: `The running hq-cli version ${renderValue(currentVersion)} is not valid SemVer, so the scaffold CLI floor could not be checked.`,
+        };
+    }
+    if (semver.satisfies(currentVersion, required, { includePrerelease: true })) {
+        return {
+            status: "pass",
+            message: `hq-cli ${currentVersion} satisfies the scaffold requirement ${required}.`,
+        };
+    }
+    const minimum = required.slice(2);
+    return {
+        status: "fail",
+        message: `This scaffold requires hq-cli >= ${minimum} (found ${currentVersion}).`,
+        remediation: SCAFFOLD_CLI_UPGRADE_COMMAND,
+    };
+}
+function renderValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+//# sourceMappingURL=scaffold-cli-floor.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.273.0-alpha.0",
+  "version": "5.273.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -44,7 +44,7 @@
   "dependencies": {
     "@aws-sdk/client-iot-data-plane": "^3.1096.0",
     "@aws-sdk/client-s3": "^3.1049.0",
-    "@indigoai-us/hq-cloud": "~6.18.13",
+    "@indigoai-us/hq-cloud": "~6.18.10",
     "@indigoai-us/hq-flags-client": "^0.1.2",
     "@sentry/node": "^10.49.0",
     "@tobilu/qmd": "2.5.3",

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

@@ -1,14 +0,0 @@
-import type { Command } from "commander";
-import { type TrackerStore } from "../lib/lanes/tracker-store.js";
-import type { LaneCompanyRef } from "../lib/lanes/types.js";
-type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
-export interface LaneTrackerImportDeps {
-    hqRoot: () => string;
-    resolveCompany: (company?: string) => Promise<LaneCompanyRef>;
-    trackerEnabled: (company: LaneCompanyRef) => boolean | Promise<boolean>;
-    now: () => Date;
-    store?: (projectDirectory: string) => TrackerStore;
-}
-export declare function registerLaneTrackerImportCommand(parent: Command, deps: LaneTrackerImportDeps, wrap: WrapHandler): void;
-export {};
-//# sourceMappingURL=lanes-import.d.ts.map