@indigoai-us/hq-cli 5.292.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/autopilot.d.ts

@@ -12,8 +12,9 @@ export interface RegisteredLead {
     status: string;
     prd: string;
 }
+export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane";
 export interface AutopilotWake {
-    condition: "review_finished_worker" | "fill_grant";
+    condition: AutopilotCondition;
     lead_lane: string;
     story_id: string;
     worker_lane?: string;
@@ -30,6 +31,14 @@ export interface AutopilotPassResult {
         story_id: string;
         worker_lane: string;
     }>;
+    escalated: Array<{
+        team: string;
+        lead_lane: string;
+        condition: AutopilotCondition;
+        story_id: string;
+        at: string;
+        fingerprint: string;
+    }>;
     skipped: Array<{
         lead_lane: string;
         reason: string;
@@ -38,15 +47,18 @@ export interface AutopilotPassResult {
 interface ProjectStory {
     id: string;
     status: string;
+    passes?: boolean;
     briefPath?: string;
     laneIds?: string[];
     updatedAt?: string;
+    externalBlocker?: string;
 }
 export declare function planLeadAutopilotWakes(input: {
     lead: LaneRecord;
     children: readonly LaneRecord[];
     stories: readonly ProjectStory[];
     now: Date;
+    managerStatus?: Record<string, unknown>;
     keepAliveResumed?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {