@svenroth-ai/shipwright 0.24.1-next.0

package/server/dist/core/triage-paths.js

@@ -0,0 +1,125 @@
+/*
+ * triage-paths.ts — centralized resolver for `<project>/.shipwright/triage.jsonl`.
+ *
+ * Reuses the existing `pathGuard` semantics (realpath + path.relative) so
+ * symlinks pointing outside the project can't redirect reads/writes
+ * (mirrors the gitignore + tree route protection from ADR-044). Every
+ * triage endpoint MUST flow through this helper — read OR write.
+ *
+ * Returned absolute path is realpath-resolved when the file exists; for
+ * the "file doesn't exist yet" case (first triage write on a project)
+ * we resolve the parent .shipwright directory and append the static
+ * filename, which is safe because path resolution can't escape an
+ * already-validated parent.
+ */
+import path from "node:path";
+import { existsSync, realpathSync, statSync } from "node:fs";
+const SUBDIR = ".shipwright";
+const FILENAME = "triage.jsonl";
+/**
+ * Per-tree, GITIGNORED background-triage buffer (campaign
+ * 2026-06-08-triage-outbox-delivery / D1). Idle-main background producers
+ * append HERE instead of the tracked `triage.jsonl`; the webui reads the
+ * union (tracked ∪ outbox) so those findings stay visible in the live
+ * Inbox without waiting for the sweep+merge round-trip. Mirrors
+ * `shared/scripts/triage.py OUTBOX_FILE`.
+ */
+const OUTBOX_FILENAME = "triage.outbox.jsonl";
+/**
+ * Derive the per-tree outbox path that sits alongside an already-resolved
+ * tracked `triage.jsonl` path. The outbox lives in the SAME `.shipwright`
+ * directory that `resolveTriagePath` already realpath-guarded, so it
+ * inherits that traversal protection — there is no new path-guard surface.
+ * Pass the `absolute` from a successful `resolveTriagePath` result.
+ */
+export function outboxPathFor(trackedAbsolute) {
+    return path.join(path.dirname(trackedAbsolute), OUTBOX_FILENAME);
+}
+export function resolveTriagePath(project) {
+    if (project.synthesized) {
+        return { ok: false, error: { reason: "synthesized_project" } };
+    }
+    if (!project.path || typeof project.path !== "string") {
+        return { ok: false, error: { reason: "missing_project_path" } };
+    }
+    // Resolve project.path to its realpath (if it exists). Fall through to
+    // the literal value if the directory doesn't exist (caller will 404
+    // separately).
+    let projectRoot;
+    try {
+        projectRoot = realpathSync(project.path);
+    }
+    catch {
+        projectRoot = path.resolve(project.path);
+    }
+    // Refuse non-directory project roots — defense in depth against an
+    // operator who registered a file path by mistake.
+    try {
+        const st = statSync(projectRoot);
+        if (!st.isDirectory()) {
+            return { ok: false, error: { reason: "project_root_not_directory" } };
+        }
+    }
+    catch {
+        // Project root doesn't exist — let the route layer return 404.
+        // We still emit the candidate path so the route can decide.
+        const candidate = path.join(projectRoot, SUBDIR, FILENAME);
+        return { ok: true, absolute: candidate, existed: false };
+    }
+    const candidate = path.resolve(projectRoot, SUBDIR, FILENAME);
+    // realpath the candidate when it exists to defeat symlink redirect.
+    // When it doesn't exist yet, we realpath the parent directory and
+    // re-append the filename — the only way an attacker can escape from
+    // a non-existent file is via the parent .shipwright dir, which we
+    // guard separately.
+    if (existsSync(candidate)) {
+        let resolved;
+        try {
+            resolved = realpathSync(candidate);
+        }
+        catch {
+            return { ok: false, error: { reason: "path_traversal" } };
+        }
+        if (!isWithin(projectRoot, resolved)) {
+            return { ok: false, error: { reason: "path_traversal" } };
+        }
+        return { ok: true, absolute: resolved, existed: true };
+    }
+    // File doesn't exist — verify the parent dir (if it exists) is within
+    // project root.
+    const parent = path.dirname(candidate);
+    if (existsSync(parent)) {
+        let resolvedParent;
+        try {
+            resolvedParent = realpathSync(parent);
+        }
+        catch {
+            return { ok: false, error: { reason: "path_traversal" } };
+        }
+        if (!isWithin(projectRoot, resolvedParent)) {
+            return { ok: false, error: { reason: "path_traversal" } };
+        }
+        return {
+            ok: true,
+            absolute: path.join(resolvedParent, FILENAME),
+            existed: false,
+        };
+    }
+    // Parent .shipwright doesn't exist either — caller decides whether to
+    // mkdir. Return the static candidate.
+    return { ok: true, absolute: candidate, existed: false };
+}
+function isWithin(projectRoot, candidate) {
+    const rel = path.relative(projectRoot, candidate);
+    if (!rel)
+        return true; // exact match — root itself
+    if (rel.startsWith(".."))
+        return false;
+    if (path.isAbsolute(rel))
+        return false;
+    // segment-wise check: rejects e.g. "..foo" only when the leading ".."
+    // is its own segment (path.relative doesn't produce that, but defense
+    // in depth).
+    return true;
+}
+//# sourceMappingURL=triage-paths.js.map

