@shipfox/api-logs-dto 2.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+$ shipfox-swc
+Successfully compiled: 7 files with swc (54.53ms)

package/.turbo/turbo-type$colon$emit.log

@@ -0,0 +1 @@
+$ shipfox-tsc-emit

package/.turbo/turbo-type.log

@@ -0,0 +1 @@
+$ shipfox-tsc-check

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# @shipfox/api-logs-dto
+
+## 2.0.0
+
+### Minor Changes
+
+- 1b0d344: Publishes the complete API runtime closure with packed-consumer-safe internal imports and records its exact package set in application releases.
+
+## 0.1.0
+
+### Minor Changes
+
+- a56748d: Adds ingestion-time agent session parsing with a stored canonical SessionView read endpoint and workflow harness lookup.
+- f92122b: Adds the logs module foundation: a stateless monolith module with its own schema, the runner-facing offset-CAS append endpoint (job-lease authenticated, idempotent, multi-instance safe), a per-job accrual budget with a cap tombstone, and an S3-compatible client targeting Garage at startup. The NDJSON v1 record contract lives in the new `@shipfox/api-logs-dto` package, and `@shipfox/node-fastify` gains a `createRawBodyPlugin({contentType, bodyLimit})` factory for byte-exact request bodies.
+- 4207772: Add the session-authenticated log read endpoint: `GET /steps/:stepId/attempts/:attempt/logs?cursor=N`. One cursor endpoint serves both the live tail and the full history of a step attempt, workspace-scoped through the stream row's denormalized `workspaceId` (a 404 covers both a missing stream and a cross-workspace step, so existence never leaks).
+  - Open or closed-but-uncompacted streams return inline NDJSON read from the hot Postgres chunks, walked by chunk `seq` so server-injected control tombstones (`capped`, `runner_lost`) interleave with runner bytes exactly as compaction concatenates them. The inline bytes are therefore byte-identical to the decompressed compacted object. Pages are bounded by `LOG_READ_INLINE_MAX_BYTES` (default 1 MiB), with a `has_more` flag and a `next_cursor` the client drains before it tails.
+  - Compacted streams (`object_key` set) return a presigned GET URL (`LOG_READ_URL_TTL_SECONDS`, default 3600) plus `total_bytes`, `expires_at`, and `truncated`, so the browser fetches the object directly and API egress is bypassed.
+  - `@shipfox/api-logs-dto` gains `readLogsQuerySchema` and the `readLogsResponseSchema` discriminated union (`inline` or `presigned`) so the backend, client, and E2E helpers share one contract. `@shipfox/api-logs` adds the `@aws-sdk/s3-request-presigner` dependency.
+
+### Patch Changes
+
+- f104ff2: Add `@shipfox/client-logs`: the record components for the step-log read stream, composing the `@shipfox/react-ui` log primitives. This covers every process and system record (`output`, `group_start`/`group_end`, `end`, `gap`, `capped`, `runner_lost`); `agent_session` is rendered by the agent-sessions surface.
+  - `buildLogTree(records)` is a pure transform that reconstructs the group tree from the flat record list. `group_end` closes the matching `group_id` (so a `group_start` dropped under gap/backlog pressure does not mis-nest), record dispatch is an exhaustive switch, and each group node carries a precomputed `hasError` (a `runner_lost` in its subtree, a genuine failure; `stderr` is a channel, not an error) and subtree line count.
+  - `OutputLogRow` renders stdout/stderr (stderr gets a subtle left channel rule, not a background tint), `LogGroup` is a collapsible disclosure with running/duration/incomplete affordances and an inset error bar, the system markers render as timeline rows, and `LogView` is the top-level dispatcher with an empty state. Reviewed in a package-local Storybook captured by Argos (`client-logs`).
+  - `@shipfox/api-logs-dto` now measures UTF-8 byte length with `TextEncoder` instead of `node:buffer`, so this shared record contract is browser-safe for the client log viewer. Behavior is identical.
+  - `@shipfox/react-ui` gains two shared formatters in `utils`: `formatBytes` (new) and `formatDuration` (an ms-span, sub-second sibling to the existing `humanDuration`), so `client-logs` and future packages share one implementation instead of re-rolling them.
+
+- 68e4022: Collapse the log stream `kind` into one stream per `(job, step, attempt)`. `kind` was modeled at the wrong layer: the runner already funnels every record through one spool and one offset axis, so the per-kind split (separate stream rows, identity, and ingest dispatch) was unnecessary server-side modeling. A reader now pulls every record for a step attempt and filters by the record `type` at read time, without passing a kind.
+  - The append request drops the `kind` query param and `LogStreamClosedEvent` drops `kind`. `streamKind`/`StreamKind` and the `agent_session` line validator (`parseSessionLine`) are removed.
+  - `attempt_streams` identity becomes `(job, step, attempt)`; the `kind` and now-dead `capped` columns are dropped (budget cap is signaled in-band by a `capped` tombstone and tracked in `job_accounting`). The close path injects `capped`/`runner_lost` tombstones uniformly.
+  - `LOG_MAX_SESSION_LINE_BYTES` is removed and `LOG_APPEND_BODY_LIMIT_BYTES` is right-sized to 1 MiB. The runner's flush-window comment is corrected to match (the server body limit is now 1 MiB, no longer 8 MiB).
+
+  Agent-session capture (its own record `type`(s) and runner producer) is deferred to the agent-sessions feature, which will emit those records into this same stream.
+
+- d49ee4c: Forward agent step session entries into the logs module as opaque `agent_session` records: the runner tails the pi session file and forwards each verbatim entry over a shared log-stream sink, and the write path stores them with a configurable per-line size cap sized for inline base64 content.
+- 2883ab4: Add a stream `kind` to the logs contract and harden the write path. Streams are now identified by `(job, step, attempt, kind)` with two kinds: `log_stream` (process output) and `agent_session` (verbatim, format-agnostic agent JSONL).
+  - The record envelope drops `src` to `{v, ts}`; the stdout/stderr pipe moves to `stream` on output, and control records become a flat `type` discriminator with multi-level named groups (`group_id`/`parent_group_id`, capped depth with overflow flattening).
+  - The append validator is split into an appendable union and a read union, so a forged server-only `capped`/`runner_lost` tombstone is rejected. `agent_session` lines are stored verbatim after a whole-line, fatal-UTF-8, JSON-well-formedness check within a configurable line cap; the budget cap never injects an in-band tombstone into a session, and close derives its `capped`/`truncated` flags out of band.
+  - The append request carries `kind`; the shared body limit and session line cap are configurable with a startup invariant.
+
+- bf8319f: Re-export the schemas through a relative path so the built package loads under a plain Node ESM resolver, not only tsx or vite, which lets Playwright-run E2E suites consume it through `@shipfox/e2e-observe-logs`.
+- 2933c33: Adds drain-boundary Zod validation for current outbox publisher event payloads.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shipfox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/events.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const LOG_STREAM_CLOSED: "logs.stream.closed";
+export declare const logStreamClosedEventSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    jobId: z.ZodString;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    streamId: z.ZodString;
+}, z.core.$strip>;
+export type LogStreamClosedEvent = z.infer<typeof logStreamClosedEventSchema>;
+export interface LogsEventMap {
+    [LOG_STREAM_CLOSED]: LogStreamClosedEvent;
+}
+export declare const logsEventSchemas: {
+    "logs.stream.closed": z.ZodObject<{
+        workspaceId: z.ZodString;
+        jobId: z.ZodString;
+        stepId: z.ZodString;
+        attempt: z.ZodNumber;
+        streamId: z.ZodString;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,eAAO,MAAM,iBAAiB,EAAG,oBAA6B,CAAC;AAE/D,eAAO,MAAM,0BAA0B;;;;;;iBAMrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,MAAM,WAAW,YAAY;IAC3B,CAAC,iBAAiB,CAAC,EAAE,oBAAoB,CAAC;CAC3C;AAED,eAAO,MAAM,gBAAgB;;;;;;;;CAEoB,CAAC"}

package/dist/events.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+const nonEmptyStringSchema = z.string().nonempty();
+export const LOG_STREAM_CLOSED = 'logs.stream.closed';
+export const logStreamClosedEventSchema = z.object({
+    workspaceId: nonEmptyStringSchema,
+    jobId: nonEmptyStringSchema,
+    stepId: nonEmptyStringSchema,
+    attempt: z.number(),
+    streamId: nonEmptyStringSchema
+});
+export const logsEventSchemas = {
+    [LOG_STREAM_CLOSED]: logStreamClosedEventSchema
+};
+
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/events.ts"],"sourcesContent":["import {z} from 'zod';\n\nconst nonEmptyStringSchema = z.string().nonempty();\n\nexport const LOG_STREAM_CLOSED = 'logs.stream.closed' as const;\n\nexport const logStreamClosedEventSchema = z.object({\n  workspaceId: nonEmptyStringSchema,\n  jobId: nonEmptyStringSchema,\n  stepId: nonEmptyStringSchema,\n  attempt: z.number(),\n  streamId: nonEmptyStringSchema,\n});\nexport type LogStreamClosedEvent = z.infer<typeof logStreamClosedEventSchema>;\n\nexport interface LogsEventMap {\n  [LOG_STREAM_CLOSED]: LogStreamClosedEvent;\n}\n\nexport const logsEventSchemas = {\n  [LOG_STREAM_CLOSED]: logStreamClosedEventSchema,\n} satisfies Record<keyof LogsEventMap, z.ZodType>;\n"],"names":["z","nonEmptyStringSchema","string","nonempty","LOG_STREAM_CLOSED","logStreamClosedEventSchema","object","workspaceId","jobId","stepId","attempt","number","streamId","logsEventSchemas"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,MAAMC,uBAAuBD,EAAEE,MAAM,GAAGC,QAAQ;AAEhD,OAAO,MAAMC,oBAAoB,qBAA8B;AAE/D,OAAO,MAAMC,6BAA6BL,EAAEM,MAAM,CAAC;IACjDC,aAAaN;IACbO,OAAOP;IACPQ,QAAQR;IACRS,SAASV,EAAEW,MAAM;IACjBC,UAAUX;AACZ,GAAG;AAOH,OAAO,MAAMY,mBAAmB;IAC9B,CAACT,kBAAkB,EAAEC;AACvB,EAAkD"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { LOG_STREAM_CLOSED, type LogStreamClosedEvent, type LogsEventMap, logStreamClosedEventSchema, logsEventSchemas, } from './events.js';
+export { type AppendLogsQueryDto, type AppendLogsResponseDto, appendLogsQuerySchema, appendLogsResponseSchema, type LogRecord, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, type OffsetGapResponseDto, offsetGapResponseSchema, parseLogRecordLine, parseRawLogRecordLine, type RawLogRecord, type ReadLogsQueryDto, type ReadLogsResponseDto, rawLogRecordSchema, readLogsQuerySchema, readLogsResponseSchema, SESSION_VIEW_VERSION, type SessionViewDto, type SessionViewLifecycleRow, type SessionViewMessageRow, type SessionViewRawRow, type SessionViewRow, type SessionViewRowMeta, type SessionViewThinkingRow, type SessionViewToolCallRow, type SessionViewToolResultRow, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema, } from './schemas/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,0BAA0B,EAC1B,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,SAAS,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,4BAA4B,EAC5B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { LOG_STREAM_CLOSED, logStreamClosedEventSchema, logsEventSchemas } from './events.js';
+export { appendLogsQuerySchema, appendLogsResponseSchema, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, offsetGapResponseSchema, parseLogRecordLine, parseRawLogRecordLine, rawLogRecordSchema, readLogsQuerySchema, readLogsResponseSchema, SESSION_VIEW_VERSION, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema } from './schemas/index.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  LOG_STREAM_CLOSED,\n  type LogStreamClosedEvent,\n  type LogsEventMap,\n  logStreamClosedEventSchema,\n  logsEventSchemas,\n} from './events.js';\nexport {\n  type AppendLogsQueryDto,\n  type AppendLogsResponseDto,\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  type LogRecord,\n  logRecordSchema,\n  MAX_RECORD_DATA_BYTES,\n  MAX_RECORD_NAME_BYTES,\n  type OffsetGapResponseDto,\n  offsetGapResponseSchema,\n  parseLogRecordLine,\n  parseRawLogRecordLine,\n  type RawLogRecord,\n  type ReadLogsQueryDto,\n  type ReadLogsResponseDto,\n  rawLogRecordSchema,\n  readLogsQuerySchema,\n  readLogsResponseSchema,\n  SESSION_VIEW_VERSION,\n  type SessionViewDto,\n  type SessionViewLifecycleRow,\n  type SessionViewMessageRow,\n  type SessionViewRawRow,\n  type SessionViewRow,\n  type SessionViewRowMeta,\n  type SessionViewThinkingRow,\n  type SessionViewToolCallRow,\n  type SessionViewToolResultRow,\n  sessionViewLifecycleRowSchema,\n  sessionViewMessageRowSchema,\n  sessionViewRawRowSchema,\n  sessionViewRowMetaSchema,\n  sessionViewRowSchema,\n  sessionViewSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n} from './schemas/index.js';\n"],"names":["LOG_STREAM_CLOSED","logStreamClosedEventSchema","logsEventSchemas","appendLogsQuerySchema","appendLogsResponseSchema","logRecordSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","offsetGapResponseSchema","parseLogRecordLine","parseRawLogRecordLine","rawLogRecordSchema","readLogsQuerySchema","readLogsResponseSchema","SESSION_VIEW_VERSION","sessionViewLifecycleRowSchema","sessionViewMessageRowSchema","sessionViewRawRowSchema","sessionViewRowMetaSchema","sessionViewRowSchema","sessionViewSchema","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","sessionViewToolResultRowSchema"],"mappings":"AAAA,SACEA,iBAAiB,EAGjBC,0BAA0B,EAC1BC,gBAAgB,QACX,cAAc;AACrB,SAGEC,qBAAqB,EACrBC,wBAAwB,EAExBC,eAAe,EACfC,qBAAqB,EACrBC,qBAAqB,EAErBC,uBAAuB,EACvBC,kBAAkB,EAClBC,qBAAqB,EAIrBC,kBAAkB,EAClBC,mBAAmB,EACnBC,sBAAsB,EACtBC,oBAAoB,EAUpBC,6BAA6B,EAC7BC,2BAA2B,EAC3BC,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,iBAAiB,EACjBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,8BAA8B,QACzB,qBAAqB"}

package/dist/schemas/append.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+/**
+ * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.
+ *
+ * The body is raw NDJSON bytes (whole records, newline-terminated), not a
+ * Zod-validated object — it is parsed line by line against the raw log record
+ * union (`rawLogRecordSchema`). `offset` is a position in the raw
+ * NDJSON spool stream; both `offset` and the returned `committed_length` are
+ * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.
+ */
+export declare const appendLogsQuerySchema: z.ZodObject<{
+    attempt: z.ZodCoercedNumber<unknown>;
+    offset: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+export type AppendLogsQueryDto = z.infer<typeof appendLogsQuerySchema>;
+export declare const appendLogsResponseSchema: z.ZodObject<{
+    committed_length: z.ZodNumber;
+    capped: z.ZodBoolean;
+}, z.core.$strip>;
+export type AppendLogsResponseDto = z.infer<typeof appendLogsResponseSchema>;
+/** Body of the 409 returned on an offset gap, so the runner rewinds its spool cursor. */
+export declare const offsetGapResponseSchema: z.ZodObject<{
+    code: z.ZodLiteral<"offset-gap">;
+    details: z.ZodObject<{
+        committed_length: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OffsetGapResponseDto = z.infer<typeof offsetGapResponseSchema>;
+//# sourceMappingURL=append.d.ts.map

package/dist/schemas/append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append.d.ts","sourceRoot":"","sources":["../../src/schemas/append.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;iBAchC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,eAAO,MAAM,wBAAwB;;;iBASnC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE7E,yFAAyF;AACzF,eAAO,MAAM,uBAAuB;;;;;iBASlC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/append.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/**
+ * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.
+ *
+ * The body is raw NDJSON bytes (whole records, newline-terminated), not a
+ * Zod-validated object — it is parsed line by line against the raw log record
+ * union (`rawLogRecordSchema`). `offset` is a position in the raw
+ * NDJSON spool stream; both `offset` and the returned `committed_length` are
+ * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.
+ */ export const appendLogsQuerySchema = z.object({
+    attempt: z.coerce.number().int().min(1).max(2_147_483_647).describe('Attempt number of the step this chunk belongs to.'),
+    offset: z.coerce.number().int().min(0).describe('Byte position of this chunk in the raw NDJSON spool. Must equal the server-held committed length: an earlier offset is acknowledged as already applied, a later offset returns 409 so the runner rewinds.')
+});
+export const appendLogsResponseSchema = z.object({
+    committed_length: z.number().int().min(0).describe('New server-held byte position after this chunk was applied.'),
+    capped: z.boolean().describe('When true, the per-job log budget is exhausted and further output is dropped.')
+});
+/** Body of the 409 returned on an offset gap, so the runner rewinds its spool cursor. */ export const offsetGapResponseSchema = z.object({
+    code: z.literal('offset-gap'),
+    details: z.object({
+        committed_length: z.number().int().min(0).describe('Current server-held committed length the runner should rewind to.')
+    })
+});
+
+//# sourceMappingURL=append.js.map

package/dist/schemas/append.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/append.ts"],"sourcesContent":["import {z} from 'zod';\n\n/**\n * Append endpoint contract: `POST .../steps/:stepId/logs?attempt=N&offset=B`.\n *\n * The body is raw NDJSON bytes (whole records, newline-terminated), not a\n * Zod-validated object — it is parsed line by line against the raw log record\n * union (`rawLogRecordSchema`). `offset` is a position in the raw\n * NDJSON spool stream; both `offset` and the returned `committed_length` are\n * bounded far below 2^53 by the accrual budget, so JavaScript `number` is safe.\n */\nexport const appendLogsQuerySchema = z.object({\n  attempt: z.coerce\n    .number()\n    .int()\n    .min(1)\n    .max(2_147_483_647)\n    .describe('Attempt number of the step this chunk belongs to.'),\n  offset: z.coerce\n    .number()\n    .int()\n    .min(0)\n    .describe(\n      'Byte position of this chunk in the raw NDJSON spool. Must equal the server-held committed length: an earlier offset is acknowledged as already applied, a later offset returns 409 so the runner rewinds.',\n    ),\n});\n\nexport type AppendLogsQueryDto = z.infer<typeof appendLogsQuerySchema>;\n\nexport const appendLogsResponseSchema = z.object({\n  committed_length: z\n    .number()\n    .int()\n    .min(0)\n    .describe('New server-held byte position after this chunk was applied.'),\n  capped: z\n    .boolean()\n    .describe('When true, the per-job log budget is exhausted and further output is dropped.'),\n});\n\nexport type AppendLogsResponseDto = z.infer<typeof appendLogsResponseSchema>;\n\n/** Body of the 409 returned on an offset gap, so the runner rewinds its spool cursor. */\nexport const offsetGapResponseSchema = z.object({\n  code: z.literal('offset-gap'),\n  details: z.object({\n    committed_length: z\n      .number()\n      .int()\n      .min(0)\n      .describe('Current server-held committed length the runner should rewind to.'),\n  }),\n});\n\nexport type OffsetGapResponseDto = z.infer<typeof offsetGapResponseSchema>;\n"],"names":["z","appendLogsQuerySchema","object","attempt","coerce","number","int","min","max","describe","offset","appendLogsResponseSchema","committed_length","capped","boolean","offsetGapResponseSchema","code","literal","details"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB;;;;;;;;CAQC,GACD,OAAO,MAAMC,wBAAwBD,EAAEE,MAAM,CAAC;IAC5CC,SAASH,EAAEI,MAAM,CACdC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,GAAG,CAAC,eACJC,QAAQ,CAAC;IACZC,QAAQV,EAAEI,MAAM,CACbC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CACP;AAEN,GAAG;AAIH,OAAO,MAAME,2BAA2BX,EAAEE,MAAM,CAAC;IAC/CU,kBAAkBZ,EACfK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZI,QAAQb,EACLc,OAAO,GACPL,QAAQ,CAAC;AACd,GAAG;AAIH,uFAAuF,GACvF,OAAO,MAAMM,0BAA0Bf,EAAEE,MAAM,CAAC;IAC9Cc,MAAMhB,EAAEiB,OAAO,CAAC;IAChBC,SAASlB,EAAEE,MAAM,CAAC;QAChBU,kBAAkBZ,EACfK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACd;AACF,GAAG"}

package/dist/schemas/index.d.ts

@@ -0,0 +1,5 @@
+export { type AppendLogsQueryDto, type AppendLogsResponseDto, appendLogsQuerySchema, appendLogsResponseSchema, type OffsetGapResponseDto, offsetGapResponseSchema, } from './append.js';
+export { type ReadLogsQueryDto, type ReadLogsResponseDto, readLogsQuerySchema, readLogsResponseSchema, } from './read.js';
+export { type LogRecord, logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, parseLogRecordLine, parseRawLogRecordLine, type RawLogRecord, rawLogRecordSchema, } from './record.js';
+export { SESSION_VIEW_VERSION, type SessionViewDto, type SessionViewLifecycleRow, type SessionViewMessageRow, type SessionViewRawRow, type SessionViewRow, type SessionViewRowMeta, type SessionViewThinkingRow, type SessionViewToolCallRow, type SessionViewToolResultRow, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema, } from './session-view.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,KAAK,oBAAoB,EACzB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,KAAK,SAAS,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,YAAY,EACjB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,4BAA4B,EAC5B,4BAA4B,EAC5B,8BAA8B,GAC/B,MAAM,mBAAmB,CAAC"}

package/dist/schemas/index.js

@@ -0,0 +1,6 @@
+export { appendLogsQuerySchema, appendLogsResponseSchema, offsetGapResponseSchema } from './append.js';
+export { readLogsQuerySchema, readLogsResponseSchema } from './read.js';
+export { logRecordSchema, MAX_RECORD_DATA_BYTES, MAX_RECORD_NAME_BYTES, parseLogRecordLine, parseRawLogRecordLine, rawLogRecordSchema } from './record.js';
+export { SESSION_VIEW_VERSION, sessionViewLifecycleRowSchema, sessionViewMessageRowSchema, sessionViewRawRowSchema, sessionViewRowMetaSchema, sessionViewRowSchema, sessionViewSchema, sessionViewThinkingRowSchema, sessionViewToolCallRowSchema, sessionViewToolResultRowSchema } from './session-view.js';
+
+//# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/index.ts"],"sourcesContent":["export {\n  type AppendLogsQueryDto,\n  type AppendLogsResponseDto,\n  appendLogsQuerySchema,\n  appendLogsResponseSchema,\n  type OffsetGapResponseDto,\n  offsetGapResponseSchema,\n} from './append.js';\nexport {\n  type ReadLogsQueryDto,\n  type ReadLogsResponseDto,\n  readLogsQuerySchema,\n  readLogsResponseSchema,\n} from './read.js';\nexport {\n  type LogRecord,\n  logRecordSchema,\n  MAX_RECORD_DATA_BYTES,\n  MAX_RECORD_NAME_BYTES,\n  parseLogRecordLine,\n  parseRawLogRecordLine,\n  type RawLogRecord,\n  rawLogRecordSchema,\n} from './record.js';\nexport {\n  SESSION_VIEW_VERSION,\n  type SessionViewDto,\n  type SessionViewLifecycleRow,\n  type SessionViewMessageRow,\n  type SessionViewRawRow,\n  type SessionViewRow,\n  type SessionViewRowMeta,\n  type SessionViewThinkingRow,\n  type SessionViewToolCallRow,\n  type SessionViewToolResultRow,\n  sessionViewLifecycleRowSchema,\n  sessionViewMessageRowSchema,\n  sessionViewRawRowSchema,\n  sessionViewRowMetaSchema,\n  sessionViewRowSchema,\n  sessionViewSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n} from './session-view.js';\n"],"names":["appendLogsQuerySchema","appendLogsResponseSchema","offsetGapResponseSchema","readLogsQuerySchema","readLogsResponseSchema","logRecordSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","parseLogRecordLine","parseRawLogRecordLine","rawLogRecordSchema","SESSION_VIEW_VERSION","sessionViewLifecycleRowSchema","sessionViewMessageRowSchema","sessionViewRawRowSchema","sessionViewRowMetaSchema","sessionViewRowSchema","sessionViewSchema","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","sessionViewToolResultRowSchema"],"mappings":"AAAA,SAGEA,qBAAqB,EACrBC,wBAAwB,EAExBC,uBAAuB,QAClB,cAAc;AACrB,SAGEC,mBAAmB,EACnBC,sBAAsB,QACjB,YAAY;AACnB,SAEEC,eAAe,EACfC,qBAAqB,EACrBC,qBAAqB,EACrBC,kBAAkB,EAClBC,qBAAqB,EAErBC,kBAAkB,QACb,cAAc;AACrB,SACEC,oBAAoB,EAUpBC,6BAA6B,EAC7BC,2BAA2B,EAC3BC,uBAAuB,EACvBC,wBAAwB,EACxBC,oBAAoB,EACpBC,iBAAiB,EACjBC,4BAA4B,EAC5BC,4BAA4B,EAC5BC,8BAA8B,QACzB,oBAAoB"}

package/dist/schemas/read.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+/**
+ * Read endpoint contract: `GET .../steps/:stepId/attempts/:attempt/logs?cursor=N`.
+ *
+ * `cursor` is an opaque chunk-sequence position, not a byte offset. Server-injected
+ * control tombstones (`capped`, `runner_lost`) do not advance the runner byte axis, so
+ * the read walks chunks by insertion `seq` to keep every record in stream order. The
+ * same `seq` walk backs compaction, so the inline `ndjson` is byte-identical to the
+ * decompressed compacted object. Start at 0 and echo back `next_cursor` to page forward.
+ */
+export declare const readLogsQuerySchema: z.ZodObject<{
+    cursor: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type ReadLogsQueryDto = z.infer<typeof readLogsQuerySchema>;
+export declare const readLogsResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"inline">;
+    ndjson: z.ZodString;
+    next_cursor: z.ZodNumber;
+    has_more: z.ZodBoolean;
+    state: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+    }>;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"presigned">;
+    url: z.ZodString;
+    state: z.ZodLiteral<"closed">;
+    expires_at: z.ZodString;
+    total_bytes: z.ZodNumber;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>], "mode">;
+export type ReadLogsResponseDto = z.infer<typeof readLogsResponseSchema>;
+//# sourceMappingURL=read.d.ts.map

package/dist/schemas/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/schemas/read.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;iBAS9B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAwDnE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;2BAGjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/schemas/read.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+/**
+ * Read endpoint contract: `GET .../steps/:stepId/attempts/:attempt/logs?cursor=N`.
+ *
+ * `cursor` is an opaque chunk-sequence position, not a byte offset. Server-injected
+ * control tombstones (`capped`, `runner_lost`) do not advance the runner byte axis, so
+ * the read walks chunks by insertion `seq` to keep every record in stream order. The
+ * same `seq` walk backs compaction, so the inline `ndjson` is byte-identical to the
+ * decompressed compacted object. Start at 0 and echo back `next_cursor` to page forward.
+ */ export const readLogsQuerySchema = z.object({
+    cursor: z.coerce.number().int().min(0).default(0).describe('Opaque chunk-sequence cursor. Start at 0; echo back the previous response next_cursor to page forward. Not a byte offset.')
+});
+/**
+ * Inline shape: stored NDJSON bytes from `cursor`, parsed client-side with
+ * `parseLogRecordLine`. Served while the stream is open or closed but not yet compacted.
+ * The bytes carry every record of every type for the `(step, attempt)`; the client
+ * filters by record type for display.
+ */ const readLogsInlineSchema = z.object({
+    mode: z.literal('inline'),
+    ndjson: z.string().describe('Stored NDJSON: every record for this (step, attempt) from cursor, in stream order.'),
+    next_cursor: z.number().int().min(0).describe('Cursor to pass on the next poll to fetch records after this page.'),
+    has_more: z.boolean().describe('True when more buffered records remain past this page; re-poll immediately to drain before tailing at the refresh interval.'),
+    state: z.enum([
+        'open',
+        'closed'
+    ]).describe('Stream lifecycle: open still accepts appends, closed is terminal.'),
+    truncated: z.boolean().describe('True when the stream was force-closed because the runner stopped reporting.')
+});
+/**
+ * Presigned shape: a short-lived GET URL to the compacted object, fetched directly by
+ * the browser (API egress bypassed). Served once the stream is compacted (`object_key`
+ * set). The object is the same NDJSON the inline shape streams, gzip-compressed.
+ */ const readLogsPresignedSchema = z.object({
+    mode: z.literal('presigned'),
+    url: z.string().url().describe('Presigned GET URL for the compacted NDJSON object.'),
+    state: z.literal('closed').describe('Compacted streams are closed before they are served by URL.'),
+    expires_at: z.string().datetime({
+        offset: true
+    }).describe('ISO 8601 instant after which the presigned URL stops working.'),
+    total_bytes: z.number().int().min(0).describe('Committed append byte position for the attempt. This is the runner CAS axis.'),
+    truncated: z.boolean().describe('True when the stream was force-closed because the runner stopped reporting.')
+});
+export const readLogsResponseSchema = z.discriminatedUnion('mode', [
+    readLogsInlineSchema,
+    readLogsPresignedSchema
+]);
+
+//# sourceMappingURL=read.js.map

package/dist/schemas/read.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/read.ts"],"sourcesContent":["import {z} from 'zod';\n\n/**\n * Read endpoint contract: `GET .../steps/:stepId/attempts/:attempt/logs?cursor=N`.\n *\n * `cursor` is an opaque chunk-sequence position, not a byte offset. Server-injected\n * control tombstones (`capped`, `runner_lost`) do not advance the runner byte axis, so\n * the read walks chunks by insertion `seq` to keep every record in stream order. The\n * same `seq` walk backs compaction, so the inline `ndjson` is byte-identical to the\n * decompressed compacted object. Start at 0 and echo back `next_cursor` to page forward.\n */\nexport const readLogsQuerySchema = z.object({\n  cursor: z.coerce\n    .number()\n    .int()\n    .min(0)\n    .default(0)\n    .describe(\n      'Opaque chunk-sequence cursor. Start at 0; echo back the previous response next_cursor to page forward. Not a byte offset.',\n    ),\n});\n\nexport type ReadLogsQueryDto = z.infer<typeof readLogsQuerySchema>;\n\n/**\n * Inline shape: stored NDJSON bytes from `cursor`, parsed client-side with\n * `parseLogRecordLine`. Served while the stream is open or closed but not yet compacted.\n * The bytes carry every record of every type for the `(step, attempt)`; the client\n * filters by record type for display.\n */\nconst readLogsInlineSchema = z.object({\n  mode: z.literal('inline'),\n  ndjson: z\n    .string()\n    .describe('Stored NDJSON: every record for this (step, attempt) from cursor, in stream order.'),\n  next_cursor: z\n    .number()\n    .int()\n    .min(0)\n    .describe('Cursor to pass on the next poll to fetch records after this page.'),\n  has_more: z\n    .boolean()\n    .describe(\n      'True when more buffered records remain past this page; re-poll immediately to drain before tailing at the refresh interval.',\n    ),\n  state: z\n    .enum(['open', 'closed'])\n    .describe('Stream lifecycle: open still accepts appends, closed is terminal.'),\n  truncated: z\n    .boolean()\n    .describe('True when the stream was force-closed because the runner stopped reporting.'),\n});\n\n/**\n * Presigned shape: a short-lived GET URL to the compacted object, fetched directly by\n * the browser (API egress bypassed). Served once the stream is compacted (`object_key`\n * set). The object is the same NDJSON the inline shape streams, gzip-compressed.\n */\nconst readLogsPresignedSchema = z.object({\n  mode: z.literal('presigned'),\n  url: z.string().url().describe('Presigned GET URL for the compacted NDJSON object.'),\n  state: z\n    .literal('closed')\n    .describe('Compacted streams are closed before they are served by URL.'),\n  expires_at: z\n    .string()\n    .datetime({offset: true})\n    .describe('ISO 8601 instant after which the presigned URL stops working.'),\n  total_bytes: z\n    .number()\n    .int()\n    .min(0)\n    .describe('Committed append byte position for the attempt. This is the runner CAS axis.'),\n  truncated: z\n    .boolean()\n    .describe('True when the stream was force-closed because the runner stopped reporting.'),\n});\n\nexport const readLogsResponseSchema = z.discriminatedUnion('mode', [\n  readLogsInlineSchema,\n  readLogsPresignedSchema,\n]);\n\nexport type ReadLogsResponseDto = z.infer<typeof readLogsResponseSchema>;\n"],"names":["z","readLogsQuerySchema","object","cursor","coerce","number","int","min","default","describe","readLogsInlineSchema","mode","literal","ndjson","string","next_cursor","has_more","boolean","state","enum","truncated","readLogsPresignedSchema","url","expires_at","datetime","offset","total_bytes","readLogsResponseSchema","discriminatedUnion"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB;;;;;;;;CAQC,GACD,OAAO,MAAMC,sBAAsBD,EAAEE,MAAM,CAAC;IAC1CC,QAAQH,EAAEI,MAAM,CACbC,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJC,OAAO,CAAC,GACRC,QAAQ,CACP;AAEN,GAAG;AAIH;;;;;CAKC,GACD,MAAMC,uBAAuBV,EAAEE,MAAM,CAAC;IACpCS,MAAMX,EAAEY,OAAO,CAAC;IAChBC,QAAQb,EACLc,MAAM,GACNL,QAAQ,CAAC;IACZM,aAAaf,EACVK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZO,UAAUhB,EACPiB,OAAO,GACPR,QAAQ,CACP;IAEJS,OAAOlB,EACJmB,IAAI,CAAC;QAAC;QAAQ;KAAS,EACvBV,QAAQ,CAAC;IACZW,WAAWpB,EACRiB,OAAO,GACPR,QAAQ,CAAC;AACd;AAEA;;;;CAIC,GACD,MAAMY,0BAA0BrB,EAAEE,MAAM,CAAC;IACvCS,MAAMX,EAAEY,OAAO,CAAC;IAChBU,KAAKtB,EAAEc,MAAM,GAAGQ,GAAG,GAAGb,QAAQ,CAAC;IAC/BS,OAAOlB,EACJY,OAAO,CAAC,UACRH,QAAQ,CAAC;IACZc,YAAYvB,EACTc,MAAM,GACNU,QAAQ,CAAC;QAACC,QAAQ;IAAI,GACtBhB,QAAQ,CAAC;IACZiB,aAAa1B,EACVK,MAAM,GACNC,GAAG,GACHC,GAAG,CAAC,GACJE,QAAQ,CAAC;IACZW,WAAWpB,EACRiB,OAAO,GACPR,QAAQ,CAAC;AACd;AAEA,OAAO,MAAMkB,yBAAyB3B,EAAE4B,kBAAkB,CAAC,QAAQ;IACjElB;IACAW;CACD,EAAE"}

package/dist/schemas/record.d.ts

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+/**
+ * NDJSON log record contract — one JSON object per line, runner-framed.
+ *
+ * `offset` / `committed_length` are byte positions in the raw append NDJSON spool stream
+ * (envelope included) — the offset-CAS axis the runner tracks. The per-job accrual
+ * budget charges the normalized NDJSON bytes the server stores, so framing and control records
+ * count against it too. The per-record byte caps below bound each record so a single
+ * entry's overhead is known and a runner cannot grow storage without moving the
+ * budget: `data` is non-empty and <= MAX_RECORD_DATA_BYTES, the group `name` is
+ * <= MAX_RECORD_NAME_BYTES, the group ids are <= MAX_RECORD_GROUP_ID_BYTES, and every
+ * other field is fixed-shape.
+ *
+ * The envelope is `{v, ts}`, and every record is discriminated by a single flat
+ * `type`. The raw/write and stored/read unions are distinct types: the server-only
+ * `capped` / `runner_lost` tombstones are members of the read union only, so a forged
+ * tombstone cannot pass append validation.
+ *
+ * The append-side `agent_session` record carries one verbatim agent session entry line
+ * in `data`, forwarded opaquely by the runner. On successful ingest, the API normalizes
+ * that raw entry into one or more read-side `agent_session` records whose `row` is the
+ * canonical session view row. The raw and normalized records travel through the same log
+ * append/read pipe; only their contract at each boundary differs.
+ */
+/** Largest decoded `data` payload per record. Longer lines are split by the runner. */
+export declare const MAX_RECORD_DATA_BYTES: number;
+/** Largest `group_start` name. Bounds the only variable-length control field. */
+export declare const MAX_RECORD_NAME_BYTES = 1024;
+/**
+ * Largest `group_id` / `parent_group_id`. The runner emits short monotonic ids (`g1`,
+ * `g2`, …); this only bounds a forged id from a lease-scoped writer so the ids stay a
+ * fixed-shape field like every other record field.
+ */
+export declare const MAX_RECORD_GROUP_ID_BYTES = 256;
+/** Records a lease-scoped runner may append. The write path validates against this. */
+export declare const rawLogRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    stream: z.ZodEnum<{
+        stdout: "stdout";
+        stderr: "stderr";
+    }>;
+    data: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"group_start">;
+    group_id: z.ZodString;
+    parent_group_id: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"group_end">;
+    group_id: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"end">;
+    total_bytes: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"gap">;
+    dropped_bytes: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"agent_session">;
+    data: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>], "type">;
+/** Stored/read records: regular records, normalized agent sessions, and tombstones. */
+export declare const logRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    stream: z.ZodEnum<{
+        stdout: "stdout";
+        stderr: "stderr";
+    }>;
+    data: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"group_start">;
+    group_id: z.ZodString;
+    parent_group_id: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"group_end">;
+    group_id: z.ZodString;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"end">;
+    total_bytes: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"gap">;
+    dropped_bytes: z.ZodNumber;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"agent_session">;
+    row: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        role: z.ZodString;
+        label: z.ZodString;
+        meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            inline: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        text: z.ZodString;
+        terminalFailure: z.ZodBoolean;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"thinking">;
+        text: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool-call">;
+        id: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        input: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool-result">;
+        toolCallId: z.ZodNullable<z.ZodString>;
+        toolName: z.ZodString;
+        output: z.ZodString;
+        isError: z.ZodBoolean;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"lifecycle">;
+        label: z.ZodString;
+        detail: z.ZodNullable<z.ZodString>;
+        meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            inline: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        tone: z.ZodEnum<{
+            error: "error";
+            default: "default";
+            warning: "warning";
+        }>;
+        terminalFailure: z.ZodBoolean;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"raw">;
+        label: z.ZodString;
+        raw: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"capped">;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"runner_lost">;
+    v: z.ZodLiteral<1>;
+    ts: z.ZodNumber;
+}, z.core.$strip>], "type">;
+export type RawLogRecord = z.infer<typeof rawLogRecordSchema>;
+export type LogRecord = z.infer<typeof logRecordSchema>;
+export declare function parseLogRecordLine(line: string): LogRecord;
+/**
+ * Parses one NDJSON line against the raw write union. A forged
+ * server-only `capped` / `runner_lost` record fails here even though it is valid
+ * under the read union — this is the write-path forgery guard.
+ */
+export declare function parseRawLogRecordLine(line: string): RawLogRecord;
+//# sourceMappingURL=record.d.ts.map

package/dist/schemas/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/schemas/record.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,uFAAuF;AACvF,eAAO,MAAM,qBAAqB,QAAY,CAAC;AAE/C,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AA4E7C,uFAAuF;AACvF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO7B,CAAC;AAEH,uFAAuF;AACvF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAS1B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAEhE"}