@indigoai-us/hq-cli 5.293.0 → 5.294.0

package/dist/lib/lanes/autopilot-metrics.js

@@ -0,0 +1,301 @@
+import { isTerminalLaneState } from "./types.js";
+const MINUTE_MS = 60_000;
+const CLOSED_STORY_STATES = new Set(["done", "dropped"]);
+function timestamp(value) {
+    if (typeof value !== "string")
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function round(value) {
+    return Math.round((value + Number.EPSILON) * 100) / 100;
+}
+function dayKey(at) {
+    return new Date(at).toISOString().slice(0, 10);
+}
+function utcDays(since, until) {
+    const days = [];
+    let current = Date.UTC(new Date(since).getUTCFullYear(), new Date(since).getUTCMonth(), new Date(since).getUTCDate());
+    const last = Date.UTC(new Date(until).getUTCFullYear(), new Date(until).getUTCMonth(), new Date(until).getUTCDate());
+    while (current <= last) {
+        days.push(new Date(current).toISOString().slice(0, 10));
+        current += 24 * 60 * MINUTE_MS;
+    }
+    return days;
+}
+function storyState(story) {
+    return typeof story.state === "string" ? story.state : typeof story.status === "string" ? story.status : undefined;
+}
+function storyPrReferences(story) {
+    const refs = [...(story.prs ?? [])];
+    if (!Array.isArray(story.lanes))
+        return refs;
+    for (const entry of story.lanes) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const record = entry;
+        if (Array.isArray(record.prs))
+            refs.push(...record.prs);
+        if (Array.isArray(record.history)) {
+            for (const historyEntry of record.history) {
+                if (historyEntry && typeof historyEntry === "object" && !Array.isArray(historyEntry)) {
+                    const prs = historyEntry.prs;
+                    if (Array.isArray(prs))
+                        refs.push(...prs);
+                }
+            }
+        }
+    }
+    return refs;
+}
+function prReferenceMatches(value, review) {
+    if (typeof value === "number")
+        return value === review.pr;
+    if (typeof value !== "string") {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return false;
+        const record = value;
+        if (record.number === review.pr)
+            return true;
+        return [record.url, record.html_url, record.ref].some((ref) => prReferenceMatches(ref, review));
+    }
+    const text = value.trim();
+    if (text === `#${review.pr}` || text === String(review.pr))
+        return true;
+    const pull = text.match(/^https?:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)(?:\/|$)/i);
+    return pull !== null && pull[1]?.toLowerCase() === review.repo.toLowerCase() && Number(pull[2]) === review.pr;
+}
+function reviewMatchesLane(review, lane, story) {
+    if (review.worker_lane !== undefined && review.worker_lane !== null)
+        return review.worker_lane === lane.lane_id;
+    return [...(story ? storyPrReferences(story) : []), ...(lane.last_envelope?.artifacts ?? [])]
+        .some((ref) => prReferenceMatches(ref, review));
+}
+function matchingStory(project, storyId) {
+    return project?.stories.find((story) => story.id === storyId);
+}
+function stateAtHistoryEntry(entry) {
+    return typeof entry.state === "string" ? entry.state : undefined;
+}
+function storyLaneHistory(story, laneId) {
+    if (!story || !Array.isArray(story.lanes))
+        return [];
+    for (const value of story.lanes) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            continue;
+        const entry = value;
+        if (entry.lane_id === laneId && Array.isArray(entry.history)) {
+            return entry.history.filter((history) => history !== null && typeof history === "object" && !Array.isArray(history));
+        }
+    }
+    return [];
+}
+function laneTerminalAt(lane) {
+    const ended = timestamp(lane.ended_at);
+    if (ended !== null)
+        return ended;
+    const envelopeAt = timestamp(lane.last_envelope?.at);
+    if (envelopeAt !== null)
+        return envelopeAt;
+    return isTerminalLaneState(lane.state) ? timestamp(lane.updated_at) : null;
+}
+function reviewCandidates(input, lead, lane, story) {
+    const candidates = [];
+    for (const review of input.reviews) {
+        const at = timestamp(review.recorded_at);
+        if (at !== null && reviewMatchesLane(review, lane, story))
+            candidates.push({ at, event: "review_record" });
+    }
+    for (const resume of input.seniorResumes) {
+        const at = timestamp(resume.at);
+        if (resume.lane_id === lead.lane_id && at !== null)
+            candidates.push({ at, event: "senior_resume" });
+    }
+    if (story && CLOSED_STORY_STATES.has(storyState(story) ?? "")) {
+        const at = timestamp(story.updated_at);
+        if (at !== null)
+            candidates.push({ at, event: "story_closed" });
+    }
+    return candidates;
+}
+function idleIntervalsForLane(lane, story, until) {
+    const created = timestamp(lane.created_at);
+    if (created === null)
+        return [];
+    const history = storyLaneHistory(story, lane.lane_id)
+        .map((entry) => ({ at: timestamp(typeof entry.at === "string" ? entry.at : undefined), state: stateAtHistoryEntry(entry), terminal: entry.terminal === true }))
+        .filter((entry) => entry.at !== null && entry.at >= created)
+        .sort((a, b) => a.at - b.at);
+    if (history.length === 0) {
+        const terminal = isTerminalLaneState(lane.state);
+        const ended = timestamp(lane.ended_at) ?? (terminal ? timestamp(lane.last_envelope?.at) ?? timestamp(lane.updated_at) : null) ?? until;
+        return ended > created ? [{ start: created, end: Math.min(ended, until) }] : [];
+    }
+    const intervals = [];
+    let active = true;
+    let start = created;
+    for (const event of history) {
+        const isTerminal = event.terminal || (event.state !== undefined && isTerminalLaneState(event.state));
+        if (isTerminal && active) {
+            if (event.at > start)
+                intervals.push({ start, end: event.at });
+            active = false;
+        }
+        else if (!isTerminal && !active) {
+            start = event.at;
+            active = true;
+        }
+    }
+    if (active) {
+        const terminal = isTerminalLaneState(lane.state);
+        const ended = timestamp(lane.ended_at) ?? (terminal ? timestamp(lane.last_envelope?.at) ?? timestamp(lane.updated_at) : null) ?? until;
+        if (ended > start)
+            intervals.push({ start, end: Math.min(ended, until) });
+    }
+    return intervals;
+}
+function overlaps(interval, start, end) {
+    return interval.start <= start && interval.end >= end;
+}
+function readyStoryIntervals(story, until) {
+    const created = timestamp(story.created_at);
+    const updated = timestamp(story.updated_at);
+    const state = storyState(story);
+    if (state === "todo") {
+        const start = updated ?? created;
+        return start !== null && start < until ? [{ start, end: until }] : [];
+    }
+    if (created !== null && updated !== null && updated > created)
+        return [{ start: created, end: updated }];
+    return [];
+}
+function idleSlotMinutes(input, lead, leadLane, project, children, start, end) {
+    if (!leadLane || project === undefined)
+        return 0;
+    const grant = Math.max(0, leadLane.hire_grant ?? 0);
+    if (grant === 0)
+        return 0;
+    const readyIntervals = project.stories.flatMap((story) => readyStoryIntervals(story, end));
+    if (readyIntervals.length === 0)
+        return 0;
+    const leadStory = matchingStory(project, leadLane.story_id);
+    const leadIntervals = idleIntervalsForLane(leadLane, leadStory, end);
+    if (leadIntervals.length === 0)
+        return 0;
+    const childIntervals = children.flatMap((child) => {
+        const story = matchingStory(project, child.story_id);
+        return idleIntervalsForLane(child, story, end);
+    });
+    const boundaries = new Set([start, end]);
+    for (const interval of [...childIntervals, ...readyIntervals, ...leadIntervals]) {
+        if (interval.start > start && interval.start < end)
+            boundaries.add(interval.start);
+        if (interval.end > start && interval.end < end)
+            boundaries.add(interval.end);
+    }
+    const sorted = [...boundaries].sort((a, b) => a - b);
+    let total = 0;
+    for (let index = 0; index < sorted.length - 1; index += 1) {
+        const segmentStart = sorted[index];
+        const segmentEnd = sorted[index + 1];
+        if (segmentStart === undefined || segmentEnd === undefined || segmentEnd <= segmentStart)
+            continue;
+        if (!readyIntervals.some((interval) => overlaps(interval, segmentStart, segmentEnd)))
+            continue;
+        if (!leadIntervals.some((interval) => overlaps(interval, segmentStart, segmentEnd)))
+            continue;
+        const live = childIntervals.filter((interval) => overlaps(interval, segmentStart, segmentEnd)).length;
+        total += Math.max(0, grant - live) * (segmentEnd - segmentStart) / MINUTE_MS;
+    }
+    return round(total);
+}
+export function buildAutopilotMetricsReport(input) {
+    const since = timestamp(input.since);
+    const until = timestamp(input.until);
+    if (since === null || until === null || since >= until) {
+        throw new Error("autopilot_metrics_window_invalid: since and until must be valid timestamps with since before until");
+    }
+    const days = utcDays(since, until);
+    const rows = new Map();
+    for (const lead of input.leads) {
+        for (const day of days) {
+            rows.set(`${lead.team}\u0000${day}`, {
+                team: lead.team,
+                day,
+                operator_nudges: 0,
+                reviewed_lanes: 0,
+                review_latency_minutes_total: 0,
+                review_latency_minutes_average: null,
+                idle_slot_minutes_ready_work: 0,
+            });
+        }
+    }
+    for (const nudge of input.nudges) {
+        const at = timestamp(nudge.at);
+        if (at === null || at < since || at > until)
+            continue;
+        const row = rows.get(`${nudge.team}\u0000${dayKey(at)}`);
+        if (row)
+            row.operator_nudges += 1;
+    }
+    const projectById = new Map(input.projects.map((project) => [project.project_id, project]));
+    const reviewLatencies = [];
+    for (const lead of input.leads) {
+        const leadLane = input.lanes.find((lane) => lane.lane_id === lead.lane_id);
+        const project = projectById.get(lead.project_id);
+        const children = input.lanes.filter((lane) => lane.lane_id !== lead.lane_id && lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
+        for (const lane of children) {
+            const finishedAt = laneTerminalAt(lane);
+            if (finishedAt === null || finishedAt < since || finishedAt > until)
+                continue;
+            const story = matchingStory(project, lane.story_id);
+            const first = reviewCandidates(input, lead, lane, story)
+                .filter((event) => event.at >= finishedAt && event.at <= until)
+                .sort((a, b) => a.at - b.at)[0];
+            if (!first)
+                continue;
+            reviewLatencies.push({
+                team: lead.team,
+                lane_id: lane.lane_id,
+                story_id: lane.story_id,
+                finished_at: new Date(finishedAt).toISOString(),
+                reviewed_at: new Date(first.at).toISOString(),
+                minutes: round((first.at - finishedAt) / MINUTE_MS),
+                end_event: first.event,
+            });
+        }
+        for (const day of days) {
+            const dayStart = Math.max(since, Date.parse(`${day}T00:00:00.000Z`));
+            const dayEnd = Math.min(until, Date.parse(`${day}T00:00:00.000Z`) + 24 * 60 * MINUTE_MS);
+            const idle = idleSlotMinutes(input, lead, leadLane, project, children, dayStart, dayEnd);
+            const row = rows.get(`${lead.team}\u0000${day}`);
+            if (row)
+                row.idle_slot_minutes_ready_work = round(row.idle_slot_minutes_ready_work + idle);
+        }
+    }
+    for (const latency of reviewLatencies) {
+        const row = rows.get(`${latency.team}\u0000${dayKey(Date.parse(latency.finished_at))}`);
+        if (!row)
+            continue;
+        row.reviewed_lanes += 1;
+        row.review_latency_minutes_total = round(row.review_latency_minutes_total + latency.minutes);
+        row.review_latency_minutes_average = round(row.review_latency_minutes_total / row.reviewed_lanes);
+    }
+    const selectedTeams = new Set(input.leads.map((lead) => lead.team));
+    const nudgeDefects = input.nudgeDefects
+        .filter((defect) => {
+        if (!selectedTeams.has(defect.team))
+            return false;
+        const at = timestamp(defect.at);
+        return at !== null && at >= since && at <= until;
+    })
+        .map((defect) => ({ ...defect, wake: null }));
+    return {
+        since: new Date(since).toISOString(),
+        until: new Date(until).toISOString(),
+        days: [...rows.values()].sort((a, b) => a.day.localeCompare(b.day) || a.team.localeCompare(b.team)),
+        review_latencies: reviewLatencies.sort((a, b) => a.finished_at.localeCompare(b.finished_at) || a.lane_id.localeCompare(b.lane_id)),
+        nudge_defects: nudgeDefects,
+    };
+}
+//# sourceMappingURL=autopilot-metrics.js.map

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

@@ -7,6 +7,7 @@
  * compare-and-set on `version`. Histories are capped at 50 at the append site.
  */
 import * as fs from "node:fs";
+import { type OutpostIdentity } from "./admission-host.js";
 import { type AttributionHistoryEntry, type LaneRecord, type LaneWriter, type QuestionRecord, type RoutingHistoryEntry, type SeniorHistoryEntry } from "./types.js";
 export declare const LANES_STORE_REL: string;
 export declare const LANE_RECORDS_DIR = "lanes";
@@ -15,6 +16,7 @@ export declare const PENDING_INDEX_DIR: string;
 export interface StoreDeps {
     now: () => Date;
     hostname: () => string;
+    outpostIdentity: () => OutpostIdentity;
     mkdirSync: typeof fs.mkdirSync;
     readFileSync: typeof fs.readFileSync;
     writeFileSync: typeof fs.writeFileSync;

package/dist/lib/lanes/store.js

@@ -14,6 +14,7 @@ import semver from "semver";
 import { CLI_VERSION } from "../../cli-version.js";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
+import { readOutpostIdentity } from "./admission-host.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
 import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isQueuedReason, isLaneState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
 import { laneStories } from "./stories.js";
@@ -29,6 +30,7 @@ function defaultStoreDeps() {
     return {
         now: () => new Date(),
         hostname: () => os.hostname(),
+        outpostIdentity: () => readOutpostIdentity(),
         mkdirSync: fs.mkdirSync.bind(fs),
         readFileSync: fs.readFileSync.bind(fs),
         writeFileSync: fs.writeFileSync.bind(fs),
@@ -1238,9 +1240,36 @@ export function readAllLanes(hqRoot, deps = defaultStoreDeps()) {
         ...deps,
         conflictSidecarPathsFor: (recordPath) => sidecarsByRecord.get(path.basename(recordPath)) ?? [],
     };
-    return laneIds
-        .map((laneId) => readLane(hqRoot, laneId, indexedDeps))
-        .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
+    const records = [];
+    for (const laneId of laneIds) {
+        try {
+            records.push(readLane(hqRoot, laneId, indexedDeps));
+        }
+        catch (err) {
+            if (!(err instanceof LaneSchemaError))
+                throw err;
+            const filePath = laneRecordPath(hqRoot, laneId);
+            const raw = readJsonFile(filePath, indexedDeps);
+            const host = raw !== null && typeof raw === "object" && !Array.isArray(raw)
+                ? raw.host
+                : undefined;
+            const hostRecord = host !== null && typeof host === "object" && !Array.isArray(host)
+                ? host
+                : undefined;
+            const outpostId = hostRecord?.kind === "outpost" &&
+                typeof hostRecord.id === "string" && hostRecord.id.trim() !== ""
+                ? hostRecord.id
+                : undefined;
+            const identity = indexedDeps.outpostIdentity();
+            const isRemoteMirror = outpostId !== undefined && (identity.kind === "not_outpost" ||
+                (identity.kind === "id" && identity.id !== outpostId));
+            if (!isRemoteMirror)
+                throw err;
+            const field = typeof err.details.field === "string" ? err.details.field : "unknown_field";
+            process.stderr.write(`lanes store: skipping malformed mirrored lane ${laneId} field ${field}: ${err.message}\n`);
+        }
+    }
+    return records.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
         a.lane_id.localeCompare(b.lane_id));
 }
 export function tryReadQuestion(hqRoot, questionId, deps = defaultStoreDeps()) {

package/dist/native-fast-route.d.ts

@@ -1,5 +1,7 @@
 /** Default-off flag check for native entrypoint routes. */
 export declare function nativeFastRouteEnabled(argv: readonly string[], env?: NodeJS.ProcessEnv): Promise<boolean>;
 /** Reads a default-off fast-route gate from its local override or fresh snapshot. */
-export declare function fastFlagEnabled(flagKey: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
+export declare function fastFlagEnabled(flagKey: string, env?: NodeJS.ProcessEnv, options?: {
+    numericEnvironmentOverride?: boolean;
+}): Promise<boolean>;
 //# sourceMappingURL=native-fast-route.d.ts.map

package/dist/native-fast-route.js

@@ -8,8 +8,8 @@ export async function nativeFastRouteEnabled(argv, env = process.env) {
     return fastFlagEnabled(parsed.entry.flagKey, env);
 }
 /** Reads a default-off fast-route gate from its local override or fresh snapshot. */
-export async function fastFlagEnabled(flagKey, env = process.env) {
-    const override = nativeRouteOverride(flagKey, env);
+export async function fastFlagEnabled(flagKey, env = process.env, options = {}) {
+    const override = nativeRouteOverride(flagKey, env, options.numericEnvironmentOverride !== false);
     if (override !== null)
         return override;
     try {
@@ -29,15 +29,17 @@ export async function fastFlagEnabled(flagKey, env = process.env) {
     }
 }
 /** The route's documented CLI override also accepts the conventional 1/0. */
-function nativeRouteOverride(flagKey, env) {
+function nativeRouteOverride(flagKey, env, numericEnvironmentOverride) {
     const override = readLocalOverride(flagKey, env);
     if (override !== null)
         return override;
-    const raw = env[localOverrideEnvVar(flagKey)];
-    if (raw === "1")
-        return true;
-    if (raw === "0")
-        return false;
+    if (numericEnvironmentOverride) {
+        const raw = env[localOverrideEnvVar(flagKey)];
+        if (raw === "1")
+            return true;
+        if (raw === "0")
+            return false;
+    }
     return null;
 }
 //# sourceMappingURL=native-fast-route.js.map

package/dist/utils/contribution-table.d.ts

@@ -99,5 +99,5 @@ export declare const CONTRIBUTION_KEYS: ContributionKey[];
  */
 export declare function payloadFor(key: ContributionKey, item: string): string;
 /** Keys whose contributions are wired by a host symlink (skip `merge` rows). */
-export declare const SYMLINK_KEYS: ("workers" | "mcp" | "commands" | "hooks" | "skills" | "policies" | "knowledge" | "scripts")[];
+export declare const SYMLINK_KEYS: ("workers" | "mcp" | "commands" | "skills" | "knowledge" | "hooks" | "policies" | "scripts")[];
 //# sourceMappingURL=contribution-table.d.ts.map

package/dist/utils/fast-stream-errors.d.ts

@@ -0,0 +1,12 @@
+type ErrorEventStream = {
+    on: (event: "error", listener: (err: unknown) => void) => unknown;
+};
+export type FastStreamErrorDependencies = {
+    stdout: ErrorEventStream;
+    stderr: ErrorEventStream;
+    exit: (code: number) => void;
+};
+/** Match the full CLI's clean handling when a pipe consumer closes early. */
+export declare function installFastPathStreamErrorHandlers(deps?: FastStreamErrorDependencies): void;
+export {};
+//# sourceMappingURL=fast-stream-errors.d.ts.map

package/dist/utils/fast-stream-errors.js

@@ -0,0 +1,18 @@
+import { isEpipe } from "./epipe.js";
+/** Match the full CLI's clean handling when a pipe consumer closes early. */
+export function installFastPathStreamErrorHandlers(deps = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+    exit: (code) => process.exit(code),
+}) {
+    const handle = (err) => {
+        if (isEpipe(err)) {
+            deps.exit(0);
+            return;
+        }
+        throw err;
+    };
+    deps.stdout.on("error", handle);
+    deps.stderr.on("error", handle);
+}
+//# sourceMappingURL=fast-stream-errors.js.map

package/dist/utils/scaffold-fast-import-guard.d.ts

@@ -1,3 +1,3 @@
-export declare function forbiddenFastPathModules(loadedModules: readonly string[], distDirectory: string): string[];
-export declare function assertFastPathStaysCommandGraphFree(loadedModules: readonly string[], distDirectory: string): void;
+export declare function forbiddenFastPathModules(loadedModules: readonly string[], distDirectory: string, allowedCommandModules?: readonly string[]): string[];
+export declare function assertFastPathStaysCommandGraphFree(loadedModules: readonly string[], distDirectory: string, allowedCommandModules?: readonly string[]): void;
 //# sourceMappingURL=scaffold-fast-import-guard.d.ts.map

package/dist/utils/scaffold-fast-import-guard.js

@@ -1,11 +1,12 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-export function forbiddenFastPathModules(loadedModules, distDirectory) {
+export function forbiddenFastPathModules(loadedModules, distDirectory, allowedCommandModules = []) {
     const dist = path.resolve(distDirectory);
     const main = path.join(dist, "main.js");
     const commands = `${path.join(dist, "commands")}${path.sep}`;
     const flagRegistry = path.join(dist, "lib", "flag-registry.js");
     const coreCommand = path.join(dist, "commands", "core.js");
+    const allowedCommands = new Set(allowedCommandModules.map((module) => path.resolve(module)));
     return [...new Set(loadedModules.map((loaded) => {
             if (loaded.startsWith("file:")) {
                 try {
@@ -22,10 +23,12 @@ export function forbiddenFastPathModules(loadedModules, distDirectory) {
         path.resolve(loaded) === flagRegistry ||
         path.resolve(loaded) === coreCommand ||
         path.resolve(loaded).includes(`${path.sep}node_modules${path.sep}@sentry${path.sep}node${path.sep}`))
+        .filter((loaded) => !allowedCommands.has(path.resolve(loaded)) ||
+        path.resolve(loaded) === main || path.resolve(loaded) === coreCommand)
         .sort();
 }
-export function assertFastPathStaysCommandGraphFree(loadedModules, distDirectory) {
-    const forbidden = forbiddenFastPathModules(loadedModules, distDirectory);
+export function assertFastPathStaysCommandGraphFree(loadedModules, distDirectory, allowedCommandModules = []) {
+    const forbidden = forbiddenFastPathModules(loadedModules, distDirectory, allowedCommandModules);
     if (forbidden.length > 0) {
         throw new Error(`fast core loaded forbidden command modules:\n${forbidden.join("\n")}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.293.0",
+  "version": "5.294.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {