@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/workflow/workflow-progress.d.ts

@@ -0,0 +1,148 @@
+import type { WorkflowSnapshot } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { ManagedAgent } from "../agent/agent-manager.js";
+import type { TaskGraph } from "./workflow-manager.js";
+/**
+ * workflow-progress — Epic 3, Story 3.1.
+ *
+ * Live workflow progress is DERIVED, never stored. This module owns the single pure
+ * computation that turns the *current set* of child-agent states + the workflow's
+ * task graph into `{ completedStoryCount, totalStoryCount, phase, gateStatus }`.
+ *
+ * Why a pure function of the current set (not a fold over per-event deltas):
+ * - **Order-independent.** Counting the present states means arrival order cannot
+ *   change the result — feeding the same children shuffled yields a deeply-equal
+ *   projection. This is what makes "derived, not stored" testable as an equality.
+ * - **Monotonic-correct.** `completedStoryCount` only moves up as more children reach
+ *   terminal-success; it never flickers backwards under out-of-order arrival.
+ * - **Recompute-on-load safe.** After a daemon restart the projection is rebuilt from
+ *   whatever child states exist now; no persisted counter is trusted as truth.
+ *
+ * Determinism rules (mirroring `docs/architecture.md` timeline discipline):
+ * - NEVER call `Date.now()` / `new Date()` here. Recency ordering uses the canonical
+ *   daemon-owned `ManagedAgent.updatedAt`, with the agent id as a stable tiebreak so
+ *   equal timestamps still resolve order-independently.
+ * - No I/O, no module-level mutable state, no snapshot reads.
+ *
+ * `WorkflowCycleError` + the execution-layer resolution live here (rather than in
+ * `workflow-manager.ts`) so the manager and the projection share ONE layer derivation
+ * — guaranteeing the phase order the manager persists matches the phases this module
+ * projects. The manager imports both back from here; the only edge in the other
+ * direction is the type-only `TaskGraph`/`TaskNode` import above (erased at runtime,
+ * so there is no runtime cycle).
+ */
+type WorkflowStatus = WorkflowSnapshot["status"];
+/** The four derived progress values for a workflow, computed from child states. */
+export interface WorkflowProgress {
+    /** Story nodes whose mapped child reached terminal-success. Never exceeds total. */
+    completedStoryCount: number;
+    /** Total number of story (task) nodes in the run. */
+    totalStoryCount: number;
+    /** Id of the current phase (earliest phase with a non-done story); null when all done. */
+    phase: string | null;
+    /** Gate status of the current phase, mapped onto WorkflowStatus; null for an empty graph. */
+    gateStatus: WorkflowStatus | null;
+}
+/** Per-phase projected state — used by the manager to overlay the wire `phases[]`. */
+export interface ProjectedPhase {
+    /** Stable phase id, matching the manager's `layer-${index + 1}` convention. */
+    id: string;
+    /** Zero-based phase index (execution-layer order). */
+    index: number;
+    /** Task ids belonging to this phase, in graph order. */
+    taskIds: string[];
+    /** Number of story nodes in this phase. */
+    storyCount: number;
+    /** Story nodes in this phase whose child reached terminal-success. */
+    completedStoryCount: number;
+    /** Derived gate status for this phase. */
+    status: WorkflowStatus;
+}
+/** Per-task lifecycle classification, derived purely from a child's lifecycle. */
+export type TaskOutcome = "pending" | "running" | "success" | "failed";
+/**
+ * Project per-phase gate state from the current child states. Children MUST already
+ * be scoped to a single workflow (filtered by `WORKFLOW_ID_LABEL`) — task ids are
+ * only unique within one workflow's graph.
+ */
+export declare function projectWorkflowPhases(params: {
+    children: ManagedAgent[];
+    taskGraph: TaskGraph;
+    terminalOutcomes?: ReadonlyMap<string, TaskOutcome>;
+}): ProjectedPhase[];
+/**
+ * Project the workflow's live progress summary from the current child states.
+ *
+ * Pure function of `(children, taskGraph)` only — no I/O, no clock, no stored-count
+ * reads. Calling it twice with the same inputs (in any order) returns deeply-equal
+ * results. Children MUST already be scoped to the workflow via `WORKFLOW_ID_LABEL`.
+ */
+export declare function projectWorkflowProgress(params: {
+    children: ManagedAgent[];
+    taskGraph: TaskGraph;
+    terminalOutcomes?: ReadonlyMap<string, TaskOutcome>;
+}): WorkflowProgress;
+/** Thrown when a task graph's dependencies cannot be layered (cycle / dangling dep). */
+export declare class WorkflowCycleError extends Error {
+    readonly unresolved: string[];
+    constructor(unresolved: string[]);
+}
+/**
+ * A graph that is malformed *before* dependencies are even considered: it declares no
+ * tasks at all, or it declares the same task id twice.
+ *
+ * Kept separate from {@link WorkflowCycleError} because neither defect is a dependency
+ * problem, and both callers (`session.ts` RPC, `mcp-server.ts` tool) forward
+ * `error.message` verbatim to a human - telling that human "dependency cycle" when the
+ * real defect is "you sent zero tasks" is the kind of message that costs an hour.
+ * `defect` is the stable discriminator; the message is the human-facing half.
+ */
+export declare class WorkflowInvalidGraphError extends Error {
+    readonly defect: "empty-graph" | "duplicate-task-id";
+    constructor(defect: "empty-graph" | "duplicate-task-id", message: string);
+}
+/**
+ * Resolve the layered execution order for a graph. Prefer the graph's declared
+ * `metadata.executionLayers`; otherwise compute layers from task dependencies.
+ */
+export declare function resolveExecutionLayers(graph: TaskGraph): string[][];
+/**
+ * Assert that a task graph is schedulable: it declares at least one task, no task id is
+ * declared twice, every declared dependency names a task that exists in the graph, and
+ * the dependency relation is acyclic. Throws {@link WorkflowInvalidGraphError} for the
+ * two shape defects and {@link WorkflowCycleError} for the two dependency defects, on
+ * the first violation; returns `void` on success.
+ *
+ * WHY the shape defects are rejected here rather than tolerated: both produce a workflow
+ * that can never reach a terminal status, which is the exact failure this validator
+ * exists to prevent. An empty graph makes `startWorkflow` flip to `running`, spawn zero
+ * children and return - and `settleWorkflow` is only ever reached from a child terminal
+ * event, so with no children no event ever fires and the workflow sits `running`
+ * forever. Duplicate ids are worse than useless: two children spawn for one task id and
+ * the first of them to close settles the whole workflow to `completed` while its twin is
+ * still live, recording intent as fact. Neither is stopped downstream - the wire schema
+ * (`WorkflowTaskGraphSchema.tasks`) has no `.min(1)` and no uniqueness constraint - so
+ * submission time is the only place they can be stopped. The definition layer already
+ * rejects both (`steps: z.array(...).min(1)` and `collectDuplicateStepIds` in
+ * `protocol/src/workflow/definition.ts`); this closes the same two holes on the
+ * raw-graph path, which is the one the wire and the CLI can still reach directly.
+ *
+ * Pure: no I/O, no snapshot reads, no `Date` API (see the determinism rules above).
+ *
+ * WHY this cannot delegate to `resolveExecutionLayers`: that function (above) returns
+ * `graph.metadata.executionLayers` verbatim and unvalidated whenever it is non-empty,
+ * and `WorkflowTaskGraphSchema.metadata.executionLayers` is a REQUIRED wire field
+ * (`packages/protocol/src/messages.ts`), so every real graph carries declared layers and
+ * takes that branch. The Kahn check inside `computeLayersFromDependencies` therefore
+ * never runs for real traffic. This validator reads `TaskNode.dependencies` only and
+ * ignores the declared layering entirely, so a graph that *claims* to be layerable is
+ * still rejected when its dependencies say otherwise.
+ *
+ * It also deliberately does NOT share `computeLayersFromDependencies`' escape hatch
+ * (`|| !byId.has(dep)`, which treats an out-of-graph dependency as already satisfied).
+ * That clause is correct for the projection, which must keep layering graphs stored
+ * before this validator existed, and wrong for scheduling, where an out-of-graph
+ * dependency can never be met. Rejecting is done here, one level up, instead.
+ */
+export declare function assertSchedulableGraph(graph: TaskGraph): void;
+export {};
+//# sourceMappingURL=workflow-progress.d.ts.map

