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

package/dist/lib/mesh/project-board.js

@@ -1,181 +0,0 @@
-import { appendThreadEvent, ensureProjectThread, getProjectView, putProjectView, registerMeshProject, } from "./api.js";
-import { mapReaderStoryStatus } from "./story-status.js";
-function httpStatus(err) {
-    if (err && typeof err === "object" && "status" in err && typeof err.status === "number") {
-        return err.status;
-    }
-    return undefined;
-}
-/** Same merge as `hq mesh project ensure`: add missing stories, keep live status. */
-export function mergeProjectStories(current, planned, opts) {
-    const currentById = new Map(current.map((story) => [story.id, story]));
-    const plannedIds = new Set(planned.map((story) => story.id));
-    const merged = planned.map((story) => {
-        const live = currentById.get(story.id);
-        if (!live)
-            return story;
-        if (opts?.resetStatus) {
-            return {
-                ...story,
-                ...(live.assigneeUid ? { assigneeUid: live.assigneeUid } : {}),
-            };
-        }
-        const status = mapReaderStoryStatus(live) || story.status;
-        return {
-            ...story,
-            ...(status ? { status } : {}),
-            passes: status === "done" ? true : typeof live.passes === "boolean" ? live.passes : story.passes,
-            ...(live.assigneeUid ? { assigneeUid: live.assigneeUid } : {}),
-        };
-    });
-    return [...merged, ...current.filter((story) => !plannedIds.has(story.id))];
-}
-export function boardStoryStatus(story) {
-    const status = mapReaderStoryStatus(story);
-    if (status)
-        return status;
-    return story.passes === true ? "done" : "queued";
-}
-/**
- * Keep only prd-sync task_status events whose Board status actually differs.
- * Missing Board rows stay (ensure will add them). Same-status replays of
- * already-done stories must not be sent again (US-051b).
- */
-export function prdSyncEventsThatChangeBoard(events, boardStories) {
-    const byId = new Map(boardStories.map((story) => [story.id, boardStoryStatus(story)]));
-    return events.filter((event) => byId.get(event.taskId) !== event.status);
-}
-/** One-line summary of live→next status diffs for existing story ids. */
-export function formatStoryStatusChanges(current, next) {
-    const currentById = new Map(current.map((story) => [story.id, story]));
-    const changes = [];
-    for (const story of next) {
-        const live = currentById.get(story.id);
-        if (!live)
-            continue;
-        const from = boardStoryStatus(live);
-        const to = boardStoryStatus(story);
-        if (from !== to)
-            changes.push(`${story.id} ${from}→${to}`);
-    }
-    if (changes.length === 0)
-        return undefined;
-    return `Work mesh: project set changed status: ${changes.join(", ")}`;
-}
-function mergeProjectRepos(current, planned) {
-    const plannedPaths = new Set(planned.map((repo) => repo.path));
-    return [...planned, ...current.filter((repo) => !plannedPaths.has(repo.path))];
-}
-/**
- * Add Board stories that a prd-sync emit is about to name, when they are missing.
- * A missing view uses ensureProjectBoard. An existing view is merged so live
- * status stays. Callers that must not block the emit should catch failures.
- */
-export async function ensureMissingBoardStories(input) {
-    const required = new Set(input.requiredIds);
-    if (required.size === 0)
-        return;
-    let current;
-    try {
-        current = await getProjectView(input.token, input.company.companyUid, input.projectId);
-    }
-    catch (err) {
-        if (httpStatus(err) !== 404)
-            throw err;
-    }
-    if (!current) {
-        await ensureProjectBoard({
-            token: input.token,
-            company: input.company,
-            projectId: input.projectId,
-            name: input.name || input.projectId,
-            description: input.description ?? "",
-            stories: input.stories,
-            repos: input.repos ?? [],
-        });
-        return;
-    }
-    if ([...required].every((id) => current.stories.some((story) => story.id === id)))
-        return;
-    const genesis = await ensureProjectThread(input.token, input.company, input.projectId, {
-        summary: input.name || input.projectId,
-    });
-    if (!genesis.threadId)
-        throw new Error("Work mesh did not return a threadId.");
-    const stories = mergeProjectStories(current.stories, input.stories);
-    const repos = mergeProjectRepos(current.repos, input.repos ?? []);
-    const name = input.name || current.name;
-    const description = input.description !== undefined ? input.description : current.description;
-    await putProjectView(input.token, input.company.companyUid, input.projectId, {
-        name,
-        description,
-        stories,
-        repos,
-        ...(current.version !== undefined ? { expectedVersion: current.version } : {}),
-    });
-    const registration = await registerMeshProject(input.token, input.company.companyUid, input.projectId);
-    await closeSupersededProjectThread({
-        token: input.token,
-        companyUid: input.company.companyUid,
-        openedThreadId: genesis.threadId,
-        canonicalThreadId: registration.threadId,
-        created: genesis.created,
-    });
-}
-/**
- * POST /v1/work-mesh/projects/{id}/register always binds the server-derived
- * proj- thread (projectGenesisThreadId). It does not accept a client threadId.
- * Close a thread only when this same ensure created it and register returned
- * a different canonical id. An already-open thread stays open on a re-run.
- * The Board view reads the registered thread.
- */
-export async function closeSupersededProjectThread(input) {
-    if (!input.created)
-        return;
-    if (!input.openedThreadId || input.openedThreadId === input.canonicalThreadId)
-        return;
-    try {
-        await appendThreadEvent(input.token, input.companyUid, input.openedThreadId, "done", {
-            summary: "Superseded by the registered project thread.",
-        });
-    }
-    catch (err) {
-        // Best effort: the server may refuse (e.g. only the thread owner may mark
-        // it done). A leftover open thread must never fail registration.
-        const reason = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`Work mesh: left extra thread ${input.openedThreadId} open (${reason.slice(0, 120)})\n`);
-    }
-}
-/**
- * Create a missing Board. Register returns 403 PROJECT_NOT_IN_COMPANY until
- * the genesis thread and the project view both exist, so the order is fixed:
- * thread, view, register, then a GET to confirm the view.
- */
-export async function ensureProjectBoard(input) {
-    const genesis = await ensureProjectThread(input.token, input.company, input.projectId, {
-        summary: input.name || input.projectId,
-    });
-    if (!genesis.threadId) {
-        throw new Error("Work mesh did not return a threadId.");
-    }
-    await putProjectView(input.token, input.company.companyUid, input.projectId, {
-        name: input.name || input.projectId,
-        description: input.description ?? "",
-        stories: input.stories,
-        repos: input.repos ?? [],
-    });
-    const registration = await registerMeshProject(input.token, input.company.companyUid, input.projectId, input.channelId);
-    await closeSupersededProjectThread({
-        token: input.token,
-        companyUid: input.company.companyUid,
-        openedThreadId: genesis.threadId,
-        canonicalThreadId: registration.threadId,
-        created: genesis.created,
-    });
-    const view = await getProjectView(input.token, input.company.companyUid, input.projectId);
-    if (view.projectId !== input.projectId || view.companyUid !== input.company.companyUid) {
-        throw new Error(`Work mesh project board does not match ${input.company.companyUid}/${input.projectId}.`);
-    }
-    return { view, registration };
-}
-//# sourceMappingURL=project-board.js.map

package/dist/lib/mesh/story-status.d.ts

@@ -1,22 +0,0 @@
-export declare const BOARD_STORY_STATUSES: readonly ["queued", "in_progress", "review", "done"];
-export type BoardStoryStatus = (typeof BOARD_STORY_STATUSES)[number];
-/**
- * The ledger has more states than the Board. `blocked` and the review states
- * need attention, while `dropped` is terminal; the Board has only one terminal
- * column (`done`).
- */
-export declare const LEDGER_STATE_TO_BOARD_STATUS: Readonly<Record<string, BoardStoryStatus>>;
-export declare function mapSourceStoryStatus(story: {
-    status?: unknown;
-    state?: unknown;
-}, source: string): BoardStoryStatus | undefined;
-/**
- * Read a status from an existing PRD or Board response without imposing the
- * stricter `--stories-file` contract. Before state mapping was added, these
- * readers passed explicit status strings through and ignored state.
- */
-export declare function mapReaderStoryStatus(story: {
-    status?: unknown;
-    state?: unknown;
-}): string | undefined;
-//# sourceMappingURL=story-status.d.ts.map

package/dist/lib/mesh/story-status.js

@@ -1,49 +0,0 @@
-export const BOARD_STORY_STATUSES = ["queued", "in_progress", "review", "done"];
-const boardStoryStatusSet = new Set(BOARD_STORY_STATUSES);
-/**
- * The ledger has more states than the Board. `blocked` and the review states
- * need attention, while `dropped` is terminal; the Board has only one terminal
- * column (`done`).
- */
-export const LEDGER_STATE_TO_BOARD_STATUS = {
-    todo: "queued",
-    in_progress: "in_progress",
-    in_review: "review",
-    verification: "review",
-    blocked: "review",
-    done: "done",
-    dropped: "done",
-};
-export function mapSourceStoryStatus(story, source) {
-    if (story.status !== undefined && story.status !== null) {
-        if (typeof story.status !== "string" || !boardStoryStatusSet.has(story.status.trim())) {
-            throw new Error(`${source}.status must be queued|in_progress|review|done.`);
-        }
-        return story.status.trim();
-    }
-    if (Object.hasOwn(story, "state")) {
-        if (typeof story.state !== "string" ||
-            !Object.hasOwn(LEDGER_STATE_TO_BOARD_STATUS, story.state.trim())) {
-            throw new Error(`${source}.state must be todo|in_progress|in_review|verification|blocked|done|dropped.`);
-        }
-        return LEDGER_STATE_TO_BOARD_STATUS[story.state.trim()];
-    }
-    return undefined;
-}
-/**
- * Read a status from an existing PRD or Board response without imposing the
- * stricter `--stories-file` contract. Before state mapping was added, these
- * readers passed explicit status strings through and ignored state.
- */
-export function mapReaderStoryStatus(story) {
-    if (story.status !== undefined && story.status !== null) {
-        return typeof story.status === "string" ? story.status : undefined;
-    }
-    if (typeof story.state !== "string")
-        return undefined;
-    const state = story.state.trim();
-    return Object.hasOwn(LEDGER_STATE_TO_BOARD_STATUS, state)
-        ? LEDGER_STATE_TO_BOARD_STATUS[state]
-        : undefined;
-}
-//# sourceMappingURL=story-status.js.map

package/dist/lib/monitor.d.ts

@@ -1,149 +0,0 @@
-import type { LaneCompanyRef, LaneProvider } from "./lanes/types.js";
-export declare const MONITOR_SCHEMA_VERSION: "hq-monitor.v1";
-export declare const MONITOR_FLAG = "monitor.enabled";
-export declare const MONITOR_FLAG_DEFAULT = false;
-export declare const MONITOR_DEFAULT_TIMEOUT_MS: number;
-export declare const MONITOR_DEFAULT_CHECKIN_MS: number;
-export declare const MONITOR_BATCH_WINDOW_MS = 200;
-export declare const MONITOR_POLL_INTERVAL_MS = 1000;
-export declare const MONITOR_RATE_WINDOW_MS = 10000;
-/** Sustained stdout floods stop after 3 windows; the per-window cap can be overridden with HQ_MONITOR_MAX_EVENTS_PER_WINDOW. */
-export declare const MONITOR_MAX_EVENTS_PER_WINDOW = 60;
-export declare const MONITOR_MAX_FLOOD_WINDOWS = 3;
-export type MonitorTarget = {
-    kind: "lane";
-    laneId: string;
-} | {
-    kind: "session";
-    provider: LaneProvider;
-    sessionId: string;
-};
-export interface MonitorProcessEntry {
-    pid: number;
-    ppid: number;
-    command: string;
-}
-export interface DetectMonitorTargetOptions {
-    env: NodeJS.ProcessEnv;
-    parentPid: number;
-    readProcess: (pid: number) => MonitorProcessEntry | null;
-}
-export interface NearestMonitorRuntime {
-    provider: LaneProvider;
-    pid: number;
-}
-export interface MonitorRuntimeIdentity extends NearestMonitorRuntime {
-    starttime: number;
-}
-interface MonitorSessionOwner {
-    pid: number;
-    starttime: number | null;
-}
-export interface MonitorMetadata {
-    schema_version: typeof MONITOR_SCHEMA_VERSION;
-    monitor_id: string;
-    target: MonitorTarget;
-    target_key: string;
-    company: LaneCompanyRef | null;
-    description: string;
-    command: string | null;
-    argv: string[] | null;
-    cwd: string;
-    created_at: string;
-    timeout_ms: number | null;
-    persistent: boolean;
-    checkin_ms: number | null;
-    session_owner: MonitorSessionOwner | null;
-}
-export interface MonitorState {
-    status: "starting" | "running" | "stopping" | "terminal";
-    pid: number | null;
-    starttime: number | null;
-    child_pid?: number | null;
-    child_starttime?: number | null;
-    started_at?: string;
-    finished_at?: string;
-    exit_code?: number | null;
-    terminal_reason?: string;
-    event_count: number;
-    /** Last sequence written to events.jsonl, including undeliverable events. */
-    event_sequence?: number;
-}
-export interface MonitorEvent {
-    seq: number;
-    at: string;
-    text: string;
-    delivery: string;
-    reason?: string;
-}
-export interface MonitorTargetActivity {
-    last_delivery_ms: number;
-    last_delivery_kind: "monitor_event" | "checkin" | "start";
-    checkin_count: number;
-    last_activity_ms?: number;
-    last_checkin_attempt_ms?: number;
-}
-export interface MonitorCheckinDeps {
-    now: () => Date;
-    isWakeable: (targetKey: string) => boolean | Promise<boolean>;
-    readTargetActivityAt?: (targetKey: string) => number | null | Promise<number | null>;
-    deliver: (text: string, sequence: number) => Promise<{
-        delivered: boolean;
-        outcome: string;
-    }>;
-    pidIsAlive: (pid: number, starttime: number | null) => boolean;
-    readStarttime: (pid: number) => number | null;
-    sleep?: (ms: number) => Promise<void>;
-}
-export interface MonitorCheckinResult {
-    sent: boolean;
-    sequence: number | null;
-    text: string | null;
-    outcome: string | null;
-}
-/** This guard is first in monitor start so a conflicting invocation has no side effects. */
-export declare function assertMonitorTimeoutCompatibility(persistent: boolean, timeoutProvided: boolean): void;
-export declare function parseMonitorDuration(value: string, kind: "timeout" | "checkin"): number;
-export declare function parseMonitorTarget(value: string): MonitorTarget;
-export declare function monitorTargetKey(target: MonitorTarget): string;
-export declare function detectMonitorTarget(options: DetectMonitorTargetOptions): MonitorTarget;
-/** The nearest runtime process in the caller chain, shared by target detection and hook mapping. */
-export declare function findNearestMonitorRuntime(options: {
-    parentPid: number;
-    readProcess: (pid: number) => MonitorProcessEntry | null;
-}): NearestMonitorRuntime | null;
-export declare function monitorSessionDir(hqRoot: string, provider: LaneProvider, sessionId: string): string;
-export declare function monitorSessionHasActiveMarkers(hqRoot: string, provider: LaneProvider, sessionId: string): boolean;
-export declare function monitorSessionHasActiveMarkerForOwner(hqRoot: string, provider: LaneProvider, sessionId: string, owner: MonitorRuntimeIdentity): boolean;
-export declare function monitorSessionInboxHasEvents(hqRoot: string, provider: LaneProvider, sessionId: string): boolean;
-export declare function monitorSessionHasWork(hqRoot: string, provider: LaneProvider, sessionId: string): boolean;
-export declare function monitorDir(hqRoot: string, monitorId: string): string;
-export declare function makeMonitorId(): string;
-export declare function formatMonitorEvent(input: {
-    monitorId: string;
-    description: string;
-    sequence: number;
-    text: string;
-}): string;
-export declare function nextMonitorEventSequence(state: Pick<MonitorState, "event_sequence">): number;
-export declare function nextMonitorTimeoutDelay(timeoutMs: number, elapsedMs: number): number;
-export declare function recordMonitorEventState(state: MonitorState, event: MonitorEvent): MonitorState;
-/** Keep the supervisor alive until its command has closed so TERM escalation can run. */
-export declare function requestMonitorStop(childPid: number | null, terminate: () => void, finishWithoutChild: () => void): void;
-export declare function parseHookSessionId(payloadText: string): string;
-export declare function recordHookSessionMapping(hqRoot: string, provider: LaneProvider, environmentSessionId: string | undefined, payloadSessionId: string, runtime: MonitorRuntimeIdentity | undefined): void;
-export declare function resolveMappedSessionId(hqRoot: string, provider: LaneProvider, environmentSessionId: string, runtime: MonitorRuntimeIdentity | undefined): string;
-export declare function withMonitorTargetLock<T>(hqRoot: string, targetKey: string, operation: (activityPath: string) => Promise<T> | T, options?: {
-    now?: () => Date;
-    pidIsAlive?: (pid: number, starttime: number | null) => boolean;
-    sleep?: (ms: number) => Promise<void>;
-}): Promise<T>;
-export declare function recordMonitorTargetDelivery(hqRoot: string, targetKey: string, now?: () => Date, kind?: MonitorTargetActivity["last_delivery_kind"]): Promise<void>;
-export declare function recordMonitorTargetActivity(hqRoot: string, targetKey: string, now?: () => Date): Promise<void>;
-export declare function recordMonitorTargetDeliveryAtPath(activityPath: string, now?: () => Date, kind?: MonitorTargetActivity["last_delivery_kind"]): void;
-/** Elapsed idle time in whole units; live timers never land on exact multiples. */
-export declare function formatElapsed(ms: number): string;
-export declare function runMonitorCheckinTick(hqRoot: string, targetKey: string, deps: MonitorCheckinDeps): Promise<MonitorCheckinResult>;
-export declare function readMonitorPidLiveness(pid: number | null, starttime: number | null, readStarttime?: (pid: number) => number | null): boolean;
-export {};
-//# sourceMappingURL=monitor.d.ts.map