@repo-os/repoos 0.5.45

package/dist/server/integration-status.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Read-model for the integration pipeline status bar (0207).
+ *
+ * Turns the serialized integration jobs (queue + the in-flight job's phase) and
+ * the orchestrator's live progress steps into a single snapshot the UI renders
+ * without any re-architecting of the orchestrator itself: it only consumes
+ * existing job data plus whichever progress `DoneStep` was last reported for
+ * each task by the close-out orchestrator.
+ */
+import type { IntegrationJob, JobCoordinator } from "./integration-job.js";
+import type { DoneStep } from "./done.js";
+/** The five discrete stages surfaced to the user, in pipeline order. */
+export declare const PIPELINE_STAGES: readonly string[];
+export interface IntegrationSnapshot {
+    /** True when nothing is queued or in progress — the idle empty state. */
+    empty: boolean;
+    /** The task currently being integrated, or null when none is in flight. */
+    active: {
+        taskId: string;
+        /** The currently-running stage in `PIPELINE_STAGES` order, or null. */
+        stage: string | null;
+        /** True when the active job's phase is `failed`. */
+        failed: boolean;
+        /** The failure detail from the job, when failed. */
+        error?: string;
+        /** When this job started processing (ISO), for the live stopwatch. Falls
+         *  back to the enqueue time when processing hasn't been marked started. */
+        startedAt: string | null;
+    } | null;
+    /** Task ids queued behind the active job, in FIFO order. */
+    queue: string[];
+    at: string;
+}
+/**
+ * The stage shown for a job. Prefers the live progress step recorded by the
+ * orchestrator (most accurate); falls back to a best-effort mapping from the
+ * job phase so a freshly hydrated snapshot still shows a sensible stage before
+ * any progress event has arrived.
+ */
+export declare function stageForJob(job: IntegrationJob, reported: DoneStep | undefined): string | null;
+/** Whether a stage is considered "done" (checked) given the current stage. */
+export declare function isStageComplete(stageIndex: number, currentIndex: number): boolean;
+/**
+ * Build the pipeline snapshot from the coordinator plus the last-reported
+ * progress step per task id. `queue` is every non-terminal job ahead of or
+ * behind the currently-in-flight one; jobs already done/failed are hidden.
+ */
+export declare function buildIntegrationSnapshot(coordinator: JobCoordinator, reported: Record<string, DoneStep>, at?: string): IntegrationSnapshot;

package/dist/server/integration-status.js

@@ -0,0 +1,71 @@
+/** The five discrete stages surfaced to the user, in pipeline order. */
+export const PIPELINE_STAGES = [
+    "sync",
+    "merge",
+    "build",
+    "check",
+    "done",
+];
+/**
+ * The stage shown for a job. Prefers the live progress step recorded by the
+ * orchestrator (most accurate); falls back to a best-effort mapping from the
+ * job phase so a freshly hydrated snapshot still shows a sensible stage before
+ * any progress event has arrived.
+ */
+export function stageForJob(job, reported) {
+    if (reported !== undefined)
+        return reported;
+    switch (job.phase) {
+        case "queued":
+            return null;
+        case "syncing":
+            return "sync";
+        case "validating":
+            return "merge";
+        case "publishing":
+        case "cleanup":
+        case "done":
+            return "done";
+        case "failed":
+            return "done";
+        default:
+            return null;
+    }
+}
+/** Whether a stage is considered "done" (checked) given the current stage. */
+export function isStageComplete(stageIndex, currentIndex) {
+    return stageIndex < currentIndex;
+}
+/**
+ * Build the pipeline snapshot from the coordinator plus the last-reported
+ * progress step per task id. `queue` is every non-terminal job ahead of or
+ * behind the currently-in-flight one; jobs already done/failed are hidden.
+ */
+export function buildIntegrationSnapshot(coordinator, reported, at = new Date().toISOString()) {
+    const all = coordinator.allJobs();
+    const inFlight = coordinator.peekNext();
+    const queue = [];
+    for (const job of all) {
+        if (job.phase === "done" || job.phase === "failed")
+            continue;
+        if (inFlight && job.taskId === inFlight.taskId)
+            continue;
+        queue.push(job.taskId);
+    }
+    if (!inFlight) {
+        return { empty: queue.length === 0, active: null, queue, at };
+    }
+    const failed = inFlight.phase === "failed";
+    return {
+        empty: false,
+        active: {
+            taskId: inFlight.taskId,
+            stage: stageForJob(inFlight, reported[inFlight.taskId]),
+            failed,
+            error: failed ? inFlight.reason : undefined,
+            startedAt: inFlight.startedAt ?? inFlight.enqueuedAt,
+        },
+        queue,
+        at,
+    };
+}

package/dist/server/live-index.d.ts

@@ -0,0 +1,295 @@
+import type { AgentOutputEntry, AgentSessionStats, RepoOSConfig, Task, Status, RepoIndex, BoardIndex, SupervisorHeartbeat } from "../core/types.js";
+import type { SystemStats } from "./system.js";
+import type { AutoEngineeringDecision } from "./auto-engineering.js";
+import type { IntegrationSnapshot } from "./integration-status.js";
+export type RepoEvent = {
+    type: "task.created";
+    task: Task;
+    at: string;
+} | {
+    type: "task.updated";
+    task: Task;
+    prev: Partial<Task>;
+    at: string;
+} | {
+    type: "task.deleted";
+    id: string;
+    path: string;
+    at: string;
+} | {
+    type: "agent.running";
+    id: string;
+    at: string;
+} | {
+    type: "agent.exited";
+    id: string;
+    at: string;
+}
+/** A start/send/chat was accepted but held for a free maxConcurrentAgents slot. */
+ | {
+    type: "agent.queued";
+    id: string;
+    at: string;
+}
+/** A queued id left the queue — about to spawn (an agent.running follows immediately). */
+ | {
+    type: "agent.dequeued";
+    id: string;
+    at: string;
+} | {
+    type: "agent.output";
+    id: string;
+    entry: AgentOutputEntry;
+    stream: "out" | "err";
+    at: string;
+} | {
+    type: "agent.stats";
+    id: string;
+    stats: AgentSessionStats;
+    at: string;
+}
+/** The freeform-create PM flesh-out failed and the draft is kept as-is
+ *  (0320): lets clients drop their "AI creation in flight" marker so a
+ *  later manual move of the stale draft cannot flag the card as newly created. */
+ | {
+    type: "task.aiCreateFailed";
+    id: string;
+    reason: string;
+    at: string;
+}
+/** The freeform-create PM flesh-out started working on a draft (0335):
+ *  drives the live "PM is working" indicator on the card + task panel. */
+ | {
+    type: "task.pmWorking";
+    id: string;
+    at: string;
+}
+/** The freeform-create PM flesh-out finished — success or failure (0335).
+ *  Emitted on every exit path so the indicator can never get stuck. */
+ | {
+    type: "task.pmFinished";
+    id: string;
+    at: string;
+} | {
+    type: "index.rebuilt";
+    taskCount: number;
+    at: string;
+} | {
+    type: "task.progress";
+    id: string;
+    step: string;
+    at: string;
+    detail?: string;
+    phase?: string;
+} | {
+    type: "task.corrected";
+    id: string;
+    path: string;
+    note: string;
+    at: string;
+} | {
+    type: "preview";
+    id: string;
+    preview: {
+        port: number;
+        url: string;
+        startedAt: string;
+        label?: string;
+    } | null;
+    at: string;
+}
+/** Lifecycle of the automatic agent review of a task in `review` (0101). */
+ | {
+    type: "review";
+    id: string;
+    state: "running" | "ready" | "failed" | "cancelled";
+    at: string;
+    error?: string;
+}
+/** Lifecycle of the CTO monitoring agent (0174). */
+ | {
+    type: "cto";
+    state: "running" | "ready" | "failed" | "cancelled";
+    at: string;
+    error?: string;
+}
+/**
+ * A newer build landed on disk (typically a close-out merge). It is parked
+ * for a user-triggered reload (0143) — the running server keeps serving the
+ * old build until POST /api/server/restart.
+ */
+ | {
+    type: "build.available";
+    hash: string;
+    buildAt: string | null;
+    at: string;
+}
+/** A user-triggered reload could not hand over — the old build keeps serving. */
+ | {
+    type: "reload.failed";
+    reason: string;
+    at: string;
+}
+/** Supervisor heartbeat report (0112). */
+ | {
+    type: "supervisor.heartbeat";
+    heartbeat: SupervisorHeartbeat;
+    at: string;
+}
+/** Auto-engineering mode state change (0124). */
+ | {
+    type: "auto-engineering.state";
+    state: {
+        enabled: boolean;
+        maxActiveTasks: number;
+        activeCount: number;
+        availableSlots: number;
+        reconciling: boolean;
+        decision: AutoEngineeringDecision | null;
+    };
+    at: string;
+} | {
+    type: "hello";
+    taskCount: number;
+    at: string;
+} | {
+    type: "system.stats";
+    stats: SystemStats;
+}
+/** Live snapshot of the integration pipeline for the pinned status bar (0207). */
+ | {
+    type: "integration";
+    pipeline: IntegrationSnapshot;
+}
+/** Full-suite test run (Control page): started, a raw stdout/stderr chunk, or exited. */
+ | {
+    type: "test-run.started";
+    at: string;
+} | {
+    type: "test-run.output";
+    chunk: string;
+    at: string;
+} | {
+    type: "test-run.done";
+    code: number | null;
+    at: string;
+}
+/**
+ * A server-run `repoos check` for one task (0310): the handoff-finalize
+ * check or the MTD merge-gate check. Scoped per task (unlike test-run.*
+ * above, which is a single global Control-page run) so the Debug tab can
+ * show check history and live-stream a check currently running for the
+ * task the drawer has open.
+ */
+ | {
+    type: "task-check.started";
+    taskId: string;
+    checkId: string;
+    checkKind: "handoff-finalize" | "merge-gate";
+    at: string;
+} | {
+    type: "task-check.output";
+    taskId: string;
+    checkId: string;
+    chunk: string;
+    at: string;
+} | {
+    type: "task-check.done";
+    taskId: string;
+    checkId: string;
+    code: number | null;
+    passed: boolean;
+    durationMs: number;
+    at: string;
+};
+type Listener = (e: RepoEvent) => void;
+export declare class LiveIndex {
+    private config;
+    /** task id -> Task */
+    private byId;
+    /** abs path -> task id, so a file change maps back to a task */
+    private pathToId;
+    private listeners;
+    private useGit;
+    private branchCache;
+    /**
+     * Guard invoked by `applyFileChange` for a transition INTO `review` that
+     * did not already pass through the trusted PATCH route. #0210: a direct
+     * task-file edit must be held to the same commit/vacuity gate as the trusted
+     * handoff path. Returns false to reject the transition (the file is reverted
+     * to its previous status); true/fire-and-forget to accept it.
+     */
+    private reviewGuard;
+    /** Wire the #0210 review-transition guard. The server owns the logic. */
+    setReviewGuard(fn: (task: Task, prev: Task) => Promise<boolean>): void;
+    constructor(config: RepoOSConfig);
+    /** Build from scratch. Safe to call any time; always authoritative. */
+    refreshAll(): void;
+    /**
+     * Async counterpart of `refreshAll`, used only at server startup: it lets
+     * `listen()` proceed while the (git-heavy, otherwise multi-second with
+     * 200+ tasks) index build runs in the background — see `buildIndexAsync`.
+     * Not a drop-in replacement for `refreshAll` in general: a file-watcher
+     * update landing mid-build is overwritten by this call's final swap-in,
+     * same as it would be by a concurrent `refreshAll`, but this call's window
+     * is wider. Fine for the one-shot boot case; callers that need to
+     * interleave safely with live updates should keep using `refreshAll`.
+     */
+    refreshAllAsync(): Promise<void>;
+    /**
+     * Refresh every task's worktree `dirty`/`worktreePath` with a real
+     * `git status` sweep (batched — see `resolveWorktreeStatuses`), persist the
+     * result, and emit `task.updated` for any that changed. Called after the
+     * fast boot build and safe to call periodically. No-op without git.
+     */
+    reconcileWorktreeStatus(): Promise<void>;
+    private isTaskFile;
+    /**
+     * Re-parse a single file after a create/modify. Emits created or updated.
+     *
+     * `opts.guarded` marks a change that already passed the #0210 review gate
+     * (the trusted PATCH route and the trusted handoff path run the gate
+     * themselves), so it is applied synchronously without re-invoking the guard.
+     * Unmarked transitions INTO `review` — a direct task-file edit picked up by
+     * the watcher — are deferred to the async guard, which reverts the file to
+     * its previous status if the transition is rejected. Returns a Promise for
+     * that deferred case so callers (and tests) can await its settlement.
+     */
+    applyFileChange(absPath: string, opts?: {
+        guarded?: boolean;
+    }): void | Promise<void>;
+    /** Apply a fully-parsed task to the in-memory index and emit. */
+    private applyParsed;
+    /**
+     * Run the #0210 review guard for a deferred transition into `review`. On
+     * acceptance the task is applied normally (the worktree was committed by the
+     * guard). On rejection the task file is reverted to its previous status —
+     * using the same safe write path as a server edit — so the bypass can never
+     * leave a task sitting in `review` with uncommitted work.
+     */
+    private runReviewGuard;
+    /** Handle a file removal. Emits deleted if it mapped to a known task. */
+    applyFileDelete(absPath: string): void;
+    /**
+     * Re-scan local branches / worktrees and re-apply the cheap git facts
+     * (`branchExists`, `worktreeExists`, `worktreePath`) to every indexed task.
+     * Called after an agent launch, branch sync, or hotfix so the UI's branch/
+     * worktree dots are right without a full rebuild.
+     *
+     * `dirty` is NOT recomputed here — that needs a `git status` per worktree,
+     * which this method used to run synchronously for every task on the event
+     * loop (~2.5s at 40 worktrees, on every task mutation). It is delegated to
+     * the batched `reconcileWorktreeStatus()` sweep, kicked off below and
+     * arriving via `task.updated` within ~100ms.
+     */
+    refreshBranches(): void;
+    getTasks(status?: Status): Task[];
+    getTask(id: string): Task | null;
+    counts(): Record<Status, number>;
+    snapshot(): RepoIndex;
+    /** Lightweight board snapshot — skips body, extra, agent overrides. */
+    boardSnapshot(): BoardIndex;
+    on(fn: Listener): () => void;
+    private emit;
+}
+export {};