@indigoai-us/hq-cli 5.312.2-beta.0 → 5.314.0

package/dist/lib/lanes/approval-gate.js

@@ -1,90 +0,0 @@
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function text(value) {
-    return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
-}
-function externalActionCheckpoint(artifactValue) {
-    const artifact = record(artifactValue);
-    if (!artifact)
-        return undefined;
-    const kind = (text(artifact.kind) ?? text(artifact.type) ?? "").toLowerCase().replace(/[\s-]+/g, "_");
-    const status = (text(artifact.status) ?? text(artifact.state) ?? "").toLowerCase();
-    const hasDate = (...keys) => keys.some((key) => text(artifact[key]) !== undefined);
-    const url = text(artifact.url) ?? "";
-    const mergedPr = (["pr", "pull_request", "merged_pr"].includes(kind) ||
-        /\/(?:pull|pulls|merge_requests)\/\d+(?:\/|$)/i.test(url)) &&
-        (status === "merged" || artifact.merged === true || hasDate("merged_at")) ||
-        artifact.merged === true || status === "merged";
-    const pushedTag = (["tag", "git_tag"].includes(kind) ||
-        text(artifact.tag) !== undefined || text(artifact.tag_name) !== undefined) &&
-        (status === "pushed" || artifact.pushed === true || hasDate("pushed_at"));
-    const publishedPackage = (["package", "npm_package", "published_package"].includes(kind) ||
-        text(artifact.package) !== undefined || text(artifact.package_name) !== undefined) &&
-        (status === "published" || artifact.published === true || hasDate("published_at"));
-    const deployment = ["deploy", "deployment", "deployed"].includes(kind) &&
-        (status === "" || ["deployed", "success", "succeeded", "successful", "complete", "completed", "live"].includes(status) ||
-            artifact.deployed === true || hasDate("deployed_at"));
-    if (!mergedPr && !pushedTag && !publishedPackage && !deployment)
-        return undefined;
-    return text(artifact.checkpoint) ?? null;
-}
-function approvedEvents(history, workerId, workerYamlSha256) {
-    const consumed = new Set(history.flatMap((entry) => entry.event === "consumed" ? [entry.approval_id] : []));
-    return history.filter((entry) => entry.event === "approved" &&
-        entry.registry_worker_id === workerId &&
-        entry.worker_yaml_sha256 === workerYamlSha256 &&
-        !consumed.has(entry.approval_id));
-}
-export function enforceRegistryApprovalGate(lane, envelope) {
-    const registryWorker = lane.registry_worker;
-    const gateEnabled = registryWorker !== undefined &&
-        (registryWorker.approval_required || registryWorker.human_checkpoints.length > 0);
-    if (!gateEnabled || envelope.decision !== "done") {
-        return { envelope, approvedIdsToConsume: [], violation: false };
-    }
-    const actionCheckpoints = envelope.artifacts
-        .map(externalActionCheckpoint)
-        .filter((checkpoint) => checkpoint !== undefined);
-    if (actionCheckpoints.length === 0) {
-        return { envelope, approvedIdsToConsume: [], violation: false };
-    }
-    const missingCheckpoint = actionCheckpoints.includes(null);
-    const requiredCheckpoints = [...new Set(actionCheckpoints.filter((checkpoint) => checkpoint !== null))];
-    const configuredCheckpoints = registryWorker.human_checkpoints.length > 0
-        ? new Set(registryWorker.human_checkpoints)
-        : new Set(["external_publish"]);
-    const approvals = approvedEvents(lane.registry_worker_approval_history ?? [], registryWorker.id, registryWorker.worker_yaml_sha256);
-    const used = [];
-    const missing = missingCheckpoint ? ["(checkpoint missing)"] : [];
-    for (const checkpoint of requiredCheckpoints) {
-        if (!configuredCheckpoints.has(checkpoint)) {
-            missing.push(checkpoint);
-            continue;
-        }
-        const approval = approvals.find((entry) => entry.checkpoint === checkpoint && !used.includes(entry.approval_id));
-        if (!approval)
-            missing.push(checkpoint);
-        else
-            used.push(approval.approval_id);
-    }
-    if (missing.length === 0) {
-        return { envelope, approvedIdsToConsume: used, violation: false };
-    }
-    return {
-        envelope: {
-            ...envelope,
-            decision: "blocked",
-            summary: `External action requires senior approval at checkpoint: ${missing.join(", ")}.`,
-            story_status: "review",
-            blocked_reason: "approval_gate_violated",
-            story_complete: false,
-            story_complete_reason: "The reported external action has no matching recorded approval.",
-        },
-        approvedIdsToConsume: [],
-        violation: true,
-    };
-}
-//# sourceMappingURL=approval-gate.js.map

package/dist/lib/lanes/autopilot-metrics.d.ts

