@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/mesh/live/spool.js

@@ -5,6 +5,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { randomBytes } from "node:crypto";
 import { ensureOwnerDir } from "../../work-context/atomic.js";
 import { workMeshClaimPath, workMeshDeadLetterPath, workMeshDroppedReceiptPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "./paths.js";
 /** Linux PIPE_BUF is typically 4096; keep a conservative ceiling for one line. */
@@ -65,12 +66,160 @@ export function appendSpoolLine(line, root) {
 }
 export function appendHeldLine(line, root) {
     const held = workMeshHeldPath(root ?? workMeshRoot());
-    appendJsonlLine(held, line);
+    appendHeldLineIfAbsent(line, root);
     return held;
 }
+/** Append a held envelope only when its eventId is not already held. */
+export function appendHeldLineIfAbsent(line, root) {
+    return appendHeldLinesIfAbsent([line], root) === 1;
+}
+/** Append a deduplicated held batch under one file lock and one write. */
+export function appendHeldLinesIfAbsent(lines, root) {
+    const heldPath = workMeshHeldPath(root ?? workMeshRoot());
+    ensureSpoolFile(heldPath);
+    return withJsonlLock(heldPath, () => {
+        const seen = readEventIds(heldPath);
+        const append = [];
+        for (const line of lines) {
+            const eventId = heldEventId(line);
+            if (eventId) {
+                if (seen.has(eventId))
+                    continue;
+                seen.add(eventId);
+            }
+            append.push(line);
+        }
+        appendJsonlLines(heldPath, append);
+        return append.length;
+    });
+}
+function heldEventId(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        const record = parsed;
+        const event = record.event && typeof record.event === "object" && !Array.isArray(record.event)
+            ? record.event
+            : record;
+        return typeof event.eventId === "string" && event.eventId.trim() ? event.eventId.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readEventIds(filePath) {
+    const ids = new Set();
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return ids;
+        throw error;
+    }
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        const eventId = heldEventId(line);
+        if (eventId)
+            ids.add(eventId);
+    }
+    return ids;
+}
+function appendJsonlLines(filePath, lines) {
+    if (lines.length === 0)
+        return;
+    ensureSpoolFile(filePath);
+    fs.appendFileSync(filePath, `${lines.join("\n")}\n`, { encoding: "utf8", mode: 0o600 });
+    chmodOwnerFile(filePath);
+}
+const JSONL_LOCK_STALE_MS = 5 * 60_000;
+const JSONL_LOCK_TIMEOUT_MS = 5_000;
+/** Serialize check-and-append with claims; stale locks expire after five minutes. */
+function withJsonlLock(filePath, fn) {
+    const lockPath = `${filePath}.lock`;
+    const token = randomBytes(12).toString("hex");
+    const deadline = Date.now() + JSONL_LOCK_TIMEOUT_MS;
+    const waitCell = new Int32Array(new SharedArrayBuffer(4));
+    while (true) {
+        try {
+            const fd = fs.openSync(lockPath, "wx", 0o600);
+            try {
+                fs.writeSync(fd, JSON.stringify({ pid: process.pid, token, at: Date.now() }));
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            let stale = false;
+            try {
+                const before = fs.statSync(lockPath);
+                stale = Date.now() - before.mtimeMs >= JSONL_LOCK_STALE_MS;
+                if (stale) {
+                    const after = fs.statSync(lockPath);
+                    if (before.dev === after.dev && before.ino === after.ino && after.mtimeMs === before.mtimeMs) {
+                        fs.unlinkSync(lockPath);
+                    }
+                    else {
+                        stale = false;
+                    }
+                }
+            }
+            catch (statError) {
+                if (statError.code !== "ENOENT")
+                    throw statError;
+            }
+            if (stale)
+                continue;
+            if (Date.now() >= deadline)
+                throw new SpoolWriteError(`Timed out waiting for ${path.basename(filePath)} lock`);
+            Atomics.wait(waitCell, 0, 0, 10);
+        }
+    }
+    let result;
+    let operationError;
+    let operationFailed = false;
+    try {
+        result = fn();
+    }
+    catch (error) {
+        operationError = error;
+        operationFailed = true;
+    }
+    let cleanupError;
+    try {
+        const record = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+        if (record.token === token)
+            fs.unlinkSync(lockPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            cleanupError = error;
+    }
+    if (operationFailed && cleanupError !== undefined) {
+        throw new AggregateError([operationError, cleanupError], "JSONL write and lock cleanup failed");
+    }
+    if (operationFailed)
+        throw operationError;
+    if (cleanupError !== undefined)
+        throw cleanupError;
+    return result;
+}
 export function appendDeadLetterLine(line, root) {
     const dl = workMeshDeadLetterPath(root ?? workMeshRoot());
-    appendJsonlLine(dl, line);
+    withJsonlLock(dl, () => {
+        ensureSpoolFile(dl);
+        const ids = readEventIds(dl);
+        const eventId = heldEventId(line);
+        if (!eventId || !ids.has(eventId))
+            appendJsonlLine(dl, line);
+    });
     return dl;
 }
 export function appendDroppedReceipt(receipt, root) {
@@ -108,7 +257,8 @@ export function claimSpool(root, ts = `${Date.now()}`) {
 }
 export function claimHeld(root, ts = `${Date.now()}`) {
     ensureOwnerDir(root);
-    return claimJsonlByRename(workMeshHeldPath(root), workMeshClaimPath("held", ts, root));
+    const heldPath = workMeshHeldPath(root);
+    return withJsonlLock(heldPath, () => claimJsonlByRename(heldPath, workMeshClaimPath("held", ts, root)));
 }
 /** Match leftover claim files: spool.<ts>.claimed / held.<ts>.claimed (and held.<ts>.held.claimed). */
 const ORPHAN_CLAIM_RE = /^(spool|held)\..+\.claimed$/;
@@ -195,4 +345,120 @@ export function countJsonlLines(filePath) {
     }
     return n;
 }
+/** Count held eventIds once; legacy rows without an eventId remain line-counted. */
+export function countDistinctHeldEvents(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        // A concurrent claim can rename held.jsonl between existence and read checks.
+        return 0;
+    }
+    const seen = new Set();
+    let count = 0;
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        const eventId = heldEventId(line);
+        if (eventId) {
+            if (seen.has(eventId))
+                continue;
+            seen.add(eventId);
+        }
+        count += 1;
+    }
+    return count;
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * A queue line can be a raw event, a held envelope, or a dead-letter
+ * envelope. Count the line when it is explicitly marked NEEDS_COMPANY/NONE,
+ * or when its underlying event has no company identity at all.
+ */
+function isUnattributedLine(line) {
+    try {
+        const outer = record(JSON.parse(line));
+        if (!outer)
+            return false;
+        const event = record(outer.event) ?? outer;
+        const markers = [
+            outer.heldReason,
+            outer.reason,
+            outer.contextStatus,
+            event.heldReason,
+            event.reason,
+            event.contextStatus,
+            event.company,
+            event.companyUid,
+            event.companySlug,
+        ];
+        if (markers.some((value) => typeof value === "string" &&
+            ["NEEDS_COMPANY", "NONE"].includes(value.trim().toUpperCase()))) {
+            return true;
+        }
+        return ![
+            event.companyUid,
+            event.companySlug,
+            event.company,
+        ].some((value) => typeof value === "string" && value.trim().length > 0);
+    }
+    catch {
+        // Malformed lines are reported separately by the dead-letter count.
+        return false;
+    }
+}
+function countUnattributedJsonlLines(filePath) {
+    if (!fs.existsSync(filePath))
+        return 0;
+    try {
+        return fs
+            .readFileSync(filePath, "utf8")
+            .split("\n")
+            .filter((line) => line.trim() && isUnattributedLine(line)).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Count the actionable, unfiled events across all local delivery queues.
+ * This deliberately does not inspect session state: the signal must stay
+ * visible even when state is absent or corrupt.
+ */
+export function countUnattributedEvents(root) {
+    const meshRoot = root ?? workMeshRoot();
+    const spool = countUnattributedJsonlLines(workMeshSpoolPath(meshRoot));
+    const held = countUnattributedHeldEvents(workMeshHeldPath(meshRoot));
+    const deadLetter = countUnattributedJsonlLines(workMeshDeadLetterPath(meshRoot));
+    return { spool, held, deadLetter, total: spool + held + deadLetter };
+}
+function countUnattributedHeldEvents(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        // A concurrent held claim may rename this file between the read and open.
+        return 0;
+    }
+    const seen = new Set();
+    let count = 0;
+    for (const line of raw.split("\n")) {
+        if (!line.trim() || !isUnattributedLine(line))
+            continue;
+        const eventId = heldEventId(line);
+        if (eventId) {
+            if (seen.has(eventId))
+                continue;
+            seen.add(eventId);
+        }
+        count += 1;
+    }
+    return count;
+}
 //# sourceMappingURL=spool.js.map

package/dist/lib/mesh/live/validate-session-event.d.ts

@@ -8,7 +8,7 @@
 import type { ValidateFunction } from "ajv";
 export declare const SESSION_EVENT_SCHEMA_PATH: string;
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export declare const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
+export declare const SESSION_EVENT_SCHEMA_SHA256 = "e3a9b05daf0037688809e8825a286f9dc89d69aa9266696270d776b64bf99dda";
 export declare const PROHIBITED_CONTENT_CLASSES: readonly ["prompts", "model_output", "transcripts", "message_bodies", "tokens", "credentials"];
 export type ProhibitedContentClass = (typeof PROHIBITED_CONTENT_CLASSES)[number];
 /** Fixture field name → prohibited class. */

package/dist/lib/mesh/live/validate-session-event.js

@@ -13,7 +13,7 @@ import Ajv2020 from "ajv/dist/2020.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const SESSION_EVENT_SCHEMA_PATH = join(HERE, "session-event.schema.json");
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
+export const SESSION_EVENT_SCHEMA_SHA256 = "e3a9b05daf0037688809e8825a286f9dc89d69aa9266696270d776b64bf99dda";
 export const PROHIBITED_CONTENT_CLASSES = [
     "prompts",
     "model_output",

package/dist/lib/mesh/project-board.d.ts

@@ -0,0 +1,65 @@
+import { type MeshCompany, type MeshProjectRegistration, type MeshProjectRepo, type MeshProjectStoryInput, type MeshProjectView } from "./api.js";
+/** Same merge as `hq mesh project ensure`: add missing stories, keep live status. */
+export declare function mergeProjectStories(current: MeshProjectStoryInput[], planned: MeshProjectStoryInput[], opts?: {
+    resetStatus?: boolean;
+}): MeshProjectStoryInput[];
+export declare function boardStoryStatus(story: MeshProjectStoryInput): string;
+/**
+ * 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 declare function prdSyncEventsThatChangeBoard<T extends {
+    taskId: string;
+    status: string;
+}>(events: readonly T[], boardStories: readonly MeshProjectStoryInput[]): T[];
+/** One-line summary of live→next status diffs for existing story ids. */
+export declare function formatStoryStatusChanges(current: MeshProjectStoryInput[], next: MeshProjectStoryInput[]): string | undefined;
+/**
+ * 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 declare function ensureMissingBoardStories(input: {
+    token: string;
+    company: MeshCompany;
+    projectId: string;
+    name: string;
+    description?: string;
+    stories: MeshProjectStoryInput[];
+    repos?: MeshProjectRepo[];
+    requiredIds: readonly string[];
+}): Promise<void>;
+/**
+ * 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 declare function closeSupersededProjectThread(input: {
+    token: string;
+    companyUid: string;
+    openedThreadId: string;
+    canonicalThreadId: string;
+    created: boolean;
+}): Promise<void>;
+/**
+ * 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 declare function ensureProjectBoard(input: {
+    token: string;
+    company: MeshCompany;
+    projectId: string;
+    name: string;
+    description?: string;
+    stories: MeshProjectStoryInput[];
+    repos?: MeshProjectRepo[];
+    channelId?: string;
+}): Promise<{
+    view: MeshProjectView;
+    registration: MeshProjectRegistration;
+}>;
+//# sourceMappingURL=project-board.d.ts.map

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

@@ -0,0 +1,181 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,49 @@
+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