package/server/dist/core/triage-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-paths.js","sourceRoot":"","sources":["../../src/core/triage-paths.ts"],"names":[],"mappings":"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"}

package/server/dist/core/triage-raw.d.ts

@@ -0,0 +1,33 @@
+import { type CorruptFragment } from "./jsonl-records.js";
+/**
+ * Tolerant string→objects parser — splits a raw JSONL blob into plain objects,
+ * RECOVERING concatenated records and skipping blank lines. Boundary rules
+ * live in `jsonl-records.ts`.
+ *
+ * `onCorrupt` is the optional side channel for undecodable text. The array
+ * return type is load-bearing: it flows through `readRawLines` to five call
+ * sites, one (`appendIdsInFile`) on the WRITE hot path driving residence
+ * routing — a shape change here would alter WRITES, not just reads.
+ *
+ * Exported so the delivered-origin composer (`triage-origin.ts`) can parse a
+ * `git show origin/…:…` blob through the SAME contract as on-disk reads.
+ */
+export declare function parseRawLines(raw: string, onCorrupt?: (fragment: CorruptFragment) => void): Record<string, unknown>[];
+/**
+ * Tolerant per-file reader — parses one JSONL file into plain objects.
+ * Returns [] when the file is missing/unreadable.
+ */
+export declare function readRawLines(p: string, onCorrupt?: (fragment: CorruptFragment) => void): Record<string, unknown>[];
+/**
+ * Raw JSONL lines for the LOCAL union, kept SPLIT as `{ tracked, outbox }`
+ * (each in file order). `readAllItems` resolves the concatenation
+ * `[...tracked, ...outbox]`; the delivered-origin composer instead splices the
+ * origin source between them (`[...tracked, ...origin, ...outbox]`) so the
+ * outbox stays LAST — preserving the existing "freshest local intent wins an
+ * equal-ts tie" file-order contract.
+ */
+export declare function readLocalRawLinesSplit(trackedPath: string, onCorrupt?: (fragment: CorruptFragment, source: "tracked" | "outbox") => void): {
+    tracked: Record<string, unknown>[];
+    outbox: Record<string, unknown>[];
+};
+//# sourceMappingURL=triage-raw.d.ts.map

package/server/dist/core/triage-raw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-raw.d.ts","sourceRoot":"","sources":["../../src/core/triage-raw.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,oBAAoB,CAAC;AAG7E;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GAC9C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAI3B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,MAAM,EACT,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GAC9C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,GAAG,QAAQ,KAAK,IAAI,GAC5E;IACD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACnC,CAMA"}

package/server/dist/core/triage-raw.js