package/dist/server/server/workflow/workflow-progress.js

@@ -0,0 +1,274 @@
+import { WORKFLOW_TASK_ID_LABEL } from "@hyperdrive.bot/fleet-protocol/agent-labels";
+/**
+ * Terminal-success = the child reached `closed` AND never ended in error. A child
+ * that errored — whether still in `error` or torn down to `closed` while carrying a
+ * `lastError` — does NOT count toward completion.
+ */
+function isTerminalSuccess(agent) {
+    return agent.lifecycle === "closed" && !agent.lastError;
+}
+/** A child that ended (or is) in error: live `error`, or `closed` with a `lastError`. */
+function hasErrored(agent) {
+    return agent.lifecycle === "error" || (agent.lifecycle === "closed" && Boolean(agent.lastError));
+}
+/**
+ * Pick the most recent child for a task, ordering by the daemon-owned `updatedAt`
+ * with the agent id as a stable tiebreak. A task may have more than one child if it
+ * was retried/re-spawned; the latest attempt is authoritative. The reduction is
+ * order-independent: max-by-(updatedAt, id) is the same regardless of input order.
+ */
+function latestChild(children) {
+    let best;
+    for (const candidate of children) {
+        if (!best) {
+            best = candidate;
+            continue;
+        }
+        const candidateTime = candidate.updatedAt.getTime();
+        const bestTime = best.updatedAt.getTime();
+        if (candidateTime > bestTime) {
+            best = candidate;
+        }
+        else if (candidateTime === bestTime && candidate.id > best.id) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+function outcomeFor(child) {
+    if (!child) {
+        return "pending"; // No child spawned for this task yet.
+    }
+    if (isTerminalSuccess(child)) {
+        return "success";
+    }
+    if (hasErrored(child)) {
+        return "failed";
+    }
+    return "running"; // initializing | idle | running — live but not terminal.
+}
+/** Map a phase's task outcomes onto a single gate status. Pure, order-independent. */
+function phaseStatusFromOutcomes(outcomes) {
+    if (outcomes.length === 0) {
+        return "completed"; // An empty phase has nothing left to gate.
+    }
+    if (outcomes.every((outcome) => outcome === "success")) {
+        return "completed";
+    }
+    if (outcomes.some((outcome) => outcome === "failed")) {
+        return "failed"; // A failed gate node dominates in-progress siblings.
+    }
+    if (outcomes.some((outcome) => outcome === "running" || outcome === "success")) {
+        return "running"; // Some progress, nothing failed, not all done.
+    }
+    return "pending"; // Nothing started in this phase.
+}
+/**
+ * Project per-phase gate state from the current child states. Children MUST already
+ * be scoped to a single workflow (filtered by `WORKFLOW_ID_LABEL`) — task ids are
+ * only unique within one workflow's graph.
+ */
+export function projectWorkflowPhases(params) {
+    const { children, taskGraph, terminalOutcomes } = params;
+    // Group children by the task they ran (latest attempt wins downstream).
+    const childrenByTask = new Map();
+    for (const child of children) {
+        const taskId = child.labels?.[WORKFLOW_TASK_ID_LABEL];
+        if (taskId === undefined) {
+            continue;
+        }
+        const bucket = childrenByTask.get(taskId);
+        if (bucket) {
+            bucket.push(child);
+        }
+        else {
+            childrenByTask.set(taskId, [child]);
+        }
+    }
+    return resolveExecutionLayers(taskGraph).map((taskIds, index) => {
+        const outcomes = taskIds.map((taskId) => terminalOutcomes?.get(taskId) ?? outcomeFor(latestChild(childrenByTask.get(taskId) ?? [])));
+        return {
+            id: `layer-${index + 1}`,
+            index,
+            taskIds,
+            storyCount: taskIds.length,
+            completedStoryCount: outcomes.filter((outcome) => outcome === "success").length,
+            status: phaseStatusFromOutcomes(outcomes),
+        };
+    });
+}
+/**
+ * Project the workflow's live progress summary from the current child states.
+ *
+ * Pure function of `(children, taskGraph)` only — no I/O, no clock, no stored-count
+ * reads. Calling it twice with the same inputs (in any order) returns deeply-equal
+ * results. Children MUST already be scoped to the workflow via `WORKFLOW_ID_LABEL`.
+ */
+export function projectWorkflowProgress(params) {
+    const phases = projectWorkflowPhases(params);
+    let completedStoryCount = 0;
+    let totalStoryCount = 0;
+    for (const phase of phases) {
+        completedStoryCount += phase.completedStoryCount;
+        totalStoryCount += phase.storyCount;
+    }
+    if (phases.length === 0) {
+        return { completedStoryCount: 0, totalStoryCount: 0, phase: null, gateStatus: null };
+    }
+    const current = phases.find((phase) => phase.status !== "completed");
+    if (!current) {
+        // Every phase is done — the run's gate has passed.
+        return { completedStoryCount, totalStoryCount, phase: null, gateStatus: "completed" };
+    }
+    return {
+        completedStoryCount,
+        totalStoryCount,
+        phase: current.id,
+        gateStatus: current.status,
+    };
+}
+// --- Execution-layer resolution ---------------------------------------------
+// Relocated from `workflow-manager.ts` so the manager and the projection derive
+// phases from ONE source. Behaviour is unchanged from the original.
+/** Thrown when a task graph's dependencies cannot be layered (cycle / dangling dep). */
+export class WorkflowCycleError extends Error {
+    constructor(unresolved) {
+        super(`Workflow task graph has a dependency cycle or unsatisfiable dependencies: ${unresolved.join(", ")}`);
+        this.unresolved = unresolved;
+        this.name = "WorkflowCycleError";
+    }
+}
+/**
+ * A graph that is malformed *before* dependencies are even considered: it declares no
+ * tasks at all, or it declares the same task id twice.
+ *
+ * Kept separate from {@link WorkflowCycleError} because neither defect is a dependency
+ * problem, and both callers (`session.ts` RPC, `mcp-server.ts` tool) forward
+ * `error.message` verbatim to a human - telling that human "dependency cycle" when the
+ * real defect is "you sent zero tasks" is the kind of message that costs an hour.
+ * `defect` is the stable discriminator; the message is the human-facing half.
+ */
+export class WorkflowInvalidGraphError extends Error {
+    constructor(defect, message) {
+        super(message);
+        this.defect = defect;
+        this.name = "WorkflowInvalidGraphError";
+    }
+}
+/**
+ * Resolve the layered execution order for a graph. Prefer the graph's declared
+ * `metadata.executionLayers`; otherwise compute layers from task dependencies.
+ */
+export function resolveExecutionLayers(graph) {
+    const declared = graph.metadata.executionLayers;
+    if (declared && declared.length > 0) {
+        return declared;
+    }
+    return computeLayersFromDependencies(graph.tasks);
+}
+/** Kahn-style topological layering: each layer is the set of tasks whose deps are met. */
+function computeLayersFromDependencies(tasks) {
+    const byId = new Map(tasks.map((task) => [task.id, task]));
+    const resolved = new Set();
+    const layers = [];
+    let remaining = tasks.map((task) => task.id);
+    while (remaining.length > 0) {
+        const layer = remaining.filter((id) => {
+            const node = byId.get(id);
+            if (!node) {
+                return false;
+            }
+            // A dependency outside the graph is treated as already satisfied.
+            return node.dependencies.every((dep) => resolved.has(dep) || !byId.has(dep));
+        });
+        if (layer.length === 0) {
+            throw new WorkflowCycleError(remaining);
+        }
+        for (const id of layer) {
+            resolved.add(id);
+        }
+        layers.push(layer);
+        remaining = remaining.filter((id) => !resolved.has(id));
+    }
+    return layers;
+}
+/**
+ * Assert that a task graph is schedulable: it declares at least one task, no task id is
+ * declared twice, every declared dependency names a task that exists in the graph, and
+ * the dependency relation is acyclic. Throws {@link WorkflowInvalidGraphError} for the
+ * two shape defects and {@link WorkflowCycleError} for the two dependency defects, on
+ * the first violation; returns `void` on success.
+ *
+ * WHY the shape defects are rejected here rather than tolerated: both produce a workflow
+ * that can never reach a terminal status, which is the exact failure this validator
+ * exists to prevent. An empty graph makes `startWorkflow` flip to `running`, spawn zero
+ * children and return - and `settleWorkflow` is only ever reached from a child terminal
+ * event, so with no children no event ever fires and the workflow sits `running`
+ * forever. Duplicate ids are worse than useless: two children spawn for one task id and
+ * the first of them to close settles the whole workflow to `completed` while its twin is
+ * still live, recording intent as fact. Neither is stopped downstream - the wire schema
+ * (`WorkflowTaskGraphSchema.tasks`) has no `.min(1)` and no uniqueness constraint - so
+ * submission time is the only place they can be stopped. The definition layer already
+ * rejects both (`steps: z.array(...).min(1)` and `collectDuplicateStepIds` in
+ * `protocol/src/workflow/definition.ts`); this closes the same two holes on the
+ * raw-graph path, which is the one the wire and the CLI can still reach directly.
+ *
+ * Pure: no I/O, no snapshot reads, no `Date` API (see the determinism rules above).
+ *
+ * WHY this cannot delegate to `resolveExecutionLayers`: that function (above) returns
+ * `graph.metadata.executionLayers` verbatim and unvalidated whenever it is non-empty,
+ * and `WorkflowTaskGraphSchema.metadata.executionLayers` is a REQUIRED wire field
+ * (`packages/protocol/src/messages.ts`), so every real graph carries declared layers and
+ * takes that branch. The Kahn check inside `computeLayersFromDependencies` therefore
+ * never runs for real traffic. This validator reads `TaskNode.dependencies` only and
+ * ignores the declared layering entirely, so a graph that *claims* to be layerable is
+ * still rejected when its dependencies say otherwise.
+ *
+ * It also deliberately does NOT share `computeLayersFromDependencies`' escape hatch
+ * (`|| !byId.has(dep)`, which treats an out-of-graph dependency as already satisfied).
+ * That clause is correct for the projection, which must keep layering graphs stored
+ * before this validator existed, and wrong for scheduling, where an out-of-graph
+ * dependency can never be met. Rejecting is done here, one level up, instead.
+ */
+export function assertSchedulableGraph(graph) {
+    // Pass 0 - shape. Runs before anything reads `dependencies`, because a graph this
+    // malformed has no dependency verdict worth reporting.
+    if (graph.tasks.length === 0) {
+        throw new WorkflowInvalidGraphError("empty-graph", "Workflow task graph declares no tasks: a workflow must declare at least one task.");
+    }
+    // Built by hand rather than `new Map(graph.tasks.map(...))` precisely so the collision
+    // is observable: the Map constructor silently keeps the LAST entry for a repeated key,
+    // which is how a duplicate id survives every downstream check.
+    const byId = new Map();
+    for (const task of graph.tasks) {
+        if (byId.has(task.id)) {
+            throw new WorkflowInvalidGraphError("duplicate-task-id", `Workflow task graph declares duplicate task id: ${task.id}`);
+        }
+        byId.set(task.id, task);
+    }
+    // Pass 1 - dangling dependencies. Runs FIRST so a dependency on a task that does not
+    // exist is never misreported as a cycle. First offender in graph order, for a
+    // deterministic message.
+    for (const task of graph.tasks) {
+        for (const dep of task.dependencies) {
+            if (!byId.has(dep)) {
+                throw new WorkflowCycleError([`${task.id} -> ${dep}`]);
+            }
+        }
+    }
+    // Pass 2 - cycles. Kahn-style sweep over `dependencies` only; no out-of-graph escape,
+    // which is safe precisely because pass 1 proved every dependency is in-graph.
+    const resolved = new Set();
+    let remaining = graph.tasks;
+    while (remaining.length > 0) {
+        const layer = remaining.filter((task) => task.dependencies.every((dep) => resolved.has(dep)));
+        if (layer.length === 0) {
+            throw new WorkflowCycleError(remaining.map((task) => task.id));
+        }
+        for (const task of layer) {
+            resolved.add(task.id);
+        }
+        remaining = remaining.filter((task) => !resolved.has(task.id));
+    }
+}
+//# sourceMappingURL=workflow-progress.js.map

package/dist/server/server/workflow/workflow-storage.d.ts

@@ -0,0 +1,36 @@
+import type { Logger } from "pino";
+import type { StoredWorkflowRecord } from "@hyperdrive.bot/fleet-protocol/messages";
+export declare function parseStoredWorkflowRecord(value: unknown): StoredWorkflowRecord;
+/**
+ * File-backed, atomic-write storage for workflow records.
+ *
+ * Mirrors the proven `agent-storage.ts` shape — in-memory cache + lazy load +
+ * per-id pending-write chain + temp-file/rename atomic writes + validate-on-load —
+ * but persists to a FLAT layout (`{baseDir}/{id}.json`, no cwd grouping) and sources
+ * its schema from the protocol package rather than defining it locally.
+ *
+ * Corrupt files (bad JSON or schema-invalid) are rejected on load — logged and omitted
+ * from results, never coerced into a partial/default record.
+ */
+export declare class WorkflowStorage {
+    private cache;
+    private pendingWrites;
+    private loaded;
+    private baseDir;
+    private loadPromise;
+    private logger;
+    constructor(baseDir: string, logger: Logger);
+    initialize(): Promise<void>;
+    listWorkflows(): Promise<StoredWorkflowRecord[]>;
+    loadWorkflow(id: string): Promise<StoredWorkflowRecord | null>;
+    saveWorkflow(record: StoredWorkflowRecord): Promise<void>;
+    flush(): Promise<void>;
+    private queueRecordWrite;
+    private writeRecord;
+    private load;
+    private doLoad;
+    private scanDisk;
+    private readRecordFile;
+    private buildRecordPath;
+}
+//# sourceMappingURL=workflow-storage.d.ts.map

package/dist/server/server/workflow/workflow-storage.js

@@ -0,0 +1,143 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { STORED_WORKFLOW_SCHEMA } from "@hyperdrive.bot/fleet-protocol/messages";
+export function parseStoredWorkflowRecord(value) {
+    return STORED_WORKFLOW_SCHEMA.parse(value);
+}
+/**
+ * File-backed, atomic-write storage for workflow records.
+ *
+ * Mirrors the proven `agent-storage.ts` shape — in-memory cache + lazy load +
+ * per-id pending-write chain + temp-file/rename atomic writes + validate-on-load —
+ * but persists to a FLAT layout (`{baseDir}/{id}.json`, no cwd grouping) and sources
+ * its schema from the protocol package rather than defining it locally.
+ *
+ * Corrupt files (bad JSON or schema-invalid) are rejected on load — logged and omitted
+ * from results, never coerced into a partial/default record.
+ */
+export class WorkflowStorage {
+    constructor(baseDir, logger) {
+        this.cache = new Map();
+        this.pendingWrites = new Map();
+        this.loaded = false;
+        this.loadPromise = null;
+        this.baseDir = baseDir;
+        this.logger = logger.child({ module: "workflow", component: "workflow-storage" });
+    }
+    async initialize() {
+        await this.load();
+    }
+    async listWorkflows() {
+        await this.load();
+        return Array.from(this.cache.values());
+    }
+    async loadWorkflow(id) {
+        await this.load();
+        return this.cache.get(id) ?? null;
+    }
+    async saveWorkflow(record) {
+        await this.load();
+        await this.queueRecordWrite(record);
+    }
+    async flush() {
+        await this.load().catch(() => undefined);
+        const writes = Array.from(this.pendingWrites.values());
+        await Promise.allSettled(writes);
+    }
+    queueRecordWrite(record) {
+        const workflowId = record.id;
+        const prev = this.pendingWrites.get(workflowId) ?? Promise.resolve();
+        const next = prev.then(async () => {
+            await this.writeRecord(record);
+            return undefined;
+        });
+        const tracked = next.finally(() => {
+            if (this.pendingWrites.get(workflowId) === tracked) {
+                this.pendingWrites.delete(workflowId);
+            }
+        });
+        this.pendingWrites.set(workflowId, tracked);
+        return tracked;
+    }
+    async writeRecord(record) {
+        const targetPath = this.buildRecordPath(record);
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await writeFileAtomically(targetPath, JSON.stringify(record, null, 2));
+        this.cache.set(record.id, record);
+    }
+    async load() {
+        if (this.loaded) {
+            return Array.from(this.cache.values());
+        }
+        if (!this.loadPromise) {
+            this.loadPromise = this.doLoad();
+        }
+        return this.loadPromise;
+    }
+    async doLoad() {
+        this.cache.clear();
+        try {
+            const records = await this.scanDisk();
+            this.loaded = true;
+            return records;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                this.loaded = true;
+                return [];
+            }
+            this.logger.error({ err: error }, "Failed to load workflows");
+            this.loaded = true;
+            return [];
+        }
+    }
+    async scanDisk() {
+        let entries = [];
+        try {
+            entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        const filePaths = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => path.join(this.baseDir, entry.name));
+        const loaded = await Promise.all(filePaths.map(async (filePath) => {
+            const record = await this.readRecordFile(filePath);
+            return record ? { record, filePath } : null;
+        }));
+        const records = [];
+        for (const item of loaded) {
+            if (!item)
+                continue;
+            records.push(item.record);
+            this.cache.set(item.record.id, item.record);
+        }
+        return records;
+    }
+    async readRecordFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, "utf8");
+            const parsed = JSON.parse(content);
+            return parseStoredWorkflowRecord(parsed);
+        }
+        catch (error) {
+            this.logger.error({ err: error, filePath }, "Skipping invalid workflow record");
+            return null;
+        }
+    }
+    buildRecordPath(record) {
+        return path.join(this.baseDir, `${record.id}.json`);
+    }
+}
+async function writeFileAtomically(targetPath, payload) {
+    const directory = path.dirname(targetPath);
+    const tempPath = path.join(directory, `.workflow.tmp-${process.pid}-${Date.now()}-${randomUUID()}`);
+    await fs.writeFile(tempPath, payload, "utf8");
+    await fs.rename(tempPath, targetPath);
+}
+//# sourceMappingURL=workflow-storage.js.map

