@svenroth-ai/shipwright 0.24.1-next.0

package/server/dist/core/inbox-derive.js

@@ -0,0 +1,211 @@
+/*
+ * Inbox derivation — surfaces pending interactions from the session JSONL.
+ *
+ * Input:  parsed events (from session-parser) + the set of tool names we
+ *         consider "user-blocking" (allowlist).
+ * Output: tool_use ids whose matching tool_result has NOT yet appeared,
+ *         filtered by the allowlist. These are surfaced to the user as
+ *         inbox entries ("Waiting for you to answer in your chat client").
+ *
+ * Rationale for allowlist (GPT MAJOR 8): plain long-running tools like
+ * `Bash` open-ended commands aren't user-blocking — they finish on their
+ * own. Only a narrow set is: AskUserQuestion + plugin-registered ones.
+ *
+ * Labelled "best-effort" in the UI per round-3 integration: tool_use
+ * without matching tool_result is a heuristic, not a semantic contract.
+ *
+ * Persisted state lives in the SdkSessionsStore per task:
+ *   - `pendingToolUseIds` — currently unresolved ids
+ *   - `dismissedToolUseIds` — user clicked "Dismiss" on a false positive
+ *   - `lastProcessedByteOffset` — incremental marker (unused in v1
+ *      because deriveInbox reparses from top; kept as the field the
+ *      Sub-iterate 1 fastpath will use)
+ */
+import { extractToolResults, extractToolUses } from "./session-parser.js";
+export const DEFAULT_USER_BLOCKING_TOOLS = new Set(["AskUserQuestion"]);
+export function deriveInbox(args) {
+    const allowlist = args.allowlist ?? DEFAULT_USER_BLOCKING_TOOLS;
+    const dismissed = args.dismissed ?? new Set();
+    const uses = extractToolUses(args.events);
+    const results = extractToolResults(args.events);
+    const resolvedIds = new Set(results.map((r) => r.toolUseId));
+    const pending = [];
+    for (const u of uses) {
+        if (resolvedIds.has(u.id))
+            continue;
+        if (dismissed.has(u.id))
+            continue;
+        if (!allowlist.has(u.name))
+            continue;
+        pending.push({
+            toolUseId: u.id,
+            toolName: u.name,
+            input: u.input,
+            atAssistantEvent: u.atAssistantEvent,
+        });
+    }
+    return {
+        pending,
+        allToolUseIds: uses.map((u) => u.id),
+        resolvedToolUseIds: Array.from(resolvedIds),
+    };
+}
+// ---------- plain-text "awaiting user" detection (iterate-2026-05-15) ----------
+//
+// `deriveInbox` only sees structured `AskUserQuestion` tool_use blocks. In an
+// interactive Claude Code TUI session — exactly what the embedded terminal
+// hosts — Claude usually asks "how should I proceed?" as plain assistant text
+// at the end of a turn (a conversational question or a numbered option-menu),
+// with no tool_use block at all. `detectAwaitingUserQuestion` surfaces those:
+// a session whose LATEST conversational turn is a turn-ended assistant message
+// (no trailing tool_use, no user reply after it) whose text reads as a request
+// for input. Detection is content-only — pure over already-parsed events — so
+// the route's mtime-keyed derive cache invalidates it for free.
+/** Max chars of detected question text surfaced to the inbox (length cap). */
+export const MAX_QUESTION_TEXT_LEN = 2000;
+/** Allowlist (not denylist) — only user/assistant events bound a "turn". */
+function isConversational(e) {
+    return e.kind === "user" || e.kind === "assistant";
+}
+function assistantHasToolUse(e) {
+    if (e.kind !== "assistant" || !Array.isArray(e.content))
+        return false;
+    return e.content.some((b) => b != null &&
+        typeof b === "object" &&
+        b.type === "tool_use");
+}
+function assistantTextBlocks(e) {
+    if (e.kind !== "assistant" || !Array.isArray(e.content))
+        return [];
+    const out = [];
+    for (const b of e.content) {
+        if (b != null && typeof b === "object") {
+            const bb = b;
+            if (bb.type === "text" && typeof bb.text === "string")
+                out.push(bb.text);
+        }
+    }
+    return out;
+}
+/** Drop fenced ```code``` blocks + inline `code` spans before the heuristic. */
+function stripCode(text) {
+    return text.replace(/```[\s\S]*?```/g, " ").replace(/`[^`\n]*`/g, " ");
+}
+const LIST_ITEM_RE = /^(?:[-*]\s+)?(?:\*\*|__)?\s*(?:\d{1,3}|[a-zA-Z])[.)]/;
+function isListItem(line) {
+    return LIST_ITEM_RE.test(line);
+}
+function endsWithQuestionMark(line) {
+    // Strip trailing decoration (whitespace, quotes, markdown emphasis, closing
+    // brackets, pictographic emoji) before testing — LLM output often closes a
+    // question with `?**`, `?"`, `? 🤔`, etc.
+    const cleaned = line.replace(/[\s"'«»“”‘’*_`~)\]}>\p{Extended_Pictographic}]+$/u, "");
+    return cleaned.endsWith("?");
+}
+/** A non-list prose line longer than this, sitting AFTER an enumerated list,
+ *  marks the turn as a report rather than a menu awaiting a choice. Short
+ *  closers ("Let me know.", "Your call.") stay under it; a full declarative
+ *  sentence does not. */
+const SUBSTANTIAL_PROSE_LEN = 40;
+/**
+ * True when the assembled assistant-turn text reads as a request for the
+ * user's input — its tail ends with a question mark or an enumerated option
+ * list. End-anchored:
+ *  - a `?`-terminated line is a strong signal and wins outright;
+ *  - an enumerated list is a weaker signal (lists also appear in reports), so
+ *    it only counts when no substantial prose line follows it.
+ */
+function looksLikeAwaitingQuestion(turnText) {
+    const lines = stripCode(turnText)
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    if (lines.length === 0)
+        return false;
+    const tail = lines.slice(-8);
+    let signalIdx = -1;
+    for (let i = 0; i < tail.length; i++) {
+        if (endsWithQuestionMark(tail[i]) || isListItem(tail[i]))
+            signalIdx = i;
+    }
+    if (signalIdx === -1)
+        return false;
+    // A `?`-terminated signal line is decisive on its own.
+    if (endsWithQuestionMark(tail[signalIdx]))
+        return true;
+    // Otherwise the signal is a list item — reject if a substantial prose line
+    // follows it (the turn moved on from the list into a report).
+    for (let i = signalIdx + 1; i < tail.length; i++) {
+        if (!isListItem(tail[i]) && tail[i].length > SUBSTANTIAL_PROSE_LEN) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Surfaces a plain-text "awaiting user" question for the session, or null.
+ * Mutually exclusive with a pending tool_use by construction: a pending
+ * tool_use leaves a trailing assistant `tool_use` block, which step 3 rejects.
+ */
+export function detectAwaitingUserQuestion(events) {
+    // 1. Latest conversational event (allowlist: user | assistant).
+    let lastIdx = -1;
+    for (let i = events.length - 1; i >= 0; i--) {
+        if (isConversational(events[i])) {
+            lastIdx = i;
+            break;
+        }
+    }
+    if (lastIdx === -1)
+        return null;
+    // 2. A trailing user event (real message OR tool_result) — Claude is not
+    //    waiting on the user.
+    if (events[lastIdx].kind !== "assistant")
+        return null;
+    // 3. Mid-action guard: the latest assistant event still carries a tool_use
+    //    (Claude is acting; a pending AskUserQuestion is handled by deriveInbox).
+    if (assistantHasToolUse(events[lastIdx]))
+        return null;
+    // 4. Gather the trailing assistant turn — back to the previous `user` event.
+    let turnStart = lastIdx;
+    for (let i = lastIdx - 1; i >= 0; i--) {
+        if (events[i].kind === "user")
+            break;
+        if (events[i].kind === "assistant")
+            turnStart = i;
+        // non-conversational events are skipped (allowlist)
+    }
+    // 5. Assemble the turn's text blocks.
+    const parts = [];
+    for (let i = turnStart; i <= lastIdx; i++) {
+        if (events[i].kind === "assistant")
+            parts.push(...assistantTextBlocks(events[i]));
+    }
+    const turnText = parts.join("\n").trim();
+    if (!turnText)
+        return null;
+    // 6. Heuristic.
+    if (!looksLikeAwaitingQuestion(turnText))
+        return null;
+    const rawId = events[lastIdx].uuid;
+    const questionId = typeof rawId === "string" && rawId.length > 0
+        ? rawId
+        : `awaiting-${turnStart}-${lastIdx}`;
+    const questionText = turnText.length > MAX_QUESTION_TEXT_LEN
+        ? "…" + turnText.slice(turnText.length - MAX_QUESTION_TEXT_LEN)
+        : turnText;
+    return { questionId, questionText, atAssistantEvent: lastIdx };
+}
+/**
+ * Unified per-session inbox derivation. Runs the tool_use path
+ * (`deriveInbox`) and the plain-text-question path
+ * (`detectAwaitingUserQuestion`) and applies the precedence rule in ONE
+ * place: a pending tool_use (e.g. AskUserQuestion) wins — a session with a
+ * pending tool interaction never also surfaces a text question.
+ */
+export function deriveSessionInbox(args) {
+    const base = deriveInbox(args);
+    const textQuestion = base.pending.length > 0 ? null : detectAwaitingUserQuestion(args.events);
+    return { ...base, textQuestion };
+}
+//# sourceMappingURL=inbox-derive.js.map

package/server/dist/core/inbox-derive.js.map

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

package/server/dist/core/jsonl-decode.d.ts

@@ -0,0 +1,28 @@
+export declare const CH_LF = 10;
+export declare const CH_LBRACE = 123;
+export declare const MAX_RECOVERY_LINE_BYTES = 1000000;
+export declare function skipJsonWs(line: string, from: number): number;
+/**
+ * `JSON.parse` restricted to plain objects. Returns undefined for invalid JSON
+ * AND for valid-but-wrong-shape input (a bare scalar or a top-level array):
+ * callers do `raw.event`, so a non-object is a fragment, not a record.
+ */
+export declare function tryParseObject(candidate: string): Record<string, unknown> | undefined;
+/**
+ * Decode one JSON object beginning at `start`, by walking candidate end
+ * positions at each `}` and letting native `JSON.parse` validate each slice.
+ *
+ * This is SELF-CORRECTING for braces inside string values: a candidate ending
+ * at an in-string `}` is unbalanced and simply fails to parse, so the walk
+ * continues. The SHORTEST valid prefix is the correct record boundary, because
+ * any shorter prefix ending at `}` is necessarily unbalanced.
+ *
+ * Deliberately NOT a hand-rolled JSON lexer (external review R2): brace
+ * counting with escaped quotes and backslash runs is a classic source of latent
+ * bugs, and delegating validation to V8 removes that whole class.
+ */
+export declare function decodeObjectAt(line: string, start: number): {
+    value: Record<string, unknown>;
+    end: number;
+} | null;
+//# sourceMappingURL=jsonl-decode.d.ts.map

package/server/dist/core/jsonl-decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-decode.d.ts","sourceRoot":"","sources":["../../src/core/jsonl-decode.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,KAAK,KAAK,CAAC;AACxB,eAAO,MAAM,SAAS,MAAO,CAAC;AAS9B,eAAO,MAAM,uBAAuB,UAAY,CAAC;AAMjD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAWrF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgBxD"}

package/server/dist/core/jsonl-decode.js

@@ -0,0 +1,96 @@
+/*
+ * jsonl-decode.ts — JSON decoding primitives for the record splitter.
+ *
+ * Extracted from `jsonl-records.ts` (iterate-2026-07-21-compliance-audit-reconcile,
+ * Group H1) purely to keep both files inside the 300-line rule. The seam is the
+ * natural one, not an arbitrary cut: everything here answers "where does ONE
+ * JSON object end?", while `jsonl-records.ts` answers "what records are on this
+ * LINE, and is the file safely appendable?".
+ *
+ * These symbols are INTERNAL to that pair — `jsonl-records.ts` is the only
+ * importer, and it remains the public face (`splitRecords`, `parseJsonlRecords`,
+ * `recordsFromLines`, `endsWithoutNewline`, `CorruptFragment`). Consumers import
+ * from there; nothing outside imports this module.
+ *
+ * The cross-language contract, the port deviations from
+ * `shared/scripts/lib/jsonl_records.py`, and the reason this leaf exists at all
+ * are documented in `jsonl-records.ts` — read that header first.
+ */
+// Explicitly JSON's whitespace set as CHAR CODES, NOT a unicode-aware test:
+// `String.prototype.trim` and Python's `str.isspace` are both unicode-aware and
+// would silently accept NBSP / U+000B / U+000C BETWEEN records, diverging from
+// every other JSON consumer of the same bytes.
+const CH_SPACE = 32;
+const CH_TAB = 9;
+const CH_CR = 13;
+export const CH_LF = 10;
+export const CH_LBRACE = 0x7b; // {
+const CH_RBRACE = 0x7d; // }
+// Slow-path ceilings (external review, medium/performance). Both degrade to
+// "fragment" — a safe, already-tested outcome, never a throw. A real triage
+// record is ~370 bytes with at most trivial nesting, so these sit orders of
+// magnitude above legitimate input: they bound an adversarial or badly-
+// truncated line, they do not shape normal behaviour.
+const MAX_DECODE_ATTEMPTS = 1024;
+export const MAX_RECOVERY_LINE_BYTES = 1_000_000;
+function isJsonWs(code) {
+    return code === CH_SPACE || code === CH_TAB || code === CH_CR || code === CH_LF;
+}
+export function skipJsonWs(line, from) {
+    let idx = from;
+    while (idx < line.length && isJsonWs(line.charCodeAt(idx)))
+        idx += 1;
+    return idx;
+}
+/**
+ * `JSON.parse` restricted to plain objects. Returns undefined for invalid JSON
+ * AND for valid-but-wrong-shape input (a bare scalar or a top-level array):
+ * callers do `raw.event`, so a non-object is a fragment, not a record.
+ */
+export function tryParseObject(candidate) {
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+/**
+ * Decode one JSON object beginning at `start`, by walking candidate end
+ * positions at each `}` and letting native `JSON.parse` validate each slice.
+ *
+ * This is SELF-CORRECTING for braces inside string values: a candidate ending
+ * at an in-string `}` is unbalanced and simply fails to parse, so the walk
+ * continues. The SHORTEST valid prefix is the correct record boundary, because
+ * any shorter prefix ending at `}` is necessarily unbalanced.
+ *
+ * Deliberately NOT a hand-rolled JSON lexer (external review R2): brace
+ * counting with escaped quotes and backslash runs is a classic source of latent
+ * bugs, and delegating validation to V8 removes that whole class.
+ */
+export function decodeObjectAt(line, start) {
+    let attempts = 0;
+    for (let i = start; i < line.length; i += 1) {
+        if (line.charCodeAt(i) !== CH_RBRACE)
+            continue;
+        // Work budget. Each attempt slices AND parses, so an adversarial line is
+        // O(candidates x length) on the request thread — and the board read path
+        // (triage-compose → readLocalRawLinesSplit) bypasses `readAllItems`' 5 s
+        // cache, so a corrupt line re-pays the cost on EVERY poll with nothing ever
+        // repairing the file. Python pays one `raw_decode`; the brace walk is the
+        // price of not hand-rolling a lexer, so it gets a ceiling.
+        attempts += 1;
+        if (attempts > MAX_DECODE_ATTEMPTS)
+            return null;
+        const value = tryParseObject(line.slice(start, i + 1));
+        if (value !== undefined)
+            return { value, end: i + 1 };
+    }
+    return null;
+}
+//# sourceMappingURL=jsonl-decode.js.map

package/server/dist/core/jsonl-decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-decode.js","sourceRoot":"","sources":["../../src/core/jsonl-decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,4EAA4E;AAC5E,gFAAgF;AAChF,+EAA+E;AAC/E,+CAA+C;AAC/C,MAAM,QAAQ,GAAG,EAAE,CAAC;AACpB,MAAM,MAAM,GAAG,CAAC,CAAC;AACjB,MAAM,KAAK,GAAG,EAAE,CAAC;AACjB,MAAM,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;AACxB,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,IAAI;AACnC,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,IAAI;AAE5B,4EAA4E;AAC5E,4EAA4E;AAC5E,4EAA4E;AAC5E,wEAAwE;AACxE,sDAAsD;AACtD,MAAM,mBAAmB,GAAG,IAAI,CAAC;AACjC,MAAM,CAAC,MAAM,uBAAuB,GAAG,SAAS,CAAC;AAEjD,SAAS,QAAQ,CAAC,IAAY;IAC5B,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC;AAClF,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,IAAY;IACnD,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAAE,GAAG,IAAI,CAAC,CAAC;IACrE,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,SAAiB;IAC9C,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3E,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,MAAiC,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAY,EACZ,KAAa;IAEb,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,SAAS;YAAE,SAAS;QAC/C,yEAAyE;QACzE,yEAAyE;QACzE,yEAAyE;QACzE,4EAA4E;QAC5E,0EAA0E;QAC1E,2DAA2D;QAC3D,QAAQ,IAAI,CAAC,CAAC;QACd,IAAI,QAAQ,GAAG,mBAAmB;YAAE,OAAO,IAAI,CAAC;QAChD,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACvD,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;IACxD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/server/dist/core/jsonl-records.d.ts

@@ -0,0 +1,104 @@
+/** One stretch of text on a physical line that could not be decoded. */
+export interface CorruptFragment {
+    /** 1-based physical line number within the blob. */
+    lineNo: number;
+    /**
+     * The on-disk text apart from the surrounding whitespace the reader strips.
+     * Never logged verbatim — callers report its LENGTH only, so arbitrary log
+     * contents and control characters cannot reach the server log.
+     */
+    text: string;
+}
+/** Tolerant-read outcome: what was recovered, and what could not be. */
+export interface RecordRead {
+    records: Record<string, unknown>[];
+    /**
+     * The explicit side channel that keeps corruption from reading as absence.
+     * Empty on a clean read.
+     */
+    corrupt: CorruptFragment[];
+}
+/**
+ * Split one physical `line` into records plus the unrecoverable remainder.
+ *
+ * `remainder` is `""` when the whole line decoded cleanly, otherwise the
+ * VERBATIM text from the first byte that could not be decoded to end of line.
+ *
+ * Contract (mirrors the Python leaf):
+ *   - JSON whitespace between records is skipped (space/tab/CR/LF only).
+ *   - A blank / whitespace-only line yields `([], "")` — formatting, not
+ *     corruption.
+ *   - Only JSON objects count as records; a bare scalar is a fragment.
+ *   - Recovery is PARTIAL: records decoded before the bad byte are returned.
+ *   - A malformed record does NOT resync — the entire rest of the line becomes
+ *     the remainder, matching `raw_decode`.
+ *
+ * Cost: the fast path is a single native `JSON.parse` and covers essentially
+ * every real line. The candidate walk runs only on an already-corrupt line,
+ * where lines are short and correctness matters more than throughput.
+ */
+export declare function splitRecords(line: string): {
+    records: Record<string, unknown>[];
+    remainder: string;
+};
+/**
+ * Tolerantly parse a whole JSONL blob, recovering concatenated records and
+ * returning the rest as data.
+ *
+ * Order is preserved: records recovered from one physical line stay in wire
+ * order relative to each other and to surrounding lines, so the store's
+ * `(ts, file-order)` status resolution is unaffected.
+ *
+ * `trim()` here is intentionally the unicode-aware one — it absorbs a trailing
+ * CR (CRLF) and mirrors Python's `raw.strip()`, which is also unicode-aware.
+ * The strict JSON-whitespace rule applies BETWEEN records, inside
+ * `splitRecords`.
+ *
+ * Line NUMBERING can differ from Python on a file containing a bare CR: this
+ * splits on `\n` only, while Python iterates the handle in universal-newline
+ * mode and also breaks on a lone `\r`. Resolved RECORDS are unaffected (CR is
+ * JSON whitespace, so `splitRecords` skips an interior CR and recovers both
+ * sides either way) — only the `lineNo` reported on a `CorruptFragment` shifts.
+ * Noted so an operator correlating a WebUI warning against the monorepo repair
+ * CLI's output is not misled.
+ */
+export declare function parseJsonlRecords(raw: string): RecordRead;
+/**
+ * Record-by-record view over ALREADY-SPLIT physical lines, recovering
+ * concatenated records (iterate-2026-07-19-events-reader-recovery).
+ *
+ * The events-log readers get `Iterable<string>` lines, not a raw blob, and each
+ * keeps its own running index for ordering. Yielding per RECORD lets them keep
+ * `idx++` unchanged: two records on one line take two consecutive indices,
+ * preserving the wire order last-wins projections depend on.
+ *
+ * `onLine` fires once per NON-BLANK PHYSICAL LINE, so a caller can keep
+ * line-based counters (`totalLines` / `skippedLines`) meaning what they always
+ * meant while record-based counters move to the yielded values. Blank lines are
+ * formatting and are reported to neither.
+ */
+export declare function recordsFromLines(lines: Iterable<string>, onLine?: (info: {
+    lineNo: number;
+    corrupt: boolean;
+}) => void): Generator<Record<string, unknown>>;
+/**
+ * True iff `path` exists, is non-empty, and its final byte is not `\n`.
+ *
+ * A missing or zero-byte file is safely appendable and returns false. A file
+ * ending `\r\n` ends in `\n` and so counts as already terminated — prefixing
+ * another newline would inject a blank line.
+ *
+ * Reads exactly ONE byte at `size - 1` via a positional `readSync`; it never
+ * reads file contents. An O(N) read here would degrade every status flip as the
+ * log grows (external review R3).
+ *
+ * Any error (missing, unreadable, a directory, not seekable) is treated as
+ * "safely appendable". This mirrors the Python leaf, which catches OSError
+ * broadly and documents that "the append itself will surface any real I/O
+ * problem" — accurate here too: a swallowed EACCES is immediately re-raised by
+ * `appendFileSync` and mapped to a route-level write error by its caller, so
+ * no error is lost. Propagating early would diverge from the cross-language
+ * contract for no behavioural gain (external review R10, rejected with reason).
+ */
+export declare function endsWithoutNewline(filePath: string): boolean;
+//# sourceMappingURL=jsonl-records.d.ts.map

package/server/dist/core/jsonl-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-records.d.ts","sourceRoot":"","sources":["../../src/core/jsonl-records.ts"],"names":[],"mappings":"AA+DA,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC9B,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wEAAwE;AACxE,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACnC;;;OAGG;IACH,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG;IAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB,CAgCA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAczD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAiB,gBAAgB,CAC/B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,KAAK,IAAI,GAC5D,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAUpC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAwB5D"}