@@ -0,0 +1,66 @@
+/*
+ * triage-raw.ts — raw JSONL line reading for the triage store. Split out of
+ * triage-store.ts (iterate-2026-08-05-triage-deferred-envelope) purely to
+ * keep that file under its bloat-baseline ceiling; no behavior changed by
+ * the move.
+ *
+ * Tolerance contract (matches Python `_iter_raw_lines_at`):
+ *   - RECOVERS concatenated records — a line holding several records (an
+ *     unterminated predecessor) yields ALL of them, not none.
+ *   - undecodable text goes to the optional `onCorrupt` side channel — never
+ *     thrown, never logged here (reporting belongs at the command boundary)
+ *   - skips non-object lines + lines without an "event" key (header)
+ */
+import { readFileSync } from "node:fs";
+import { parseJsonlRecords } from "./jsonl-records.js";
+import { outboxPathFor } from "./triage-paths.js";
+/**
+ * Tolerant string→objects parser — splits a raw JSONL blob into plain objects,
+ * RECOVERING concatenated records and skipping blank lines. Boundary rules
+ * live in `jsonl-records.ts`.
+ *
+ * `onCorrupt` is the optional side channel for undecodable text. The array
+ * return type is load-bearing: it flows through `readRawLines` to five call
+ * sites, one (`appendIdsInFile`) on the WRITE hot path driving residence
+ * routing — a shape change here would alter WRITES, not just reads.
+ *
+ * Exported so the delivered-origin composer (`triage-origin.ts`) can parse a
+ * `git show origin/…:…` blob through the SAME contract as on-disk reads.
+ */
+export function parseRawLines(raw, onCorrupt) {
+    const { records, corrupt } = parseJsonlRecords(raw);
+    if (onCorrupt)
+        for (const fragment of corrupt)
+            onCorrupt(fragment);
+    return records;
+}
+/**
+ * Tolerant per-file reader — parses one JSONL file into plain objects.
+ * Returns [] when the file is missing/unreadable.
+ */
+export function readRawLines(p, onCorrupt) {
+    let raw;
+    try {
+        raw = readFileSync(p, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    return parseRawLines(raw, onCorrupt);
+}
+/**
+ * Raw JSONL lines for the LOCAL union, kept SPLIT as `{ tracked, outbox }`
+ * (each in file order). `readAllItems` resolves the concatenation
+ * `[...tracked, ...outbox]`; the delivered-origin composer instead splices the
+ * origin source between them (`[...tracked, ...origin, ...outbox]`) so the
+ * outbox stays LAST — preserving the existing "freshest local intent wins an
+ * equal-ts tie" file-order contract.
+ */
+export function readLocalRawLinesSplit(trackedPath, onCorrupt) {
+    const outboxPath = outboxPathFor(trackedPath);
+    return {
+        tracked: readRawLines(trackedPath, onCorrupt && ((f) => onCorrupt(f, "tracked"))),
+        outbox: readRawLines(outboxPath, onCorrupt && ((f) => onCorrupt(f, "outbox"))),
+    };
+}
+//# sourceMappingURL=triage-raw.js.map

package/server/dist/core/triage-raw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-raw.js","sourceRoot":"","sources":["../../src/core/triage-raw.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,OAAO,EAAwB,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,GAAW,EACX,SAA+C;IAE/C,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACpD,IAAI,SAAS;QAAE,KAAK,MAAM,QAAQ,IAAI,OAAO;YAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IACnE,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC1B,CAAS,EACT,SAA+C;IAE/C,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,aAAa,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CACpC,WAAmB,EACnB,SAA6E;IAK7E,MAAM,UAAU,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;IAC9C,OAAO;QACL,OAAO,EAAE,YAAY,CAAC,WAAW,EAAE,SAAS,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;QACjF,MAAM,EAAE,YAAY,CAAC,UAAU,EAAE,SAAS,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;KAC/E,CAAC;AACJ,CAAC"}

package/server/dist/core/triage-store.d.ts

@@ -0,0 +1,42 @@
+import type { TriageItem } from "../types/triage.js";
+export { parseRawLines, readLocalRawLinesSplit } from "./triage-raw.js";
+/** Forced cache eviction for test support after a fixture mutation. */
+export declare function invalidateCacheForPath(path: string): void;
+/** Test-only — clear the entire cache. Exported so vitest setup can isolate runs. */
+export declare function _clearCache_TEST_ONLY(): void;
+/**
+ * Two-pass union resolution over already-parsed raw lines (tracked THEN
+ * outbox, file order). Byte-for-byte mirror of Python `read_all_items`'s
+ * resolution body — Pass 1 applies all `append` events, Pass 2 applies all
+ * `status` AND `amend` events together, ordered by (ts, file-order).
+ *
+ * Exported for the delivered-origin composer (`triage-compose.ts`): the same
+ * multi-source union already reconciles tracked ∪ outbox, so adding origin as
+ * a third raw-line source is a natural extension resolved by identical rules.
+ */
+export declare function resolveUnion(rawLines: Record<string, unknown>[]): TriageItem[];
+/**
+ * Read and resolve every triage item for a project, sourcing the UNION of
+ * the tracked store (`trackedPath`) and the per-tree outbox buffer alongside
+ * it. Returns [] when neither file exists (so consumers need no separate
+ * existence check).
+ *
+ * `trackedPath` is the absolute tracked `triage.jsonl` path (from
+ * `resolveTriagePath().absolute`); the outbox sibling is derived via
+ * `outboxPathFor`.
+ */
+export declare function readAllItems(trackedPath: string): TriageItem[];
+/**
+ * Set of `append`-event ids in ONE file (residence probe for the
+ * residence-derived status write in the Python CLI). Mirrors Python
+ * `_append_ids_at`. Tolerant — skips corrupt lines.
+ */
+export declare function appendIdsInFile(jsonlPath: string): Set<string>;
+/** Convenience: filter to active triage status. */
+export declare function filterTriage(items: TriageItem[]): TriageItem[];
+/**
+ * Find a single item by id (linear scan). Used by the route layer for
+ * existence + status checks.
+ */
+export declare function findItemById(items: TriageItem[], id: string): TriageItem | undefined;
+//# sourceMappingURL=triage-store.d.ts.map

package/server/dist/core/triage-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-store.d.ts","sourceRoot":"","sources":["../../src/core/triage-store.ts"],"names":[],"mappings":"AA6DA,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,oBAAoB,CAAC;AAMnE,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAyBxE,uEAAuE;AACvE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzD;AAED,qFAAqF;AACrF,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAiBD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,UAAU,EAAE,CAoF9E;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU,EAAE,CA2C9D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAQ9D;AAED,mDAAmD;AACnD,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAE9D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EAAE,EACnB,EAAE,EAAE,MAAM,GACT,UAAU,GAAG,SAAS,CAExB"}

package/server/dist/core/triage-store.js

@@ -0,0 +1,268 @@
+/*
+ * triage-store.ts — TS port of `triage.read_all_items` from
+ * `shared/scripts/triage.py`. Pure read path; status flips go through
+ * the Python triage CLI. Raw JSONL line reading lives in `triage-raw.ts`.
+ *
+ * UNION read (campaign 2026-06-08-triage-outbox-delivery / D1): the
+ * resolved view sources the tracked `triage.jsonl` AND the per-tree,
+ * gitignored `triage.outbox.jsonl` buffer (idle-main background producers
+ * append there, never the tracked store). Reading the union keeps those
+ * findings visible in the live Inbox without waiting for the D2
+ * sweep+merge round-trip. Raw lines are concatenated tracked-THEN-outbox
+ * (file order); resolution is by id, so a line present in both (post-sweep,
+ * pre-GC) collapses to one item.
+ *
+ * Two-pass resolution (matches Python read_all_items):
+ *   - Pass 1 applies ALL `append` events (base records, union of both files)
+ *   - Pass 2 applies ALL `status` AND `amend` events TOGETHER, ordered by
+ *     (ts, file-order): ts is primary so the chronologically-later event in
+ *     EITHER file wins REGARDLESS OF EVENT TYPE; file order (tracked-before-
+ *     outbox) is the stable tiebreaker for equal ts, preserving the
+ *     single-file "later valid line wins by file order" contract. The
+ *     append-first split stops an outbox append (status:triage) from
+ *     clobbering a tracked status flip. Each event type keeps its own
+ *     overlay semantics (status: whole-field replace; amend: only present
+ *     fields, via `triage-amend.ts tryApplyAmend`) — interleaving them by
+ *     time is what makes two amends ACCUMULATE (each is a merge) while a
+ *     later status still fully supersedes an earlier one (iterate-2026-08-08-
+ *     triage-amend-reader; byte-for-byte mirror of `triage.py`
+ *     read_all_items` Pass 2, which loops one combined sorted list rather
+ *     than two separate passes).
+ *   - status overlay sets: status, ts, statusBy, statusReason, revisitAt
+ *   - promotedTaskId only set when the status event carries a non-null value
+ *   - amend overlay sets: title/detail/severity/kind (present fields only),
+ *     suggestedPriority (on a severity amend), amendedBy, amendedAt — never
+ *     `ts`, which stays "time of the last STATUS decision"
+ *
+ * Park-expiry overlay (monorepo P2.03, iterate-2026-08-05-triage-deferred-
+ * envelope): `applyDeferOverlay` (triage-defer.ts) runs exactly ONCE, right
+ * after the two-pass resolution, mirroring where Python's `read_all_items`
+ * applies `_defer.apply_revisit_expiry` — never re-applied to its own output
+ * (see triage-defer.ts's module header for why that matters).
+ *
+ * Cache (5 s soft TTL) keyed by the tracked path, keyed on BOTH the tracked
+ * AND outbox mtimes — a change to either file invalidates. Forced eviction
+ * from test support after a fixture mutation.
+ *
+ * The overlay result depends on wall-clock time, not just file bytes, so a
+ * cache hit alone cannot answer "is this still correct" — a park's due day
+ * can turn over WITHIN the 5 s TTL with neither file touched (doubt review,
+ * iterate-2026-08-05-triage-deferred-envelope). Each entry therefore also
+ * remembers `overlayDay` (the UTC calendar day `items` was computed for): a
+ * cache hit on the SAME day returns `items` unchanged (identical array
+ * reference — the pre-overlay `rawItems` are never re-mapped); a hit whose
+ * day has turned over re-applies `applyDeferOverlay` to the SAME `rawItems`
+ * (no re-read, no re-parse) and remembers the new day. This keeps the
+ * common case free (one .map() at most once per calendar day per path)
+ * while never serving a stale-by-more-than-nothing due-state.
+ */
+import { statSync } from "node:fs";
+import { AMENDED_AT_FIELD, AMENDED_BY_FIELD, tryApplyAmend } from "./triage-amend.js";
+import { applyDeferOverlay, utcToday } from "./triage-defer.js";
+import { readRawLines } from "./triage-raw.js";
+import { outboxPathFor } from "./triage-paths.js";
+export { parseRawLines, readLocalRawLinesSplit } from "./triage-raw.js";
+const STATUSES = new Set([
+    "triage",
+    "promoted",
+    "dismissed",
+    "snoozed",
+]);
+const CACHE_TTL_MS = 5_000;
+const cache = new Map();
+/** Forced cache eviction for test support after a fixture mutation. */
+export function invalidateCacheForPath(path) {
+    cache.delete(path);
+}
+/** Test-only — clear the entire cache. Exported so vitest setup can isolate runs. */
+export function _clearCache_TEST_ONLY() {
+    cache.clear();
+}
+/** mtime in ms, or null when the file is absent / unstat-able. */
+function mtimeOrNull(p) {
+    try {
+        return statSync(p).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+/** ISO-8601-Z string sort key; non-string/missing ts sorts EARLIEST (""). */
+function tsKey(raw) {
+    const ts = raw.ts;
+    return typeof ts === "string" ? ts : "";
+}
+/**
+ * Two-pass union resolution over already-parsed raw lines (tracked THEN
+ * outbox, file order). Byte-for-byte mirror of Python `read_all_items`'s
+ * resolution body — Pass 1 applies all `append` events, Pass 2 applies all
+ * `status` AND `amend` events together, ordered by (ts, file-order).
+ *
+ * Exported for the delivered-origin composer (`triage-compose.ts`): the same
+ * multi-source union already reconciles tracked ∪ outbox, so adding origin as
+ * a third raw-line source is a natural extension resolved by identical rules.
+ */
+export function resolveUnion(rawLines) {
+    // Pass 1 — every append establishes a base record (union of both files).
+    // A duplicate append for the same id (post-sweep, pre-GC) collapses to one
+    // record; the later line's fields win (identical content → harmless).
+    const resolved = new Map();
+    for (const raw of rawLines) {
+        if (raw.event !== "append")
+            continue;
+        const id = raw.id;
+        if (typeof id !== "string")
+            continue;
+        const item = {};
+        for (const [k, v] of Object.entries(raw)) {
+            if (k === "event")
+                continue;
+            item[k] = v;
+        }
+        item.statusBy = null;
+        item.statusReason = null;
+        item.promotedTaskId = null;
+        // Revisit semantics belong only to a valid `snoozed` status event — a
+        // hand-edited append must not acquire park semantics (mirrors Python).
+        item.revisitAt = null;
+        item[AMENDED_BY_FIELD] = null;
+        item[AMENDED_AT_FIELD] = null;
+        resolved.set(id, item);
+    }
+    // Pass 2 — overlay status flips AND amends TOGETHER, ordered by
+    // (ts, file-order). ts is primary so a chronologically-later event in
+    // EITHER file wins regardless of type; the enumerate index is the stable
+    // tiebreaker for equal ts (tracked precedes outbox).
+    const statusAndAmendEvents = [];
+    rawLines.forEach((raw, idx) => {
+        if (raw.event === "status" || raw.event === "amend")
+            statusAndAmendEvents.push({ idx, raw });
+    });
+    statusAndAmendEvents.sort((a, b) => {
+        const ta = tsKey(a.raw);
+        const tb = tsKey(b.raw);
+        if (ta < tb)
+            return -1;
+        if (ta > tb)
+            return 1;
+        return a.idx - b.idx;
+    });
+    for (const { raw } of statusAndAmendEvents) {
+        const id = raw.id;
+        if (typeof id !== "string")
+            continue;
+        const item = resolved.get(id);
+        if (!item)
+            continue; // status/amend for unknown id (corrupt / out-of-order) — skip
+        if (raw.event === "amend") {
+            tryApplyAmend(item, raw);
+            continue;
+        }
+        const newStatus = raw.newStatus;
+        if (typeof newStatus === "string" && STATUSES.has(newStatus)) {
+            item.status = newStatus;
+        }
+        // Per-field overlay is byte-identical to the pre-union single-pass port
+        // (AC5: existing single-file behavior unchanged). The ONLY new behavior
+        // is the union source + the (ts, file-order) ordering above — NOT the
+        // per-line overlay semantics. The typeof guards also keep the webui's
+        // stricter `TriageItem` type contract (ts: string; promotedTaskId:
+        // string | null) intact for malformed-but-tolerated status events, where
+        // Python's verbatim `raw.get(...)` would leak a non-string through.
+        const overlayTs = raw.ts;
+        if (typeof overlayTs === "string") {
+            item.ts = overlayTs;
+        }
+        item.statusBy = raw.by ?? null;
+        item.statusReason = raw.reason ?? null;
+        // A valid `snoozed` flip takes its supplied revisit date; any other flip
+        // (un-park/dismiss/promote) clears it, even if a hand-edited event
+        // illegally carries park semantics on a non-snoozed status.
+        const revisit = raw.revisitAt;
+        item.revisitAt =
+            newStatus === "snoozed" && typeof revisit === "string" ? revisit : null;
+        const promoted = raw.promotedTaskId;
+        // Only a non-null promotedTaskId overrides (null/absent keep the prior
+        // value); non-strings are coerced to preserve the string|null contract.
+        if (promoted !== undefined && promoted !== null) {
+            item.promotedTaskId =
+                typeof promoted === "string" ? promoted : String(promoted);
+        }
+    }
+    return Array.from(resolved.values());
+}
+/**
+ * Read and resolve every triage item for a project, sourcing the UNION of
+ * the tracked store (`trackedPath`) and the per-tree outbox buffer alongside
+ * it. Returns [] when neither file exists (so consumers need no separate
+ * existence check).
+ *
+ * `trackedPath` is the absolute tracked `triage.jsonl` path (from
+ * `resolveTriagePath().absolute`); the outbox sibling is derived via
+ * `outboxPathFor`.
+ */
+export function readAllItems(trackedPath) {
+    const outboxPath = outboxPathFor(trackedPath);
+    const trackedMtimeMs = mtimeOrNull(trackedPath);
+    const outboxMtimeMs = mtimeOrNull(outboxPath);
+    // Neither file present — no triage store at all.
+    if (trackedMtimeMs === null && outboxMtimeMs === null)
+        return [];
+    const now = new Date();
+    const today = utcToday(now);
+    // Dual-mtime cache lookup (keyed by the tracked path).
+    const cached = cache.get(trackedPath);
+    if (cached &&
+        cached.trackedMtimeMs === trackedMtimeMs &&
+        cached.outboxMtimeMs === outboxMtimeMs &&
+        Date.now() - cached.filledAt < CACHE_TTL_MS) {
+        if (cached.overlayDay === today)
+            return cached.items;
+        // Same bytes, but the UTC day turned over since the cache filled — the
+        // overlay is a pure function of (rawItems, today), so re-apply it to
+        // the ALREADY-PARSED rawItems (no re-read, no re-parse) rather than
+        // serving a due-state that's stale by more than nothing.
+        cached.items = applyDeferOverlay(cached.rawItems, now);
+        cached.overlayDay = today;
+        return cached.items;
+    }
+    // Tolerant union read: tracked lines THEN outbox lines (file order).
+    const rawLines = [...readRawLines(trackedPath), ...readRawLines(outboxPath)];
+    const rawItems = resolveUnion(rawLines);
+    const items = applyDeferOverlay(rawItems, now);
+    cache.set(trackedPath, {
+        trackedMtimeMs,
+        outboxMtimeMs,
+        filledAt: Date.now(),
+        rawItems,
+        overlayDay: today,
+        items,
+    });
+    return items;
+}
+/**
+ * Set of `append`-event ids in ONE file (residence probe for the
+ * residence-derived status write in the Python CLI). Mirrors Python
+ * `_append_ids_at`. Tolerant — skips corrupt lines.
+ */
+export function appendIdsInFile(jsonlPath) {
+    const ids = new Set();
+    for (const raw of readRawLines(jsonlPath)) {
+        if (raw.event === "append" && typeof raw.id === "string") {
+            ids.add(raw.id);
+        }
+    }
+    return ids;
+}
+/** Convenience: filter to active triage status. */
+export function filterTriage(items) {
+    return items.filter((it) => it.status === "triage");
+}
+/**
+ * Find a single item by id (linear scan). Used by the route layer for
+ * existence + status checks.
+ */
+export function findItemById(items, id) {
+    return items.find((it) => it.id === id);
+}
+//# sourceMappingURL=triage-store.js.map

package/server/dist/core/triage-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-store.js","sourceRoot":"","sources":["../../src/core/triage-store.ts"],"names":[],"mappings":"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"}

package/server/dist/core/triage-validation.d.ts

@@ -0,0 +1,58 @@
+import type { TriagePriority, TriageSeverity } from "../types/triage.js";
+export interface PromoteBody {
+    triageId: string;
+    priority: TriagePriority;
+    domain: string;
+    complexityHint?: "small" | "medium" | "large";
+    tags: string[];
+}
+export interface DismissSnoozeBody {
+    triageId: string;
+    reason: string | null;
+    /** Present only on a `snoozed` flip — see `parseDismissSnoozeBody`. */
+    revisitAt?: string;
+}
+export type Validated<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        error: string;
+        field?: string;
+    };
+};
+export declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+export declare function containsControlChar(s: string): boolean;
+export declare function parsePromoteBody(body: unknown): Validated<PromoteBody>;
+/**
+ * `newStatus` decides whether `revisitAt` is even legal on this body — park
+ * semantics apply ONLY to a `snoozed` flip, mirroring the monorepo's
+ * `mark_status` validation (`revisit_at is park semantics and is accepted
+ * only on a snoozed flip`). A non-future date (today or past) is rejected
+ * too: it would resolve straight back to `status: "triage"` on the very
+ * next read, defeating the point of parking it (iterate-2026-08-05-triage-
+ * deferred-envelope plan review, AC7).
+ */
+export declare function parseDismissSnoozeBody(body: unknown, newStatus: "dismissed" | "snoozed"): Validated<DismissSnoozeBody>;
+export interface AmendBody {
+    triageId: string;
+    title?: string;
+    detail?: string;
+    severity?: TriageSeverity;
+}
+/**
+ * Validates a `POST /api/triage/:projectId/amend` body: a DELTA, never a
+ * rewrite — any subset of title/detail/severity, at least one present
+ * (contentless → 400 before any write, mirrors `check_amend_fields`'s
+ * writer-side precondition in `lib/triage_amend.py`). Field-level validity
+ * (non-blank title, string detail, known severity) reuses
+ * `triage-amend.ts`'s `validateAmendEvent` — the SAME check the reader
+ * applies to a stored line, so a body that would pass here is guaranteed to
+ * resolve on the very next read (no accepted-but-silently-ignored amend).
+ * `kind` is deliberately NOT accepted here — the Edit UI only offers
+ * title/detail/severity (filing-card decision); the wire format itself
+ * still supports a `kind` amend for parity with any future producer.
+ */
+export declare function parseAmendBody(body: unknown): Validated<AmendBody>;
+//# sourceMappingURL=triage-validation.d.ts.map

package/server/dist/core/triage-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-validation.d.ts","sourceRoot":"","sources":["../../src/core/triage-validation.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAqBzE,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC9C,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,IACnB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACtB;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAE5D,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEtE;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAMtD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,WAAW,CAAC,CA8DtE;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,WAAW,GAAG,SAAS,GACjC,SAAS,CAAC,iBAAiB,CAAC,CAmC9B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC,CAoClE"}