@@ -1,99 +0,0 @@
-export interface AutopilotMetricsLead {
-    team: string;
-    lane_id: string;
-    project_id: string;
-}
-export interface AutopilotMetricsLane {
-    lane_id: string;
-    project_id: string;
-    story_id: string;
-    senior: {
-        kind: string;
-        id?: string;
-    };
-    state: string;
-    created_at: string;
-    updated_at?: string;
-    ended_at?: string;
-    hire_grant?: number;
-    last_resume?: {
-        at?: string;
-    };
-    last_envelope?: {
-        at?: string;
-        artifacts?: unknown[];
-    };
-}
-export interface AutopilotMetricsStory {
-    id: string;
-    state?: string;
-    status?: string;
-    created_at?: string;
-    updated_at?: string;
-    prs?: unknown[];
-    lanes?: unknown[];
-}
-export interface AutopilotMetricsProject {
-    project_id: string;
-    stories: readonly AutopilotMetricsStory[];
-}
-export interface AutopilotMetricsNudge {
-    team: string;
-    at: string;
-}
-export interface AutopilotMetricsReview {
-    repo: string;
-    pr: number;
-    recorded_at: string;
-    worker_lane?: string | null;
-}
-export interface AutopilotMetricsResume {
-    lane_id: string;
-    at: string;
-}
-export interface AutopilotMetricsDefect {
-    at: string;
-    team: string;
-    defect: string;
-}
-export interface BuildAutopilotMetricsReportInput {
-    since: string;
-    until: string;
-    leads: readonly AutopilotMetricsLead[];
-    lanes: readonly AutopilotMetricsLane[];
-    projects: readonly AutopilotMetricsProject[];
-    reviews: readonly AutopilotMetricsReview[];
-    nudges: readonly AutopilotMetricsNudge[];
-    nudgeDefects: readonly AutopilotMetricsDefect[];
-    seniorResumes: readonly AutopilotMetricsResume[];
-}
-export interface AutopilotMetricsDay {
-    team: string;
-    day: string;
-    operator_nudges: number;
-    reviewed_lanes: number;
-    review_latency_minutes_total: number;
-    review_latency_minutes_average: number | null;
-    idle_slot_minutes_ready_work: number;
-}
-export interface AutopilotReviewLatency {
-    team: string;
-    lane_id: string;
-    story_id: string;
-    finished_at: string;
-    reviewed_at: string;
-    minutes: number;
-    end_event: "review_record" | "senior_resume" | "story_closed";
-}
-export interface AutopilotNudgeDefect extends AutopilotMetricsDefect {
-    wake: null;
-}
-export interface AutopilotMetricsReport {
-    since: string;
-    until: string;
-    days: AutopilotMetricsDay[];
-    review_latencies: AutopilotReviewLatency[];
-    nudge_defects: AutopilotNudgeDefect[];
-}
-export declare function buildAutopilotMetricsReport(input: BuildAutopilotMetricsReportInput): AutopilotMetricsReport;
-//# sourceMappingURL=autopilot-metrics.d.ts.map

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

@@ -1,301 +0,0 @@
-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-registry.d.ts

@@ -1,62 +0,0 @@
-import type { LaneCompanyRef, LaneHost } from "./types.js";
-export declare const OUTPOST_LEAD_REGISTRY_SCHEMA = "hq-lanes-outpost-lead-registry.v1";
-export declare const OUTPOST_LEAD_REGISTRY_MAX_AGE_MS: number;
-export declare const OUTPOST_LEAD_REGISTRY_REFRESH_MS: number;
-export declare const LEAD_REGISTRY_REL: string;
-export declare const OUTPOST_LEAD_REGISTRY_STATE_REL: string;
-export declare const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
-export interface LeadRegistryRow {
-    team: string;
-    lane: string;
-    host: string;
-    status: string;
-    prd: string;
-}
-export interface OutpostLeadRegistry {
-    schema_version: typeof OUTPOST_LEAD_REGISTRY_SCHEMA;
-    outpost_id: string;
-    generated_at: string;
-    juniors: LeadRegistryRow[];
-}
-export declare function buildOutpostLeadRegistry(input: {
-    rows: readonly LeadRegistryRow[];
-    outpostId: string;
-    generatedAt: string;
-}): OutpostLeadRegistry;
-/** Stage a host-filtered registry on the Outpost using an atomic local rename. */
-export declare function buildOutpostLeadRegistryInstallCommand(registry: OutpostLeadRegistry): string;
-export declare function syncOutpostLeadRegistries(input: {
-    hqRoot: string;
-    outpostIds: readonly string[];
-    generatedAt: string;
-    localHost: LaneHost;
-    resolveCompany: (slug: string) => Promise<LaneCompanyRef>;
-    readFlag: (flag: string, options: {
-        company: LaneCompanyRef;
-    }) => Promise<boolean>;
-    dispatch: (request: {
-        outpostId: string;
-        command: string;
-        timeoutSeconds?: number;
-        waitMs?: number;
-    }) => Promise<{
-        done?: boolean;
-        exitCode: number | null;
-        stdout: string;
-        stderr: string;
-    }>;
-}): Promise<Array<{
-    outpost_id: string;
-    row_count: number;
-    skipped: Array<{
-        lane: string;
-        reason: string;
-    }>;
-    dispatched: boolean;
-}>>;
-export declare function validateOutpostLeadRegistry(input: {
-    registry: unknown;
-    outpostId: string;
-    now: Date;
-}): OutpostLeadRegistry;
-//# sourceMappingURL=autopilot-registry.d.ts.map