package/dist/server/server/workspace/all-sessions-route.d.ts

@@ -0,0 +1,32 @@
+import type express from "express";
+import type pino from "pino";
+export interface AllSessionsEntry {
+    sid: string;
+    title: string | null;
+    lastActivity: string;
+    cwd: string;
+    agentName: string | null;
+}
+export interface AllSessionsResponse {
+    sessions: AllSessionsEntry[];
+}
+export interface AllSessionsRouteOptions {
+    /**
+     * Override the Claude projects root. Defaults to `~/.claude/projects/`.
+     * Tests pass a tmp dir to avoid scanning the developer's real session store.
+     */
+    projectsRoot?: string;
+}
+/** Default Claude projects root (`~/.claude/projects/`). */
+export declare function defaultProjectsRoot(): string;
+/**
+ * Core session enumeration — walks `<projectsRoot>/<cwd-slug>/<sid>.jsonl`
+ * and returns every restorable session header, newest-first. Shared by the
+ * HTTP `GET /sessions` route AND the `list_all_sessions_request` WS handler
+ * (so the command palette works over the relay, where HTTP is unavailable).
+ *
+ * Throws on a non-ENOENT readdir failure; ENOENT (fresh machine) yields `[]`.
+ */
+export declare function collectAllSessions(projectsRoot: string, logger: pino.Logger): Promise<AllSessionsEntry[]>;
+export declare function registerAllSessionsRoute(app: express.Express, logger: pino.Logger, options?: AllSessionsRouteOptions): void;
+//# sourceMappingURL=all-sessions-route.d.ts.map