From edec2aee650ef9f96d8685a17fbed870313144bb Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 3 Jun 2026 21:40:01 +0100
Subject: [PATCH 01/72] feat(logs-server): add runtime column
 (browser|node|edge) to telemetry rows

---
 .../__tests__/bun-only/clean.test.ts          |  1 +
 .../logs-server/__tests__/bun-only/db.test.ts | 63 +++++++++++++++++++
 .../logs-server/__tests__/envelope.test.ts    | 46 ++++++++++++++
 packages/logs-server/src/db.ts                | 24 ++++++-
 packages/logs-server/src/envelope.ts          | 15 +++++
 5 files changed, 148 insertions(+), 1 deletion(-)

diff --git a/packages/logs-server/__tests__/bun-only/clean.test.ts b/packages/logs-server/__tests__/bun-only/clean.test.ts
index a010078..f6a6fad 100644
--- a/packages/logs-server/__tests__/bun-only/clean.test.ts
+++ b/packages/logs-server/__tests__/bun-only/clean.test.ts
@@ -43,6 +43,7 @@ function row(over: Partial<LogRow>): LogRow {
     attrs: null,
     tag: null,
     duration_ms: null,
+    runtime: null,
     ...over,
   };
 }
diff --git a/packages/logs-server/__tests__/bun-only/db.test.ts b/packages/logs-server/__tests__/bun-only/db.test.ts
index 53fd3a5..e7bce1c 100644
--- a/packages/logs-server/__tests__/bun-only/db.test.ts
+++ b/packages/logs-server/__tests__/bun-only/db.test.ts
@@ -24,6 +24,7 @@ function row(over: Partial<LogRow>): LogRow {
     attrs: null,
     tag: null,
     duration_ms: null,
+    runtime: null,
     ...over,
   };
 }
@@ -188,6 +189,68 @@ test('openDb migrates pre-2.7 schema: adds kind/duration_ms, existing rows → k
   }
 });
 
+test('openDb stores runtime column; it round-trips and absence is NULL', () => {
+  const db = openDb(':memory:');
+  const cols = db.query('PRAGMA table_info(logs)').all() as { name: string }[];
+  expect(cols.some((c) => c.name === 'runtime')).toBe(true);
+  insertLogs(db, [
+    row({ msg: 'browser-row', runtime: 'browser' }),
+    row({ msg: 'node-row', runtime: 'node' }),
+    row({ msg: 'unstamped' }), // runtime defaults to null in row()
+  ]);
+  const got = db
+    .query('SELECT msg, runtime FROM logs ORDER BY id')
+    .all() as { msg: string; runtime: unknown }[];
+  expect(got).toEqual([
+    { msg: 'browser-row', runtime: 'browser' },
+    { msg: 'node-row', runtime: 'node' },
+    { msg: 'unstamped', runtime: null },
+  ]);
+});
+
+test('openDb migrates pre-2.9 schema: adds runtime column, existing rows → NULL', () => {
+  // Hand-build a 2.8-era table (kind/duration_ms present, no runtime). The
+  // migration must add the column; existing rows stay NULL.
+  const { Database } = require('bun:sqlite');
+  const legacy = new Database(':memory:');
+  legacy.exec(`CREATE TABLE logs (
+    id INTEGER PRIMARY KEY, ts REAL, recv_ts REAL, kind TEXT DEFAULT 'log',
+    project TEXT, service TEXT, run_id TEXT, trace_id TEXT, span_id TEXT,
+    level TEXT, severity_number INTEGER, logger TEXT, msg TEXT, data TEXT,
+    attrs TEXT, tag TEXT, duration_ms REAL
+  )`);
+  legacy.exec(`INSERT INTO logs (ts, recv_ts, kind, project, msg, data) VALUES
+    (1, 1, 'log', 'p', 'old-one', '{"body":"x"}')`);
+  const tmp = `/tmp/migrate-runtime-${process.pid}-${Date.now()}.db`;
+  legacy.exec(`VACUUM INTO '${tmp}'`);
+  legacy.close();
+
+  const db = openDb(tmp);
+  const cols = db.query('PRAGMA table_info(logs)').all() as { name: string }[];
+  expect(cols.some((c) => c.name === 'runtime')).toBe(true);
+  const old = db.query("SELECT runtime FROM logs WHERE msg = 'old-one'").get() as {
+    runtime: unknown;
+  };
+  expect(old.runtime).toBeNull();
+
+  // Idempotent — a second open is a no-op, and a freshly stamped row coexists.
+  db.close();
+  const db2 = openDb(tmp);
+  insertLogs(db2, [row({ msg: 'new-row', runtime: 'edge', ts: 2, recv_ts: 2 })]);
+  const got = db2.query("SELECT runtime FROM logs WHERE msg = 'new-row'").get() as {
+    runtime: unknown;
+  };
+  expect(got.runtime).toBe('edge');
+  db2.close();
+  for (const p of [tmp, `${tmp}-wal`, `${tmp}-shm`]) {
+    try {
+      require('node:fs').rmSync(p, { force: true });
+    } catch {
+      /* temp file still locked — leave it for the OS */
+    }
+  }
+});
+
 test('insertLogs batch-inserts and rows are retrievable with autoincrement id', () => {
   const db = openDb(':memory:');
   const n = insertLogs(db, [row({ msg: 'a' }), row({ msg: 'b' }), row({ msg: 'c' })]);
diff --git a/packages/logs-server/__tests__/envelope.test.ts b/packages/logs-server/__tests__/envelope.test.ts
index f4ecfc1..54f7a8c 100644
--- a/packages/logs-server/__tests__/envelope.test.ts
+++ b/packages/logs-server/__tests__/envelope.test.ts
@@ -497,6 +497,52 @@ test('back-compat: a mixed envelope (log item + transaction item) yields both ki
   expect(logRow.duration_ms).toBeNull();
 });
 
+//* MARK: Runtime
+
+// The `runtime` column records which Next.js runtime (browser|node|edge)
+// emitted the row, stamped at the Sentry config source. Logs read it from
+// `attributes.runtime`; spans from the span's plain `data.runtime`; events from
+// `tags.runtime` (falling back to Sentry's native `contexts.runtime.name`).
+
+test('log runtime comes from attributes.runtime', () => {
+  const { rows } = parseEnvelope(envelope([log({ attributes: { runtime: a('browser') } })]));
+  expect(rows[0].runtime).toBe('browser');
+});
+
+test('log runtime is null when attributes.runtime is absent', () => {
+  const { rows } = parseEnvelope(envelope([log()]));
+  expect(rows[0].runtime).toBeNull();
+});
+
+test('span runtime comes from the span/trace plain data.runtime, root + children', () => {
+  const tx = transaction();
+  (tx.contexts.trace.data as Record<string, unknown>).runtime = 'node';
+  (tx.spans[0].data as Record<string, unknown>).runtime = 'node';
+  (tx.spans[1].data as Record<string, unknown>).runtime = 'node';
+  const { rows } = parseEnvelope(txEnvelope(tx));
+  expect(rows.every((r) => r.runtime === 'node')).toBe(true);
+});
+
+test('span runtime is null when data.runtime is absent', () => {
+  const { rows } = parseEnvelope(txEnvelope(transaction()));
+  expect(rows.every((r) => r.runtime === null)).toBe(true);
+});
+
+test('event runtime prefers tags.runtime', () => {
+  const ev = exceptionEvent({ tags: { runtime: 'edge' } });
+  expect(parseEnvelope(eventEnvelope(ev)).rows[0].runtime).toBe('edge');
+});
+
+test('event runtime falls back to contexts.runtime.name when no tag', () => {
+  // exceptionEvent() carries contexts.runtime = { name: 'node', ... }
+  expect(parseEnvelope(eventEnvelope(exceptionEvent())).rows[0].runtime).toBe('node');
+});
+
+test('event runtime is null when neither tags.runtime nor contexts.runtime present', () => {
+  const bare = { event_id: 'deadbeef', level: 'info', timestamp: 1.0 };
+  expect(parseEnvelope(eventEnvelope(bare)).rows[0].runtime).toBeNull();
+});
+
 //* MARK: Events (exceptions)
 
 // Real error/message events. Both fixtures below are the verbatim payloads
diff --git a/packages/logs-server/src/db.ts b/packages/logs-server/src/db.ts
index 3a8d2c6..f372a8c 100644
--- a/packages/logs-server/src/db.ts
+++ b/packages/logs-server/src/db.ts
@@ -22,6 +22,7 @@ export type LogRow = {
   attrs: string | null; // flat key→value JSON (NULL when none). Spans add op/status/parent_span_id/description/duration_ms.
   tag: string | null; // diag.tag attribution (optional)
   duration_ms: number | null; // span headline metric ((timestamp - start_timestamp)*1000); NULL for logs
+  runtime: string | null; // emitting Next.js runtime (browser|node|edge), stamped at the Sentry config; NULL when absent
 };
 
 const COLS: (keyof LogRow)[] = [
@@ -41,6 +42,7 @@ const COLS: (keyof LogRow)[] = [
   'attrs',
   'tag',
   'duration_ms',
+  'runtime',
 ];
 
 // Migrate pre-2.2 schemas: add the `attrs` column if missing, backfill from
@@ -102,6 +104,24 @@ function migrateKindColumns(db: Database): void {
   }
 }
 
+// Migrate pre-2.9 schemas: add the free-text `runtime` column if missing. It
+// records which Next.js runtime (browser|node|edge) emitted the row, stamped at
+// the Sentry config source. Legacy rows stay NULL (the runtime split didn't
+// exist when they were written). Wrapped in BEGIN IMMEDIATE so partial state
+// can't leak; idempotent (guarded by the table_info check).
+function migrateRuntimeColumn(db: Database): void {
+  const cols = db.query('PRAGMA table_info(logs)').all() as { name: string }[];
+  if (cols.some((c) => c.name === 'runtime')) return;
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    db.exec('ALTER TABLE logs ADD COLUMN runtime TEXT');
+    db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+}
+
 export function openDb(path: string): Database {
   const db = new Database(path);
   db.exec('PRAGMA journal_mode = WAL'); // concurrent hammer-ingest + query
@@ -123,7 +143,8 @@ export function openDb(path: string): Database {
       data            TEXT,
       attrs           TEXT,
       tag             TEXT,
-      duration_ms     REAL
+      duration_ms     REAL,
+      runtime         TEXT
     )`);
   db.exec(
     `CREATE INDEX IF NOT EXISTS idx_logs_corr
@@ -131,6 +152,7 @@ export function openDb(path: string): Database {
   );
   migrateAttrsColumn(db);
   migrateKindColumns(db);
+  migrateRuntimeColumn(db);
   return db;
 }
 
diff --git a/packages/logs-server/src/envelope.ts b/packages/logs-server/src/envelope.ts
index 50d3aac..9191363 100644
--- a/packages/logs-server/src/envelope.ts
+++ b/packages/logs-server/src/envelope.ts
@@ -54,6 +54,12 @@ function strOr(v: unknown, d: string): string {
   return v === undefined || v === null ? d : String(v);
 }
 
+// Like strOr but yields null (not a default) for absent values — for nullable
+// columns (e.g. `runtime`) where absence must round-trip as SQL NULL.
+function strOrNull(v: unknown): string | null {
+  return v === undefined || v === null ? null : String(v);
+}
+
 // Strip a leading ANSI styled prefix shaped like `\x1b[<style>m%s\x1b[0m ` —
 // pure rendering noise from console-monkey-patchers upstream of the JS
 // `consoleLoggingIntegration` (React DevTools / HMR / the `debug` package
@@ -118,6 +124,7 @@ function toRow(rec: Record<string, unknown>, sdkName: string, envTraceId: string
     attrs: flattenAttrs(attrsForFlatten),
     tag: diagTag === undefined || diagTag === null ? null : String(diagTag),
     duration_ms: null,
+    runtime: strOrNull(attrVal(attrs, 'runtime')),
     routeDb,
   };
 }
@@ -224,6 +231,7 @@ function spanRow(opts: {
     attrs: flattenSpanAttrs(dataForPersist, headline),
     tag: diagTag === undefined || diagTag === null ? null : String(diagTag),
     duration_ms: dur,
+    runtime: strOrNull(dataForPersist?.['runtime']),
     routeDb,
   };
 }
@@ -368,6 +376,12 @@ function eventRow(
   }
   const diagTag = (evForPersist.tags as Record<string, unknown> | undefined)?.['diag.tag'];
 
+  // runtime: prefer an explicit tags.runtime stamp; else fall back to Sentry's
+  // native contexts.runtime.name (the SDK auto-fills this for server events).
+  const tagRuntime = (evForPersist.tags as Record<string, unknown> | undefined)?.['runtime'];
+  const ctxRuntime = (contexts?.runtime as Record<string, unknown> | undefined)?.name;
+  const runtime = strOrNull(tagRuntime ?? ctxRuntime);
+
   return {
     ts: tsNum(ev.timestamp) ?? 0,
     kind: 'event',
@@ -384,6 +398,7 @@ function eventRow(
     attrs: Object.keys(headline).length === 0 ? null : JSON.stringify(headline),
     tag: diagTag === undefined || diagTag === null ? null : String(diagTag),
     duration_ms: null,
+    runtime,
     routeDb,
   };
 }

From 64fa6fd41d5047ff57a14d9fcb70a2e3ff535a9d Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 3 Jun 2026 23:41:50 +0100
Subject: [PATCH 02/72] feat(logs-server): store web vitals + request on root
 span attrs

---
 .../logs-server/__tests__/envelope.test.ts    | 76 +++++++++++++++++++
 packages/logs-server/src/envelope.ts          | 63 ++++++++++++---
 2 files changed, 129 insertions(+), 10 deletions(-)

diff --git a/packages/logs-server/__tests__/envelope.test.ts b/packages/logs-server/__tests__/envelope.test.ts
index 54f7a8c..e96eace 100644
--- a/packages/logs-server/__tests__/envelope.test.ts
+++ b/packages/logs-server/__tests__/envelope.test.ts
@@ -375,6 +375,82 @@ test('ISO-8601 string timestamps (python sentry_sdk) yield real ts + duration, n
   expect(rows[1].duration_ms).toBeCloseTo(20, 3);
 });
 
+//* MARK: Transaction metadata (web vitals + request)
+
+// Web vitals ride at the EVENT level (`event.measurements`), NOT on any span.
+// The architecture stores transaction-level metadata ONCE on the ROOT span row
+// (the segment); child spans never carry it. The key convention is
+// `attrs["measurement.<vital>"] = <value>` (value only, unit implied) and
+// `attrs["request.url"] / ["request.method"]`. trace-view.ts reads these.
+
+const measurements = {
+  lcp: { value: 1234.5, unit: 'millisecond' },
+  cls: { value: 0.01, unit: '' },
+  fcp: { value: 800.2, unit: 'millisecond' },
+  ttfb: { value: 120, unit: 'millisecond' },
+  inp: { value: 80, unit: 'millisecond' },
+};
+
+test('root row attrs carry web vitals from event.measurements (value extracted)', () => {
+  const { rows } = parseEnvelope(txEnvelope(transaction({ measurements })));
+  const root = JSON.parse(rows[0].attrs as string) as Record<string, unknown>;
+  expect(root['measurement.lcp']).toBe(1234.5);
+  expect(root['measurement.cls']).toBe(0.01);
+  expect(root['measurement.fcp']).toBe(800.2);
+  expect(root['measurement.ttfb']).toBe(120);
+  expect(root['measurement.inp']).toBe(80);
+  // the trace context's own data is preserved alongside the vitals
+  expect(root.op).toBe('http.server');
+  expect(root['diag.project']).toBe('titanium');
+});
+
+test('child span rows do NOT carry the transaction web vitals', () => {
+  const { rows } = parseEnvelope(txEnvelope(transaction({ measurements })));
+  for (const child of rows.slice(1)) {
+    const a = JSON.parse(child.attrs as string) as Record<string, unknown>;
+    expect(a['measurement.lcp']).toBeUndefined();
+    expect(a['measurement.cls']).toBeUndefined();
+  }
+});
+
+test('no measurements / no request ⇒ nothing added (back-compat baseline)', () => {
+  const { rows } = parseEnvelope(txEnvelope(transaction()));
+  const root = JSON.parse(rows[0].attrs as string) as Record<string, unknown>;
+  expect(Object.keys(root).some((k) => k.startsWith('measurement.'))).toBe(false);
+  expect(root['request.url']).toBeUndefined();
+  expect(root['request.method']).toBeUndefined();
+});
+
+test('a measurement with a non-numeric value is skipped (never corrupts attrs)', () => {
+  const { rows } = parseEnvelope(
+    txEnvelope(transaction({ measurements: { lcp: { value: 'oops', unit: '' } } })),
+  );
+  const root = JSON.parse(rows[0].attrs as string) as Record<string, unknown>;
+  expect(root['measurement.lcp']).toBeUndefined();
+});
+
+test('root row attrs capture request.url and request.method when present', () => {
+  const { rows } = parseEnvelope(
+    txEnvelope(transaction({ request: { url: 'https://app.test/dashboard', method: 'GET' } })),
+  );
+  const root = JSON.parse(rows[0].attrs as string) as Record<string, unknown>;
+  expect(root['request.url']).toBe('https://app.test/dashboard');
+  expect(root['request.method']).toBe('GET');
+  // and child spans still do not carry request metadata
+  const child = JSON.parse(rows[1].attrs as string) as Record<string, unknown>;
+  expect(child['request.url']).toBeUndefined();
+});
+
+test('vitals attach to the root even when the trace context had no data block', () => {
+  // A trace context with no `data` ⇒ root.attrs would be null without vitals.
+  // Merging must still produce a valid attrs object carrying the measurements.
+  const tx = transaction({ measurements: { lcp: { value: 999, unit: 'millisecond' } } });
+  delete (tx.contexts.trace as Record<string, unknown>).data;
+  const { rows } = parseEnvelope(txEnvelope(tx));
+  const root = JSON.parse(rows[0].attrs as string) as Record<string, unknown>;
+  expect(root['measurement.lcp']).toBe(999);
+});
+
 //* MARK: Span tolerance
 
 // The sink's prime directive: never throw, never emit a corrupt row. These
diff --git a/packages/logs-server/src/envelope.ts b/packages/logs-server/src/envelope.ts
index 9191363..7d9cb4e 100644
--- a/packages/logs-server/src/envelope.ts
+++ b/packages/logs-server/src/envelope.ts
@@ -236,6 +236,40 @@ function spanRow(opts: {
   };
 }
 
+// Transaction-level metadata that lives ONCE on the ROOT span row (the
+// segment) — we never duplicate it onto child spans; nesting/inheritance is
+// reconstructed on demand by the reader (scripts/trace-view.ts). Two groups:
+//
+//   measurement.<vital> — web vitals from `event.measurements`. VALUE ONLY
+//     (the unit is implied — ms for timing vitals, unitless for CLS), e.g.
+//     attrs["measurement.lcp"] = 1234.5. Keys are lowercased vital names
+//     exactly as Sentry sends them (lcp, cls, fcp, ttfb, inp, fp, fid, ...).
+//   request.url / request.method — from `event.request`, cheap bug-repro
+//     context.
+//
+// Mirror this convention in scripts/trace-view.ts (the "view substitute").
+function rootTransactionAttrs(tx: Record<string, unknown>): Record<string, unknown> {
+  const extra: Record<string, unknown> = {};
+
+  const measurements = tx.measurements as Record<string, unknown> | undefined;
+  if (measurements && typeof measurements === 'object') {
+    for (const k of Object.keys(measurements)) {
+      const m = measurements[k] as { value?: unknown } | undefined;
+      const v = m && typeof m === 'object' ? m.value : undefined;
+      if (typeof v === 'number' && Number.isFinite(v)) extra[`measurement.${k}`] = v;
+    }
+  }
+
+  const request = tx.request as Record<string, unknown> | undefined;
+  if (request && typeof request === 'object') {
+    if (request.url !== undefined && request.url !== null) extra['request.url'] = request.url;
+    if (request.method !== undefined && request.method !== null)
+      extra['request.method'] = request.method;
+  }
+
+  return extra;
+}
+
 // Expand a transaction event into its span rows: the ROOT (from
 // `contexts.trace`, timed by the event's top-level start/timestamp) plus one
 // row per `spans[]` child (each self-timed). Emitted in that order.
@@ -252,16 +286,25 @@ function transactionRows(
   if (trace && typeof trace === 'object') {
     const op = (trace.data as Record<string, unknown> | undefined)?.['sentry.op'] ?? trace.op;
     const rootMsg = strOr(tx.transaction ?? op, '');
-    out.push(
-      spanRow({
-        spanObj: trace,
-        msg: rootMsg,
-        start: tx.start_timestamp,
-        end: tx.timestamp,
-        sdkName,
-        envTraceId,
-      }),
-    );
+    const root = spanRow({
+      spanObj: trace,
+      msg: rootMsg,
+      start: tx.start_timestamp,
+      end: tx.timestamp,
+      sdkName,
+      envTraceId,
+    });
+
+    // Attach transaction-level metadata (web vitals + request) onto the ROOT
+    // row's flat attrs only — never the child spans. Merge into the existing
+    // attrs JSON (which may be null when the trace context had no data).
+    const extra = rootTransactionAttrs(tx);
+    if (Object.keys(extra).length > 0) {
+      const existing = root.attrs ? (JSON.parse(root.attrs) as Record<string, unknown>) : {};
+      root.attrs = JSON.stringify({ ...existing, ...extra });
+    }
+
+    out.push(root);
   }
 
   const spans = tx.spans;

From cbb1f3efcb342113e7ffb2447fcee16035e78147 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 3 Jun 2026 23:47:10 +0100
Subject: [PATCH 03/72] docs(logs-server): document root transaction metadata +
 tree CTE

---
 packages/logs-server/docs/reading-logs.md | 67 +++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/packages/logs-server/docs/reading-logs.md b/packages/logs-server/docs/reading-logs.md
index ade70ec..e75ea30 100644
--- a/packages/logs-server/docs/reading-logs.md
+++ b/packages/logs-server/docs/reading-logs.md
@@ -141,3 +141,70 @@ sqlite3 -header -column .davstack/logs/default.db "
 "
 ```
 
+## Spans: transaction metadata + the tree
+
+We do NOT duplicate transaction-level metadata onto every span. It is stored
+ONCE on the **ROOT span row** (the segment — the row whose `parent_span_id` is
+empty / not present in the trace), and nesting is reconstructed on demand. There
+is no SQL view for the tree; this CTE (and `titanium/scripts/trace-view.ts`) IS
+the view substitute.
+
+### Root-only metadata keys (in `attrs`)
+
+Stamped onto the root span row only, by `transactionRows()` in `src/envelope.ts`:
+
+| key                    | source                       | notes                          |
+|------------------------|------------------------------|--------------------------------|
+| `measurement.lcp`      | `event.measurements.lcp`     | web vital, **value only**, ms  |
+| `measurement.fcp`      | `event.measurements.fcp`     | ms                             |
+| `measurement.ttfb`     | `event.measurements.ttfb`    | ms                             |
+| `measurement.inp`      | `event.measurements.inp`     | ms                             |
+| `measurement.cls`      | `event.measurements.cls`     | unitless                       |
+| `measurement.<other>`  | `event.measurements.<k>`     | any vital Sentry sends         |
+| `request.url`          | `event.request.url`          | bug-repro context              |
+| `request.method`       | `event.request.method`       | bug-repro context              |
+
+```bash
+# Web vitals for a trace (read off the root span row)
+sqlite3 -header -column .davstack/logs/default.db "
+  SELECT attrs->>'measurement.lcp'  AS lcp_ms,
+         attrs->>'measurement.cls'  AS cls,
+         attrs->>'measurement.inp'  AS inp_ms,
+         attrs->>'request.url'      AS url
+  FROM logs
+  WHERE kind = 'span'
+    AND trace_id = '<trace_id>'
+    AND COALESCE(attrs->>'parent_span_id','') = '';
+"
+```
+
+### Reconstruct the span tree (recursive CTE)
+
+`parent_span_id` is surfaced into `attrs` for each span. Walk it from the roots
+to get depth + a materialised path, ordered depth-first — the same shape the
+`trace-view.ts` waterfall renders.
+
+```bash
+sqlite3 -header -column .davstack/logs/default.db "
+  WITH RECURSIVE tree AS (
+    -- roots: spans with no resolvable parent in this trace
+    SELECT id, span_id, attrs->>'parent_span_id' AS parent,
+           0 AS depth, printf('%010d', id) AS path, msg, duration_ms
+    FROM logs
+    WHERE kind = 'span' AND trace_id = '<trace_id>'
+      AND COALESCE(attrs->>'parent_span_id','') = ''
+    UNION ALL
+    SELECT c.id, c.span_id, c.attrs->>'parent_span_id',
+           t.depth + 1, t.path || '.' || printf('%010d', c.id), c.msg, c.duration_ms
+    FROM logs c
+    JOIN tree t ON c.attrs->>'parent_span_id' = t.span_id
+    WHERE c.kind = 'span' AND c.trace_id = '<trace_id>'
+  )
+  SELECT depth,
+         substr('                    ', 1, depth*2) || msg AS tree,
+         round(duration_ms) AS dur_ms
+  FROM tree
+  ORDER BY path;
+"
+```
+

From df51308c980cd4f91d6d1fae9e326a08b7902f3f Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 3 Jun 2026 23:53:56 +0100
Subject: [PATCH 04/72] chore(logs-server): changeset for runtime column +
 root-span vitals

---
 .changeset/logs-server-runtime-vitals.md | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 .changeset/logs-server-runtime-vitals.md

diff --git a/.changeset/logs-server-runtime-vitals.md b/.changeset/logs-server-runtime-vitals.md
new file mode 100644
index 0000000..feaca36
--- /dev/null
+++ b/.changeset/logs-server-runtime-vitals.md
@@ -0,0 +1,9 @@
+---
+"@davstack/logs-server": minor
+---
+
+Enrich telemetry rows with a `runtime` column and root-span transaction metadata.
+
+- **`runtime` column** (`browser | node | edge`): added to every row (spans, logs, events) with an idempotent `ALTER` migration. The shred can't recover the runtime from per-span fields once a transaction is expanded, so the consumer stamps it (Sentry `beforeSendLog` / `beforeSendTransaction`) and the parser persists it into a first-class column for trivial filtering (`WHERE runtime='browser'`) instead of digging through `attrs`.
+- **Web vitals + request on the root span**: `transactionRows()` now reads `tx.measurements` (numeric web vitals → `attrs["measurement.<vital>"]`, value-only: LCP/FCP/TTFB/INP/FID in ms, CLS unitless) and `tx.request` (→ `attrs["request.url"]` / `["request.method"]`), attaching them to the **root span row only** — no child duplication, no new columns. This is the "enriched root span" model (spans are the primitive; the segment/root span carries what the transaction used to), recovering the perf data the transaction→span shred otherwise drops.
+- Docs: `reading-logs.md` gains a section on the root transaction metadata + a recursive-CTE query for reconstructing the span tree from the flat table.

From 675d99b1607964e07dd92aa4690f52867593f22c Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Thu, 4 Jun 2026 00:04:05 +0100
Subject: [PATCH 05/72] feat(logs-server): add view verb (nested trace
 waterfall + list/cross scan)

---
 .changeset/logs-server-view.md                |  12 +
 .../__tests__/bun-only/view.test.ts           | 215 ++++++++++++
 packages/logs-server/src/cli-spec.ts          |  30 ++
 packages/logs-server/src/view.ts              | 317 ++++++++++++++++++
 4 files changed, 574 insertions(+)
 create mode 100644 .changeset/logs-server-view.md
 create mode 100644 packages/logs-server/__tests__/bun-only/view.test.ts
 create mode 100644 packages/logs-server/src/view.ts

diff --git a/.changeset/logs-server-view.md b/.changeset/logs-server-view.md
new file mode 100644
index 0000000..5163a5f
--- /dev/null
+++ b/.changeset/logs-server-view.md
@@ -0,0 +1,12 @@
+---
+"@davstack/logs-server": minor
+---
+
+Add a `view` CLI verb to render traces from the local sink.
+
+The viewer encodes the sink's own schema (the `runtime` column, `measurement.*` root-span attrs, the `kind ∈ span|log|event` enum, `parent_span_id` resolution, the transaction→span shred), so it lives in the package and ships versioned with that schema instead of being copied into each consuming repo.
+
+- `logs-server view <trace_id>` — genuinely nested waterfall (DFS span tree via `parent_span_id`; logs slot under their enclosing span, orphans float at root by timestamp), with a web-vitals + request header read off the root span.
+- `logs-server view --list [--n N]` — N most-recent traces with row/span/runtime summary.
+- `logs-server view --cross [--n N]` — scan recent traces for ones spanning >1 runtime; the browser↔server trace-propagation feedback-loop command.
+- Writes Markdown to `.davstack/view.md` by default (trace tables are wide and wrap badly in a terminal); `--stdout` prints instead. Flags: `--db` (accepts a bare session name → `.davstack/logs/<name>.db`, or a path), `--ids`, `--limit`, `--out`.
diff --git a/packages/logs-server/__tests__/bun-only/view.test.ts b/packages/logs-server/__tests__/bun-only/view.test.ts
new file mode 100644
index 0000000..31ad5eb
--- /dev/null
+++ b/packages/logs-server/__tests__/bun-only/view.test.ts
@@ -0,0 +1,215 @@
+// `view` renderer + pure helpers. Asserts the nesting, runtime labelling, and
+// root-span vitals header that the trace viewer depends on, plus db-path
+// resolution. Pure functions are tested directly; renderers run against an
+// in-memory db seeded via the real insert path.
+
+import { test, expect } from 'bun:test';
+import { join } from 'node:path';
+import { openDb, insertLogs, type LogRow } from '../../src/db.js';
+import {
+  runtimeOf,
+  bareRuntime,
+  parentOf,
+  vitalsLine,
+  buildTree,
+  summarise,
+  renderTrace,
+  renderList,
+  renderCross,
+  resolveDbPath,
+  type ViewRow,
+} from '../../src/view.js';
+
+const T = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+
+function logRow(over: Partial<LogRow>): LogRow {
+  return {
+    ts: 1_700_000_000.0,
+    recv_ts: 1_700_000_000_000,
+    kind: 'log',
+    project: 'proj',
+    service: 'sentry.javascript.nextjs',
+    run_id: 'run-1',
+    trace_id: T,
+    span_id: 'bbbbbbbbbbbbbbbb',
+    level: 'info',
+    severity_number: 9,
+    logger: 'auto',
+    msg: 'hello',
+    data: '{}',
+    attrs: null,
+    tag: null,
+    duration_ms: null,
+    runtime: null,
+    ...over,
+  };
+}
+
+function viewRow(over: Partial<ViewRow>): ViewRow {
+  return { kind: 'span', msg: '', attrs: null, data: null, duration_ms: null, ts: 1000, span_id: null, id: 1, ...over };
+}
+
+//* MARK: runtimeOf
+test('runtimeOf trusts a stamped runtime over any heuristic', () => {
+  expect(runtimeOf({ runtime: 'edge', op: 'http.server' })).toBe('edge');
+});
+
+test('runtimeOf falls back to a heuristic with a trailing ?', () => {
+  expect(runtimeOf({ op: 'http.server' })).toBe('node?');
+  expect(runtimeOf({ op: 'pageload' })).toBe('browser?');
+  expect(runtimeOf({})).toBe('?');
+  expect(bareRuntime({ op: 'http.server' })).toBe('node');
+  expect(bareRuntime({})).toBe('unknown');
+});
+
+//* MARK: parentOf
+test('parentOf reads parent_span_id from data, then attrs', () => {
+  expect(parentOf({ data: JSON.stringify({ parent_span_id: 'p1' }), attrs: null })).toBe('p1');
+  expect(parentOf({ data: null, attrs: JSON.stringify({ 'sentry.parent_span_id': 'p2' }) })).toBe('p2');
+  expect(parentOf({ data: 'not json', attrs: null })).toBe('');
+});
+
+//* MARK: vitalsLine
+test('vitalsLine formats web vitals (ms rounded, CLS unitless) + request', () => {
+  const line = vitalsLine({ 'measurement.lcp': 1234.6, 'measurement.cls': 0.04, 'request.method': 'GET', 'request.url': '/' });
+  expect(line).toContain('LCP 1235ms');
+  expect(line).toContain('CLS 0.04');
+  expect(line).toContain('req: GET /');
+});
+
+test('vitalsLine returns empty string when nothing present', () => {
+  expect(vitalsLine({})).toBe('');
+});
+
+//* MARK: buildTree
+test('buildTree nests children under parents and logs under their span', () => {
+  const rows: ViewRow[] = [
+    viewRow({ kind: 'span', span_id: 'root', msg: 'root', ts: 1, id: 1 }),
+    viewRow({ kind: 'span', span_id: 'child', data: JSON.stringify({ parent_span_id: 'root' }), msg: 'child', ts: 2, id: 2 }),
+    viewRow({ kind: 'log', span_id: 'child', msg: 'log-under-child', ts: 3, id: 3 }),
+  ];
+  const flat = buildTree(rows);
+  const byMsg = Object.fromEntries(flat.map((x) => [x.r.msg, x.depth]));
+  expect(byMsg['root']).toBe(0);
+  expect(byMsg['child']).toBe(1);
+  expect(byMsg['log-under-child']).toBe(2);
+});
+
+test('buildTree floats logs/spans with unresolvable parents at root', () => {
+  const rows: ViewRow[] = [
+    viewRow({ kind: 'span', span_id: 'a', data: JSON.stringify({ parent_span_id: 'missing' }), msg: 'a', id: 1 }),
+    viewRow({ kind: 'log', span_id: 'nope', msg: 'orphan-log', id: 2 }),
+  ];
+  const flat = buildTree(rows);
+  expect(flat.every((x) => x.depth === 0)).toBe(true);
+  expect(flat.map((x) => x.r.msg).sort()).toEqual(['a', 'orphan-log']);
+});
+
+test('buildTree does not loop on a parent cycle', () => {
+  const rows: ViewRow[] = [
+    viewRow({ kind: 'span', span_id: 'x', data: JSON.stringify({ parent_span_id: 'y' }), msg: 'x', id: 1 }),
+    viewRow({ kind: 'span', span_id: 'y', data: JSON.stringify({ parent_span_id: 'x' }), msg: 'y', id: 2 }),
+  ];
+  const flat = buildTree(rows);
+  expect(flat.length).toBe(2); // each visited once, no infinite recursion
+});
+
+//* MARK: summarise
+test('summarise counts spans and collects distinct runtimes', () => {
+  const s = summarise([
+    { kind: 'span', attrs: JSON.stringify({ runtime: 'node' }) },
+    { kind: 'span', attrs: JSON.stringify({ runtime: 'browser' }) },
+    { kind: 'log', attrs: JSON.stringify({ runtime: 'browser' }) },
+  ]);
+  expect(s.spans).toBe(2);
+  expect(s.rows).toBe(3);
+  expect(s.runtimes).toEqual(['browser', 'node']);
+});
+
+//* MARK: renderTrace (against a real db)
+function seedTrace(db: ReturnType<typeof openDb>) {
+  insertLogs(db, [
+    logRow({
+      kind: 'span',
+      span_id: 'root0000',
+      msg: 'GET /',
+      duration_ms: 100,
+      ts: 1000,
+      runtime: 'node',
+      attrs: JSON.stringify({ op: 'http.server', runtime: 'node', 'measurement.lcp': 1234.5, 'request.method': 'GET', 'request.url': '/' }),
+    }),
+    logRow({
+      kind: 'span',
+      span_id: 'child000',
+      msg: 'getRaceResults',
+      duration_ms: 50,
+      ts: 1000.01,
+      runtime: 'node',
+      data: JSON.stringify({ parent_span_id: 'root0000' }),
+      attrs: JSON.stringify({ op: 'server-fn', runtime: 'node' }),
+    }),
+    logRow({ kind: 'log', span_id: 'child000', msg: 'hello:db', ts: 1000.02, runtime: 'node', attrs: JSON.stringify({ runtime: 'node' }) }),
+  ]);
+}
+
+test('renderTrace nests children/logs and prints a vitals header from the root', () => {
+  const db = openDb(':memory:');
+  seedTrace(db);
+  const md = renderTrace(db, T, 'default');
+  expect(md).toContain('vitals: LCP 1235ms');
+  expect(md).toContain('req: GET /');
+  expect(md).toContain('└─'); // genuine nesting rendered
+  expect(md).toContain('getRaceResults');
+  expect(md).toContain('hello:db');
+  expect(md).toContain('node'); // runtime column
+});
+
+test('renderTrace reports an empty db cleanly', () => {
+  const db = openDb(':memory:');
+  expect(renderTrace(db, T, 'default')).toContain('no rows in db');
+});
+
+//* MARK: renderList / renderCross
+test('renderList summarises recent traces', () => {
+  const db = openDb(':memory:');
+  seedTrace(db);
+  const md = renderList(db, 20, 'default');
+  expect(md).toContain('most-recent traces');
+  expect(md).toContain(T);
+});
+
+test('renderCross flags when no trace spans >1 runtime', () => {
+  const db = openDb(':memory:');
+  seedTrace(db); // single-runtime (node) trace
+  expect(renderCross(db, 200, 'default')).toContain('NOT working yet');
+});
+
+test('renderCross detects a browser↔node stitched trace', () => {
+  const db = openDb(':memory:');
+  insertLogs(db, [
+    logRow({ kind: 'span', span_id: 's1', msg: 'pageload', ts: 1, runtime: 'browser', attrs: JSON.stringify({ runtime: 'browser' }) }),
+    logRow({ kind: 'span', span_id: 's2', msg: 'GET /', ts: 2, runtime: 'node', attrs: JSON.stringify({ runtime: 'node' }) }),
+  ]);
+  const md = renderCross(db, 200, 'default');
+  expect(md).toContain('stitch browser ↔ node');
+});
+
+//* MARK: resolveDbPath
+test('resolveDbPath maps a bare name to .davstack/logs/<name>.db', () => {
+  const r = resolveDbPath({ db: 'session2', cwd: '/repo' });
+  expect(r.name).toBe('session2');
+  expect(r.path).toBe(join('/repo', '.davstack', 'logs', 'session2.db'));
+});
+
+test('resolveDbPath defaults to the repo default db', () => {
+  const r = resolveDbPath({ cwd: '/repo' });
+  expect(r.name).toBe('default');
+  expect(r.path).toBe(join('/repo', '.davstack', 'logs', 'default.db'));
+});
+
+test('resolveDbPath passes a path-like value straight through', () => {
+  const r = resolveDbPath({ db: 'tmp/custom.db', cwd: '/repo' });
+  expect(r.name).toBe('custom');
+  // `resolve` may prepend a drive on Windows; assert the tail, not the root.
+  expect(r.path.endsWith(join('repo', 'tmp', 'custom.db'))).toBe(true);
+});
diff --git a/packages/logs-server/src/cli-spec.ts b/packages/logs-server/src/cli-spec.ts
index 09a2b7b..38ddb7f 100644
--- a/packages/logs-server/src/cli-spec.ts
+++ b/packages/logs-server/src/cli-spec.ts
@@ -253,6 +253,36 @@ export const cliSpec: CliSpec = {
         }
       },
     },
+    view: {
+      description:
+        'Render one trace as a nested waterfall, or scan recent traces (--list / --cross for cross-runtime propagation). Writes Markdown to .davstack/view.md (wide tables wrap badly in a terminal); --stdout to print instead.',
+      positionals: [{ name: 'trace_id', required: false, description: 'Trace to render (omit with --list / --cross)' }],
+      flags: {
+        db: dbFlag(),
+        list: { type: 'boolean', default: false, description: 'List N most-recent traces' },
+        cross: { type: 'boolean', default: false, description: 'Scan recent traces for ones spanning >1 runtime' },
+        n: { type: 'number', description: 'Count for --list (default 20) / --cross (default 200)' },
+        limit: { type: 'number', description: 'Cap rows in a waterfall' },
+        ids: { type: 'boolean', default: false, description: 'Add span_id / parent columns (propagation debugging)' },
+        out: { type: 'string', description: 'Output path (default .davstack/view.md)' },
+        stdout: { type: 'boolean', default: false, description: 'Print to stdout instead of writing a file' },
+      },
+      run: async (ctx) => {
+        const { runView } = await import('./view.js');
+        return runView({
+          trace: ctx.positionals[0],
+          list: ctx.flags.list as boolean,
+          cross: ctx.flags.cross as boolean,
+          n: ctx.flags.n as number | undefined,
+          limit: ctx.flags.limit as number | undefined,
+          ids: ctx.flags.ids as boolean,
+          out: ctx.flags.out as string | undefined,
+          stdout: ctx.flags.stdout as boolean,
+          db: ctx.flags.db as string | undefined,
+          cwd: process.cwd(),
+        });
+      },
+    },
     doctor: doctorSpec,
     check: {
       ...doctorSpec,
diff --git a/packages/logs-server/src/view.ts b/packages/logs-server/src/view.ts
new file mode 100644
index 0000000..db7ea37
--- /dev/null
+++ b/packages/logs-server/src/view.ts
@@ -0,0 +1,317 @@
+// `view` — render one trace from the local sink as a nested waterfall, or scan
+// recent traces (list / cross-runtime). Built for the browser↔server
+// trace-propagation feedback loop: after a fix, `view --cross` shows whether any
+// single trace now stitches browser → node → db.
+//
+// Output is written to `.davstack/view.md` (under the already-gitignored
+// `.davstack/`) — trace tables are wide and wrap badly in a terminal; open the
+// file in an editor. Each run overwrites it. `--stdout` prints instead.
+//
+// This module is pure of CLI parsing: `runView()` is the entry the cli-spec
+// dispatches to; the render functions take an open bun:sqlite `Database` so they
+// can be unit-tested against an in-memory db.
+
+import { Database } from 'bun:sqlite';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { DEFAULT_DB_DIR, defaultDbPathForRepo } from './paths.js';
+
+//* MARK: Row shape
+/** The subset of columns the renderers read. Matches `logs` table rows. */
+export interface ViewRow {
+  kind: string;
+  msg: string;
+  attrs: string | null;
+  data: string | null;
+  duration_ms: number | null;
+  ts: number;
+  span_id: string | null;
+  id: number;
+}
+
+const parse = (s: string | null): Record<string, any> => {
+  try {
+    return JSON.parse(s || '{}');
+  } catch {
+    return {};
+  }
+};
+const esc = (s: string) => (s || '').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+
+//* MARK: Runtime
+/** Authoritative when the consumer stamped `runtime`; else a heuristic (`?`). */
+export function runtimeOf(a: Record<string, any>): string {
+  if (a.runtime) return a.runtime; // stamped by the consumer's Sentry config — trust it
+  const o = a['sentry.origin'] || '';
+  const op = a.op || a['sentry.op'] || '';
+  const k = a['otel.kind'];
+  if (/\.browser\./.test(o) || /^(pageload|navigation|paint|mark|resource\.|ui\.|browser\.)/.test(op)) return 'browser?';
+  if (k === 'CLIENT' || op === 'http.client' || o === 'auto.http.otel.node_fetch') return 'node?'; // outbound from node
+  if (k === 'SERVER' || op === 'http.server' || a['next.span_type'] != null) return 'node?';
+  return '?';
+}
+/** Bare runtime (no `?`), for set membership when scanning. */
+export const bareRuntime = (a: Record<string, any>) => runtimeOf(a).replace(/\?$/, '') || 'unknown';
+
+/** Parent span id, dug out of the per-row data/attrs JSON. */
+export function parentOf(r: Pick<ViewRow, 'data' | 'attrs'>): string {
+  const d = parse(r.data);
+  const a = parse(r.attrs);
+  return d.parent_span_id || d?.data?.parent_span_id || a['sentry.parent_span_id'] || '';
+}
+
+//* MARK: Vitals
+/**
+ * Web-vitals + request summary from a ROOT span row's attrs. The sink stamps
+ * these onto the root span ONLY, value-only, keyed `measurement.<vital>`
+ * (LCP/FCP/TTFB/INP/FID in ms; CLS unitless) — see envelope.ts. Returns "" when
+ * none present.
+ */
+export function vitalsLine(a: Record<string, any>): string {
+  const ms = (k: string) => (typeof a[`measurement.${k}`] === 'number' ? `${Math.round(a[`measurement.${k}`])}ms` : null);
+  const parts: string[] = [];
+  if (ms('lcp')) parts.push(`LCP ${ms('lcp')}`);
+  if (ms('fcp')) parts.push(`FCP ${ms('fcp')}`);
+  if (ms('ttfb')) parts.push(`TTFB ${ms('ttfb')}`);
+  if (ms('inp')) parts.push(`INP ${ms('inp')}`);
+  if (ms('fid')) parts.push(`FID ${ms('fid')}`);
+  if (typeof a['measurement.cls'] === 'number') parts.push(`CLS ${a['measurement.cls']}`);
+  const req = a['request.method'] && a['request.url'] ? `${a['request.method']} ${a['request.url']}` : a['request.url'] || '';
+  let line = '';
+  if (parts.length) line += `vitals: ${parts.join(' · ')}`;
+  if (req) line += `${line ? '  ·  ' : ''}req: ${req}`;
+  return line;
+}
+
+//* MARK: Tree
+/**
+ * Build the DEPTH-FIRST nesting of a trace's rows. Spans/events form the tree
+ * via `parentOf`; logs slot UNDER their enclosing span (by `span_id`) when
+ * resolvable, else float at root by timestamp. Pure over a row array so it's
+ * unit-testable without a db. Returns rows in render order, each with `depth`.
+ */
+export function buildTree(rows: ViewRow[]): { r: ViewRow; depth: number }[] {
+  const spanRows = rows.filter((r) => r.kind === 'span' || r.kind === 'event');
+  const logRows = rows.filter((r) => r.kind === 'log');
+  const bySpanId = new Map<string, ViewRow>();
+  for (const r of spanRows) if (r.span_id) bySpanId.set(r.span_id, r);
+
+  // children[parentSpanId]; roots = parent empty or pointing outside this trace.
+  const children = new Map<string, ViewRow[]>();
+  const roots: ViewRow[] = [];
+  for (const r of spanRows) {
+    const p = parentOf(r);
+    if (p && bySpanId.has(p)) {
+      (children.get(p) ?? children.set(p, []).get(p)!).push(r);
+    } else {
+      roots.push(r);
+    }
+  }
+  const logsForSpan = new Map<string, ViewRow[]>();
+  const orphanLogs: ViewRow[] = [];
+  for (const r of logRows) {
+    if (r.span_id && bySpanId.has(r.span_id)) {
+      (logsForSpan.get(r.span_id) ?? logsForSpan.set(r.span_id, []).get(r.span_id)!).push(r);
+    } else {
+      orphanLogs.push(r);
+    }
+  }
+  const byTs = (a: ViewRow, b: ViewRow) => a.ts - b.ts || a.id - b.id;
+  roots.sort(byTs);
+  for (const arr of children.values()) arr.sort(byTs);
+  for (const arr of logsForSpan.values()) arr.sort(byTs);
+  orphanLogs.sort(byTs);
+
+  const flat: { r: ViewRow; depth: number }[] = [];
+  const seen = new Set<ViewRow>();
+  const visit = (r: ViewRow, depth: number) => {
+    if (seen.has(r)) return; // guard against pathological parent cycles
+    seen.add(r);
+    flat.push({ r, depth });
+    for (const lg of logsForSpan.get(r.span_id ?? '') ?? []) flat.push({ r: lg, depth: depth + 1 });
+    for (const c of children.get(r.span_id ?? '') ?? []) visit(c, depth + 1);
+  };
+  for (const root of roots) visit(root, 0);
+  for (const lg of orphanLogs) flat.push({ r: lg, depth: 0 });
+  for (const r of spanRows) if (!seen.has(r)) flat.push({ r, depth: 0 }); // unreached (cycle) → flat
+  return flat;
+}
+
+/** The topmost root row of a trace (carries the vitals/request attrs). */
+function rootOf(rows: ViewRow[]): ViewRow | undefined {
+  return buildTree(rows).find((x) => x.depth === 0)?.r;
+}
+
+//* MARK: Summary
+/** Distinct runtimes present in a trace, plus row/span counts. */
+export function summarise(rows: { kind: string; attrs: string | null }[]) {
+  const runtimes = new Set<string>();
+  let spans = 0;
+  for (const r of rows) {
+    runtimes.add(bareRuntime(parse(r.attrs)));
+    if (r.kind === 'span') spans++;
+  }
+  return { rows: rows.length, spans, runtimes: [...runtimes].sort() };
+}
+
+//* MARK: Waterfall
+/** Render one trace's rows as a genuinely nested waterfall table. */
+export function renderWaterfall(rows: ViewRow[], opts: { showIds?: boolean; limit?: number } = {}): { md: string; n: number; vitals: string } {
+  if (!rows.length) return { md: '_no rows for this trace_\n', n: 0, vitals: '' };
+  const t0 = Math.min(...rows.map((r) => r.ts));
+  const flat = buildTree(rows);
+  const use = opts.limit ? flat.slice(0, opts.limit) : flat;
+
+  const head = opts.showIds
+    ? `| +ms | runtime | kind | op / type | dur(ms) | span | parent | msg |\n|----:|---------|------|-----------|--------:|------|--------|-----|\n`
+    : `| +ms | runtime | kind | op / type | dur(ms) | msg |\n|----:|---------|------|-----------|--------:|-----|\n`;
+  let md = head;
+  for (const { r, depth } of use) {
+    const a = parse(r.attrs);
+    const off = Math.round((r.ts - t0) * 1000);
+    const dur = r.duration_ms != null ? Math.round(r.duration_ms) : (a.durationMs ?? '');
+    const op = esc(a.op || a['sentry.op'] || a['next.span_type'] || '').slice(0, 32);
+    const prefix = depth > 0 ? `${'  '.repeat(depth - 1)}└─ ` : '';
+    const msg = prefix + esc(r.msg).slice(0, 70);
+    if (opts.showIds) {
+      const sp = (r.span_id || '').slice(0, 8);
+      const pa = (parentOf(r) || '').slice(0, 8);
+      md += `| ${off} | ${runtimeOf(a)} | ${r.kind} | ${op} | ${dur} | ${sp} | ${pa} | ${msg} |\n`;
+    } else {
+      md += `| ${off} | ${runtimeOf(a)} | ${r.kind} | ${op} | ${dur} | ${msg} |\n`;
+    }
+  }
+  if (opts.limit && flat.length > opts.limit) {
+    md += `| … | | | | ${opts.showIds ? '| | ' : ''}| _(${flat.length - opts.limit} more rows)_ |\n`;
+  }
+  const root = rootOf(rows);
+  const vitals = root ? vitalsLine(parse(root.attrs)) : '';
+  return { md, n: rows.length, vitals };
+}
+
+//* MARK: DB queries
+const traceRows = (db: Database, traceId: string): ViewRow[] =>
+  db.query('SELECT kind,msg,attrs,data,duration_ms,ts,span_id,id FROM logs WHERE trace_id=? ORDER BY ts,id').all(traceId) as ViewRow[];
+
+const recentTraces = (db: Database, n: number) =>
+  db
+    .query("SELECT trace_id, MAX(recv_ts) AS last, COUNT(*) AS rows FROM logs WHERE trace_id!='' GROUP BY trace_id ORDER BY last DESC LIMIT ?")
+    .all(n) as { trace_id: string; last: number; rows: number }[];
+
+const summaryRows = (db: Database, traceId: string) =>
+  db.query('SELECT kind,attrs FROM logs WHERE trace_id=?').all(traceId) as { kind: string; attrs: string | null }[];
+
+//* MARK: Renderers
+export function renderTrace(db: Database, traceId: string, dbName: string, opts: { showIds?: boolean; limit?: number } = {}): string {
+  const s = summarise(summaryRows(db, traceId));
+  if (!s.rows) return `# trace ${traceId}\n\n_no rows in db "${dbName}"_\n`;
+  const { md, n, vitals } = renderWaterfall(traceRows(db, traceId), opts);
+  const vitalsHeader = vitals ? `${vitals}\n\n` : '';
+  return `# trace ${traceId}\n\n${n} rows · ${s.spans} spans · runtimes: ${s.runtimes.join(', ')}\n\n${vitalsHeader}${md}`;
+}
+
+export function renderList(db: Database, n: number, dbName: string): string {
+  const traces = recentTraces(db, n);
+  let md = `# ${traces.length} most-recent traces  (db: ${dbName})\n\n`;
+  md += '| trace_id | rows | spans | runtimes |\n|----------|-----:|------:|----------|\n';
+  for (const t of traces) {
+    const s = summarise(summaryRows(db, t.trace_id));
+    md += `| ${t.trace_id} | ${s.rows} | ${s.spans} | ${s.runtimes.join(', ')} |\n`;
+  }
+  return md;
+}
+
+export function renderCross(db: Database, n: number, dbName: string): string {
+  const traces = recentTraces(db, n);
+  const multi: { trace_id: string; runtimes: string[]; rows: number }[] = [];
+  let browserAndNode = 0;
+  for (const t of traces) {
+    const s = summarise(summaryRows(db, t.trace_id));
+    const real = s.runtimes.filter((r) => r !== 'unknown');
+    if (real.length > 1) {
+      multi.push({ trace_id: t.trace_id, runtimes: s.runtimes, rows: s.rows });
+      if (real.includes('browser') && real.includes('node')) browserAndNode++;
+    }
+  }
+  let md = `# Cross-runtime traces in the last ${traces.length} traces  (db: ${dbName})\n\n`;
+  md += `browser+node traces: **${browserAndNode}**   ·   any-multi-runtime traces: **${multi.length}**\n\n`;
+  if (!multi.length) return `${md}⚠️  No trace spans more than one runtime — propagation is NOT working yet.\n`;
+  md += '| trace_id | rows | runtimes |\n|----------|-----:|----------|\n';
+  for (const m of multi) md += `| ${m.trace_id} | ${m.rows} | ${m.runtimes.join(', ')} |\n`;
+  if (browserAndNode > 0) md += `\n✅ ${browserAndNode} trace(s) stitch browser ↔ node.\n`;
+  return md;
+}
+
+//* MARK: Path resolution
+/**
+ * Resolve the sink db. `--db` accepts a bare session name (→
+ * `.davstack/logs/<name>.db`) for the per-session convention, or a path/abs file
+ * passed straight through. Default: `<cwd>/.davstack/logs/default.db`.
+ */
+export function resolveDbPath(opts: { db?: string; cwd: string }): { path: string; name: string } {
+  const { db, cwd } = opts;
+  if (!db || !db.trim()) return { path: defaultDbPathForRepo(cwd), name: 'default' };
+  const v = db.trim();
+  if (!v.includes('/') && !v.includes('\\') && !v.endsWith('.db')) {
+    return { path: join(cwd, DEFAULT_DB_DIR, `${v}.db`), name: v };
+  }
+  const path = isAbsolute(v) ? v : resolve(cwd, v);
+  return { path, name: v.replace(/\\/g, '/').split('/').pop()!.replace(/\.db$/, '') };
+}
+
+//* MARK: Entry
+export interface RunViewOpts {
+  trace?: string;
+  list?: boolean;
+  cross?: boolean;
+  n?: number;
+  limit?: number;
+  ids?: boolean;
+  out?: string;
+  stdout?: boolean;
+  db?: string;
+  cwd?: string;
+}
+
+export async function runView(opts: RunViewOpts): Promise<number> {
+  const cwd = opts.cwd ?? process.cwd();
+  const { path: dbFile, name: dbName } = resolveDbPath({ db: opts.db, cwd });
+  let db: Database;
+  try {
+    db = new Database(dbFile, { readonly: true });
+  } catch {
+    process.stderr.write(`[logs-server] view: cannot open db ${dbFile}\n`);
+    return 1;
+  }
+
+  let md: string;
+  let summary: string;
+  if (opts.list) {
+    const n = opts.n ?? 20;
+    md = renderList(db, n, dbName);
+    summary = `${n} recent traces`;
+  } else if (opts.cross) {
+    const n = opts.n ?? 200;
+    md = renderCross(db, n, dbName);
+    summary = `cross-runtime scan (last ${n})`;
+  } else if (opts.trace) {
+    md = renderTrace(db, opts.trace, dbName, { showIds: opts.ids, limit: opts.limit });
+    summary = `trace ${opts.trace}`;
+  } else {
+    db.close();
+    process.stderr.write('usage: logs-server view <trace_id> | --list | --cross  (see --help)\n');
+    return 2;
+  }
+  db.close();
+
+  if (opts.stdout) {
+    process.stdout.write(md.endsWith('\n') ? md : `${md}\n`);
+    return 0;
+  }
+  const out = opts.out ?? join('.davstack', 'view.md');
+  const dir = dirname(out);
+  if (dir && dir !== '.') mkdirSync(dir, { recursive: true });
+  writeFileSync(out, md);
+  process.stdout.write(`wrote ${out}  (${summary})\n`);
+  return 0;
+}

From 512b2379dc77cb5cd2ef2a53aed50a93f7e4ff1c Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Thu, 4 Jun 2026 00:06:15 +0100
Subject: [PATCH 06/72] chore(release): @davstack/logs-server@2.9.0

---
 .changeset/logs-server-runtime-vitals.md |  9 ---------
 .changeset/logs-server-view.md           | 12 ------------
 packages/logs-server/CHANGELOG.md        | 19 +++++++++++++++++++
 packages/logs-server/package.json        |  2 +-
 4 files changed, 20 insertions(+), 22 deletions(-)
 delete mode 100644 .changeset/logs-server-runtime-vitals.md
 delete mode 100644 .changeset/logs-server-view.md

diff --git a/.changeset/logs-server-runtime-vitals.md b/.changeset/logs-server-runtime-vitals.md
deleted file mode 100644
index feaca36..0000000
--- a/.changeset/logs-server-runtime-vitals.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-"@davstack/logs-server": minor
----
-
-Enrich telemetry rows with a `runtime` column and root-span transaction metadata.
-
-- **`runtime` column** (`browser | node | edge`): added to every row (spans, logs, events) with an idempotent `ALTER` migration. The shred can't recover the runtime from per-span fields once a transaction is expanded, so the consumer stamps it (Sentry `beforeSendLog` / `beforeSendTransaction`) and the parser persists it into a first-class column for trivial filtering (`WHERE runtime='browser'`) instead of digging through `attrs`.
-- **Web vitals + request on the root span**: `transactionRows()` now reads `tx.measurements` (numeric web vitals → `attrs["measurement.<vital>"]`, value-only: LCP/FCP/TTFB/INP/FID in ms, CLS unitless) and `tx.request` (→ `attrs["request.url"]` / `["request.method"]`), attaching them to the **root span row only** — no child duplication, no new columns. This is the "enriched root span" model (spans are the primitive; the segment/root span carries what the transaction used to), recovering the perf data the transaction→span shred otherwise drops.
-- Docs: `reading-logs.md` gains a section on the root transaction metadata + a recursive-CTE query for reconstructing the span tree from the flat table.
diff --git a/.changeset/logs-server-view.md b/.changeset/logs-server-view.md
deleted file mode 100644
index 5163a5f..0000000
--- a/.changeset/logs-server-view.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-"@davstack/logs-server": minor
----
-
-Add a `view` CLI verb to render traces from the local sink.
-
-The viewer encodes the sink's own schema (the `runtime` column, `measurement.*` root-span attrs, the `kind ∈ span|log|event` enum, `parent_span_id` resolution, the transaction→span shred), so it lives in the package and ships versioned with that schema instead of being copied into each consuming repo.
-
-- `logs-server view <trace_id>` — genuinely nested waterfall (DFS span tree via `parent_span_id`; logs slot under their enclosing span, orphans float at root by timestamp), with a web-vitals + request header read off the root span.
-- `logs-server view --list [--n N]` — N most-recent traces with row/span/runtime summary.
-- `logs-server view --cross [--n N]` — scan recent traces for ones spanning >1 runtime; the browser↔server trace-propagation feedback-loop command.
-- Writes Markdown to `.davstack/view.md` by default (trace tables are wide and wrap badly in a terminal); `--stdout` prints instead. Flags: `--db` (accepts a bare session name → `.davstack/logs/<name>.db`, or a path), `--ids`, `--limit`, `--out`.
diff --git a/packages/logs-server/CHANGELOG.md b/packages/logs-server/CHANGELOG.md
index d41f6e1..7a6e7db 100644
--- a/packages/logs-server/CHANGELOG.md
+++ b/packages/logs-server/CHANGELOG.md
@@ -1,5 +1,24 @@
 # @davstack/logs-server
 
+## 2.9.0
+
+### Minor Changes
+
+- df51308: Enrich telemetry rows with a `runtime` column and root-span transaction metadata.
+
+  - **`runtime` column** (`browser | node | edge`): added to every row (spans, logs, events) with an idempotent `ALTER` migration. The shred can't recover the runtime from per-span fields once a transaction is expanded, so the consumer stamps it (Sentry `beforeSendLog` / `beforeSendTransaction`) and the parser persists it into a first-class column for trivial filtering (`WHERE runtime='browser'`) instead of digging through `attrs`.
+  - **Web vitals + request on the root span**: `transactionRows()` now reads `tx.measurements` (numeric web vitals → `attrs["measurement.<vital>"]`, value-only: LCP/FCP/TTFB/INP/FID in ms, CLS unitless) and `tx.request` (→ `attrs["request.url"]` / `["request.method"]`), attaching them to the **root span row only** — no child duplication, no new columns. This is the "enriched root span" model (spans are the primitive; the segment/root span carries what the transaction used to), recovering the perf data the transaction→span shred otherwise drops.
+  - Docs: `reading-logs.md` gains a section on the root transaction metadata + a recursive-CTE query for reconstructing the span tree from the flat table.
+
+- 675d99b: Add a `view` CLI verb to render traces from the local sink.
+
+  The viewer encodes the sink's own schema (the `runtime` column, `measurement.*` root-span attrs, the `kind ∈ span|log|event` enum, `parent_span_id` resolution, the transaction→span shred), so it lives in the package and ships versioned with that schema instead of being copied into each consuming repo.
+
+  - `logs-server view <trace_id>` — genuinely nested waterfall (DFS span tree via `parent_span_id`; logs slot under their enclosing span, orphans float at root by timestamp), with a web-vitals + request header read off the root span.
+  - `logs-server view --list [--n N]` — N most-recent traces with row/span/runtime summary.
+  - `logs-server view --cross [--n N]` — scan recent traces for ones spanning >1 runtime; the browser↔server trace-propagation feedback-loop command.
+  - Writes Markdown to `.davstack/view.md` by default (trace tables are wide and wrap badly in a terminal); `--stdout` prints instead. Flags: `--db` (accepts a bare session name → `.davstack/logs/<name>.db`, or a path), `--ids`, `--limit`, `--out`.
+
 ## 2.8.0
 
 ### Minor Changes
diff --git a/packages/logs-server/package.json b/packages/logs-server/package.json
index dac2b5e..62edeaf 100644
--- a/packages/logs-server/package.json
+++ b/packages/logs-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/logs-server",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "license": "MIT",
   "type": "module",
   "description": "Local Sentry-shaped telemetry sink (logs + traces): ingest envelopes over HTTP, persist to per-repo SQLite. Read with sqlite3 against the logs table (kind discriminates log vs span; flat attrs column).",

From e371689a6763c3b3e665f41ce5da0d56697ceded Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Thu, 4 Jun 2026 00:27:16 +0100
Subject: [PATCH 07/72] docs(logs-server): clarify sqlite vs view (don't litter
 .md files); refresh schema + view refs

---
 packages/logs-server/docs/reading-logs.md | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/packages/logs-server/docs/reading-logs.md b/packages/logs-server/docs/reading-logs.md
index e75ea30..4b77f7a 100644
--- a/packages/logs-server/docs/reading-logs.md
+++ b/packages/logs-server/docs/reading-logs.md
@@ -8,6 +8,17 @@ sqlite3 -header -column .davstack/logs/default.db "<SQL>"
 
 `-header` prints column names, `-column` aligns the output as a table.
 
+## `sqlite3` vs `view` — when to write a file
+
+Default to **`sqlite3`** (or `logs-server view --stdout`) for your own investigation —
+querying answers a question without leaving an artifact behind. The `view` command's
+**file output (`.davstack/view.md`) is for handing a rendered trace to a human** to
+read in their editor; reach for it only when you're actually presenting a trace, not
+for every lookup. Don't generate a Markdown file per query — that litters the repo.
+
+- Agent self-service / a quick check → `sqlite3 …` or `view <trace> --stdout`.
+- Showing a person a trace waterfall → `view <trace>` (writes `.davstack/view.md`).
+
 ## Sessions
 
 The daemon writes one file per "session" under `.davstack/logs/` based on --db tag:
@@ -41,7 +52,10 @@ logs(
   msg             TEXT,     -- Sentry log body, ANSI prefix stripped
   data            TEXT,     -- raw Sentry log record JSON, verbatim
   attrs           TEXT,     -- flat {key: value} JSON, OTel {value,type} wrapper stripped (NULL when no attributes)
-  tag             TEXT      -- promoted from data.attributes['diag.tag'].value (nullable)
+  tag             TEXT,     -- promoted from data.attributes['diag.tag'].value (nullable)
+  kind            TEXT,     -- row discriminator: 'log' | 'span' | 'event'
+  duration_ms     REAL,     -- span headline metric ((end-start)*1000); NULL for logs
+  runtime         TEXT      -- emitting runtime ('browser'|'node'|'edge'), stamped by the consumer; NULL when absent
 )
 ```
 
@@ -146,7 +160,7 @@ sqlite3 -header -column .davstack/logs/default.db "
 We do NOT duplicate transaction-level metadata onto every span. It is stored
 ONCE on the **ROOT span row** (the segment — the row whose `parent_span_id` is
 empty / not present in the trace), and nesting is reconstructed on demand. There
-is no SQL view for the tree; this CTE (and `titanium/scripts/trace-view.ts`) IS
+is no SQL view for the tree; this CTE (and the `logs-server view` CLI) IS
 the view substitute.
 
 ### Root-only metadata keys (in `attrs`)
@@ -182,7 +196,7 @@ sqlite3 -header -column .davstack/logs/default.db "
 
 `parent_span_id` is surfaced into `attrs` for each span. Walk it from the roots
 to get depth + a materialised path, ordered depth-first — the same shape the
-`trace-view.ts` waterfall renders.
+`logs-server view` waterfall renders.
 
 ```bash
 sqlite3 -header -column .davstack/logs/default.db "

From 0019d8a96fd3f458672cfc08b6761a3ff904d538 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Thu, 4 Jun 2026 00:46:56 +0100
Subject: [PATCH 08/72] fix(logs-server): view reads vitals from the pageload
 segment, not just trace root

---
 .../__tests__/bun-only/view.test.ts           | 22 +++++++++++++++++
 packages/logs-server/src/view.ts              | 24 ++++++++++++++++---
 2 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/packages/logs-server/__tests__/bun-only/view.test.ts b/packages/logs-server/__tests__/bun-only/view.test.ts
index 31ad5eb..d4b28b2 100644
--- a/packages/logs-server/__tests__/bun-only/view.test.ts
+++ b/packages/logs-server/__tests__/bun-only/view.test.ts
@@ -164,6 +164,28 @@ test('renderTrace nests children/logs and prints a vitals header from the root',
   expect(md).toContain('node'); // runtime column
 });
 
+test('renderTrace surfaces vitals from a browser pageload nested under the server root', () => {
+  // Propagation re-parents the browser pageload (which carries measurement.*)
+  // under the node http.server root — so vitals are NOT on the trace root.
+  const db = openDb(':memory:');
+  insertLogs(db, [
+    logRow({ kind: 'span', span_id: 'srv00000', msg: 'GET /', duration_ms: 800, ts: 1000, runtime: 'node', attrs: JSON.stringify({ op: 'http.server', runtime: 'node' }) }),
+    logRow({
+      kind: 'span',
+      span_id: 'pageload0',
+      msg: '/',
+      duration_ms: 1283,
+      ts: 1000.01,
+      runtime: 'browser',
+      data: JSON.stringify({ parent_span_id: 'srv00000' }),
+      attrs: JSON.stringify({ op: 'pageload', runtime: 'browser', 'measurement.lcp': 624, 'measurement.cls': 0.0001 }),
+    }),
+  ]);
+  const md = renderTrace(db, T, 'default');
+  expect(md).toContain('LCP 624ms');
+  expect(md).toContain('CLS 0.0001');
+});
+
 test('renderTrace reports an empty db cleanly', () => {
   const db = openDb(':memory:');
   expect(renderTrace(db, T, 'default')).toContain('no rows in db');
diff --git a/packages/logs-server/src/view.ts b/packages/logs-server/src/view.ts
index db7ea37..d9fa0cb 100644
--- a/packages/logs-server/src/view.ts
+++ b/packages/logs-server/src/view.ts
@@ -75,7 +75,7 @@ export function vitalsLine(a: Record<string, any>): string {
   if (ms('ttfb')) parts.push(`TTFB ${ms('ttfb')}`);
   if (ms('inp')) parts.push(`INP ${ms('inp')}`);
   if (ms('fid')) parts.push(`FID ${ms('fid')}`);
-  if (typeof a['measurement.cls'] === 'number') parts.push(`CLS ${a['measurement.cls']}`);
+  if (typeof a['measurement.cls'] === 'number') parts.push(`CLS ${parseFloat(a['measurement.cls'].toFixed(4))}`);
   const req = a['request.method'] && a['request.url'] ? `${a['request.method']} ${a['request.url']}` : a['request.url'] || '';
   let line = '';
   if (parts.length) line += `vitals: ${parts.join(' · ')}`;
@@ -137,11 +137,24 @@ export function buildTree(rows: ViewRow[]): { r: ViewRow; depth: number }[] {
   return flat;
 }
 
-/** The topmost root row of a trace (carries the vitals/request attrs). */
+/** The topmost root row of a trace. */
 function rootOf(rows: ViewRow[]): ViewRow | undefined {
   return buildTree(rows).find((x) => x.depth === 0)?.r;
 }
 
+/**
+ * Attrs of the span that measured web vitals (the pageload / transaction
+ * segment), if any. NOT necessarily the trace root: trace propagation nests the
+ * browser pageload — which carries `measurement.*` — under the server root.
+ */
+function vitalsSegmentAttrs(rows: ViewRow[]): Record<string, any> | null {
+  for (const r of rows) {
+    const a = parse(r.attrs);
+    if (Object.keys(a).some((k) => k.startsWith('measurement.'))) return a;
+  }
+  return null;
+}
+
 //* MARK: Summary
 /** Distinct runtimes present in a trace, plus row/span counts. */
 export function summarise(rows: { kind: string; attrs: string | null }[]) {
@@ -184,8 +197,13 @@ export function renderWaterfall(rows: ViewRow[], opts: { showIds?: boolean; limi
   if (opts.limit && flat.length > opts.limit) {
     md += `| … | | | | ${opts.showIds ? '| | ' : ''}| _(${flat.length - opts.limit} more rows)_ |\n`;
   }
+  // Vitals live on the transaction segment that measured them — in a propagated
+  // cross-runtime trace that's the browser pageload, which gets re-parented under
+  // the server root, so it is NOT rootOf(rows). Find the segment carrying
+  // measurements; fall back to the root for request context on vitals-less traces.
   const root = rootOf(rows);
-  const vitals = root ? vitalsLine(parse(root.attrs)) : '';
+  const vitalsAttrs = vitalsSegmentAttrs(rows) ?? (root ? parse(root.attrs) : {});
+  const vitals = vitalsLine(vitalsAttrs);
   return { md, n: rows.length, vitals };
 }
 

From 2ba15ff2a37e6c393c0709f2e8c3083ff0823ccc Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Thu, 4 Jun 2026 00:58:02 +0100
Subject: [PATCH 09/72] chore(logs-server): changeset for view vitals-segment
 fix

---
 .changeset/logs-server-view-vitals-segment.md | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 .changeset/logs-server-view-vitals-segment.md

diff --git a/.changeset/logs-server-view-vitals-segment.md b/.changeset/logs-server-view-vitals-segment.md
new file mode 100644
index 0000000..9630d6b
--- /dev/null
+++ b/.changeset/logs-server-view-vitals-segment.md
@@ -0,0 +1,7 @@
+---
+"@davstack/logs-server": patch
+---
+
+Fix `view` reading web vitals from the wrong span in cross-runtime traces.
+
+The vitals header pulled `measurement.*` off the trace's topmost root span — but trace propagation re-parents the browser pageload (which actually carries the web vitals) *under* the server root, so its segment isn't parentless and the header came up empty. `view` now scans for the segment carrying `measurement.*` rather than assuming it's the root, and rounds CLS to 4 d.p. So a browser↔server trace now renders e.g. `vitals: LCP 624ms · FCP 624ms · TTFB 364ms · CLS 0.0001`.

From 14a7d3d10ad2828f7dd926db23043c46856fe3bd Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Thu, 4 Jun 2026 00:58:37 +0100
Subject: [PATCH 10/72] chore(release): @davstack/logs-server@2.9.1

---
 .changeset/logs-server-view-vitals-segment.md | 7 -------
 packages/logs-server/CHANGELOG.md             | 8 ++++++++
 packages/logs-server/package.json             | 2 +-
 3 files changed, 9 insertions(+), 8 deletions(-)
 delete mode 100644 .changeset/logs-server-view-vitals-segment.md

diff --git a/.changeset/logs-server-view-vitals-segment.md b/.changeset/logs-server-view-vitals-segment.md
deleted file mode 100644
index 9630d6b..0000000
--- a/.changeset/logs-server-view-vitals-segment.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@davstack/logs-server": patch
----
-
-Fix `view` reading web vitals from the wrong span in cross-runtime traces.
-
-The vitals header pulled `measurement.*` off the trace's topmost root span — but trace propagation re-parents the browser pageload (which actually carries the web vitals) *under* the server root, so its segment isn't parentless and the header came up empty. `view` now scans for the segment carrying `measurement.*` rather than assuming it's the root, and rounds CLS to 4 d.p. So a browser↔server trace now renders e.g. `vitals: LCP 624ms · FCP 624ms · TTFB 364ms · CLS 0.0001`.
diff --git a/packages/logs-server/CHANGELOG.md b/packages/logs-server/CHANGELOG.md
index 7a6e7db..bee28e3 100644
--- a/packages/logs-server/CHANGELOG.md
+++ b/packages/logs-server/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @davstack/logs-server
 
+## 2.9.1
+
+### Patch Changes
+
+- 2ba15ff: Fix `view` reading web vitals from the wrong span in cross-runtime traces.
+
+  The vitals header pulled `measurement.*` off the trace's topmost root span — but trace propagation re-parents the browser pageload (which actually carries the web vitals) _under_ the server root, so its segment isn't parentless and the header came up empty. `view` now scans for the segment carrying `measurement.*` rather than assuming it's the root, and rounds CLS to 4 d.p. So a browser↔server trace now renders e.g. `vitals: LCP 624ms · FCP 624ms · TTFB 364ms · CLS 0.0001`.
+
 ## 2.9.0
 
 ### Minor Changes
diff --git a/packages/logs-server/package.json b/packages/logs-server/package.json
index 62edeaf..994c0f8 100644
--- a/packages/logs-server/package.json
+++ b/packages/logs-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/logs-server",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "license": "MIT",
   "type": "module",
   "description": "Local Sentry-shaped telemetry sink (logs + traces): ingest envelopes over HTTP, persist to per-repo SQLite. Read with sqlite3 against the logs table (kind discriminates log vs span; flat attrs column).",

From 9b9594c3583c6a4e7e44ffaee42615b6a999d86e Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Sat, 6 Jun 2026 14:00:07 +0100
Subject: [PATCH 11/72] feat(logs-server): add ./sink programmatic embed entry
 (openDb + handleIngest)

---
 packages/logs-server/CHANGELOG.md   |  8 ++++++++
 packages/logs-server/package.json   |  7 ++++++-
 packages/logs-server/src/sink.ts    | 12 ++++++++++++
 packages/logs-server/tsconfig.json  |  2 +-
 packages/logs-server/tsup.config.ts |  1 +
 pnpm-lock.yaml                      | 15 +++++++++++++++
 6 files changed, 43 insertions(+), 2 deletions(-)
 create mode 100644 packages/logs-server/src/sink.ts

diff --git a/packages/logs-server/CHANGELOG.md b/packages/logs-server/CHANGELOG.md
index bee28e3..edf66e0 100644
--- a/packages/logs-server/CHANGELOG.md
+++ b/packages/logs-server/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @davstack/logs-server
 
+## 2.10.0
+
+### Minor Changes
+
+- Add a `./sink` programmatic embedding entry point.
+
+  `@davstack/logs-server/sink` re-exports the existing in-process ingest primitives (`openDb`, `handleIngest`, `dispatchIngest`, `insertLogs`, `selectByTrace`, `parseEnvelope`, `decodeBody`, plus the `LogRow`/`IngestResult`/`ParsedLog` types) so a consumer can persist Sentry telemetry to a sink SQLite file in-process — no HTTP daemon, no network. Purely additive: the CLI/daemon/server/ingest logic is unchanged; this is a new side-effect-free export surface only.
+
 ## 2.9.1
 
 ### Patch Changes
diff --git a/packages/logs-server/package.json b/packages/logs-server/package.json
index 994c0f8..43d615d 100644
--- a/packages/logs-server/package.json
+++ b/packages/logs-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/logs-server",
-  "version": "2.9.1",
+  "version": "2.10.0",
   "license": "MIT",
   "type": "module",
   "description": "Local Sentry-shaped telemetry sink (logs + traces): ingest envelopes over HTTP, persist to per-repo SQLite. Read with sqlite3 against the logs table (kind discriminates log vs span; flat attrs column).",
@@ -20,6 +20,10 @@
     "./config": {
       "types": "./dist/config.d.ts",
       "default": "./dist/config.js"
+    },
+    "./sink": {
+      "types": "./dist/sink.d.ts",
+      "default": "./dist/sink.js"
     }
   },
   "files": [
@@ -36,6 +40,7 @@
     "@davstack/cli-utils": "workspace:*"
   },
   "devDependencies": {
+    "@types/bun": "^1.1.0",
     "@types/node": "^25.9.1",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
diff --git a/packages/logs-server/src/sink.ts b/packages/logs-server/src/sink.ts
new file mode 100644
index 0000000..cd29d3d
--- /dev/null
+++ b/packages/logs-server/src/sink.ts
@@ -0,0 +1,12 @@
+// Programmatic embedding surface for the sink. Use this to write Sentry-shaped
+// telemetry into a sink SQLite file IN-PROCESS — no HTTP daemon, no network.
+// A `bun build --compile` standalone binary can open the sink DB with `openDb`
+// and feed serialized Sentry envelopes straight to `handleIngest` from a custom
+// transport. This module is a side-effect-free re-export of the existing ingest
+// primitives (CLI/daemon/server logic is untouched); importing it opens nothing
+// and starts nothing.
+
+export { openDb, insertLogs, selectByTrace, type LogRow } from './db.js';
+export { handleIngest, dispatchIngest, type IngestResult } from './ingest.js';
+export { parseEnvelope, type ParsedLog } from './envelope.js';
+export { decodeBody } from './decode.js';
diff --git a/packages/logs-server/tsconfig.json b/packages/logs-server/tsconfig.json
index 977483e..34caf39 100644
--- a/packages/logs-server/tsconfig.json
+++ b/packages/logs-server/tsconfig.json
@@ -4,7 +4,7 @@
 		"module": "ESNext",
 		"moduleResolution": "Bundler",
 		"lib": ["ES2022"],
-		"types": ["node"],
+		"types": ["node", "bun"],
 		"strict": true,
 		"esModuleInterop": true,
 		"skipLibCheck": true,
diff --git a/packages/logs-server/tsup.config.ts b/packages/logs-server/tsup.config.ts
index 4699b5b..d7ffbeb 100644
--- a/packages/logs-server/tsup.config.ts
+++ b/packages/logs-server/tsup.config.ts
@@ -4,6 +4,7 @@ export default defineConfig({
 	entry: {
 		index: "src/index.ts",
 		config: "src/config.ts",
+		sink: "src/sink.ts",
 	},
 	format: ["esm"],
 	target: "node20",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index bddf285..22c88b2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -70,6 +70,9 @@ importers:
         specifier: workspace:*
         version: link:../cli-utils
     devDependencies:
+      '@types/bun':
+        specifier: ^1.1.0
+        version: 1.3.14
       '@types/node':
         specifier: ^25.9.1
         version: 25.9.1
@@ -3847,6 +3850,12 @@ packages:
     resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==}
     dev: false
 
+  /@types/bun@1.3.14:
+    resolution: {integrity: sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw==}
+    dependencies:
+      bun-types: 1.3.14
+    dev: true
+
   /@types/chai@5.2.3:
     resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
     dependencies:
@@ -4937,6 +4946,12 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /bun-types@1.3.14:
+    resolution: {integrity: sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ==}
+    dependencies:
+      '@types/node': 25.9.1
+    dev: true
+
   /bundle-name@4.1.0:
     resolution: {integrity: sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==}
     engines: {node: '>=18'}

From c457ad53f40dbac63fd92585196e976b5a1d9c3a Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 14:23:07 +0100
Subject: [PATCH 12/72] docs: plan open agent handoff testing

---
 notes/davstack-meta/1-initial-concept.md      |  90 ++++
 .../.folder-meta.md                           |  41 ++
 .../1-initial-comparison.md                   |  77 ++++
 .../2-scenarios-and-isolation.md              | 150 +++++++
 .../3-promptfoo-integration-plan.md           | 115 +++++
 .../4-candidate-backlog.md                    | 399 ++++++++++++++++++
 6 files changed, 872 insertions(+)
 create mode 100644 notes/davstack-meta/1-initial-concept.md
 create mode 100644 notes/open-agent-handoff-testing/.folder-meta.md
 create mode 100644 notes/open-agent-handoff-testing/1-initial-comparison.md
 create mode 100644 notes/open-agent-handoff-testing/2-scenarios-and-isolation.md
 create mode 100644 notes/open-agent-handoff-testing/3-promptfoo-integration-plan.md
 create mode 100644 notes/open-agent-handoff-testing/4-candidate-backlog.md

diff --git a/notes/davstack-meta/1-initial-concept.md b/notes/davstack-meta/1-initial-concept.md
new file mode 100644
index 0000000..62f32b5
--- /dev/null
+++ b/notes/davstack-meta/1-initial-concept.md
@@ -0,0 +1,90 @@
+# Davstack Meta Initial Concept
+
+Idea: add a small package/CLI, probably `@davstack/meta`, that generates concise
+folder-level metadata files for agents.
+
+## Motivation
+
+Agents often need a quick map of a folder before deciding what to read. Full
+recursive exploration can burn tokens and time. A generated metadata file could
+act like a compact table of contents for source and docs.
+
+## Possible CLI
+
+```text
+npx @davstack/meta gen ./path-to-folder
+npx @davstack/meta view ./path-to-folder
+npx @davstack/meta view ./path-to-folder --deep
+```
+
+## `gen`
+
+`gen` scans a folder and writes a concise generated markdown file in that
+folder, likely something like `.folder-meta.generated.md`.
+
+Initial scope:
+
+- Include markdown, TypeScript, and Python files.
+- Skip files ignored by git.
+- Skip generated metadata files themselves.
+- Prefer concise structural summaries over content summaries.
+
+For markdown:
+
+- Include file path.
+- Include headings.
+
+For TypeScript:
+
+- Include exported functions, classes, types, interfaces, consts, and important
+  non-exported top-level symbols.
+- Possibly include JSDoc in a longer mode.
+
+For Python:
+
+- Include functions, classes, constants, and module docstring where useful.
+
+## `view`
+
+`view` prints existing metadata for a folder. If the metadata file does not
+exist, it can generate it on the spot.
+
+`--deep` could recursively include child folder metadata, either by generating
+missing child files or by doing a direct recursive scan.
+
+## Output Shape
+
+Experiment with XML-ish blocks because agents parse them well:
+
+```xml
+<folder path="packages/open-agents/src">
+  <file path="cli.ts">
+    <exports>
+      <function name="main" />
+      <function name="parseFlags" />
+    </exports>
+  </file>
+</folder>
+```
+
+There may be two useful output levels:
+
+- Short: names and headings only.
+- Long: names, signatures, JSDoc/docstrings, and maybe one-line comments.
+
+## Git Hygiene
+
+Generated metadata files should probably be gitignored by default. The package
+could also provide a recommended `.gitignore` entry.
+
+## Agent Workflow
+
+An agent can run:
+
+```text
+npx @davstack/meta view packages/open-agents/src --deep
+```
+
+Then use the metadata as a cheap routing map before opening source files. This
+could pair well with open-agent handoff testing because history/context pointers
+are more useful when agents can cheaply inspect repo structure too.
diff --git a/notes/open-agent-handoff-testing/.folder-meta.md b/notes/open-agent-handoff-testing/.folder-meta.md
new file mode 100644
index 0000000..c060af2
--- /dev/null
+++ b/notes/open-agent-handoff-testing/.folder-meta.md
@@ -0,0 +1,41 @@
+# Folder Meta: Open Agent Handoff Testing
+
+This folder tracks experiments for reducing the cost and friction of handing
+work from a main agent to open-agents execution agents.
+
+## Files
+
+### `1-initial-comparison.md`
+
+Defines the first lean A/B/C comparison:
+
+- Main-agent written spec.
+- No-spec handoff with title, recent history tail, and full-history pointer.
+- Spec-writer middleman with title, recent history tail, and full-history
+  pointer.
+
+Use this as the current decision anchor.
+
+### `2-scenarios-and-isolation.md`
+
+Lists candidate test scenarios and isolation requirements. Focuses on realistic
+`explore` and `fast-edit` usage: code reconnaissance, mechanical edits,
+diagnosis instrumentation, and later fan-out composition.
+
+Use this when choosing fixtures and deciding cleanup/parallelism rules.
+
+### `3-promptfoo-integration-plan.md`
+
+Sketches how Promptfoo might wrap the eval workflow without owning open-agents
+execution. The preferred shape is a thin local provider script that open-agents
+can also run manually.
+
+Use this when turning the experiment into a repeatable matrix runner.
+
+### `4-candidate-backlog.md`
+
+Keeps the broader handoff variant list and longer-range hypotheses. This file is
+not the active starting plan; it is a backlog for later expansion after the
+three-way comparison produces signal.
+
+Use this when deciding what variants to test next.
diff --git a/notes/open-agent-handoff-testing/1-initial-comparison.md b/notes/open-agent-handoff-testing/1-initial-comparison.md
new file mode 100644
index 0000000..d31a320
--- /dev/null
+++ b/notes/open-agent-handoff-testing/1-initial-comparison.md
@@ -0,0 +1,77 @@
+# Initial Handoff Comparison
+
+Related issues:
+
+- #28 Experiment with improved openagents spec writing flow
+- #25 Add evals
+
+## Current Focus
+
+Start with three handoff strategies only. The wider candidate set belongs in
+`4-candidate-backlog.md` until the small comparison proves what is worth
+expanding.
+
+## Variants
+
+### A. Main-Agent Written Spec
+
+This is the baseline. The main agent writes the normal detailed open-agents spec
+and passes that to `explore` or `fast-edit`.
+
+Hypothesis:
+
+- Best quality and scope control.
+- Highest main-agent output cost.
+- Slowest preparation path.
+
+### B. No Spec: Title Plus Recent Tail Plus Full-History Pointer
+
+The main agent writes only a concise task title or one-line intent, appends the
+last X chars of the chat/history, and includes a path/link to the full history
+file for deeper lookup.
+
+Hypothesis:
+
+- May be good enough for many realistic `explore` and `fast-edit` tasks.
+- Avoids the spec-writer middleman entirely.
+- Main risk is that the execution agent must synthesize and execute in one run.
+
+### C. Spec Writer: Title Plus Recent Tail Plus Full-History Pointer
+
+The main agent writes the concise title/intent. A cheap middleman agent receives
+that plus recent history tail plus a full-history pointer, then writes a compact
+execution spec. The actual execution agent receives only that generated spec.
+
+Hypothesis:
+
+- Better focus than variant B on harder tasks.
+- Still much cheaper for the main agent than variant A.
+- Only worth productizing if the quality gain beats the extra agent run.
+
+## First Decision Rule
+
+Compare B against C before assuming the spec-writer middleman is necessary.
+
+- If B is close to C, prefer no-spec history handoff for common tasks.
+- If C is materially better, build spec writing as a first-class flow.
+- If A is still clearly better, identify which task shapes need human/orchestrator
+  spec synthesis and avoid over-automating those.
+
+## Tail Sizes
+
+Initial tail-size sweep should stay small:
+
+- 30k chars.
+- 50k chars.
+- 100k chars only if 30k/50k are inconclusive.
+
+The full-history pointer should be present in B and C for every run so the tail
+size measures "immediate context usefulness", not "does the agent have any
+history at all?"
+
+## Documentation Style
+
+Prefer append-only experiment notes as runs happen. Edit existing sections only
+when they are actively misleading or block comprehension. When the next decision
+branch appears, start a new numbered file instead of repeatedly rewriting a long
+plan.
diff --git a/notes/open-agent-handoff-testing/2-scenarios-and-isolation.md b/notes/open-agent-handoff-testing/2-scenarios-and-isolation.md
new file mode 100644
index 0000000..b0ebea7
--- /dev/null
+++ b/notes/open-agent-handoff-testing/2-scenarios-and-isolation.md
@@ -0,0 +1,150 @@
+# Scenarios And Isolation
+
+## What Existing Specs Suggest
+
+Local `.davstack` artifacts show the realistic open-agents work is mostly:
+
+- Read-only reconnaissance with explicit scope and path/line reporting.
+- Mechanical edit specs with tight file lists and acceptance criteria.
+- Diagnosis support, especially broad instrumentation or quote-only extraction.
+- Fan-out work where one main question becomes several bounded sub-jobs.
+
+The initial eval should avoid abstract planning prompts. We should test the
+things `explore` and `fast-edit` are already used for.
+
+## Scenario Requirements
+
+Each scenario should be:
+
+- Repeatable from a clean fixture/worktree.
+- Independent, so variants can run in parallel.
+- Cheap enough to run multiple times.
+- Easy to grade with a mix of objective checks and quick human review.
+- Representative of real `explore` or `fast-edit` usage.
+
+For edit scenarios, every variant needs either its own isolated copy/worktree or
+a teardown step that restores exactly the touched files. Parallel runs should
+not share a mutable checkout.
+
+## Scenario 1: Read-Only Code Recon
+
+Shape:
+
+- `explore` task.
+- Ask where a concrete open-agents behavior lives and how it works.
+
+Example:
+
+> Find where open-agents builds provider command args and explain how ask vs
+> force mode changes the Cursor, Gemini, and Agy adapters. Cite files and lines.
+
+Why this is useful:
+
+- Mirrors real `explore` specs.
+- No cleanup required.
+- Grading can check for specific source files and absence of invented behavior.
+
+Expected answer should mention:
+
+- `packages/open-agents/src/cli.ts`
+- `packages/open-agents/src/adapters/cursor.ts`
+- `packages/open-agents/src/adapters/gemini.ts`
+- `packages/open-agents/src/adapters/agy.ts`
+- Profile mode source in `packages/open-agents/src/profiles/*`
+
+## Scenario 2: Mechanical Fast-Edit
+
+Shape:
+
+- `fast-edit` task.
+- Small, deterministic code change with clear acceptance criteria.
+
+Example:
+
+> Add a persisted `handoffVariant` metadata field to open-agents job records and
+> cover the default/roundtrip behavior with unit tests.
+
+Isolation:
+
+- Run each variant in a separate temporary worktree or copied fixture repo.
+- Teardown can remove the temp worktree/copy after metrics are collected.
+
+Objective checks:
+
+- Typecheck or targeted tests pass.
+- Only expected open-agents files changed.
+- Job record compatibility remains intact for old records.
+
+Risk:
+
+- This may be too product-shaped for the very first run. If so, replace it with
+  a smaller metadata-only edit in a toy package fixture.
+
+## Scenario 3: Diagnosis Support / Instrumentation Fan-Out
+
+Shape:
+
+- `fast-edit` task derived from diagnosis usage.
+- Add broad, additive-only instrumentation across several named seams.
+
+Example:
+
+> Given hypotheses H1/H2/H3 and a path through three files, add additive debug
+> logs at every seam with stable tags and enough fields to discriminate the
+> hypotheses. Do not change behavior.
+
+Why this matters:
+
+- Existing diagnosis feedback says fast-edit specs underused fan-out and were
+  too verbatim.
+- This tests whether history handoff preserves the doctrine: intent plus seam
+  list, not pasted code.
+
+Isolation:
+
+- Use a small fixture package or temporary worktree.
+- Logs should be easy to grep by tag.
+- Teardown deletes the fixture copy/worktree.
+
+Objective checks:
+
+- All expected tags exist.
+- No non-instrumentation behavior changes.
+- Typecheck passes.
+
+## Scenario 4: Multi-Explore Fan-Out Recon
+
+Shape:
+
+- Future scenario, not in the first run unless the first three are too easy.
+- A middleman identifies that a broad question can split into several parallel
+  `explore` jobs.
+
+Why this is future-only:
+
+- It tests composition/fan-out, not just handoff shape.
+- It likely needs a shared context artifact plus several generated task specs.
+
+This should become its own follow-up once the basic A/B/C handoff comparison is
+working.
+
+## Cleanup And Parallelism Notes
+
+For read-only scenarios:
+
+- Variants can run in parallel in the same repo.
+- Persist raw prompt, job id, result path, duration, and review score.
+
+For edit scenarios:
+
+- Prefer one temp worktree/copy per variant and per repeat.
+- Record the exact base commit or fixture version.
+- Collect diff stats before teardown.
+- Keep failed worktrees until inspected, or copy their diffs into the result
+  artifact before cleanup.
+
+For diagnosis/instrumentation scenarios:
+
+- Fixture should include deterministic code paths and named seams.
+- Expected instrumentation tags should be declared up front.
+- Verification should be grep/typecheck, not a long runtime test.
diff --git a/notes/open-agent-handoff-testing/3-promptfoo-integration-plan.md b/notes/open-agent-handoff-testing/3-promptfoo-integration-plan.md
new file mode 100644
index 0000000..1e20896
--- /dev/null
+++ b/notes/open-agent-handoff-testing/3-promptfoo-integration-plan.md
@@ -0,0 +1,115 @@
+# Promptfoo Integration Plan
+
+## Why Consider Promptfoo Early
+
+Promptfoo may be worth using from the start if it gives us a consistent matrix
+runner and report format without forcing open-agents to become an eval framework.
+
+The risk is over-integration: if promptfoo has to own process orchestration,
+worktree setup, open-agents job polling, and human grading, the setup may become
+heavier than the experiment.
+
+## Preferred Boundary
+
+Open-agents should remain responsible for:
+
+- Creating and running agent jobs.
+- Persisting job specs/results/logs.
+- Selecting adapter/profile/model.
+- Reporting job status and result paths.
+
+Promptfoo should be responsible for:
+
+- Running the variant/scenario matrix.
+- Passing variables into prompt templates.
+- Capturing normalized JSON summaries from a local provider script.
+- Rendering comparison reports.
+- Hosting simple assertions where they are reliable.
+
+## Thin Local Provider Shape
+
+Promptfoo can call a local script instead of directly calling model APIs.
+
+Possible flow:
+
+1. Promptfoo selects `{scenario, variant, tailSize, provider, model}`.
+2. Local provider script prepares an isolated run directory or worktree.
+3. Script builds the handoff prompt for A, B, or C.
+4. Script invokes open-agents.
+5. Script records metrics and returns compact JSON to promptfoo.
+
+The local provider result should include:
+
+- `variant`
+- `scenario`
+- `promptChars`
+- `tailChars`
+- `generatedSpecChars`
+- `durationMs`
+- `exitCode`
+- `resultPath`
+- `filesChanged`
+- `verificationCommand`
+- `verificationExitCode`
+- `summary`
+
+## Initial File Layout
+
+```text
+packages/open-agents/evals/
+  fixtures/
+    scenarios.yaml
+  prompts/
+    a-main-agent-spec.md
+    b-title-tail-history.md
+    c-spec-writer-title-tail-history.md
+  scripts/
+    run-promptfoo-provider.ts
+    prepare-fixture.ts
+    score-result.ts
+  promptfooconfig.yaml
+```
+
+Keep this small at first. The script can shell out to the existing local source
+entrypoint rather than requiring a published package.
+
+## Assertions
+
+Use objective assertions where they are cheap:
+
+- Did the run exit successfully?
+- Did required files appear in the answer?
+- Did required instrumentation tags appear?
+- Did verification command pass?
+- Did edit diff stay under expected paths?
+
+Use human review for the important qualitative parts:
+
+- Intent fidelity.
+- Scope control.
+- Whether the result would have saved main-agent time.
+- Whether the handoff was pleasant enough to use again.
+
+## Open Questions
+
+- Does promptfoo handle long-running local providers comfortably enough for
+  agent jobs?
+- Does it stream useful progress, or only final results?
+- How awkward is one-worktree-per-variant setup inside promptfoo?
+- Should the first implementation use promptfoo directly, or write the local
+  provider script first and wrap it with promptfoo once stable?
+- Can promptfoo store enough metadata, or should run artifacts live entirely
+  under `.davstack/evals/` with promptfoo only linking to them?
+
+## Lean Recommendation
+
+Build the local provider script as if promptfoo will call it, then wire promptfoo
+around it immediately if the integration feels simple.
+
+That gives us both options:
+
+- Run one scenario manually while debugging.
+- Run the full A/B/C matrix through promptfoo once the provider is stable.
+
+This is different from delaying evals. The eval-shaped artifact comes first; the
+promptfoo wrapper should be thin.
diff --git a/notes/open-agent-handoff-testing/4-candidate-backlog.md b/notes/open-agent-handoff-testing/4-candidate-backlog.md
new file mode 100644
index 0000000..545accb
--- /dev/null
+++ b/notes/open-agent-handoff-testing/4-candidate-backlog.md
@@ -0,0 +1,399 @@
+# Candidate Backlog: Open Agents Spec Handoff Experiments
+
+Related issues:
+
+- #28 Experiment with improved openagents spec writing flow
+- #25 Add evals
+
+## Problem
+
+Open-agents delegation is useful when a cheap/fast agent can absorb bounded
+work, but the current handoff can be expensive in a different way: the main
+agent often spends a lot of output tokens writing a detailed spec. That can make
+delegation feel slower and more costly than just doing the work directly.
+
+The central question is not "should every task have a generated spec?" The
+question is:
+
+> What is the cheapest handoff shape that still gives the execution agent enough
+> context to succeed on the first try?
+
+## High-Level Hypotheses
+
+### H1: Main-agent specs are high quality but often over-priced
+
+The current pattern gives the execution agent a curated spec, but the main agent
+pays the full cost of synthesis. This may be best for complex or risky edits,
+but it is probably wasteful for straightforward explore and mechanical edit
+tasks.
+
+### H2: Title plus history may be enough for many tasks
+
+A very short intent plus recent chat context and a pointer to full history may
+let the execution agent infer the needed spec internally. If true, the separate
+spec-writer agent is unnecessary for a large class of tasks.
+
+### H3: A spec-writer middleman helps when the execution agent needs focus
+
+Some tasks may fail when the execution agent has to both discover the task and
+execute it. A cheap spec-writer agent may be valuable when it turns noisy chat
+history into a compact, executable brief.
+
+### H4: Recent chat tail plus full-history pointer beats either alone
+
+The recent tail gives the agent immediately relevant context. The full-history
+file gives it an escape hatch for older decisions without forcing all that text
+into the prompt.
+
+### H5: The best strategy may depend on task shape
+
+Explore, fast-edit, bug diagnosis, and architectural planning may need different
+handoff strategies. The eval should preserve task category instead of averaging
+everything into one score.
+
+## Candidate Handoff Variants
+
+### A. Main Agent Written Spec
+
+Current baseline.
+
+Input to execution agent:
+
+- Detailed spec written by the orchestrating agent.
+- Normal open-agents profile scaffold.
+
+Expected strengths:
+
+- Highest intent clarity.
+- Best acceptance criteria.
+- Lowest chance the execution agent chases stale context.
+
+Expected weaknesses:
+
+- Expensive output tokens from the main agent.
+- Slow to prepare.
+- May erase useful nuance from the original chat.
+
+### B. No Spec: Title Only
+
+Input to execution agent:
+
+- Task title or one-line intent only.
+- Normal open-agents profile scaffold.
+
+Expected strengths:
+
+- Cheapest possible orchestration.
+- Useful lower-bound baseline.
+
+Expected weaknesses:
+
+- Likely under-specified.
+- May work only for tiny or obvious tasks.
+
+### C. No Spec: Title Plus Full-History Pointer
+
+Input to execution agent:
+
+- Task title or one-line intent.
+- Path to full chat history file.
+- Instruction to inspect only relevant portions.
+
+Expected strengths:
+
+- Very low main-agent output.
+- Avoids pasting huge context into every run.
+- Lets execution agent decide what history matters.
+
+Expected weaknesses:
+
+- Agent may not inspect the right parts.
+- More tool use and latency.
+- Harder to guarantee reproducibility if history file format changes.
+
+### D. No Spec: Title Plus Recent Tail Plus Full-History Pointer
+
+Input to execution agent:
+
+- Task title or one-line intent.
+- Last X chars of chat history, probably 30k, 50k, and 100k buckets.
+- Path to full chat history file for deeper lookup.
+
+Expected strengths:
+
+- Keeps the most relevant context in the prompt.
+- Still avoids full-context prompt bloat.
+- May remove the need for a spec-writer middleman.
+
+Expected weaknesses:
+
+- Still pays input-token cost for the tail.
+- Recent chat can contain distractions.
+- The execution agent still has to synthesize and execute in one pass.
+
+### E. Spec Writer: Title Plus Full-History Pointer
+
+Step 1 spec-writer agent input:
+
+- Task title or one-line intent.
+- Path to full chat history file.
+- Instruction to produce a compact execution spec.
+
+Step 2 execution agent input:
+
+- Generated spec.
+- Normal open-agents profile scaffold.
+
+Expected strengths:
+
+- Main agent writes almost nothing.
+- Execution agent gets a compact, focused spec.
+- Full history is only read by the spec writer.
+
+Expected weaknesses:
+
+- Adds an extra agent run.
+- Spec writer may miss context.
+- More moving parts and more artifact management.
+
+### F. Spec Writer: Title Plus Recent Tail Plus Full-History Pointer
+
+Step 1 spec-writer agent input:
+
+- Task title or one-line intent.
+- Recent chat tail.
+- Path to full chat history file.
+- Instruction to produce a compact execution spec.
+
+Step 2 execution agent input:
+
+- Generated spec.
+- Normal open-agents profile scaffold.
+
+Expected strengths:
+
+- Likely strongest middleman variant.
+- Spec writer sees recent nuance immediately.
+- Execution agent gets a clean, bounded brief.
+
+Expected weaknesses:
+
+- Most expensive experimental variant besides baseline.
+- May be overkill for simple tasks.
+- Tail-size tuning matters.
+
+### G. Spec Writer Iteration
+
+Same as E or F, but the spec writer can run a self-check pass before handing off.
+
+Possible self-check questions:
+
+- Does the spec include the exact goal?
+- Does it name scope and non-goals?
+- Does it include acceptance criteria for edit tasks?
+- Does it preserve user preferences from the chat?
+- Does it avoid inventing requirements?
+
+Expected strengths:
+
+- Better generated specs for complex work.
+- Useful for high-risk edits.
+
+Expected weaknesses:
+
+- More latency.
+- More tokens.
+- May collapse into the same cost problem we are trying to solve.
+
+## Task Fixtures
+
+Start with a small set of real-ish tasks instead of synthetic only.
+
+### Fixture 1: Hello World Mechanical Edit
+
+Purpose:
+
+- Prove the harness can run all variants.
+- Check that metadata, artifacts, timings, and result paths are captured.
+
+Success criteria:
+
+- All variants produce comparable records.
+- Execution result is easy to grade.
+- No expensive manual analysis needed.
+
+### Fixture 2: Open-Agents Small Explore
+
+Example:
+
+- "Find where open-agents builds the Cursor command args and explain the mode
+  differences."
+
+Purpose:
+
+- Tests whether history helps a read-only task.
+- Lower risk than editing.
+
+Success criteria:
+
+- Answer cites relevant files and lines.
+- No invented behavior.
+
+### Fixture 3: Open-Agents Small Edit
+
+Example:
+
+- "Add a small metadata field to persisted job records and cover it with a unit
+  test."
+
+Purpose:
+
+- Tests whether generated/no-spec handoffs can produce acceptable edit specs.
+
+Success criteria:
+
+- Patch applies.
+- Typecheck or targeted tests pass.
+- Scope remains narrow.
+
+### Fixture 4: Ambiguous Planning Task
+
+Example:
+
+- "Improve open-agents spec handoff."
+
+Purpose:
+
+- Stress test whether the agent can recover intent from chat history.
+
+Success criteria:
+
+- Output identifies uncertainty.
+- Does not over-commit to implementation without enough evidence.
+
+## Measurements
+
+Capture objective metrics for every run:
+
+- Variant id.
+- Fixture id.
+- Provider and model.
+- Prompt character count.
+- Recent-tail character count.
+- Whether a full-history pointer was provided.
+- Generated spec character count, if any.
+- Wall-clock duration.
+- Process exit code.
+- Result path.
+- Files changed.
+- Test/typecheck command result, when applicable.
+
+Capture subjective review metrics:
+
+- Intent fidelity: 1-5.
+- Scope control: 1-5.
+- First-pass usefulness: 1-5.
+- Would-use-again: yes/no.
+- Notes on failure mode.
+
+For edit tasks, also capture:
+
+- Did it modify only expected files?
+- Did it include or preserve acceptance criteria?
+- Did it run the allowed verification command?
+- Did the final diff require human cleanup?
+
+## Promptfoo Integration Shape
+
+Promptfoo is probably useful, but it should start as a thin runner/evaluator
+around the same artifacts open-agents already writes. Avoid making promptfoo own
+the whole execution pipeline too early.
+
+Proposed lightweight structure:
+
+```text
+packages/open-agents/evals/
+  fixtures/
+    hello-world.yaml
+    small-explore.yaml
+    small-edit.yaml
+  prompts/
+    main-agent-spec.md
+    no-spec-title.md
+    no-spec-title-history-pointer.md
+    no-spec-title-tail-history-pointer.md
+    spec-writer-history-pointer.md
+    spec-writer-tail-history-pointer.md
+  promptfooconfig.yaml
+  scripts/
+    run-variant.ts
+    collect-results.ts
+```
+
+Promptfoo can compare prompt variants and call a local script provider that:
+
+1. Builds the variant prompt.
+2. Runs open-agents with the selected adapter/profile.
+3. Records job metadata and result artifacts.
+4. Returns a compact JSON summary to promptfoo.
+
+This keeps open-agents as the source of truth for job execution while promptfoo
+handles matrix runs, assertions, and reports.
+
+## Open Questions
+
+- Where does the full chat history file live in each host environment?
+- Is the history file stable enough to pass directly, or do we need an export
+  command?
+- Should recent-tail extraction happen in open-agents, a wrapper script, or the
+  main agent?
+- Should generated specs be persisted as first-class job artifacts?
+- Do we need a new `spec` profile, or is this just an `explore` profile with a
+  different output contract?
+- Should spec-writer output be constrained to the existing `<goal>`,
+  `<context>`, `<scope>`, `<acceptance>` shape?
+- How much should the execution agent be told about the experiment variant?
+
+## Suggested Implementation Phases
+
+### Phase 1: Planning Artifacts
+
+- Write this experiment plan.
+- Pick 3-4 fixtures.
+- Define review rubric.
+- Decide where chat history input comes from.
+
+### Phase 2: Minimal Manual Harness
+
+- Add scripts that run one fixture through each variant.
+- Persist raw prompts, generated specs, job ids, results, and metrics.
+- Avoid promptfoo until one or two variants have completed manually.
+
+### Phase 3: Promptfoo Wrapper
+
+- Add promptfoo config over the same fixtures and scripts.
+- Use promptfoo for repeatable matrix runs and basic assertions.
+- Keep human review fields in a simple JSON/Markdown report.
+
+### Phase 4: Productize Winning Flow
+
+- Add a user-facing command or profile only after the experiment shows a winner.
+- Likely candidates:
+  - `open-agents spec`
+  - `open-agents submit --handoff title-tail-history`
+  - `open-agents submit --spec-writer`
+
+## Current Lean Recommendation
+
+Do not assume the middleman spec-writer is necessary. Test no-spec history
+variants directly against spec-writer variants.
+
+The most promising early comparison is:
+
+1. Main-agent written spec.
+2. No spec: title plus recent tail plus full-history pointer.
+3. Spec writer: title plus recent tail plus full-history pointer.
+
+If variant 2 is close to variant 3, skip the middleman for common tasks and
+reserve spec-writing for complex/risky work. If variant 3 is much better, build
+the spec-writer path as a first-class open-agents flow.

From de71620e868107ecc7958a7732fca3d4f6f321f6 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 14:59:18 +0100
Subject: [PATCH 13/72] docs: outline external handoff fixtures

---
 .../.folder-meta.md                           |  16 +++
 .../5-external-fixtures.md                    | 132 ++++++++++++++++++
 .../6-fixture-repo-candidates.md              |  83 +++++++++++
 3 files changed, 231 insertions(+)
 create mode 100644 notes/open-agent-handoff-testing/5-external-fixtures.md
 create mode 100644 notes/open-agent-handoff-testing/6-fixture-repo-candidates.md

diff --git a/notes/open-agent-handoff-testing/.folder-meta.md b/notes/open-agent-handoff-testing/.folder-meta.md
index c060af2..5f328c6 100644
--- a/notes/open-agent-handoff-testing/.folder-meta.md
+++ b/notes/open-agent-handoff-testing/.folder-meta.md
@@ -39,3 +39,19 @@ not the active starting plan; it is a backlog for later expansion after the
 three-way comparison produces signal.
 
 Use this when deciding what variants to test next.
+
+### `5-external-fixtures.md`
+
+Captures the fixture strategy for using pinned third-party repositories without
+vendoring them into this repo. Covers manifests, isolated checkouts per run,
+reset behavior, and the open questions around Promptfoo artifact layout.
+
+Use this when implementing fixture preparation and choosing the first CRUD app.
+
+### `6-fixture-repo-candidates.md`
+
+Records candidate GitHub repositories for the first external fixture, with a
+short recommendation and tradeoffs.
+
+Use this when selecting the pinned repo/commit for the first prepare-script
+spike.
diff --git a/notes/open-agent-handoff-testing/5-external-fixtures.md b/notes/open-agent-handoff-testing/5-external-fixtures.md
new file mode 100644
index 0000000..4e6978d
--- /dev/null
+++ b/notes/open-agent-handoff-testing/5-external-fixtures.md
@@ -0,0 +1,132 @@
+# External Fixture Strategy
+
+## Direction We Agree On
+
+Use a pinned third-party mid-size repository as the first realistic eval target,
+instead of testing only against `davstack` itself.
+
+Agreed principles:
+
+- Do not vendor a large third-party repo into normal git history.
+- Keep only a small fixture manifest in this repo.
+- Clone the target repo at a pinned commit during a prepare step.
+- Put cloned/prepared repo copies in a gitignored eval workspace.
+- Run variants in isolated checkouts so edits, generated files, and dependency
+  artifacts cannot contaminate other runs.
+- Reset to the pinned base between runs.
+
+## Candidate Fixture Shape
+
+Preferred first fixture:
+
+- Next.js app.
+- Supabase-backed or Supabase-like CRUD flow.
+- Todo or simple CRUD domain.
+- Medium sized: enough routing/components/server logic to make `explore` useful,
+  but not so large that setup and grading become the project.
+- Has predictable local install/build/typecheck/test behavior.
+- Licensed in a way that is comfortable for local eval use.
+
+The fixture does not need to be perfect. It needs to be stable, understandable,
+and realistic enough to exercise the handoff strategies.
+
+## Manifest-First Model
+
+Store a small manifest in git, not the cloned repo.
+
+Example shape:
+
+```yaml
+id: nextjs-supabase-todos
+repo: https://github.com/example/nextjs-supabase-todos.git
+commit: abc123
+sparse:
+  - app/**
+  - components/**
+  - lib/**
+  - supabase/**
+  - package.json
+  - pnpm-lock.yaml
+setup:
+  - pnpm install --frozen-lockfile
+verify:
+  - pnpm typecheck
+  - pnpm test
+```
+
+Sparse checkout is optional. It is useful only if the chosen repo has docs,
+assets, generated files, or unrelated examples that would distract agents.
+
+## Isolation Model
+
+For edit-capable scenarios, each `{scenario, variant, repeat}` should get its
+own checkout/worktree/copy.
+
+Why:
+
+- Variant A must not see files changed by variant B.
+- Failed runs should be inspectable without blocking later runs.
+- Parallel runs become much easier to reason about.
+
+For read-only scenarios, shared checkout is possible, but the first harness
+should probably use the same isolation model for every scenario. Uniformity is
+worth a little disk/time overhead while the eval is young.
+
+## Reset Behavior
+
+Every run starts from the same pinned commit plus the same setup result.
+
+Possible implementation:
+
+1. Maintain a local bare/mirror cache of the fixture repo.
+2. Create a fresh worktree or clone for each run from the pinned commit.
+3. Apply any scenario-specific seed patch or setup script.
+4. Run the handoff variant.
+5. Collect result, diff, verification output, and metadata.
+6. Delete successful run dirs or keep only compressed artifacts.
+7. Keep failed run dirs until inspected, or save their diff before cleanup.
+
+## Artifact Layout Is Still Provisional
+
+The earlier `.davstack/evals` sketch is a plausible starting point, not a
+decision. Promptfoo may emit its own logs/results in a way that changes the best
+layout.
+
+Open question:
+
+- Should Promptfoo own the run directory?
+- Should open-agents own `.davstack/evals/runs/*` and Promptfoo only link to it?
+- Should fixture clones live under `.davstack/evals`, `packages/open-agents/evals/.work`,
+  or a configurable temp path?
+
+Lean starting point:
+
+- Keep manifests and prompt templates in git.
+- Keep cloned repos and run artifacts out of git.
+- Let the first Promptfoo spike tell us whether `.davstack/evals` is the right
+  home or just a useful placeholder.
+
+## Macro Plan
+
+1. Pick one candidate CRUD fixture repo.
+2. Record repo URL, commit SHA, install command, verify command, and any setup
+   quirks in a manifest.
+3. Build a tiny prepare script that clones/resets one isolated checkout.
+4. Run one read-only `explore` scenario manually against that checkout.
+5. Run one edit scenario manually in three isolated checkouts for variants A/B/C.
+6. Capture artifacts and review whether the layout is annoying.
+7. Wrap the same provider/prepare flow with Promptfoo only after the manual
+   path is understandable.
+
+## Future Extension
+
+Once the basic three-way handoff comparison works, test the middleman as a
+fan-out planner:
+
+- It reads the task and fixture context.
+- It writes one shared context artifact.
+- It emits several parallel `explore` or `fast-edit` specs.
+- The harness runs them independently and collects/composes results.
+
+That is likely a high-leverage path, but it should not be mixed into the first
+fixture-preparation spike.
diff --git a/notes/open-agent-handoff-testing/6-fixture-repo-candidates.md b/notes/open-agent-handoff-testing/6-fixture-repo-candidates.md
new file mode 100644
index 0000000..e798833
--- /dev/null
+++ b/notes/open-agent-handoff-testing/6-fixture-repo-candidates.md
@@ -0,0 +1,83 @@
+# Fixture Repo Candidates
+
+## Current Recommendation
+
+Start by trying `imbhargav5/nextbase-nextjs-supabase-starter` if the goal is a
+realistic agent-eval fixture rather than the smallest possible todo app.
+
+Why:
+
+- It has real project structure: app code, database app, packages, docs, and
+  migrations.
+- It advertises Supabase, CRUD/private items, typecheck, lint, tests, e2e tests,
+  and local Supabase lifecycle scripts.
+- It is likely rich enough for both `explore` and `fast-edit` scenarios.
+
+Tradeoff:
+
+- It is more of a SaaS starter than a tiny todo app.
+- It may be heavier to install and reset.
+- It uses newer framework versions, so the commit and lockfile need to be pinned
+  tightly.
+
+Candidate:
+
+- <https://github.com/imbhargav5/nextbase-nextjs-supabase-starter>
+
+## Other Candidates
+
+### Halo-Lab/next-supabase-todo
+
+- URL: <https://github.com/Halo-Lab/next-supabase-todo>
+- Shape: small Next.js + Supabase todo app.
+- Pros: focused todo domain, MIT license noted in README, likely easy for agents
+  to understand.
+- Cons: very small; package scripts appear limited to dev/build/start; dependency
+  versions may be less deterministic if using `latest`.
+
+### Ali-Onar/nextjs-supabase-todo-app
+
+- URL: <https://github.com/Ali-Onar/nextjs-supabase-todo-app>
+- Shape: small-to-mid Next.js todo app with Supabase, Clerk, TypeScript, Material
+  UI, and drag/drop.
+- Pros: more UI/application structure than the smallest examples.
+- Cons: Clerk plus Supabase setup may add auth/environment friction; tests were
+  not obvious from a quick scan.
+
+### keiloktql/supabase-todo-app
+
+- URL: <https://github.com/keiloktql/supabase-todo-app>
+- Shape: small Supabase todo app.
+- Pros: MIT license visible, simple domain.
+- Cons: likely too small for deeper eval tasks; setup details looked less
+  reliable from a quick scan.
+
+### clerk/clerk-supabase-nextjs
+
+- URL: <https://github.com/clerk/clerk-supabase-nextjs>
+- Shape: official-ish Clerk/Supabase/Next.js integration example.
+- Pros: auth/RLS integration may be realistic.
+- Cons: not clearly todo/CRUD-focused; likely depends on dashboard/env setup;
+  less ideal for deterministic local evals.
+
+## Selection Criteria
+
+Before committing to a fixture, check:
+
+- Can it install from the pinned lockfile?
+- Can it typecheck/build without hosted secrets?
+- Does it have local tests, or can we define a cheap verification command?
+- Does it have enough code structure for meaningful `explore` tasks?
+- Does it have a safe edit surface for `fast-edit` tasks?
+- Can Supabase setup be skipped, mocked, or run locally without long setup?
+
+## First Spike
+
+Try the recommended starter first, but treat that as a spike rather than a final
+choice:
+
+1. Pin a commit.
+2. Clone into a gitignored eval workspace.
+3. Run install/typecheck/test commands once manually.
+4. Record setup friction.
+5. Decide whether to keep it or fall back to a smaller todo repo.

From 9d2d8f95490f648bb900095469e1fdc2df4741e0 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:00:04 +0100
Subject: [PATCH 14/72] feat: add davstack meta package

---
 packages/meta/README.md              |  11 ++
 packages/meta/__tests__/cli.test.ts  |  47 +++++++
 packages/meta/__tests__/meta.test.ts | 129 ++++++++++++++++++
 packages/meta/bin/davstack-meta.mjs  |  17 +++
 packages/meta/package.json           |  44 ++++++
 packages/meta/src/cli-spec.ts        |  45 +++++++
 packages/meta/src/cli.ts             |   5 +
 packages/meta/src/index.ts           | 193 +++++++++++++++++++++++++++
 packages/meta/tsconfig.json          |  17 +++
 packages/meta/tsup.config.ts         |  16 +++
 pnpm-lock.yaml                       |  16 +++
 vitest.workspace.ts                  |  15 +++
 12 files changed, 555 insertions(+)
 create mode 100644 packages/meta/README.md
 create mode 100644 packages/meta/__tests__/cli.test.ts
 create mode 100644 packages/meta/__tests__/meta.test.ts
 create mode 100644 packages/meta/bin/davstack-meta.mjs
 create mode 100644 packages/meta/package.json
 create mode 100644 packages/meta/src/cli-spec.ts
 create mode 100644 packages/meta/src/cli.ts
 create mode 100644 packages/meta/src/index.ts
 create mode 100644 packages/meta/tsconfig.json
 create mode 100644 packages/meta/tsup.config.ts

diff --git a/packages/meta/README.md b/packages/meta/README.md
new file mode 100644
index 0000000..63405df
--- /dev/null
+++ b/packages/meta/README.md
@@ -0,0 +1,11 @@
+# @davstack/meta
+
+Generate concise, agent-friendly folder metadata.
+
+```sh
+davstack-meta gen .
+davstack-meta view . --deep
+```
+
+The first version uses conservative text scanning and safe default ignores for
+`node_modules`, `.git`, `dist`, `.next`, coverage, and generated metadata files.
diff --git a/packages/meta/__tests__/cli.test.ts b/packages/meta/__tests__/cli.test.ts
new file mode 100644
index 0000000..c6cecd6
--- /dev/null
+++ b/packages/meta/__tests__/cli.test.ts
@@ -0,0 +1,47 @@
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { defineCli } from '@davstack/cli-utils';
+import { GENERATED_META_FILE } from '../src/index.js';
+import { cliSpec } from '../src/cli-spec.js';
+
+async function makeTempFolder() {
+  return await mkdtemp(path.join(os.tmpdir(), 'davstack-meta-cli-'));
+}
+
+describe('davstack-meta CLI', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test('gen writes metadata and prints the generated file path', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, 'README.md'), '# CLI\n');
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const code = await defineCli(cliSpec).run(['gen', root]);
+
+    expect(code).toBe(0);
+    expect(log).toHaveBeenCalledWith(path.join(root, GENERATED_META_FILE));
+    await expect(readFile(path.join(root, GENERATED_META_FILE), 'utf8')).resolves.toContain(
+      'h1 CLI',
+    );
+  });
+
+  test('view prints existing metadata and supports deep generation', async () => {
+    const root = await makeTempFolder();
+    await mkdir(path.join(root, 'child'));
+    await writeFile(path.join(root, 'README.md'), '# Root\n');
+    await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const code = await defineCli(cliSpec).run(['view', root, '--deep']);
+
+    expect(code).toBe(0);
+    const output = log.mock.calls.map(([value]) => String(value)).join('\n');
+    expect(output).toContain('h1 Root');
+    expect(output).toContain('child/child.ts');
+    expect(output).toContain('childValue');
+  });
+});
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
new file mode 100644
index 0000000..43eaa54
--- /dev/null
+++ b/packages/meta/__tests__/meta.test.ts
@@ -0,0 +1,129 @@
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { describe, expect, test } from 'vitest';
+import {
+  GENERATED_META_FILE,
+  generateFolderMetadata,
+  scanFolderMetadata,
+  viewFolderMetadata,
+} from '../src/index.js';
+
+const execFileAsync = promisify(execFile);
+
+async function makeTempFolder() {
+  return await mkdtemp(path.join(os.tmpdir(), 'davstack-meta-'));
+}
+
+describe('scanFolderMetadata', () => {
+  test('summarizes markdown headings and top-level code symbols in deterministic order', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, 'notes.md'), '# Overview\n\n## Details\n');
+    await writeFile(
+      path.join(root, 'sample.py'),
+      'CONSTANT = 1\n\nclass Worker:\n    pass\n\ndef run():\n    pass\n',
+    );
+    await writeFile(
+      path.join(root, 'tools.ts'),
+      'export interface Config {}\nexport type Mode = "fast"\nexport const value = 1\nexport function build() {}\nclass LocalThing {}\n',
+    );
+
+    await expect(scanFolderMetadata(root)).resolves.toMatchInlineSnapshot(`
+      "# Folder Metadata
+
+      <folder path=".">
+      <file path="notes.md" kind="markdown">
+      - h1 Overview
+      - h2 Details
+      </file>
+      <file path="sample.py" kind="python">
+      - const CONSTANT
+      - class Worker
+      - function run
+      </file>
+      <file path="tools.ts" kind="typescript">
+      - class LocalThing
+      - interface Config
+      - type Mode
+      - const value
+      - function build
+      </file>
+      </folder>
+      "
+    `);
+  });
+
+  test('skips generated metadata and default ignored folders', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, GENERATED_META_FILE), '# stale generated file\n');
+    await mkdir(path.join(root, 'node_modules'), { recursive: true });
+    await writeFile(path.join(root, 'node_modules', 'ignored.ts'), 'export const ignored = true\n');
+    await writeFile(path.join(root, 'visible.ts'), 'export const visible = true\n');
+
+    const metadata = await scanFolderMetadata(root, { deep: true });
+
+    expect(metadata).toContain('path="visible.ts"');
+    expect(metadata).toContain('const visible');
+    expect(metadata).not.toContain(GENERATED_META_FILE);
+    expect(metadata).not.toContain('ignored');
+  });
+
+  test('skips files ignored by git when scanning a git worktree', async () => {
+    const root = await makeTempFolder();
+    await execFileAsync('git', ['init'], { cwd: root });
+    await writeFile(path.join(root, '.gitignore'), 'ignored.ts\n');
+    await writeFile(path.join(root, 'ignored.ts'), 'export const ignored = true\n');
+    await writeFile(path.join(root, 'visible.ts'), 'export const visible = true\n');
+
+    const metadata = await scanFolderMetadata(root);
+
+    expect(metadata).toContain('visible.ts');
+    expect(metadata).not.toContain('ignored.ts');
+    expect(metadata).not.toContain('const ignored');
+  });
+});
+
+describe('generated folder metadata', () => {
+  test('gen writes the generated metadata file in the scanned folder', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, 'README.md'), '# Root\n');
+
+    const result = await generateFolderMetadata(root);
+
+    expect(result.path).toBe(path.join(root, GENERATED_META_FILE));
+    await expect(readFile(result.path, 'utf8')).resolves.toBe(result.content);
+    expect(result.content).toContain('<file path="README.md" kind="markdown">');
+  });
+
+  test('view prints existing metadata, generating it when missing', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, GENERATED_META_FILE), '# Existing\n');
+
+    await expect(viewFolderMetadata(root)).resolves.toBe('# Existing\n');
+
+    const missing = await makeTempFolder();
+    await writeFile(path.join(missing, 'README.md'), '# Created\n');
+
+    const generated = await viewFolderMetadata(missing);
+    expect(generated).toContain('h1 Created');
+    await expect(readFile(path.join(missing, GENERATED_META_FILE), 'utf8')).resolves.toBe(generated);
+  });
+
+  test('deep scans child folders while the default view stays shallow', async () => {
+    const root = await makeTempFolder();
+    await mkdir(path.join(root, 'child'));
+    await writeFile(path.join(root, 'root.ts'), 'export const rootValue = true\n');
+    await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
+
+    const shallow = await scanFolderMetadata(root);
+    const deep = await scanFolderMetadata(root, { deep: true });
+
+    expect(shallow).toContain('rootValue');
+    expect(shallow).not.toContain('childValue');
+    expect(deep).toContain('rootValue');
+    expect(deep).toContain('child/child.ts');
+    expect(deep).toContain('childValue');
+  });
+});
diff --git a/packages/meta/bin/davstack-meta.mjs b/packages/meta/bin/davstack-meta.mjs
new file mode 100644
index 0000000..156d101
--- /dev/null
+++ b/packages/meta/bin/davstack-meta.mjs
@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const entry = path.join(here, '..', 'dist', 'cli.js')
+const child = spawn(process.execPath, [entry, ...process.argv.slice(2)], { stdio: 'inherit' })
+
+child.on('error', (err) => {
+  console.error('davstack-meta: launcher error:', err)
+  process.exit(1)
+})
+child.on('exit', (code, signal) => {
+  if (signal) process.kill(process.pid, signal)
+  else process.exit(code ?? 0)
+})
diff --git a/packages/meta/package.json b/packages/meta/package.json
new file mode 100644
index 0000000..54bd398
--- /dev/null
+++ b/packages/meta/package.json
@@ -0,0 +1,44 @@
+{
+  "name": "@davstack/meta",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "description": "Generate concise folder metadata for agents.",
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "tsup",
+    "test": "pnpm -w exec vitest run --project meta"
+  },
+  "bin": {
+    "davstack-meta": "./bin/davstack-meta.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./cli-spec": {
+      "types": "./dist/cli-spec.d.ts",
+      "default": "./dist/cli-spec.js"
+    }
+  },
+  "files": [
+    "bin/**",
+    "dist/**",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@davstack/cli-utils": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/meta/src/cli-spec.ts b/packages/meta/src/cli-spec.ts
new file mode 100644
index 0000000..3689c4a
--- /dev/null
+++ b/packages/meta/src/cli-spec.ts
@@ -0,0 +1,45 @@
+import type { CliSpec } from '@davstack/cli-utils';
+
+export const cliSpec: CliSpec = {
+  name: 'davstack-meta',
+  description: 'Generate and view concise folder metadata for agents.',
+  commands: {
+    gen: {
+      description: 'Write .folder-meta.generated.md in a folder',
+      positionals: [{ name: 'path', required: true, description: 'Folder to scan' }],
+      flags: {
+        deep: {
+          type: 'boolean',
+          default: false,
+          description: 'Recursively include child folders',
+        },
+      },
+      run: async (ctx) => {
+        const { generateFolderMetadata } = await import('./index.js');
+        const result = await generateFolderMetadata(ctx.positionals[0], {
+          deep: ctx.flags.deep as boolean,
+        });
+        console.log(result.path);
+      },
+    },
+    view: {
+      description: 'Print existing metadata, generating it when missing',
+      positionals: [{ name: 'path', required: true, description: 'Folder to view' }],
+      flags: {
+        deep: {
+          type: 'boolean',
+          default: false,
+          description: 'Recursively include child folders',
+        },
+      },
+      run: async (ctx) => {
+        const { viewFolderMetadata } = await import('./index.js');
+        console.log(
+          await viewFolderMetadata(ctx.positionals[0], {
+            deep: ctx.flags.deep as boolean,
+          }),
+        );
+      },
+    },
+  },
+};
diff --git a/packages/meta/src/cli.ts b/packages/meta/src/cli.ts
new file mode 100644
index 0000000..f8e1d52
--- /dev/null
+++ b/packages/meta/src/cli.ts
@@ -0,0 +1,5 @@
+import { defineCli } from '@davstack/cli-utils';
+import { cliSpec } from './cli-spec.js';
+
+const code = await defineCli(cliSpec).run(process.argv.slice(2));
+process.exit(code);
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
new file mode 100644
index 0000000..722a08d
--- /dev/null
+++ b/packages/meta/src/index.ts
@@ -0,0 +1,193 @@
+import { execFile } from 'node:child_process';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+export const GENERATED_META_FILE = '.folder-meta.generated.md';
+const execFileAsync = promisify(execFile);
+
+export type ScanOptions = {
+  deep?: boolean;
+};
+
+type FileSummary = {
+  path: string;
+  kind: 'markdown' | 'typescript' | 'python';
+  items: string[];
+};
+
+const SKIP_DIRS = new Set([
+  '.git',
+  '.next',
+  'coverage',
+  'dist',
+  'dist-ssr',
+  'node_modules',
+]);
+
+const SKIP_FILES = new Set([GENERATED_META_FILE]);
+
+export async function scanFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
+  const root = path.resolve(folder);
+  const summaries = await collectFileSummaries(root, root, options.deep === true);
+
+  const lines = ['# Folder Metadata', '', '<folder path=".">'];
+  for (const summary of summaries) {
+    lines.push(`<file path="${escapeAttribute(summary.path)}" kind="${summary.kind}">`);
+    for (const item of summary.items) lines.push(`- ${item}`);
+    lines.push('</file>');
+  }
+  lines.push('</folder>', '');
+  return lines.join('\n');
+}
+
+export async function generateFolderMetadata(
+  folder: string,
+  options: ScanOptions = {},
+): Promise<{ path: string; content: string }> {
+  const root = path.resolve(folder);
+  const content = await scanFolderMetadata(root, options);
+  const outPath = path.join(root, GENERATED_META_FILE);
+  await mkdir(root, { recursive: true });
+  await writeFile(outPath, content, 'utf8');
+  return { path: outPath, content };
+}
+
+export async function viewFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
+  const root = path.resolve(folder);
+  const generatedPath = path.join(root, GENERATED_META_FILE);
+  try {
+    if (!options.deep) return await readFile(generatedPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+  return (await generateFolderMetadata(root, options)).content;
+}
+
+async function collectFileSummaries(
+  root: string,
+  dir: string,
+  deep: boolean,
+): Promise<FileSummary[]> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const summaries: FileSummary[] = [];
+
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const fullPath = path.join(dir, entry.name);
+    if (await isGitIgnored(root, fullPath)) continue;
+
+    if (entry.isDirectory()) {
+      if (!deep || shouldSkipDirectory(entry.name)) continue;
+      summaries.push(...(await collectFileSummaries(root, fullPath, deep)));
+      continue;
+    }
+    if (!entry.isFile() || shouldSkipFile(entry.name)) continue;
+
+    const summary = await summarizeFile(root, fullPath);
+    if (summary) summaries.push(summary);
+  }
+
+  return summaries.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+async function summarizeFile(root: string, fullPath: string): Promise<FileSummary | null> {
+  const extension = path.extname(fullPath);
+  const relativePath = toPosix(path.relative(root, fullPath));
+  const text = await readFile(fullPath, 'utf8');
+
+  if (extension === '.md' || extension === '.mdx') {
+    return { path: relativePath, kind: 'markdown', items: extractMarkdownHeadings(text) };
+  }
+  if (['.ts', '.tsx', '.mts', '.cts'].includes(extension) && !fullPath.endsWith('.d.ts')) {
+    return { path: relativePath, kind: 'typescript', items: extractTypeScriptSymbols(text) };
+  }
+  if (extension === '.py') {
+    return { path: relativePath, kind: 'python', items: extractPythonSymbols(text) };
+  }
+  return null;
+}
+
+function extractMarkdownHeadings(text: string): string[] {
+  return text
+    .split(/\r?\n/)
+    .map((line) => /^(#{1,6})\s+(.+?)\s*$/.exec(line))
+    .filter((match): match is RegExpExecArray => match !== null)
+    .map((match) => `h${match[1].length} ${match[2].replace(/\s+#+$/, '').trim()}`);
+}
+
+function extractTypeScriptSymbols(text: string): string[] {
+  const items: string[] = [];
+  const source = stripBlockComments(text);
+  const patterns: Array<[RegExp, string]> = [
+    [/^(?:export\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/gm, 'class'],
+    [/^(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/gm, 'interface'],
+    [/^(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*=/gm, 'type'],
+    [/^(?:export\s+)?(?:declare\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)/gm, 'const'],
+    [
+      /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/gm,
+      'function',
+    ],
+  ];
+
+  for (const [pattern, label] of patterns) {
+    for (const match of source.matchAll(pattern)) items.push(`${label} ${match[1]}`);
+  }
+  return unique(items);
+}
+
+function extractPythonSymbols(text: string): string[] {
+  const items: string[] = [];
+  for (const line of text.split(/\r?\n/)) {
+    let match = /^class\s+([A-Za-z_]\w*)\s*[:(]/.exec(line);
+    if (match) {
+      items.push(`class ${match[1]}`);
+      continue;
+    }
+    match = /^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/.exec(line);
+    if (match) {
+      items.push(`function ${match[1]}`);
+      continue;
+    }
+    match = /^([A-Z][A-Z0-9_]*)\s*[:=]/.exec(line);
+    if (match) items.push(`const ${match[1]}`);
+  }
+  return unique(items);
+}
+
+function shouldSkipDirectory(name: string): boolean {
+  return SKIP_DIRS.has(name);
+}
+
+function shouldSkipFile(name: string): boolean {
+  return SKIP_FILES.has(name) || name.endsWith('.map');
+}
+
+function stripBlockComments(text: string): string {
+  return text.replace(/\/\*[\s\S]*?\*\//g, '');
+}
+
+function unique(items: string[]): string[] {
+  return Array.from(new Set(items));
+}
+
+function toPosix(value: string): string {
+  return value.split(path.sep).join('/');
+}
+
+function escapeAttribute(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+
+async function isGitIgnored(root: string, fullPath: string): Promise<boolean> {
+  const relativePath = toPosix(path.relative(root, fullPath));
+  if (!relativePath || relativePath.startsWith('..')) return false;
+
+  try {
+    await execFileAsync('git', ['-C', root, 'check-ignore', '--quiet', '--', relativePath]);
+    return true;
+  } catch (error) {
+    const code = (error as { code?: number | string }).code;
+    if (code === 1 || code === 128 || code === 'ENOENT') return false;
+    return false;
+  }
+}
diff --git a/packages/meta/tsconfig.json b/packages/meta/tsconfig.json
new file mode 100644
index 0000000..9865451
--- /dev/null
+++ b/packages/meta/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "__tests__/**/*"]
+}
diff --git a/packages/meta/tsup.config.ts b/packages/meta/tsup.config.ts
new file mode 100644
index 0000000..06a723f
--- /dev/null
+++ b/packages/meta/tsup.config.ts
@@ -0,0 +1,16 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    cli: "src/cli.ts",
+    "cli-spec": "src/cli-spec.ts",
+  },
+  format: ["esm"],
+  target: "node20",
+  outDir: "dist",
+  dts: true,
+  clean: true,
+  splitting: false,
+  sourcemap: true,
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 22c88b2..8e18d93 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -83,6 +83,22 @@ importers:
         specifier: ^5.0.0
         version: 5.3.3
 
+  packages/meta:
+    dependencies:
+      '@davstack/cli-utils':
+        specifier: workspace:*
+        version: link:../cli-utils
+    devDependencies:
+      '@types/node':
+        specifier: ^25.9.1
+        version: 25.9.1
+      tsup:
+        specifier: ^8.0.0
+        version: 8.5.1(tsx@4.22.3)(typescript@5.3.3)
+      typescript:
+        specifier: ^5.0.0
+        version: 5.3.3
+
   packages/open-agents:
     dependencies:
       '@davstack/cli-utils':
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index e252b71..ba4a1c5 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -49,6 +49,21 @@ export default defineWorkspace([
 			exclude: ['__tests__/bun-only/**', '**/node_modules/**'],
 		},
 	},
+	{
+		resolve: {
+			alias: {
+				vitest: vitestAlias,
+				'@davstack/cli-utils': path.join(here, 'packages/cli-utils/src/cli.ts'),
+			},
+		},
+		test: {
+			name: 'meta',
+			root: './packages/meta',
+			environment: 'node',
+			include: ['__tests__/**/*.test.ts'],
+			exclude: ['**/node_modules/**'],
+		},
+	},
 	{
 		resolve: { alias: { vitest: vitestAlias } },
 		test: {

From ff277cb585867ccaf67f48d42c4ac8f8947eef3d Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:06:18 +0100
Subject: [PATCH 15/72] chore: commit davstack local state

---
 .davstack/logs/default.db     | Bin 0 -> 4096 bytes
 .davstack/logs/default.db-shm | Bin 0 -> 32768 bytes
 .davstack/logs/default.db-wal | Bin 0 -> 2088872 bytes
 .gitignore                    |   4 +++-
 4 files changed, 3 insertions(+), 1 deletion(-)
 create mode 100644 .davstack/logs/default.db
 create mode 100644 .davstack/logs/default.db-shm
 create mode 100644 .davstack/logs/default.db-wal

diff --git a/.davstack/logs/default.db b/.davstack/logs/default.db
new file mode 100644
index 0000000000000000000000000000000000000000..159e90adb13561c0365c22e76084c658383a62f1
GIT binary patch
literal 4096
zcmWFz^vNtqRY=P(%1ta$FlG>7U}9o$P*7lCU|@t|AVoG{WYFvV#S79dK(-m98b?E5
nGz3ONU^E0qLtr!nMnhmU1V%$(Gz3ONU^E0qLtr!nC=3Arqf-Z%

literal 0
HcmV?d00001

diff --git a/.davstack/logs/default.db-shm b/.davstack/logs/default.db-shm
new file mode 100644
index 0000000000000000000000000000000000000000..9689d0e5d66e8bafbc25884a98eeaa79e32e245b
GIT binary patch
literal 32768
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

literal 0
HcmV?d00001

diff --git a/.davstack/logs/default.db-wal b/.davstack/logs/default.db-wal
new file mode 100644
index 0000000000000000000000000000000000000000..43d3c3e756e518ef6dc1f3e11f3882b760acd767
GIT binary patch
literal 2088872
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%0Aw
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
V@_hW5!N-KQ9?^eQ4M)CS;19{8=w|=`

literal 0
HcmV?d00001

diff --git a/.gitignore b/.gitignore
index 4a30cf2..f56f4db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,4 +12,6 @@ server/dist
 public/dist
 .turbo
 coverage
-/temp
\ No newline at end of file
+.folder-meta.generated.md
+/temp
+paper.md

From e7ec693ed108d3b5bb9f131fee900bab7f398ff0 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:10:25 +0100
Subject: [PATCH 16/72] docs: add multi-db notes

---
 notes/multi-db/01-plan.md                     | 355 ++++++++++++++++++
 ...2-per-run-routing-and-consumer-overhead.md | 185 +++++++++
 .../03-clean-and-label-the-stateless-pivot.md | 286 ++++++++++++++
 3 files changed, 826 insertions(+)
 create mode 100644 notes/multi-db/01-plan.md
 create mode 100644 notes/multi-db/02-per-run-routing-and-consumer-overhead.md
 create mode 100644 notes/multi-db/03-clean-and-label-the-stateless-pivot.md

diff --git a/notes/multi-db/01-plan.md b/notes/multi-db/01-plan.md
new file mode 100644
index 0000000..ae0dba0
--- /dev/null
+++ b/notes/multi-db/01-plan.md
@@ -0,0 +1,355 @@
+# Multi-DB log routing — implementation plan
+
+**Status**: design locked, ready to file as issue + start Phase 1.
+**Target version**: `@davstack/logs-server@2.0.0` for Phase 1 (breaking: default path move).
+**Related**: closes / supersedes the design portion of #51 (session scoping). Builds on #52 (`logs_v` view, shipped in 1.4.0).
+
+## Motivation
+
+Today every log emitted by a project lands in `.davstack/logs.db`. Concurrent debug sessions (or just multiple bugs worked in the same repo) pile their logs into one file. Symptoms:
+
+- Probe-tag greps find hits from earlier unrelated sessions ("cross-session noise" — the user-facing problem in #51).
+- The cognitive cost of `WHERE ts > :baseline` scoping every query.
+- Eval runs that should keep their log output co-located with their test artifacts can't — logs go to a fixed global location.
+
+Each of these collapses if logs from a given context land in their own DB file. The DB file becomes the session boundary.
+
+A second benefit, equally load-bearing: **per-DB views**. With per-session DBs, agents and humans can `CREATE VIEW probe AS …` in the session DB with a probe vocabulary tailored to THAT bug — and cleanup is `rm` the file. This is the "temp views with auto-cleanup" idea, achieved by making the DB itself the session boundary instead of trying to scope views within a shared DB.
+
+## Out of scope (v1)
+
+**Cross-service routing.** When `--db=reorder-bug` is set, only logs from the frontend (which reads the value at boot) land in `reorder-bug.db`. Backend logs continue to route to `default.db`. The user's stack today is frontend-emission-only, so this isn't a felt loss. If/when cross-stack tracing becomes a concrete pain, design a v2.X to add it — likely either an explicit `X-Davstack-Db` header that backends propagate, or a daemon-side `trace_id → db` correlation cache. Both were considered for v1 and deferred: the header approach asks meaningful work of every backend service; the correlation cache is implicit-state magic that's hard to debug when it misbehaves. Wait for real cases.
+
+**Listing / cleanup tooling.** `ls .davstack/logs/` + `rm` are fine. No `logs-server db list / drop` verbs in v1. Revisit if friction shows up.
+
+**Sentry integration sub-package.** Not shipping `@davstack/logs-server/sentry`. The consumer wiring is small (3 lines in their `sentry.ts`); a package wrapper adds peer-dep / version-compat maintenance for marginal ergonomic gain. Document the snippet instead.
+
+## What we're building (high level)
+
+```
+[browser tab w/ frontend transmitter]
+    │ Sentry envelope POST (existing DSN, no transport changes)
+    │ each log envelope carries attributes['davstack-logs.db'].value if set
+    ↓
+[logs-server daemon @ :5181]
+    │ reads attributes['davstack-logs.db'].value from each log
+    │ validates + resolves to a path
+    │ getOrOpenDb(<resolved>) → cached Database handle
+    │ strips the routing attribute from data before persisting
+    │ first open: CREATE TABLE + idx + logs_v view (existing openDb)
+    ↓
+[.davstack/logs/<name>.db]   or escaped to e.g. <repo-root>/my-evals/run-1/logs.db
+```
+
+Persisted `data` is byte-for-byte the envelope's log record **minus the one daemon-managed routing key**. The DB filename IS the session indicator; nothing inside the row records which bucket it landed in.
+
+## File layout (post-2.0)
+
+```
+<repo-root>/
+  .davstack/
+    logs/
+      default.db          ← un-tagged emissions (no attribute set)
+      reorder-bug.db      ← runs with --db=reorder-bug
+      hotfix-7c.db
+      column-sync.db
+    config/               ← existing, untouched
+      logs-server.config.ts
+```
+
+Plus, when the `..` escape is used for eval co-location:
+
+```
+<repo-root>/
+  my-evals/
+    runs/
+      1779889134/
+        test-results.json
+        logs.db           ← --db=../../my-evals/runs/1779889134/logs
+  .davstack/
+    logs/
+      default.db          ← still here for un-tagged work
+```
+
+## Wire shape: a Sentry log attribute
+
+**Routing channel**: the Sentry log envelope attribute `davstack-logs.db` (value = the `--db` string).
+
+Why an attribute, not a header / URL param / DSN tweak:
+- The consumer (in their `sentry.ts`) already stamps attributes inside `beforeSendLog` for `diag.project` / `diag.run_id`. Adding one more line is the minimum-friction surface for them — no transport rewrite, no DSN change, no Sentry-SDK-internal customization.
+- Existing CORS / proxy / Sentry-SDK behavior unchanged — the wire shape is identical to what's already crossing it.
+- Value is an opaque string in the consumer's transmitter — `..` for the eval escape case just rides through as plain text. No URL encoding, no path-normalization surprises.
+
+The daemon does its own validation + resolution server-side; the consumer never needs to know the file-path semantics.
+
+Why `davstack-logs.db` and not `diag.db`: `diag.*` is a name-holdover from when the package was `diag` / `log-sink`. New attribute keys should use the current `@davstack/logs-server` identity. Existing `diag.project` / `diag.run_id` stay untouched (real consumers depend on those names).
+
+## `--db` value: validation pipeline
+
+The daemon receives one string. Pipeline:
+
+1. **Per-segment charset**: split on `/`, each segment must match `^[a-z0-9][a-z0-9_-]*$` (lowercase alnum, hyphen, underscore; no leading separator char). Segments `.` and `..` are allowed as path-traversal tokens (validated in step 4, not 1).
+2. **No absolute paths**: reject if value starts with `/` or matches `[A-Za-z]:` (Windows drive prefix).
+3. **Resolve to absolute**: `path.resolve(repoRoot, '.davstack/logs', value)`. `repoRoot` discovered by walking up for `pnpm-workspace.yaml` / `turbo.json` / `package.json#workspaces` / `.git`, capped at 8 levels — the same walker `loadConfig` already uses.
+4. **Containment check**: resolved path MUST start with `<repoRoot>/`. Anything resolving above `repoRoot` is rejected as "escapes repo."
+5. **Auto-append `.db`** if value doesn't already end in `.db`.
+6. **On reject**: log a single-line stderr warning (`[logs-server] invalid db "<value>": <reason>; routing to default.db`) and dispatch to `default.db` rather than failing. Warn-once per unique invalid value to avoid spam.
+
+### Examples
+
+| Input | Resolves to | Status |
+|---|---|---|
+| `reorder-bug` | `.davstack/logs/reorder-bug.db` | ✓ |
+| `feat/reorder` | `.davstack/logs/feat/reorder.db` | ✓ subdirs ok |
+| `../sandbox/x` | `.davstack/sandbox/x.db` | ✓ in repo |
+| `../../my-evals/run-1/logs` | `<repoRoot>/my-evals/run-1/logs.db` | ✓ in repo |
+| `../../../escaped` | `<above repoRoot>/escaped.db` | ✗ escapes repo |
+| `/etc/passwd` | absolute | ✗ |
+| `C:\evil` | abs (win) | ✗ |
+| `Reorder-Bug` | uppercase | ✗ |
+| `reorder bug` | space | ✗ |
+| `reorder-bug.db` | `.davstack/logs/reorder-bug.db` | ✓ (.db pre-supplied) |
+
+## Daemon implementation
+
+**In `envelope.ts` (or wherever the parser lives)**: after parsing each log item, extract the routing attribute and strip it from the persisted record.
+
+```ts
+// pseudocode in toRow()
+const routeKey = "davstack-logs.db"
+const dbName = rec.attributes?.[routeKey]?.value as string | undefined
+if (rec.attributes && routeKey in rec.attributes) {
+  delete rec.attributes[routeKey]   // strip before JSON.stringify(rec)
+}
+return {
+  ...,
+  data: JSON.stringify(rec),
+  _route_db: dbName,   // internal-only field, drives dispatch, not persisted
+}
+```
+
+**In `ingest.ts`**: group rows by `_route_db`, dispatch each group to the appropriate `Database` handle.
+
+```ts
+// pseudocode
+const groups = new Map<string | undefined, LogRow[]>()
+for (const r of stamped) {
+  const k = r._route_db
+  if (!groups.has(k)) groups.set(k, [])
+  groups.get(k)!.push(r)
+}
+let accepted = 0
+for (const [rawDbName, batch] of groups) {
+  const resolved = rawDbName ? resolveDbPath(rawDbName, ctx.repoRoot) : ctx.defaultDbPath
+  const db = ctx.handleCache.getOrOpen(resolved)
+  accepted += insertLogs(db, batch)
+}
+```
+
+**In `db.ts`** (or a new `db-cache.ts`): a `DbHandleCache` mapping `absolutePath → Database`.
+
+```ts
+// pseudocode
+class DbHandleCache {
+  private handles = new Map<string, { db: Database; lastUsed: number }>()
+  private idleCloseMs = 30 * 60 * 1000  // 30 min
+
+  getOrOpen(path: string): Database {
+    const cached = this.handles.get(path)
+    if (cached) {
+      cached.lastUsed = Date.now()
+      return cached.db
+    }
+    ensureParent(path)
+    const db = openDb(path)  // existing — runs CREATE TABLE + idx + logs_v view
+    this.handles.set(path, { db, lastUsed: Date.now() })
+    return db
+  }
+
+  startIdleSweeper() {
+    setInterval(() => {
+      const cutoff = Date.now() - this.idleCloseMs
+      for (const [p, entry] of this.handles) {
+        if (entry.lastUsed < cutoff) {
+          entry.db.close()
+          this.handles.delete(p)
+        }
+      }
+    }, 5 * 60 * 1000).unref()
+  }
+}
+```
+
+Schema-boot happens automatically via existing `openDb()` — every new DB file gets `CREATE TABLE logs`, the correlation index, and the `logs_v` view (from #52). No special-case code.
+
+**Default DB path**: `path.resolve(repoRoot, '.davstack/logs/default.db')`. Used when the attribute is absent or invalid.
+
+## Emission surfaces — how the value reaches the consumer
+
+### Browser (the only surface in v1)
+
+The runner sets a global before the app boots. The app reads it at `initSentry()` time and stamps it onto every log via the existing `beforeSendLog`.
+
+**Runner side (`playwright-server --db=<value>`):**
+
+```ts
+// pseudocode in playwright-server's spec-runner
+if (cliFlags.db) {
+  await page.addInitScript((dbName) => {
+    ;(window as any).__davstack_db = dbName
+  }, cliFlags.db)
+}
+await page.goto(spec.baseUrl)
+```
+
+`addInitScript` runs before any page script — so by the time the app's bundle starts and `initSentry()` runs, `window.__davstack_db` is already populated.
+
+**Consumer side (in their `sentry.ts`):**
+
+Three lines added next to the existing `diagRunId` setup:
+
+```ts
+// near the top, after diagRunId is captured
+const davstackDb = (window as { __davstack_db?: string }).__davstack_db ?? null
+
+// inside the existing beforeSendLog, alongside diag.project / diag.run_id
+log.attributes = {
+  ...log.attributes,
+  "diag.project": DIAG_PROJECT,
+  "diag.run_id": diagRunId,
+  ...(davstackDb && { "davstack-logs.db": davstackDb }),
+}
+```
+
+No transport rewrite. No DSN change. No URL param. No integration package import. Existing Sentry init unchanged otherwise.
+
+### Node (deferred — not in v1)
+
+Currently no node-side emitters in the user's stack. The same shape would apply if added later: `vitest-server --db=<value>` sets `process.env.DAVSTACK_DB` on the spawned child; the test process reads it at boot and stamps the attribute in its own `beforeSendLog`. No daemon changes needed — the wire is identical.
+
+## Phased landing
+
+### Phase 1 — daemon-side dispatch (logs-server 2.0.0)
+
+Self-contained, ships without touching any runner or transmitter.
+
+**Scope:**
+- `envelope.ts`: extract `davstack-logs.db` from attributes, strip from `rec` before persist, surface as internal `_route_db` field
+- `ingest.ts`: group-by-`_route_db` dispatch loop
+- `db.ts`: `DbHandleCache`, `resolveDbPath()`, validation
+- `openDb()`: unchanged (already creates the table + index + `logs_v` view; runs per DB)
+- Default path moves: `.davstack/logs.db` → `.davstack/logs/default.db`
+- `prune` verb: walks `.davstack/logs/*.db` instead of single file (`--db <name>` to scope to one if needed)
+- Docs updates (see Docs phase below)
+- Tests: dispatch routing, validation table cases, escape rules, cache idle-close, strip-before-persist verification
+- CHANGELOG `2.0.0` block with migration note
+
+**BC notes**: requests without the attribute (i.e. everyone today) route to `default.db` in the new location. The only breaking change is the path move — anyone with hardcoded `sqlite3 .davstack/logs.db` scripts updates to `sqlite3 .davstack/logs/default.db`. The `logs-server check` verb should detect a legacy `.davstack/logs.db` file at boot and print a one-line migration hint.
+
+**Not in this phase**: no runner flags, no transmitter changes, no node-side stamping. Phase 1 is a pure daemon upgrade. Until Phase 2/3 land, nobody is setting the attribute, so behavior is identical to today except the file moves into `logs/`.
+
+### Phase 2 — `playwright-server --db` flag
+
+One package, minor bump (likely `@davstack/playwright-server@1.4.0`):
+
+- Add `--db=<value>` CLI flag
+- In the spec-runner, if flag is set, call `page.addInitScript` to seed `window.__davstack_db` before navigation
+- Test: assert `window.__davstack_db` is set in the page context when the flag is passed
+
+~5–10 lines + a test.
+
+### Phase 3 — consumer wiring snippet
+
+Not a davstack ship — a docs deliverable. Add the 3-line snippet to `packages/logs-server/docs/transmitter-wiring.md` (see Docs phase). The user copies it into their app's `sentry.ts`.
+
+## Docs phase (lands with Phase 1)
+
+### Updates to existing docs
+
+- **`packages/logs-server/docs/reading-logs.md`**: revise opening to mention the per-DB layout. Replace `.davstack/logs.db` with `.davstack/logs/default.db` throughout. Add a "Choosing a DB" subsection explaining file-per-session, naming convention, opening the right one (`sqlite3 .davstack/logs/<name>.db`).
+- **`packages/logs-server/docs/setup.md`**: document the new default path. Note `pruneDays` semantics (per-DB or all-DBs, whichever we land on).
+- **`packages/logs-server/docs/writing-logs.md`**: add a short "Routing logs to a specific DB" section pointing to the new `transmitter-wiring.md` for the snippet.
+- **`packages/logs-server/README.md`**: one-line update to reflect the new default path in any inline example.
+- **`packages/logs-server/CHANGELOG.md`**: 2.0.0 entry with migration note.
+- **`~/dev/davstack/skills/*`**: audit any skill docs that reference the old `.davstack/logs.db` path or teach query patterns.
+
+### New doc: `packages/logs-server/docs/transmitter-wiring.md`
+
+How to wire your app's `sentry.ts` to honor `window.__davstack_db`. The single ~3-line snippet shown above + brief explanation of what each line does. Includes a one-paragraph note that backend logs (today) go to default DB, by design.
+
+### New doc: `packages/logs-server/docs/session-views.md`
+
+**The per-DB views guide.** This is the second load-bearing reason to ship multi-DB — each session DB is an isolated playground for session-specific views, with cleanup-via-`rm`.
+
+Content outline:
+
+1. **Why per-DB views are now safe**
+   - With one global DB, `CREATE VIEW probe AS …` would pollute every future query.
+   - With per-session DBs, the view lives in THAT bug's DB. When you `rm .davstack/logs/reorder-bug.db`, the views go with it.
+   - This achieves the "temp view with auto-cleanup" goal without SQLite's per-connection limitation.
+
+2. **The pattern**
+   - Pick a DB: `sqlite3 .davstack/logs/reorder-bug.db`
+   - Define a probe-vocabulary view at the start of the session:
+     ```sql
+     CREATE VIEW probe AS
+     SELECT id, ts, level,
+            json_extract(data, '$.body')               AS msg,
+            json_extract(attrs, '$.seam')              AS seam,
+            json_extract(attrs, '$.nextDims')          AS nextDims,
+            json_extract(attrs, '$.prevDims')          AS prevDims,
+            json_extract(attrs, '$.columnOrder')       AS columnOrder
+     FROM logs_v
+     WHERE msg LIKE '%[colorder-probe]%';
+     ```
+   - Every subsequent query becomes `SELECT … FROM probe …` — one cheap reference, no JSON-extract repetition.
+
+3. **Useful view shapes**
+   - `pre_fix` / `post_fix`: filter by `ts <` / `>=` a fix-application timestamp; compare side-by-side.
+   - `this_run`: `WHERE run_id = 'r-XYZ'` — scope to one run within the session.
+   - `errors_only`: convenience filter for an errors-with-context recipe.
+   - Pivot views when probes emit a fixed attribute set: rotate `attrs.<k>` into typed columns for `WHERE` ergonomics.
+
+4. **Lifecycle**
+   - Views persist across `sqlite3` invocations within the same DB file.
+   - Cleanup = delete the file: `rm .davstack/logs/<name>.db`.
+   - To drop just one view in a live session: `DROP VIEW probe;`.
+
+5. **Agent usage**
+   - If an agent is iterating in a session, the FIRST query of the iteration is `CREATE VIEW … IF NOT EXISTS` for the probe vocabulary; subsequent queries hit `FROM probe`. This is the agent-side hygiene equivalent of "stash the projection once, reuse it everywhere."
+   - Naming convention for agent-created views: prefix `dbg_` so they're easy to spot and drop in bulk (`SELECT name FROM sqlite_master WHERE type='view' AND name LIKE 'dbg_%'`).
+
+6. **Anti-patterns**
+   - Don't `CREATE VIEW` in `default.db` (or any sessionless DB). That view is now global noise.
+   - Don't rely on `CREATE TEMP VIEW` — it's per-connection and evaporates between sqlite invocations.
+
+## Open items / things to confirm before coding
+
+These have been discussed and tentatively decided, but worth a final pass before Phase 1 starts:
+
+1. **Charset rule**: `[a-z0-9_-]+` per segment (lowercase alnum + hyphen + underscore). Tentative. Hyphen + underscore both allowed; user said "might want an underscore at some point."
+2. **Validation reject behavior**: warn-on-stderr + route to default (friendly). Not fail-loud. Tentative — could be revisited if it masks typos in practice.
+3. **Idle-close timeout**: 30 min. Pick by feel; can tune. Memory cost of holding DB handles open is trivial; only reason to close is to free file descriptors.
+4. **What if the legacy `.davstack/logs.db` file exists at boot?** Tentative answer: print a warning, create the new default anyway, leave the legacy file orphaned. The `logs-server check` verb gets a row that flags the legacy file's presence with the migration command (`mv .davstack/logs.db .davstack/logs/default.db`).
+5. **`prune` verb scoping**: walk all DB files by default, or require `--db <name>`? Default to "all" seems closer to today's "one DB pruned" behavior — semantically the same global cleanup.
+
+## Test plan (Phase 1)
+
+Unit:
+- `resolveDbPath`: full validation table from above, every row a test case.
+- `DbHandleCache`: cache hit, miss, idle-close after configured timeout, parallel insert into same DB doesn't collide (WAL handles it).
+- Containment check: `..`, double-`..`, absolute paths, Windows drive prefixes — all rejected per the table.
+- Strip-before-persist: insert a log with `davstack-logs.db` attribute, assert the persisted `data` blob does NOT contain that key in its `attributes`.
+
+Integration:
+- Two `POST /envelope/` requests carrying different `davstack-logs.db` attributes → two DB files materialize with correct row counts.
+- Attribute-absent request → row in `default.db`.
+- Invalid value → stderr warning + row in `default.db`.
+- Backend service emits a log (no attribute) → row in `default.db` (regression test for "we didn't accidentally make backend logs disappear").
+
+E2E (after Phase 2):
+- `playwright-server --db=test-bug e2e/smoke.spec.ts` against a sample app that includes the transmitter snippet → rows land in `.davstack/logs/test-bug.db`, not `default.db`.
+
+## Filing
+
+Open a single issue (`feat(logs-server): per-DB log routing via davstack-logs.db attribute`) referencing this plan as the canonical design. Mark with `breaking-change` label given the 2.0 bump. Cross-link to #51 (closes if appropriate) and #52 (depends-on, already shipped).
diff --git a/notes/multi-db/02-per-run-routing-and-consumer-overhead.md b/notes/multi-db/02-per-run-routing-and-consumer-overhead.md
new file mode 100644
index 0000000..3029d6f
--- /dev/null
+++ b/notes/multi-db/02-per-run-routing-and-consumer-overhead.md
@@ -0,0 +1,185 @@
+# Per-run log-DB routing: header experiment (works) → the cleaner trace_id + integration design
+
+**Date:** 2026-06-03
+**Status:** Header approach PROTOTYPED + VALIDATED in traffease, then REVERTED. Recommended design (sink-side trace_id inference + Sentry integration packaging) NOT yet built. Pick up tomorrow.
+**Repos:** experiment ran in `~/dev/traffease_man` (branch `feat/full-stack-logs-infra`, PR #1229); real implementation home is `~/dev/davstack` (`@davstack/logs-server`).
+**Continues:** [`01-plan.md`](./01-plan.md)
+**⚠️ SUPERSEDED (2026-06-03):** the per-run **file-routing** direction below (Approach A/B/C) is
+replaced by [`03-clean-and-label-the-stateless-pivot.md`](./03-clean-and-label-the-stateless-pivot.md)
+— a single DB + a logical `label` (filter at query time) + a `clean` verb. The trace-propagation
+**foundation** here still holds (it's reused at query time); the **routing machinery** is demoted to
+an optional escape hatch. Read 03 first.
+
+---
+
+## 0. TL;DR
+
+- **Problem:** today the server tiers (Node, Python backend, Python agent) pick their sink DB from a **boot-time `LOGS_DB` env**, so to route a run into its own `.davstack/logs/<name>.db` you must set `LOGS_DB` on `docker compose up`. That pins the whole container to one DB → **can't run parallel runs through shared containers** (the actual goal).
+- **We proved** a per-request `x-davstack-db` **header** approach works end-to-end (logs *and* spans route per-request, no per-container env). See §2 for the validated result.
+- **But we're not shipping it:** it demands ~5 edit sites × every service in every consumer repo, and **structurally can't do WebSocket** (browsers can't set WS headers → the agent chat path is excluded). Wrong place for the complexity given we maintain the package and want **minimal consumer setup** (traffease + titanium + public sharing).
+- **Recommended instead (§3):** **sink-side `trace_id → db` inference.** `trace_id` is *already* propagated across all tiers by Sentry for free; the DB is decided once at the trace root (browser tab = the run). So don't propagate the DB at all — let the **sink** learn `trace_id → db` from the browser's already-stamped rows and route every same-trace row accordingly. **Zero server-tier consumer code. Solves WebSocket. Backward compatible.**
+- **Plus (§4):** package the *stamping* boilerplate (project / run_id / db-hint `before_send` hooks, ~100 lines per service today) as a **Sentry integration** `davstackLogs({ project })`. Routing stays sink-side; stamping shrinks to one init line.
+- **Open knobs (§6):** back-fill migration vs. buffering vs. accept-leak for pre-mapping rows; where the integration package lives.
+
+---
+
+## 1. Context / how routing works today
+
+- The sink dispatches **per-record**: every log/span envelope may carry a `davstack-logs.db` attribute; the sink writes that row to `.davstack/logs/<value>.db` (validated + sandboxed in `db-route.ts`), strips the key, else → `default.db`. Code path: `ingest.ts` → `stamp()` → `resolveTarget(routeDb, ctx)` → `resolveRoutedDb()`. `db.ts` already has a `trace_id` column (indexed) and `selectByTrace()`.
+- **Who stamps the routing key today:**
+  - **Browser (React):** from `window.__davstack_db` (set pre-page-load by the e2e fixture / devtools). → **already per-run.** `react/src/config/sentry.ts` `beforeSendLog` + `beforeSendTransaction`.
+  - **Node / backend / agent:** from **`env.LOGS_DB`** (boot-time constant) in their `beforeSend(Transaction|Log)` hooks. → **per-container.**
+- **Backend already has more machinery than the others:** `backend/src/config/diag_logs.py` has a `_logs_db` **ContextVar** that *wins over* the env (`resolve_logs_db()` precedence: ContextVar > `LOGS_DB` env > None), plus a `logs_db()` context manager (used by the eval `--db` flag) and `ROUTE_DB_ATTR = "davstack-logs.db"`. Agent + Node only read env.
+
+So routing is *already per-record* — the only reason it's "per-container" is that 3 tiers stamp a **constant**. Make them stamp a **per-run** value and parallelism falls out. The header experiment does that via the request; the recommended design does it via the trace.
+
+---
+
+## 2. What we tried: per-request `x-davstack-db` header (Approach A) — WORKS, but reverted
+
+### Mechanism
+Browser stamps `x-davstack-db: <window.__davstack_db>` on every outgoing HTTP request; each server reads it per-request and routes that request's logs+spans to `<db>.db`. React calls all three backends **directly** (star topology, not a chain) — `VITE_BACKEND_URL`=node, `VITE_AGENT_API_ROOT`=agent, `VITE_AGENTFLOW_API_URL`=backend — so mostly the browser stamps + each server reads; server↔server propagation is a smaller secondary concern.
+
+### The one non-obvious technical win (keep this knowledge)
+**Backend middleware must be pure-ASGI, not `BaseHTTPMiddleware`.** Sentry's `before_send_transaction` fires at **transaction-finish**, which is *after* a `BaseHTTPMiddleware.dispatch` returns (Starlette runs the app in a child task → the ContextVar binding is gone by the time the txn is serialized → **span routing silently lost**, though *logs* would still route since they're emitted mid-request). A **pure-ASGI** middleware sets the ContextVar in the *same* async context Sentry finishes the transaction in → both logs AND spans route. **This was the main risk and it's now empirically dead** (see below).
+
+### Validated result (real, this session)
+- Backend restarted with `ENABLE_LOGS=1`, **no `LOGS_DB`**. Fired 5 requests with `x-davstack-db: hdrtest1` + 3 without.
+- `hdrtest1.db` got exactly **5 logs + 5 spans, project `traffease-backend`**; the 3 header-less control requests did **not** leak in. → per-request routing works for both logs and spans, with zero env.
+- Earlier in the session we also confirmed (compose-tagged run) that one `trace_id` spans react+node+backend, and that **server rows carry the browser's `trace_id` even with no routing code** — this is the foundation Approach C relies on (§3).
+- **Cross-stack re-validation (a separate Next.js app [titanium]):** independently confirmed the same foundation on a different stack/topology by querying that app's local sink — found **344 distinct `trace_id`s shared between confirmed browser rows and server rows**. Browser rows were positively identified by client-only console output (React DevTools notice / Fast Refresh / hydration warnings); server rows by a server-only `server.address` attribute. So browser→server `trace_id` propagation — the thing Approach C stands on — is **not stack-specific**: it holds on Next.js (Sentry's server SDK continues the browser's trace via the `sentry-trace`/`baggage` headers) where the topology is browser → middleware/edge → RSC/route-handlers, not traffease's star. (Two caveats found there, now resolved — see 03 §8: browser shipped *logs but not spans* — a **config gap**, fixed by enabling `browserTracingIntegration` on the client, not a limitation; and trace grain is **per-pageload/navigation** — fine for run/session/`db`/`label` keying, too coarse for per-test.)
+
+### Why we reverted it (the adoption argument)
+- **Consumer surface is the worst of all options:** per service you write inbound-read + scope-binding + outbound-propagation + (Node) a CORS allowlist entry; the browser needs an HTTP-client interceptor. ~5 sites × N services, replicated in every adopting repo.
+- **WebSocket is structurally excluded:** browsers can't set custom headers on `WebSocket`. The agent chat path is raw WS → never covered by a header scheme.
+- We maintain `@davstack/logs-server` and want **minimal consumer setup**. Header plumbing is the opposite.
+
+### Exact diff we reverted (recoverable — re-apply if ever needed)
+
+> 5 files, +90/−6. All gated so prod is byte-identical (`diag_logs_enabled()` / `logsEnabled`). Reverted via `git restore` on branch `feat/full-stack-logs-infra` (these were uncommitted working-tree edits on top of the committed PR).
+
+```diff
+# backend/src/config/diag_logs.py  — pure-ASGI middleware + header const
++ROUTE_DB_HEADER = b"x-davstack-db"
++
++class LogsDbRoutingMiddleware:
++    """Pure-ASGI (NOT BaseHTTPMiddleware): ContextVar set survives to
++    before_send_transaction at txn-finish, so SPAN routing works."""
++    def __init__(self, app): self.app = app
++    async def __call__(self, scope, receive, send):
++        if scope.get("type") in ("http", "websocket"):
++            for key, value in scope.get("headers") or []:
++                if key == ROUTE_DB_HEADER:
++                    db = value.decode(errors="ignore").strip()
++                    if db: _logs_db.set(db)
++                    break
++        await self.app(scope, receive, send)
+
+# backend/src/app/middleware.py  — wire it in, gated
++def configure_logs_db_routing(app):
++    if diag_logs_enabled():
++        app.add_middleware(LogsDbRoutingMiddleware)
+# ...called in configure_middleware() between event_context and exception_handlers
+
+# react/src/lib/axios/axios.ts  — forward the header from window.__davstack_db (all 3 Orval clients funnel through addAuthHeaders)
++const addDavstackDbHeader = (config) => {
++  const db = (window as Window & { __davstack_db?: string }).__davstack_db
++  if (db) config.headers["x-davstack-db"] = db
++}
+# ...addDavstackDbHeader(config) appended inside addAuthHeaders()
+
+# node/src/server.ts  — CORS allow + scope-bind middleware
+-allowedHeaders: ["Content-Type", "Authorization", "sentry-trace", "baggage"]
++allowedHeaders: ["Content-Type", "Authorization", "sentry-trace", "baggage", "x-davstack-db"]
++app.use((req, _res, next) => {
++  const db = req.headers["x-davstack-db"]
++  if (typeof db === "string" && db) Sentry.getCurrentScope().setTag("davstack-logs.db", db)
++  next()
++})
+
+# node/src/config/sentry.ts  — per-request tag wins over env in stampDiagOnTransaction
++const perRequestDb = tx.tags?.["davstack-logs.db"]
++const logsDb = (typeof perRequestDb === "string" && perRequestDb) || env.LOGS_DB
++if (tx.tags) delete tx.tags["davstack-logs.db"]
+```
+
+> Agent tier was **not** implemented (would need the ContextVar machinery the backend has + a FastAPI middleware + the unsolved WS path). Deliberately stopped before it once the strategy pivoted.
+
+---
+
+## 3. Recommended: sink-side `trace_id → db` inference (Approach C)
+
+### The insight
+Sentry **already propagates `trace_id`** across every hop, free, zero consumer code (it's the cross-service-join key that already works). The DB is chosen **once at the trace root** (the browser tab = one run) and is constant for the whole trace. So **don't propagate the DB name at all** — associate `trace_id → db` once and let the sink route.
+
+### Mechanism (all in `@davstack/logs-server`)
+1. Browser stamps `davstack-logs.db` on **its own** rows — **already happens** (from `window.__davstack_db`).
+2. Sink keeps an in-memory `Map<trace_id, routeDb>`. On ingest, if a row carries both `trace_id=T` and `davstack-logs.db=D` → learn `T → D`.
+3. Any row (from *any* tier) with `trace_id=T` and **no** explicit route → route to `D` via the map.
+4. Rows that already landed in `default.db` before the mapping was learned → **back-fill** (`INSERT…SELECT` into `D.db` + `DELETE` from default) when `T → D` is first seen.
+
+Slot-in point: `resolveTarget(routeDb, ctx)` in `ingest.ts` (consult the map when `routeDb` is absent); learning + back-fill hang off the same ingest loop. `db.ts` already has `selectByTrace()` for the migration query.
+
+### Why this is the right call
+- **Server-tier consumer code: ZERO.** No middleware, no CORS, no header, no `before_send` routing. They emit normal trace-correlated envelopes (already do).
+- **Solves WebSocket / agent for free:** the agent's spans already carry the bridged `trace_id` (`agent_traces.sentry_trace_id` in the PR) → they route correctly with no agent code. The thing the header approach *couldn't* do.
+- **Backward compatible & additive:** explicit `davstack-logs.db` (env-based `LOGS_DB`, pytest `--db`, browser stamp) still works and takes precedence; inference only fills the gap.
+- **Complexity lives once, in the package we own** — not copied into every adopter forever.
+
+### Cost / risks
+- **Sink becomes stateful** (the map + back-fill). Bound it: TTL / LRU on the map (dev-only, fine).
+- **Ordering race:** server rows for `T` can arrive before the browser's `D`-stamped row. Browser usually starts the trace first, but server spans flush at request-end. Back-fill self-heals it; the design knob (§6) is whether to back-fill, buffer briefly, or accept a small leak to `default.db`.
+- A trace mapping to two DBs "shouldn't happen" (DB is per-tab-run) — assert/last-writer-wins.
+
+---
+
+## 4. The other half: a `davstackLogs()` Sentry integration (packaging the stamping)
+
+Routing is only half the consumer pain. The *other* half is that today **every service hand-writes ~100 lines** of `before_send_log` / `before_send_transaction` to stamp `diag.project`, `diag.run_id`, and the db hint (see `react/src/config/sentry.ts`, `node/src/config/sentry.ts`, `backend|agent/src/config/sentry.py` — all near-duplicates).
+
+Package that as a **Sentry integration** per platform (browser / node / python):
+
+```ts
+// target consumer surface — per service, this is the WHOLE setup:
+Sentry.init({
+  dsn: davstackSinkDsn(),                       // helper: dev → local sink, prod → real DSN
+  integrations: [davstackLogs({ project: "myapp-web" })],
+})
+```
+
+What the integration does (event processors, not consumer code):
+- stamp `diag.project` (from the one config arg) on logs + span data,
+- stamp `diag.run_id` (browser: per-page-load uuid + `window.__diagRunId`),
+- browser only: stamp the `davstack-logs.db` hint from `window.__davstack_db` — **this is the single feeder for Approach C.**
+
+**Keep routing OUT of the integration.** An integration can't cleanly propagate a custom key across services (that's Approach B / baggage — see §5, fragile). Routing belongs sink-side (§3). The integration only owns *stamping*.
+
+Net consumer overhead after C + integration: **routing → 0 lines; stamping → 1 integration line per service; DSN → 1 helper call.** Down from ~100 lines × N services + per-container env.
+
+---
+
+## 5. Approach B (Sentry baggage) — considered, parked
+
+Put the db in Sentry **baggage** (W3C baggage / DSC): Sentry auto-propagates `baggage` outbound+inbound, and CORS already allows it (the PR added it for tracing). DSC is frozen at trace root — which actually *fits* (db is constant per trace).
+
+**Why parked, not chosen:** relies on Sentry propagating **third-party (non-`sentry-`) baggage items** end-to-end, which is SDK-version-dependent and underdocumented across the three SDKs we use (browser/node/python, mixed v8/v9). You'd still need an integration to inject at the root + read downstream + stamp. More moving parts and more fragility than §3 for the *same* outcome. **Fallback only** if trace-inference (§3) proves too racy in practice.
+
+---
+
+## 6. Decisions / open questions for tomorrow
+
+1. **Build order:** (a) prototype C in `~/dev/davstack` and re-validate the parallel-e2e with zero server config, then (b) the `davstackLogs()` integration. Probably C first (unblocks the real goal).
+2. **Pre-mapping rows knob:** back-fill migration (self-healing, more code) **vs.** brief buffering window **vs.** accept-leak-to-default (simplest). Recommend back-fill; it's bounded and gives correct files.
+3. **Integration packaging:** new package(s) vs. part of the existing logs-server client surface? Three runtimes (browser/node/python) — python can't live in an npm package, so at least a `davstack-logs` PyPI shim is implied. Scope this.
+4. **`davstackSinkDsn()` helper:** ship per-platform helpers so the DSN line is also boilerplate-free.
+5. **titanium check:** validate the target surface against titanium's setup so we don't design only for traffease.
+6. **Map bound:** TTL/LRU sizing for `trace_id → db` (dev volumes are small; pick something boring).
+
+---
+
+## 7. State left behind (for clean resume)
+
+- **Code:** the §2 diff was **reverted** (`git restore` on the 5 files). Branch `feat/full-stack-logs-infra` is back to its committed state. The browser's existing `davstack-logs.db` stamping is **untouched** (it's the feeder for C).
+- **Containers:** `node` / `backend` / `agent` left running with `ENABLE_LOGS=1`, **no `LOGS_DB`** (so → `default.db`). To fully restore the pre-session state, recreate without `ENABLE_LOGS`.
+- **Sink test DBs created this session** (`hdrtest1.db`, `qbtrace.db`, `bug-5.db`) can be deleted from `traffease_man/.davstack/logs/`.
+- **Untracked in traffease:** `PR-1229-how-to-use.md` (the rewritten "How to use it" section for PR #1229 — separate, unrelated workstream).
diff --git a/notes/multi-db/03-clean-and-label-the-stateless-pivot.md b/notes/multi-db/03-clean-and-label-the-stateless-pivot.md
new file mode 100644
index 0000000..9e89830
--- /dev/null
+++ b/notes/multi-db/03-clean-and-label-the-stateless-pivot.md
@@ -0,0 +1,286 @@
+# The stateless pivot: drop per-file routing → `label` (filter) + `clean` (size)
+
+**Date:** 2026-06-03
+**Status:** DESIGN AGREED, not yet built. Supersedes the routing direction in
+[`02-per-run-routing-and-consumer-overhead.md`](./02-per-run-routing-and-consumer-overhead.md)
+(Approaches A/B/C). The empirical foundation from 02 (browser→server `trace_id`
+propagation, incl. the cross-stack Next.js re-validation) **still holds and is reused** —
+just at query time instead of ingest time.
+**Repo:** `~/dev/davstack` (`@davstack/logs-server`).
+
+---
+
+## 0. TL;DR
+
+- **Decision:** abandon **physical per-run DB-file routing** (02's Approach A/B/C). It was
+  meant to *simplify* the workflow but did the opposite. Replace it with two small,
+  **stateless, local, independent** primitives:
+  1. **`label`** — a free-form annotation stamped **once at the source** (browser), used to
+     **filter at query time** via a `trace_id` self-join. Zero server-tier code.
+  2. **`clean`** — a CLI verb + auto-clean loop that bounds the working DB's size
+     (archive-or-delete old rows, then vacuum).
+- **The core insight:** physical routing forced the sink to decide *which file* a row goes to
+  **at ingest** — before the browser's stamp may have arrived. *That* is the single source of
+  all of 02's complexity (stateful `trace_id→db` map, back-fill, ordering race). Drop routing
+  and the decision moves to **query time**, where the data is already complete → **the sink
+  goes back to being dumb.**
+- **`label` and `clean` are complementary, not redundant.** `label` = *logical* isolation
+  (keep history, look back at past runs, compare — without deleting). `clean` = *physical*
+  hygiene (a true slate when you want one; bounded disk). Having both means you **don't have to
+  clean on every run** to stay un-confused.
+- **Consumer surface:** deliberately minimal — server tiers stamp **nothing** (joined in by
+  trace); only the browser stamps `label`. Packaging that into an integration + DSN helper is
+  **deferred** (see §6) — not building a custom abstraction now.
+
+---
+
+## 1. Why we're pivoting (the complexity audit)
+
+Per-run **file** routing (`.davstack/logs/<name>.db`) sounded like clean isolation. In
+practice it dragged in (all documented in 02 §3/§6):
+
+- the sink must become **stateful** — an in-memory `Map<trace_id, db>`;
+- it needs **back-fill** — moving rows that landed in `default.db` before the mapping was
+  learned;
+- it has an **ordering race** — server spans flush at request-end, often *before* the
+  browser's db-stamped row arrives.
+
+Every one of those exists for a single reason: **a physical file must be chosen the instant a
+row is ingested**, and at that instant the routing value may not have been seen yet.
+
+A **metadata tag** has none of that pressure. It just rides on the row; the sink stores it and
+moves on (it already stores arbitrary `attrs`). You decide what to *do* with it — filter,
+group — **later, at query time, when every row is already present.** No map, no back-fill, no
+race. The sink stays stateless.
+
+So: routing-to-simplify backfired. Tag-and-filter is both simpler *for the user* and *far*
+less machinery *in the package*. The test we'll hold every piece of this design to:
+**does it keep the sink stateless?** If a feature reintroduces the map/back-fill/race, it's
+the wrong feature.
+
+---
+
+## 2. The `label` primitive
+
+### 2.1 Name
+Call it **`label`**. Not `tag` — the `logs` table already has a `tag` column for **row-type**
+tags (`server-fn`, `test-boundary`, `action`); overloading it will confuse every query. Not
+`run` — collides with the existing `run_id` (process/page-load uuid). `label` is unambiguous:
+*a free-form annotation the human chose for this run.*
+
+### 2.2 How it's set & propagated (one place)
+Identical mechanism to the browser's existing `davstack-logs.db` stamp — which already works:
+
+1. Source sets it: e.g. `LABEL=login-bug pnpm playwright …` → the e2e fixture reads
+   `process.env.LABEL` and sets `window.__davstack_label` (via `addInitScript`), exactly like
+   `window.__davstack_db` today. For manual browsing, set it from devtools or leave it absent.
+2. The browser's `beforeSendLog` / integration stamps `attrs.label` on **its own** rows.
+3. **That's it.** Server tiers stamp nothing. They are correlated in by `trace_id` (validated:
+   server rows carry the browser's trace — 02 §2 + the Next.js cross-stack re-validation).
+
+### 2.3 How it's queried (the whole "routing" replacement)
+Resolution is a query-time self-join on the validated key:
+
+```sql
+-- everything belonging to a labelled run, across all tiers
+SELECT l.*
+FROM logs l
+WHERE l.trace_id IN (
+  SELECT DISTINCT trace_id
+  FROM logs
+  WHERE json_extract(attrs, '$.label') = :label
+    AND trace_id IS NOT NULL AND trace_id != ''
+);
+```
+
+A CLI verb (`logs --label <x>`) wraps this; optionally a `labelled_logs` VIEW. **The sink does
+nothing special for labels** — it only needs the value present on ≥1 row per trace (the browser
+row). Server rows stay lean; they're pulled in by the join. Storage cost: the label is
+denormalised onto browser rows only (a small fraction of rows).
+
+### 2.4 Why keep `label` *and* `clean`
+- `label` lets you **retain and revisit** past runs and still tell them apart — so you're not
+  forced to `clean` before every single run just to avoid confusion.
+- `clean` gives a **true empty slate** and **bounds disk** — things filtering can't do.
+
+They cover different needs; neither subsumes the other.
+
+---
+
+## 3. The `clean` verb + auto-clean
+
+Bounds the working DB and provides the "fresh slate for this repro" move. **Manual** and
+**auto** are deliberately *different sweeps*:
+
+| | Trigger | Scope | Honors `autoCleanWindow`? |
+|---|---|---|---|
+| **Manual `clean`** | CLI, on demand | **full sweep** → fresh empty hot DB | **No** — you want it *all* gone (a slate) |
+| **Auto-clean** | daemon timer, every `autoCleanInterval` | rows older than `autoCleanWindow` | **Yes** |
+
+Both honor `cleaningMode` and **both must `VACUUM`** afterward.
+
+### 3.1 Config (in logs-server config)
+- `autoCleanInterval` — how often the daemon sweeps, e.g. `"10m"`. **Unset → auto-clean off.**
+- `autoCleanWindow` — retention, e.g. `"24h"`. **Default `"24h"`** (deliberately *not* `1h`:
+  aggressive windows can delete logs mid-session if you step away; 24h is safe, and you use
+  manual `clean` when you actually want a slate).
+- `cleaningMode` — `"archive" | "delete"`.
+
+Manual `clean` may take `--window` / `--mode` overrides, but defaults to full sweep + the
+configured `cleaningMode`.
+
+### 3.2 The reclaim gotcha (don't skip)
+SQLite `DELETE` **does not shrink the file** — 311 MB stays 311 MB until you `VACUUM`. So:
+
+- `delete` mode = `DELETE …` **+ `VACUUM`** (or run with `PRAGMA auto_vacuum=INCREMENTAL` set
+  at DB creation + `PRAGMA incremental_vacuum`).
+- `archive` mode = write the archive file → `DELETE` the rows → **`VACUUM`**.
+
+`VACUUM INTO '<path>'` conveniently produces a clean, defragmented copy in one step — useful for
+the archive write (§4). VACUUM briefly takes a write lock; at dev volumes that's a non-issue,
+but it's why the daemon (not an ad-hoc process) should own the timer.
+
+---
+
+## 4. Archive format — lightest, never queried, no new dependency
+
+Assumption (stated by design): **archives are just-in-case cold storage; we will not query
+them**, and they may get **big**. So optimize purely for **small + simple**, not for
+queryability.
+
+- **Skip parquet.** Its only edge is columnar query via DuckDB/pandas — a toolchain we'd never
+  use here, bought at the cost of leaving the `sqlite3` world.
+- The data is wildly repetitive (same `attrs` keys, `sentry.sdk.name`, `server.address` on every
+  row) → it compresses **10–20×**. **Compression is the whole game; the container barely
+  matters.**
+- The sink is **Node**, whose stdlib `zlib` ships **Brotli** — excellent ratio, **zero extra
+  dependency**.
+
+**Chosen:** `sqlite3 .dump` (SQL text) → Brotli → `logs/archive/<timestamp>.sql.br`. Text dump
+compresses best of all *and* carries no index bloat (indexes are just `CREATE` statements).
+Restore if ever needed: `brotli -d < x.sql.br | sqlite3 restored.db`.
+
+**Noted alternative (slightly bigger, zero reopen-friction):** `VACUUM INTO <ts>.db` → Brotli →
+`<ts>.db.br` — decompress and it's openable as a normal DB. Pick this only if "peek without
+restoring" turns out to matter.
+
+---
+
+## 5. The workflow this enables
+
+- **Routine:** let **auto-clean** (24h) handle accumulation. You generally don't think about it.
+- **Look back / compare:** runs you care about carry a **`label`** → filter past runs out of the
+  retained 24h window without having cleaned between them.
+- **Focused debug:** run **`clean`** to get a slate, then run the one repro, then read
+  everything (no label even needed at that point). Optionally also `LABEL=<x>` it so it survives
+  in the archive/history meaningfully.
+
+**Cautions baked into the design:**
+1. **`clean` is a *before-you-observe* action.** Do **not** put it at the *end* of an e2e
+   script — that deletes exactly the logs you'd debug a failure with. Put it at the **start** of
+   a focused run; rely on auto-clean for routine growth.
+2. Skill guidance: when an agent is debugging and wants to disambiguate, it runs `clean` (or
+   filters by `label`) **first**, not after.
+
+---
+
+## 6. Consumer surface — DEFERRED (future consideration)
+
+> **Status: not building this now.** No custom Sentry integration, no `davstackSinkDsn()`
+> helper. Decision parked. This section records the research so picking it up later is cheap.
+> For now, the small amount of consumer-side stamping `label` needs (§2.2) can be a few inline
+> lines; we are explicitly *not* introducing a package abstraction yet.
+
+The eventual idea (future): package the per-service `beforeSend*` boilerplate as a
+`davstackLogs({ project })` Sentry integration + a `davstackSinkDsn()` helper, so consumer setup
+is ~one init line:
+
+```ts
+// FUTURE — not implemented; illustration only
+Sentry.init({
+  dsn: davstackSinkDsn(),                 // dev → local sink, prod → real DSN
+  integrations: [davstackLogs({ project: "myapp-web" })],
+})
+```
+
+### What belongs where (research, for when we revisit)
+
+**Governing fact:** Sentry **log records and span data do NOT inherit `initialScope` tags** —
+only *error events* do. So any custom attribute on logs/spans (`label`, `run_id`, `project`)
+**must** be stamped in `beforeSendLog` / `beforeSendTransaction` (or an integration
+event-processor); there is no scope shortcut. (This is *why* `beforeSend*` exists in titanium
+and traffease today.)
+
+`beforeSend*` does three separable jobs — keep them distinct when deciding what to cut:
+
+1. **Correlation stamping** — `project` / `run_id` / `label` onto logs + spans.
+2. **Routing** — the `davstack-logs.db` hint. **Demoted by this design.**
+3. **Noise hygiene** — drop prod debug logs; **drop Sentry's own `"Sentry Logger ["` chatter**
+   (a real feedback-loop guard: `consoleLoggingIntegration` would otherwise re-ingest Sentry's
+   debug output); ignore internal-user error events.
+
+Where each piece lands under this architecture:
+
+| Piece | Verdict | Why |
+|---|---|---|
+| **Server-tier `beforeSend*` (correlation)** | **delete entirely** | server rows correlate by `trace_id` (auto); the server is downstream of "stamp once at the source" — it needs to stamp nothing |
+| **`davstack-logs.db` hint** | **gone** | routing demoted to escape hatch |
+| **`run_id`** | **drop** (or keep as free auto-grouping) | `label` (human) + `trace_id` (correlation) supersede it |
+| **`project`** | **multi-service sinks only** | traffease's 4 tiers need it; for a single app `server.address` already separates client/server |
+| **`label` (browser stamp)** | **the one must-keep** *if* we want look-back filtering | logs don't inherit scope, so it must be stamped on browser rows; ~3 lines or the integration's browser processor |
+| **Noise guards** | **keep regardless** | not correlation; the chatter guard prevents a feedback loop |
+
+**Implication for the future integration:** its real remaining weight is **browser-side** (the
+`label` stamp + noise guards + the DSN helper). **Server-side it is near-empty.** So when we
+revisit, the open question is narrow: build the integration at all, or keep a tiny inline
+browser `beforeSendLog`? Either way, *everything server-side comes out.*
+
+---
+
+## 7. Empirical foundation (reused, not re-litigated)
+
+- Browser→server `trace_id` propagation is **confirmed** (02 §2 in traffease's node/py/react;
+  cross-stack re-validated on a Next.js app — **344 distinct trace_ids shared** between
+  confirmed-browser and server rows). This is the join key §2.3 stands on. Now used at **query
+  time**, which is strictly easier than the ingest-time use Approach C needed.
+- Browser **spans** reach the sink **once `browserTracingIntegration` is enabled** on the client
+  (verified: `pageload`/`navigation` + child spans land). So the label feeder can be any browser
+  row (log or span). (Earlier "browser ships logs but not spans" was a *config gap*, not a
+  limitation.)
+
+---
+
+## 8. Caveats & limits (honest)
+
+- **Trace grain is per-pageload/navigation.** Great for *per-run / per-session / per-db* labels;
+  **too coarse to key per-test** (one session-trace can span many tests; e.g. a single trace
+  observed spanning many Fast-Refresh cycles). Don't try to make `label` a per-test key — that's
+  the grain trap from 02.
+- **`label` only resolves browser-rooted traces.** A purely server-originated trace (background
+  job, server→server call that starts its own trace, no browser ancestor) has no browser row
+  carrying the label → unresolvable by label. Small tail for browser-driven work; fall back to
+  time-slicing or `clean`-slate for those.
+- **VACUUM** briefly write-locks; keep it on the daemon timer, fine at dev volumes.
+- **Operational:** the daemon can wedge into "HTTP 200 but persists 0 rows" (stale DB handle).
+  Fix observed: `logs-server refresh --hard`. Worth a doctor check + maybe an auto-heal.
+
+---
+
+## 9. What this supersedes / open questions
+
+- **Supersedes** 02's recommendation to build Approach C routing. Physical `db` routing (the
+  existing `db-route.ts` / `davstack-logs.db` stamp) is **demoted to an optional explicit escape
+  hatch** (`DB=` for the rare "I really want a separate file"), **not** the default and **not**
+  the thing we keep investing in. Candidate for eventual removal once `label` + `clean` prove
+  out — decide later; no need to rip it out now.
+- **Build order:** (1) `clean` + auto-clean + VACUUM (highest leverage — bounds the DB, enables
+  the slate workflow, zero consumer change); (2) `label` end-to-end (a **tiny inline browser
+  `beforeSendLog`** stamp for now + `logs --label` query). **Deferred / future (see §6):**
+  packaging the stamp as a `davstackLogs()` integration and a `davstackSinkDsn()` helper — not
+  building now.
+- **Open knobs:** exact CLI flags for `clean`; whether `label` should *also* be settable
+  server-side via a header for server-originated traces (only if the §8 tail bites); archive
+  retention/rotation in `logs/archive/` (cap count? age?); whether to expose a `labelled_logs`
+  VIEW vs a CLI flag only.
+- **Skill integration:** wire "`clean` at the start of a repro / filter by `label`" into the
+  debugging skill's guidance (consumer-side, e.g. titanium), not the package.

From c6eb9547122069e6ea9bd60d40f140ea8f88de75 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:19:39 +0100
Subject: [PATCH 17/72] test: add open agents handoff eval smoke

---
 .gitignore                                    |   1 +
 .../fixtures/nextbase-supabase-starter.json   |  12 ++
 .../open-agents/evals/promptfooconfig.yaml    |  20 +++
 .../evals/prompts/a-main-agent-spec.md        |  16 +++
 .../evals/prompts/b-title-tail-history.md     |   7 ++
 .../c-spec-writer-title-tail-history.md       |  11 ++
 .../evals/scripts/prepare-fixture.mjs         | 117 ++++++++++++++++++
 .../evals/scripts/promptfoo-provider.mjs      |  57 +++++++++
 8 files changed, 241 insertions(+)
 create mode 100644 packages/open-agents/evals/fixtures/nextbase-supabase-starter.json
 create mode 100644 packages/open-agents/evals/promptfooconfig.yaml
 create mode 100644 packages/open-agents/evals/prompts/a-main-agent-spec.md
 create mode 100644 packages/open-agents/evals/prompts/b-title-tail-history.md
 create mode 100644 packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
 create mode 100644 packages/open-agents/evals/scripts/prepare-fixture.mjs
 create mode 100644 packages/open-agents/evals/scripts/promptfoo-provider.mjs

diff --git a/.gitignore b/.gitignore
index f56f4db..bc88dd4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,5 +13,6 @@ public/dist
 .turbo
 coverage
 .folder-meta.generated.md
+.davstack/evals/
 /temp
 paper.md
diff --git a/packages/open-agents/evals/fixtures/nextbase-supabase-starter.json b/packages/open-agents/evals/fixtures/nextbase-supabase-starter.json
new file mode 100644
index 0000000..4df28ca
--- /dev/null
+++ b/packages/open-agents/evals/fixtures/nextbase-supabase-starter.json
@@ -0,0 +1,12 @@
+{
+  "id": "nextbase-supabase-starter",
+  "repo": "https://github.com/imbhargav5/nextbase-nextjs-supabase-starter.git",
+  "commit": "1c71bece81a15dd855196d2c1c5479271ea9f990",
+  "description": "Pinned Next.js/Supabase starter fixture for open-agents handoff evals.",
+  "setup": ["pnpm install --frozen-lockfile"],
+  "verify": ["pnpm typecheck", "pnpm test"],
+  "notes": [
+    "First spike fixture. Keep cloned repos and run artifacts out of git.",
+    "Promptfoo artifact layout is still provisional; this manifest only pins source identity."
+  ]
+}
diff --git a/packages/open-agents/evals/promptfooconfig.yaml b/packages/open-agents/evals/promptfooconfig.yaml
new file mode 100644
index 0000000..887532e
--- /dev/null
+++ b/packages/open-agents/evals/promptfooconfig.yaml
@@ -0,0 +1,20 @@
+description: Open-agents handoff fixture smoke eval
+
+prompts:
+  - file://prompts/a-main-agent-spec.md
+  - file://prompts/b-title-tail-history.md
+  - file://prompts/c-spec-writer-title-tail-history.md
+
+providers:
+  - 'exec: node ./scripts/promptfoo-provider.mjs'
+
+tests:
+  - vars:
+      fixture: nextbase-supabase-starter
+      scenario: fixture-prepare-smoke
+      tailChars: 50000
+    assert:
+      - type: contains
+        value: '"ok":true'
+      - type: contains
+        value: '"fixture":"nextbase-supabase-starter"'
diff --git a/packages/open-agents/evals/prompts/a-main-agent-spec.md b/packages/open-agents/evals/prompts/a-main-agent-spec.md
new file mode 100644
index 0000000..efcb537
--- /dev/null
+++ b/packages/open-agents/evals/prompts/a-main-agent-spec.md
@@ -0,0 +1,16 @@
+# Variant A: Main-Agent Written Spec
+
+<goal>
+Prepare the pinned fixture repo and report whether the checkout is available for
+open-agents handoff testing.
+</goal>
+
+<context>
+This prompt stands in for the current baseline where the main agent writes a
+detailed execution spec before delegating.
+</context>
+
+<scope>
+Fixture: {{fixture}}
+Scenario: {{scenario}}
+</scope>
diff --git a/packages/open-agents/evals/prompts/b-title-tail-history.md b/packages/open-agents/evals/prompts/b-title-tail-history.md
new file mode 100644
index 0000000..6066aca
--- /dev/null
+++ b/packages/open-agents/evals/prompts/b-title-tail-history.md
@@ -0,0 +1,7 @@
+# Variant B: Title + Tail + History Pointer
+
+Task: prepare fixture {{fixture}} for scenario {{scenario}}.
+
+Recent history tail budget: {{tailChars}} chars.
+
+Full history pointer: not wired in this smoke slice.
diff --git a/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md b/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
new file mode 100644
index 0000000..5f9c7e9
--- /dev/null
+++ b/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
@@ -0,0 +1,11 @@
+# Variant C: Spec Writer Middleman
+
+Task title: prepare fixture {{fixture}} for scenario {{scenario}}.
+
+Recent history tail budget: {{tailChars}} chars.
+
+Full history pointer: not wired in this smoke slice.
+
+In the full flow, this variant first asks a spec-writer agent to produce the
+execution spec. In this smoke slice, the provider only proves fixture
+preparation and Promptfoo plumbing.
diff --git a/packages/open-agents/evals/scripts/prepare-fixture.mjs b/packages/open-agents/evals/scripts/prepare-fixture.mjs
new file mode 100644
index 0000000..136b64e
--- /dev/null
+++ b/packages/open-agents/evals/scripts/prepare-fixture.mjs
@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const evalRoot = resolve(here, '..');
+const repoRoot = resolve(evalRoot, '..', '..', '..');
+const defaultWorkRoot = join(repoRoot, '.davstack', 'evals');
+
+function usage() {
+  console.error(
+    'usage: node prepare-fixture.mjs --fixture <id> [--run-id <id>] [--variant <id>] [--work-root <path>] [--fresh]',
+  );
+}
+
+function parseArgs(argv) {
+  const out = { runId: 'manual', variant: 'smoke', workRoot: defaultWorkRoot, fresh: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--fixture') out.fixture = argv[++i];
+    else if (arg === '--run-id') out.runId = argv[++i];
+    else if (arg === '--variant') out.variant = argv[++i];
+    else if (arg === '--work-root') out.workRoot = resolve(argv[++i]);
+    else if (arg === '--fresh') out.fresh = true;
+    else {
+      usage();
+      process.exit(2);
+    }
+  }
+  if (!out.fixture) {
+    usage();
+    process.exit(2);
+  }
+  return out;
+}
+
+function run(cmd, args, options = {}) {
+  const result = spawnSync(cmd, args, {
+    stdio: options.capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    cwd: options.cwd,
+    shell: false,
+    windowsHide: true,
+    encoding: 'utf8',
+  });
+  if (result.status !== 0) {
+    const detail = options.capture ? `\n${result.stderr || result.stdout || ''}` : '';
+    throw new Error(`${cmd} ${args.join(' ')} failed with exit ${result.status}${detail}`);
+  }
+  return result.stdout || '';
+}
+
+export function loadFixture(fixtureId) {
+  const manifestPath = join(evalRoot, 'fixtures', `${fixtureId}.json`);
+  return {
+    manifestPath,
+    manifest: JSON.parse(readFileSync(manifestPath, 'utf8')),
+  };
+}
+
+export function prepareFixture(options) {
+  const { manifest } = loadFixture(options.fixture);
+  const workRoot = resolve(options.workRoot || defaultWorkRoot);
+  const cacheDir = join(workRoot, 'repo-cache');
+  const runsDir = join(workRoot, 'runs', options.runId);
+  const mirrorPath = join(cacheDir, `${manifest.id}.git`);
+  const checkoutPath = join(runsDir, `${options.variant}-${manifest.id}`);
+
+  mkdirSync(cacheDir, { recursive: true });
+  mkdirSync(runsDir, { recursive: true });
+
+  if (!existsSync(mirrorPath)) {
+    run('git', ['clone', '--mirror', manifest.repo, mirrorPath], { capture: options.quiet });
+  } else {
+    run('git', ['fetch', '--prune'], { cwd: mirrorPath, capture: options.quiet });
+  }
+
+  if (options.fresh && existsSync(checkoutPath)) {
+    rmSync(checkoutPath, { recursive: true, force: true });
+  }
+  if (!existsSync(checkoutPath)) {
+    run('git', ['clone', mirrorPath, checkoutPath], { capture: options.quiet });
+  }
+
+  run('git', ['checkout', '--force', manifest.commit], {
+    cwd: checkoutPath,
+    capture: options.quiet,
+  });
+  run('git', ['reset', '--hard', manifest.commit], { cwd: checkoutPath, capture: options.quiet });
+  run('git', ['clean', '-ffd'], { cwd: checkoutPath, capture: options.quiet });
+
+  const actualCommit = run('git', ['rev-parse', 'HEAD'], {
+    cwd: checkoutPath,
+    capture: true,
+  }).trim();
+
+  return {
+    ok: actualCommit === manifest.commit,
+    fixture: manifest.id,
+    repo: manifest.repo,
+    commit: manifest.commit,
+    actualCommit,
+    checkoutPath,
+    mirrorPath,
+  };
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const result = prepareFixture(parseArgs(process.argv.slice(2)));
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
diff --git a/packages/open-agents/evals/scripts/promptfoo-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
new file mode 100644
index 0000000..7452990
--- /dev/null
+++ b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { prepareFixture } from './prepare-fixture.mjs';
+
+const [, , prompt = '', optionsJson = '{}', contextJson = '{}'] = process.argv;
+
+function parseJson(value, fallback) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+const context = parseJson(contextJson, {});
+const vars = context.vars || {};
+const options = parseJson(optionsJson, {});
+const fixture = vars.fixture || options.fixture || 'nextbase-supabase-starter';
+const scenario = vars.scenario || 'fixture-prepare-smoke';
+const variant = /Variant B/.test(prompt)
+  ? 'b-title-tail-history'
+  : /Variant C/.test(prompt)
+    ? 'c-spec-writer-title-tail-history'
+    : 'a-main-agent-spec';
+
+try {
+  const prepared = prepareFixture({
+    fixture,
+    runId: `${scenario}-${Date.now()}`,
+    variant,
+    workRoot: options.workRoot,
+    fresh: true,
+    quiet: true,
+  });
+  console.log(
+    JSON.stringify({
+      ok: prepared.ok,
+      fixture,
+      scenario,
+      variant,
+      promptChars: prompt.length,
+      checkoutPath: prepared.checkoutPath,
+      commit: prepared.actualCommit,
+    }),
+  );
+} catch (error) {
+  console.log(
+    JSON.stringify({
+      ok: false,
+      fixture,
+      scenario,
+      variant,
+      promptChars: prompt.length,
+      error: error instanceof Error ? error.message : String(error),
+    }),
+  );
+  process.exit(1);
+}

From 17941b1a5494c96068ba81f3baf0e54cf9b06208 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:26:44 +0100
Subject: [PATCH 18/72] test: clean promptfoo fixture smoke runs

---
 packages/open-agents/evals/scripts/prepare-fixture.mjs    | 1 +
 packages/open-agents/evals/scripts/promptfoo-provider.mjs | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/packages/open-agents/evals/scripts/prepare-fixture.mjs b/packages/open-agents/evals/scripts/prepare-fixture.mjs
index 136b64e..6d9711d 100644
--- a/packages/open-agents/evals/scripts/prepare-fixture.mjs
+++ b/packages/open-agents/evals/scripts/prepare-fixture.mjs
@@ -101,6 +101,7 @@ export function prepareFixture(options) {
     repo: manifest.repo,
     commit: manifest.commit,
     actualCommit,
+    runPath: runsDir,
     checkoutPath,
     mirrorPath,
   };
diff --git a/packages/open-agents/evals/scripts/promptfoo-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
index 7452990..ff2c271 100644
--- a/packages/open-agents/evals/scripts/promptfoo-provider.mjs
+++ b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { prepareFixture } from './prepare-fixture.mjs';
+import { rmSync } from 'node:fs';
 
 const [, , prompt = '', optionsJson = '{}', contextJson = '{}'] = process.argv;
 
@@ -16,6 +17,7 @@ const vars = context.vars || {};
 const options = parseJson(optionsJson, {});
 const fixture = vars.fixture || options.fixture || 'nextbase-supabase-starter';
 const scenario = vars.scenario || 'fixture-prepare-smoke';
+const keepRun = vars.keepRun === true || options.keepRun === true;
 const variant = /Variant B/.test(prompt)
   ? 'b-title-tail-history'
   : /Variant C/.test(prompt)
@@ -31,6 +33,9 @@ try {
     fresh: true,
     quiet: true,
   });
+  if (!keepRun && prepared.ok) {
+    rmSync(prepared.runPath, { recursive: true, force: true });
+  }
   console.log(
     JSON.stringify({
       ok: prepared.ok,
@@ -40,6 +45,7 @@ try {
       promptChars: prompt.length,
       checkoutPath: prepared.checkoutPath,
       commit: prepared.actualCommit,
+      retained: keepRun,
     }),
   );
 } catch (error) {

From 2c9fb0185f645fc1a7599aaccbbe7aab6bb72f4b Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:29:46 +0100
Subject: [PATCH 19/72] docs: explain promptfoo handoff eval usage

---
 .../.folder-meta.md                           |   8 ++
 .../7-first-real-explore-eval.md              | 115 ++++++++++++++++++
 packages/open-agents/evals/README.md          |  55 +++++++++
 3 files changed, 178 insertions(+)
 create mode 100644 notes/open-agent-handoff-testing/7-first-real-explore-eval.md
 create mode 100644 packages/open-agents/evals/README.md

diff --git a/notes/open-agent-handoff-testing/.folder-meta.md b/notes/open-agent-handoff-testing/.folder-meta.md
index 5f328c6..b78e012 100644
--- a/notes/open-agent-handoff-testing/.folder-meta.md
+++ b/notes/open-agent-handoff-testing/.folder-meta.md
@@ -55,3 +55,11 @@ short recommendation and tradeoffs.
 
 Use this when selecting the pinned repo/commit for the first prepare-script
 spike.
+
+### `7-first-real-explore-eval.md`
+
+Plans the first non-smoke eval: a small read-only `explore` task against the
+pinned Supabase starter fixture, including the three variants, candidate task,
+measurements, and open questions.
+
+Use this before wiring the provider to launch real open-agents jobs.
diff --git a/notes/open-agent-handoff-testing/7-first-real-explore-eval.md b/notes/open-agent-handoff-testing/7-first-real-explore-eval.md
new file mode 100644
index 0000000..fca9e0b
--- /dev/null
+++ b/notes/open-agent-handoff-testing/7-first-real-explore-eval.md
@@ -0,0 +1,115 @@
+# First Real Explore Eval Plan
+
+## Goal
+
+Move from fixture-preparation smoke testing to one real `explore` task against
+the pinned Supabase starter fixture.
+
+Keep the first real eval small. The purpose is to prove the A/B/C handoff shape,
+not to solve all scoring and artifact problems at once.
+
+## Three Variants
+
+### A. Main-Agent Written Spec
+
+The prompt contains a normal curated `explore` spec:
+
+- clear goal;
+- short context;
+- concrete scope;
+- expected citation style.
+
+This is the quality baseline and the current manual workflow.
+
+### B. No Spec: Title + Tail + History Pointer
+
+The prompt contains:
+
+- one-line task title;
+- recent conversation/history tail;
+- pointer to full history/context artifact;
+- instruction to inspect only what is needed.
+
+For the first real eval, the "history" can be a small synthetic artifact instead
+of the actual full chat export. We mainly need to test whether the execution
+agent can turn lightweight context into a useful read-only answer.
+
+### C. Spec Writer Middleman
+
+Two-step flow:
+
+1. Spec-writer receives the same title + tail + history pointer as variant B.
+2. It emits a compact `explore` spec.
+3. Execution agent receives only that generated spec.
+
+For the first implementation, it is acceptable to simulate step 1 with a local
+provider function or a separate open-agents run, as long as the generated spec is
+persisted and measured.
+
+## Candidate Task
+
+Use a read-only architecture reconnaissance task:
+
+> In the pinned Supabase starter fixture, trace how the private-items CRUD flow
+> is structured from route/page entry points through server/data access and
+> Supabase calls. Cite relevant files and lines. Do not modify files.
+
+Why this task:
+
+- It matches real `explore` usage.
+- It is concrete but not trivial.
+- The answer can be graded by checking for route/page files, data-access files,
+  Supabase client usage, and path/line citations.
+- It does not require installing dependencies or running the app.
+
+## Measurements
+
+Capture per variant:
+
+- prompt character count;
+- tail character count;
+- generated spec character count, if any;
+- fixture checkout path;
+- open-agents job id;
+- result path;
+- wall-clock duration;
+- exit code;
+- whether the run checkout was retained;
+- answer character count.
+
+Review manually:
+
+- intent fidelity: 1-5;
+- citation usefulness: 1-5;
+- coverage of CRUD path: 1-5;
+- hallucination / unsupported claims: yes/no;
+- would use again: yes/no.
+
+Cheap automated assertions:
+
+- result includes at least one `path:line`-style citation;
+- result mentions Supabase;
+- result mentions private/items or the equivalent fixture domain term;
+- result does not report edits/files changed.
+
+## Harness Steps
+
+1. Extend the provider so a scenario can run `explore` after preparing the
+   fixture checkout.
+2. Persist each variant's final prompt/spec beside the Promptfoo result.
+3. Keep successful run checkouts cleaned by default, but retain result artifacts.
+4. Add `keepRun: true` for debugging failed runs.
+5. Run one Promptfoo row with the three variants.
+6. Manually inspect the three outputs and record the review scores.
+
+## Open Questions
+
+- Should the first real run use Cursor via open-agents immediately, or should we
+  first make the provider output the exact prompts/specs without launching
+  agents?
+- Where should generated specs/results live if Promptfoo stores only table
+  output?
+- Should the fixture checkout be retained for `explore` results so citations can
+  be clicked after cleanup, or is the mirror/pinned commit enough?
+- How should we pass the synthetic history tail and full-history pointer into
+  Promptfoo vars without making the YAML noisy?
diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
new file mode 100644
index 0000000..db72a59
--- /dev/null
+++ b/packages/open-agents/evals/README.md
@@ -0,0 +1,55 @@
+# Open Agents Evals
+
+Small Promptfoo-based harness for testing open-agents handoff strategies against
+pinned external fixtures.
+
+## Current Smoke Eval
+
+The current eval proves plumbing only:
+
+- loads three prompt variants;
+- prepares the pinned `nextbase-supabase-starter` fixture;
+- creates isolated checkouts under `.davstack/evals/runs`;
+- cleans successful run checkouts by default;
+- keeps the reusable mirror cache under `.davstack/evals/repo-cache`.
+
+Run from this folder:
+
+```sh
+npx promptfoo@latest eval -c promptfooconfig.yaml
+```
+
+Expected result:
+
+```text
+3 passed (100%)
+```
+
+## Fixture Prep
+
+Manual smoke:
+
+```sh
+node scripts/prepare-fixture.mjs --fixture nextbase-supabase-starter --run-id smoke --variant manual --fresh
+```
+
+This clones or refreshes the mirror cache, creates a checkout at the pinned
+commit, hard-resets it, and prints JSON metadata.
+
+## Keeping Run Checkouts
+
+Promptfoo provider runs delete successful checkouts by default. For debugging,
+pass `keepRun: true` through provider options or test vars once that is wired
+into a specific eval config.
+
+## Local Artifacts
+
+Generated local artifacts are intentionally ignored:
+
+```text
+.davstack/evals/
+```
+
+Keep manifests, prompt templates, scripts, and score logic in git. Keep cloned
+fixtures, run checkouts, Promptfoo caches, and bulky outputs out of git unless a
+small artifact is intentionally promoted into a fixture.

From 017af6654df07df9a96007280414eaf50037e96a Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:51:58 +0100
Subject: [PATCH 20/72] docs: define handoff eval artifacts

---
 .../.folder-meta.md                           |  7 ++
 .../8-eval-artifact-convention.md             | 68 +++++++++++++++++++
 2 files changed, 75 insertions(+)
 create mode 100644 notes/open-agent-handoff-testing/8-eval-artifact-convention.md

diff --git a/notes/open-agent-handoff-testing/.folder-meta.md b/notes/open-agent-handoff-testing/.folder-meta.md
index b78e012..d8b5967 100644
--- a/notes/open-agent-handoff-testing/.folder-meta.md
+++ b/notes/open-agent-handoff-testing/.folder-meta.md
@@ -63,3 +63,10 @@ pinned Supabase starter fixture, including the three variants, candidate task,
 measurements, and open questions.
 
 Use this before wiring the provider to launch real open-agents jobs.
+
+### `8-eval-artifact-convention.md`
+
+Defines where local eval outputs, copied open-agents results, job metadata, and
+manual score files should live.
+
+Use this when making the Promptfoo provider persist inspectable run artifacts.
diff --git a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
new file mode 100644
index 0000000..75a0b43
--- /dev/null
+++ b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
@@ -0,0 +1,68 @@
+# Eval Artifact Convention
+
+## Problem
+
+Promptfoo's table output is useful for a quick pass/fail view, but it is not
+enough for inspecting agent-handoff evals later. We need durable local artifacts
+per run: inputs, outputs, job metadata, scores, and notes.
+
+## Current Convention
+
+Ignored local eval artifacts live under:
+
+```text
+.davstack/evals/runs/<run-id>/artifacts/
+```
+
+For a manual comparison run, store:
+
+```text
+score.md
+scores.json
+variant-a-input.md
+variant-a-output.md
+variant-a-job.json
+variant-b-input.md
+variant-b-output.md
+variant-b-job.json
+related-history.jsonl
+```
+
+The fixture checkout can live beside `artifacts/` while the run is being scored:
+
+```text
+.davstack/evals/runs/<run-id>/shared-nextbase-supabase-starter/
+```
+
+That checkout is noisy, but useful for clickable citation verification. Once a
+run is scored, we can either keep the checkout temporarily or delete it and rely
+on the pinned commit plus copied outputs.
+
+## What Gets Committed
+
+Commit:
+
+- fixture manifests;
+- Promptfoo configs;
+- provider scripts;
+- prompt templates;
+- scoring conventions/docs.
+
+Do not commit:
+
+- cloned fixture repos;
+- run checkouts;
+- raw Promptfoo caches;
+- bulky open-agents logs;
+- manual score artifacts unless deliberately promoting a small golden fixture.
+
+## Next Automation Step
+
+The Promptfoo provider should write this artifact bundle automatically:
+
+- copy final prompt/spec for each variant;
+- copy open-agents result;
+- copy job JSON;
+- run citation-range validation;
+- write `scores.json` with objective metrics;
+- leave manual score fields blank for review.

From debf81ffa245ed784b5f985f92f76b650099ed0f Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:54:18 +0100
Subject: [PATCH 21/72] docs: prefer promptfoo-native eval results

---
 .../8-eval-artifact-convention.md             | 43 ++++++++++++++++++-
 packages/open-agents/evals/README.md          | 33 +++++++++++++-
 2 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
index 75a0b43..91a99b1 100644
--- a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
+++ b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
@@ -14,11 +14,21 @@ Ignored local eval artifacts live under:
 .davstack/evals/runs/<run-id>/artifacts/
 ```
 
+Promptfoo should own the primary machine-readable result file:
+
+```text
+.davstack/evals/runs/<run-id>/promptfoo-results.json
+```
+
+Run evals with `--output` so Promptfoo writes that file directly instead of us
+inventing a separate score format.
+
 For a manual comparison run, store:
 
 ```text
 score.md
 scores.json
+promptfoo-results.json
 variant-a-input.md
 variant-a-output.md
 variant-a-job.json
@@ -64,5 +74,34 @@ The Promptfoo provider should write this artifact bundle automatically:
 - copy open-agents result;
 - copy job JSON;
 - run citation-range validation;
-- write `scores.json` with objective metrics;
-- leave manual score fields blank for review.
+- return objective metrics to Promptfoo so Promptfoo can score/assert them;
+- write or update `manual-review.json` with blank human-review fields.
+
+Promptfoo should produce `promptfoo-results.json`. A tiny post-process script can
+then merge in manual review fields from `manual-review.json` and render
+`score.md` for humans.
+
+## Promptfoo-Native Scoring
+
+Use Promptfoo assertions for objective checks:
+
+- result contains at least one `path:Lx-Ly` citation;
+- citation-range validation returned zero invalid ranges;
+- result mentions the target domain term, such as `private_items`;
+- result has no `filesChanged`;
+- provider exit status is success.
+
+Use Promptfoo metrics or named assertions for objective dimensions where
+possible. Keep manual scores separate and additive:
+
+```text
+manual-review.json
+```
+
+Manual review should add only human judgment:
+
+- coverage;
+- usefulness;
+- hallucination risk;
+- would-use-again;
+- notes.
diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
index db72a59..f3af31b 100644
--- a/packages/open-agents/evals/README.md
+++ b/packages/open-agents/evals/README.md
@@ -16,7 +16,7 @@ The current eval proves plumbing only:
 Run from this folder:
 
 ```sh
-npx promptfoo@latest eval -c promptfooconfig.yaml
+npx promptfoo@latest eval -c promptfooconfig.yaml --output ../../..\\.davstack\\evals\\runs\\smoke\\promptfoo-results.json
 ```
 
 Expected result:
@@ -25,6 +25,10 @@ Expected result:
 3 passed (100%)
 ```
 
+Promptfoo should be the source of truth for machine-readable eval results. Use
+`--output <path>` so each run gets a Promptfoo JSON result file alongside any
+open-agents artifacts copied by the provider.
+
 ## Fixture Prep
 
 Manual smoke:
@@ -53,3 +57,30 @@ Generated local artifacts are intentionally ignored:
 Keep manifests, prompt templates, scripts, and score logic in git. Keep cloned
 fixtures, run checkouts, Promptfoo caches, and bulky outputs out of git unless a
 small artifact is intentionally promoted into a fixture.
+
+## Scoring Shape
+
+Promptfoo should generate:
+
+- pass/fail status;
+- assertion scores;
+- provider output;
+- prompt text;
+- latency and metadata where available;
+- JSON export via `--output`.
+
+The eval provider should generate/copy:
+
+- open-agents job JSON;
+- open-agents result markdown;
+- final prompt/spec per variant;
+- objective checks that Promptfoo can assert on, such as citation count and
+  valid citation ranges.
+
+Humans should only add:
+
+- coverage score;
+- usefulness score;
+- hallucination notes;
+- would-use-again decision;
+- any qualitative comparison notes.

From 47381fd8c81f02c916480ca4c970803358af9189 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:55:57 +0100
Subject: [PATCH 22/72] docs: make eval runs self contained

---
 .../8-eval-artifact-convention.md             | 75 ++++++++++++++++---
 1 file changed, 64 insertions(+), 11 deletions(-)

diff --git a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
index 91a99b1..51083de 100644
--- a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
+++ b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
@@ -8,10 +8,42 @@ per run: inputs, outputs, job metadata, scores, and notes.
 
 ## Current Convention
 
-Ignored local eval artifacts live under:
+Ignored local eval artifacts live under one folder per run:
 
 ```text
-.davstack/evals/runs/<run-id>/artifacts/
+.davstack/evals/runs/<run-id>/
+```
+
+Each run folder should be self-contained enough to inspect later without knowing
+which global history files, open-agents job files, or fixture cache were used.
+
+Preferred layout:
+
+```text
+.davstack/evals/runs/<run-id>/
+  promptfoo-results.json
+  run.json
+  manual-review.json
+  score.md
+  history/
+    related-history.jsonl
+    recent-tail.txt
+    source-pointer.txt
+  inputs/
+    variant-a.md
+    variant-b.md
+    variant-c.md
+  outputs/
+    variant-a.md
+    variant-b.md
+    variant-c.md
+  jobs/
+    variant-a.job.json
+    variant-b.job.json
+    variant-c.job.json
+  artifacts/
+    citation-checks.json
+    diff-summary.json
 ```
 
 Promptfoo should own the primary machine-readable result file:
@@ -26,16 +58,17 @@ inventing a separate score format.
 For a manual comparison run, store:
 
 ```text
-score.md
-scores.json
 promptfoo-results.json
-variant-a-input.md
-variant-a-output.md
-variant-a-job.json
-variant-b-input.md
-variant-b-output.md
-variant-b-job.json
-related-history.jsonl
+manual-review.json
+score.md
+history/related-history.jsonl
+history/recent-tail.txt
+inputs/variant-a.md
+inputs/variant-b.md
+outputs/variant-a.md
+outputs/variant-b.md
+jobs/variant-a.job.json
+jobs/variant-b.job.json
 ```
 
 The fixture checkout can live beside `artifacts/` while the run is being scored:
@@ -48,6 +81,25 @@ That checkout is noisy, but useful for clickable citation verification. Once a
 run is scored, we can either keep the checkout temporarily or delete it and rely
 on the pinned commit plus copied outputs.
 
+## History Snapshots
+
+If a variant uses history/context from outside the run folder, copy the exact
+material into the run folder before launching the agent.
+
+Examples:
+
+- related synthetic Claude-history-shaped JSONL;
+- redacted excerpts from `~/.claude/history.jsonl`;
+- Cursor/agent chat exports, if used;
+- a recent-tail text file;
+- a `source-pointer.txt` file naming the original source path, timestamp, and
+  redaction/sampling rule.
+
+Do not make later review depend on mutable global files such as
+`~/.claude/history.jsonl` or Cursor history databases. The run should contain
+the exact history bytes the agent saw, or a clear statement that no history was
+provided.
+
 ## What Gets Committed
 
 Commit:
@@ -71,6 +123,7 @@ Do not commit:
 The Promptfoo provider should write this artifact bundle automatically:
 
 - copy final prompt/spec for each variant;
+- copy any history/context files used by that variant;
 - copy open-agents result;
 - copy job JSON;
 - run citation-range validation;

From 3ecb6e48db0eeb82b5c72b0d17275d7617014f21 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 15:58:03 +0100
Subject: [PATCH 23/72] test: add open agents eval script

---
 packages/open-agents/evals/README.md          | 16 +++++++--
 .../evals/scripts/run-promptfoo.mjs           | 36 +++++++++++++++++++
 packages/open-agents/package.json             |  4 ++-
 3 files changed, 53 insertions(+), 3 deletions(-)
 create mode 100644 packages/open-agents/evals/scripts/run-promptfoo.mjs

diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
index f3af31b..99443dd 100644
--- a/packages/open-agents/evals/README.md
+++ b/packages/open-agents/evals/README.md
@@ -13,10 +13,10 @@ The current eval proves plumbing only:
 - cleans successful run checkouts by default;
 - keeps the reusable mirror cache under `.davstack/evals/repo-cache`.
 
-Run from this folder:
+Run from the repo root:
 
 ```sh
-npx promptfoo@latest eval -c promptfooconfig.yaml --output ../../..\\.davstack\\evals\\runs\\smoke\\promptfoo-results.json
+pnpm --filter @davstack/open-agents eval:smoke
 ```
 
 Expected result:
@@ -29,6 +29,18 @@ Promptfoo should be the source of truth for machine-readable eval results. Use
 `--output <path>` so each run gets a Promptfoo JSON result file alongside any
 open-agents artifacts copied by the provider.
 
+The package script writes Promptfoo JSON to:
+
+```text
+.davstack/evals/runs/smoke/promptfoo-results.json
+```
+
+For a named run:
+
+```sh
+pnpm --filter @davstack/open-agents eval -- --run-id=first-explore
+```
+
 ## Fixture Prep
 
 Manual smoke:
diff --git a/packages/open-agents/evals/scripts/run-promptfoo.mjs b/packages/open-agents/evals/scripts/run-promptfoo.mjs
new file mode 100644
index 0000000..8097bff
--- /dev/null
+++ b/packages/open-agents/evals/scripts/run-promptfoo.mjs
@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { mkdirSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const evalRoot = resolve(here, '..');
+const repoRoot = resolve(evalRoot, '..', '..', '..');
+
+const runId =
+  process.env.OPEN_AGENTS_EVAL_RUN_ID ||
+  process.argv.find((arg) => arg.startsWith('--run-id='))?.slice('--run-id='.length) ||
+  'smoke';
+
+const outDir = join(repoRoot, '.davstack', 'evals', 'runs', runId);
+mkdirSync(outDir, { recursive: true });
+
+const extraArgs = process.argv.slice(2).filter((arg) => !arg.startsWith('--run-id='));
+const args = [
+  'promptfoo@latest',
+  'eval',
+  '-c',
+  'promptfooconfig.yaml',
+  '--output',
+  join(outDir, 'promptfoo-results.json'),
+  ...extraArgs,
+];
+
+const result = spawnSync('npx', args, {
+  cwd: evalRoot,
+  stdio: 'inherit',
+  shell: process.platform === 'win32',
+});
+
+process.exit(result.status ?? 1);
diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index ed43a7a..59a8a31 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -7,7 +7,9 @@
   "scripts": {
     "build": "tsup",
     "prepublishOnly": "tsup",
-    "test": "pnpm -w exec vitest run --project open-agents"
+    "test": "pnpm -w exec vitest run --project open-agents",
+    "eval": "node evals/scripts/run-promptfoo.mjs",
+    "eval:smoke": "node evals/scripts/run-promptfoo.mjs --run-id=smoke"
   },
   "bin": {
     "explore": "./bin/explore.mjs",

From ec07e02b86924b52370a2350e8ce030cca0a774d Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 16:05:10 +0100
Subject: [PATCH 24/72] test: organize eval artifacts by case

---
 .../8-eval-artifact-convention.md             |  75 ++++++-------
 packages/open-agents/evals/README.md          |  24 ++++-
 .../evals/scripts/promptfoo-provider.mjs      | 101 +++++++++++++-----
 .../evals/scripts/run-promptfoo.mjs           |  82 +++++++++++++-
 4 files changed, 216 insertions(+), 66 deletions(-)

diff --git a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
index 51083de..8d594cf 100644
--- a/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
+++ b/notes/open-agent-handoff-testing/8-eval-artifact-convention.md
@@ -21,29 +21,24 @@ Preferred layout:
 
 ```text
 .davstack/evals/runs/<run-id>/
+  report.md
   promptfoo-results.json
   run.json
-  manual-review.json
-  score.md
-  history/
-    related-history.jsonl
-    recent-tail.txt
-    source-pointer.txt
-  inputs/
-    variant-a.md
-    variant-b.md
-    variant-c.md
-  outputs/
-    variant-a.md
-    variant-b.md
-    variant-c.md
-  jobs/
-    variant-a.job.json
-    variant-b.job.json
-    variant-c.job.json
-  artifacts/
-    citation-checks.json
-    diff-summary.json
+  cases/
+    a-main-agent-spec/
+      history.jsonl
+      input.md
+      output.md
+      job.json
+      scores.json
+      manual-review.json
+    b-title-tail-history/
+      history.jsonl
+      input.md
+      output.md
+      job.json
+      scores.json
+      manual-review.json
 ```
 
 Promptfoo should own the primary machine-readable result file:
@@ -59,22 +54,27 @@ For a manual comparison run, store:
 
 ```text
 promptfoo-results.json
-manual-review.json
-score.md
-history/related-history.jsonl
-history/recent-tail.txt
-inputs/variant-a.md
-inputs/variant-b.md
-outputs/variant-a.md
-outputs/variant-b.md
-jobs/variant-a.job.json
-jobs/variant-b.job.json
+report.md
+run.json
+cases/a-main-agent-spec/history.jsonl
+cases/a-main-agent-spec/input.md
+cases/a-main-agent-spec/output.md
+cases/a-main-agent-spec/job.json
+cases/a-main-agent-spec/scores.json
+cases/a-main-agent-spec/manual-review.json
+cases/b-title-tail-history/history.jsonl
+cases/b-title-tail-history/input.md
+cases/b-title-tail-history/output.md
+cases/b-title-tail-history/job.json
+cases/b-title-tail-history/scores.json
+cases/b-title-tail-history/manual-review.json
 ```
 
-The fixture checkout can live beside `artifacts/` while the run is being scored:
+The fixture checkout can live inside the run folder while the run is being
+scored:
 
 ```text
-.davstack/evals/runs/<run-id>/shared-nextbase-supabase-starter/
+.davstack/evals/runs/<run-id>/<case-id>-nextbase-supabase-starter/
 ```
 
 That checkout is noisy, but useful for clickable citation verification. Once a
@@ -120,7 +120,8 @@ Do not commit:
 
 ## Next Automation Step
 
-The Promptfoo provider should write this artifact bundle automatically:
+The Promptfoo provider should write this artifact bundle automatically for each
+case:
 
 - copy final prompt/spec for each variant;
 - copy any history/context files used by that variant;
@@ -131,8 +132,8 @@ The Promptfoo provider should write this artifact bundle automatically:
 - write or update `manual-review.json` with blank human-review fields.
 
 Promptfoo should produce `promptfoo-results.json`. A tiny post-process script can
-then merge in manual review fields from `manual-review.json` and render
-`score.md` for humans.
+then merge in per-case `manual-review.json` files and render run-level
+`report.md` for humans.
 
 ## Promptfoo-Native Scoring
 
@@ -148,7 +149,7 @@ Use Promptfoo metrics or named assertions for objective dimensions where
 possible. Keep manual scores separate and additive:
 
 ```text
-manual-review.json
+cases/<case-id>/manual-review.json
 ```
 
 Manual review should add only human judgment:
diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
index 99443dd..cfaa871 100644
--- a/packages/open-agents/evals/README.md
+++ b/packages/open-agents/evals/README.md
@@ -35,6 +35,22 @@ The package script writes Promptfoo JSON to:
 .davstack/evals/runs/smoke/promptfoo-results.json
 ```
 
+Provider artifacts are grouped by case:
+
+```text
+.davstack/evals/runs/smoke/
+  promptfoo-results.json
+  run.json
+  cases/
+    a-main-agent-spec/
+      input.md
+      output.md
+      history.jsonl
+      job.json
+      scores.json
+      manual-review.json
+```
+
 For a named run:
 
 ```sh
@@ -83,9 +99,11 @@ Promptfoo should generate:
 
 The eval provider should generate/copy:
 
-- open-agents job JSON;
-- open-agents result markdown;
-- final prompt/spec per variant;
+- `cases/<case-id>/job.json`;
+- `cases/<case-id>/output.md`;
+- `cases/<case-id>/input.md`;
+- `cases/<case-id>/history.jsonl`;
+- `cases/<case-id>/scores.json`;
 - objective checks that Promptfoo can assert on, such as citation count and
   valid citation ranges.
 
diff --git a/packages/open-agents/evals/scripts/promptfoo-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
index ff2c271..a4694dd 100644
--- a/packages/open-agents/evals/scripts/promptfoo-provider.mjs
+++ b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import { prepareFixture } from './prepare-fixture.mjs';
-import { rmSync } from 'node:fs';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const [, , prompt = '', optionsJson = '{}', contextJson = '{}'] = process.argv;
+const here = dirname(fileURLToPath(import.meta.url));
+const evalRoot = resolve(here, '..');
+const repoRoot = resolve(evalRoot, '..', '..', '..');
 
 function parseJson(value, fallback) {
   try {
@@ -18,46 +23,92 @@ const options = parseJson(optionsJson, {});
 const fixture = vars.fixture || options.fixture || 'nextbase-supabase-starter';
 const scenario = vars.scenario || 'fixture-prepare-smoke';
 const keepRun = vars.keepRun === true || options.keepRun === true;
+const runId = process.env.OPEN_AGENTS_EVAL_RUN_ID || vars.runId || options.runId || scenario;
 const variant = /Variant B/.test(prompt)
   ? 'b-title-tail-history'
   : /Variant C/.test(prompt)
     ? 'c-spec-writer-title-tail-history'
     : 'a-main-agent-spec';
+const runPath = join(repoRoot, '.davstack', 'evals', 'runs', runId);
+const casePath = join(runPath, 'cases', variant);
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function blankManualReview() {
+  return {
+    status: 'unreviewed',
+    coverage: null,
+    usefulness: null,
+    hallucinationRisk: null,
+    citationCorrectness: null,
+    wouldUseAgain: null,
+    notes: '',
+  };
+}
 
 try {
   const prepared = prepareFixture({
     fixture,
-    runId: `${scenario}-${Date.now()}`,
+    runId,
     variant,
     workRoot: options.workRoot,
     fresh: true,
     quiet: true,
   });
+  const output = {
+    ok: prepared.ok,
+    fixture,
+    scenario,
+    variant,
+    caseId: variant,
+    promptChars: prompt.length,
+    checkoutPath: prepared.checkoutPath,
+    commit: prepared.actualCommit,
+    retained: keepRun,
+  };
+  mkdirSync(casePath, { recursive: true });
+  writeFileSync(join(casePath, 'input.md'), prompt);
+  writeFileSync(join(casePath, 'history.jsonl'), '');
+  writeJson(join(casePath, 'job.json'), {
+    kind: 'fixture-prepare-smoke',
+    fixture,
+    scenario,
+    variant,
+    checkoutPath: prepared.checkoutPath,
+    repo: prepared.repo,
+    commit: prepared.commit,
+    actualCommit: prepared.actualCommit,
+    retained: keepRun,
+  });
+  writeFileSync(join(casePath, 'output.md'), `${JSON.stringify(output, null, 2)}\n`);
+  writeJson(join(casePath, 'scores.json'), {
+    ok: prepared.ok,
+    fixturePrepared: prepared.ok ? 1 : 0,
+    promptChars: prompt.length,
+  });
+  writeJson(join(casePath, 'manual-review.json'), blankManualReview());
   if (!keepRun && prepared.ok) {
-    rmSync(prepared.runPath, { recursive: true, force: true });
+    rmSync(prepared.checkoutPath, { recursive: true, force: true });
   }
-  console.log(
-    JSON.stringify({
-      ok: prepared.ok,
-      fixture,
-      scenario,
-      variant,
-      promptChars: prompt.length,
-      checkoutPath: prepared.checkoutPath,
-      commit: prepared.actualCommit,
-      retained: keepRun,
-    }),
-  );
+  console.log(JSON.stringify(output));
 } catch (error) {
-  console.log(
-    JSON.stringify({
-      ok: false,
-      fixture,
-      scenario,
-      variant,
-      promptChars: prompt.length,
-      error: error instanceof Error ? error.message : String(error),
-    }),
-  );
+  const output = {
+    ok: false,
+    fixture,
+    scenario,
+    variant,
+    caseId: variant,
+    promptChars: prompt.length,
+    error: error instanceof Error ? error.message : String(error),
+  };
+  mkdirSync(casePath, { recursive: true });
+  writeFileSync(join(casePath, 'input.md'), prompt);
+  writeFileSync(join(casePath, 'history.jsonl'), '');
+  writeFileSync(join(casePath, 'output.md'), `${JSON.stringify(output, null, 2)}\n`);
+  writeJson(join(casePath, 'scores.json'), { ok: false, fixturePrepared: 0 });
+  writeJson(join(casePath, 'manual-review.json'), blankManualReview());
+  console.log(JSON.stringify(output));
   process.exit(1);
 }
diff --git a/packages/open-agents/evals/scripts/run-promptfoo.mjs b/packages/open-agents/evals/scripts/run-promptfoo.mjs
index 8097bff..d1a470e 100644
--- a/packages/open-agents/evals/scripts/run-promptfoo.mjs
+++ b/packages/open-agents/evals/scripts/run-promptfoo.mjs
@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
@@ -16,6 +16,21 @@ const runId =
 const outDir = join(repoRoot, '.davstack', 'evals', 'runs', runId);
 mkdirSync(outDir, { recursive: true });
 
+const startedAt = new Date().toISOString();
+writeFileSync(
+  join(outDir, 'run.json'),
+  `${JSON.stringify(
+    {
+      runId,
+      startedAt,
+      config: 'packages/open-agents/evals/promptfooconfig.yaml',
+      command: 'promptfoo eval',
+    },
+    null,
+    2,
+  )}\n`,
+);
+
 const extraArgs = process.argv.slice(2).filter((arg) => !arg.startsWith('--run-id='));
 const args = [
   'promptfoo@latest',
@@ -31,6 +46,71 @@ const result = spawnSync('npx', args, {
   cwd: evalRoot,
   stdio: 'inherit',
   shell: process.platform === 'win32',
+  env: {
+    ...process.env,
+    OPEN_AGENTS_EVAL_RUN_ID: runId,
+  },
 });
 
+function readCaseSummary(caseId) {
+  const caseDir = join(outDir, 'cases', caseId);
+  const scoresPath = join(caseDir, 'scores.json');
+  const reviewPath = join(caseDir, 'manual-review.json');
+  const scores = existsSync(scoresPath)
+    ? JSON.parse(readFileSync(scoresPath, 'utf8'))
+    : {};
+  const review = existsSync(reviewPath)
+    ? JSON.parse(readFileSync(reviewPath, 'utf8'))
+    : {};
+  return { caseId, scores, review };
+}
+
+function writeReport(finishedAt) {
+  const casesDir = join(outDir, 'cases');
+  const cases = existsSync(casesDir)
+    ? readdirSync(casesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => readCaseSummary(entry.name))
+    : [];
+  const rows = cases
+    .map(
+      (entry) =>
+        `| ${entry.caseId} | ${entry.scores.ok === false ? 'fail' : 'pass'} | ${entry.review.status || 'unreviewed'} | ${entry.scores.promptChars ?? ''} |`,
+    )
+    .join('\n');
+
+  writeFileSync(
+    join(outDir, 'report.md'),
+    `# Open Agents Eval Run: ${runId}
+
+- Started: ${startedAt}
+- Finished: ${finishedAt}
+- Promptfoo status: ${result.status ?? 1}
+- Promptfoo results: promptfoo-results.json
+
+| Case | Smoke status | Manual review | Prompt chars |
+| --- | --- | --- | --- |
+${rows || '| _none_ | _none_ | _none_ | _none_ |'}
+`,
+  );
+}
+
+writeFileSync(
+  join(outDir, 'run.json'),
+  `${JSON.stringify(
+    {
+      runId,
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      status: result.status ?? 1,
+      config: 'packages/open-agents/evals/promptfooconfig.yaml',
+      command: 'promptfoo eval',
+      resultPath: join(outDir, 'promptfoo-results.json'),
+    },
+    null,
+    2,
+  )}\n`,
+);
+writeReport(new Date().toISOString());
+
 process.exit(result.status ?? 1);

From d90b0196f2a3db036475b922038edbd23e9d5755 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 18:34:04 +0100
Subject: [PATCH 25/72] test: checkpoint llm judge eval spike

Records the initial Promptfoo LLM-as-judge experiment before cleanup. Known rough edges include mixed smoke/explore config, variant-only artifact paths, hardcoded Gemini execution, and unstructured grader output.
---
 .../open-agents/evals/promptfooconfig.yaml    |  87 +++++++++
 .../evals/prompts/a-main-agent-spec.md        |   6 +-
 .../evals/prompts/b-title-tail-history.md     |   4 +-
 .../c-spec-writer-title-tail-history.md       |   4 +-
 .../evals/scripts/prepare-fixture.mjs         |  26 ++-
 .../scripts/promptfoo-grader-provider.mjs     |  36 ++++
 .../evals/scripts/promptfoo-provider.mjs      |  81 +++++++-
 .../evals/scripts/run-promptfoo.mjs           | 178 +++++++++++++++++-
 packages/open-agents/src/adapters/gemini.ts   |   4 +-
 9 files changed, 400 insertions(+), 26 deletions(-)
 create mode 100644 packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs

diff --git a/packages/open-agents/evals/promptfooconfig.yaml b/packages/open-agents/evals/promptfooconfig.yaml
index 887532e..4cd8ca4 100644
--- a/packages/open-agents/evals/promptfooconfig.yaml
+++ b/packages/open-agents/evals/promptfooconfig.yaml
@@ -9,12 +9,99 @@ providers:
   - 'exec: node ./scripts/promptfoo-provider.mjs'
 
 tests:
+  # 1. Smoke test: fixture preparation only.
   - vars:
       fixture: nextbase-supabase-starter
       scenario: fixture-prepare-smoke
       tailChars: 50000
+      goal: Prepare the pinned fixture repo and report whether the checkout is available for open-agents handoff testing.
+      context: This prompt stands in for the current baseline where the main agent writes a detailed execution spec before delegating.
+      historyPointer: not wired in this smoke slice.
     assert:
       - type: contains
         value: '"ok":true'
       - type: contains
         value: '"fixture":"nextbase-supabase-starter"'
+
+  # 2. Real explore test: runs the explore agent and performs LLM-as-judge grading.
+  - vars:
+      fixture: nextbase-supabase-starter
+      scenario: explore-private-items
+      tailChars: 50000
+      goal: In the pinned Supabase starter fixture, trace how the private-items CRUD flow is structured from route/page entry points through server/data access and Supabase calls. Cite relevant files and lines. Do not modify files.
+      context: Trace route/page entry points, server/data access, and Supabase client calls for private-items CRUD.
+      historyPointer: not wired.
+    assert:
+      - type: contains
+        value: 'private'
+      - type: contains
+        value: 'Supabase'
+      - type: javascript
+        value: |
+          // Verify that output contains a path:line citation
+          return /[\w.-]+\.\w+:(?:L)?\d+/.test(output);
+
+      - type: llm-rubric
+        metric: coverage
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score coverage from 0.0 to 1.0:
+          1.0 = identifies all important implementation areas needed for the task.
+          0.7 = covers the main implementation path but misses minor useful details.
+          0.4 = partial answer; misses important modules or relationships.
+          0.0 = mostly unrelated or not enough detail to act.
+
+          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory.
+
+      - type: llm-rubric
+        metric: usefulness
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score usefulness from 0.0 to 1.0:
+          1.0 = a developer could confidently use this to make the next decision.
+          0.7 = useful with small follow-up inspection.
+          0.4 = somewhat useful but requires substantial rework.
+          0.0 = not useful.
+
+          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory.
+
+      - type: llm-rubric
+        metric: hallucination_safety
+        threshold: 0.8
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score hallucination safety from 0.0 to 1.0:
+          1.0 = claims are grounded in cited files or clearly marked as inference.
+          0.7 = mostly grounded, with minor uncited claims.
+          0.4 = several unsupported claims.
+          0.0 = fabricates files, APIs, behavior, or line numbers.
+
+          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory. Assume the files cited exist in the fixture repo.
+
+      - type: llm-rubric
+        metric: citation_quality
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score citation quality from 0.0 to 1.0:
+          1.0 = all references point directly to exact files and valid line numbers that exist and are relevant.
+          0.7 = references are mostly relevant and correct but might miss minor details or include slight misalignment.
+          0.4 = many references are vague, point to incorrect files/lines, or are missing for key statements.
+          0.0 = no citations or completely incorrect/fabricated citations.
+
+          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory. Assume the files cited exist in the fixture repo.
+
+      - type: llm-rubric
+        metric: actionability
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score actionability from 0.0 to 1.0:
+          1.0 = provides clear, concrete next steps, command suggestions, or precise file edits so a developer or agent can act immediately.
+          0.7 = suggests concrete next steps but requires some interpretation or minor planning.
+          0.4 = broad suggestions without clear instructions or code locations.
+          0.0 = vague, generic advice that cannot be directly acted upon.
+
+          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory.
diff --git a/packages/open-agents/evals/prompts/a-main-agent-spec.md b/packages/open-agents/evals/prompts/a-main-agent-spec.md
index efcb537..108859f 100644
--- a/packages/open-agents/evals/prompts/a-main-agent-spec.md
+++ b/packages/open-agents/evals/prompts/a-main-agent-spec.md
@@ -1,13 +1,11 @@
 # Variant A: Main-Agent Written Spec
 
 <goal>
-Prepare the pinned fixture repo and report whether the checkout is available for
-open-agents handoff testing.
+{{goal}}
 </goal>
 
 <context>
-This prompt stands in for the current baseline where the main agent writes a
-detailed execution spec before delegating.
+{{context}}
 </context>
 
 <scope>
diff --git a/packages/open-agents/evals/prompts/b-title-tail-history.md b/packages/open-agents/evals/prompts/b-title-tail-history.md
index 6066aca..af6a68d 100644
--- a/packages/open-agents/evals/prompts/b-title-tail-history.md
+++ b/packages/open-agents/evals/prompts/b-title-tail-history.md
@@ -1,7 +1,7 @@
 # Variant B: Title + Tail + History Pointer
 
-Task: prepare fixture {{fixture}} for scenario {{scenario}}.
+Task: {{goal}}
 
 Recent history tail budget: {{tailChars}} chars.
 
-Full history pointer: not wired in this smoke slice.
+Full history pointer: {{historyPointer}}
diff --git a/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md b/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
index 5f9c7e9..3be899a 100644
--- a/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
+++ b/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
@@ -1,10 +1,10 @@
 # Variant C: Spec Writer Middleman
 
-Task title: prepare fixture {{fixture}} for scenario {{scenario}}.
+Task title: {{goal}}
 
 Recent history tail budget: {{tailChars}} chars.
 
-Full history pointer: not wired in this smoke slice.
+Full history pointer: {{historyPointer}}
 
 In the full flow, this variant first asks a spec-writer agent to produce the
 execution spec. In this smoke slice, the provider only proves fixture
diff --git a/packages/open-agents/evals/scripts/prepare-fixture.mjs b/packages/open-agents/evals/scripts/prepare-fixture.mjs
index 6d9711d..5263723 100644
--- a/packages/open-agents/evals/scripts/prepare-fixture.mjs
+++ b/packages/open-agents/evals/scripts/prepare-fixture.mjs
@@ -51,6 +51,18 @@ function run(cmd, args, options = {}) {
   return result.stdout || '';
 }
 
+function runWithRetry(cmd, args, options = {}, retries = 5, delayMs = 1500) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return run(cmd, args, options);
+    } catch (error) {
+      if (attempt === retries) throw error;
+      // Sync sleep using Node child process timeout execution
+      spawnSync('node', ['-e', `setTimeout(() => {}, ${delayMs + Math.random() * 1000})`]);
+    }
+  }
+}
+
 export function loadFixture(fixtureId) {
   const manifestPath = join(evalRoot, 'fixtures', `${fixtureId}.json`);
   return {
@@ -71,26 +83,26 @@ export function prepareFixture(options) {
   mkdirSync(runsDir, { recursive: true });
 
   if (!existsSync(mirrorPath)) {
-    run('git', ['clone', '--mirror', manifest.repo, mirrorPath], { capture: options.quiet });
+    runWithRetry('git', ['clone', '--mirror', manifest.repo, mirrorPath], { capture: options.quiet });
   } else {
-    run('git', ['fetch', '--prune'], { cwd: mirrorPath, capture: options.quiet });
+    runWithRetry('git', ['fetch', '--prune'], { cwd: mirrorPath, capture: options.quiet });
   }
 
   if (options.fresh && existsSync(checkoutPath)) {
     rmSync(checkoutPath, { recursive: true, force: true });
   }
   if (!existsSync(checkoutPath)) {
-    run('git', ['clone', mirrorPath, checkoutPath], { capture: options.quiet });
+    runWithRetry('git', ['clone', mirrorPath, checkoutPath], { capture: options.quiet });
   }
 
-  run('git', ['checkout', '--force', manifest.commit], {
+  runWithRetry('git', ['checkout', '--force', manifest.commit], {
     cwd: checkoutPath,
     capture: options.quiet,
   });
-  run('git', ['reset', '--hard', manifest.commit], { cwd: checkoutPath, capture: options.quiet });
-  run('git', ['clean', '-ffd'], { cwd: checkoutPath, capture: options.quiet });
+  runWithRetry('git', ['reset', '--hard', manifest.commit], { cwd: checkoutPath, capture: options.quiet });
+  runWithRetry('git', ['clean', '-ffd'], { cwd: checkoutPath, capture: options.quiet });
 
-  const actualCommit = run('git', ['rev-parse', 'HEAD'], {
+  const actualCommit = runWithRetry('git', ['rev-parse', 'HEAD'], {
     cwd: checkoutPath,
     capture: true,
   }).trim();
diff --git a/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs
new file mode 100644
index 0000000..6059f85
--- /dev/null
+++ b/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs
@@ -0,0 +1,36 @@
+import { spawnSync } from 'node:child_process';
+
+export default class GeminiGraderProvider {
+  constructor(options) {
+    this.config = options.config || {};
+  }
+
+  id() {
+    return 'gemini-grader';
+  }
+
+  async callApi(prompt, context) {
+    try {
+      const result = spawnSync('gemini', ['-m', 'gemini-3.1-flash-lite-preview', '--skip-trust'], {
+        input: prompt,
+        encoding: 'utf8',
+        shell: process.platform === 'win32',
+      });
+
+      if (result.error) {
+        return { error: `Spawn error: ${result.error.message}` };
+      }
+      if (result.status !== 0) {
+        return { error: `Gemini exited with status ${result.status}: ${result.stderr || result.stdout}` };
+      }
+
+      // Clean up tool setup logging warnings from output if any
+      let outputText = result.stdout || '';
+      outputText = outputText.replace(/Ripgrep is not available\. Falling back to GrepTool\.\r?\n?/g, '').trim();
+
+      return { output: outputText };
+    } catch (e) {
+      return { error: `Grader exception: ${e instanceof Error ? e.message : String(e)}` };
+    }
+  }
+}
diff --git a/packages/open-agents/evals/scripts/promptfoo-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
index a4694dd..1bbf334 100644
--- a/packages/open-agents/evals/scripts/promptfoo-provider.mjs
+++ b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { prepareFixture } from './prepare-fixture.mjs';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
 
 const [, , prompt = '', optionsJson = '{}', contextJson = '{}'] = process.argv;
 const here = dirname(fileURLToPath(import.meta.url));
@@ -57,8 +58,55 @@ try {
     fresh: true,
     quiet: true,
   });
+
+  mkdirSync(casePath, { recursive: true });
+  writeFileSync(join(casePath, 'input.md'), prompt);
+  writeFileSync(join(casePath, 'history.jsonl'), '');
+
+  let agentText = '';
+  let agentExitCode = 0;
+  let filesChanged = [];
+  const isSmoke = scenario === 'fixture-prepare-smoke';
+
+  if (!isSmoke) {
+    const exploreBin = resolve(repoRoot, 'packages', 'open-agents', 'bin', 'explore.mjs');
+    const resultRun = spawnSync('node', [
+      exploreBin,
+      'submit',
+      '--cwd', prepared.checkoutPath,
+      '--file', join(casePath, 'input.md'),
+      '--provider', 'gemini'
+    ], {
+      encoding: 'utf8',
+      shell: process.platform === 'win32',
+    });
+
+    agentExitCode = resultRun.status ?? 0;
+    const stdout = resultRun.stdout || '';
+    const match = stdout.match(/RESULT_PATH:\s*(.+)/);
+    if (match && match[1]) {
+      const resultPath = match[1].trim();
+      if (existsSync(resultPath)) {
+        agentText = readFileSync(resultPath, 'utf8');
+        writeFileSync(join(casePath, 'output.md'), agentText);
+      }
+    } else {
+      agentText = `Agent run failed with exit code ${agentExitCode}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`;
+    }
+
+    // Check if any files were changed in the checkout path
+    const gitStatus = spawnSync('git', ['status', '--porcelain'], {
+      cwd: prepared.checkoutPath,
+      encoding: 'utf8',
+      shell: false,
+    });
+    if (gitStatus.status === 0 && gitStatus.stdout.trim()) {
+      filesChanged = gitStatus.stdout.trim().split('\n').map(line => line.slice(3).trim());
+    }
+  }
+
   const output = {
-    ok: prepared.ok,
+    ok: prepared.ok && (isSmoke || agentExitCode === 0),
     fixture,
     scenario,
     variant,
@@ -67,12 +115,12 @@ try {
     checkoutPath: prepared.checkoutPath,
     commit: prepared.actualCommit,
     retained: keepRun,
+    filesChanged,
+    agentExitCode,
   };
-  mkdirSync(casePath, { recursive: true });
-  writeFileSync(join(casePath, 'input.md'), prompt);
-  writeFileSync(join(casePath, 'history.jsonl'), '');
+
   writeJson(join(casePath, 'job.json'), {
-    kind: 'fixture-prepare-smoke',
+    kind: isSmoke ? 'fixture-prepare-smoke' : 'explore',
     fixture,
     scenario,
     variant,
@@ -81,18 +129,33 @@ try {
     commit: prepared.commit,
     actualCommit: prepared.actualCommit,
     retained: keepRun,
+    filesChanged,
+    agentExitCode,
   });
-  writeFileSync(join(casePath, 'output.md'), `${JSON.stringify(output, null, 2)}\n`);
+
+  if (isSmoke) {
+    writeFileSync(join(casePath, 'output.md'), `${JSON.stringify(output, null, 2)}\n`);
+  }
+
   writeJson(join(casePath, 'scores.json'), {
-    ok: prepared.ok,
+    ok: output.ok,
     fixturePrepared: prepared.ok ? 1 : 0,
     promptChars: prompt.length,
+    agentExitCode,
+    filesChangedCount: filesChanged.length,
   });
+
   writeJson(join(casePath, 'manual-review.json'), blankManualReview());
+
   if (!keepRun && prepared.ok) {
     rmSync(prepared.checkoutPath, { recursive: true, force: true });
   }
-  console.log(JSON.stringify(output));
+
+  if (isSmoke) {
+    console.log(JSON.stringify(output));
+  } else {
+    console.log(agentText);
+  }
 } catch (error) {
   const output = {
     ok: false,
diff --git a/packages/open-agents/evals/scripts/run-promptfoo.mjs b/packages/open-agents/evals/scripts/run-promptfoo.mjs
index d1a470e..d667f44 100644
--- a/packages/open-agents/evals/scripts/run-promptfoo.mjs
+++ b/packages/open-agents/evals/scripts/run-promptfoo.mjs
@@ -31,7 +31,7 @@ writeFileSync(
   )}\n`,
 );
 
-const extraArgs = process.argv.slice(2).filter((arg) => !arg.startsWith('--run-id='));
+const extraArgs = process.argv.slice(2).filter((arg) => !arg.startsWith('--run-id=') && arg !== '--');
 const args = [
   'promptfoo@latest',
   'eval',
@@ -65,6 +65,177 @@ function readCaseSummary(caseId) {
   return { caseId, scores, review };
 }
 
+function generateMarkdownReport(resultsJsonPath) {
+  if (!existsSync(resultsJsonPath)) {
+    return '';
+  }
+  try {
+    const data = JSON.parse(readFileSync(resultsJsonPath, 'utf8'));
+    const results = data.results?.results || [];
+    
+    // Group results by scenario
+    const scenarios = {};
+    for (const r of results) {
+      const scenario = r.testCase?.vars?.scenario || 'unknown';
+      if (!scenarios[scenario]) {
+        scenarios[scenario] = [];
+      }
+      scenarios[scenario].push(r);
+    }
+    
+    let reportContent = '';
+    
+    for (const [scenarioName, scenarioRuns] of Object.entries(scenarios)) {
+      reportContent += `\n### LLM-Graded Performance Summary (${scenarioName})\n\n`;
+      
+      // Get all unique variants in this scenario
+      const getVariantName = (r) => {
+        const variantStr = r.testCase?.vars?.variant || r.response?.output?.variant || '';
+        if (variantStr) return variantStr;
+        
+        const rawPrompt = r.prompt?.raw || '';
+        const firstLine = rawPrompt.split('\n')[0].trim();
+        if (firstLine.startsWith('# ')) {
+          const match = firstLine.slice(2).match(/^(Variant\s+[A-Z]):\s*(.*)$/i);
+          if (match) {
+            return `${match[1]} (${match[2]})`;
+          }
+          return firstLine.slice(2);
+        }
+        
+        if (/Variant A/i.test(rawPrompt)) return 'Variant A';
+        if (/Variant B/i.test(rawPrompt)) return 'Variant B';
+        if (/Variant C/i.test(rawPrompt)) return 'Variant C';
+        return r.prompt?.label?.split(':')[0] || 'Unknown Variant';
+      };
+
+      const variants = Array.from(new Set(scenarioRuns.map(getVariantName)));
+      variants.sort();
+      
+      // Map runs by variant name
+      const runsByVariant = {};
+      for (const r of scenarioRuns) {
+        const varName = getVariantName(r);
+        runsByVariant[varName] = r;
+      }
+      
+      // Extract all unique assertions/metrics across all runs
+      const assertionMap = new Map();
+      for (const r of scenarioRuns) {
+        const componentResults = r.gradingResult?.componentResults || [];
+        for (const cr of componentResults) {
+          const ass = cr.assertion || {};
+          const key = ass.metric || `${ass.type}:${ass.value}`;
+          if (!assertionMap.has(key)) {
+            assertionMap.set(key, ass);
+          }
+        }
+      }
+      
+      // Build markdown table header
+      const headers = ['Metric (Min Threshold)', ...variants];
+      const divider = headers.map(() => '---');
+      
+      reportContent += `| ${headers.join(' | ')} |\n`;
+      reportContent += `| ${divider.join(' | ')} |\n`;
+      
+      // Populate rows
+      for (const [key, ass] of assertionMap.entries()) {
+        const rowCells = [];
+        
+        let metricName = ass.metric || '';
+        if (!metricName) {
+          if (ass.type === 'contains') {
+            metricName = ass.value;
+          } else if (ass.type === 'javascript') {
+            metricName = `Citation Format`;
+          } else {
+            metricName = `${ass.type} (${ass.value})`;
+          }
+        }
+        
+        const thresholdSuffix = ass.threshold ? ` (${ass.threshold})` : ' (Pass/Fail)';
+        rowCells.push(`${metricName}${thresholdSuffix}`);
+        
+        for (const variantName of variants) {
+          const run = runsByVariant[variantName];
+          if (!run) {
+            rowCells.push('-');
+            continue;
+          }
+          
+          if (run.error && !run.gradingResult) {
+            const cleanErr = run.error.replace(/\r?\n/g, ' ').replace(/\|/g, '\\|').slice(0, 50);
+            rowCells.push(`ERROR: ${cleanErr}...`);
+            continue;
+          }
+          
+          const cr = run.gradingResult?.componentResults?.find(c => {
+            const ca = c.assertion || {};
+            const ckey = ca.metric || `${ca.type}:${ca.value}`;
+            return ckey === key;
+          });
+          
+          if (!cr) {
+            rowCells.push('-');
+          } else {
+            const hasScore = typeof cr.score === 'number';
+            const isRubric = key.includes('coverage') || key.includes('usefulness') || key.includes('safety') || key.includes('quality') || key.includes('actionability') || ass.type === 'llm-rubric';
+            
+            let cleanReason = cr.reason || '';
+            if (cleanReason.includes('Custom function returned false')) {
+              const commentMatch = cleanReason.match(/\/\/\s*(.*)/);
+              cleanReason = commentMatch ? commentMatch[1].trim() : 'custom assertion failed';
+            }
+            
+            if (cleanReason.includes('Verify that output contains a path:line citation') || cleanReason.includes('path:line citation')) {
+              cleanReason = 'no path:line format found';
+            } else if (cleanReason.startsWith('Expected output to contain ')) {
+              const term = cleanReason.match(/"(.*)"/)?.[1] || '';
+              cleanReason = term ? `did not mention "${term}"` : cleanReason;
+            } else {
+              const howeverMatch = cleanReason.match(/However,\s*(.*)/i);
+              if (howeverMatch) {
+                cleanReason = howeverMatch[1];
+              }
+              if (cleanReason.includes('descriptive rather than actively guiding') || cleanReason.includes('making it descriptive')) {
+                cleanReason = 'purely descriptive';
+              } else if (cleanReason.includes('lacks any actionable directives') || cleanReason.includes('lacked next steps') || cleanReason.includes('lacks actionable')) {
+                cleanReason = 'lacked next steps';
+              }
+              if (cleanReason.length > 50) {
+                cleanReason = cleanReason.slice(0, 47) + '...';
+              }
+            }
+
+            let cellText = '';
+            if (cr.pass) {
+              if (isRubric && hasScore) {
+                cellText = `PASS (Score: ${cr.score.toFixed(1)})`;
+              } else {
+                cellText = 'PASS';
+              }
+            } else {
+              const reasonSuffix = cleanReason ? ` - ${cleanReason}` : '';
+              if (isRubric && hasScore) {
+                cellText = `FAIL (Score: ${cr.score.toFixed(1)}${reasonSuffix})`;
+              } else {
+                cellText = `FAIL${cleanReason ? ` (${cleanReason})` : ''}`;
+              }
+            }
+            rowCells.push(cellText);
+          }
+        }
+        reportContent += `| ${rowCells.join(' | ')} |\n`;
+      }
+      reportContent += '\n';
+    }
+    return reportContent;
+  } catch (err) {
+    return `\n*Failed to generate performance summary: ${err.message}*\n`;
+  }
+}
+
 function writeReport(finishedAt) {
   const casesDir = join(outDir, 'cases');
   const cases = existsSync(casesDir)
@@ -79,6 +250,9 @@ function writeReport(finishedAt) {
     )
     .join('\n');
 
+  const resultsJsonPath = join(outDir, 'promptfoo-results.json');
+  const dynamicTables = generateMarkdownReport(resultsJsonPath);
+
   writeFileSync(
     join(outDir, 'report.md'),
     `# Open Agents Eval Run: ${runId}
@@ -91,6 +265,8 @@ function writeReport(finishedAt) {
 | Case | Smoke status | Manual review | Prompt chars |
 | --- | --- | --- | --- |
 ${rows || '| _none_ | _none_ | _none_ | _none_ |'}
+
+${dynamicTables}
 `,
   );
 }
diff --git a/packages/open-agents/src/adapters/gemini.ts b/packages/open-agents/src/adapters/gemini.ts
index 9d460ec..9b452aa 100644
--- a/packages/open-agents/src/adapters/gemini.ts
+++ b/packages/open-agents/src/adapters/gemini.ts
@@ -84,7 +84,9 @@ export function resolveGeminiEntry(): string | null {
   const appData = process.env.APPDATA;
   if (!appData) return null;
   const idx = join(appData, 'npm', 'node_modules', '@google', 'gemini-cli', 'dist', 'index.js');
-  return existsSync(idx) ? idx : null;
+  if (existsSync(idx)) return idx;
+  const bundleIdx = join(appData, 'npm', 'node_modules', '@google', 'gemini-cli', 'bundle', 'gemini.js');
+  return existsSync(bundleIdx) ? bundleIdx : null;
 }
 
 export function resolveBin(): { bin: string; prelaunchArgs: string[]; shell: boolean } {

From 632846c27471d19ced68884595c1e284206da536 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 18:43:38 +0100
Subject: [PATCH 26/72] test: harden llm judge eval harness

---
 packages/open-agents/evals/README.md          |  28 ++
 .../evals/promptfooconfig.explore.yaml        |  92 ++++++
 .../open-agents/evals/promptfooconfig.yaml    |  84 -----
 .../scripts/promptfoo-grader-provider.mjs     | 152 +++++++--
 .../evals/scripts/promptfoo-provider.mjs      |  63 ++--
 .../evals/scripts/run-promptfoo.mjs           | 305 +++++-------------
 packages/open-agents/package.json             |   3 +-
 7 files changed, 382 insertions(+), 345 deletions(-)
 create mode 100644 packages/open-agents/evals/promptfooconfig.explore.yaml

diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
index cfaa871..9a8d483 100644
--- a/packages/open-agents/evals/README.md
+++ b/packages/open-agents/evals/README.md
@@ -35,6 +35,10 @@ The package script writes Promptfoo JSON to:
 .davstack/evals/runs/smoke/promptfoo-results.json
 ```
 
+The wrapper passes `--no-cache` to Promptfoo because the provider creates local
+case artifacts as side effects. Cached Promptfoo results can otherwise report a
+pass without creating the corresponding `cases/` folders.
+
 Provider artifacts are grouped by case:
 
 ```text
@@ -57,6 +61,30 @@ For a named run:
 pnpm --filter @davstack/open-agents eval -- --run-id=first-explore
 ```
 
+## Explore + LLM Judge Eval
+
+The real explore eval is intentionally separate from smoke because it launches
+agents and judge calls:
+
+```sh
+pnpm --filter @davstack/open-agents eval:explore
+```
+
+It uses `promptfooconfig.explore.yaml`, keeps explore checkouts for later
+inspection, and grades subjective dimensions through
+`scripts/promptfoo-grader-provider.mjs`.
+
+Gemini judge knobs:
+
+```sh
+OPEN_AGENTS_EVAL_GRADER_MODEL=gemini-3.1-flash-lite-preview
+OPEN_AGENTS_EVAL_GRADER_TIMEOUT_MS=120000
+GEMINI_CLI_BIN=/path/to/gemini
+```
+
+The grader resolves the installed `@google/gemini-cli` bundle on Windows before
+falling back to `gemini` on PATH.
+
 ## Fixture Prep
 
 Manual smoke:
diff --git a/packages/open-agents/evals/promptfooconfig.explore.yaml b/packages/open-agents/evals/promptfooconfig.explore.yaml
new file mode 100644
index 0000000..b2722fb
--- /dev/null
+++ b/packages/open-agents/evals/promptfooconfig.explore.yaml
@@ -0,0 +1,92 @@
+description: Open-agents handoff explore eval with LLM-as-judge grading
+
+prompts:
+  - file://prompts/a-main-agent-spec.md
+  - file://prompts/b-title-tail-history.md
+  - file://prompts/c-spec-writer-title-tail-history.md
+
+providers:
+  - 'exec: node ./scripts/promptfoo-provider.mjs'
+
+tests:
+  - vars:
+      fixture: nextbase-supabase-starter
+      scenario: explore-private-items
+      tailChars: 50000
+      goal: In the pinned Supabase starter fixture, trace how the private-items CRUD flow is structured from route/page entry points through server/data access and Supabase calls. Cite relevant files and lines. Do not modify files.
+      context: Trace route/page entry points, server/data access, and Supabase client calls for private-items CRUD.
+      historyPointer: not wired.
+    assert:
+      - type: contains
+        value: 'private'
+      - type: contains
+        value: 'Supabase'
+      - type: javascript
+        metric: citation_format
+        value: |
+          return /[\w./-]+\.\w+:(?:L)?\d+/.test(output);
+
+      - type: llm-rubric
+        metric: coverage
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score coverage from 0.0 to 1.0:
+          1.0 = identifies all important implementation areas needed for the task.
+          0.7 = covers the main implementation path but misses minor useful details.
+          0.4 = partial answer; misses important modules or relationships.
+          0.0 = mostly unrelated or not enough detail to act.
+
+          Judge only the candidate answer. The answer was generated against the checked-out fixture repository, not this runner workspace.
+
+      - type: llm-rubric
+        metric: usefulness
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score usefulness from 0.0 to 1.0:
+          1.0 = a developer could confidently use this to make the next decision.
+          0.7 = useful with small follow-up inspection.
+          0.4 = somewhat useful but requires substantial rework.
+          0.0 = not useful.
+
+          Judge only the candidate answer. The answer was generated against the checked-out fixture repository, not this runner workspace.
+
+      - type: llm-rubric
+        metric: hallucination_safety
+        threshold: 0.8
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score hallucination safety from 0.0 to 1.0:
+          1.0 = claims are grounded in cited files or clearly marked as inference.
+          0.7 = mostly grounded, with minor uncited claims.
+          0.4 = several unsupported claims.
+          0.0 = fabricates files, APIs, behavior, or line numbers.
+
+          Judge only the candidate answer. Do not assume claims are correct just because they sound plausible.
+
+      - type: llm-rubric
+        metric: citation_quality
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score citation quality from 0.0 to 1.0:
+          1.0 = references are precise and relevant to the claims they support.
+          0.7 = references are mostly useful but might miss minor details or include slight misalignment.
+          0.4 = many references are vague, misplaced, or missing for key statements.
+          0.0 = no citations or completely unhelpful citations.
+
+          Judge only the candidate answer. The fixture checkout is separate from this runner workspace.
+
+      - type: llm-rubric
+        metric: actionability
+        threshold: 0.7
+        provider: file://scripts/promptfoo-grader-provider.mjs
+        value: |
+          Score actionability from 0.0 to 1.0:
+          1.0 = provides clear, concrete next steps or precise code locations so a developer or agent can act immediately.
+          0.7 = suggests concrete next steps but requires some interpretation.
+          0.4 = broad suggestions without clear instructions or code locations.
+          0.0 = vague, generic advice that cannot be directly acted upon.
+
+          Judge only the candidate answer.
diff --git a/packages/open-agents/evals/promptfooconfig.yaml b/packages/open-agents/evals/promptfooconfig.yaml
index 4cd8ca4..350d126 100644
--- a/packages/open-agents/evals/promptfooconfig.yaml
+++ b/packages/open-agents/evals/promptfooconfig.yaml
@@ -9,7 +9,6 @@ providers:
   - 'exec: node ./scripts/promptfoo-provider.mjs'
 
 tests:
-  # 1. Smoke test: fixture preparation only.
   - vars:
       fixture: nextbase-supabase-starter
       scenario: fixture-prepare-smoke
@@ -22,86 +21,3 @@ tests:
         value: '"ok":true'
       - type: contains
         value: '"fixture":"nextbase-supabase-starter"'
-
-  # 2. Real explore test: runs the explore agent and performs LLM-as-judge grading.
-  - vars:
-      fixture: nextbase-supabase-starter
-      scenario: explore-private-items
-      tailChars: 50000
-      goal: In the pinned Supabase starter fixture, trace how the private-items CRUD flow is structured from route/page entry points through server/data access and Supabase calls. Cite relevant files and lines. Do not modify files.
-      context: Trace route/page entry points, server/data access, and Supabase client calls for private-items CRUD.
-      historyPointer: not wired.
-    assert:
-      - type: contains
-        value: 'private'
-      - type: contains
-        value: 'Supabase'
-      - type: javascript
-        value: |
-          // Verify that output contains a path:line citation
-          return /[\w.-]+\.\w+:(?:L)?\d+/.test(output);
-
-      - type: llm-rubric
-        metric: coverage
-        threshold: 0.7
-        provider: file://scripts/promptfoo-grader-provider.mjs
-        value: |
-          Score coverage from 0.0 to 1.0:
-          1.0 = identifies all important implementation areas needed for the task.
-          0.7 = covers the main implementation path but misses minor useful details.
-          0.4 = partial answer; misses important modules or relationships.
-          0.0 = mostly unrelated or not enough detail to act.
-
-          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory.
-
-      - type: llm-rubric
-        metric: usefulness
-        threshold: 0.7
-        provider: file://scripts/promptfoo-grader-provider.mjs
-        value: |
-          Score usefulness from 0.0 to 1.0:
-          1.0 = a developer could confidently use this to make the next decision.
-          0.7 = useful with small follow-up inspection.
-          0.4 = somewhat useful but requires substantial rework.
-          0.0 = not useful.
-
-          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory.
-
-      - type: llm-rubric
-        metric: hallucination_safety
-        threshold: 0.8
-        provider: file://scripts/promptfoo-grader-provider.mjs
-        value: |
-          Score hallucination safety from 0.0 to 1.0:
-          1.0 = claims are grounded in cited files or clearly marked as inference.
-          0.7 = mostly grounded, with minor uncited claims.
-          0.4 = several unsupported claims.
-          0.0 = fabricates files, APIs, behavior, or line numbers.
-
-          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory. Assume the files cited exist in the fixture repo.
-
-      - type: llm-rubric
-        metric: citation_quality
-        threshold: 0.7
-        provider: file://scripts/promptfoo-grader-provider.mjs
-        value: |
-          Score citation quality from 0.0 to 1.0:
-          1.0 = all references point directly to exact files and valid line numbers that exist and are relevant.
-          0.7 = references are mostly relevant and correct but might miss minor details or include slight misalignment.
-          0.4 = many references are vague, point to incorrect files/lines, or are missing for key statements.
-          0.0 = no citations or completely incorrect/fabricated citations.
-
-          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory. Assume the files cited exist in the fixture repo.
-
-      - type: llm-rubric
-        metric: actionability
-        threshold: 0.7
-        provider: file://scripts/promptfoo-grader-provider.mjs
-        value: |
-          Score actionability from 0.0 to 1.0:
-          1.0 = provides clear, concrete next steps, command suggestions, or precise file edits so a developer or agent can act immediately.
-          0.7 = suggests concrete next steps but requires some interpretation or minor planning.
-          0.4 = broad suggestions without clear instructions or code locations.
-          0.0 = vague, generic advice that cannot be directly acted upon.
-
-          Note: The candidate output was generated against the checked-out fixture repository (not this runner workspace). Do not attempt to locate the files in the current workspace directory.
diff --git a/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs
index 6059f85..3289885 100644
--- a/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs
+++ b/packages/open-agents/evals/scripts/promptfoo-grader-provider.mjs
@@ -1,7 +1,95 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DEFAULT_MODEL = 'gemini-3.1-flash-lite-preview';
+const DEFAULT_TIMEOUT_MS = 120000;
+
+function resolveGeminiCommand() {
+  const env = process.env.GEMINI_CLI_BIN;
+  if (env && env.trim()) {
+    return { bin: env.trim(), prelaunchArgs: [], shell: false };
+  }
+
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA;
+    if (appData) {
+      const bundle = join(appData, 'npm', 'node_modules', '@google', 'gemini-cli', 'bundle', 'gemini.js');
+      const dist = join(appData, 'npm', 'node_modules', '@google', 'gemini-cli', 'dist', 'index.js');
+      if (existsSync(bundle)) return { bin: 'node', prelaunchArgs: [bundle], shell: false };
+      if (existsSync(dist)) return { bin: 'node', prelaunchArgs: [dist], shell: false };
+    }
+  }
+
+  return { bin: 'gemini', prelaunchArgs: [], shell: process.platform === 'win32' };
+}
+
+function findJsonObject(text) {
+  const cleaned = text
+    .replace(/```(?:json)?/gi, '')
+    .replace(/```/g, '')
+    .trim();
+  try {
+    return JSON.stringify(JSON.parse(cleaned));
+  } catch {
+    // Continue to brace extraction.
+  }
+
+  const start = cleaned.indexOf('{');
+  const end = cleaned.lastIndexOf('}');
+  if (start === -1 || end <= start) return null;
+  const candidate = cleaned.slice(start, end + 1);
+  try {
+    return JSON.stringify(JSON.parse(candidate));
+  } catch {
+    return null;
+  }
+}
+
+function pickModelText(value) {
+  if (typeof value === 'string') return value;
+  if (!value || typeof value !== 'object') return '';
+  for (const key of ['response', 'result', 'text', 'message', 'content', 'output']) {
+    const found = pickModelText(value[key]);
+    if (found) return found;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = pickModelText(item);
+      if (found) return found;
+    }
+  }
+  return '';
+}
+
+function normalizeGeminiOutput(stdout) {
+  const raw = stdout || '';
+  try {
+    const parsed = JSON.parse(raw);
+    const modelText = pickModelText(parsed);
+    return findJsonObject(modelText) || findJsonObject(raw) || modelText || raw;
+  } catch {
+    return findJsonObject(raw) || raw.trim();
+  }
+}
+
+function buildStrictPrompt(prompt) {
+  return `You are a strict Promptfoo LLM-as-judge grader.
+
+Follow the grading instructions below. Return only a JSON object with this exact shape:
+{"pass": boolean, "score": number, "reason": string}
+
+Rules:
+- score must be a number from 0.0 to 1.0.
+- pass should be true only when the score satisfies the rubric threshold implied by the prompt.
+- reason must be concise and cite the main evidence from the candidate answer.
+- Do not include markdown fences, prose outside JSON, or extra keys.
+
+${prompt}`;
+}
 
 export default class GeminiGraderProvider {
-  constructor(options) {
+  constructor(options = {}) {
     this.config = options.config || {};
   }
 
@@ -9,28 +97,48 @@ export default class GeminiGraderProvider {
     return 'gemini-grader';
   }
 
-  async callApi(prompt, context) {
-    try {
-      const result = spawnSync('gemini', ['-m', 'gemini-3.1-flash-lite-preview', '--skip-trust'], {
-        input: prompt,
+  async callApi(prompt) {
+    const { bin, prelaunchArgs, shell } = resolveGeminiCommand();
+    const model = this.config.model || process.env.OPEN_AGENTS_EVAL_GRADER_MODEL || DEFAULT_MODEL;
+    const timeout = Number(
+      this.config.timeoutMs || process.env.OPEN_AGENTS_EVAL_GRADER_TIMEOUT_MS || DEFAULT_TIMEOUT_MS,
+    );
+    const strictPrompt = buildStrictPrompt(prompt);
+
+    const result = spawnSync(
+      bin,
+      [
+        ...prelaunchArgs,
+        '-m',
+        model,
+        '-o',
+        'json',
+        '--skip-trust',
+        '-p',
+        strictPrompt,
+      ],
+      {
         encoding: 'utf8',
-        shell: process.platform === 'win32',
-      });
-
-      if (result.error) {
-        return { error: `Spawn error: ${result.error.message}` };
-      }
-      if (result.status !== 0) {
-        return { error: `Gemini exited with status ${result.status}: ${result.stderr || result.stdout}` };
-      }
-
-      // Clean up tool setup logging warnings from output if any
-      let outputText = result.stdout || '';
-      outputText = outputText.replace(/Ripgrep is not available\. Falling back to GrepTool\.\r?\n?/g, '').trim();
-
-      return { output: outputText };
-    } catch (e) {
-      return { error: `Grader exception: ${e instanceof Error ? e.message : String(e)}` };
+        shell,
+        timeout,
+        windowsHide: true,
+      },
+    );
+
+    if (result.error) {
+      return { error: `Gemini grader spawn error: ${result.error.message}` };
+    }
+    if (result.status !== 0) {
+      return {
+        error: `Gemini grader exited with status ${result.status}: ${result.stderr || result.stdout}`,
+      };
+    }
+
+    const output = normalizeGeminiOutput(result.stdout);
+    const strictJson = findJsonObject(output);
+    if (!strictJson) {
+      return { error: `Gemini grader did not return JSON: ${output.slice(0, 500)}` };
     }
+    return { output: strictJson };
   }
 }
diff --git a/packages/open-agents/evals/scripts/promptfoo-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
index 1bbf334..71fb9ad 100644
--- a/packages/open-agents/evals/scripts/promptfoo-provider.mjs
+++ b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
@@ -30,8 +30,14 @@ const variant = /Variant B/.test(prompt)
   : /Variant C/.test(prompt)
     ? 'c-spec-writer-title-tail-history'
     : 'a-main-agent-spec';
+const safeSegment = (value) =>
+  String(value)
+    .replace(/[^A-Za-z0-9._-]+/g, '-')
+    .replace(/^-|-$/g, '');
+const scenarioId = safeSegment(scenario);
+const variantId = safeSegment(variant);
 const runPath = join(repoRoot, '.davstack', 'evals', 'runs', runId);
-const casePath = join(runPath, 'cases', variant);
+const casePath = join(runPath, 'cases', scenarioId, variantId);
 
 function writeJson(path, value) {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
@@ -53,7 +59,7 @@ try {
   const prepared = prepareFixture({
     fixture,
     runId,
-    variant,
+    variant: `${scenarioId}-${variantId}`,
     workRoot: options.workRoot,
     fresh: true,
     quiet: true,
@@ -69,30 +75,45 @@ try {
   const isSmoke = scenario === 'fixture-prepare-smoke';
 
   if (!isSmoke) {
-    const exploreBin = resolve(repoRoot, 'packages', 'open-agents', 'bin', 'explore.mjs');
-    const resultRun = spawnSync('node', [
-      exploreBin,
-      'submit',
-      '--cwd', prepared.checkoutPath,
-      '--file', join(casePath, 'input.md'),
-      '--provider', 'gemini'
-    ], {
-      encoding: 'utf8',
-      shell: process.platform === 'win32',
-    });
-
-    agentExitCode = resultRun.status ?? 0;
+    const exploreEntry = resolve(repoRoot, 'packages', 'open-agents', 'src', 'entrypoints', 'explore.ts');
+    const agentProvider =
+      vars.agentProvider || options.agentProvider || process.env.OPEN_AGENTS_EVAL_AGENT_PROVIDER || 'gemini';
+    const resultRun = spawnSync(
+      'bun',
+      [
+        exploreEntry,
+        'submit',
+        '--cwd',
+        prepared.checkoutPath,
+        '--file',
+        join(casePath, 'input.md'),
+        '--provider',
+        agentProvider,
+      ],
+      {
+        encoding: 'utf8',
+        shell: false,
+        timeout: Number(process.env.OPEN_AGENTS_EVAL_AGENT_TIMEOUT_MS || options.agentTimeoutMs || 600000),
+      },
+    );
+
+    agentExitCode = resultRun.status ?? (resultRun.error || resultRun.signal ? 1 : 0);
     const stdout = resultRun.stdout || '';
     const match = stdout.match(/RESULT_PATH:\s*(.+)/);
     if (match && match[1]) {
       const resultPath = match[1].trim();
       if (existsSync(resultPath)) {
         agentText = readFileSync(resultPath, 'utf8');
-        writeFileSync(join(casePath, 'output.md'), agentText);
+      } else {
+        agentText = `Agent reported missing result path: ${resultPath}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`;
       }
     } else {
-      agentText = `Agent run failed with exit code ${agentExitCode}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`;
+      agentText =
+        `Agent run failed with exit code ${agentExitCode}` +
+        (resultRun.error ? ` (${resultRun.error.message})` : '') +
+        `\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`;
     }
+    writeFileSync(join(casePath, 'output.md'), agentText);
 
     // Check if any files were changed in the checkout path
     const gitStatus = spawnSync('git', ['status', '--porcelain'], {
@@ -110,7 +131,7 @@ try {
     fixture,
     scenario,
     variant,
-    caseId: variant,
+    caseId: `${scenarioId}/${variantId}`,
     promptChars: prompt.length,
     checkoutPath: prepared.checkoutPath,
     commit: prepared.actualCommit,
@@ -148,7 +169,9 @@ try {
   writeJson(join(casePath, 'manual-review.json'), blankManualReview());
 
   if (!keepRun && prepared.ok) {
-    rmSync(prepared.checkoutPath, { recursive: true, force: true });
+    if (isSmoke) {
+      rmSync(prepared.checkoutPath, { recursive: true, force: true });
+    }
   }
 
   if (isSmoke) {
@@ -162,7 +185,7 @@ try {
     fixture,
     scenario,
     variant,
-    caseId: variant,
+    caseId: `${scenarioId}/${variantId}`,
     promptChars: prompt.length,
     error: error instanceof Error ? error.message : String(error),
   };
diff --git a/packages/open-agents/evals/scripts/run-promptfoo.mjs b/packages/open-agents/evals/scripts/run-promptfoo.mjs
index d667f44..3ec07c8 100644
--- a/packages/open-agents/evals/scripts/run-promptfoo.mjs
+++ b/packages/open-agents/evals/scripts/run-promptfoo.mjs
@@ -12,31 +12,35 @@ const runId =
   process.env.OPEN_AGENTS_EVAL_RUN_ID ||
   process.argv.find((arg) => arg.startsWith('--run-id='))?.slice('--run-id='.length) ||
   'smoke';
+const config =
+  process.argv.find((arg) => arg.startsWith('--config='))?.slice('--config='.length) ||
+  'promptfooconfig.yaml';
 
 const outDir = join(repoRoot, '.davstack', 'evals', 'runs', runId);
 mkdirSync(outDir, { recursive: true });
 
 const startedAt = new Date().toISOString();
-writeFileSync(
-  join(outDir, 'run.json'),
-  `${JSON.stringify(
-    {
-      runId,
-      startedAt,
-      config: 'packages/open-agents/evals/promptfooconfig.yaml',
-      command: 'promptfoo eval',
-    },
-    null,
-    2,
-  )}\n`,
-);
 
-const extraArgs = process.argv.slice(2).filter((arg) => !arg.startsWith('--run-id=') && arg !== '--');
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+writeJson(join(outDir, 'run.json'), {
+  runId,
+  startedAt,
+  config: `packages/open-agents/evals/${config}`,
+  command: 'promptfoo eval',
+});
+
+const extraArgs = process.argv
+  .slice(2)
+  .filter((arg) => !arg.startsWith('--run-id=') && !arg.startsWith('--config=') && arg !== '--');
 const args = [
   'promptfoo@latest',
   'eval',
   '-c',
-  'promptfooconfig.yaml',
+  config,
+  '--no-cache',
   '--output',
   join(outDir, 'promptfoo-results.json'),
   ...extraArgs,
@@ -52,206 +56,74 @@ const result = spawnSync('npx', args, {
   },
 });
 
-function readCaseSummary(caseId) {
-  const caseDir = join(outDir, 'cases', caseId);
-  const scoresPath = join(caseDir, 'scores.json');
-  const reviewPath = join(caseDir, 'manual-review.json');
-  const scores = existsSync(scoresPath)
-    ? JSON.parse(readFileSync(scoresPath, 'utf8'))
-    : {};
-  const review = existsSync(reviewPath)
-    ? JSON.parse(readFileSync(reviewPath, 'utf8'))
-    : {};
-  return { caseId, scores, review };
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return fallback;
+  }
 }
 
-function generateMarkdownReport(resultsJsonPath) {
-  if (!existsSync(resultsJsonPath)) {
-    return '';
-  }
-  try {
-    const data = JSON.parse(readFileSync(resultsJsonPath, 'utf8'));
-    const results = data.results?.results || [];
-    
-    // Group results by scenario
-    const scenarios = {};
-    for (const r of results) {
-      const scenario = r.testCase?.vars?.scenario || 'unknown';
-      if (!scenarios[scenario]) {
-        scenarios[scenario] = [];
+function listCaseDirs(root) {
+  if (!existsSync(root)) return [];
+  const out = [];
+  for (const scenarioEntry of readdirSync(root, { withFileTypes: true })) {
+    if (!scenarioEntry.isDirectory()) continue;
+    const scenarioDir = join(root, scenarioEntry.name);
+    for (const caseEntry of readdirSync(scenarioDir, { withFileTypes: true })) {
+      if (caseEntry.isDirectory()) {
+        out.push({
+          caseId: `${scenarioEntry.name}/${caseEntry.name}`,
+          path: join(scenarioDir, caseEntry.name),
+        });
       }
-      scenarios[scenario].push(r);
     }
-    
-    let reportContent = '';
-    
-    for (const [scenarioName, scenarioRuns] of Object.entries(scenarios)) {
-      reportContent += `\n### LLM-Graded Performance Summary (${scenarioName})\n\n`;
-      
-      // Get all unique variants in this scenario
-      const getVariantName = (r) => {
-        const variantStr = r.testCase?.vars?.variant || r.response?.output?.variant || '';
-        if (variantStr) return variantStr;
-        
-        const rawPrompt = r.prompt?.raw || '';
-        const firstLine = rawPrompt.split('\n')[0].trim();
-        if (firstLine.startsWith('# ')) {
-          const match = firstLine.slice(2).match(/^(Variant\s+[A-Z]):\s*(.*)$/i);
-          if (match) {
-            return `${match[1]} (${match[2]})`;
-          }
-          return firstLine.slice(2);
-        }
-        
-        if (/Variant A/i.test(rawPrompt)) return 'Variant A';
-        if (/Variant B/i.test(rawPrompt)) return 'Variant B';
-        if (/Variant C/i.test(rawPrompt)) return 'Variant C';
-        return r.prompt?.label?.split(':')[0] || 'Unknown Variant';
-      };
+  }
+  return out;
+}
 
-      const variants = Array.from(new Set(scenarioRuns.map(getVariantName)));
-      variants.sort();
-      
-      // Map runs by variant name
-      const runsByVariant = {};
-      for (const r of scenarioRuns) {
-        const varName = getVariantName(r);
-        runsByVariant[varName] = r;
-      }
-      
-      // Extract all unique assertions/metrics across all runs
-      const assertionMap = new Map();
-      for (const r of scenarioRuns) {
-        const componentResults = r.gradingResult?.componentResults || [];
-        for (const cr of componentResults) {
-          const ass = cr.assertion || {};
-          const key = ass.metric || `${ass.type}:${ass.value}`;
-          if (!assertionMap.has(key)) {
-            assertionMap.set(key, ass);
-          }
-        }
-      }
-      
-      // Build markdown table header
-      const headers = ['Metric (Min Threshold)', ...variants];
-      const divider = headers.map(() => '---');
-      
-      reportContent += `| ${headers.join(' | ')} |\n`;
-      reportContent += `| ${divider.join(' | ')} |\n`;
-      
-      // Populate rows
-      for (const [key, ass] of assertionMap.entries()) {
-        const rowCells = [];
-        
-        let metricName = ass.metric || '';
-        if (!metricName) {
-          if (ass.type === 'contains') {
-            metricName = ass.value;
-          } else if (ass.type === 'javascript') {
-            metricName = `Citation Format`;
-          } else {
-            metricName = `${ass.type} (${ass.value})`;
-          }
-        }
-        
-        const thresholdSuffix = ass.threshold ? ` (${ass.threshold})` : ' (Pass/Fail)';
-        rowCells.push(`${metricName}${thresholdSuffix}`);
-        
-        for (const variantName of variants) {
-          const run = runsByVariant[variantName];
-          if (!run) {
-            rowCells.push('-');
-            continue;
-          }
-          
-          if (run.error && !run.gradingResult) {
-            const cleanErr = run.error.replace(/\r?\n/g, ' ').replace(/\|/g, '\\|').slice(0, 50);
-            rowCells.push(`ERROR: ${cleanErr}...`);
-            continue;
-          }
-          
-          const cr = run.gradingResult?.componentResults?.find(c => {
-            const ca = c.assertion || {};
-            const ckey = ca.metric || `${ca.type}:${ca.value}`;
-            return ckey === key;
-          });
-          
-          if (!cr) {
-            rowCells.push('-');
-          } else {
-            const hasScore = typeof cr.score === 'number';
-            const isRubric = key.includes('coverage') || key.includes('usefulness') || key.includes('safety') || key.includes('quality') || key.includes('actionability') || ass.type === 'llm-rubric';
-            
-            let cleanReason = cr.reason || '';
-            if (cleanReason.includes('Custom function returned false')) {
-              const commentMatch = cleanReason.match(/\/\/\s*(.*)/);
-              cleanReason = commentMatch ? commentMatch[1].trim() : 'custom assertion failed';
-            }
-            
-            if (cleanReason.includes('Verify that output contains a path:line citation') || cleanReason.includes('path:line citation')) {
-              cleanReason = 'no path:line format found';
-            } else if (cleanReason.startsWith('Expected output to contain ')) {
-              const term = cleanReason.match(/"(.*)"/)?.[1] || '';
-              cleanReason = term ? `did not mention "${term}"` : cleanReason;
-            } else {
-              const howeverMatch = cleanReason.match(/However,\s*(.*)/i);
-              if (howeverMatch) {
-                cleanReason = howeverMatch[1];
-              }
-              if (cleanReason.includes('descriptive rather than actively guiding') || cleanReason.includes('making it descriptive')) {
-                cleanReason = 'purely descriptive';
-              } else if (cleanReason.includes('lacks any actionable directives') || cleanReason.includes('lacked next steps') || cleanReason.includes('lacks actionable')) {
-                cleanReason = 'lacked next steps';
-              }
-              if (cleanReason.length > 50) {
-                cleanReason = cleanReason.slice(0, 47) + '...';
-              }
-            }
+function readCaseSummary(entry) {
+  const scores = readJson(join(entry.path, 'scores.json'), {});
+  const review = readJson(join(entry.path, 'manual-review.json'), {});
+  return { caseId: entry.caseId, scores, review };
+}
 
-            let cellText = '';
-            if (cr.pass) {
-              if (isRubric && hasScore) {
-                cellText = `PASS (Score: ${cr.score.toFixed(1)})`;
-              } else {
-                cellText = 'PASS';
-              }
-            } else {
-              const reasonSuffix = cleanReason ? ` - ${cleanReason}` : '';
-              if (isRubric && hasScore) {
-                cellText = `FAIL (Score: ${cr.score.toFixed(1)}${reasonSuffix})`;
-              } else {
-                cellText = `FAIL${cleanReason ? ` (${cleanReason})` : ''}`;
-              }
-            }
-            rowCells.push(cellText);
-          }
-        }
-        reportContent += `| ${rowCells.join(' | ')} |\n`;
-      }
-      reportContent += '\n';
-    }
-    return reportContent;
-  } catch (err) {
-    return `\n*Failed to generate performance summary: ${err.message}*\n`;
-  }
+function promptfooSummary(resultsJsonPath) {
+  if (!existsSync(resultsJsonPath)) return '';
+  const data = readJson(resultsJsonPath, {});
+  const results = data.results?.results || [];
+  if (!Array.isArray(results) || results.length === 0) return '';
+
+  const rows = results
+    .map((run) => {
+      const scenario = run.testCase?.vars?.scenario || 'unknown';
+      const prompt = run.prompt?.raw || '';
+      const firstLine = prompt.split('\n')[0]?.replace(/^#\s*/, '') || 'unknown';
+      const pass = run.gradingResult?.pass === false || run.success === false ? 'fail' : 'pass';
+      const score =
+        typeof run.gradingResult?.score === 'number' ? run.gradingResult.score.toFixed(2) : '';
+      return `| ${scenario} | ${firstLine} | ${pass} | ${score} |`;
+    })
+    .join('\n');
+
+  return `
+## Promptfoo Results
+
+| Scenario | Prompt | Status | Score |
+| --- | --- | --- | --- |
+${rows}
+`;
 }
 
 function writeReport(finishedAt) {
-  const casesDir = join(outDir, 'cases');
-  const cases = existsSync(casesDir)
-    ? readdirSync(casesDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => readCaseSummary(entry.name))
-    : [];
+  const cases = listCaseDirs(join(outDir, 'cases')).map(readCaseSummary);
   const rows = cases
     .map(
       (entry) =>
         `| ${entry.caseId} | ${entry.scores.ok === false ? 'fail' : 'pass'} | ${entry.review.status || 'unreviewed'} | ${entry.scores.promptChars ?? ''} |`,
     )
     .join('\n');
-
   const resultsJsonPath = join(outDir, 'promptfoo-results.json');
-  const dynamicTables = generateMarkdownReport(resultsJsonPath);
 
   writeFileSync(
     join(outDir, 'report.md'),
@@ -260,33 +132,30 @@ function writeReport(finishedAt) {
 - Started: ${startedAt}
 - Finished: ${finishedAt}
 - Promptfoo status: ${result.status ?? 1}
+- Promptfoo config: ${config}
 - Promptfoo results: promptfoo-results.json
 
-| Case | Smoke status | Manual review | Prompt chars |
+## Cases
+
+| Case | Provider status | Manual review | Prompt chars |
 | --- | --- | --- | --- |
 ${rows || '| _none_ | _none_ | _none_ | _none_ |'}
 
-${dynamicTables}
+${promptfooSummary(resultsJsonPath)}
 `,
   );
 }
 
-writeFileSync(
-  join(outDir, 'run.json'),
-  `${JSON.stringify(
-    {
-      runId,
-      startedAt,
-      finishedAt: new Date().toISOString(),
-      status: result.status ?? 1,
-      config: 'packages/open-agents/evals/promptfooconfig.yaml',
-      command: 'promptfoo eval',
-      resultPath: join(outDir, 'promptfoo-results.json'),
-    },
-    null,
-    2,
-  )}\n`,
-);
-writeReport(new Date().toISOString());
+const finishedAt = new Date().toISOString();
+writeJson(join(outDir, 'run.json'), {
+  runId,
+  startedAt,
+  finishedAt,
+  status: result.status ?? 1,
+  config: `packages/open-agents/evals/${config}`,
+  command: 'promptfoo eval',
+  resultPath: join(outDir, 'promptfoo-results.json'),
+});
+writeReport(finishedAt);
 
 process.exit(result.status ?? 1);
diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index 59a8a31..3c115ac 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -9,7 +9,8 @@
     "prepublishOnly": "tsup",
     "test": "pnpm -w exec vitest run --project open-agents",
     "eval": "node evals/scripts/run-promptfoo.mjs",
-    "eval:smoke": "node evals/scripts/run-promptfoo.mjs --run-id=smoke"
+    "eval:smoke": "node evals/scripts/run-promptfoo.mjs --config=promptfooconfig.yaml --run-id=smoke",
+    "eval:explore": "node evals/scripts/run-promptfoo.mjs --config=promptfooconfig.explore.yaml --run-id=explore-private-items"
   },
   "bin": {
     "explore": "./bin/explore.mjs",

From 1377f25f7089682ab4074af95d86d651a09b5c5c Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 19:58:39 +0100
Subject: [PATCH 27/72] feat: add compact open-agents handoff mode

Add --compact-mode to open-agents submit. Compact mode treats the user's input as a short task title, requires a history file, extracts a fixed 50k token-like tail, runs a Cursor composer-2.5 spec-writer job, and then submits the generated spec to the selected executor provider.

The spec-writer prompt now prioritizes a dense <context> block with relevant files, folders, project facts, original user query, useful quotes, decisions, constraints, and caveats. It avoids <acceptance> unless the history explicitly calls for one.

Also extend the eval harness artifacts for title-tail and spec-writer variants so generated specs, recent tails, history snapshots, and executor outputs are persisted for comparison.
---
 packages/open-agents/README.md                |   7 +
 .../open-agents/__tests__/compact.test.ts     |  22 ++
 packages/open-agents/evals/README.md          |  13 +
 .../evals/promptfooconfig.explore.yaml        |   2 +-
 .../open-agents/evals/promptfooconfig.yaml    |   2 +-
 .../evals/prompts/b-title-tail-history.md     |   5 +-
 .../c-spec-writer-title-tail-history.md       |   9 +-
 .../evals/scripts/promptfoo-provider.mjs      | 294 +++++++++++++++---
 packages/open-agents/src/cli.ts               |  98 +++++-
 packages/open-agents/src/core/compact.ts      | 111 +++++++
 .../open-agents/src/profiles/spec-writer.ts   |  20 ++
 11 files changed, 536 insertions(+), 47 deletions(-)
 create mode 100644 packages/open-agents/__tests__/compact.test.ts
 create mode 100644 packages/open-agents/src/core/compact.ts
 create mode 100644 packages/open-agents/src/profiles/spec-writer.ts

diff --git a/packages/open-agents/README.md b/packages/open-agents/README.md
index 221434c..0cab854 100644
--- a/packages/open-agents/README.md
+++ b/packages/open-agents/README.md
@@ -38,6 +38,13 @@ submit --file a.md [--file b.md …] | "<inline>"  [--edit] [--model m] [--timeo
         many --file ⇒ run in parallel · --detach: print bare id(s), don't wait
         --parallel-mode asap|all-together (default asap): asap prints each
           index line as its job finishes; all-together waits, submission order
+        --compact-mode: treat the input as a short task title, require
+          --history-file <path> or OPEN_AGENTS_HISTORY_FILE, run a Cursor
+          composer-2.5 spec-writer over the last 50000 token-like history
+          units, then submit the generated spec to the chosen executor. The
+          generated spec should emphasize a dense <context> block, including
+          relevant files/folders, project facts, original user query, and useful
+          short quotes from the conversation.
 wait                        wait for ALL running jobs (this repo)
 wait   "<id…>" | <id…>      wait for ALL of these
 wait   --any <id…>          return when ≥1 done; prints which (loop = popcorn)
diff --git a/packages/open-agents/__tests__/compact.test.ts b/packages/open-agents/__tests__/compact.test.ts
new file mode 100644
index 0000000..75443a6
--- /dev/null
+++ b/packages/open-agents/__tests__/compact.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, test } from 'vitest';
+import { tokenTail } from '../src/core/compact.js';
+import { parseFlags } from '../src/cli.js';
+
+describe('compact mode helpers', () => {
+  test('tokenTail keeps the last token-like units', () => {
+    expect(tokenTail('one two three four', 2)).toBe('three four');
+    expect(tokenTail('one, two. three!', 4)).toBe('two. three!');
+  });
+
+  test('compact flags parse', () => {
+    const { flags, positional } = parseFlags([
+      '--compact-mode',
+      '--history-file',
+      'C:/history.jsonl',
+      'short task',
+    ]);
+    expect(flags.compactMode).toBe(true);
+    expect(flags.historyFile).toBe('C:/history.jsonl');
+    expect(positional).toEqual(['short task']);
+  });
+});
diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
index 9a8d483..bc98c60 100644
--- a/packages/open-agents/evals/README.md
+++ b/packages/open-agents/evals/README.md
@@ -131,10 +131,23 @@ The eval provider should generate/copy:
 - `cases/<case-id>/output.md`;
 - `cases/<case-id>/input.md`;
 - `cases/<case-id>/history.jsonl`;
+- `cases/<case-id>/recent-tail.md`;
 - `cases/<case-id>/scores.json`;
 - objective checks that Promptfoo can assert on, such as citation count and
   valid citation ranges.
 
+For the spec-writer hybrid variant, the provider also writes:
+
+- `cases/<case-id>/spec-writer-input.md`;
+- `cases/<case-id>/generated-spec.md`;
+- `cases/<case-id>/spec-writer-job.json` when the spec-writer agent actually
+  runs.
+
+Set `tailTokens: 50000` plus either `historyText` or `historyPath` in Promptfoo
+vars/options to feed the spec writer a recent history tail. If no history source
+is provided, smoke runs use a small synthetic history snapshot from the test
+vars so artifact plumbing remains deterministic.
+
 Humans should only add:
 
 - coverage score;
diff --git a/packages/open-agents/evals/promptfooconfig.explore.yaml b/packages/open-agents/evals/promptfooconfig.explore.yaml
index b2722fb..45b70df 100644
--- a/packages/open-agents/evals/promptfooconfig.explore.yaml
+++ b/packages/open-agents/evals/promptfooconfig.explore.yaml
@@ -12,7 +12,7 @@ tests:
   - vars:
       fixture: nextbase-supabase-starter
       scenario: explore-private-items
-      tailChars: 50000
+      tailTokens: 50000
       goal: In the pinned Supabase starter fixture, trace how the private-items CRUD flow is structured from route/page entry points through server/data access and Supabase calls. Cite relevant files and lines. Do not modify files.
       context: Trace route/page entry points, server/data access, and Supabase client calls for private-items CRUD.
       historyPointer: not wired.
diff --git a/packages/open-agents/evals/promptfooconfig.yaml b/packages/open-agents/evals/promptfooconfig.yaml
index 350d126..7510851 100644
--- a/packages/open-agents/evals/promptfooconfig.yaml
+++ b/packages/open-agents/evals/promptfooconfig.yaml
@@ -12,7 +12,7 @@ tests:
   - vars:
       fixture: nextbase-supabase-starter
       scenario: fixture-prepare-smoke
-      tailChars: 50000
+      tailTokens: 50000
       goal: Prepare the pinned fixture repo and report whether the checkout is available for open-agents handoff testing.
       context: This prompt stands in for the current baseline where the main agent writes a detailed execution spec before delegating.
       historyPointer: not wired in this smoke slice.
diff --git a/packages/open-agents/evals/prompts/b-title-tail-history.md b/packages/open-agents/evals/prompts/b-title-tail-history.md
index af6a68d..12552fb 100644
--- a/packages/open-agents/evals/prompts/b-title-tail-history.md
+++ b/packages/open-agents/evals/prompts/b-title-tail-history.md
@@ -2,6 +2,9 @@
 
 Task: {{goal}}
 
-Recent history tail budget: {{tailChars}} chars.
+Recent history tail budget: {{tailTokens}} tokens.
 
 Full history pointer: {{historyPointer}}
+
+The provider appends the concrete recent history tail at the bottom of the
+submitted task prompt.
diff --git a/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md b/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
index 3be899a..90903e2 100644
--- a/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
+++ b/packages/open-agents/evals/prompts/c-spec-writer-title-tail-history.md
@@ -2,10 +2,11 @@
 
 Task title: {{goal}}
 
-Recent history tail budget: {{tailChars}} chars.
+Recent history tail budget: {{tailTokens}} tokens.
 
 Full history pointer: {{historyPointer}}
 
-In the full flow, this variant first asks a spec-writer agent to produce the
-execution spec. In this smoke slice, the provider only proves fixture
-preparation and Promptfoo plumbing.
+The provider gives the last {{tailTokens}} token-like units from the configured
+history source to a spec-writer agent at the bottom of its task prompt, persists
+the generated execution spec, then gives that generated spec to the executor
+agent.
diff --git a/packages/open-agents/evals/scripts/promptfoo-provider.mjs b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
index 71fb9ad..e82e335 100644
--- a/packages/open-agents/evals/scripts/promptfoo-provider.mjs
+++ b/packages/open-agents/evals/scripts/promptfoo-provider.mjs
@@ -55,6 +55,179 @@ function blankManualReview() {
   };
 }
 
+function tokenTail(text, maxTokens) {
+  const limit = Number(maxTokens);
+  if (!Number.isFinite(limit) || limit <= 0) return '';
+  const parts = text.match(/\s+|[A-Za-z0-9_]+|[^\sA-Za-z0-9_]/g) || [];
+  let tokens = 0;
+  let start = parts.length;
+  while (start > 0 && tokens < limit) {
+    start -= 1;
+    if (!/^\s+$/.test(parts[start])) tokens += 1;
+  }
+  return parts.slice(start).join('').trim();
+}
+
+function historySnapshot() {
+  if (typeof vars.historyText === 'string') {
+    return {
+      text: vars.historyText,
+      pointer: vars.historyPointer || 'vars.historyText',
+      source: 'vars.historyText',
+    };
+  }
+
+  const historyPath = vars.historyPath || options.historyPath;
+  if (historyPath) {
+    const resolved = resolve(String(historyPath));
+    return {
+      text: readFileSync(resolved, 'utf8'),
+      pointer: vars.historyPointer || resolved,
+      source: resolved,
+    };
+  }
+
+  const synthetic = [
+    JSON.stringify({
+      role: 'user',
+      content: vars.goal || prompt,
+    }),
+    JSON.stringify({
+      role: 'assistant',
+      content: vars.context || 'No external history was provided for this eval case.',
+    }),
+  ].join('\n');
+
+  return {
+    text: synthetic,
+    pointer: vars.historyPointer || 'synthetic eval history generated from test vars',
+    source: 'synthetic',
+  };
+}
+
+function buildSpecWriterPrompt({ goal, context, historyPointer, recentTail, tailTokens }) {
+  return `# Spec Writer: Hybrid ${tailTokens} Token Tail Handoff
+
+You are the spec-writer agent in a two-agent handoff.
+
+Task title:
+${goal}
+
+Known task context:
+${context || '(none)'}
+
+Full history pointer:
+${historyPointer}
+
+Write a detailed execution spec for the executor agent. Preserve the user's
+latest intent, scope, constraints, and non-goals. Do not solve the task yourself.
+Do not invent requirements that are not supported by the title, context, or
+history tail.
+
+Return only the execution spec, in this shape:
+
+<goal>
+...
+</goal>
+
+<context>
+...
+</context>
+
+<scope>
+...
+</scope>
+
+<constraints>
+...
+</constraints>
+
+<acceptance>
+...
+</acceptance>
+
+Recent history tail:
+The following block contains the last ${tailTokens} token-like units available
+from the provided history source. Use it as the primary source of recent intent.
+
+<recent_history_tail>
+${recentTail || '(empty)'}
+</recent_history_tail>
+`;
+}
+
+function appendRecentTail(prompt, { historyPointer, recentTail, tailTokens }) {
+  return `${prompt.trim()}
+
+Recent history tail:
+The following block contains the last ${tailTokens} token-like units available
+from the provided history source.
+
+Full history pointer:
+${historyPointer}
+
+<recent_history_tail>
+${recentTail || '(empty)'}
+</recent_history_tail>
+`;
+}
+
+function runExploreAgent({ inputPath, cwd, provider, timeoutMs }) {
+  const exploreEntry = resolve(repoRoot, 'packages', 'open-agents', 'src', 'entrypoints', 'explore.ts');
+  const resultRun = spawnSync(
+    'bun',
+    [
+      exploreEntry,
+      'submit',
+      '--cwd',
+      cwd,
+      '--file',
+      inputPath,
+      '--provider',
+      provider,
+    ],
+    {
+      encoding: 'utf8',
+      shell: false,
+      timeout: timeoutMs,
+    },
+  );
+
+  const exitCode = resultRun.status ?? (resultRun.error || resultRun.signal ? 1 : 0);
+  const stdout = resultRun.stdout || '';
+  const match = stdout.match(/RESULT_PATH:\s*(.+)/);
+  if (match && match[1]) {
+    const resultPath = match[1].trim();
+    if (existsSync(resultPath)) {
+      return {
+        exitCode,
+        stdout,
+        stderr: resultRun.stderr || '',
+        resultPath,
+        text: readFileSync(resultPath, 'utf8'),
+      };
+    }
+    return {
+      exitCode: exitCode || 1,
+      stdout,
+      stderr: resultRun.stderr || '',
+      resultPath,
+      text: `Agent reported missing result path: ${resultPath}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`,
+    };
+  }
+
+  return {
+    exitCode,
+    stdout,
+    stderr: resultRun.stderr || '',
+    resultPath: null,
+    text:
+      `Agent run failed with exit code ${exitCode}` +
+      (resultRun.error ? ` (${resultRun.error.message})` : '') +
+      `\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`,
+  };
+}
+
 try {
   const prepared = prepareFixture({
     fixture,
@@ -66,53 +239,79 @@ try {
   });
 
   mkdirSync(casePath, { recursive: true });
-  writeFileSync(join(casePath, 'input.md'), prompt);
-  writeFileSync(join(casePath, 'history.jsonl'), '');
+  const history = historySnapshot();
+  const tailTokens = Number(vars.tailTokens || vars.tailChars || options.tailTokens || 50000);
+  const recentTail = tokenTail(history.text, tailTokens);
+  writeFileSync(join(casePath, 'history.jsonl'), history.text);
+  writeFileSync(join(casePath, 'recent-tail.md'), recentTail ? `${recentTail}\n` : '');
 
   let agentText = '';
   let agentExitCode = 0;
+  let specWriterExitCode = null;
+  let generatedSpecChars = 0;
   let filesChanged = [];
   const isSmoke = scenario === 'fixture-prepare-smoke';
+  const agentProvider =
+    vars.agentProvider || options.agentProvider || process.env.OPEN_AGENTS_EVAL_AGENT_PROVIDER || 'gemini';
+  const agentTimeoutMs = Number(process.env.OPEN_AGENTS_EVAL_AGENT_TIMEOUT_MS || options.agentTimeoutMs || 600000);
+  const isSpecWriterVariant = variant === 'c-spec-writer-title-tail-history';
+  let executorInput = prompt;
 
-  if (!isSmoke) {
-    const exploreEntry = resolve(repoRoot, 'packages', 'open-agents', 'src', 'entrypoints', 'explore.ts');
-    const agentProvider =
-      vars.agentProvider || options.agentProvider || process.env.OPEN_AGENTS_EVAL_AGENT_PROVIDER || 'gemini';
-    const resultRun = spawnSync(
-      'bun',
-      [
-        exploreEntry,
-        'submit',
-        '--cwd',
-        prepared.checkoutPath,
-        '--file',
-        join(casePath, 'input.md'),
-        '--provider',
-        agentProvider,
-      ],
-      {
-        encoding: 'utf8',
-        shell: false,
-        timeout: Number(process.env.OPEN_AGENTS_EVAL_AGENT_TIMEOUT_MS || options.agentTimeoutMs || 600000),
-      },
-    );
-
-    agentExitCode = resultRun.status ?? (resultRun.error || resultRun.signal ? 1 : 0);
-    const stdout = resultRun.stdout || '';
-    const match = stdout.match(/RESULT_PATH:\s*(.+)/);
-    if (match && match[1]) {
-      const resultPath = match[1].trim();
-      if (existsSync(resultPath)) {
-        agentText = readFileSync(resultPath, 'utf8');
-      } else {
-        agentText = `Agent reported missing result path: ${resultPath}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`;
-      }
+  if (variant === 'b-title-tail-history') {
+    executorInput = appendRecentTail(prompt, {
+      historyPointer: history.pointer,
+      recentTail,
+      tailTokens,
+    });
+  }
+
+  if (isSpecWriterVariant) {
+    const specWriterPrompt = buildSpecWriterPrompt({
+      goal: vars.goal || prompt,
+      context: vars.context,
+      historyPointer: history.pointer,
+      recentTail,
+      tailTokens,
+    });
+    writeFileSync(join(casePath, 'spec-writer-input.md'), specWriterPrompt);
+
+    if (isSmoke) {
+      executorInput = `<goal>\n${vars.goal || prompt}\n</goal>\n\n<context>\n${vars.context || ''}\n\nGenerated from ${tailTokens} token tail source: ${history.source}.\n</context>\n\n<scope>\nFixture: ${fixture}\nScenario: ${scenario}\n</scope>\n\n<constraints>\nSmoke run only; do not launch an executor agent.\n</constraints>\n\n<acceptance>\nFixture preparation artifacts are created for this case.\n</acceptance>\n`;
     } else {
-      agentText =
-        `Agent run failed with exit code ${agentExitCode}` +
-        (resultRun.error ? ` (${resultRun.error.message})` : '') +
-        `\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${resultRun.stderr || ''}`;
+      const specWriterResult = runExploreAgent({
+        inputPath: join(casePath, 'spec-writer-input.md'),
+        cwd: prepared.checkoutPath,
+        provider: agentProvider,
+        timeoutMs: agentTimeoutMs,
+      });
+      specWriterExitCode = specWriterResult.exitCode;
+      executorInput = specWriterResult.text.trim();
+      writeJson(join(casePath, 'spec-writer-job.json'), {
+        exitCode: specWriterResult.exitCode,
+        resultPath: specWriterResult.resultPath,
+      });
+      if (specWriterResult.exitCode !== 0) {
+        agentExitCode = specWriterResult.exitCode || 1;
+        agentText = `Spec writer failed; executor was not launched.\n\n${specWriterResult.text}`;
+      }
     }
+
+    generatedSpecChars = executorInput.length;
+    writeFileSync(join(casePath, 'generated-spec.md'), executorInput.trim() + '\n');
+  }
+
+  writeFileSync(join(casePath, 'input.md'), executorInput);
+
+  if (!isSmoke && (!isSpecWriterVariant || specWriterExitCode === 0)) {
+    const executorResult = runExploreAgent({
+      inputPath: join(casePath, 'input.md'),
+      cwd: prepared.checkoutPath,
+      provider: agentProvider,
+      timeoutMs: agentTimeoutMs,
+    });
+
+    agentExitCode = executorResult.exitCode;
+    agentText = executorResult.text;
     writeFileSync(join(casePath, 'output.md'), agentText);
 
     // Check if any files were changed in the checkout path
@@ -124,6 +323,8 @@ try {
     if (gitStatus.status === 0 && gitStatus.stdout.trim()) {
       filesChanged = gitStatus.stdout.trim().split('\n').map(line => line.slice(3).trim());
     }
+  } else if (agentText) {
+    writeFileSync(join(casePath, 'output.md'), agentText);
   }
 
   const output = {
@@ -133,11 +334,16 @@ try {
     variant,
     caseId: `${scenarioId}/${variantId}`,
     promptChars: prompt.length,
+    executorPromptChars: executorInput.length,
+    tailTokens,
+    recentTailChars: recentTail.length,
+    generatedSpecChars,
     checkoutPath: prepared.checkoutPath,
     commit: prepared.actualCommit,
     retained: keepRun,
     filesChanged,
     agentExitCode,
+    specWriterExitCode,
   };
 
   writeJson(join(casePath, 'job.json'), {
@@ -152,6 +358,11 @@ try {
     retained: keepRun,
     filesChanged,
     agentExitCode,
+    specWriterExitCode,
+    historySource: history.source,
+    tailTokens,
+    recentTailChars: recentTail.length,
+    generatedSpecChars,
   });
 
   if (isSmoke) {
@@ -162,6 +373,11 @@ try {
     ok: output.ok,
     fixturePrepared: prepared.ok ? 1 : 0,
     promptChars: prompt.length,
+    executorPromptChars: executorInput.length,
+    tailTokens,
+    recentTailChars: recentTail.length,
+    generatedSpecChars,
+    specWriterExitCode,
     agentExitCode,
     filesChangedCount: filesChanged.length,
   });
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 0200648..6d02a24 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -19,6 +19,7 @@ import { agyAdapter } from './adapters/agy.js';
 import { cursorAdapter } from './adapters/cursor.js';
 import { geminiAdapter } from './adapters/gemini.js';
 import type { AgentAdapter, Tier } from './adapters/types.js';
+import { buildCompactSpecWriterTask, loadCompactHistory } from './core/compact.js';
 import { readDeliverable, renderJobResult } from './core/deliverable.js';
 import {
   createJob,
@@ -31,6 +32,7 @@ import { jobsDir } from './core/paths.js';
 import { DEFAULT_TIMEOUT_SEC, runJob } from './core/run.js';
 import { editProfile } from './profiles/edit.js';
 import { exploreProfile } from './profiles/explore.js';
+import { specWriterProfile } from './profiles/spec-writer.js';
 import type { Profile } from './profiles/types.js';
 import { loadConfig } from './config.js';
 import { runCheck } from './check.js';
@@ -67,6 +69,8 @@ export interface Flags {
   timeout?: number;
   parallelMode?: string;
   adapter?: string;
+  compactMode?: boolean;
+  historyFile?: string;
 }
 
 export function parseFlags(argv: string[]): { flags: Flags; positional: string[] } {
@@ -83,6 +87,7 @@ export function parseFlags(argv: string[]): { flags: Flags; positional: string[]
     const val = () => (inlineVal !== undefined ? inlineVal : argv[++i]);
     if (a === '--edit' || a === '--any' || a === '--all' || a === '--detach')
       (flags as any)[a.slice(2)] = true;
+    else if (a === '--compact-mode') flags.compactMode = true;
     else if (a === '--smarter') flags.tier = 'smarter';
     else if (a === '--faster') flags.tier = 'faster';
     else if (a === '--background' || a === '--bg' || a === '--no-wait') flags.detach = true;
@@ -93,6 +98,7 @@ export function parseFlags(argv: string[]): { flags: Flags; positional: string[]
     else if (a === '--timeout') flags.timeout = Number(val());
     else if (a === '--parallel-mode') flags.parallelMode = val();
     else if (a === '--adapter' || a === '--provider') flags.adapter = val();
+    else if (a === '--history-file') flags.historyFile = val();
     else positional.push(argv[i]);
   }
   return { flags, positional };
@@ -133,6 +139,77 @@ function pickProfile(flags: Flags): Profile {
 
 // --- submit ----------------------------------------------------------------
 const SHELL_HOSTILE = /[\n"'`$();|&<>]/;
+const COMPACT_TAIL_TOKENS = 50000;
+
+function compactHistoryFile(flags: Flags): string {
+  const historyFile = flags.historyFile || process.env.OPEN_AGENTS_HISTORY_FILE;
+  if (!historyFile) {
+    throw new Error(
+      'open-agents submit --compact-mode requires --history-file <path> or OPEN_AGENTS_HISTORY_FILE',
+    );
+  }
+  return historyFile;
+}
+
+async function generateCompactSpec(input: {
+  repoPath: string;
+  timeoutSec: number;
+  targetProfile: Profile;
+  task: string;
+  historyFile: string;
+}): Promise<string> {
+  const history = loadCompactHistory(input.historyFile, COMPACT_TAIL_TOKENS);
+  const specWriterTask = buildCompactSpecWriterTask({
+    task: input.task,
+    repoPath: input.repoPath,
+    targetProfile: input.targetProfile.name,
+    historyPath: history.path,
+    historyTail: history.tail,
+    tailTokens: COMPACT_TAIL_TOKENS,
+  });
+  const id = genId();
+  const adapter = cursorAdapter;
+  const model = cursorAdapter.defaultModel();
+  createJob({
+    id,
+    repoPath: input.repoPath,
+    prompt: `compact spec: ${input.task}`.slice(0, 500),
+    model,
+    background: true,
+  });
+  updateJob(input.repoPath, id, {
+    fullPrompt: specWriterProfile.buildPrompt(specWriterTask),
+    edit: false,
+    model,
+    timeoutSec: input.timeoutSec,
+  });
+  try {
+    writeFileSync(
+      join(jobsDir(input.repoPath), `${id}.spec.md`),
+      specWriterTask.trim() + '\n',
+      'utf8',
+    );
+  } catch {
+    /* best-effort */
+  }
+
+  process.stderr.write(
+    `open-agents: compact-mode spec writer running (${adapter.name}, ${model}, ${history.tailTokens} history tokens) ...\n`,
+  );
+  const preToken = adapter.preSpawn(input.repoPath);
+  await runJob({ adapter, profile: specWriterProfile }, input.repoPath, id);
+  adapter.postExit(input.repoPath, preToken);
+  const job = readJob(input.repoPath, id);
+  if (!job || job.status !== 'done') {
+    throw new Error(`compact-mode spec writer failed: ${id}`);
+  }
+  const generated = readDeliverable(adapter, job).trim();
+  if (!generated || generated === '(no final message captured)') {
+    throw new Error(`compact-mode spec writer produced no spec: ${id}`);
+  }
+  process.stderr.write(`open-agents: compact-mode generated spec ${id} (${generated.length} chars)\n`);
+  return generated;
+}
 
 async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
   const repoPath = flags.cwd || process.cwd();
@@ -160,7 +237,7 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
   const preToken = adapter.preSpawn(repoPath);
 
   // Gather one or more spec bodies. Multiple --file → run them in parallel.
-  const bodies: string[] = [];
+  let bodies: string[] = [];
   const files = flags.files || [];
   if (files.length) {
     for (const f of files) {
@@ -186,6 +263,21 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
     bodies.push(body);
   }
 
+  if (flags.compactMode) {
+    const historyFile = compactHistoryFile(flags);
+    bodies = await Promise.all(
+      bodies.map((body) =>
+        generateCompactSpec({
+          repoPath,
+          timeoutSec,
+          targetProfile: profile,
+          task: body,
+          historyFile,
+        }),
+      ),
+    );
+  }
+
   const ids = bodies.map((body) => {
     profile.warnIfMissingAcceptance(body);
     const id = genId();
@@ -452,6 +544,10 @@ const HELP = `open-agents cli — self-waiting subagent job primitive
              --no-wait): print bare id(s), don't wait, no inline output.
            --parallel-mode asap|all-together (default asap): asap prints each
              index line the moment its job finishes; all-together = submit order.
+           --compact-mode: treat the input as a very short task title and ask
+             a spec-writer agent to turn recent history into the executor spec.
+             Requires --history-file <path> or OPEN_AGENTS_HISTORY_FILE.
+             Uses the last 50000 token-like units from the history file.
   wait                         wait for ALL running jobs in this repo
   wait   "<id…>" | <id…>       wait for ALL of these
   wait   --any <id…>           return when ≥1 done; prints which (loop = popcorn)
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
new file mode 100644
index 0000000..163754d
--- /dev/null
+++ b/packages/open-agents/src/core/compact.ts
@@ -0,0 +1,111 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export interface CompactHistory {
+  path: string;
+  text: string;
+  tail: string;
+  tailTokens: number;
+}
+
+export function tokenTail(text: string, maxTokens: number): string {
+  if (!Number.isFinite(maxTokens) || maxTokens <= 0) return '';
+  const parts = text.match(/\s+|[A-Za-z0-9_]+|[^\sA-Za-z0-9_]/g) || [];
+  let tokens = 0;
+  let start = parts.length;
+  while (start > 0 && tokens < maxTokens) {
+    start -= 1;
+    if (!/^\s+$/.test(parts[start])) tokens += 1;
+  }
+  return parts.slice(start).join('').trim();
+}
+
+export function loadCompactHistory(path: string, tailTokens: number): CompactHistory {
+  const resolved = resolve(path);
+  if (!existsSync(resolved)) {
+    throw new Error(`compact history file not found: ${resolved}`);
+  }
+  const text = readFileSync(resolved, 'utf8');
+  return {
+    path: resolved,
+    text,
+    tail: tokenTail(text, tailTokens),
+    tailTokens,
+  };
+}
+
+export function buildCompactSpecWriterTask(input: {
+  task: string;
+  repoPath: string;
+  targetProfile: string;
+  historyPath: string;
+  historyTail: string;
+  tailTokens: number;
+}): string {
+  return `# Compact Mode Spec Handoff
+
+You are the spec-writer agent in a two-agent handoff.
+
+The orchestrating user intentionally provided only a short task title. Use the
+recent history tail below to recover the detailed context needed by the executor.
+
+Short task:
+${input.task}
+
+Repository path:
+${input.repoPath}
+
+Executor profile:
+${input.targetProfile}
+
+Full history pointer:
+${input.historyPath}
+
+Write a detailed execution spec for the executor agent. Preserve the user's
+latest intent, scope, constraints, preferences, and non-goals. Do not solve the
+task yourself. Do not invent requirements that are not supported by the short
+task or history tail.
+
+Strongly prioritize the <context> block. It should contain dense bullet points
+with anything from the history that could help the executor succeed, including:
+
+- relevant files, folders, packages, commands, flags, and artifact paths;
+- the user's original query and short direct quotes when they clarify intent;
+- project-specific facts and conventions;
+- decisions already made in the conversation;
+- constraints, non-goals, risks, and caveats;
+- details that may look incidental but could matter during implementation.
+
+Do not add an <acceptance> block unless the history explicitly asks for one.
+For compact handoffs, a rich <context> block is more important than a formal
+acceptance checklist.
+
+Return only the generated execution spec, preferably using this shape:
+
+<goal>
+...
+</goal>
+
+<context>
+- ...
+- ...
+</context>
+
+<scope>
+...
+</scope>
+
+<constraints>
+...
+</constraints>
+
+Recent history tail:
+The following block contains the last ${input.tailTokens} token-like units from
+the provided history file. This block is intentionally placed at the bottom of
+the prompt so the newest relevant context is closest to generation.
+
+<recent_history_tail>
+${input.historyTail || '(empty)'}
+</recent_history_tail>
+`;
+}
diff --git a/packages/open-agents/src/profiles/spec-writer.ts b/packages/open-agents/src/profiles/spec-writer.ts
new file mode 100644
index 0000000..0f01d88
--- /dev/null
+++ b/packages/open-agents/src/profiles/spec-writer.ts
@@ -0,0 +1,20 @@
+import { type Profile, assembleScaffold } from './types.js';
+
+const GUARDS =
+  '- SPEC WRITER ONLY: write an execution spec for a later subagent. Do not solve the task.\n' +
+  '- READ-ONLY: inspect files only if the prompt explicitly asks you to use repository context.\n' +
+  '- Preserve concrete user intent, the original user query, short useful quotes, constraints, file scope, project context, conversation decisions, and non-goals from the history.\n' +
+  '- Do not invent requirements. If important context is missing, state the ambiguity in the spec.\n' +
+  '- OUTPUT: only the generated execution spec. Use <goal>, <context>, <scope>, and <constraints> tags. Do not include an <acceptance> block unless the history explicitly requires one.\n';
+
+export const specWriterProfile: Profile = {
+  name: 'spec-writer',
+  tag: 'spec',
+  mode: 'ask',
+  buildPrompt(specBody: string, addendum?: string) {
+    return assembleScaffold(specBody, GUARDS, addendum);
+  },
+  warnIfMissingAcceptance() {
+    // The spec writer produces acceptance criteria; its own prompt does not need them.
+  },
+};

From 4ab91d0a8e463a0ead219cb9825239a368fb932f Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 20:04:11 +0100
Subject: [PATCH 28/72] feat: auto-detect compact history transcripts

Let compact mode find history without manual --history-file wiring. Resolution now prefers --history-file, then OPEN_AGENTS_HISTORY_FILE, then CLAUDE_CODE_TRANSCRIPT_PATH for hook-style callers, then CLAUDE_CODE_SESSION_ID by scanning ~/.claude/projects/*/<session>.jsonl.

This keeps explicit history paths available but makes the common Claude Code-launched flow deterministic for tools that inherit the session environment.
---
 packages/open-agents/README.md                |  9 +++--
 .../open-agents/__tests__/compact.test.ts     | 40 ++++++++++++++++++-
 packages/open-agents/src/cli.ts               | 13 ++++--
 packages/open-agents/src/core/compact.ts      | 37 ++++++++++++++++-
 4 files changed, 88 insertions(+), 11 deletions(-)

diff --git a/packages/open-agents/README.md b/packages/open-agents/README.md
index 0cab854..ce7d895 100644
--- a/packages/open-agents/README.md
+++ b/packages/open-agents/README.md
@@ -38,10 +38,11 @@ submit --file a.md [--file b.md …] | "<inline>"  [--edit] [--model m] [--timeo
         many --file ⇒ run in parallel · --detach: print bare id(s), don't wait
         --parallel-mode asap|all-together (default asap): asap prints each
           index line as its job finishes; all-together waits, submission order
-        --compact-mode: treat the input as a short task title, require
-          --history-file <path> or OPEN_AGENTS_HISTORY_FILE, run a Cursor
-          composer-2.5 spec-writer over the last 50000 token-like history
-          units, then submit the generated spec to the chosen executor. The
+        --compact-mode: treat the input as a short task title, find history via
+          --history-file <path>, OPEN_AGENTS_HISTORY_FILE, or the current
+          Claude Code transcript when CLAUDE_CODE_SESSION_ID is set. It runs a
+          Cursor composer-2.5 spec-writer over the last 50000 token-like history
+          units, then submits the generated spec to the chosen executor. The
           generated spec should emphasize a dense <context> block, including
           relevant files/folders, project facts, original user query, and useful
           short quotes from the conversation.
diff --git a/packages/open-agents/__tests__/compact.test.ts b/packages/open-agents/__tests__/compact.test.ts
index 75443a6..814b97c 100644
--- a/packages/open-agents/__tests__/compact.test.ts
+++ b/packages/open-agents/__tests__/compact.test.ts
@@ -1,5 +1,8 @@
 import { describe, expect, test } from 'vitest';
-import { tokenTail } from '../src/core/compact.js';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findClaudeTranscriptBySession, resolveCompactHistoryFile, tokenTail } from '../src/core/compact.js';
 import { parseFlags } from '../src/cli.js';
 
 describe('compact mode helpers', () => {
@@ -19,4 +22,39 @@ describe('compact mode helpers', () => {
     expect(flags.historyFile).toBe('C:/history.jsonl');
     expect(positional).toEqual(['short task']);
   });
+
+  test('resolves explicit and env history paths before Claude session lookup', () => {
+    expect(
+      resolveCompactHistoryFile({
+        historyFile: 'explicit.jsonl',
+        env: { OPEN_AGENTS_HISTORY_FILE: 'env.jsonl' },
+      }),
+    ).toContain('explicit.jsonl');
+    expect(
+      resolveCompactHistoryFile({
+        env: { OPEN_AGENTS_HISTORY_FILE: 'env.jsonl' },
+      }),
+    ).toContain('env.jsonl');
+  });
+
+  test('finds Claude Code transcript by session id', () => {
+    const home = mkdtempSync(join(tmpdir(), 'compact-history-'));
+    try {
+      const sessionId = 'fe080f49-6b6b-4f57-98ab-c954671c6a40';
+      const projectDir = join(home, '.claude', 'projects', 'C--Users-dpwra-dev-davstack');
+      mkdirSync(projectDir, { recursive: true });
+      const transcript = join(projectDir, `${sessionId}.jsonl`);
+      writeFileSync(transcript, '{}\n');
+
+      expect(findClaudeTranscriptBySession(sessionId, home)).toBe(transcript);
+      expect(
+        resolveCompactHistoryFile({
+          env: { CLAUDE_CODE_SESSION_ID: sessionId },
+          homeDir: home,
+        }),
+      ).toBe(transcript);
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 6d02a24..155d7ad 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -19,7 +19,11 @@ import { agyAdapter } from './adapters/agy.js';
 import { cursorAdapter } from './adapters/cursor.js';
 import { geminiAdapter } from './adapters/gemini.js';
 import type { AgentAdapter, Tier } from './adapters/types.js';
-import { buildCompactSpecWriterTask, loadCompactHistory } from './core/compact.js';
+import {
+  buildCompactSpecWriterTask,
+  loadCompactHistory,
+  resolveCompactHistoryFile,
+} from './core/compact.js';
 import { readDeliverable, renderJobResult } from './core/deliverable.js';
 import {
   createJob,
@@ -142,10 +146,10 @@ const SHELL_HOSTILE = /[\n"'`$();|&<>]/;
 const COMPACT_TAIL_TOKENS = 50000;
 
 function compactHistoryFile(flags: Flags): string {
-  const historyFile = flags.historyFile || process.env.OPEN_AGENTS_HISTORY_FILE;
+  const historyFile = resolveCompactHistoryFile({ historyFile: flags.historyFile });
   if (!historyFile) {
     throw new Error(
-      'open-agents submit --compact-mode requires --history-file <path> or OPEN_AGENTS_HISTORY_FILE',
+      'open-agents submit --compact-mode needs history context. Pass --history-file <path>, set OPEN_AGENTS_HISTORY_FILE, or run from a Claude Code session with CLAUDE_CODE_SESSION_ID.',
     );
   }
   return historyFile;
@@ -546,7 +550,8 @@ const HELP = `open-agents cli — self-waiting subagent job primitive
              index line the moment its job finishes; all-together = submit order.
            --compact-mode: treat the input as a very short task title and ask
              a spec-writer agent to turn recent history into the executor spec.
-             Requires --history-file <path> or OPEN_AGENTS_HISTORY_FILE.
+             Uses --history-file <path>, OPEN_AGENTS_HISTORY_FILE, or the
+             current Claude Code transcript when CLAUDE_CODE_SESSION_ID is set.
              Uses the last 50000 token-like units from the history file.
   wait                         wait for ALL running jobs in this repo
   wait   "<id…>" | <id…>       wait for ALL of these
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
index 163754d..076436f 100644
--- a/packages/open-agents/src/core/compact.ts
+++ b/packages/open-agents/src/core/compact.ts
@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
 
 export interface CompactHistory {
   path: string;
@@ -20,6 +21,38 @@ export function tokenTail(text: string, maxTokens: number): string {
   return parts.slice(start).join('').trim();
 }
 
+export function findClaudeTranscriptBySession(
+  sessionId: string,
+  homeDir = homedir(),
+): string | null {
+  if (!sessionId.trim()) return null;
+  const projectsDir = join(homeDir, '.claude', 'projects');
+  if (!existsSync(projectsDir)) return null;
+  for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const candidate = join(projectsDir, entry.name, `${sessionId}.jsonl`);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function resolveCompactHistoryFile(input?: {
+  historyFile?: string;
+  env?: NodeJS.ProcessEnv;
+  homeDir?: string;
+}): string | null {
+  const env = input?.env ?? process.env;
+  const explicit = input?.historyFile || env.OPEN_AGENTS_HISTORY_FILE;
+  if (explicit) return resolve(explicit);
+
+  const transcriptPath = env.CLAUDE_CODE_TRANSCRIPT_PATH;
+  if (transcriptPath) return resolve(transcriptPath);
+
+  const sessionId = env.CLAUDE_CODE_SESSION_ID;
+  if (!sessionId) return null;
+  return findClaudeTranscriptBySession(sessionId, input?.homeDir);
+}
+
 export function loadCompactHistory(path: string, tailTokens: number): CompactHistory {
   const resolved = resolve(path);
   if (!existsSync(resolved)) {

From b5a79a8b7a8367a557ebe01021b9aecaf56b0193 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 20:21:43 +0100
Subject: [PATCH 29/72] fix: keep compact spec handoff file-backed

Avoid passing the full 50k-token compact history prompt through argv. The spec-writer task is now persisted to the job .spec.md file, and the composer-2.5 spec-writer receives only a short wrapper telling it to read that file and produce the executor spec. This avoids Windows ENAMETOOLONG failures while keeping the full task inspectable on disk.

Also tighten the spec-writer contract: it should distill history into a super concise executor brief, avoid copying the transcript or long history excerpts, and point the executor at the history file when details are uncertain or too large to summarize cleanly.
---
 packages/open-agents/src/cli.ts               | 27 ++++++++++++-------
 packages/open-agents/src/core/compact.ts      | 19 ++++++++++---
 .../open-agents/src/profiles/spec-writer.ts   |  4 ++-
 3 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 155d7ad..1cb9be7 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -174,6 +174,7 @@ async function generateCompactSpec(input: {
   const id = genId();
   const adapter = cursorAdapter;
   const model = cursorAdapter.defaultModel();
+  const specWriterTaskPath = join(jobsDir(input.repoPath), `${id}.spec.md`);
   createJob({
     id,
     repoPath: input.repoPath,
@@ -181,21 +182,27 @@ async function generateCompactSpec(input: {
     model,
     background: true,
   });
+  try {
+    writeFileSync(specWriterTaskPath, specWriterTask.trim() + '\n', 'utf8');
+  } catch {
+    /* best-effort */
+  }
+
+  const specWriterWrapper = [
+    'Read the compact-mode spec-writer task from this file:',
+    '',
+    specWriterTaskPath,
+    '',
+    'The file contains the short task, repository path, history pointer, and recent history tail.',
+    'Use it as the authoritative task source and produce only the generated executor spec.',
+  ].join('\n');
+
   updateJob(input.repoPath, id, {
-    fullPrompt: specWriterProfile.buildPrompt(specWriterTask),
+    fullPrompt: specWriterProfile.buildPrompt(specWriterWrapper),
     edit: false,
     model,
     timeoutSec: input.timeoutSec,
   });
-  try {
-    writeFileSync(
-      join(jobsDir(input.repoPath), `${id}.spec.md`),
-      specWriterTask.trim() + '\n',
-      'utf8',
-    );
-  } catch {
-    /* best-effort */
-  }
 
   process.stderr.write(
     `open-agents: compact-mode spec writer running (${adapter.name}, ${model}, ${history.tailTokens} history tokens) ...\n`,
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
index 076436f..9e85f4c 100644
--- a/packages/open-agents/src/core/compact.ts
+++ b/packages/open-agents/src/core/compact.ts
@@ -94,13 +94,21 @@ ${input.targetProfile}
 Full history pointer:
 ${input.historyPath}
 
-Write a detailed execution spec for the executor agent. Preserve the user's
+Write a compact execution spec for the executor agent. Preserve the user's
 latest intent, scope, constraints, preferences, and non-goals. Do not solve the
 task yourself. Do not invent requirements that are not supported by the short
 task or history tail.
 
-Strongly prioritize the <context> block. It should contain dense bullet points
-with anything from the history that could help the executor succeed, including:
+Keep the generated spec super concise and brief. Prefer concise bullets over
+prose. Do not enumerate every remembered detail; include only what changes the
+executor's behavior. The full history pointer is available, so if context is
+uncertain or too detailed to summarize cleanly, point the executor to inspect
+the relevant part of the history instead of copying it into the spec.
+
+Strongly prioritize the <context> block, but keep it distilled. The executor
+should receive a clean brief, not the transcript or full history tail. Include
+dense bullet points with only the history details that could help the executor
+succeed, including:
 
 - relevant files, folders, packages, commands, flags, and artifact paths;
 - the user's original query and short direct quotes when they clarify intent;
@@ -109,6 +117,11 @@ with anything from the history that could help the executor succeed, including:
 - constraints, non-goals, risks, and caveats;
 - details that may look incidental but could matter during implementation.
 
+Do not paste the full history, full recent tail, or long conversation excerpts
+into the generated spec. Use short direct quotes only when they clarify intent.
+Omit irrelevant turns, dead ends, and stale decisions that the user's latest
+messages supersede.
+
 Do not add an <acceptance> block unless the history explicitly asks for one.
 For compact handoffs, a rich <context> block is more important than a formal
 acceptance checklist.
diff --git a/packages/open-agents/src/profiles/spec-writer.ts b/packages/open-agents/src/profiles/spec-writer.ts
index 0f01d88..1a6343d 100644
--- a/packages/open-agents/src/profiles/spec-writer.ts
+++ b/packages/open-agents/src/profiles/spec-writer.ts
@@ -1,9 +1,11 @@
 import { type Profile, assembleScaffold } from './types.js';
 
 const GUARDS =
-  '- SPEC WRITER ONLY: write an execution spec for a later subagent. Do not solve the task.\n' +
+  '- SPEC WRITER ONLY: write a compact execution spec for a later subagent. Do not solve the task.\n' +
   '- READ-ONLY: inspect files only if the prompt explicitly asks you to use repository context.\n' +
   '- Preserve concrete user intent, the original user query, short useful quotes, constraints, file scope, project context, conversation decisions, and non-goals from the history.\n' +
+  '- Distill the history. Do not copy the transcript, full history tail, or long excerpts into the generated spec.\n' +
+  '- Keep the generated spec super concise and brief; point to the history file for uncertain details instead of copying them.\n' +
   '- Do not invent requirements. If important context is missing, state the ambiguity in the spec.\n' +
   '- OUTPUT: only the generated execution spec. Use <goal>, <context>, <scope>, and <constraints> tags. Do not include an <acceptance> block unless the history explicitly requires one.\n';
 

From 23f7b2ca30ba75bb2e6022bc97cfecb2972a6b43 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 20:24:25 +0100
Subject: [PATCH 30/72] fix: improve compact-mode progress output

Report how long the compact spec-writer stage took and include a user-friendly ~/... path to the generated spec artifact. This makes the handoff easier to inspect after compact mode finishes.

Also silence the Cursor .test.ts probe cleanup message; the cleanup still runs, but compact-mode output no longer includes the noisy swept-stray line.
---
 packages/open-agents/src/adapters/cursor.ts |  3 ---
 packages/open-agents/src/cli.ts             | 18 +++++++++++++++++-
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/packages/open-agents/src/adapters/cursor.ts b/packages/open-agents/src/adapters/cursor.ts
index 1ae28bd..cbd38eb 100644
--- a/packages/open-agents/src/adapters/cursor.ts
+++ b/packages/open-agents/src/adapters/cursor.ts
@@ -143,9 +143,6 @@ export function sweepDotTest(repoPath: string, before: DotTestState | null): voi
   if (isGitTracked(repoPath, DOTTEST)) return; // committed (degenerate) — leave it
   try {
     unlinkSync(join(repoPath, DOTTEST));
-    process.stderr.write(
-      `open-agents: swept stray 0-byte ${DOTTEST} (cursor-agent Windows probe litter)\n`,
-    );
   } catch {
     /* best-effort */
   }
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 1cb9be7..37a8770 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -13,6 +13,7 @@
 
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { agyAdapter } from './adapters/agy.js';
@@ -145,6 +146,17 @@ function pickProfile(flags: Flags): Profile {
 const SHELL_HOSTILE = /[\n"'`$();|&<>]/;
 const COMPACT_TAIL_TOKENS = 50000;
 
+function userPath(path: string): string {
+  const home = homedir();
+  const normalized = path.replace(/\\/g, '/');
+  const normalizedHome = home.replace(/\\/g, '/');
+  if (normalized === normalizedHome) return '~';
+  if (normalized.startsWith(`${normalizedHome}/`)) {
+    return `~/${normalized.slice(normalizedHome.length + 1)}`;
+  }
+  return normalized;
+}
+
 function compactHistoryFile(flags: Flags): string {
   const historyFile = resolveCompactHistoryFile({ historyFile: flags.historyFile });
   if (!historyFile) {
@@ -208,7 +220,9 @@ async function generateCompactSpec(input: {
     `open-agents: compact-mode spec writer running (${adapter.name}, ${model}, ${history.tailTokens} history tokens) ...\n`,
   );
   const preToken = adapter.preSpawn(input.repoPath);
+  const specStartedAt = Date.now();
   await runJob({ adapter, profile: specWriterProfile }, input.repoPath, id);
+  const specElapsedSec = Math.round((Date.now() - specStartedAt) / 1000);
   adapter.postExit(input.repoPath, preToken);
   const job = readJob(input.repoPath, id);
   if (!job || job.status !== 'done') {
@@ -218,7 +232,9 @@ async function generateCompactSpec(input: {
   if (!generated || generated === '(no final message captured)') {
     throw new Error(`compact-mode spec writer produced no spec: ${id}`);
   }
-  process.stderr.write(`open-agents: compact-mode generated spec ${id} (${generated.length} chars)\n`);
+  process.stderr.write(
+    `open-agents: compact-mode generated spec ${id} in ${specElapsedSec}s (${generated.length} chars) -> ${userPath(job.resultPath || '')}\n`,
+  );
   return generated;
 }
 

From feb51f42a3471347d20d64e46b8c8c841337f857 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 20:32:14 +0100
Subject: [PATCH 31/72] docs: guide skills toward compact handoffs

Update explore and fast-edit skill guidance to prefer compact mode when the current conversation already contains the real context. The docs now tell agents to use a tiny 5-10 word inline prompt, avoid pasting details or file lists, and trust the compact spec-writer to distill transcript context for the executor.

Regenerate the init skill templates so newly installed skills carry the same compact-mode guidance.
---
 packages/init/src/skills/explore.md   | 11 +++++++++++
 packages/init/src/skills/fast-edit.md | 11 +++++++++++
 skills/explore/SKILL.md               | 11 +++++++++++
 skills/fast-edit/SKILL.md             | 11 +++++++++++
 4 files changed, 44 insertions(+)

diff --git a/packages/init/src/skills/explore.md b/packages/init/src/skills/explore.md
index a74d08b..a762e71 100644
--- a/packages/init/src/skills/explore.md
+++ b/packages/init/src/skills/explore.md
@@ -14,6 +14,17 @@ Scope tightly, then run (backgrounded — the harness notifies you):
 
     npx explore submit --file ~/.davstack/specs/<slug>.md
 
+When the current conversation already contains the real context, prefer compact
+mode over writing a spec:
+
+    npx explore submit --compact-mode "audit supervisor handoffs"
+
+Keep the inline compact prompt to roughly 5-10 words. Do not paste details,
+requirements, quotes, or file lists into it; the compact spec-writer reads the
+current transcript/history and distills that context for the executor. Trust the
+subagent handoff unless the task is genuinely too ambiguous from conversation
+history.
+
 For a **single scoped fact**, skip the spec file — inline it (no boilerplate):
 
     npx explore submit '<goal>Exact signature + return type of resolve_query_adapter</goal> <scope>backend/src/query/adapter.py only</scope>'
diff --git a/packages/init/src/skills/fast-edit.md b/packages/init/src/skills/fast-edit.md
index 9b4500a..f63e46c 100644
--- a/packages/init/src/skills/fast-edit.md
+++ b/packages/init/src/skills/fast-edit.md
@@ -15,6 +15,17 @@ Run (backgrounded — the harness notifies you):
 
     npx fast-edit submit --file ~/.davstack/specs/<slug>.md
 
+When the current conversation already contains the real context, prefer compact
+mode over writing a spec:
+
+    npx fast-edit submit --compact-mode "rename legacy adapter"
+
+Keep the inline compact prompt to roughly 5-10 words. Do not paste details,
+requirements, quotes, or file lists into it; the compact spec-writer reads the
+current transcript/history and distills that context for the executor. Trust the
+subagent handoff unless the edit is too risky or underspecified from
+conversation history.
+
 **Routing test.** Delegate when a *short* intent+constraints spec is enough
 for the executor to produce the **full** intended edit. If writing the spec
 would mean pasting the new file contents or spelling out every line, the spec
diff --git a/skills/explore/SKILL.md b/skills/explore/SKILL.md
index 330b3b2..5377da4 100644
--- a/skills/explore/SKILL.md
+++ b/skills/explore/SKILL.md
@@ -12,6 +12,17 @@ Scope tightly, then run (backgrounded — the harness notifies you):
 
     npx explore submit --file ~/.davstack/specs/<slug>.md
 
+When the current conversation already contains the real context, prefer compact
+mode over writing a spec:
+
+    npx explore submit --compact-mode "audit supervisor handoffs"
+
+Keep the inline compact prompt to roughly 5-10 words. Do not paste details,
+requirements, quotes, or file lists into it; the compact spec-writer reads the
+current transcript/history and distills that context for the executor. Trust the
+subagent handoff unless the task is genuinely too ambiguous from conversation
+history.
+
 For a **single scoped fact**, skip the spec file — inline it (no boilerplate):
 
     npx explore submit '<goal>Exact signature + return type of resolve_query_adapter</goal> <scope>backend/src/query/adapter.py only</scope>'
diff --git a/skills/fast-edit/SKILL.md b/skills/fast-edit/SKILL.md
index b7c8bd6..8449b39 100644
--- a/skills/fast-edit/SKILL.md
+++ b/skills/fast-edit/SKILL.md
@@ -13,6 +13,17 @@ Run (backgrounded — the harness notifies you):
 
     npx fast-edit submit --file ~/.davstack/specs/<slug>.md
 
+When the current conversation already contains the real context, prefer compact
+mode over writing a spec:
+
+    npx fast-edit submit --compact-mode "rename legacy adapter"
+
+Keep the inline compact prompt to roughly 5-10 words. Do not paste details,
+requirements, quotes, or file lists into it; the compact spec-writer reads the
+current transcript/history and distills that context for the executor. Trust the
+subagent handoff unless the edit is too risky or underspecified from
+conversation history.
+
 **Routing test.** Delegate when a *short* intent+constraints spec is enough
 for the executor to produce the **full** intended edit. If writing the spec
 would mean pasting the new file contents or spelling out every line, the spec

From 99b28473a397318e053da3eb779b327ea36aadf0 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Mon, 8 Jun 2026 20:37:44 +0100
Subject: [PATCH 32/72] chore: version open-agents compact release

Version @davstack/open-agents to 1.2.4 for the compact handoff release and update its changelog.

Changesets also bumped @davstack/tui to 0.5.3 for its internal dependency on @davstack/open-agents.
---
 packages/open-agents/CHANGELOG.md | 6 ++++++
 packages/open-agents/package.json | 2 +-
 packages/tui/CHANGELOG.md         | 7 +++++++
 packages/tui/package.json         | 2 +-
 4 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/packages/open-agents/CHANGELOG.md b/packages/open-agents/CHANGELOG.md
index 92f249e..826df76 100644
--- a/packages/open-agents/CHANGELOG.md
+++ b/packages/open-agents/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/open-agents
 
+## 1.2.4
+
+### Patch Changes
+
+- Add compact handoff mode for `explore` and `fast-edit`, including transcript-backed spec writing, Claude Code transcript auto-detection, file-backed compact spec-writer prompts on Windows, and clearer compact-mode progress output.
+
 ## 1.2.3
 
 ### Patch Changes
diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index 3c115ac..a99146d 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/open-agents",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "license": "MIT",
   "type": "module",
   "description": "Self-waiting Cursor-jobs primitive: delegate scoped explore (read-only) and fast-edit (mechanical) work to cursor-agent, harness-trackable, results persisted per job.",
diff --git a/packages/tui/CHANGELOG.md b/packages/tui/CHANGELOG.md
index 6274306..502213e 100644
--- a/packages/tui/CHANGELOG.md
+++ b/packages/tui/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @davstack/tui
 
+## 0.5.3
+
+### Patch Changes
+
+- Updated dependencies
+  - @davstack/open-agents@1.2.4
+
 ## 0.5.2
 
 ### Patch Changes
diff --git a/packages/tui/package.json b/packages/tui/package.json
index 7e5113f..c8d8e5a 100644
--- a/packages/tui/package.json
+++ b/packages/tui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/tui",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "license": "MIT",
   "type": "module",
   "description": "Long-running terminal UI that spawns, owns, and surfaces the davstack daemons (vitest-server, logs-server).",

From 3f92b2eea0f9423ffaa0fa0251831fb602d4d152 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 10:43:47 +0100
Subject: [PATCH 33/72] docs: clarify compact-mode usage

---
 packages/open-agents/README.md       | 21 +++++++++++++--------
 packages/open-agents/evals/README.md | 10 ++++++----
 packages/open-agents/src/cli.ts      | 18 ++++++++++++------
 3 files changed, 31 insertions(+), 18 deletions(-)

diff --git a/packages/open-agents/README.md b/packages/open-agents/README.md
index ce7d895..e04b47e 100644
--- a/packages/open-agents/README.md
+++ b/packages/open-agents/README.md
@@ -38,14 +38,19 @@ submit --file a.md [--file b.md …] | "<inline>"  [--edit] [--model m] [--timeo
         many --file ⇒ run in parallel · --detach: print bare id(s), don't wait
         --parallel-mode asap|all-together (default asap): asap prints each
           index line as its job finishes; all-together waits, submission order
-        --compact-mode: treat the input as a short task title, find history via
-          --history-file <path>, OPEN_AGENTS_HISTORY_FILE, or the current
-          Claude Code transcript when CLAUDE_CODE_SESSION_ID is set. It runs a
-          Cursor composer-2.5 spec-writer over the last 50000 token-like history
-          units, then submits the generated spec to the chosen executor. The
-          generated spec should emphasize a dense <context> block, including
-          relevant files/folders, project facts, original user query, and useful
-          short quotes from the conversation.
+        --compact-mode: treat the inline input as a very short task title
+          (roughly 5-10 words) and let a Cursor composer-2.5 spec-writer distill
+          recent conversation history into the executor spec. Do not paste
+          details, quotes, or file lists into the inline prompt when the current
+          conversation already has that context.
+          History resolves from --history-file <path>, OPEN_AGENTS_HISTORY_FILE,
+          CLAUDE_CODE_TRANSCRIPT_PATH, or the current Claude Code transcript
+          when CLAUDE_CODE_SESSION_ID is set. Compact mode always gives the
+          spec-writer the last 50000 token-like history units plus a pointer to
+          the full history file. The generated spec is kept concise and points
+          back to the history file for uncertain detail instead of copying the
+          transcript. Progress output includes the spec generation duration and
+          a ~/... path to the generated spec artifact.
 wait                        wait for ALL running jobs (this repo)
 wait   "<id…>" | <id…>      wait for ALL of these
 wait   --any <id…>          return when ≥1 done; prints which (loop = popcorn)
diff --git a/packages/open-agents/evals/README.md b/packages/open-agents/evals/README.md
index bc98c60..92f24a9 100644
--- a/packages/open-agents/evals/README.md
+++ b/packages/open-agents/evals/README.md
@@ -143,10 +143,12 @@ For the spec-writer hybrid variant, the provider also writes:
 - `cases/<case-id>/spec-writer-job.json` when the spec-writer agent actually
   runs.
 
-Set `tailTokens: 50000` plus either `historyText` or `historyPath` in Promptfoo
-vars/options to feed the spec writer a recent history tail. If no history source
-is provided, smoke runs use a small synthetic history snapshot from the test
-vars so artifact plumbing remains deterministic.
+Eval configs can set `tailTokens: 50000` plus either `historyText` or
+`historyPath` in Promptfoo vars/options to feed the spec writer a recent history
+tail. This is eval-only plumbing, not a package CLI flag; real `--compact-mode`
+always uses the built-in 50000-unit tail plus the resolved history file pointer.
+If no history source is provided, smoke runs use a small synthetic history
+snapshot from the test vars so artifact plumbing remains deterministic.
 
 Humans should only add:
 
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 37a8770..6885664 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -161,7 +161,7 @@ function compactHistoryFile(flags: Flags): string {
   const historyFile = resolveCompactHistoryFile({ historyFile: flags.historyFile });
   if (!historyFile) {
     throw new Error(
-      'open-agents submit --compact-mode needs history context. Pass --history-file <path>, set OPEN_AGENTS_HISTORY_FILE, or run from a Claude Code session with CLAUDE_CODE_SESSION_ID.',
+      'open-agents submit --compact-mode needs history context. Pass --history-file <path>, set OPEN_AGENTS_HISTORY_FILE or CLAUDE_CODE_TRANSCRIPT_PATH, or run from a Claude Code session with CLAUDE_CODE_SESSION_ID.',
     );
   }
   return historyFile;
@@ -571,11 +571,17 @@ const HELP = `open-agents cli — self-waiting subagent job primitive
              --no-wait): print bare id(s), don't wait, no inline output.
            --parallel-mode asap|all-together (default asap): asap prints each
              index line the moment its job finishes; all-together = submit order.
-           --compact-mode: treat the input as a very short task title and ask
-             a spec-writer agent to turn recent history into the executor spec.
-             Uses --history-file <path>, OPEN_AGENTS_HISTORY_FILE, or the
-             current Claude Code transcript when CLAUDE_CODE_SESSION_ID is set.
-             Uses the last 50000 token-like units from the history file.
+           --compact-mode: treat the input as a very short task title
+             (roughly 5-10 words) and ask a Cursor composer-2.5 spec-writer to
+             distill recent history into a concise executor spec. Do not paste
+             details, quotes, or file lists into the inline prompt when the
+             conversation already contains that context.
+             Uses --history-file <path>, OPEN_AGENTS_HISTORY_FILE,
+             CLAUDE_CODE_TRANSCRIPT_PATH, or the current Claude Code transcript
+             when CLAUDE_CODE_SESSION_ID is set. Always gives the spec-writer
+             the last 50000 token-like units plus a pointer to the full history.
+             Progress output includes spec generation time and the generated
+             spec artifact path.
   wait                         wait for ALL running jobs in this repo
   wait   "<id…>" | <id…>       wait for ALL of these
   wait   --any <id…>           return when ≥1 done; prints which (loop = popcorn)

From 1ad337face6a79b4f8ee868ec50a27f81458e3a8 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 11:49:28 +0100
Subject: [PATCH 34/72] Add open-agents typecheck config

---
 packages/open-agents/package.json  |  1 +
 packages/open-agents/tsconfig.json | 17 +++++++++++++++++
 2 files changed, 18 insertions(+)
 create mode 100644 packages/open-agents/tsconfig.json

diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index a99146d..0ab9af4 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -6,6 +6,7 @@
   "description": "Self-waiting Cursor-jobs primitive: delegate scoped explore (read-only) and fast-edit (mechanical) work to cursor-agent, harness-trackable, results persisted per job.",
   "scripts": {
     "build": "tsup",
+    "typecheck": "tsc --noEmit",
     "prepublishOnly": "tsup",
     "test": "pnpm -w exec vitest run --project open-agents",
     "eval": "node evals/scripts/run-promptfoo.mjs",
diff --git a/packages/open-agents/tsconfig.json b/packages/open-agents/tsconfig.json
new file mode 100644
index 0000000..799de32
--- /dev/null
+++ b/packages/open-agents/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "__tests__/**/*"]
+}

From 286a2bae1544e498e1a65bf61209502067b23dfe Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 11:49:51 +0100
Subject: [PATCH 35/72] Support Codex compact history discovery

---
 .../open-agents/__tests__/compact.test.ts     | 42 +++++++-
 packages/open-agents/src/core/compact.ts      | 95 ++++++++++++++++++-
 2 files changed, 133 insertions(+), 4 deletions(-)

diff --git a/packages/open-agents/__tests__/compact.test.ts b/packages/open-agents/__tests__/compact.test.ts
index 814b97c..d435196 100644
--- a/packages/open-agents/__tests__/compact.test.ts
+++ b/packages/open-agents/__tests__/compact.test.ts
@@ -2,7 +2,12 @@ import { describe, expect, test } from 'vitest';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { findClaudeTranscriptBySession, resolveCompactHistoryFile, tokenTail } from '../src/core/compact.js';
+import {
+  findClaudeTranscriptBySession,
+  findCodexTranscriptBySession,
+  resolveCompactHistoryFile,
+  tokenTail,
+} from '../src/core/compact.js';
 import { parseFlags } from '../src/cli.js';
 
 describe('compact mode helpers', () => {
@@ -57,4 +62,39 @@ describe('compact mode helpers', () => {
       rmSync(home, { recursive: true, force: true });
     }
   });
+
+  test('finds Codex transcript by thread id', () => {
+    const home = mkdtempSync(join(tmpdir(), 'compact-codex-history-'));
+    try {
+      const threadId = '019eabb5-b1ba-7ba1-b84b-97efcca16393';
+      const sessionDir = join(home, '.codex', 'sessions', '2026', '06', '09');
+      mkdirSync(sessionDir, { recursive: true });
+      const transcript = join(sessionDir, `rollout-2026-06-09T10-27-52-${threadId}.jsonl`);
+      writeFileSync(transcript, '{}\n');
+
+      expect(findCodexTranscriptBySession(threadId, home)).toBe(transcript);
+      expect(
+        resolveCompactHistoryFile({
+          env: { CODEX_THREAD_ID: threadId },
+          homeDir: home,
+        }),
+      ).toBe(transcript);
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+
+  test('falls back to Codex history.jsonl when no active session env is present', () => {
+    const home = mkdtempSync(join(tmpdir(), 'compact-codex-history-'));
+    try {
+      const codexDir = join(home, '.codex');
+      mkdirSync(codexDir, { recursive: true });
+      const history = join(codexDir, 'history.jsonl');
+      writeFileSync(history, '{"text":"hello"}\n');
+
+      expect(resolveCompactHistoryFile({ env: {}, homeDir: home })).toBe(history);
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
index 9e85f4c..b58f932 100644
--- a/packages/open-agents/src/core/compact.ts
+++ b/packages/open-agents/src/core/compact.ts
@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 
@@ -36,6 +36,78 @@ export function findClaudeTranscriptBySession(
   return null;
 }
 
+function walkFiles(dir: string, predicate: (path: string) => boolean, limit = 5000): string[] {
+  const out: string[] = [];
+  const visit = (current: string) => {
+    if (out.length >= limit) return;
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= limit) return;
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) visit(full);
+      else if (entry.isFile() && predicate(full)) out.push(full);
+    }
+  };
+  if (existsSync(dir)) visit(dir);
+  return out;
+}
+
+function newest(paths: string[]): string | null {
+  return (
+    paths
+      .map((path) => {
+        try {
+          return { path, mtimeMs: statSync(path).mtimeMs };
+        } catch {
+          return null;
+        }
+      })
+      .filter((x): x is { path: string; mtimeMs: number } => x !== null)
+      .sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.path ?? null
+  );
+}
+
+export function findCodexTranscriptBySession(
+  sessionId: string,
+  homeDir = homedir(),
+): string | null {
+  if (!sessionId.trim()) return null;
+  const sessionsDir = join(homeDir, '.codex', 'sessions');
+  return newest(
+    walkFiles(
+      sessionsDir,
+      (path) => path.endsWith('.jsonl') && path.includes(sessionId),
+    ),
+  );
+}
+
+export function findLatestCodexHistory(homeDir = homedir()): string | null {
+  const codexDir = join(homeDir, '.codex');
+  const history = join(codexDir, 'history.jsonl');
+  if (existsSync(history)) return history;
+  return newest(walkFiles(join(codexDir, 'sessions'), (path) => path.endsWith('.jsonl')));
+}
+
+export function findLatestCursorAgentHistory(homeDir = homedir()): string | null {
+  const explicitRoots = [
+    join(homeDir, 'AppData', 'Roaming', 'Cursor'),
+    join(homeDir, 'AppData', 'Local', 'cursor-agent'),
+    join(homeDir, '.cursor-agent'),
+  ];
+  for (const root of explicitRoots) {
+    const hit = newest(
+      walkFiles(root, (path) => /(?:history|session|transcript|conversation).*\.jsonl$/i.test(path), 2000),
+    );
+    if (hit) return hit;
+  }
+  return null;
+}
+
 export function resolveCompactHistoryFile(input?: {
   historyFile?: string;
   env?: NodeJS.ProcessEnv;
@@ -49,8 +121,25 @@ export function resolveCompactHistoryFile(input?: {
   if (transcriptPath) return resolve(transcriptPath);
 
   const sessionId = env.CLAUDE_CODE_SESSION_ID;
-  if (!sessionId) return null;
-  return findClaudeTranscriptBySession(sessionId, input?.homeDir);
+  if (sessionId) return findClaudeTranscriptBySession(sessionId, input?.homeDir);
+
+  const codexTranscriptPath = env.CODEX_TRANSCRIPT_PATH || env.CODEX_SESSION_FILE;
+  if (codexTranscriptPath) return resolve(codexTranscriptPath);
+
+  const codexThreadId = env.CODEX_THREAD_ID || env.CODEX_SESSION_ID;
+  if (codexThreadId) {
+    const codexTranscript = findCodexTranscriptBySession(codexThreadId, input?.homeDir);
+    if (codexTranscript) return codexTranscript;
+  }
+
+  const cursorTranscriptPath =
+    env.CURSOR_AGENT_TRANSCRIPT_PATH || env.CURSOR_AGENT_HISTORY_FILE || env.AGENT_HISTORY_FILE;
+  if (cursorTranscriptPath) return resolve(cursorTranscriptPath);
+
+  const cursorHistory = findLatestCursorAgentHistory(input?.homeDir);
+  if (cursorHistory) return cursorHistory;
+
+  return findLatestCodexHistory(input?.homeDir);
 }
 
 export function loadCompactHistory(path: string, tailTokens: number): CompactHistory {

From ebaa7e3648fb3c8432c52d2ad6abcae4ee0e06be Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 11:50:02 +0100
Subject: [PATCH 36/72] Add optional Headroom routing

---
 packages/open-agents/README.md                |  35 +++-
 packages/open-agents/__tests__/config.test.ts |  21 +++
 .../open-agents/__tests__/headroom.test.ts    |  39 +++++
 packages/open-agents/src/cli.ts               |  68 +++++++-
 packages/open-agents/src/config.ts            |  16 ++
 packages/open-agents/src/core/headroom.ts     | 159 ++++++++++++++++++
 packages/open-agents/src/core/run.ts          |   8 +-
 7 files changed, 332 insertions(+), 14 deletions(-)
 create mode 100644 packages/open-agents/__tests__/headroom.test.ts
 create mode 100644 packages/open-agents/src/core/headroom.ts

diff --git a/packages/open-agents/README.md b/packages/open-agents/README.md
index e04b47e..01f57af 100644
--- a/packages/open-agents/README.md
+++ b/packages/open-agents/README.md
@@ -45,12 +45,21 @@ submit --file a.md [--file b.md …] | "<inline>"  [--edit] [--model m] [--timeo
           conversation already has that context.
           History resolves from --history-file <path>, OPEN_AGENTS_HISTORY_FILE,
           CLAUDE_CODE_TRANSCRIPT_PATH, or the current Claude Code transcript
-          when CLAUDE_CODE_SESSION_ID is set. Compact mode always gives the
-          spec-writer the last 50000 token-like history units plus a pointer to
-          the full history file. The generated spec is kept concise and points
+          when CLAUDE_CODE_SESSION_ID is set. It also detects Codex sessions
+          from CODEX_THREAD_ID / ~/.codex/sessions and falls back to
+          ~/.codex/history.jsonl when no richer transcript is available.
+          Compact mode gives the spec-writer the last 50000 token-like history
+          units plus a pointer to the full history file, or 100000 when a local
+          Headroom proxy is healthy. The generated spec is kept concise and points
           back to the history file for uncertain detail instead of copying the
           transcript. Progress output includes the spec generation duration and
           a ~/... path to the generated spec artifact.
+        --headroom auto|off|require (default auto): probe the local Headroom
+          proxy and, when healthy, run the Cursor adapter with
+          OPENAI_BASE_URL=http://127.0.0.1:8787/v1. If the proxy is absent,
+          jobs continue normally with a concise stderr notice. Use
+          --headroom-url <url>, OPEN_AGENTS_HEADROOM_URL, or config
+          headroom.url for a non-default proxy.
 wait                        wait for ALL running jobs (this repo)
 wait   "<id…>" | <id…>      wait for ALL of these
 wait   --any <id…>          return when ≥1 done; prints which (loop = popcorn)
@@ -101,6 +110,26 @@ The bin launcher prefers `bun` (matches sibling davstack packages); set
 `OPEN_AGENTS_RUNTIME=node` to use `node --experimental-transform-types`
 instead. The source is pure `node:*` — either runtime works.
 
+## Optional Headroom proxy
+
+Headroom is optional. By default, `open-agents` briefly probes
+`http://127.0.0.1:8787/health`. If the proxy is healthy and the selected adapter
+is `cursor`, the spawned Cursor Agent process receives
+`OPENAI_BASE_URL=http://127.0.0.1:8787/v1`. If the proxy is not installed or not
+running, the job still runs directly.
+
+Controls:
+
+```bash
+OPEN_AGENTS_HEADROOM=off explore submit "short task"
+OPEN_AGENTS_HEADROOM=require fast-edit submit --compact-mode "fix parser"
+OPEN_AGENTS_HEADROOM_URL=http://127.0.0.1:8788 explore submit "inspect auth"
+```
+
+In compact mode, a healthy Headroom proxy raises the history tail budget from
+50000 to 100000 token-like units and prints a `/stats` delta from
+`requests.total` and `tokens.saved`.
+
 ## Job state
 
 Lives under `~/.davstack/jobs/<repo-hash>/` (override `OPEN_AGENTS_HOME`).
diff --git a/packages/open-agents/__tests__/config.test.ts b/packages/open-agents/__tests__/config.test.ts
index ca509d0..f9e41b1 100644
--- a/packages/open-agents/__tests__/config.test.ts
+++ b/packages/open-agents/__tests__/config.test.ts
@@ -46,12 +46,18 @@ describe('loadConfig — .davstack/config/open-agents.config.ts present', () =>
         defaultModel: 'composer-2-fast',
         defaultAdapter: 'cursor',
         defaultTimeoutSec: 900,
+        headroom: { mode: 'require', url: 'http://localhost:8788', logStats: false },
       }`,
     );
     const cfg = await loadConfig(sandbox);
     expect(cfg.defaultModel).toBe('composer-2-fast');
     expect(cfg.defaultAdapter).toBe('cursor');
     expect(cfg.defaultTimeoutSec).toBe(900);
+    expect(cfg.headroom).toEqual({
+      mode: 'require',
+      url: 'http://localhost:8788',
+      logStats: false,
+    });
     expect(cfg._source).toContain('open-agents.config.ts');
   });
 
@@ -82,6 +88,21 @@ describe('loadConfig — .davstack/config/open-agents.config.ts present', () =>
     expect(cfg.defaultModel).toBeUndefined();
   });
 
+  test('drops invalid headroom fields', async () => {
+    writeFileSync(
+      join(sandbox, '.davstack', 'config', 'open-agents.config.ts'),
+      `export default {
+        headroom: { mode: 'sometimes', url: 42, logStats: 'yes' },
+      }`,
+    );
+    const cfg = await loadConfig(sandbox);
+    expect(cfg.headroom).toEqual({
+      mode: undefined,
+      url: undefined,
+      logStats: undefined,
+    });
+  });
+
   test('preserves profiles object as-authored', async () => {
     writeFileSync(
       join(sandbox, '.davstack', 'config', 'open-agents.config.ts'),
diff --git a/packages/open-agents/__tests__/headroom.test.ts b/packages/open-agents/__tests__/headroom.test.ts
new file mode 100644
index 0000000..37c6a91
--- /dev/null
+++ b/packages/open-agents/__tests__/headroom.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'vitest';
+import {
+  formatHeadroomDelta,
+  resolveHeadroomConfig,
+} from '../src/core/headroom.js';
+
+describe('headroom helpers', () => {
+  test('defaults to auto localhost proxy', () => {
+    expect(resolveHeadroomConfig({ env: {} })).toEqual({
+      mode: 'auto',
+      url: 'http://127.0.0.1:8787',
+      logStats: true,
+    });
+  });
+
+  test('env and flags override config', () => {
+    expect(
+      resolveHeadroomConfig({
+        config: { mode: 'auto', url: 'http://config:8787', logStats: true },
+        env: { OPEN_AGENTS_HEADROOM: 'off', OPEN_AGENTS_HEADROOM_URL: 'http://env:8787/' },
+        modeFlag: 'require',
+        urlFlag: 'http://flag:8787/',
+      }),
+    ).toEqual({
+      mode: 'require',
+      url: 'http://flag:8787',
+      logStats: true,
+    });
+  });
+
+  test('formats stats deltas when counters are available', () => {
+    expect(
+      formatHeadroomDelta(
+        { requestsTotal: 10, tokensSaved: 1000, inputTokens: 10000, outputTokens: 100, raw: {} },
+        { requestsTotal: 12, tokensSaved: 2500, inputTokens: 12000, outputTokens: 200, raw: {} },
+      ),
+    ).toBe('2 requests, 1,500 tokens saved');
+  });
+});
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 6885664..6a41277 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -35,6 +35,12 @@ import {
 } from './core/jobs.js';
 import { jobsDir } from './core/paths.js';
 import { DEFAULT_TIMEOUT_SEC, runJob } from './core/run.js';
+import {
+  detectHeadroom,
+  formatHeadroomDelta,
+  readHeadroomStats,
+  resolveHeadroomConfig,
+} from './core/headroom.js';
 import { editProfile } from './profiles/edit.js';
 import { exploreProfile } from './profiles/explore.js';
 import { specWriterProfile } from './profiles/spec-writer.js';
@@ -76,6 +82,8 @@ export interface Flags {
   adapter?: string;
   compactMode?: boolean;
   historyFile?: string;
+  headroom?: string;
+  headroomUrl?: string;
 }
 
 export function parseFlags(argv: string[]): { flags: Flags; positional: string[] } {
@@ -104,6 +112,8 @@ export function parseFlags(argv: string[]): { flags: Flags; positional: string[]
     else if (a === '--parallel-mode') flags.parallelMode = val();
     else if (a === '--adapter' || a === '--provider') flags.adapter = val();
     else if (a === '--history-file') flags.historyFile = val();
+    else if (a === '--headroom') flags.headroom = val();
+    else if (a === '--headroom-url') flags.headroomUrl = val();
     else positional.push(argv[i]);
   }
   return { flags, positional };
@@ -144,7 +154,8 @@ function pickProfile(flags: Flags): Profile {
 
 // --- submit ----------------------------------------------------------------
 const SHELL_HOSTILE = /[\n"'`$();|&<>]/;
-const COMPACT_TAIL_TOKENS = 50000;
+const DEFAULT_COMPACT_TAIL_TOKENS = 50000;
+const HEADROOM_COMPACT_TAIL_TOKENS = 100000;
 
 function userPath(path: string): string {
   const home = homedir();
@@ -173,15 +184,19 @@ async function generateCompactSpec(input: {
   targetProfile: Profile;
   task: string;
   historyFile: string;
+  tailTokens: number;
+  headroomEnv?: Record<string, string>;
+  headroomUrl?: string;
+  logHeadroomStats?: boolean;
 }): Promise<string> {
-  const history = loadCompactHistory(input.historyFile, COMPACT_TAIL_TOKENS);
+  const history = loadCompactHistory(input.historyFile, input.tailTokens);
   const specWriterTask = buildCompactSpecWriterTask({
     task: input.task,
     repoPath: input.repoPath,
     targetProfile: input.targetProfile.name,
     historyPath: history.path,
     historyTail: history.tail,
-    tailTokens: COMPACT_TAIL_TOKENS,
+    tailTokens: input.tailTokens,
   });
   const id = genId();
   const adapter = cursorAdapter;
@@ -221,7 +236,15 @@ async function generateCompactSpec(input: {
   );
   const preToken = adapter.preSpawn(input.repoPath);
   const specStartedAt = Date.now();
-  await runJob({ adapter, profile: specWriterProfile }, input.repoPath, id);
+  const statsBefore =
+    input.headroomUrl && input.logHeadroomStats ? await readHeadroomStats(input.headroomUrl) : null;
+  await runJob(
+    { adapter, profile: specWriterProfile, env: input.headroomEnv },
+    input.repoPath,
+    id,
+  );
+  const statsAfter =
+    input.headroomUrl && input.logHeadroomStats ? await readHeadroomStats(input.headroomUrl) : null;
   const specElapsedSec = Math.round((Date.now() - specStartedAt) / 1000);
   adapter.postExit(input.repoPath, preToken);
   const job = readJob(input.repoPath, id);
@@ -235,6 +258,8 @@ async function generateCompactSpec(input: {
   process.stderr.write(
     `open-agents: compact-mode generated spec ${id} in ${specElapsedSec}s (${generated.length} chars) -> ${userPath(job.resultPath || '')}\n`,
   );
+  const delta = formatHeadroomDelta(statsBefore, statsAfter);
+  if (delta) process.stderr.write(`open-agents: headroom compact-mode stats: ${delta}\n`);
   return generated;
 }
 
@@ -254,6 +279,23 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
   const timeoutSec = Number.isFinite(flags.timeout)
     ? flags.timeout!
     : (config.defaultTimeoutSec ?? DEFAULT_TIMEOUT_SEC);
+  const headroomConfig = resolveHeadroomConfig({
+    config: config.headroom,
+    modeFlag: flags.headroom,
+    urlFlag: flags.headroomUrl,
+  });
+  const headroom = await detectHeadroom({ adapterName: adapter.name, config: headroomConfig });
+  if (headroom.active) {
+    process.stderr.write(`open-agents: headroom active (${headroom.openAIBaseUrl})\n`);
+  } else if (headroomConfig.mode !== 'off') {
+    process.stderr.write(
+      `open-agents: headroom unavailable; continuing without proxy` +
+        `${headroom.reason ? ` (${headroom.reason})` : ''}\n`,
+    );
+  }
+  const compactTailTokens = headroom.active
+    ? HEADROOM_COMPACT_TAIL_TOKENS
+    : DEFAULT_COMPACT_TAIL_TOKENS;
   const adapterAddendum = adapter.guardAddendum?.(profile.name, flags.tier) ?? '';
   const profileKey = profile.name as 'explore' | 'edit';
   const userExtension = config.profiles?.[profileKey]?.systemPromptExtension ?? '';
@@ -300,6 +342,10 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
           targetProfile: profile,
           task: body,
           historyFile,
+          tailTokens: compactTailTokens,
+          headroomEnv: headroom.env,
+          headroomUrl: headroom.active ? headroom.url : undefined,
+          logHeadroomStats: headroomConfig.logStats,
         }),
       ),
     );
@@ -324,7 +370,7 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
     return id;
   });
 
-  const deps = { adapter, profile };
+  const deps = { adapter, profile, env: headroom.env };
 
   if (flags.detach) {
     for (const id of ids) {
@@ -332,6 +378,7 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
         detached: true,
         stdio: 'ignore',
         windowsHide: true,
+        env: { ...process.env, ...headroom.env },
       }).unref();
     }
     process.stdout.write(ids.join('\n') + '\n');
@@ -577,11 +624,16 @@ const HELP = `open-agents cli — self-waiting subagent job primitive
              details, quotes, or file lists into the inline prompt when the
              conversation already contains that context.
              Uses --history-file <path>, OPEN_AGENTS_HISTORY_FILE,
-             CLAUDE_CODE_TRANSCRIPT_PATH, or the current Claude Code transcript
-             when CLAUDE_CODE_SESSION_ID is set. Always gives the spec-writer
-             the last 50000 token-like units plus a pointer to the full history.
+             CLAUDE_CODE_TRANSCRIPT_PATH, the current Claude Code transcript
+             when CLAUDE_CODE_SESSION_ID is set, CODEX_THREAD_ID sessions under
+             ~/.codex/sessions, or ~/.codex/history.jsonl. Gives the spec-writer
+             the last 50000 token-like units plus a pointer to the full history
+             (100000 when a local Headroom proxy is active).
              Progress output includes spec generation time and the generated
              spec artifact path.
+           --headroom auto|off|require (default auto): auto-probe Headroom at
+             http://127.0.0.1:8787 and set OPENAI_BASE_URL=<url>/v1 for cursor
+             jobs when healthy. --headroom-url overrides the proxy URL.
   wait                         wait for ALL running jobs in this repo
   wait   "<id…>" | <id…>       wait for ALL of these
   wait   --any <id…>           return when ≥1 done; prints which (loop = popcorn)
diff --git a/packages/open-agents/src/config.ts b/packages/open-agents/src/config.ts
index ca2c78f..dbd0905 100644
--- a/packages/open-agents/src/config.ts
+++ b/packages/open-agents/src/config.ts
@@ -12,6 +12,7 @@
 
 import { resolve } from 'node:path';
 import { findRepoRoot, findToolConfig } from '@davstack/cli-utils/config';
+import type { HeadroomConfig } from './core/headroom.js';
 
 export type AdapterName = 'cursor' | 'gemini' | 'agy';
 
@@ -23,6 +24,7 @@ export type OpenAgentsConfig = {
   defaultModel?: string;
   defaultAdapter?: AdapterName;
   defaultTimeoutSec?: number;
+  headroom?: HeadroomConfig;
   profiles?: {
     explore?: ProfileOverrides;
     edit?: ProfileOverrides;
@@ -69,6 +71,7 @@ export async function loadConfig(cwd: string = process.cwd()): Promise<LoadedCon
       typeof raw.defaultTimeoutSec === 'number' && raw.defaultTimeoutSec > 0
         ? raw.defaultTimeoutSec
         : undefined,
+    headroom: normalizeHeadroomConfig(raw.headroom),
     profiles: raw.profiles && typeof raw.profiles === 'object' ? raw.profiles : undefined,
     _source: configPath,
     _repoRoot: repoRoot,
@@ -77,6 +80,19 @@ export async function loadConfig(cwd: string = process.cwd()): Promise<LoadedCon
   return merged;
 }
 
+function normalizeHeadroomConfig(raw: unknown): HeadroomConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const obj = raw as Record<string, unknown>;
+  const mode = obj.mode;
+  const normalizedMode =
+    mode === 'auto' || mode === 'off' || mode === 'require' ? mode : undefined;
+  return {
+    mode: normalizedMode,
+    url: typeof obj.url === 'string' ? obj.url : undefined,
+    logStats: typeof obj.logStats === 'boolean' ? obj.logStats : undefined,
+  };
+}
+
 function pathToFileUrl(p: string): string {
   // Minimal local equivalent of url.pathToFileURL(p).href to avoid the extra
   // import and to keep the surface trivially auditable.
diff --git a/packages/open-agents/src/core/headroom.ts b/packages/open-agents/src/core/headroom.ts
new file mode 100644
index 0000000..7533d4e
--- /dev/null
+++ b/packages/open-agents/src/core/headroom.ts
@@ -0,0 +1,159 @@
+export type HeadroomMode = 'auto' | 'off' | 'require';
+
+export interface HeadroomConfig {
+  mode?: HeadroomMode;
+  url?: string;
+  logStats?: boolean;
+}
+
+export interface HeadroomState {
+  active: boolean;
+  required: boolean;
+  url: string;
+  openAIBaseUrl: string;
+  env: Record<string, string>;
+  reason?: string;
+}
+
+export interface HeadroomStats {
+  requestsTotal: number;
+  tokensSaved: number;
+  inputTokens: number;
+  outputTokens: number;
+  raw: unknown;
+}
+
+interface HeadroomStatsResponse {
+  requests?: {
+    total?: number;
+  };
+  tokens?: {
+    input?: number;
+    output?: number;
+    saved?: number;
+  };
+}
+
+const DEFAULT_URL = 'http://127.0.0.1:8787';
+const DEFAULT_TIMEOUT_MS = 750;
+
+function cleanUrl(url: string): string {
+  return url.replace(/\/+$/, '');
+}
+
+function parseMode(value: unknown): HeadroomMode | undefined {
+  if (typeof value !== 'string') return undefined;
+  const lower = value.toLowerCase();
+  if (lower === 'auto' || lower === 'off' || lower === 'require') return lower;
+  return undefined;
+}
+
+export function resolveHeadroomConfig(input?: {
+  config?: HeadroomConfig;
+  env?: NodeJS.ProcessEnv;
+  modeFlag?: string;
+  urlFlag?: string;
+}): Required<Pick<HeadroomConfig, 'mode' | 'url' | 'logStats'>> {
+  const env = input?.env ?? process.env;
+  const mode =
+    parseMode(input?.modeFlag) ??
+    parseMode(env.OPEN_AGENTS_HEADROOM) ??
+    input?.config?.mode ??
+    'auto';
+  const url = cleanUrl(
+    input?.urlFlag || env.OPEN_AGENTS_HEADROOM_URL || input?.config?.url || DEFAULT_URL,
+  );
+  const logStats =
+    env.OPEN_AGENTS_HEADROOM_LOG_STATS === '0' || env.OPEN_AGENTS_HEADROOM_LOG_STATS === 'false'
+      ? false
+      : (input?.config?.logStats ?? true);
+  return { mode, url, logStats };
+}
+
+async function fetchJson(url: string, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<unknown> {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { signal: ac.signal });
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`.trim());
+    return await res.json();
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export async function detectHeadroom(input: {
+  adapterName: string;
+  config: Required<Pick<HeadroomConfig, 'mode' | 'url' | 'logStats'>>;
+}): Promise<HeadroomState> {
+  const { adapterName, config } = input;
+  const required = config.mode === 'require';
+  const openAIBaseUrl = `${config.url}/v1`;
+  if (config.mode === 'off') {
+    return { active: false, required, url: config.url, openAIBaseUrl, env: {}, reason: 'disabled' };
+  }
+  if (adapterName !== 'cursor') {
+    return {
+      active: false,
+      required,
+      url: config.url,
+      openAIBaseUrl,
+      env: {},
+      reason: `adapter ${adapterName} does not use the OpenAI-compatible proxy path`,
+    };
+  }
+  try {
+    await fetchJson(`${config.url}/health`);
+    return {
+      active: true,
+      required,
+      url: config.url,
+      openAIBaseUrl,
+      env: { OPENAI_BASE_URL: openAIBaseUrl },
+    };
+  } catch (err) {
+    if (required) {
+      throw new Error(
+        `Headroom is required but not healthy at ${config.url}: ${(err as Error).message}`,
+      );
+    }
+    return {
+      active: false,
+      required,
+      url: config.url,
+      openAIBaseUrl,
+      env: {},
+      reason: (err as Error).message,
+    };
+  }
+}
+
+function numberOrZero(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+export async function readHeadroomStats(url: string): Promise<HeadroomStats | null> {
+  try {
+    const raw = await fetchJson(`${cleanUrl(url)}/stats`);
+    const stats = raw as HeadroomStatsResponse;
+    return {
+      requestsTotal: numberOrZero(stats.requests?.total),
+      tokensSaved: numberOrZero(stats.tokens?.saved),
+      inputTokens: numberOrZero(stats.tokens?.input),
+      outputTokens: numberOrZero(stats.tokens?.output),
+      raw,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function formatHeadroomDelta(before: HeadroomStats | null, after: HeadroomStats | null): string | null {
+  if (!before || !after) return null;
+  const bits: string[] = [];
+  const requestDelta = after.requestsTotal - before.requestsTotal;
+  if (requestDelta > 0) bits.push(`${requestDelta} request${requestDelta === 1 ? '' : 's'}`);
+  const savedDelta = after.tokensSaved - before.tokensSaved;
+  if (savedDelta > 0) bits.push(`${Math.round(savedDelta).toLocaleString()} tokens saved`);
+  return bits.length ? bits.join(', ') : null;
+}
diff --git a/packages/open-agents/src/core/run.ts b/packages/open-agents/src/core/run.ts
index 8fb1a65..32ab64c 100644
--- a/packages/open-agents/src/core/run.ts
+++ b/packages/open-agents/src/core/run.ts
@@ -24,12 +24,13 @@ export function resultFilePath(repoPath: string, id: string): string {
 interface RunDeps {
   adapter: AgentAdapter;
   profile: Profile;
+  env?: Record<string, string>;
 }
 
 // Resolves (with 0) when the job reaches a terminal state. Used by the
 // detached runner (`__run`) and by a blocking foreground `submit`.
 export function runJob(
-  { adapter, profile }: RunDeps,
+  { adapter, profile, env }: RunDeps,
   repoPath: string,
   id: string,
 ): Promise<number> {
@@ -43,7 +44,7 @@ export function runJob(
       ...adapter.buildArgs({
         model: job.model,
         mode: profile.mode,
-        prompt: job.fullPrompt,
+        prompt: job.fullPrompt ?? job.prompt,
       }),
     ];
     const child = spawn(bin, args, {
@@ -51,8 +52,9 @@ export function runJob(
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
       shell,
+      env: env ? { ...process.env, ...env } : process.env,
     });
-    updateJob(repoPath, id, { pid: child.pid });
+    if (typeof child.pid === 'number') updateJob(repoPath, id, { pid: child.pid });
 
     const log = createWriteStream(job.rawLogPath, { flags: 'a' });
     const events: any[] = [];

From 458c0ecb5b7fe47b3e14673ac261bc45c075b1c9 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 11:52:08 +0100
Subject: [PATCH 37/72] Add open-agents changeset

---
 .changeset/headroom-open-agents.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 .changeset/headroom-open-agents.md

diff --git a/.changeset/headroom-open-agents.md b/.changeset/headroom-open-agents.md
new file mode 100644
index 0000000..75019d6
--- /dev/null
+++ b/.changeset/headroom-open-agents.md
@@ -0,0 +1,5 @@
+---
+"@davstack/open-agents": patch
+---
+
+Add optional Headroom proxy routing plus Codex compact-history discovery.

From e66bad64e7724bda262c2080653e49c8cfaef13a Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 12:00:05 +0100
Subject: [PATCH 38/72] chore: version open-agents headroom release

---
 .changeset/headroom-open-agents.md | 5 -----
 packages/open-agents/CHANGELOG.md  | 6 ++++++
 packages/open-agents/package.json  | 2 +-
 packages/tui/CHANGELOG.md          | 7 +++++++
 packages/tui/package.json          | 2 +-
 5 files changed, 15 insertions(+), 7 deletions(-)
 delete mode 100644 .changeset/headroom-open-agents.md

diff --git a/.changeset/headroom-open-agents.md b/.changeset/headroom-open-agents.md
deleted file mode 100644
index 75019d6..0000000
--- a/.changeset/headroom-open-agents.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@davstack/open-agents": patch
----
-
-Add optional Headroom proxy routing plus Codex compact-history discovery.
diff --git a/packages/open-agents/CHANGELOG.md b/packages/open-agents/CHANGELOG.md
index 826df76..09334b2 100644
--- a/packages/open-agents/CHANGELOG.md
+++ b/packages/open-agents/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/open-agents
 
+## 1.2.5
+
+### Patch Changes
+
+- 458c0ec: Add optional Headroom proxy routing plus Codex compact-history discovery.
+
 ## 1.2.4
 
 ### Patch Changes
diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index 0ab9af4..c4371bc 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/open-agents",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "license": "MIT",
   "type": "module",
   "description": "Self-waiting Cursor-jobs primitive: delegate scoped explore (read-only) and fast-edit (mechanical) work to cursor-agent, harness-trackable, results persisted per job.",
diff --git a/packages/tui/CHANGELOG.md b/packages/tui/CHANGELOG.md
index 502213e..ae3fe48 100644
--- a/packages/tui/CHANGELOG.md
+++ b/packages/tui/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @davstack/tui
 
+## 0.5.4
+
+### Patch Changes
+
+- Updated dependencies [458c0ec]
+  - @davstack/open-agents@1.2.5
+
 ## 0.5.3
 
 ### Patch Changes
diff --git a/packages/tui/package.json b/packages/tui/package.json
index c8d8e5a..4b92a7d 100644
--- a/packages/tui/package.json
+++ b/packages/tui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/tui",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "license": "MIT",
   "type": "module",
   "description": "Long-running terminal UI that spawns, owns, and surfaces the davstack daemons (vitest-server, logs-server).",

From 81da9118c959ed61fe352092cb3303c73ba72515 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 15:10:06 +0100
Subject: [PATCH 39/72] feat(context-compactor): add TS-native context
 compaction package
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

New @davstack/context-compactor: deterministic, dependency-light context
compaction for LLM agents. Detects content type and routes to structure-aware
handlers — JSON (array head/tail cap, string truncation, schema-preserving),
code (body elision), log (run dedup), diff (context collapse), text (head/tail)
— each leaving retrieval-pointer breadcrumbs.

JSON output supports TOON (Token-Oriented Object Notation) via the zero-dep
@toon-format/toon encoder, with a 'json' | 'toon' | 'auto' switch; 'auto'
(default) emits whichever serialization is smaller and is never worse than JSON.
Arrays of uniform objects collapse from repeated keys to a single field header
plus comma rows. No ML, no network, no proxy. 48 vitest tests.
---
 .../context-compactor-spec-compaction.md      |   6 +
 .../context-compactor/__tests__/code.test.ts  |  66 +++++++++
 .../__tests__/detect.test.ts                  |  36 +++++
 .../context-compactor/__tests__/diff.test.ts  |  67 +++++++++
 .../__tests__/entropy.test.ts                 |  33 +++++
 .../context-compactor/__tests__/json.test.ts  |  88 ++++++++++++
 .../context-compactor/__tests__/log.test.ts   |  60 ++++++++
 .../context-compactor/__tests__/text.test.ts  |  48 +++++++
 .../context-compactor/__tests__/toon.test.ts  |  57 ++++++++
 packages/context-compactor/package.json       |  37 +++++
 packages/context-compactor/src/detect.ts      |  43 ++++++
 packages/context-compactor/src/entropy.ts     |  32 +++++
 .../context-compactor/src/handlers/code.ts    |  92 +++++++++++++
 .../context-compactor/src/handlers/diff.ts    |  64 +++++++++
 .../context-compactor/src/handlers/json.ts    |  83 +++++++++++
 .../context-compactor/src/handlers/log.ts     |  69 ++++++++++
 .../context-compactor/src/handlers/text.ts    |  59 ++++++++
 .../context-compactor/src/handlers/toon.ts    |  93 +++++++++++++
 packages/context-compactor/src/index.ts       | 129 ++++++++++++++++++
 packages/context-compactor/src/types.ts       |  63 +++++++++
 packages/context-compactor/tsconfig.json      |  17 +++
 packages/context-compactor/tsup.config.ts     |  14 ++
 .../open-agents/__tests__/compact.test.ts     |  40 ++++++
 .../open-agents/__tests__/headroom.test.ts    |  52 ++++++-
 packages/open-agents/src/cli.ts               |  29 +++-
 packages/open-agents/src/core/compact.ts      |  91 +++++++++++-
 packages/open-agents/src/core/headroom.ts     |  71 ++++++++++
 pnpm-lock.yaml                                |  27 +++-
 vitest.workspace.ts                           |  10 ++
 29 files changed, 1569 insertions(+), 7 deletions(-)
 create mode 100644 .changeset/context-compactor-spec-compaction.md
 create mode 100644 packages/context-compactor/__tests__/code.test.ts
 create mode 100644 packages/context-compactor/__tests__/detect.test.ts
 create mode 100644 packages/context-compactor/__tests__/diff.test.ts
 create mode 100644 packages/context-compactor/__tests__/entropy.test.ts
 create mode 100644 packages/context-compactor/__tests__/json.test.ts
 create mode 100644 packages/context-compactor/__tests__/log.test.ts
 create mode 100644 packages/context-compactor/__tests__/text.test.ts
 create mode 100644 packages/context-compactor/__tests__/toon.test.ts
 create mode 100644 packages/context-compactor/package.json
 create mode 100644 packages/context-compactor/src/detect.ts
 create mode 100644 packages/context-compactor/src/entropy.ts
 create mode 100644 packages/context-compactor/src/handlers/code.ts
 create mode 100644 packages/context-compactor/src/handlers/diff.ts
 create mode 100644 packages/context-compactor/src/handlers/json.ts
 create mode 100644 packages/context-compactor/src/handlers/log.ts
 create mode 100644 packages/context-compactor/src/handlers/text.ts
 create mode 100644 packages/context-compactor/src/handlers/toon.ts
 create mode 100644 packages/context-compactor/src/index.ts
 create mode 100644 packages/context-compactor/src/types.ts
 create mode 100644 packages/context-compactor/tsconfig.json
 create mode 100644 packages/context-compactor/tsup.config.ts

diff --git a/.changeset/context-compactor-spec-compaction.md b/.changeset/context-compactor-spec-compaction.md
new file mode 100644
index 0000000..2698c03
--- /dev/null
+++ b/.changeset/context-compactor-spec-compaction.md
@@ -0,0 +1,6 @@
+---
+"@davstack/context-compactor": minor
+"@davstack/open-agents": minor
+---
+
+Add `@davstack/context-compactor`: a TS-native, deterministic context-compaction package with structure-aware handlers (JSON, code, log, diff, text) and TOON output for arrays of uniform objects. open-agents now compacts spec-writer handoff history through it before generation, and the Headroom proxy routing is defaulted off.
diff --git a/packages/context-compactor/__tests__/code.test.ts b/packages/context-compactor/__tests__/code.test.ts
new file mode 100644
index 0000000..a8829d9
--- /dev/null
+++ b/packages/context-compactor/__tests__/code.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'vitest'
+import { compact, compactCode } from '../src/index.js'
+
+const SAMPLE = `import { foo } from './foo'
+export function doWork(input: string) {
+  const a = input.trim()
+  const b = a.toUpperCase()
+  const c = b.split('')
+  const d = c.reverse()
+  return d.join('')
+}
+
+export class Widget {
+  render() {
+    const el = document.createElement('div')
+    el.className = 'widget'
+    el.textContent = 'hi'
+    document.body.appendChild(el)
+    return el
+  }
+}
+`
+
+describe('compactCode', () => {
+  test('keeps structural lines (imports, signatures, class)', () => {
+    const { text } = compactCode(SAMPLE, { signatureIndent: 4, minRun: 3 })
+    expect(text).toContain("import { foo } from './foo'")
+    expect(text).toContain('export function doWork(input: string) {')
+    expect(text).toContain('export class Widget {')
+    expect(text).toContain('render() {')
+  })
+
+  test('collapses deep body runs into a marker + pointer', () => {
+    const { text, transforms, pointers } = compactCode(SAMPLE, { signatureIndent: 4, minRun: 3 })
+    expect(transforms).toContain('code:body-elide')
+    expect(text).toMatch(/\/\/ … \d+ lines/)
+    const p = pointers.find((p) => p.kind === 'code-body')
+    expect(p).toBeDefined()
+    expect(p!.omitted).toBeGreaterThanOrEqual(3)
+  })
+
+  test('reduces line count', () => {
+    const { text } = compactCode(SAMPLE, { signatureIndent: 4, minRun: 3 })
+    expect(text.split('\n').length).toBeLessThan(SAMPLE.split('\n').length)
+  })
+
+  test('preserves leading comments', () => {
+    const src = '// important note\nfunction f() {\n      x\n      y\n      z\n      w\n}'
+    const { text } = compactCode(src, { signatureIndent: 4, minRun: 3 })
+    expect(text).toContain('// important note')
+  })
+
+  test('routes via compact() and leaves short input unchanged', () => {
+    const short = 'export const x = 1'
+    const result = compact(short, { contentType: 'code' })
+    expect(result.transforms).toHaveLength(0)
+    expect(result.text).toBe(short)
+  })
+
+  test('compact() detects and compacts code', () => {
+    const result = compact(SAMPLE)
+    expect(result.contentType).toBe('code')
+    expect(result.transforms).toContain('code:body-elide')
+    expect(result.tokensSaved).toBeGreaterThan(0)
+  })
+})
diff --git a/packages/context-compactor/__tests__/detect.test.ts b/packages/context-compactor/__tests__/detect.test.ts
new file mode 100644
index 0000000..34f972c
--- /dev/null
+++ b/packages/context-compactor/__tests__/detect.test.ts
@@ -0,0 +1,36 @@
+import { describe, expect, test } from 'vitest'
+import { detectContentType } from '../src/detect.js'
+
+describe('detectContentType', () => {
+  test('valid json object', () => {
+    expect(detectContentType('{"a": 1, "b": [1, 2, 3]}')).toBe('json')
+  })
+
+  test('valid json array', () => {
+    expect(detectContentType('[{"id": 1}, {"id": 2}]')).toBe('json')
+  })
+
+  test('json-looking but invalid falls through to text', () => {
+    expect(detectContentType('{not json at all')).toBe('text')
+  })
+
+  test('unified diff', () => {
+    expect(detectContentType('diff --git a/x.ts b/x.ts\n@@ -1 +1 @@\n-old\n+new')).toBe('diff')
+  })
+
+  test('source code', () => {
+    expect(detectContentType('export function foo() {\n  return 1\n}')).toBe('code')
+  })
+
+  test('log output', () => {
+    expect(detectContentType('2026-06-09 12:00:00 ERROR something failed')).toBe('log')
+  })
+
+  test('plain prose', () => {
+    expect(detectContentType('the quick brown fox jumps over the lazy dog')).toBe('text')
+  })
+
+  test('empty is unknown', () => {
+    expect(detectContentType('   ')).toBe('unknown')
+  })
+})
diff --git a/packages/context-compactor/__tests__/diff.test.ts b/packages/context-compactor/__tests__/diff.test.ts
new file mode 100644
index 0000000..e6866ae
--- /dev/null
+++ b/packages/context-compactor/__tests__/diff.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, test } from 'vitest'
+import { compact, compactDiff } from '../src/index.js'
+
+const SAMPLE = `diff --git a/src/x.ts b/src/x.ts
+index 1111111..2222222 100644
+--- a/src/x.ts
++++ b/src/x.ts
+@@ -1,12 +1,12 @@
+ context line 1
+ context line 2
+ context line 3
+ context line 4
+ context line 5
+ context line 6
+-const old = 1
++const next = 2
+ context line 7
+ context line 8
+ context line 9
+ context line 10
+ context line 11
+`
+
+describe('compactDiff', () => {
+  test('keeps diff and hunk headers', () => {
+    const { text } = compactDiff(SAMPLE, { maxContext: 3 })
+    expect(text).toContain('diff --git a/src/x.ts b/src/x.ts')
+    expect(text).toContain('--- a/src/x.ts')
+    expect(text).toContain('+++ b/src/x.ts')
+    expect(text).toContain('@@ -1,12 +1,12 @@')
+  })
+
+  test('keeps changed lines', () => {
+    const { text } = compactDiff(SAMPLE, { maxContext: 3 })
+    expect(text).toContain('-const old = 1')
+    expect(text).toContain('+const next = 2')
+  })
+
+  test('collapses long context runs into a marker + pointer', () => {
+    const { text, transforms, pointers } = compactDiff(SAMPLE, { maxContext: 3 })
+    expect(transforms).toContain('diff:context-collapse')
+    expect(text).toMatch(/… \d+ unchanged lines/)
+    const p = pointers.find((p) => p.kind === 'diff-context')
+    expect(p).toBeDefined()
+    expect(p!.omitted).toBeGreaterThan(3)
+    expect(text.split('\n').length).toBeLessThan(SAMPLE.split('\n').length)
+  })
+
+  test('does not collapse short context runs', () => {
+    const small = `@@ -1,2 +1,2 @@
+ ctx a
+-old
++new
+ ctx b`
+    const { text, transforms } = compactDiff(small, { maxContext: 3 })
+    expect(transforms).toHaveLength(0)
+    expect(text).toContain(' ctx a')
+    expect(text).toContain(' ctx b')
+  })
+
+  test('compact() detects and compacts diffs', () => {
+    const result = compact(SAMPLE)
+    expect(result.contentType).toBe('diff')
+    expect(result.transforms).toContain('diff:context-collapse')
+    expect(result.tokensSaved).toBeGreaterThan(0)
+  })
+})
diff --git a/packages/context-compactor/__tests__/entropy.test.ts b/packages/context-compactor/__tests__/entropy.test.ts
new file mode 100644
index 0000000..25bd1ea
--- /dev/null
+++ b/packages/context-compactor/__tests__/entropy.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, test } from 'vitest'
+import { isHighEntropy, normalizedEntropy } from '../src/entropy.js'
+
+describe('normalizedEntropy', () => {
+  test('uniform repetition has ~zero entropy', () => {
+    expect(normalizedEntropy('aaaaaaaa')).toBe(0)
+  })
+
+  test('empty string is zero', () => {
+    expect(normalizedEntropy('')).toBe(0)
+  })
+
+  test('a uuid scores higher than an english word', () => {
+    const uuid = '8f14e45f-ceea-4123-8f14-e45fceea4123'
+    expect(normalizedEntropy(uuid)).toBeGreaterThan(normalizedEntropy('success'))
+  })
+})
+
+describe('isHighEntropy', () => {
+  test('preserves a uuid', () => {
+    expect(isHighEntropy('8f14e45f-ceea-4123-8f14-e45fceea4123')).toBe(true)
+  })
+
+  test('does not flag a short common word', () => {
+    expect(isHighEntropy('hello')).toBe(false)
+  })
+
+  test('does not flag a long string dominated by one character', () => {
+    // Normalized entropy measures alphabet-evenness, not word repetition: a
+    // skewed distribution (mostly 'a') scores low and is not preserved.
+    expect(isHighEntropy('aaaaaaaaaaaaaaaaaaaab')).toBe(false)
+  })
+})
diff --git a/packages/context-compactor/__tests__/json.test.ts b/packages/context-compactor/__tests__/json.test.ts
new file mode 100644
index 0000000..8d605e6
--- /dev/null
+++ b/packages/context-compactor/__tests__/json.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'vitest'
+import { compact } from '../src/index.js'
+
+/** Build the canonical "large tool-result array" shape (cf. logs-dump.md). */
+function bigArrayFixture(n = 1000): string {
+  const results = Array.from({ length: n }, (_, i) => ({
+    id: i,
+    status: i === n - 2 ? 'error' : 'ok',
+    message: i === n - 2 ? 'Connection timeout' : 'Success',
+    uuid: '8f14e45f-ceea-4123-8f14-e45fceea4123',
+    timestamp: '2026-06-09T12:00:00Z',
+  }))
+  return JSON.stringify({ results }, null, 2)
+}
+
+describe('compact() on JSON', () => {
+  test('caps a long array to head + sentinel + tail and stays valid JSON', () => {
+    const input = bigArrayFixture(1000)
+    const result = compact(input, { jsonFormat: 'json' })
+
+    expect(result.contentType).toBe('json')
+    expect(result.transforms).toContain('json:array-cap')
+
+    const parsed = JSON.parse(result.text) as { results: unknown[] }
+    // 3 head + 1 sentinel + 1 tail
+    expect(parsed.results).toHaveLength(5)
+    expect((parsed.results[0] as { id: number }).id).toBe(0)
+    expect((parsed.results[4] as { id: number }).id).toBe(999)
+    expect(parsed.results[3]).toContain('omitted')
+  })
+
+  test('records a pointer with the omitted count', () => {
+    const result = compact(bigArrayFixture(1000))
+    const arrayPointer = result.pointers.find((p) => p.kind === 'json-array-items')
+    expect(arrayPointer).toBeDefined()
+    expect(arrayPointer!.omitted).toBe(996)
+  })
+
+  test('preserves the full schema (every key) of kept items', () => {
+    const result = compact(bigArrayFixture(1000), { jsonFormat: 'json' })
+    const parsed = JSON.parse(result.text) as { results: Array<Record<string, unknown>> }
+    expect(Object.keys(parsed.results[0]).sort()).toEqual([
+      'id',
+      'message',
+      'status',
+      'timestamp',
+      'uuid',
+    ])
+  })
+
+  test('preserves high-entropy ids verbatim in kept items', () => {
+    const result = compact(bigArrayFixture(1000))
+    expect(result.text).toContain('8f14e45f-ceea-4123-8f14-e45fceea4123')
+  })
+
+  test('achieves a large token reduction on the big array', () => {
+    const result = compact(bigArrayFixture(1000))
+    expect(result.tokensSaved).toBeGreaterThan(0)
+    expect(result.ratio).toBeLessThan(0.2)
+  })
+
+  test('truncates long string values but keeps short ones', () => {
+    const input = JSON.stringify({
+      short: 'keep me',
+      long: 'x'.repeat(1000),
+    })
+    const result = compact(input, { jsonFormat: 'json' })
+    expect(result.transforms).toContain('json:string-truncate')
+    const parsed = JSON.parse(result.text) as { short: string; long: string }
+    expect(parsed.short).toBe('keep me')
+    expect(parsed.long).toContain('chars]')
+    expect(parsed.long.length).toBeLessThan(200)
+  })
+
+  test('leaves small JSON untouched (below minLength)', () => {
+    const input = '{"a": 1, "b": 2}'
+    const result = compact(input)
+    expect(result.transforms).toHaveLength(0)
+    expect(result.text).toBe(input)
+    expect(result.tokensSaved).toBe(0)
+  })
+
+  test('does not cap arrays that are already short', () => {
+    const input = JSON.stringify({ items: [1, 2, 3] }) + ' '.repeat(300)
+    const result = compact(input)
+    expect(result.transforms).not.toContain('json:array-cap')
+  })
+})
diff --git a/packages/context-compactor/__tests__/log.test.ts b/packages/context-compactor/__tests__/log.test.ts
new file mode 100644
index 0000000..1106040
--- /dev/null
+++ b/packages/context-compactor/__tests__/log.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, test } from 'vitest'
+import { compact, compactLog } from '../src/index.js'
+
+describe('compactLog', () => {
+  test('collapses runs of identical lines into a count marker', () => {
+    const input = Array.from({ length: 50 }, () => 'connection retry...').join('\n')
+    const { text, transforms, pointers } = compactLog(input, { ignoreTimestamps: true })
+    expect(transforms).toContain('log:dedup')
+    expect(text).toContain('(×50)')
+    const p = pointers.find((p) => p.kind === 'log-dedup')
+    expect(p).toBeDefined()
+    expect(p!.omitted).toBe(49)
+    expect(text.split('\n').length).toBeLessThan(input.split('\n').length)
+  })
+
+  test('treats timestamped lines as near-identical', () => {
+    const input = [
+      '2026-06-09T12:00:00Z heartbeat ok',
+      '2026-06-09T12:00:01Z heartbeat ok',
+      '2026-06-09T12:00:02Z heartbeat ok',
+    ].join('\n')
+    const { text } = compactLog(input, { ignoreTimestamps: true })
+    expect(text).toContain('(×3)')
+    expect(text.split('\n')).toHaveLength(1)
+  })
+
+  test('ALWAYS keeps error / warn / stack-frame lines', () => {
+    const input = [
+      'info ok',
+      'info ok',
+      'ERROR boom failed',
+      'ERROR boom failed',
+      'Traceback (most recent call last):',
+      '  File "app.py", line 10, in <module>',
+      '    at Object.<anonymous> (/x.js:1:1)',
+      'WARNING low disk',
+    ].join('\n')
+    const { text } = compactLog(input, { ignoreTimestamps: true })
+    expect((text.match(/ERROR boom failed/g) ?? []).length).toBe(2)
+    expect(text).toContain('Traceback (most recent call last):')
+    expect(text).toContain('File "app.py"')
+    expect(text).toContain('at Object.<anonymous>')
+    expect(text).toContain('WARNING low disk')
+  })
+
+  test('leaves non-repeating lines unchanged', () => {
+    const input = 'line one\nline two\nline three'
+    const { text, transforms } = compactLog(input, { ignoreTimestamps: true })
+    expect(transforms).toHaveLength(0)
+    expect(text).toBe(input)
+  })
+
+  test('compact() detects and compacts logs', () => {
+    const input = Array.from({ length: 30 }, () => 'DEBUG polling status').join('\n')
+    const result = compact(input)
+    expect(result.contentType).toBe('log')
+    expect(result.transforms).toContain('log:dedup')
+    expect(result.tokensSaved).toBeGreaterThan(0)
+  })
+})
diff --git a/packages/context-compactor/__tests__/text.test.ts b/packages/context-compactor/__tests__/text.test.ts
new file mode 100644
index 0000000..dd0be10
--- /dev/null
+++ b/packages/context-compactor/__tests__/text.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'vitest'
+import { compact, compactText } from '../src/index.js'
+
+function lines(n: number): string {
+  return Array.from({ length: n }, (_, i) => `line ${i}`).join('\n')
+}
+
+describe('compactText', () => {
+  test('keeps head and tail, elides the middle with a marker + pointer', () => {
+    const input = lines(100)
+    const { text, transforms, pointers } = compactText(input, {
+      headLines: 5,
+      tailLines: 5,
+      dedup: false,
+    })
+    expect(transforms).toContain('text:head-tail')
+    expect(text).toContain('line 0')
+    expect(text).toContain('line 4')
+    expect(text).toContain('line 99')
+    expect(text).toMatch(/…\[\+\d+ lines omitted\]/)
+    const p = pointers.find((p) => p.kind === 'text-middle')
+    expect(p).toBeDefined()
+    expect(p!.omitted).toBe(90)
+    expect(text.split('\n').length).toBeLessThan(input.split('\n').length)
+  })
+
+  test('leaves short input unchanged', () => {
+    const input = lines(4)
+    const { text, transforms } = compactText(input, { headLines: 5, tailLines: 5, dedup: false })
+    expect(transforms).toHaveLength(0)
+    expect(text).toBe(input)
+  })
+
+  test('dedups exact-duplicate lines when enabled', () => {
+    const input = ['a', 'a', 'b', 'b', 'c'].join('\n')
+    const { text, transforms } = compactText(input, { headLines: 50, tailLines: 50, dedup: true })
+    expect(transforms).toContain('text:dedup')
+    expect(text.split('\n')).toEqual(['a', 'b', 'c'])
+  })
+
+  test('compact() detects and compacts prose', () => {
+    const input = Array.from({ length: 80 }, (_, i) => `the quick brown fox number ${i}`).join('\n')
+    const result = compact(input)
+    expect(result.contentType).toBe('text')
+    expect(result.transforms).toContain('text:head-tail')
+    expect(result.tokensSaved).toBeGreaterThan(0)
+  })
+})
diff --git a/packages/context-compactor/__tests__/toon.test.ts b/packages/context-compactor/__tests__/toon.test.ts
new file mode 100644
index 0000000..48d82db
--- /dev/null
+++ b/packages/context-compactor/__tests__/toon.test.ts
@@ -0,0 +1,57 @@
+import { describe, expect, test } from 'vitest'
+import { compact } from '../src/index.js'
+
+function bigArrayFixture(n = 1000): string {
+  const results = Array.from({ length: n }, (_, i) => ({
+    id: i,
+    status: i === n - 2 ? 'error' : 'ok',
+    message: i === n - 2 ? 'Connection timeout' : 'Success',
+    timestamp: '2026-06-09T12:00:00Z',
+  }))
+  return JSON.stringify({ results }, null, 2)
+}
+
+describe('compact() with TOON output', () => {
+  test('emits a tabular TOON header declaring fields once', () => {
+    const result = compact(bigArrayFixture(1000), { jsonFormat: 'toon' })
+    expect(result.contentType).toBe('json')
+    expect(result.transforms).toContain('json:toon')
+    expect(result.transforms).toContain('json:array-cap')
+    // length + field list declared once: results[N]{id,status,message,timestamp}:
+    expect(result.text).toMatch(/results\[\d+\]\{id,status,message,timestamp\}:/)
+  })
+
+  test('keeps array rows uniform (no inline sentinel) and notes omissions in trailing comments', () => {
+    const result = compact(bigArrayFixture(1000), { jsonFormat: 'toon' })
+    // The omission marker is a trailing `#` line, not an array element.
+    expect(result.text).toMatch(/#.*items omitted/)
+    const arrayPointer = result.pointers.find((p) => p.kind === 'json-array-items')
+    expect(arrayPointer?.omitted).toBe(996)
+  })
+
+  test('preserves field values verbatim in kept rows', () => {
+    const result = compact(bigArrayFixture(1000), { jsonFormat: 'toon' })
+    // Timestamp contains ':' so TOON quotes it; the value is still present verbatim.
+    expect(result.text).toContain('2026-06-09T12:00:00Z')
+    expect(result.text).toContain('Success')
+  })
+
+  test('TOON beats JSON on a uniform-object array', () => {
+    const input = bigArrayFixture(1000)
+    const asJson = compact(input, { jsonFormat: 'json' })
+    const asToon = compact(input, { jsonFormat: 'toon' })
+    expect(asToon.tokensAfter).toBeLessThan(asJson.tokensAfter)
+  })
+
+  test("'auto' (the default) selects TOON for a large uniform array", () => {
+    const result = compact(bigArrayFixture(1000))
+    expect(result.transforms).toContain('json:toon')
+  })
+
+  test("'auto' never produces more tokens than JSON", () => {
+    const input = bigArrayFixture(1000)
+    const auto = compact(input)
+    const asJson = compact(input, { jsonFormat: 'json' })
+    expect(auto.tokensAfter).toBeLessThanOrEqual(asJson.tokensAfter)
+  })
+})
diff --git a/packages/context-compactor/package.json b/packages/context-compactor/package.json
new file mode 100644
index 0000000..b03eb9c
--- /dev/null
+++ b/packages/context-compactor/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "@davstack/context-compactor",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "description": "Deterministic, TS-native context compaction for LLM agents: structure-aware reduction of tool outputs (JSON/code/logs) with retrieval pointers. No ML, no proxy.",
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "tsup",
+    "test": "pnpm -w exec vitest run --project context-compactor"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@toon-format/toon": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/context-compactor/src/detect.ts b/packages/context-compactor/src/detect.ts
new file mode 100644
index 0000000..3764baa
--- /dev/null
+++ b/packages/context-compactor/src/detect.ts
@@ -0,0 +1,43 @@
+import type { ContentType } from './types.js'
+
+const CODE_KEYWORDS = [
+  'def ',
+  'class ',
+  'function ',
+  'import ',
+  'const ',
+  'let ',
+  'var ',
+  'func ',
+  'fn ',
+  'pub ',
+  'package ',
+  'export ',
+]
+
+const DIFF_PATTERN = /^(diff --git |@@ .* @@|\+\+\+ |--- )/m
+const LOG_PATTERN = /\b(ERROR|WARN|WARNING|INFO|DEBUG|FATAL|TRACE)\b/
+
+/**
+ * Heuristic content-type detection (no ML). Cheap and good enough because we
+ * usually compact known tool-output shapes. Order matters: diff before code
+ * (diffs contain code keywords); json is confirmed by an actual parse.
+ */
+export function detectContentType(content: string): ContentType {
+  const stripped = content.trim()
+  if (!stripped) return 'unknown'
+
+  if (stripped.startsWith('{') || stripped.startsWith('[')) {
+    try {
+      JSON.parse(stripped)
+      return 'json'
+    } catch {
+      // not valid JSON; fall through
+    }
+  }
+
+  if (DIFF_PATTERN.test(stripped)) return 'diff'
+  if (CODE_KEYWORDS.some((kw) => content.includes(kw))) return 'code'
+  if (LOG_PATTERN.test(content)) return 'log'
+  return 'text'
+}
diff --git a/packages/context-compactor/src/entropy.ts b/packages/context-compactor/src/entropy.ts
new file mode 100644
index 0000000..88d92ac
--- /dev/null
+++ b/packages/context-compactor/src/entropy.ts
@@ -0,0 +1,32 @@
+/**
+ * Shannon-entropy signal for preservation decisions.
+ *
+ * High-entropy tokens (UUIDs, hashes, random ids) are information-dense, often
+ * identifiers, and easily mangled by naive compression — so handlers preserve
+ * them. Ported from headroom's masks.EntropyScore.
+ */
+
+/** Normalized character entropy in [0, 1] (Shannon entropy / log2(alphabet size)). */
+export function normalizedEntropy(text: string): number {
+  if (!text) return 0
+  const counts = new Map<string, number>()
+  for (const ch of text) counts.set(ch, (counts.get(ch) ?? 0) + 1)
+  const total = text.length
+  let entropy = 0
+  for (const count of counts.values()) {
+    const p = count / total
+    entropy -= p * Math.log2(p)
+  }
+  const distinct = counts.size
+  const max = distinct > 1 ? Math.log2(distinct) : 1
+  return max > 0 ? entropy / max : 0
+}
+
+/**
+ * True for tokens worth preserving verbatim: long enough to matter and above the
+ * entropy threshold. Short tokens rarely carry meaningful entropy.
+ */
+export function isHighEntropy(text: string, threshold = 0.85, minLength = 8): boolean {
+  if (text.length < minLength) return false
+  return normalizedEntropy(text) >= threshold
+}
diff --git a/packages/context-compactor/src/handlers/code.ts b/packages/context-compactor/src/handlers/code.ts
new file mode 100644
index 0000000..7fad958
--- /dev/null
+++ b/packages/context-compactor/src/handlers/code.ts
@@ -0,0 +1,92 @@
+import type { Pointer } from '../types.js'
+
+export interface CodeCompactOptions {
+  /** Indent columns at/below which a *block-opening* line is kept as a signature. */
+  signatureIndent: number
+  /** Minimum run of body lines before they are collapsed. */
+  minRun: number
+}
+
+export interface CodeCompactResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+const STRUCTURAL = [
+  'import',
+  'export',
+  'from ',
+  'def ',
+  'class ',
+  'function ',
+  'func ',
+  'fn ',
+  'interface ',
+  'type ',
+  'struct ',
+  'enum ',
+  'pub ',
+  'package ',
+]
+
+function leadingIndent(line: string): number {
+  const m = line.match(/^[ \t]*/)
+  return m ? m[0].replace(/\t/g, '  ').length : 0
+}
+
+function isStructural(line: string, signatureIndent: number): boolean {
+  const trimmed = line.trim()
+  if (!trimmed) return false
+  if (trimmed.startsWith('//') || trimmed.startsWith('#') || trimmed.startsWith('*')) return true
+  if (trimmed.startsWith('@')) return true // decorator
+  if (STRUCTURAL.some((kw) => trimmed.startsWith(kw))) return true
+  // Shallow block-opening lines (signatures, closing braces) are scaffolding.
+  if (leadingIndent(line) <= signatureIndent) {
+    if (/[{([:]\s*$/.test(trimmed) || /=>\s*\{?\s*$/.test(trimmed)) return true
+    if (/^[)\]}]/.test(trimmed)) return true
+  }
+  return false
+}
+
+/**
+ * Line-based code compaction. Keeps structural lines (imports/exports, defs,
+ * classes, signatures, decorators, comments and low-indent scaffolding) and
+ * collapses consecutive deeply-indented body lines into a `// … N lines` marker.
+ * Heuristic only: it does not parse the language, so unusual formatting (no
+ * indentation, minified code) will simply collapse less.
+ */
+export function compactCode(content: string, opts: CodeCompactOptions): CodeCompactResult {
+  const lines = content.split('\n')
+  const transforms = new Set<string>()
+  const pointers: Pointer[] = []
+  const out: string[] = []
+
+  let run: string[] = []
+
+  const flush = () => {
+    if (run.length === 0) return
+    if (run.length >= opts.minRun) {
+      const indent = run[0].match(/^[ \t]*/)?.[0] ?? ''
+      const note = `${indent}// … ${run.length} lines`
+      transforms.add('code:body-elide')
+      pointers.push({ kind: 'code-body', omitted: run.length, note })
+      out.push(note)
+    } else {
+      out.push(...run)
+    }
+    run = []
+  }
+
+  for (const line of lines) {
+    if (isStructural(line, opts.signatureIndent)) {
+      flush()
+      out.push(line)
+    } else {
+      run.push(line)
+    }
+  }
+  flush()
+
+  return { text: out.join('\n'), transforms: [...transforms], pointers }
+}
diff --git a/packages/context-compactor/src/handlers/diff.ts b/packages/context-compactor/src/handlers/diff.ts
new file mode 100644
index 0000000..89137d6
--- /dev/null
+++ b/packages/context-compactor/src/handlers/diff.ts
@@ -0,0 +1,64 @@
+import type { Pointer } from '../types.js'
+
+export interface DiffCompactOptions {
+  /** Runs of unchanged context longer than this are collapsed. */
+  maxContext: number
+}
+
+export interface DiffCompactResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+const HEADER = /^(diff --git |index |--- |\+\+\+ |@@ )/
+
+function isHeader(line: string): boolean {
+  return HEADER.test(line)
+}
+
+function isChange(line: string): boolean {
+  // '+'/'-' but not the '+++'/'---' file headers (caught by isHeader first).
+  return (line.startsWith('+') || line.startsWith('-')) && !isHeader(line)
+}
+
+/**
+ * Line-based unified-diff compaction. Keeps every diff/hunk header and every
+ * changed line (`+`/`-`), and collapses runs of unchanged context (leading
+ * space, or blank) longer than `maxContext` into a `… N unchanged lines` marker.
+ * Heuristic only: it assumes standard unified-diff line prefixes.
+ */
+export function compactDiff(content: string, opts: DiffCompactOptions): DiffCompactResult {
+  const lines = content.split('\n')
+  const transforms = new Set<string>()
+  const pointers: Pointer[] = []
+  const out: string[] = []
+
+  let run: string[] = []
+
+  const flush = () => {
+    if (run.length === 0) return
+    if (run.length > opts.maxContext) {
+      const note = `… ${run.length} unchanged lines`
+      transforms.add('diff:context-collapse')
+      pointers.push({ kind: 'diff-context', omitted: run.length, note })
+      out.push(note)
+    } else {
+      out.push(...run)
+    }
+    run = []
+  }
+
+  for (const line of lines) {
+    if (isHeader(line) || isChange(line)) {
+      flush()
+      out.push(line)
+    } else {
+      // context (leading space) or blank line
+      run.push(line)
+    }
+  }
+  flush()
+
+  return { text: out.join('\n'), transforms: [...transforms], pointers }
+}
diff --git a/packages/context-compactor/src/handlers/json.ts b/packages/context-compactor/src/handlers/json.ts
new file mode 100644
index 0000000..c9041b4
--- /dev/null
+++ b/packages/context-compactor/src/handlers/json.ts
@@ -0,0 +1,83 @@
+import type { Pointer } from '../types.js'
+
+export interface JsonCompactOptions {
+  /** Leading array items kept verbatim. */
+  headItems: number
+  /** Trailing array items kept verbatim. */
+  tailItems: number
+  /** String values longer than this are truncated. */
+  maxStringLength: number
+  /** Chars retained from the head of a truncated string. */
+  stringHead: number
+}
+
+export interface JsonCompactResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+/**
+ * Structure-aware JSON compaction. Unlike a blind truncation it preserves the
+ * full schema (every key, all booleans/nulls/numbers, short values) so the LLM
+ * still sees the shape, while collapsing the two things that dominate token
+ * count in real tool output:
+ *
+ *  - long arrays  -> keep first N + last M items, drop the middle
+ *  - long strings -> keep a head, drop the tail
+ *
+ * Every elision leaves an inline marker and a Pointer for retrieval. Re-emitting
+ * with compact JSON.stringify also drops all pretty-print whitespace for free.
+ *
+ * Adapted from headroom's json_handler + array-cap heuristic, but operating on
+ * the parsed structure (cleaner and exact) rather than a character mask.
+ */
+export function compactJson(content: string, opts: JsonCompactOptions): JsonCompactResult {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(content)
+  } catch {
+    return { text: content, transforms: [], pointers: [] }
+  }
+
+  const transforms = new Set<string>()
+  const pointers: Pointer[] = []
+  const keep = opts.headItems + opts.tailItems
+
+  const walk = (node: unknown): unknown => {
+    if (Array.isArray(node)) {
+      // Only cap when it actually saves more than one element.
+      if (node.length > keep + 1) {
+        const omitted = node.length - keep
+        const note = `…[+${omitted} of ${node.length} items omitted]`
+        transforms.add('json:array-cap')
+        pointers.push({ kind: 'json-array-items', omitted, note })
+        return [
+          ...node.slice(0, opts.headItems).map(walk),
+          note,
+          ...node.slice(node.length - opts.tailItems).map(walk),
+        ]
+      }
+      return node.map(walk)
+    }
+
+    if (node && typeof node === 'object') {
+      const out: Record<string, unknown> = {}
+      for (const [key, value] of Object.entries(node)) out[key] = walk(value)
+      return out
+    }
+
+    if (typeof node === 'string' && node.length > opts.maxStringLength) {
+      const omitted = node.length - opts.stringHead
+      const note = `…[+${omitted} chars]`
+      transforms.add('json:string-truncate')
+      pointers.push({ kind: 'json-string', omitted, note })
+      return node.slice(0, opts.stringHead) + note
+    }
+
+    return node
+  }
+
+  const reduced = walk(parsed)
+  return { text: JSON.stringify(reduced), transforms: [...transforms], pointers }
+}
diff --git a/packages/context-compactor/src/handlers/log.ts b/packages/context-compactor/src/handlers/log.ts
new file mode 100644
index 0000000..56ef287
--- /dev/null
+++ b/packages/context-compactor/src/handlers/log.ts
@@ -0,0 +1,69 @@
+import type { Pointer } from '../types.js'
+
+export interface LogCompactOptions {
+  /** Strip leading timestamps before comparing lines for near-identity. */
+  ignoreTimestamps: boolean
+}
+
+export interface LogCompactResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+const SEVERITY = /\b(ERROR|WARN|WARNING|FATAL|Exception|Traceback)\b/
+const STACK_FRAME = /(^\s*at\s)|(\bFile ")/
+const TIMESTAMP =
+  /^\s*(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?Z?|\[\d{2}:\d{2}:\d{2}(?:[.,]\d+)?\]|\d{2}:\d{2}:\d{2}(?:[.,]\d+)?)\s*/
+
+function alwaysKeep(line: string): boolean {
+  return SEVERITY.test(line) || STACK_FRAME.test(line)
+}
+
+function normalize(line: string, ignoreTimestamps: boolean): string {
+  return ignoreTimestamps ? line.replace(TIMESTAMP, '') : line
+}
+
+/**
+ * Line-based log compaction. Collapses runs of identical (or, with timestamps
+ * stripped, near-identical) lines into `<line>  (×N)`, but ALWAYS keeps lines
+ * carrying a severity keyword or a stack frame. Heuristic only: "near-identical"
+ * means equal after an optional leading-timestamp strip, not fuzzy matching.
+ */
+export function compactLog(content: string, opts: LogCompactOptions): LogCompactResult {
+  const lines = content.split('\n')
+  const transforms = new Set<string>()
+  const pointers: Pointer[] = []
+  const out: string[] = []
+
+  let i = 0
+  while (i < lines.length) {
+    const line = lines[i]
+    if (alwaysKeep(line)) {
+      out.push(line)
+      i++
+      continue
+    }
+
+    const key = normalize(line, opts.ignoreTimestamps)
+    let count = 1
+    while (
+      i + count < lines.length &&
+      !alwaysKeep(lines[i + count]) &&
+      normalize(lines[i + count], opts.ignoreTimestamps) === key
+    ) {
+      count++
+    }
+
+    if (count > 1) {
+      transforms.add('log:dedup')
+      pointers.push({ kind: 'log-dedup', omitted: count - 1, note: `(×${count})` })
+      out.push(`${line}  (×${count})`)
+    } else {
+      out.push(line)
+    }
+    i += count
+  }
+
+  return { text: out.join('\n'), transforms: [...transforms], pointers }
+}
diff --git a/packages/context-compactor/src/handlers/text.ts b/packages/context-compactor/src/handlers/text.ts
new file mode 100644
index 0000000..efea3ef
--- /dev/null
+++ b/packages/context-compactor/src/handlers/text.ts
@@ -0,0 +1,59 @@
+import type { Pointer } from '../types.js'
+
+export interface TextCompactOptions {
+  /** Lines kept from the head. */
+  headLines: number
+  /** Lines kept from the tail. */
+  tailLines: number
+  /** Drop exact-duplicate lines before head/tail trimming. */
+  dedup: boolean
+}
+
+export interface TextCompactResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+/**
+ * Line-based prose compaction. Optionally drops exact-duplicate lines, then
+ * keeps the first K and last K lines, replacing the middle with an
+ * `…[+N lines omitted]` marker. Heuristic only: it has no sentence awareness,
+ * so it can cut mid-paragraph — fine for boilerplate-heavy tool output.
+ */
+export function compactText(content: string, opts: TextCompactOptions): TextCompactResult {
+  const transforms = new Set<string>()
+  const pointers: Pointer[] = []
+  let lines = content.split('\n')
+
+  if (opts.dedup) {
+    const seen = new Set<string>()
+    const deduped: string[] = []
+    for (const line of lines) {
+      const trimmed = line.trim()
+      if (trimmed && seen.has(line)) {
+        transforms.add('text:dedup')
+        continue
+      }
+      if (trimmed) seen.add(line)
+      deduped.push(line)
+    }
+    lines = deduped
+  }
+
+  const keep = opts.headLines + opts.tailLines
+  if (lines.length > keep + 1) {
+    const omitted = lines.length - keep
+    const note = `…[+${omitted} lines omitted]`
+    transforms.add('text:head-tail')
+    pointers.push({ kind: 'text-middle', omitted, note })
+    const out = [
+      ...lines.slice(0, opts.headLines),
+      note,
+      ...lines.slice(lines.length - opts.tailLines),
+    ]
+    return { text: out.join('\n'), transforms: [...transforms], pointers }
+  }
+
+  return { text: lines.join('\n'), transforms: [...transforms], pointers }
+}
diff --git a/packages/context-compactor/src/handlers/toon.ts b/packages/context-compactor/src/handlers/toon.ts
new file mode 100644
index 0000000..1dbcced
--- /dev/null
+++ b/packages/context-compactor/src/handlers/toon.ts
@@ -0,0 +1,93 @@
+import { encode } from '@toon-format/toon'
+import type { Pointer } from '../types.js'
+
+export interface ToonCompactOptions {
+  /** Leading array items kept verbatim. */
+  headItems: number
+  /** Trailing array items kept verbatim. */
+  tailItems: number
+  /** String values longer than this are truncated. */
+  maxStringLength: number
+  /** Chars retained from the head of a truncated string. */
+  stringHead: number
+}
+
+export interface ToonCompactResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+/**
+ * JSON compaction that serializes to TOON (Token-Oriented Object Notation)
+ * instead of JSON. TOON declares an array's length + field names once and
+ * streams comma-separated rows, so arrays of uniform objects cost far fewer
+ * tokens than JSON (which repeats every key per element).
+ *
+ * Unlike the JSON handler, the array cap keeps the kept items *uniform* (no
+ * inline sentinel) so the TOON table stays clean; omission/truncation notes are
+ * appended as trailing `#` comment lines (read by the LLM, ignored as data).
+ */
+export function compactJsonToon(content: string, opts: ToonCompactOptions): ToonCompactResult {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(content)
+  } catch {
+    return { text: content, transforms: [], pointers: [] }
+  }
+
+  const transforms = new Set<string>(['json:toon'])
+  const pointers: Pointer[] = []
+  const keep = opts.headItems + opts.tailItems
+
+  const walk = (node: unknown): unknown => {
+    if (Array.isArray(node)) {
+      if (node.length > keep + 1) {
+        const omitted = node.length - keep
+        transforms.add('json:array-cap')
+        pointers.push({
+          kind: 'json-array-items',
+          omitted,
+          note: `+${omitted} of ${node.length} array items omitted`,
+        })
+        return [
+          ...node.slice(0, opts.headItems).map(walk),
+          ...node.slice(node.length - opts.tailItems).map(walk),
+        ]
+      }
+      return node.map(walk)
+    }
+
+    if (node && typeof node === 'object') {
+      const out: Record<string, unknown> = {}
+      for (const [key, value] of Object.entries(node)) out[key] = walk(value)
+      return out
+    }
+
+    if (typeof node === 'string' && node.length > opts.maxStringLength) {
+      const omitted = node.length - opts.stringHead
+      transforms.add('json:string-truncate')
+      pointers.push({ kind: 'json-string', omitted, note: `string truncated (+${omitted} chars)` })
+      return node.slice(0, opts.stringHead) + `…[+${omitted} chars]`
+    }
+
+    return node
+  }
+
+  const reduced = walk(parsed)
+  let text: string
+  try {
+    text = encode(reduced)
+  } catch {
+    // encode is total over the JSON data model, but stay defensive: fall back
+    // to compact JSON if it ever throws.
+    transforms.delete('json:toon')
+    return { text: JSON.stringify(reduced), transforms: [...transforms], pointers }
+  }
+
+  if (pointers.length) {
+    text += '\n' + pointers.map((pointer) => `# ${pointer.note}`).join('\n')
+  }
+
+  return { text, transforms: [...transforms], pointers }
+}
diff --git a/packages/context-compactor/src/index.ts b/packages/context-compactor/src/index.ts
new file mode 100644
index 0000000..5e97004
--- /dev/null
+++ b/packages/context-compactor/src/index.ts
@@ -0,0 +1,129 @@
+import { detectContentType } from './detect.js'
+import { compactCode } from './handlers/code.js'
+import { compactDiff } from './handlers/diff.js'
+import { compactJson } from './handlers/json.js'
+import { compactLog } from './handlers/log.js'
+import { compactText } from './handlers/text.js'
+import { compactJsonToon } from './handlers/toon.js'
+import type { CompactOptions, CompactResult, ContentType, Pointer } from './types.js'
+
+const DEFAULTS = {
+  minLength: 200,
+  jsonHeadItems: 3,
+  jsonTailItems: 1,
+  jsonMaxStringLength: 200,
+  jsonStringHead: 120,
+  jsonFormat: 'auto' as const,
+  codeSignatureIndent: 4,
+  codeMinRun: 3,
+  logIgnoreTimestamps: true,
+  diffMaxContext: 3,
+  textHeadLines: 5,
+  textTailLines: 5,
+  textDedup: false,
+}
+
+interface HandlerResult {
+  text: string
+  transforms: string[]
+  pointers: Pointer[]
+}
+
+/** Cheap chars/4 token estimate (same heuristic headroom uses). */
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4)
+}
+
+/** Per-type reducers. Each mirrors `compactJson`'s `(content, opts) => result`. */
+const HANDLERS: Partial<Record<ContentType, (content: string, o: CompactOptions) => HandlerResult>> =
+  {
+    json: (content, o) => {
+      const jsonOpts = {
+        headItems: o.jsonHeadItems ?? DEFAULTS.jsonHeadItems,
+        tailItems: o.jsonTailItems ?? DEFAULTS.jsonTailItems,
+        maxStringLength: o.jsonMaxStringLength ?? DEFAULTS.jsonMaxStringLength,
+        stringHead: DEFAULTS.jsonStringHead,
+      }
+      const format = o.jsonFormat ?? DEFAULTS.jsonFormat
+      if (format === 'json') return compactJson(content, jsonOpts)
+      if (format === 'toon') return compactJsonToon(content, jsonOpts)
+      // 'auto': emit whichever serialization is smaller (never worse than JSON).
+      const asJson = compactJson(content, jsonOpts)
+      const asToon = compactJsonToon(content, jsonOpts)
+      const count = o.countTokens ?? estimateTokens
+      return count(asToon.text) <= count(asJson.text) ? asToon : asJson
+    },
+    code: (content, o) =>
+      compactCode(content, {
+        signatureIndent: o.codeSignatureIndent ?? DEFAULTS.codeSignatureIndent,
+        minRun: o.codeMinRun ?? DEFAULTS.codeMinRun,
+      }),
+    log: (content, o) =>
+      compactLog(content, {
+        ignoreTimestamps: o.logIgnoreTimestamps ?? DEFAULTS.logIgnoreTimestamps,
+      }),
+    diff: (content, o) =>
+      compactDiff(content, {
+        maxContext: o.diffMaxContext ?? DEFAULTS.diffMaxContext,
+      }),
+    text: (content, o) =>
+      compactText(content, {
+        headLines: o.textHeadLines ?? DEFAULTS.textHeadLines,
+        tailLines: o.textTailLines ?? DEFAULTS.textTailLines,
+        dedup: o.textDedup ?? DEFAULTS.textDedup,
+      }),
+  }
+
+/**
+ * Compact a single blob of content. Detects the content type and routes to a
+ * structure-aware handler. Deterministic, synchronous, no ML, no network.
+ *
+ * Each content type (json/code/log/diff/text) has its own handler; 'unknown'
+ * and anything below `minLength` pass through unchanged.
+ */
+export function compact(content: string, options: CompactOptions = {}): CompactResult {
+  const count = options.countTokens ?? estimateTokens
+  const contentType: ContentType = options.contentType ?? detectContentType(content)
+  const tokensBefore = count(content)
+  const minLength = options.minLength ?? DEFAULTS.minLength
+
+  let text = content
+  let transforms: string[] = []
+  let pointers: Pointer[] = []
+
+  const handler = HANDLERS[contentType]
+  if (content.length >= minLength && handler) {
+    const result = handler(content, options)
+    text = result.text
+    transforms = result.transforms
+    pointers = result.pointers
+  }
+
+  const tokensAfter = count(text)
+  return {
+    text,
+    contentType,
+    tokensBefore,
+    tokensAfter,
+    tokensSaved: Math.max(0, tokensBefore - tokensAfter),
+    ratio: tokensBefore > 0 ? tokensAfter / tokensBefore : 1,
+    transforms,
+    pointers,
+  }
+}
+
+export { detectContentType } from './detect.js'
+export { normalizedEntropy, isHighEntropy } from './entropy.js'
+export { compactJson } from './handlers/json.js'
+export { compactCode } from './handlers/code.js'
+export { compactLog } from './handlers/log.js'
+export { compactDiff } from './handlers/diff.js'
+export { compactText } from './handlers/text.js'
+export { compactJsonToon } from './handlers/toon.js'
+export type { JsonCompactOptions, JsonCompactResult } from './handlers/json.js'
+export type { ToonCompactOptions, ToonCompactResult } from './handlers/toon.js'
+export type { CodeCompactOptions, CodeCompactResult } from './handlers/code.js'
+export type { LogCompactOptions, LogCompactResult } from './handlers/log.js'
+export type { DiffCompactOptions, DiffCompactResult } from './handlers/diff.js'
+export type { TextCompactOptions, TextCompactResult } from './handlers/text.js'
+export type { CompactOptions, CompactResult, ContentType, Pointer } from './types.js'
diff --git a/packages/context-compactor/src/types.ts b/packages/context-compactor/src/types.ts
new file mode 100644
index 0000000..d04168a
--- /dev/null
+++ b/packages/context-compactor/src/types.ts
@@ -0,0 +1,63 @@
+/** High-level content categories used to route to a compaction handler. */
+export type ContentType = 'json' | 'code' | 'log' | 'diff' | 'text' | 'unknown'
+
+/** A breadcrumb left where content was elided, so a caller can retrieve the original. */
+export interface Pointer {
+  /** What kind of elision this marks (e.g. 'json-array-items', 'json-string'). */
+  kind: string
+  /** How much was dropped (items / lines / chars, depending on kind). */
+  omitted: number
+  /** Inline marker text that was inserted into the output. */
+  note: string
+}
+
+export interface CompactOptions {
+  /** Force a content type, skipping detection. */
+  contentType?: ContentType
+  /** Token counter. Defaults to a chars/4 estimator. */
+  countTokens?: (s: string) => number
+  /** Skip compaction below this length (chars). Default 200. */
+  minLength?: number
+  /** JSON: number of leading array items to keep verbatim. Default 3. */
+  jsonHeadItems?: number
+  /** JSON: number of trailing array items to keep verbatim. Default 1. */
+  jsonTailItems?: number
+  /** JSON: string values longer than this are truncated. Default 200. */
+  jsonMaxStringLength?: number
+  /**
+   * JSON output serialization. 'json' = compact JSON; 'toon' = Token-Oriented
+   * Object Notation (keys declared once per array, comma rows — far cheaper for
+   * arrays of uniform objects); 'auto' = emit whichever is smaller. Default 'auto'.
+   */
+  jsonFormat?: 'json' | 'toon' | 'auto'
+  /** code: indent columns at/below which a line is structural. Default 4. */
+  codeSignatureIndent?: number
+  /** code: minimum run of body lines before collapsing. Default 3. */
+  codeMinRun?: number
+  /** log: strip leading timestamps before comparing lines. Default true. */
+  logIgnoreTimestamps?: boolean
+  /** diff: collapse runs of unchanged context longer than this. Default 3. */
+  diffMaxContext?: number
+  /** text: lines kept from the head. Default 5. */
+  textHeadLines?: number
+  /** text: lines kept from the tail. Default 5. */
+  textTailLines?: number
+  /** text: drop exact-duplicate lines. Default false. */
+  textDedup?: boolean
+}
+
+export interface CompactResult {
+  /** The compacted content. */
+  text: string
+  /** Detected (or forced) content type. */
+  contentType: ContentType
+  tokensBefore: number
+  tokensAfter: number
+  tokensSaved: number
+  /** tokensAfter / tokensBefore (1 = no change). */
+  ratio: number
+  /** Names of transforms that fired, e.g. ['json:array-cap']. */
+  transforms: string[]
+  /** Breadcrumbs for elided content. */
+  pointers: Pointer[]
+}
diff --git a/packages/context-compactor/tsconfig.json b/packages/context-compactor/tsconfig.json
new file mode 100644
index 0000000..9865451
--- /dev/null
+++ b/packages/context-compactor/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "__tests__/**/*"]
+}
diff --git a/packages/context-compactor/tsup.config.ts b/packages/context-compactor/tsup.config.ts
new file mode 100644
index 0000000..8d00a38
--- /dev/null
+++ b/packages/context-compactor/tsup.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+  },
+  format: ["esm"],
+  target: "node20",
+  outDir: "dist",
+  dts: true,
+  clean: true,
+  splitting: false,
+  sourcemap: true,
+})
diff --git a/packages/open-agents/__tests__/compact.test.ts b/packages/open-agents/__tests__/compact.test.ts
index d435196..47e78b6 100644
--- a/packages/open-agents/__tests__/compact.test.ts
+++ b/packages/open-agents/__tests__/compact.test.ts
@@ -5,6 +5,9 @@ import { join } from 'node:path';
 import {
   findClaudeTranscriptBySession,
   findCodexTranscriptBySession,
+  loadCompactHistory,
+  parseCompactMessages,
+  renderCompactMessages,
   resolveCompactHistoryFile,
   tokenTail,
 } from '../src/core/compact.js';
@@ -28,6 +31,43 @@ describe('compact mode helpers', () => {
     expect(positional).toEqual(['short task']);
   });
 
+  test('loads real JSONL messages for Headroom compression', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'compact-messages-'));
+    try {
+      const history = join(dir, 'history.jsonl');
+      writeFileSync(
+        history,
+        [
+          JSON.stringify({ message: { role: 'user', content: 'keep user intent' } }),
+          JSON.stringify({ message: { role: 'assistant', content: 'assistant response' } }),
+        ].join('\n') + '\n',
+      );
+
+      const loaded = loadCompactHistory(history, 100);
+
+      expect(loaded.messages).toEqual([
+        { role: 'user', content: 'keep user intent' },
+        { role: 'assistant', content: 'assistant response' },
+      ]);
+      expect(loaded.tail).toContain('user: keep user intent');
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('renders parsed compact messages without changing roles', () => {
+    const messages = parseCompactMessages(
+      [
+        JSON.stringify({ role: 'user', content: 'do not compress this as tool output' }),
+        JSON.stringify({ role: 'assistant', content: [{ type: 'text', text: 'ok' }] }),
+      ].join('\n'),
+    );
+
+    expect(renderCompactMessages(messages)).toBe(
+      'user: do not compress this as tool output\n\nassistant: ok',
+    );
+  });
+
   test('resolves explicit and env history paths before Claude session lookup', () => {
     expect(
       resolveCompactHistoryFile({
diff --git a/packages/open-agents/__tests__/headroom.test.ts b/packages/open-agents/__tests__/headroom.test.ts
index 37c6a91..273836b 100644
--- a/packages/open-agents/__tests__/headroom.test.ts
+++ b/packages/open-agents/__tests__/headroom.test.ts
@@ -1,10 +1,15 @@
-import { describe, expect, test } from 'vitest';
+import { afterEach, describe, expect, test, vi } from 'vitest';
 import {
+  compressHeadroomMessages,
   formatHeadroomDelta,
   resolveHeadroomConfig,
 } from '../src/core/headroom.js';
 
 describe('headroom helpers', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   test('defaults to auto localhost proxy', () => {
     expect(resolveHeadroomConfig({ env: {} })).toEqual({
       mode: 'auto',
@@ -36,4 +41,49 @@ describe('headroom helpers', () => {
       ),
     ).toBe('2 requests, 1,500 tokens saved');
   });
+
+  test('compresses the real message array without changing roles locally', async () => {
+    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        messages: [
+          { role: 'user', content: 'keep intent' },
+          { role: 'assistant', content: 'shorter output' },
+        ],
+        tokens_before: 100,
+        tokens_after: 40,
+        tokens_saved: 60,
+        compression_ratio: 0.4,
+        transforms_applied: ['smart_crusher'],
+      }),
+    } as Response);
+
+    const result = await compressHeadroomMessages({
+      url: 'http://127.0.0.1:8787',
+      model: 'composer-2.5',
+      tokenBudget: 100000,
+      messages: [
+        { role: 'user', content: 'keep intent' },
+        { role: 'assistant', content: 'long output' },
+      ],
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'http://127.0.0.1:8787/v1/compress',
+      expect.objectContaining({
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model: 'composer-2.5',
+          tokenBudget: 100000,
+          messages: [
+            { role: 'user', content: 'keep intent' },
+            { role: 'assistant', content: 'long output' },
+          ],
+        }),
+      }),
+    );
+    expect(result.messages[0]).toEqual({ role: 'user', content: 'keep intent' });
+    expect(result.tokensSaved).toBe(60);
+  });
 });
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 6a41277..5d6a78f 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -23,6 +23,7 @@ import type { AgentAdapter, Tier } from './adapters/types.js';
 import {
   buildCompactSpecWriterTask,
   loadCompactHistory,
+  renderCompactMessages,
   resolveCompactHistoryFile,
 } from './core/compact.js';
 import { readDeliverable, renderJobResult } from './core/deliverable.js';
@@ -36,6 +37,7 @@ import {
 import { jobsDir } from './core/paths.js';
 import { DEFAULT_TIMEOUT_SEC, runJob } from './core/run.js';
 import {
+  compressHeadroomMessages,
   detectHeadroom,
   formatHeadroomDelta,
   readHeadroomStats,
@@ -190,17 +192,38 @@ async function generateCompactSpec(input: {
   logHeadroomStats?: boolean;
 }): Promise<string> {
   const history = loadCompactHistory(input.historyFile, input.tailTokens);
+  const adapter = cursorAdapter;
+  const model = cursorAdapter.defaultModel();
+  let historyTail = history.tail;
+  if (input.headroomUrl && history.messages.length) {
+    try {
+      const compressed = await compressHeadroomMessages({
+        url: input.headroomUrl,
+        messages: history.messages,
+        model: model,
+        tokenBudget: input.tailTokens,
+      });
+      historyTail = renderCompactMessages(compressed.messages);
+      if (compressed.tokensSaved > 0) {
+        process.stderr.write(
+          `open-agents: headroom compressed history ${Math.round(compressed.tokensBefore).toLocaleString()} -> ${Math.round(compressed.tokensAfter).toLocaleString()} tokens (${Math.round(compressed.tokensSaved).toLocaleString()} saved)\n`,
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `open-agents: headroom history compression failed; using raw history tail (${(err as Error).message})\n`,
+      );
+    }
+  }
   const specWriterTask = buildCompactSpecWriterTask({
     task: input.task,
     repoPath: input.repoPath,
     targetProfile: input.targetProfile.name,
     historyPath: history.path,
-    historyTail: history.tail,
+    historyTail,
     tailTokens: input.tailTokens,
   });
   const id = genId();
-  const adapter = cursorAdapter;
-  const model = cursorAdapter.defaultModel();
   const specWriterTaskPath = join(jobsDir(input.repoPath), `${id}.spec.md`);
   createJob({
     id,
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
index b58f932..0141d4e 100644
--- a/packages/open-agents/src/core/compact.ts
+++ b/packages/open-agents/src/core/compact.ts
@@ -1,12 +1,14 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
+import type { HeadroomMessage } from './headroom.js';
 
 export interface CompactHistory {
   path: string;
   text: string;
   tail: string;
   tailTokens: number;
+  messages: HeadroomMessage[];
 }
 
 export function tokenTail(text: string, maxTokens: number): string {
@@ -21,6 +23,91 @@ export function tokenTail(text: string, maxTokens: number): string {
   return parts.slice(start).join('').trim();
 }
 
+function tokenLikeCount(text: string): number {
+  return (text.match(/[A-Za-z0-9_]+|[^\sA-Za-z0-9_]/g) || []).length;
+}
+
+function textFromContent(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (content == null) return '';
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (!part || typeof part !== 'object') return '';
+        const item = part as Record<string, unknown>;
+        if (typeof item.text === 'string') return item.text;
+        if (typeof item.content === 'string') return item.content;
+        return JSON.stringify(item);
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return JSON.stringify(content);
+}
+
+function compactMessageText(message: HeadroomMessage): string {
+  const role = typeof message.role === 'string' ? message.role : 'message';
+  const content = textFromContent(message.content);
+  return `${role}: ${content || JSON.stringify(message)}`;
+}
+
+export function renderCompactMessages(messages: HeadroomMessage[]): string {
+  return messages.map(compactMessageText).join('\n\n').trim();
+}
+
+function isMessage(value: unknown): value is HeadroomMessage {
+  if (!value || typeof value !== 'object') return false;
+  const item = value as Record<string, unknown>;
+  return typeof item.role === 'string' && 'content' in item;
+}
+
+function extractMessage(row: unknown): HeadroomMessage | null {
+  if (isMessage(row)) return row;
+  if (!row || typeof row !== 'object') return null;
+  const item = row as Record<string, unknown>;
+  if (isMessage(item.message)) return item.message;
+  if (
+    typeof item.type === 'string' &&
+    ['system', 'user', 'assistant', 'tool'].includes(item.type) &&
+    'content' in item
+  ) {
+    return { ...item, role: item.type };
+  }
+  return null;
+}
+
+export function parseCompactMessages(text: string): HeadroomMessage[] {
+  const messages: HeadroomMessage[] = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const message = extractMessage(JSON.parse(line));
+      if (message) messages.push(message);
+    } catch {
+      return [];
+    }
+  }
+  return messages;
+}
+
+export function tailCompactMessages(
+  messages: HeadroomMessage[],
+  maxTokens: number,
+): HeadroomMessage[] {
+  if (!Number.isFinite(maxTokens) || maxTokens <= 0) return [];
+  const out: HeadroomMessage[] = [];
+  let tokens = 0;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const messageTokens = tokenLikeCount(compactMessageText(messages[i]));
+    if (out.length && tokens + messageTokens > maxTokens) break;
+    out.unshift(messages[i]);
+    tokens += messageTokens;
+    if (tokens >= maxTokens) break;
+  }
+  return out;
+}
+
 export function findClaudeTranscriptBySession(
   sessionId: string,
   homeDir = homedir(),
@@ -148,11 +235,13 @@ export function loadCompactHistory(path: string, tailTokens: number): CompactHis
     throw new Error(`compact history file not found: ${resolved}`);
   }
   const text = readFileSync(resolved, 'utf8');
+  const messages = tailCompactMessages(parseCompactMessages(text), tailTokens);
   return {
     path: resolved,
     text,
-    tail: tokenTail(text, tailTokens),
+    tail: messages.length ? renderCompactMessages(messages) : tokenTail(text, tailTokens),
     tailTokens,
+    messages,
   };
 }
 
diff --git a/packages/open-agents/src/core/headroom.ts b/packages/open-agents/src/core/headroom.ts
index 7533d4e..53f99b9 100644
--- a/packages/open-agents/src/core/headroom.ts
+++ b/packages/open-agents/src/core/headroom.ts
@@ -23,6 +23,21 @@ export interface HeadroomStats {
   raw: unknown;
 }
 
+export type HeadroomMessage = Record<string, unknown> & {
+  role?: string;
+  content?: unknown;
+};
+
+export interface HeadroomCompressionResult {
+  messages: HeadroomMessage[];
+  tokensBefore: number;
+  tokensAfter: number;
+  tokensSaved: number;
+  compressionRatio: number;
+  transformsApplied: string[];
+  raw: unknown;
+}
+
 interface HeadroomStatsResponse {
   requests?: {
     total?: number;
@@ -34,6 +49,20 @@ interface HeadroomStatsResponse {
   };
 }
 
+interface HeadroomCompressionResponse {
+  messages?: HeadroomMessage[];
+  tokens_before?: number;
+  tokens_after?: number;
+  tokens_saved?: number;
+  compression_ratio?: number;
+  transforms_applied?: string[];
+  tokensBefore?: number;
+  tokensAfter?: number;
+  tokensSaved?: number;
+  compressionRatio?: number;
+  transformsApplied?: string[];
+}
+
 const DEFAULT_URL = 'http://127.0.0.1:8787';
 const DEFAULT_TIMEOUT_MS = 750;
 
@@ -82,6 +111,23 @@ async function fetchJson(url: string, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<u
   }
 }
 
+async function postJson(url: string, body: unknown, timeoutMs = 15_000): Promise<unknown> {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: ac.signal,
+    });
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`.trim());
+    return await res.json();
+  } finally {
+    clearTimeout(t);
+  }
+}
+
 export async function detectHeadroom(input: {
   adapterName: string;
   config: Required<Pick<HeadroomConfig, 'mode' | 'url' | 'logStats'>>;
@@ -148,6 +194,31 @@ export async function readHeadroomStats(url: string): Promise<HeadroomStats | nu
   }
 }
 
+export async function compressHeadroomMessages(input: {
+  url: string;
+  messages: HeadroomMessage[];
+  model?: string;
+  tokenBudget?: number;
+}): Promise<HeadroomCompressionResult> {
+  const raw = await postJson(`${cleanUrl(input.url)}/v1/compress`, {
+    model: input.model || 'gpt-4o',
+    tokenBudget: input.tokenBudget,
+    messages: input.messages,
+  });
+  const result = raw as HeadroomCompressionResponse;
+  return {
+    messages: Array.isArray(result.messages) ? result.messages : input.messages,
+    tokensBefore: numberOrZero(result.tokens_before ?? result.tokensBefore),
+    tokensAfter: numberOrZero(result.tokens_after ?? result.tokensAfter),
+    tokensSaved: numberOrZero(result.tokens_saved ?? result.tokensSaved),
+    compressionRatio: numberOrZero(result.compression_ratio ?? result.compressionRatio),
+    transformsApplied: Array.isArray(result.transforms_applied ?? result.transformsApplied)
+      ? ((result.transforms_applied ?? result.transformsApplied) as string[])
+      : [],
+    raw,
+  };
+}
+
 export function formatHeadroomDelta(before: HeadroomStats | null, after: HeadroomStats | null): string | null {
   if (!before || !after) return null;
   const bits: string[] = [];
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8e18d93..429260a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -52,6 +52,22 @@ importers:
         specifier: ^5.0.0
         version: 5.3.3
 
+  packages/context-compactor:
+    dependencies:
+      '@toon-format/toon':
+        specifier: ^2.3.0
+        version: 2.3.0
+    devDependencies:
+      '@types/node':
+        specifier: ^25.9.1
+        version: 25.9.1
+      tsup:
+        specifier: ^8.0.0
+        version: 8.5.1(tsx@4.22.3)(typescript@5.3.3)
+      typescript:
+        specifier: ^5.0.0
+        version: 5.3.3
+
   packages/init:
     dependencies:
       '@inquirer/prompts':
@@ -104,6 +120,9 @@ importers:
       '@davstack/cli-utils':
         specifier: workspace:*
         version: link:../cli-utils
+      '@davstack/context-compactor':
+        specifier: workspace:*
+        version: link:../context-compactor
     devDependencies:
       '@types/node':
         specifier: ^25.9.1
@@ -3854,6 +3873,10 @@ packages:
       '@testing-library/dom': 9.3.4
     dev: false
 
+  /@toon-format/toon@2.3.0:
+    resolution: {integrity: sha512-/Ew9etdRQKVMnm9fDaCG0JjyAOK/O7T0M97oum1aW4W+UR8ZhVVPBanIV7oWgHBiGlnVxV9M55PWQCHofDV07w==}
+    dev: false
+
   /@tybys/wasm-util@0.10.2:
     resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
     requiresBuild: true
@@ -9331,7 +9354,7 @@ packages:
     dependencies:
       browserslist: 4.22.1
       escalade: 3.1.1
-      picocolors: 1.0.0
+      picocolors: 1.1.1
     dev: true
 
   /update-browserslist-db@1.0.13(browserslist@4.23.0):
@@ -9342,7 +9365,7 @@ packages:
     dependencies:
       browserslist: 4.23.0
       escalade: 3.1.1
-      picocolors: 1.0.0
+      picocolors: 1.1.1
     dev: true
 
   /uri-js@4.4.1:
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index ba4a1c5..ac20897 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -49,6 +49,16 @@ export default defineWorkspace([
 			exclude: ['__tests__/bun-only/**', '**/node_modules/**'],
 		},
 	},
+	{
+		resolve: { alias: { vitest: vitestAlias } },
+		test: {
+			name: 'context-compactor',
+			root: './packages/context-compactor',
+			environment: 'node',
+			include: ['__tests__/**/*.test.ts'],
+			exclude: ['**/node_modules/**'],
+		},
+	},
 	{
 		resolve: {
 			alias: {

From b3cbfe5166e05adeb5ca491596b47c54244eb306 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 15:10:24 +0100
Subject: [PATCH 40/72] feat(open-agents): add Headroom proxy routing (compress
 + stats), default off
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds the OpenAI-compatible Headroom proxy client — detect/health, /v1/compress
history compression, and /stats deltas — and wires it into compact-mode spec
generation. Defaulted OFF in cmdSubmit (mode forced 'off': no /health probe, no
OPENAI_BASE_URL injection): the proxy measured ~0 token savings for our tool mix
and its ML compress path is too slow on CPU (hits the 30s timeout). The client
is kept behind a documented one-line revert.
---
 packages/open-agents/src/cli.ts | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index 5d6a78f..a5c3e23 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -302,11 +302,21 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
   const timeoutSec = Number.isFinite(flags.timeout)
     ? flags.timeout!
     : (config.defaultTimeoutSec ?? DEFAULT_TIMEOUT_SEC);
-  const headroomConfig = resolveHeadroomConfig({
-    config: config.headroom,
-    modeFlag: flags.headroom,
-    urlFlag: flags.headroomUrl,
-  });
+  // Headroom proxy DISABLED (2026-06-09). The local proxy at 127.0.0.1:8787
+  // added latency and saved ~0 tokens for our tool mix (Read/Glob/Grep/Write/
+  // Edit/Bash are all excluded; the one compressible path is ML token-pruning
+  // that is unusably slow on CPU and hits the 30s timeout). We are replacing it
+  // with a TS-native, deterministic context compactor. Forcing mode 'off' keeps
+  // the compact-mode flow working without any /health probe or OPENAI_BASE_URL.
+  // To re-enable the proxy temporarily, drop the `, mode: 'off'` override.
+  const headroomConfig = {
+    ...resolveHeadroomConfig({
+      config: config.headroom,
+      modeFlag: flags.headroom,
+      urlFlag: flags.headroomUrl,
+    }),
+    mode: 'off' as const,
+  };
   const headroom = await detectHeadroom({ adapterName: adapter.name, config: headroomConfig });
   if (headroom.active) {
     process.stderr.write(`open-agents: headroom active (${headroom.openAIBaseUrl})\n`);

From 020c94721cbc25bbc7a6fe5c3e279a00e4e06778 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 15:10:24 +0100
Subject: [PATCH 41/72] feat(open-agents): compact spec-writer history via
 @davstack/context-compactor

Run the spec-handoff history through @davstack/context-compactor before the
spec-writer reads it. New compactMessageContent/compactMessages strip
tool-output noise (large JSON -> TOON tables, etc.), and the pipeline now
compacts BEFORE budget selection so more clean context fits the window. The
raw-text tokenTail fallback is preserved for transcripts without structured
messages. Adds the workspace dependency on @davstack/context-compactor.
---
 .../__tests__/compact-messages.test.ts        | 92 +++++++++++++++++++
 packages/open-agents/package.json             |  3 +-
 packages/open-agents/src/core/compact.ts      | 50 +++++++++-
 3 files changed, 143 insertions(+), 2 deletions(-)
 create mode 100644 packages/open-agents/__tests__/compact-messages.test.ts

diff --git a/packages/open-agents/__tests__/compact-messages.test.ts b/packages/open-agents/__tests__/compact-messages.test.ts
new file mode 100644
index 0000000..2676332
--- /dev/null
+++ b/packages/open-agents/__tests__/compact-messages.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'vitest'
+import {
+  compactMessageContent,
+  compactMessages,
+  renderCompactMessages,
+} from '../src/core/compact.js'
+import type { HeadroomMessage } from '../src/core/headroom.js'
+
+function bigJsonToolResult(): string {
+  return JSON.stringify(
+    Array.from({ length: 80 }, (_, i) => ({
+      id: i,
+      name: `row-${i}`,
+      value: i * 7,
+      active: i % 2 === 0,
+      note: 'lorem ipsum dolor sit amet consectetur adipiscing elit',
+    })),
+  )
+}
+
+describe('compactMessageContent', () => {
+  test('reduces a large JSON string content, preserves role and schema keys', () => {
+    const original = bigJsonToolResult()
+    const message: HeadroomMessage = { role: 'tool', content: original }
+    const result = compactMessageContent(message)
+
+    expect(result.role).toBe('tool')
+    expect(typeof result.content).toBe('string')
+    expect((result.content as string).length).toBeLessThan(original.length)
+    // schema keys still present in the compacted output
+    expect(result.content as string).toContain('id')
+    expect(result.content as string).toContain('name')
+    expect(result.content as string).toContain('value')
+  })
+
+  test('passes a small / plain message through unchanged', () => {
+    const message: HeadroomMessage = { role: 'user', content: 'fix the enum bug please' }
+    const result = compactMessageContent(message)
+    expect(result.role).toBe('user')
+    expect(result.content).toBe('fix the enum bug please')
+  })
+
+  test('array content: text blocks compacted, non-text blocks preserved', () => {
+    const big = bigJsonToolResult()
+    const message: HeadroomMessage = {
+      role: 'assistant',
+      content: [
+        { type: 'text', text: big },
+        { type: 'tool_use', id: 'tu_1', name: 'do_thing', input: { a: 1 } },
+        { type: 'text', content: big },
+      ],
+    }
+    const result = compactMessageContent(message)
+    expect(result.role).toBe('assistant')
+    const blocks = result.content as Array<Record<string, unknown>>
+
+    // text block compacted
+    expect((blocks[0].text as string).length).toBeLessThan(big.length)
+    expect(blocks[0].type).toBe('text')
+    // non-text block untouched
+    expect(blocks[1]).toEqual({ type: 'tool_use', id: 'tu_1', name: 'do_thing', input: { a: 1 } })
+    // .content string block compacted too
+    expect((blocks[2].content as string).length).toBeLessThan(big.length)
+  })
+})
+
+describe('compactMessages', () => {
+  test('aggregates token estimates and reduces a big tool_result message', () => {
+    const messages: HeadroomMessage[] = [
+      { role: 'user', content: 'short ask' },
+      { role: 'tool', content: bigJsonToolResult() },
+    ]
+    const result = compactMessages(messages)
+    expect(result.messages).toHaveLength(2)
+    expect(result.tokensAfter).toBeLessThan(result.tokensBefore)
+    expect(result.tokensSaved).toBe(result.tokensBefore - result.tokensAfter)
+    expect(result.messages[0].role).toBe('user')
+    expect(result.messages[1].role).toBe('tool')
+  })
+
+  test('renderCompactMessages still works on compacted messages', () => {
+    const messages: HeadroomMessage[] = [
+      { role: 'user', content: 'do the thing' },
+      { role: 'tool', content: bigJsonToolResult() },
+    ]
+    const { messages: compacted } = compactMessages(messages)
+    const rendered = renderCompactMessages(compacted)
+    expect(rendered).toContain('user: do the thing')
+    expect(rendered).toContain('tool:')
+    expect(rendered.length).toBeGreaterThan(0)
+  })
+})
diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index c4371bc..62809a1 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -58,7 +58,8 @@
     "bun": ">=1.1"
   },
   "dependencies": {
-    "@davstack/cli-utils": "workspace:*"
+    "@davstack/cli-utils": "workspace:*",
+    "@davstack/context-compactor": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
index 0141d4e..8f9be34 100644
--- a/packages/open-agents/src/core/compact.ts
+++ b/packages/open-agents/src/core/compact.ts
@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { compact } from '@davstack/context-compactor';
 import type { HeadroomMessage } from './headroom.js';
 
 export interface CompactHistory {
@@ -56,6 +57,51 @@ export function renderCompactMessages(messages: HeadroomMessage[]): string {
   return messages.map(compactMessageText).join('\n\n').trim();
 }
 
+function compactText(text: string): string {
+  if (!text) return text;
+  try {
+    return compact(text).text;
+  } catch {
+    return text;
+  }
+}
+
+export function compactMessageContent(message: HeadroomMessage): HeadroomMessage {
+  const content = message.content;
+  if (typeof content === 'string') {
+    return { ...message, content: compactText(content) };
+  }
+  if (Array.isArray(content)) {
+    const blocks = content.map((part) => {
+      if (!part || typeof part !== 'object') return part;
+      const item = part as Record<string, unknown>;
+      if (typeof item.text === 'string') return { ...item, text: compactText(item.text) };
+      if (typeof item.content === 'string') return { ...item, content: compactText(item.content) };
+      return part;
+    });
+    return { ...message, content: blocks };
+  }
+  return { ...message };
+}
+
+export function compactMessages(messages: HeadroomMessage[]): {
+  messages: HeadroomMessage[];
+  tokensBefore: number;
+  tokensAfter: number;
+  tokensSaved: number;
+} {
+  const out: HeadroomMessage[] = [];
+  let tokensBefore = 0;
+  let tokensAfter = 0;
+  for (const message of messages) {
+    tokensBefore += tokenLikeCount(compactMessageText(message));
+    const compacted = compactMessageContent(message);
+    tokensAfter += tokenLikeCount(compactMessageText(compacted));
+    out.push(compacted);
+  }
+  return { messages: out, tokensBefore, tokensAfter, tokensSaved: tokensBefore - tokensAfter };
+}
+
 function isMessage(value: unknown): value is HeadroomMessage {
   if (!value || typeof value !== 'object') return false;
   const item = value as Record<string, unknown>;
@@ -235,7 +281,9 @@ export function loadCompactHistory(path: string, tailTokens: number): CompactHis
     throw new Error(`compact history file not found: ${resolved}`);
   }
   const text = readFileSync(resolved, 'utf8');
-  const messages = tailCompactMessages(parseCompactMessages(text), tailTokens);
+  const parsed = parseCompactMessages(text);
+  const compacted = parsed.length ? compactMessages(parsed).messages : parsed;
+  const messages = tailCompactMessages(compacted, tailTokens);
   return {
     path: resolved,
     text,

From 590ad671e67296c4757c7c43d370110fc58b3a07 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 15:26:59 +0100
Subject: [PATCH 42/72] chore(open-agents): remove Headroom proxy integration

The Headroom proxy saved ~0 tokens for our tool mix and its ML compress path
was unusably slow on CPU; @davstack/context-compactor replaces it. Removes the
proxy entirely rather than leaving it dead-but-disabled:

- delete core/headroom.ts and its test
- strip the proxy flags, config resolution, detect/stats/compress wiring, and
  help text from cli.ts (compact-mode now relies solely on the compactor)
- drop HeadroomConfig from config.ts and its config tests
- move the message type to a local CompactMessage in core/compact.ts

Compact-mode (the spec-writer handoff) is unchanged.
---
 .../context-compactor-spec-compaction.md      |   2 +-
 .../__tests__/compact-messages.test.ts        |  12 +-
 .../open-agents/__tests__/compact.test.ts     |   2 +-
 packages/open-agents/__tests__/config.test.ts |  21 --
 .../open-agents/__tests__/headroom.test.ts    |  89 -------
 packages/open-agents/src/cli.ts               |  87 +------
 packages/open-agents/src/config.ts            |  16 --
 packages/open-agents/src/core/compact.ts      |  34 +--
 packages/open-agents/src/core/headroom.ts     | 230 ------------------
 9 files changed, 33 insertions(+), 460 deletions(-)
 delete mode 100644 packages/open-agents/__tests__/headroom.test.ts
 delete mode 100644 packages/open-agents/src/core/headroom.ts

diff --git a/.changeset/context-compactor-spec-compaction.md b/.changeset/context-compactor-spec-compaction.md
index 2698c03..7c09f5c 100644
--- a/.changeset/context-compactor-spec-compaction.md
+++ b/.changeset/context-compactor-spec-compaction.md
@@ -3,4 +3,4 @@
 "@davstack/open-agents": minor
 ---
 
-Add `@davstack/context-compactor`: a TS-native, deterministic context-compaction package with structure-aware handlers (JSON, code, log, diff, text) and TOON output for arrays of uniform objects. open-agents now compacts spec-writer handoff history through it before generation, and the Headroom proxy routing is defaulted off.
+Add `@davstack/context-compactor`: a TS-native, deterministic context-compaction package with structure-aware handlers (JSON, code, log, diff, text) and TOON output for arrays of uniform objects. open-agents now compacts spec-writer handoff history through it before generation, replacing the removed Headroom proxy integration.
diff --git a/packages/open-agents/__tests__/compact-messages.test.ts b/packages/open-agents/__tests__/compact-messages.test.ts
index 2676332..3c132f5 100644
--- a/packages/open-agents/__tests__/compact-messages.test.ts
+++ b/packages/open-agents/__tests__/compact-messages.test.ts
@@ -4,7 +4,7 @@ import {
   compactMessages,
   renderCompactMessages,
 } from '../src/core/compact.js'
-import type { HeadroomMessage } from '../src/core/headroom.js'
+import type { CompactMessage } from '../src/core/compact.js'
 
 function bigJsonToolResult(): string {
   return JSON.stringify(
@@ -21,7 +21,7 @@ function bigJsonToolResult(): string {
 describe('compactMessageContent', () => {
   test('reduces a large JSON string content, preserves role and schema keys', () => {
     const original = bigJsonToolResult()
-    const message: HeadroomMessage = { role: 'tool', content: original }
+    const message: CompactMessage = { role: 'tool', content: original }
     const result = compactMessageContent(message)
 
     expect(result.role).toBe('tool')
@@ -34,7 +34,7 @@ describe('compactMessageContent', () => {
   })
 
   test('passes a small / plain message through unchanged', () => {
-    const message: HeadroomMessage = { role: 'user', content: 'fix the enum bug please' }
+    const message: CompactMessage = { role: 'user', content: 'fix the enum bug please' }
     const result = compactMessageContent(message)
     expect(result.role).toBe('user')
     expect(result.content).toBe('fix the enum bug please')
@@ -42,7 +42,7 @@ describe('compactMessageContent', () => {
 
   test('array content: text blocks compacted, non-text blocks preserved', () => {
     const big = bigJsonToolResult()
-    const message: HeadroomMessage = {
+    const message: CompactMessage = {
       role: 'assistant',
       content: [
         { type: 'text', text: big },
@@ -66,7 +66,7 @@ describe('compactMessageContent', () => {
 
 describe('compactMessages', () => {
   test('aggregates token estimates and reduces a big tool_result message', () => {
-    const messages: HeadroomMessage[] = [
+    const messages: CompactMessage[] = [
       { role: 'user', content: 'short ask' },
       { role: 'tool', content: bigJsonToolResult() },
     ]
@@ -79,7 +79,7 @@ describe('compactMessages', () => {
   })
 
   test('renderCompactMessages still works on compacted messages', () => {
-    const messages: HeadroomMessage[] = [
+    const messages: CompactMessage[] = [
       { role: 'user', content: 'do the thing' },
       { role: 'tool', content: bigJsonToolResult() },
     ]
diff --git a/packages/open-agents/__tests__/compact.test.ts b/packages/open-agents/__tests__/compact.test.ts
index 47e78b6..ba402b1 100644
--- a/packages/open-agents/__tests__/compact.test.ts
+++ b/packages/open-agents/__tests__/compact.test.ts
@@ -31,7 +31,7 @@ describe('compact mode helpers', () => {
     expect(positional).toEqual(['short task']);
   });
 
-  test('loads real JSONL messages for Headroom compression', () => {
+  test('loads real JSONL messages for compaction', () => {
     const dir = mkdtempSync(join(tmpdir(), 'compact-messages-'));
     try {
       const history = join(dir, 'history.jsonl');
diff --git a/packages/open-agents/__tests__/config.test.ts b/packages/open-agents/__tests__/config.test.ts
index f9e41b1..ca509d0 100644
--- a/packages/open-agents/__tests__/config.test.ts
+++ b/packages/open-agents/__tests__/config.test.ts
@@ -46,18 +46,12 @@ describe('loadConfig — .davstack/config/open-agents.config.ts present', () =>
         defaultModel: 'composer-2-fast',
         defaultAdapter: 'cursor',
         defaultTimeoutSec: 900,
-        headroom: { mode: 'require', url: 'http://localhost:8788', logStats: false },
       }`,
     );
     const cfg = await loadConfig(sandbox);
     expect(cfg.defaultModel).toBe('composer-2-fast');
     expect(cfg.defaultAdapter).toBe('cursor');
     expect(cfg.defaultTimeoutSec).toBe(900);
-    expect(cfg.headroom).toEqual({
-      mode: 'require',
-      url: 'http://localhost:8788',
-      logStats: false,
-    });
     expect(cfg._source).toContain('open-agents.config.ts');
   });
 
@@ -88,21 +82,6 @@ describe('loadConfig — .davstack/config/open-agents.config.ts present', () =>
     expect(cfg.defaultModel).toBeUndefined();
   });
 
-  test('drops invalid headroom fields', async () => {
-    writeFileSync(
-      join(sandbox, '.davstack', 'config', 'open-agents.config.ts'),
-      `export default {
-        headroom: { mode: 'sometimes', url: 42, logStats: 'yes' },
-      }`,
-    );
-    const cfg = await loadConfig(sandbox);
-    expect(cfg.headroom).toEqual({
-      mode: undefined,
-      url: undefined,
-      logStats: undefined,
-    });
-  });
-
   test('preserves profiles object as-authored', async () => {
     writeFileSync(
       join(sandbox, '.davstack', 'config', 'open-agents.config.ts'),
diff --git a/packages/open-agents/__tests__/headroom.test.ts b/packages/open-agents/__tests__/headroom.test.ts
deleted file mode 100644
index 273836b..0000000
--- a/packages/open-agents/__tests__/headroom.test.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import { afterEach, describe, expect, test, vi } from 'vitest';
-import {
-  compressHeadroomMessages,
-  formatHeadroomDelta,
-  resolveHeadroomConfig,
-} from '../src/core/headroom.js';
-
-describe('headroom helpers', () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test('defaults to auto localhost proxy', () => {
-    expect(resolveHeadroomConfig({ env: {} })).toEqual({
-      mode: 'auto',
-      url: 'http://127.0.0.1:8787',
-      logStats: true,
-    });
-  });
-
-  test('env and flags override config', () => {
-    expect(
-      resolveHeadroomConfig({
-        config: { mode: 'auto', url: 'http://config:8787', logStats: true },
-        env: { OPEN_AGENTS_HEADROOM: 'off', OPEN_AGENTS_HEADROOM_URL: 'http://env:8787/' },
-        modeFlag: 'require',
-        urlFlag: 'http://flag:8787/',
-      }),
-    ).toEqual({
-      mode: 'require',
-      url: 'http://flag:8787',
-      logStats: true,
-    });
-  });
-
-  test('formats stats deltas when counters are available', () => {
-    expect(
-      formatHeadroomDelta(
-        { requestsTotal: 10, tokensSaved: 1000, inputTokens: 10000, outputTokens: 100, raw: {} },
-        { requestsTotal: 12, tokensSaved: 2500, inputTokens: 12000, outputTokens: 200, raw: {} },
-      ),
-    ).toBe('2 requests, 1,500 tokens saved');
-  });
-
-  test('compresses the real message array without changing roles locally', async () => {
-    const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        messages: [
-          { role: 'user', content: 'keep intent' },
-          { role: 'assistant', content: 'shorter output' },
-        ],
-        tokens_before: 100,
-        tokens_after: 40,
-        tokens_saved: 60,
-        compression_ratio: 0.4,
-        transforms_applied: ['smart_crusher'],
-      }),
-    } as Response);
-
-    const result = await compressHeadroomMessages({
-      url: 'http://127.0.0.1:8787',
-      model: 'composer-2.5',
-      tokenBudget: 100000,
-      messages: [
-        { role: 'user', content: 'keep intent' },
-        { role: 'assistant', content: 'long output' },
-      ],
-    });
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      'http://127.0.0.1:8787/v1/compress',
-      expect.objectContaining({
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          model: 'composer-2.5',
-          tokenBudget: 100000,
-          messages: [
-            { role: 'user', content: 'keep intent' },
-            { role: 'assistant', content: 'long output' },
-          ],
-        }),
-      }),
-    );
-    expect(result.messages[0]).toEqual({ role: 'user', content: 'keep intent' });
-    expect(result.tokensSaved).toBe(60);
-  });
-});
diff --git a/packages/open-agents/src/cli.ts b/packages/open-agents/src/cli.ts
index a5c3e23..d4ba9e8 100644
--- a/packages/open-agents/src/cli.ts
+++ b/packages/open-agents/src/cli.ts
@@ -23,7 +23,6 @@ import type { AgentAdapter, Tier } from './adapters/types.js';
 import {
   buildCompactSpecWriterTask,
   loadCompactHistory,
-  renderCompactMessages,
   resolveCompactHistoryFile,
 } from './core/compact.js';
 import { readDeliverable, renderJobResult } from './core/deliverable.js';
@@ -36,13 +35,6 @@ import {
 } from './core/jobs.js';
 import { jobsDir } from './core/paths.js';
 import { DEFAULT_TIMEOUT_SEC, runJob } from './core/run.js';
-import {
-  compressHeadroomMessages,
-  detectHeadroom,
-  formatHeadroomDelta,
-  readHeadroomStats,
-  resolveHeadroomConfig,
-} from './core/headroom.js';
 import { editProfile } from './profiles/edit.js';
 import { exploreProfile } from './profiles/explore.js';
 import { specWriterProfile } from './profiles/spec-writer.js';
@@ -84,8 +76,6 @@ export interface Flags {
   adapter?: string;
   compactMode?: boolean;
   historyFile?: string;
-  headroom?: string;
-  headroomUrl?: string;
 }
 
 export function parseFlags(argv: string[]): { flags: Flags; positional: string[] } {
@@ -114,8 +104,6 @@ export function parseFlags(argv: string[]): { flags: Flags; positional: string[]
     else if (a === '--parallel-mode') flags.parallelMode = val();
     else if (a === '--adapter' || a === '--provider') flags.adapter = val();
     else if (a === '--history-file') flags.historyFile = val();
-    else if (a === '--headroom') flags.headroom = val();
-    else if (a === '--headroom-url') flags.headroomUrl = val();
     else positional.push(argv[i]);
   }
   return { flags, positional };
@@ -157,7 +145,6 @@ function pickProfile(flags: Flags): Profile {
 // --- submit ----------------------------------------------------------------
 const SHELL_HOSTILE = /[\n"'`$();|&<>]/;
 const DEFAULT_COMPACT_TAIL_TOKENS = 50000;
-const HEADROOM_COMPACT_TAIL_TOKENS = 100000;
 
 function userPath(path: string): string {
   const home = homedir();
@@ -187,34 +174,11 @@ async function generateCompactSpec(input: {
   task: string;
   historyFile: string;
   tailTokens: number;
-  headroomEnv?: Record<string, string>;
-  headroomUrl?: string;
-  logHeadroomStats?: boolean;
 }): Promise<string> {
   const history = loadCompactHistory(input.historyFile, input.tailTokens);
   const adapter = cursorAdapter;
   const model = cursorAdapter.defaultModel();
-  let historyTail = history.tail;
-  if (input.headroomUrl && history.messages.length) {
-    try {
-      const compressed = await compressHeadroomMessages({
-        url: input.headroomUrl,
-        messages: history.messages,
-        model: model,
-        tokenBudget: input.tailTokens,
-      });
-      historyTail = renderCompactMessages(compressed.messages);
-      if (compressed.tokensSaved > 0) {
-        process.stderr.write(
-          `open-agents: headroom compressed history ${Math.round(compressed.tokensBefore).toLocaleString()} -> ${Math.round(compressed.tokensAfter).toLocaleString()} tokens (${Math.round(compressed.tokensSaved).toLocaleString()} saved)\n`,
-        );
-      }
-    } catch (err) {
-      process.stderr.write(
-        `open-agents: headroom history compression failed; using raw history tail (${(err as Error).message})\n`,
-      );
-    }
-  }
+  const historyTail = history.tail;
   const specWriterTask = buildCompactSpecWriterTask({
     task: input.task,
     repoPath: input.repoPath,
@@ -259,15 +223,11 @@ async function generateCompactSpec(input: {
   );
   const preToken = adapter.preSpawn(input.repoPath);
   const specStartedAt = Date.now();
-  const statsBefore =
-    input.headroomUrl && input.logHeadroomStats ? await readHeadroomStats(input.headroomUrl) : null;
   await runJob(
-    { adapter, profile: specWriterProfile, env: input.headroomEnv },
+    { adapter, profile: specWriterProfile, env: {} },
     input.repoPath,
     id,
   );
-  const statsAfter =
-    input.headroomUrl && input.logHeadroomStats ? await readHeadroomStats(input.headroomUrl) : null;
   const specElapsedSec = Math.round((Date.now() - specStartedAt) / 1000);
   adapter.postExit(input.repoPath, preToken);
   const job = readJob(input.repoPath, id);
@@ -281,8 +241,6 @@ async function generateCompactSpec(input: {
   process.stderr.write(
     `open-agents: compact-mode generated spec ${id} in ${specElapsedSec}s (${generated.length} chars) -> ${userPath(job.resultPath || '')}\n`,
   );
-  const delta = formatHeadroomDelta(statsBefore, statsAfter);
-  if (delta) process.stderr.write(`open-agents: headroom compact-mode stats: ${delta}\n`);
   return generated;
 }
 
@@ -302,33 +260,7 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
   const timeoutSec = Number.isFinite(flags.timeout)
     ? flags.timeout!
     : (config.defaultTimeoutSec ?? DEFAULT_TIMEOUT_SEC);
-  // Headroom proxy DISABLED (2026-06-09). The local proxy at 127.0.0.1:8787
-  // added latency and saved ~0 tokens for our tool mix (Read/Glob/Grep/Write/
-  // Edit/Bash are all excluded; the one compressible path is ML token-pruning
-  // that is unusably slow on CPU and hits the 30s timeout). We are replacing it
-  // with a TS-native, deterministic context compactor. Forcing mode 'off' keeps
-  // the compact-mode flow working without any /health probe or OPENAI_BASE_URL.
-  // To re-enable the proxy temporarily, drop the `, mode: 'off'` override.
-  const headroomConfig = {
-    ...resolveHeadroomConfig({
-      config: config.headroom,
-      modeFlag: flags.headroom,
-      urlFlag: flags.headroomUrl,
-    }),
-    mode: 'off' as const,
-  };
-  const headroom = await detectHeadroom({ adapterName: adapter.name, config: headroomConfig });
-  if (headroom.active) {
-    process.stderr.write(`open-agents: headroom active (${headroom.openAIBaseUrl})\n`);
-  } else if (headroomConfig.mode !== 'off') {
-    process.stderr.write(
-      `open-agents: headroom unavailable; continuing without proxy` +
-        `${headroom.reason ? ` (${headroom.reason})` : ''}\n`,
-    );
-  }
-  const compactTailTokens = headroom.active
-    ? HEADROOM_COMPACT_TAIL_TOKENS
-    : DEFAULT_COMPACT_TAIL_TOKENS;
+  const compactTailTokens = DEFAULT_COMPACT_TAIL_TOKENS;
   const adapterAddendum = adapter.guardAddendum?.(profile.name, flags.tier) ?? '';
   const profileKey = profile.name as 'explore' | 'edit';
   const userExtension = config.profiles?.[profileKey]?.systemPromptExtension ?? '';
@@ -376,9 +308,6 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
           task: body,
           historyFile,
           tailTokens: compactTailTokens,
-          headroomEnv: headroom.env,
-          headroomUrl: headroom.active ? headroom.url : undefined,
-          logHeadroomStats: headroomConfig.logStats,
         }),
       ),
     );
@@ -403,7 +332,7 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
     return id;
   });
 
-  const deps = { adapter, profile, env: headroom.env };
+  const deps = { adapter, profile, env: {} };
 
   if (flags.detach) {
     for (const id of ids) {
@@ -411,7 +340,7 @@ async function cmdSubmit(flags: Flags, positional: string[]): Promise<void> {
         detached: true,
         stdio: 'ignore',
         windowsHide: true,
-        env: { ...process.env, ...headroom.env },
+        env: { ...process.env },
       }).unref();
     }
     process.stdout.write(ids.join('\n') + '\n');
@@ -660,13 +589,9 @@ const HELP = `open-agents cli — self-waiting subagent job primitive
              CLAUDE_CODE_TRANSCRIPT_PATH, the current Claude Code transcript
              when CLAUDE_CODE_SESSION_ID is set, CODEX_THREAD_ID sessions under
              ~/.codex/sessions, or ~/.codex/history.jsonl. Gives the spec-writer
-             the last 50000 token-like units plus a pointer to the full history
-             (100000 when a local Headroom proxy is active).
+             the last 50000 token-like units plus a pointer to the full history.
              Progress output includes spec generation time and the generated
              spec artifact path.
-           --headroom auto|off|require (default auto): auto-probe Headroom at
-             http://127.0.0.1:8787 and set OPENAI_BASE_URL=<url>/v1 for cursor
-             jobs when healthy. --headroom-url overrides the proxy URL.
   wait                         wait for ALL running jobs in this repo
   wait   "<id…>" | <id…>       wait for ALL of these
   wait   --any <id…>           return when ≥1 done; prints which (loop = popcorn)
diff --git a/packages/open-agents/src/config.ts b/packages/open-agents/src/config.ts
index dbd0905..ca2c78f 100644
--- a/packages/open-agents/src/config.ts
+++ b/packages/open-agents/src/config.ts
@@ -12,7 +12,6 @@
 
 import { resolve } from 'node:path';
 import { findRepoRoot, findToolConfig } from '@davstack/cli-utils/config';
-import type { HeadroomConfig } from './core/headroom.js';
 
 export type AdapterName = 'cursor' | 'gemini' | 'agy';
 
@@ -24,7 +23,6 @@ export type OpenAgentsConfig = {
   defaultModel?: string;
   defaultAdapter?: AdapterName;
   defaultTimeoutSec?: number;
-  headroom?: HeadroomConfig;
   profiles?: {
     explore?: ProfileOverrides;
     edit?: ProfileOverrides;
@@ -71,7 +69,6 @@ export async function loadConfig(cwd: string = process.cwd()): Promise<LoadedCon
       typeof raw.defaultTimeoutSec === 'number' && raw.defaultTimeoutSec > 0
         ? raw.defaultTimeoutSec
         : undefined,
-    headroom: normalizeHeadroomConfig(raw.headroom),
     profiles: raw.profiles && typeof raw.profiles === 'object' ? raw.profiles : undefined,
     _source: configPath,
     _repoRoot: repoRoot,
@@ -80,19 +77,6 @@ export async function loadConfig(cwd: string = process.cwd()): Promise<LoadedCon
   return merged;
 }
 
-function normalizeHeadroomConfig(raw: unknown): HeadroomConfig | undefined {
-  if (!raw || typeof raw !== 'object') return undefined;
-  const obj = raw as Record<string, unknown>;
-  const mode = obj.mode;
-  const normalizedMode =
-    mode === 'auto' || mode === 'off' || mode === 'require' ? mode : undefined;
-  return {
-    mode: normalizedMode,
-    url: typeof obj.url === 'string' ? obj.url : undefined,
-    logStats: typeof obj.logStats === 'boolean' ? obj.logStats : undefined,
-  };
-}
-
 function pathToFileUrl(p: string): string {
   // Minimal local equivalent of url.pathToFileURL(p).href to avoid the extra
   // import and to keep the surface trivially auditable.
diff --git a/packages/open-agents/src/core/compact.ts b/packages/open-agents/src/core/compact.ts
index 8f9be34..7d73293 100644
--- a/packages/open-agents/src/core/compact.ts
+++ b/packages/open-agents/src/core/compact.ts
@@ -2,14 +2,18 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { compact } from '@davstack/context-compactor';
-import type { HeadroomMessage } from './headroom.js';
+
+export type CompactMessage = Record<string, unknown> & {
+  role?: string;
+  content?: unknown;
+};
 
 export interface CompactHistory {
   path: string;
   text: string;
   tail: string;
   tailTokens: number;
-  messages: HeadroomMessage[];
+  messages: CompactMessage[];
 }
 
 export function tokenTail(text: string, maxTokens: number): string {
@@ -47,13 +51,13 @@ function textFromContent(content: unknown): string {
   return JSON.stringify(content);
 }
 
-function compactMessageText(message: HeadroomMessage): string {
+function compactMessageText(message: CompactMessage): string {
   const role = typeof message.role === 'string' ? message.role : 'message';
   const content = textFromContent(message.content);
   return `${role}: ${content || JSON.stringify(message)}`;
 }
 
-export function renderCompactMessages(messages: HeadroomMessage[]): string {
+export function renderCompactMessages(messages: CompactMessage[]): string {
   return messages.map(compactMessageText).join('\n\n').trim();
 }
 
@@ -66,7 +70,7 @@ function compactText(text: string): string {
   }
 }
 
-export function compactMessageContent(message: HeadroomMessage): HeadroomMessage {
+export function compactMessageContent(message: CompactMessage): CompactMessage {
   const content = message.content;
   if (typeof content === 'string') {
     return { ...message, content: compactText(content) };
@@ -84,13 +88,13 @@ export function compactMessageContent(message: HeadroomMessage): HeadroomMessage
   return { ...message };
 }
 
-export function compactMessages(messages: HeadroomMessage[]): {
-  messages: HeadroomMessage[];
+export function compactMessages(messages: CompactMessage[]): {
+  messages: CompactMessage[];
   tokensBefore: number;
   tokensAfter: number;
   tokensSaved: number;
 } {
-  const out: HeadroomMessage[] = [];
+  const out: CompactMessage[] = [];
   let tokensBefore = 0;
   let tokensAfter = 0;
   for (const message of messages) {
@@ -102,13 +106,13 @@ export function compactMessages(messages: HeadroomMessage[]): {
   return { messages: out, tokensBefore, tokensAfter, tokensSaved: tokensBefore - tokensAfter };
 }
 
-function isMessage(value: unknown): value is HeadroomMessage {
+function isMessage(value: unknown): value is CompactMessage {
   if (!value || typeof value !== 'object') return false;
   const item = value as Record<string, unknown>;
   return typeof item.role === 'string' && 'content' in item;
 }
 
-function extractMessage(row: unknown): HeadroomMessage | null {
+function extractMessage(row: unknown): CompactMessage | null {
   if (isMessage(row)) return row;
   if (!row || typeof row !== 'object') return null;
   const item = row as Record<string, unknown>;
@@ -123,8 +127,8 @@ function extractMessage(row: unknown): HeadroomMessage | null {
   return null;
 }
 
-export function parseCompactMessages(text: string): HeadroomMessage[] {
-  const messages: HeadroomMessage[] = [];
+export function parseCompactMessages(text: string): CompactMessage[] {
+  const messages: CompactMessage[] = [];
   for (const line of text.split(/\r?\n/)) {
     if (!line.trim()) continue;
     try {
@@ -138,11 +142,11 @@ export function parseCompactMessages(text: string): HeadroomMessage[] {
 }
 
 export function tailCompactMessages(
-  messages: HeadroomMessage[],
+  messages: CompactMessage[],
   maxTokens: number,
-): HeadroomMessage[] {
+): CompactMessage[] {
   if (!Number.isFinite(maxTokens) || maxTokens <= 0) return [];
-  const out: HeadroomMessage[] = [];
+  const out: CompactMessage[] = [];
   let tokens = 0;
   for (let i = messages.length - 1; i >= 0; i -= 1) {
     const messageTokens = tokenLikeCount(compactMessageText(messages[i]));
diff --git a/packages/open-agents/src/core/headroom.ts b/packages/open-agents/src/core/headroom.ts
deleted file mode 100644
index 53f99b9..0000000
--- a/packages/open-agents/src/core/headroom.ts
+++ /dev/null
@@ -1,230 +0,0 @@
-export type HeadroomMode = 'auto' | 'off' | 'require';
-
-export interface HeadroomConfig {
-  mode?: HeadroomMode;
-  url?: string;
-  logStats?: boolean;
-}
-
-export interface HeadroomState {
-  active: boolean;
-  required: boolean;
-  url: string;
-  openAIBaseUrl: string;
-  env: Record<string, string>;
-  reason?: string;
-}
-
-export interface HeadroomStats {
-  requestsTotal: number;
-  tokensSaved: number;
-  inputTokens: number;
-  outputTokens: number;
-  raw: unknown;
-}
-
-export type HeadroomMessage = Record<string, unknown> & {
-  role?: string;
-  content?: unknown;
-};
-
-export interface HeadroomCompressionResult {
-  messages: HeadroomMessage[];
-  tokensBefore: number;
-  tokensAfter: number;
-  tokensSaved: number;
-  compressionRatio: number;
-  transformsApplied: string[];
-  raw: unknown;
-}
-
-interface HeadroomStatsResponse {
-  requests?: {
-    total?: number;
-  };
-  tokens?: {
-    input?: number;
-    output?: number;
-    saved?: number;
-  };
-}
-
-interface HeadroomCompressionResponse {
-  messages?: HeadroomMessage[];
-  tokens_before?: number;
-  tokens_after?: number;
-  tokens_saved?: number;
-  compression_ratio?: number;
-  transforms_applied?: string[];
-  tokensBefore?: number;
-  tokensAfter?: number;
-  tokensSaved?: number;
-  compressionRatio?: number;
-  transformsApplied?: string[];
-}
-
-const DEFAULT_URL = 'http://127.0.0.1:8787';
-const DEFAULT_TIMEOUT_MS = 750;
-
-function cleanUrl(url: string): string {
-  return url.replace(/\/+$/, '');
-}
-
-function parseMode(value: unknown): HeadroomMode | undefined {
-  if (typeof value !== 'string') return undefined;
-  const lower = value.toLowerCase();
-  if (lower === 'auto' || lower === 'off' || lower === 'require') return lower;
-  return undefined;
-}
-
-export function resolveHeadroomConfig(input?: {
-  config?: HeadroomConfig;
-  env?: NodeJS.ProcessEnv;
-  modeFlag?: string;
-  urlFlag?: string;
-}): Required<Pick<HeadroomConfig, 'mode' | 'url' | 'logStats'>> {
-  const env = input?.env ?? process.env;
-  const mode =
-    parseMode(input?.modeFlag) ??
-    parseMode(env.OPEN_AGENTS_HEADROOM) ??
-    input?.config?.mode ??
-    'auto';
-  const url = cleanUrl(
-    input?.urlFlag || env.OPEN_AGENTS_HEADROOM_URL || input?.config?.url || DEFAULT_URL,
-  );
-  const logStats =
-    env.OPEN_AGENTS_HEADROOM_LOG_STATS === '0' || env.OPEN_AGENTS_HEADROOM_LOG_STATS === 'false'
-      ? false
-      : (input?.config?.logStats ?? true);
-  return { mode, url, logStats };
-}
-
-async function fetchJson(url: string, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<unknown> {
-  const ac = new AbortController();
-  const t = setTimeout(() => ac.abort(), timeoutMs);
-  try {
-    const res = await fetch(url, { signal: ac.signal });
-    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`.trim());
-    return await res.json();
-  } finally {
-    clearTimeout(t);
-  }
-}
-
-async function postJson(url: string, body: unknown, timeoutMs = 15_000): Promise<unknown> {
-  const ac = new AbortController();
-  const t = setTimeout(() => ac.abort(), timeoutMs);
-  try {
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(body),
-      signal: ac.signal,
-    });
-    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`.trim());
-    return await res.json();
-  } finally {
-    clearTimeout(t);
-  }
-}
-
-export async function detectHeadroom(input: {
-  adapterName: string;
-  config: Required<Pick<HeadroomConfig, 'mode' | 'url' | 'logStats'>>;
-}): Promise<HeadroomState> {
-  const { adapterName, config } = input;
-  const required = config.mode === 'require';
-  const openAIBaseUrl = `${config.url}/v1`;
-  if (config.mode === 'off') {
-    return { active: false, required, url: config.url, openAIBaseUrl, env: {}, reason: 'disabled' };
-  }
-  if (adapterName !== 'cursor') {
-    return {
-      active: false,
-      required,
-      url: config.url,
-      openAIBaseUrl,
-      env: {},
-      reason: `adapter ${adapterName} does not use the OpenAI-compatible proxy path`,
-    };
-  }
-  try {
-    await fetchJson(`${config.url}/health`);
-    return {
-      active: true,
-      required,
-      url: config.url,
-      openAIBaseUrl,
-      env: { OPENAI_BASE_URL: openAIBaseUrl },
-    };
-  } catch (err) {
-    if (required) {
-      throw new Error(
-        `Headroom is required but not healthy at ${config.url}: ${(err as Error).message}`,
-      );
-    }
-    return {
-      active: false,
-      required,
-      url: config.url,
-      openAIBaseUrl,
-      env: {},
-      reason: (err as Error).message,
-    };
-  }
-}
-
-function numberOrZero(value: unknown): number {
-  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
-}
-
-export async function readHeadroomStats(url: string): Promise<HeadroomStats | null> {
-  try {
-    const raw = await fetchJson(`${cleanUrl(url)}/stats`);
-    const stats = raw as HeadroomStatsResponse;
-    return {
-      requestsTotal: numberOrZero(stats.requests?.total),
-      tokensSaved: numberOrZero(stats.tokens?.saved),
-      inputTokens: numberOrZero(stats.tokens?.input),
-      outputTokens: numberOrZero(stats.tokens?.output),
-      raw,
-    };
-  } catch {
-    return null;
-  }
-}
-
-export async function compressHeadroomMessages(input: {
-  url: string;
-  messages: HeadroomMessage[];
-  model?: string;
-  tokenBudget?: number;
-}): Promise<HeadroomCompressionResult> {
-  const raw = await postJson(`${cleanUrl(input.url)}/v1/compress`, {
-    model: input.model || 'gpt-4o',
-    tokenBudget: input.tokenBudget,
-    messages: input.messages,
-  });
-  const result = raw as HeadroomCompressionResponse;
-  return {
-    messages: Array.isArray(result.messages) ? result.messages : input.messages,
-    tokensBefore: numberOrZero(result.tokens_before ?? result.tokensBefore),
-    tokensAfter: numberOrZero(result.tokens_after ?? result.tokensAfter),
-    tokensSaved: numberOrZero(result.tokens_saved ?? result.tokensSaved),
-    compressionRatio: numberOrZero(result.compression_ratio ?? result.compressionRatio),
-    transformsApplied: Array.isArray(result.transforms_applied ?? result.transformsApplied)
-      ? ((result.transforms_applied ?? result.transformsApplied) as string[])
-      : [],
-    raw,
-  };
-}
-
-export function formatHeadroomDelta(before: HeadroomStats | null, after: HeadroomStats | null): string | null {
-  if (!before || !after) return null;
-  const bits: string[] = [];
-  const requestDelta = after.requestsTotal - before.requestsTotal;
-  if (requestDelta > 0) bits.push(`${requestDelta} request${requestDelta === 1 ? '' : 's'}`);
-  const savedDelta = after.tokensSaved - before.tokensSaved;
-  if (savedDelta > 0) bits.push(`${Math.round(savedDelta).toLocaleString()} tokens saved`);
-  return bits.length ? bits.join(', ') : null;
-}

From 4ec4a332863ce45c0b1fd423dd34c9278d757ffa Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 15:36:11 +0100
Subject: [PATCH 43/72] Update meta folder XML output

Remove file kind attributes from generated metadata, render deep scans as nested folder tags with root-absolute child paths, report unsupported files in per-folder omitted_files blocks, and treat js/mjs files like TypeScript while covering mdx behavior in tests.
---
 packages/meta/__tests__/cli.test.ts  |  3 +-
 packages/meta/__tests__/meta.test.ts | 65 ++++++++++++++++++++--
 packages/meta/src/index.ts           | 82 ++++++++++++++++++++++------
 3 files changed, 128 insertions(+), 22 deletions(-)

diff --git a/packages/meta/__tests__/cli.test.ts b/packages/meta/__tests__/cli.test.ts
index c6cecd6..1f278ae 100644
--- a/packages/meta/__tests__/cli.test.ts
+++ b/packages/meta/__tests__/cli.test.ts
@@ -41,7 +41,8 @@ describe('davstack-meta CLI', () => {
     expect(code).toBe(0);
     const output = log.mock.calls.map(([value]) => String(value)).join('\n');
     expect(output).toContain('h1 Root');
-    expect(output).toContain('child/child.ts');
+    expect(output).toContain('<folder path="/child">');
+    expect(output).toContain('<file path="child.ts">');
     expect(output).toContain('childValue');
   });
 });
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index 43eaa54..5926124 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -34,16 +34,16 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path=".">
-      <file path="notes.md" kind="markdown">
+      <file path="notes.md">
       - h1 Overview
       - h2 Details
       </file>
-      <file path="sample.py" kind="python">
+      <file path="sample.py">
       - const CONSTANT
       - class Worker
       - function run
       </file>
-      <file path="tools.ts" kind="typescript">
+      <file path="tools.ts">
       - class LocalThing
       - interface Config
       - type Mode
@@ -83,6 +83,60 @@ describe('scanFolderMetadata', () => {
     expect(metadata).not.toContain('ignored.ts');
     expect(metadata).not.toContain('const ignored');
   });
+
+  test('summarizes js, mjs, and mdx files with existing extractors', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, 'component.mdx'), '# Component\n');
+    await writeFile(path.join(root, 'script.js'), 'export function boot() {}\n');
+    await writeFile(path.join(root, 'module.mjs'), 'export const mode = "esm"\n');
+
+    const metadata = await scanFolderMetadata(root);
+
+    expect(metadata).toContain('<file path="component.mdx">');
+    expect(metadata).toContain('- h1 Component');
+    expect(metadata).toContain('<file path="script.js">');
+    expect(metadata).toContain('- function boot');
+    expect(metadata).toContain('<file path="module.mjs">');
+    expect(metadata).toContain('- const mode');
+    expect(metadata).not.toContain('omitted_files');
+  });
+
+  test('wraps deep child folders and reports omitted files per folder', async () => {
+    const root = await makeTempFolder();
+    await mkdir(path.join(root, 'child', 'grandchild'), { recursive: true });
+    await writeFile(path.join(root, 'root.ts'), 'export const rootValue = true\n');
+    await writeFile(path.join(root, 'asset.png'), 'not code\n');
+    await writeFile(path.join(root, 'child', 'child.py'), 'def child_function():\n    pass\n');
+    await writeFile(path.join(root, 'child', 'data.json'), '{"hidden":true}\n');
+    await writeFile(path.join(root, 'child', 'grandchild', 'notes.md'), '# Nested\n');
+
+    await expect(scanFolderMetadata(root, { deep: true })).resolves.toMatchInlineSnapshot(`
+      "# Folder Metadata
+
+      <folder path=".">
+      <file path="root.ts">
+      - const rootValue
+      </file>
+      <omitted_files>
+      - asset.png
+      </omitted_files>
+      <folder path="/child">
+      <file path="child.py">
+      - function child_function
+      </file>
+      <omitted_files>
+      - data.json
+      </omitted_files>
+      <folder path="/child/grandchild">
+      <file path="notes.md">
+      - h1 Nested
+      </file>
+      </folder>
+      </folder>
+      </folder>
+      "
+    `);
+  });
 });
 
 describe('generated folder metadata', () => {
@@ -94,7 +148,7 @@ describe('generated folder metadata', () => {
 
     expect(result.path).toBe(path.join(root, GENERATED_META_FILE));
     await expect(readFile(result.path, 'utf8')).resolves.toBe(result.content);
-    expect(result.content).toContain('<file path="README.md" kind="markdown">');
+    expect(result.content).toContain('<file path="README.md">');
   });
 
   test('view prints existing metadata, generating it when missing', async () => {
@@ -123,7 +177,8 @@ describe('generated folder metadata', () => {
     expect(shallow).toContain('rootValue');
     expect(shallow).not.toContain('childValue');
     expect(deep).toContain('rootValue');
-    expect(deep).toContain('child/child.ts');
+    expect(deep).toContain('<folder path="/child">');
+    expect(deep).toContain('<file path="child.ts">');
     expect(deep).toContain('childValue');
   });
 });
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 722a08d..5c1a8a1 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -16,6 +16,13 @@ type FileSummary = {
   items: string[];
 };
 
+type FolderSummary = {
+  path: string;
+  files: FileSummary[];
+  folders: FolderSummary[];
+  omittedFiles: string[];
+};
+
 const SKIP_DIRS = new Set([
   '.git',
   '.next',
@@ -29,15 +36,9 @@ const SKIP_FILES = new Set([GENERATED_META_FILE]);
 
 export async function scanFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
   const root = path.resolve(folder);
-  const summaries = await collectFileSummaries(root, root, options.deep === true);
+  const summary = await collectFolderSummary(root, root, options.deep === true);
 
-  const lines = ['# Folder Metadata', '', '<folder path=".">'];
-  for (const summary of summaries) {
-    lines.push(`<file path="${escapeAttribute(summary.path)}" kind="${summary.kind}">`);
-    for (const item of summary.items) lines.push(`- ${item}`);
-    lines.push('</file>');
-  }
-  lines.push('</folder>', '');
+  const lines = ['# Folder Metadata', '', ...renderFolderSummary(summary), ''];
   return lines.join('\n');
 }
 
@@ -64,13 +65,15 @@ export async function viewFolderMetadata(folder: string, options: ScanOptions =
   return (await generateFolderMetadata(root, options)).content;
 }
 
-async function collectFileSummaries(
+async function collectFolderSummary(
   root: string,
   dir: string,
   deep: boolean,
-): Promise<FileSummary[]> {
+): Promise<FolderSummary> {
   const entries = await readdir(dir, { withFileTypes: true });
-  const summaries: FileSummary[] = [];
+  const files: FileSummary[] = [];
+  const folders: FolderSummary[] = [];
+  const omittedFiles: string[] = [];
 
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     const fullPath = path.join(dir, entry.name);
@@ -78,35 +81,78 @@ async function collectFileSummaries(
 
     if (entry.isDirectory()) {
       if (!deep || shouldSkipDirectory(entry.name)) continue;
-      summaries.push(...(await collectFileSummaries(root, fullPath, deep)));
+      folders.push(await collectFolderSummary(root, fullPath, deep));
       continue;
     }
     if (!entry.isFile() || shouldSkipFile(entry.name)) continue;
 
     const summary = await summarizeFile(root, fullPath);
-    if (summary) summaries.push(summary);
+    if (summary) {
+      files.push(summary);
+    } else {
+      omittedFiles.push(entry.name);
+    }
+  }
+
+  return {
+    path: formatFolderPath(root, dir),
+    files: files.sort((a, b) => a.path.localeCompare(b.path)),
+    folders: folders.sort((a, b) => a.path.localeCompare(b.path)),
+    omittedFiles: omittedFiles.sort((a, b) => a.localeCompare(b)),
+  };
+}
+
+function formatFolderPath(root: string, dir: string): string {
+  const relativePath = toPosix(path.relative(root, dir));
+  return relativePath ? `/${relativePath}` : '.';
+}
+
+function renderFolderSummary(summary: FolderSummary): string[] {
+  const lines = [`<folder path="${escapeAttribute(summary.path)}">`];
+
+  for (const file of summary.files) {
+    lines.push(`<file path="${escapeAttribute(path.basename(file.path))}">`);
+    for (const item of file.items) lines.push(`- ${item}`);
+    lines.push('</file>');
+  }
+
+  if (summary.omittedFiles.length > 0) {
+    lines.push('<omitted_files>');
+    for (const omittedFile of summary.omittedFiles) {
+      lines.push(`- ${escapeText(omittedFile)}`);
+    }
+    lines.push('</omitted_files>');
   }
 
-  return summaries.sort((a, b) => a.path.localeCompare(b.path));
+  for (const folder of summary.folders) lines.push(...renderFolderSummary(folder));
+
+  lines.push('</folder>');
+  return lines;
 }
 
 async function summarizeFile(root: string, fullPath: string): Promise<FileSummary | null> {
   const extension = path.extname(fullPath);
   const relativePath = toPosix(path.relative(root, fullPath));
-  const text = await readFile(fullPath, 'utf8');
 
   if (extension === '.md' || extension === '.mdx') {
+    const text = await readFile(fullPath, 'utf8');
     return { path: relativePath, kind: 'markdown', items: extractMarkdownHeadings(text) };
   }
-  if (['.ts', '.tsx', '.mts', '.cts'].includes(extension) && !fullPath.endsWith('.d.ts')) {
+  if (isTypeScriptLikeFile(extension, fullPath)) {
+    const text = await readFile(fullPath, 'utf8');
     return { path: relativePath, kind: 'typescript', items: extractTypeScriptSymbols(text) };
   }
   if (extension === '.py') {
+    const text = await readFile(fullPath, 'utf8');
     return { path: relativePath, kind: 'python', items: extractPythonSymbols(text) };
   }
   return null;
 }
 
+function isTypeScriptLikeFile(extension: string, fullPath: string): boolean {
+  return ['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs'].includes(extension) && !fullPath.endsWith('.d.ts');
+}
+
 function extractMarkdownHeadings(text: string): string[] {
   return text
     .split(/\r?\n/)
@@ -178,6 +224,10 @@ function escapeAttribute(value: string): string {
   return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
 }
 
+function escapeText(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+}
+
 async function isGitIgnored(root: string, fullPath: string): Promise<boolean> {
   const relativePath = toPosix(path.relative(root, fullPath));
   if (!relativePath || relativePath.startsWith('..')) return false;

From bca5af3e3cc93e33ae030a892216e053c201aee3 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 15:51:55 +0100
Subject: [PATCH 44/72] Version @davstack/meta to 0.1.1

Add the 0.1.1 changelog entry for the folder metadata XML output changes and bump @davstack/meta from 0.1.0 to 0.1.1.
---
 packages/meta/CHANGELOG.md | 7 +++++++
 packages/meta/package.json | 2 +-
 2 files changed, 8 insertions(+), 1 deletion(-)
 create mode 100644 packages/meta/CHANGELOG.md

diff --git a/packages/meta/CHANGELOG.md b/packages/meta/CHANGELOG.md
new file mode 100644
index 0000000..3252726
--- /dev/null
+++ b/packages/meta/CHANGELOG.md
@@ -0,0 +1,7 @@
+# @davstack/meta
+
+## 0.1.1
+
+### Patch Changes
+
+- Update folder metadata XML output to omit file kinds, nest deep folder tags with root-relative paths, report unsupported files per folder, and summarize JS/MJS files like TypeScript.
diff --git a/packages/meta/package.json b/packages/meta/package.json
index 54bd398..935e30f 100644
--- a/packages/meta/package.json
+++ b/packages/meta/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/meta",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "type": "module",
   "description": "Generate concise folder metadata for agents.",

From 50f1d6beb95f5e3930575b494eca185f31214072 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 16:17:09 +0100
Subject: [PATCH 45/72] Release meta symbol line numbers

Add line numbers to TypeScript-like and Python symbol summaries while preserving comment-stripped locations. Render omitted files after nested folders so each folder block ends with unsupported files, and publish this as @davstack/meta 0.1.2.
---
 packages/meta/CHANGELOG.md           |  6 +++++
 packages/meta/__tests__/meta.test.ts | 36 ++++++++++++++--------------
 packages/meta/package.json           |  2 +-
 packages/meta/src/index.ts           | 30 ++++++++++++++++-------
 4 files changed, 47 insertions(+), 27 deletions(-)

diff --git a/packages/meta/CHANGELOG.md b/packages/meta/CHANGELOG.md
index 3252726..b7e64ab 100644
--- a/packages/meta/CHANGELOG.md
+++ b/packages/meta/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/meta
 
+## 0.1.2
+
+### Patch Changes
+
+- Add line numbers to code symbol references and render omitted files at the bottom of each folder block.
+
 ## 0.1.1
 
 ### Patch Changes
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index 5926124..9af6cb9 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -39,16 +39,16 @@ describe('scanFolderMetadata', () => {
       - h2 Details
       </file>
       <file path="sample.py">
-      - const CONSTANT
-      - class Worker
-      - function run
+      - const CONSTANT line 1
+      - class Worker line 3
+      - function run line 6
       </file>
       <file path="tools.ts">
-      - class LocalThing
-      - interface Config
-      - type Mode
-      - const value
-      - function build
+      - class LocalThing line 5
+      - interface Config line 1
+      - type Mode line 2
+      - const value line 3
+      - function build line 4
       </file>
       </folder>
       "
@@ -95,9 +95,9 @@ describe('scanFolderMetadata', () => {
     expect(metadata).toContain('<file path="component.mdx">');
     expect(metadata).toContain('- h1 Component');
     expect(metadata).toContain('<file path="script.js">');
-    expect(metadata).toContain('- function boot');
+    expect(metadata).toContain('- function boot line 1');
     expect(metadata).toContain('<file path="module.mjs">');
-    expect(metadata).toContain('- const mode');
+    expect(metadata).toContain('- const mode line 1');
     expect(metadata).not.toContain('omitted_files');
   });
 
@@ -115,24 +115,24 @@ describe('scanFolderMetadata', () => {
 
       <folder path=".">
       <file path="root.ts">
-      - const rootValue
+      - const rootValue line 1
       </file>
-      <omitted_files>
-      - asset.png
-      </omitted_files>
       <folder path="/child">
       <file path="child.py">
-      - function child_function
+      - function child_function line 1
       </file>
-      <omitted_files>
-      - data.json
-      </omitted_files>
       <folder path="/child/grandchild">
       <file path="notes.md">
       - h1 Nested
       </file>
       </folder>
+      <omitted_files>
+      - data.json
+      </omitted_files>
       </folder>
+      <omitted_files>
+      - asset.png
+      </omitted_files>
       </folder>
       "
     `);
diff --git a/packages/meta/package.json b/packages/meta/package.json
index 935e30f..976932f 100644
--- a/packages/meta/package.json
+++ b/packages/meta/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/meta",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
   "description": "Generate concise folder metadata for agents.",
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 5c1a8a1..a1e00d5 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -116,6 +116,8 @@ function renderFolderSummary(summary: FolderSummary): string[] {
     lines.push('</file>');
   }
 
+  for (const folder of summary.folders) lines.push(...renderFolderSummary(folder));
+
   if (summary.omittedFiles.length > 0) {
     lines.push('<omitted_files>');
     for (const omittedFile of summary.omittedFiles) {
@@ -124,8 +126,6 @@ function renderFolderSummary(summary: FolderSummary): string[] {
     lines.push('</omitted_files>');
   }
 
-  for (const folder of summary.folders) lines.push(...renderFolderSummary(folder));
-
   lines.push('</folder>');
   return lines;
 }
@@ -176,26 +176,30 @@ function extractTypeScriptSymbols(text: string): string[] {
   ];
 
   for (const [pattern, label] of patterns) {
-    for (const match of source.matchAll(pattern)) items.push(`${label} ${match[1]}`);
+    for (const match of source.matchAll(pattern)) {
+      items.push(`${label} ${match[1]} line ${lineNumberAt(source, match.index ?? 0)}`);
+    }
   }
   return unique(items);
 }
 
 function extractPythonSymbols(text: string): string[] {
   const items: string[] = [];
-  for (const line of text.split(/\r?\n/)) {
+  const lines = text.split(/\r?\n/);
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
     let match = /^class\s+([A-Za-z_]\w*)\s*[:(]/.exec(line);
     if (match) {
-      items.push(`class ${match[1]}`);
+      items.push(`class ${match[1]} line ${lineNumber}`);
       continue;
     }
     match = /^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/.exec(line);
     if (match) {
-      items.push(`function ${match[1]}`);
+      items.push(`function ${match[1]} line ${lineNumber}`);
       continue;
     }
     match = /^([A-Z][A-Z0-9_]*)\s*[:=]/.exec(line);
-    if (match) items.push(`const ${match[1]}`);
+    if (match) items.push(`const ${match[1]} line ${lineNumber}`);
   }
   return unique(items);
 }
@@ -209,13 +213,23 @@ function shouldSkipFile(name: string): boolean {
 }
 
 function stripBlockComments(text: string): string {
-  return text.replace(/\/\*[\s\S]*?\*\//g, '');
+  return text.replace(/\/\*[\s\S]*?\*\//g, (comment) =>
+    comment.replace(/[^\r\n]/g, ' '),
+  );
 }
 
 function unique(items: string[]): string[] {
   return Array.from(new Set(items));
 }
 
+function lineNumberAt(text: string, index: number): number {
+  let lineNumber = 1;
+  for (let offset = 0; offset < index; offset += 1) {
+    if (text.charCodeAt(offset) === 10) lineNumber += 1;
+  }
+  return lineNumber;
+}
+
 function toPosix(value: string): string {
   return value.split(path.sep).join('/');
 }

From f988e55661e762c5c6345717d4083e20d1cb1274 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 17:28:04 +0100
Subject: [PATCH 46/72] Release repo-relative meta ranges

Render file paths relative to the Git repository root and format code symbol references as [ln start-end] ranges. Update tests for nested folder paths and release @davstack/meta 0.1.3.
---
 packages/meta/CHANGELOG.md           |   6 ++
 packages/meta/__tests__/cli.test.ts  |   2 +-
 packages/meta/__tests__/meta.test.ts |  34 ++++-----
 packages/meta/package.json           |   2 +-
 packages/meta/src/index.ts           | 103 ++++++++++++++++++++++++---
 5 files changed, 118 insertions(+), 29 deletions(-)

diff --git a/packages/meta/CHANGELOG.md b/packages/meta/CHANGELOG.md
index b7e64ab..5e9f51b 100644
--- a/packages/meta/CHANGELOG.md
+++ b/packages/meta/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/meta
 
+## 0.1.3
+
+### Patch Changes
+
+- Format code symbol references with repo-relative file paths and `[ln start-end]` line ranges.
+
 ## 0.1.2
 
 ### Patch Changes
diff --git a/packages/meta/__tests__/cli.test.ts b/packages/meta/__tests__/cli.test.ts
index 1f278ae..1f69593 100644
--- a/packages/meta/__tests__/cli.test.ts
+++ b/packages/meta/__tests__/cli.test.ts
@@ -42,7 +42,7 @@ describe('davstack-meta CLI', () => {
     const output = log.mock.calls.map(([value]) => String(value)).join('\n');
     expect(output).toContain('h1 Root');
     expect(output).toContain('<folder path="/child">');
-    expect(output).toContain('<file path="child.ts">');
+    expect(output).toContain('<file path="child/child.ts">');
     expect(output).toContain('childValue');
   });
 });
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index 9af6cb9..df05734 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -39,16 +39,16 @@ describe('scanFolderMetadata', () => {
       - h2 Details
       </file>
       <file path="sample.py">
-      - const CONSTANT line 1
-      - class Worker line 3
-      - function run line 6
+      - [ln 1] const CONSTANT
+      - [ln 3-4] class Worker
+      - [ln 6-7] function run
       </file>
       <file path="tools.ts">
-      - class LocalThing line 5
-      - interface Config line 1
-      - type Mode line 2
-      - const value line 3
-      - function build line 4
+      - [ln 5] class LocalThing
+      - [ln 1] interface Config
+      - [ln 2] type Mode
+      - [ln 3] const value
+      - [ln 4] function build
       </file>
       </folder>
       "
@@ -87,17 +87,17 @@ describe('scanFolderMetadata', () => {
   test('summarizes js, mjs, and mdx files with existing extractors', async () => {
     const root = await makeTempFolder();
     await writeFile(path.join(root, 'component.mdx'), '# Component\n');
-    await writeFile(path.join(root, 'script.js'), 'export function boot() {}\n');
-    await writeFile(path.join(root, 'module.mjs'), 'export const mode = "esm"\n');
+    await writeFile(path.join(root, 'script.js'), 'export function boot() {\n  return true\n}\n');
+    await writeFile(path.join(root, 'module.mjs'), 'export const mode = {\n  format: "esm"\n}\n');
 
     const metadata = await scanFolderMetadata(root);
 
     expect(metadata).toContain('<file path="component.mdx">');
     expect(metadata).toContain('- h1 Component');
     expect(metadata).toContain('<file path="script.js">');
-    expect(metadata).toContain('- function boot line 1');
+    expect(metadata).toContain('- [ln 1-3] function boot');
     expect(metadata).toContain('<file path="module.mjs">');
-    expect(metadata).toContain('- const mode line 1');
+    expect(metadata).toContain('- [ln 1-3] const mode');
     expect(metadata).not.toContain('omitted_files');
   });
 
@@ -115,14 +115,14 @@ describe('scanFolderMetadata', () => {
 
       <folder path=".">
       <file path="root.ts">
-      - const rootValue line 1
+      - [ln 1] const rootValue
       </file>
       <folder path="/child">
-      <file path="child.py">
-      - function child_function line 1
+      <file path="child/child.py">
+      - [ln 1-2] function child_function
       </file>
       <folder path="/child/grandchild">
-      <file path="notes.md">
+      <file path="child/grandchild/notes.md">
       - h1 Nested
       </file>
       </folder>
@@ -178,7 +178,7 @@ describe('generated folder metadata', () => {
     expect(shallow).not.toContain('childValue');
     expect(deep).toContain('rootValue');
     expect(deep).toContain('<folder path="/child">');
-    expect(deep).toContain('<file path="child.ts">');
+    expect(deep).toContain('<file path="child/child.ts">');
     expect(deep).toContain('childValue');
   });
 });
diff --git a/packages/meta/package.json b/packages/meta/package.json
index 976932f..2fb8029 100644
--- a/packages/meta/package.json
+++ b/packages/meta/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/meta",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "MIT",
   "type": "module",
   "description": "Generate concise folder metadata for agents.",
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index a1e00d5..ca299b2 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -36,7 +36,8 @@ const SKIP_FILES = new Set([GENERATED_META_FILE]);
 
 export async function scanFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
   const root = path.resolve(folder);
-  const summary = await collectFolderSummary(root, root, options.deep === true);
+  const repoRoot = await findRepoRoot(root);
+  const summary = await collectFolderSummary(root, repoRoot, root, options.deep === true);
 
   const lines = ['# Folder Metadata', '', ...renderFolderSummary(summary), ''];
   return lines.join('\n');
@@ -67,6 +68,7 @@ export async function viewFolderMetadata(folder: string, options: ScanOptions =
 
 async function collectFolderSummary(
   root: string,
+  repoRoot: string,
   dir: string,
   deep: boolean,
 ): Promise<FolderSummary> {
@@ -81,12 +83,12 @@ async function collectFolderSummary(
 
     if (entry.isDirectory()) {
       if (!deep || shouldSkipDirectory(entry.name)) continue;
-      folders.push(await collectFolderSummary(root, fullPath, deep));
+      folders.push(await collectFolderSummary(root, repoRoot, fullPath, deep));
       continue;
     }
     if (!entry.isFile() || shouldSkipFile(entry.name)) continue;
 
-    const summary = await summarizeFile(root, fullPath);
+    const summary = await summarizeFile(root, repoRoot, fullPath);
     if (summary) {
       files.push(summary);
     } else {
@@ -111,7 +113,7 @@ function renderFolderSummary(summary: FolderSummary): string[] {
   const lines = [`<folder path="${escapeAttribute(summary.path)}">`];
 
   for (const file of summary.files) {
-    lines.push(`<file path="${escapeAttribute(path.basename(file.path))}">`);
+    lines.push(`<file path="${escapeAttribute(file.path)}">`);
     for (const item of file.items) lines.push(`- ${item}`);
     lines.push('</file>');
   }
@@ -130,9 +132,9 @@ function renderFolderSummary(summary: FolderSummary): string[] {
   return lines;
 }
 
-async function summarizeFile(root: string, fullPath: string): Promise<FileSummary | null> {
+async function summarizeFile(root: string, repoRoot: string, fullPath: string): Promise<FileSummary | null> {
   const extension = path.extname(fullPath);
-  const relativePath = toPosix(path.relative(root, fullPath));
+  const relativePath = formatFilePath(root, repoRoot, fullPath);
 
   if (extension === '.md' || extension === '.mdx') {
     const text = await readFile(fullPath, 'utf8');
@@ -177,7 +179,8 @@ function extractTypeScriptSymbols(text: string): string[] {
 
   for (const [pattern, label] of patterns) {
     for (const match of source.matchAll(pattern)) {
-      items.push(`${label} ${match[1]} line ${lineNumberAt(source, match.index ?? 0)}`);
+      const range = lineRangeForTypeScriptSymbol(source, match.index ?? 0);
+      items.push(`${formatLineRange(range)} ${label} ${match[1]}`);
     }
   }
   return unique(items);
@@ -190,16 +193,16 @@ function extractPythonSymbols(text: string): string[] {
     const lineNumber = index + 1;
     let match = /^class\s+([A-Za-z_]\w*)\s*[:(]/.exec(line);
     if (match) {
-      items.push(`class ${match[1]} line ${lineNumber}`);
+      items.push(`${formatLineRange(lineRangeForPythonBlock(lines, index))} class ${match[1]}`);
       continue;
     }
     match = /^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/.exec(line);
     if (match) {
-      items.push(`function ${match[1]} line ${lineNumber}`);
+      items.push(`${formatLineRange(lineRangeForPythonBlock(lines, index))} function ${match[1]}`);
       continue;
     }
     match = /^([A-Z][A-Z0-9_]*)\s*[:=]/.exec(line);
-    if (match) items.push(`const ${match[1]} line ${lineNumber}`);
+    if (match) items.push(`${formatLineRange({ start: lineNumber, end: lineNumber })} const ${match[1]}`);
   }
   return unique(items);
 }
@@ -230,6 +233,77 @@ function lineNumberAt(text: string, index: number): number {
   return lineNumber;
 }
 
+function lineRangeForTypeScriptSymbol(text: string, index: number): { start: number; end: number } {
+  const start = lineNumberAt(text, index);
+  const lineEnd = text.indexOf('\n', index);
+  const declarationEnd = lineEnd === -1 ? text.length : lineEnd;
+  const openingBrace = text.indexOf('{', index);
+
+  if (openingBrace !== -1 && openingBrace < declarationEnd) {
+    const closingBrace = findMatchingBrace(text, openingBrace);
+    if (closingBrace !== -1) return { start, end: lineNumberAt(text, closingBrace) };
+  }
+
+  const semicolon = text.indexOf(';', index);
+  if (semicolon !== -1 && semicolon < declarationEnd) {
+    return { start, end: lineNumberAt(text, semicolon) };
+  }
+
+  return { start, end: start };
+}
+
+function findMatchingBrace(text: string, openingBrace: number): number {
+  let depth = 0;
+  for (let index = openingBrace; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '{') depth += 1;
+    if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function lineRangeForPythonBlock(
+  lines: string[],
+  startIndex: number,
+): { start: number; end: number } {
+  const startIndent = indentationLength(lines[startIndex] ?? '');
+  let endIndex = startIndex;
+
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? '';
+    if (line.trim() === '') {
+      endIndex = index;
+      continue;
+    }
+    if (indentationLength(line) <= startIndent) break;
+    endIndex = index;
+  }
+
+  while (endIndex > startIndex && (lines[endIndex] ?? '').trim() === '') endIndex -= 1;
+  return { start: startIndex + 1, end: endIndex + 1 };
+}
+
+function indentationLength(line: string): number {
+  return line.match(/^\s*/)?.[0].length ?? 0;
+}
+
+function formatLineRange(range: { start: number; end: number }): string {
+  return range.start === range.end ? `[ln ${range.start}]` : `[ln ${range.start}-${range.end}]`;
+}
+
+function formatFilePath(root: string, repoRoot: string, fullPath: string): string {
+  const base = isInsidePath(repoRoot, fullPath) ? repoRoot : root;
+  return toPosix(path.relative(base, fullPath));
+}
+
+function isInsidePath(parent: string, child: string): boolean {
+  const relativePath = path.relative(parent, child);
+  return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+
 function toPosix(value: string): string {
   return value.split(path.sep).join('/');
 }
@@ -255,3 +329,12 @@ async function isGitIgnored(root: string, fullPath: string): Promise<boolean> {
     return false;
   }
 }
+
+async function findRepoRoot(root: string): Promise<string> {
+  try {
+    const { stdout } = await execFileAsync('git', ['-C', root, 'rev-parse', '--show-toplevel']);
+    return path.resolve(stdout.trim());
+  } catch {
+    return root;
+  }
+}

From e08918a84e9541c9ba3afb58761a4e9176bef51e Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 17:30:17 +0100
Subject: [PATCH 47/72] Align meta folder paths with repo paths

Render folder paths relative to the Git repository root using the same convention as file paths, including parent segments for nested folders. Add coverage for scanning a nested Git worktree folder.
---
 packages/meta/__tests__/cli.test.ts  |  2 +-
 packages/meta/__tests__/meta.test.ts | 27 ++++++++++++++++++++++++---
 packages/meta/src/index.ts           |  9 +++++----
 3 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/packages/meta/__tests__/cli.test.ts b/packages/meta/__tests__/cli.test.ts
index 1f69593..6b603fa 100644
--- a/packages/meta/__tests__/cli.test.ts
+++ b/packages/meta/__tests__/cli.test.ts
@@ -41,7 +41,7 @@ describe('davstack-meta CLI', () => {
     expect(code).toBe(0);
     const output = log.mock.calls.map(([value]) => String(value)).join('\n');
     expect(output).toContain('h1 Root');
-    expect(output).toContain('<folder path="/child">');
+    expect(output).toContain('<folder path="child">');
     expect(output).toContain('<file path="child/child.ts">');
     expect(output).toContain('childValue');
   });
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index df05734..e082d57 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -117,11 +117,11 @@ describe('scanFolderMetadata', () => {
       <file path="root.ts">
       - [ln 1] const rootValue
       </file>
-      <folder path="/child">
+      <folder path="child">
       <file path="child/child.py">
       - [ln 1-2] function child_function
       </file>
-      <folder path="/child/grandchild">
+      <folder path="child/grandchild">
       <file path="child/grandchild/notes.md">
       - h1 Nested
       </file>
@@ -137,6 +137,27 @@ describe('scanFolderMetadata', () => {
       "
     `);
   });
+
+  test('uses git repo relative paths when scanning a nested folder', async () => {
+    const root = await makeTempFolder();
+    await execFileAsync('git', ['init'], { cwd: root });
+    const scanRoot = path.join(root, 'apps', 'web');
+    await mkdir(path.join(scanRoot, 'src'), { recursive: true });
+    await writeFile(path.join(scanRoot, 'src', 'widget.ts'), 'export class Widget {}\n');
+
+    await expect(scanFolderMetadata(scanRoot, { deep: true })).resolves.toMatchInlineSnapshot(`
+      "# Folder Metadata
+
+      <folder path="apps/web">
+      <folder path="apps/web/src">
+      <file path="apps/web/src/widget.ts">
+      - [ln 1] class Widget
+      </file>
+      </folder>
+      </folder>
+      "
+    `);
+  });
 });
 
 describe('generated folder metadata', () => {
@@ -177,7 +198,7 @@ describe('generated folder metadata', () => {
     expect(shallow).toContain('rootValue');
     expect(shallow).not.toContain('childValue');
     expect(deep).toContain('rootValue');
-    expect(deep).toContain('<folder path="/child">');
+    expect(deep).toContain('<folder path="child">');
     expect(deep).toContain('<file path="child/child.ts">');
     expect(deep).toContain('childValue');
   });
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index ca299b2..8391033 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -97,16 +97,17 @@ async function collectFolderSummary(
   }
 
   return {
-    path: formatFolderPath(root, dir),
+    path: formatFolderPath(root, repoRoot, dir),
     files: files.sort((a, b) => a.path.localeCompare(b.path)),
     folders: folders.sort((a, b) => a.path.localeCompare(b.path)),
     omittedFiles: omittedFiles.sort((a, b) => a.localeCompare(b)),
   };
 }
 
-function formatFolderPath(root: string, dir: string): string {
-  const relativePath = toPosix(path.relative(root, dir));
-  return relativePath ? `/${relativePath}` : '.';
+function formatFolderPath(root: string, repoRoot: string, dir: string): string {
+  const base = isInsidePath(repoRoot, dir) ? repoRoot : root;
+  const relativePath = toPosix(path.relative(base, dir));
+  return relativePath || '.';
 }
 
 function renderFolderSummary(summary: FolderSummary): string[] {

From 0d29e67cefb8643b1dc4fea04fe370a451c9c6dd Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 17:31:40 +0100
Subject: [PATCH 48/72] Indent meta XML output

Render nested folder metadata with tab indentation so folders, files, symbol bullets, and omitted-file entries visually reflect the XML hierarchy.
---
 packages/meta/__tests__/meta.test.ts | 80 ++++++++++++++--------------
 packages/meta/src/index.ts           | 23 ++++----
 2 files changed, 53 insertions(+), 50 deletions(-)

diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index e082d57..ed3c5de 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -34,22 +34,22 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path=".">
-      <file path="notes.md">
-      - h1 Overview
-      - h2 Details
-      </file>
-      <file path="sample.py">
-      - [ln 1] const CONSTANT
-      - [ln 3-4] class Worker
-      - [ln 6-7] function run
-      </file>
-      <file path="tools.ts">
-      - [ln 5] class LocalThing
-      - [ln 1] interface Config
-      - [ln 2] type Mode
-      - [ln 3] const value
-      - [ln 4] function build
-      </file>
+      	<file path="notes.md">
+      		- h1 Overview
+      		- h2 Details
+      	</file>
+      	<file path="sample.py">
+      		- [ln 1] const CONSTANT
+      		- [ln 3-4] class Worker
+      		- [ln 6-7] function run
+      	</file>
+      	<file path="tools.ts">
+      		- [ln 5] class LocalThing
+      		- [ln 1] interface Config
+      		- [ln 2] type Mode
+      		- [ln 3] const value
+      		- [ln 4] function build
+      	</file>
       </folder>
       "
     `);
@@ -114,25 +114,25 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path=".">
-      <file path="root.ts">
-      - [ln 1] const rootValue
-      </file>
-      <folder path="child">
-      <file path="child/child.py">
-      - [ln 1-2] function child_function
-      </file>
-      <folder path="child/grandchild">
-      <file path="child/grandchild/notes.md">
-      - h1 Nested
-      </file>
-      </folder>
-      <omitted_files>
-      - data.json
-      </omitted_files>
-      </folder>
-      <omitted_files>
-      - asset.png
-      </omitted_files>
+      	<file path="root.ts">
+      		- [ln 1] const rootValue
+      	</file>
+      	<folder path="child">
+      		<file path="child/child.py">
+      			- [ln 1-2] function child_function
+      		</file>
+      		<folder path="child/grandchild">
+      			<file path="child/grandchild/notes.md">
+      				- h1 Nested
+      			</file>
+      		</folder>
+      		<omitted_files>
+      			- data.json
+      		</omitted_files>
+      	</folder>
+      	<omitted_files>
+      		- asset.png
+      	</omitted_files>
       </folder>
       "
     `);
@@ -149,11 +149,11 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path="apps/web">
-      <folder path="apps/web/src">
-      <file path="apps/web/src/widget.ts">
-      - [ln 1] class Widget
-      </file>
-      </folder>
+      	<folder path="apps/web/src">
+      		<file path="apps/web/src/widget.ts">
+      			- [ln 1] class Widget
+      		</file>
+      	</folder>
       </folder>
       "
     `);
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 8391033..9a31129 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -110,26 +110,29 @@ function formatFolderPath(root: string, repoRoot: string, dir: string): string {
   return relativePath || '.';
 }
 
-function renderFolderSummary(summary: FolderSummary): string[] {
-  const lines = [`<folder path="${escapeAttribute(summary.path)}">`];
+function renderFolderSummary(summary: FolderSummary, depth = 0): string[] {
+  const indent = '\t'.repeat(depth);
+  const childIndent = '\t'.repeat(depth + 1);
+  const itemIndent = '\t'.repeat(depth + 2);
+  const lines = [`${indent}<folder path="${escapeAttribute(summary.path)}">`];
 
   for (const file of summary.files) {
-    lines.push(`<file path="${escapeAttribute(file.path)}">`);
-    for (const item of file.items) lines.push(`- ${item}`);
-    lines.push('</file>');
+    lines.push(`${childIndent}<file path="${escapeAttribute(file.path)}">`);
+    for (const item of file.items) lines.push(`${itemIndent}- ${item}`);
+    lines.push(`${childIndent}</file>`);
   }
 
-  for (const folder of summary.folders) lines.push(...renderFolderSummary(folder));
+  for (const folder of summary.folders) lines.push(...renderFolderSummary(folder, depth + 1));
 
   if (summary.omittedFiles.length > 0) {
-    lines.push('<omitted_files>');
+    lines.push(`${childIndent}<omitted_files>`);
     for (const omittedFile of summary.omittedFiles) {
-      lines.push(`- ${escapeText(omittedFile)}`);
+      lines.push(`${itemIndent}- ${escapeText(omittedFile)}`);
     }
-    lines.push('</omitted_files>');
+    lines.push(`${childIndent}</omitted_files>`);
   }
 
-  lines.push('</folder>');
+  lines.push(`${indent}</folder>`);
   return lines;
 }
 

From 0aae4717251407e6c686e98d28ed63fa81ceee2c Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 17:45:44 +0100
Subject: [PATCH 49/72] Release refined meta indentation

Adjust folder metadata indentation so root-level children stay flush-left while nested folder contents indent by folder depth. Render code symbol references without list prefixes, keep markdown headings and omitted files as list entries, and release @davstack/meta 0.1.4.
---
 packages/meta/CHANGELOG.md           |  6 +++
 packages/meta/__tests__/meta.test.ts | 74 ++++++++++++++--------------
 packages/meta/package.json           |  2 +-
 packages/meta/src/index.ts           | 12 +++--
 4 files changed, 51 insertions(+), 43 deletions(-)

diff --git a/packages/meta/CHANGELOG.md b/packages/meta/CHANGELOG.md
index 5e9f51b..ca6e350 100644
--- a/packages/meta/CHANGELOG.md
+++ b/packages/meta/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/meta
 
+## 0.1.4
+
+### Patch Changes
+
+- Refine folder metadata indentation and render code symbol line references without list prefixes.
+
 ## 0.1.3
 
 ### Patch Changes
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index ed3c5de..25c3957 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -34,22 +34,22 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path=".">
-      	<file path="notes.md">
-      		- h1 Overview
-      		- h2 Details
-      	</file>
-      	<file path="sample.py">
-      		- [ln 1] const CONSTANT
-      		- [ln 3-4] class Worker
-      		- [ln 6-7] function run
-      	</file>
-      	<file path="tools.ts">
-      		- [ln 5] class LocalThing
-      		- [ln 1] interface Config
-      		- [ln 2] type Mode
-      		- [ln 3] const value
-      		- [ln 4] function build
-      	</file>
+      <file path="notes.md">
+      - h1 Overview
+      - h2 Details
+      </file>
+      <file path="sample.py">
+      [ln 1] const CONSTANT
+      [ln 3-4] class Worker
+      [ln 6-7] function run
+      </file>
+      <file path="tools.ts">
+      [ln 5] class LocalThing
+      [ln 1] interface Config
+      [ln 2] type Mode
+      [ln 3] const value
+      [ln 4] function build
+      </file>
       </folder>
       "
     `);
@@ -95,9 +95,9 @@ describe('scanFolderMetadata', () => {
     expect(metadata).toContain('<file path="component.mdx">');
     expect(metadata).toContain('- h1 Component');
     expect(metadata).toContain('<file path="script.js">');
-    expect(metadata).toContain('- [ln 1-3] function boot');
+    expect(metadata).toContain('[ln 1-3] function boot');
     expect(metadata).toContain('<file path="module.mjs">');
-    expect(metadata).toContain('- [ln 1-3] const mode');
+    expect(metadata).toContain('[ln 1-3] const mode');
     expect(metadata).not.toContain('omitted_files');
   });
 
@@ -114,26 +114,26 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path=".">
-      	<file path="root.ts">
-      		- [ln 1] const rootValue
+      <file path="root.ts">
+      [ln 1] const rootValue
+      </file>
+      <folder path="child">
+      	<file path="child/child.py">
+      	[ln 1-2] function child_function
       	</file>
-      	<folder path="child">
-      		<file path="child/child.py">
-      			- [ln 1-2] function child_function
+      	<folder path="child/grandchild">
+      		<file path="child/grandchild/notes.md">
+      		- h1 Nested
       		</file>
-      		<folder path="child/grandchild">
-      			<file path="child/grandchild/notes.md">
-      				- h1 Nested
-      			</file>
-      		</folder>
-      		<omitted_files>
-      			- data.json
-      		</omitted_files>
       	</folder>
       	<omitted_files>
-      		- asset.png
+      	- data.json
       	</omitted_files>
       </folder>
+      <omitted_files>
+      - asset.png
+      </omitted_files>
+      </folder>
       "
     `);
   });
@@ -149,11 +149,11 @@ describe('scanFolderMetadata', () => {
       "# Folder Metadata
 
       <folder path="apps/web">
-      	<folder path="apps/web/src">
-      		<file path="apps/web/src/widget.ts">
-      			- [ln 1] class Widget
-      		</file>
-      	</folder>
+      <folder path="apps/web/src">
+      	<file path="apps/web/src/widget.ts">
+      	[ln 1] class Widget
+      	</file>
+      </folder>
       </folder>
       "
     `);
diff --git a/packages/meta/package.json b/packages/meta/package.json
index 2fb8029..4481b77 100644
--- a/packages/meta/package.json
+++ b/packages/meta/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/meta",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "description": "Generate concise folder metadata for agents.",
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 9a31129..481b6e6 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -111,14 +111,16 @@ function formatFolderPath(root: string, repoRoot: string, dir: string): string {
 }
 
 function renderFolderSummary(summary: FolderSummary, depth = 0): string[] {
-  const indent = '\t'.repeat(depth);
-  const childIndent = '\t'.repeat(depth + 1);
-  const itemIndent = '\t'.repeat(depth + 2);
+  const indent = '\t'.repeat(Math.max(0, depth - 1));
+  const childIndent = '\t'.repeat(depth);
   const lines = [`${indent}<folder path="${escapeAttribute(summary.path)}">`];
 
   for (const file of summary.files) {
     lines.push(`${childIndent}<file path="${escapeAttribute(file.path)}">`);
-    for (const item of file.items) lines.push(`${itemIndent}- ${item}`);
+    for (const item of file.items) {
+      const prefix = item.startsWith('[ln ') ? '' : '- ';
+      lines.push(`${childIndent}${prefix}${item}`);
+    }
     lines.push(`${childIndent}</file>`);
   }
 
@@ -127,7 +129,7 @@ function renderFolderSummary(summary: FolderSummary, depth = 0): string[] {
   if (summary.omittedFiles.length > 0) {
     lines.push(`${childIndent}<omitted_files>`);
     for (const omittedFile of summary.omittedFiles) {
-      lines.push(`${itemIndent}- ${escapeText(omittedFile)}`);
+      lines.push(`${childIndent}- ${escapeText(omittedFile)}`);
     }
     lines.push(`${childIndent}</omitted_files>`);
   }

From 139e3831b80cfd6b945023966ccc2a86c421a1be Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 18:24:07 +0100
Subject: [PATCH 50/72] Add meta output presets

Introduce configurable metadata output with human and agent presets. Human output keeps indentation and full repo-relative file paths, while agent output removes indentation and uses concise file paths inside full folder paths. Expose --human, --agent, --indent/--no-indent, and --file_paths through gen/view, with explicit flags overriding preset defaults.
---
 .changeset/meta-output-config.md     |  5 ++
 packages/meta/__tests__/cli.test.ts  | 32 ++++++++++
 packages/meta/__tests__/meta.test.ts | 39 ++++++++++++
 packages/meta/src/cli-spec.ts        | 53 +++++++++++++---
 packages/meta/src/index.ts           | 91 ++++++++++++++++++++++++----
 5 files changed, 200 insertions(+), 20 deletions(-)
 create mode 100644 .changeset/meta-output-config.md

diff --git a/.changeset/meta-output-config.md b/.changeset/meta-output-config.md
new file mode 100644
index 0000000..b3cd33d
--- /dev/null
+++ b/.changeset/meta-output-config.md
@@ -0,0 +1,5 @@
+---
+"@davstack/meta": patch
+---
+
+Add configurable output presets for human-readable and token-optimized folder metadata.
diff --git a/packages/meta/__tests__/cli.test.ts b/packages/meta/__tests__/cli.test.ts
index 6b603fa..daba0bf 100644
--- a/packages/meta/__tests__/cli.test.ts
+++ b/packages/meta/__tests__/cli.test.ts
@@ -45,4 +45,36 @@ describe('davstack-meta CLI', () => {
     expect(output).toContain('<file path="child/child.ts">');
     expect(output).toContain('childValue');
   });
+
+  test('view supports agent preset and explicit output overrides', async () => {
+    const root = await makeTempFolder();
+    await mkdir(path.join(root, 'child'));
+    await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const code = await defineCli(cliSpec).run([
+      'view',
+      root,
+      '--deep',
+      '--agent',
+      '--indent=true',
+      '--file_paths=full',
+    ]);
+
+    expect(code).toBe(0);
+    const output = log.mock.calls.map(([value]) => String(value)).join('\n');
+    expect(output).toContain('\t<file path="child/child.ts">');
+  });
+
+  test('view rejects conflicting output presets', async () => {
+    const root = await makeTempFolder();
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const code = await defineCli(cliSpec).run(['view', root, '--human', '--agent']);
+
+    expect(code).toBe(1);
+    expect(error.mock.calls.map(([value]) => String(value)).join('\n')).toContain(
+      'Use only one output preset',
+    );
+  });
 });
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index 25c3957..74c2562 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -158,6 +158,45 @@ describe('scanFolderMetadata', () => {
       "
     `);
   });
+
+  test('agent preset uses concise file paths and removes indentation', async () => {
+    const root = await makeTempFolder();
+    await execFileAsync('git', ['init'], { cwd: root });
+    const scanRoot = path.join(root, 'packages', 'context-compactor');
+    await mkdir(path.join(scanRoot, '__tests__'), { recursive: true });
+    await writeFile(path.join(scanRoot, '__tests__', 'log.test.ts'), 'export const SAMPLE = true\n');
+
+    await expect(scanFolderMetadata(scanRoot, { deep: true, preset: 'agent' })).resolves.toMatchInlineSnapshot(`
+      "# Folder Metadata
+
+      <folder path="packages/context-compactor">
+      <folder path="packages/context-compactor/__tests__">
+      <file path="/log.test.ts">
+      [ln 1] const SAMPLE
+      </file>
+      </folder>
+      </folder>
+      "
+    `);
+  });
+
+  test('explicit output options override preset defaults', async () => {
+    const root = await makeTempFolder();
+    await execFileAsync('git', ['init'], { cwd: root });
+    const scanRoot = path.join(root, 'packages', 'meta');
+    await mkdir(path.join(scanRoot, 'src'), { recursive: true });
+    await writeFile(path.join(scanRoot, 'src', 'index.ts'), 'export function scan() {}\n');
+
+    const metadata = await scanFolderMetadata(scanRoot, {
+      deep: true,
+      preset: 'agent',
+      indent: true,
+      filePaths: 'full',
+    });
+
+    expect(metadata).toContain('<file path="packages/meta/src/index.ts">');
+    expect(metadata).toContain('\t<file path="packages/meta/src/index.ts">');
+  });
 });
 
 describe('generated folder metadata', () => {
diff --git a/packages/meta/src/cli-spec.ts b/packages/meta/src/cli-spec.ts
index 3689c4a..970cbb8 100644
--- a/packages/meta/src/cli-spec.ts
+++ b/packages/meta/src/cli-spec.ts
@@ -1,4 +1,45 @@
 import type { CliSpec } from '@davstack/cli-utils';
+import type { MetaFilePathMode, MetaOutputPresetName, ScanOptions } from './index.js';
+
+const outputFlags = {
+  human: {
+    type: 'boolean',
+    default: false,
+    description: 'Use human-readable output defaults: indented XML and full repo-relative file paths',
+  },
+  agent: {
+    type: 'boolean',
+    default: false,
+    description: 'Use token-optimized output defaults: no indentation and concise file paths',
+  },
+  indent: {
+    type: 'boolean',
+    description: 'Indent nested folder output',
+  },
+  file_paths: {
+    type: 'string',
+    description: 'File path style: concise or full',
+  },
+} as const;
+
+function resolveCliScanOptions(flags: Record<string, unknown>): ScanOptions {
+  const human = flags.human === true;
+  const agent = flags.agent === true;
+  if (human && agent) throw new Error('Use only one output preset: --human or --agent');
+
+  const preset: MetaOutputPresetName | undefined = agent ? 'agent' : human ? 'human' : undefined;
+  const filePaths = flags.file_paths;
+  if (filePaths !== undefined && filePaths !== 'concise' && filePaths !== 'full') {
+    throw new Error('--file_paths must be "concise" or "full"');
+  }
+
+  return {
+    deep: flags.deep as boolean,
+    preset,
+    indent: flags.indent as boolean | undefined,
+    filePaths: filePaths as MetaFilePathMode | undefined,
+  };
+}
 
 export const cliSpec: CliSpec = {
   name: 'davstack-meta',
@@ -13,12 +54,11 @@ export const cliSpec: CliSpec = {
           default: false,
           description: 'Recursively include child folders',
         },
+        ...outputFlags,
       },
       run: async (ctx) => {
         const { generateFolderMetadata } = await import('./index.js');
-        const result = await generateFolderMetadata(ctx.positionals[0], {
-          deep: ctx.flags.deep as boolean,
-        });
+        const result = await generateFolderMetadata(ctx.positionals[0], resolveCliScanOptions(ctx.flags));
         console.log(result.path);
       },
     },
@@ -31,14 +71,11 @@ export const cliSpec: CliSpec = {
           default: false,
           description: 'Recursively include child folders',
         },
+        ...outputFlags,
       },
       run: async (ctx) => {
         const { viewFolderMetadata } = await import('./index.js');
-        console.log(
-          await viewFolderMetadata(ctx.positionals[0], {
-            deep: ctx.flags.deep as boolean,
-          }),
-        );
+        console.log(await viewFolderMetadata(ctx.positionals[0], resolveCliScanOptions(ctx.flags)));
       },
     },
   },
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 481b6e6..63a2576 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -8,6 +8,10 @@ const execFileAsync = promisify(execFile);
 
 export type ScanOptions = {
   deep?: boolean;
+  preset?: MetaOutputPresetName;
+  indent?: boolean;
+  filePaths?: MetaFilePathMode;
+  file_paths?: MetaFilePathMode;
 };
 
 type FileSummary = {
@@ -16,6 +20,25 @@ type FileSummary = {
   items: string[];
 };
 
+export type MetaFilePathMode = 'concise' | 'full';
+export type MetaOutputPresetName = 'agent' | 'human';
+
+export type MetaOutputConfig = {
+  indent: boolean;
+  filePaths: MetaFilePathMode;
+};
+
+export const META_OUTPUT_PRESETS: Record<MetaOutputPresetName, MetaOutputConfig> = {
+  human: {
+    indent: true,
+    filePaths: 'full',
+  },
+  agent: {
+    indent: false,
+    filePaths: 'concise',
+  },
+};
+
 type FolderSummary = {
   path: string;
   files: FileSummary[];
@@ -37,9 +60,10 @@ const SKIP_FILES = new Set([GENERATED_META_FILE]);
 export async function scanFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
   const root = path.resolve(folder);
   const repoRoot = await findRepoRoot(root);
-  const summary = await collectFolderSummary(root, repoRoot, root, options.deep === true);
+  const outputConfig = resolveOutputConfig(options);
+  const summary = await collectFolderSummary(root, repoRoot, root, options.deep === true, outputConfig);
 
-  const lines = ['# Folder Metadata', '', ...renderFolderSummary(summary), ''];
+  const lines = ['# Folder Metadata', '', ...renderFolderSummary(summary, outputConfig), ''];
   return lines.join('\n');
 }
 
@@ -59,7 +83,7 @@ export async function viewFolderMetadata(folder: string, options: ScanOptions =
   const root = path.resolve(folder);
   const generatedPath = path.join(root, GENERATED_META_FILE);
   try {
-    if (!options.deep) return await readFile(generatedPath, 'utf8');
+    if (!options.deep && !hasOutputOverrides(options)) return await readFile(generatedPath, 'utf8');
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
   }
@@ -71,6 +95,7 @@ async function collectFolderSummary(
   repoRoot: string,
   dir: string,
   deep: boolean,
+  outputConfig: MetaOutputConfig,
 ): Promise<FolderSummary> {
   const entries = await readdir(dir, { withFileTypes: true });
   const files: FileSummary[] = [];
@@ -83,12 +108,12 @@ async function collectFolderSummary(
 
     if (entry.isDirectory()) {
       if (!deep || shouldSkipDirectory(entry.name)) continue;
-      folders.push(await collectFolderSummary(root, repoRoot, fullPath, deep));
+      folders.push(await collectFolderSummary(root, repoRoot, fullPath, deep, outputConfig));
       continue;
     }
     if (!entry.isFile() || shouldSkipFile(entry.name)) continue;
 
-    const summary = await summarizeFile(root, repoRoot, fullPath);
+    const summary = await summarizeFile(root, repoRoot, fullPath, outputConfig);
     if (summary) {
       files.push(summary);
     } else {
@@ -110,9 +135,13 @@ function formatFolderPath(root: string, repoRoot: string, dir: string): string {
   return relativePath || '.';
 }
 
-function renderFolderSummary(summary: FolderSummary, depth = 0): string[] {
-  const indent = '\t'.repeat(Math.max(0, depth - 1));
-  const childIndent = '\t'.repeat(depth);
+function renderFolderSummary(
+  summary: FolderSummary,
+  outputConfig: MetaOutputConfig,
+  depth = 0,
+): string[] {
+  const indent = outputConfig.indent ? '\t'.repeat(Math.max(0, depth - 1)) : '';
+  const childIndent = outputConfig.indent ? '\t'.repeat(depth) : '';
   const lines = [`${indent}<folder path="${escapeAttribute(summary.path)}">`];
 
   for (const file of summary.files) {
@@ -124,7 +153,9 @@ function renderFolderSummary(summary: FolderSummary, depth = 0): string[] {
     lines.push(`${childIndent}</file>`);
   }
 
-  for (const folder of summary.folders) lines.push(...renderFolderSummary(folder, depth + 1));
+  for (const folder of summary.folders) {
+    lines.push(...renderFolderSummary(folder, outputConfig, depth + 1));
+  }
 
   if (summary.omittedFiles.length > 0) {
     lines.push(`${childIndent}<omitted_files>`);
@@ -138,9 +169,14 @@ function renderFolderSummary(summary: FolderSummary, depth = 0): string[] {
   return lines;
 }
 
-async function summarizeFile(root: string, repoRoot: string, fullPath: string): Promise<FileSummary | null> {
+async function summarizeFile(
+  root: string,
+  repoRoot: string,
+  fullPath: string,
+  outputConfig: MetaOutputConfig,
+): Promise<FileSummary | null> {
   const extension = path.extname(fullPath);
-  const relativePath = formatFilePath(root, repoRoot, fullPath);
+  const relativePath = formatFilePath(root, repoRoot, fullPath, outputConfig.filePaths);
 
   if (extension === '.md' || extension === '.mdx') {
     const text = await readFile(fullPath, 'utf8');
@@ -300,11 +336,42 @@ function formatLineRange(range: { start: number; end: number }): string {
   return range.start === range.end ? `[ln ${range.start}]` : `[ln ${range.start}-${range.end}]`;
 }
 
-function formatFilePath(root: string, repoRoot: string, fullPath: string): string {
+function formatFilePath(
+  root: string,
+  repoRoot: string,
+  fullPath: string,
+  filePaths: MetaFilePathMode,
+): string {
+  if (filePaths === 'concise') return `/${path.basename(fullPath)}`;
   const base = isInsidePath(repoRoot, fullPath) ? repoRoot : root;
   return toPosix(path.relative(base, fullPath));
 }
 
+function resolveOutputConfig(options: ScanOptions): MetaOutputConfig {
+  const presetName = options.preset ?? 'human';
+  const preset = META_OUTPUT_PRESETS[presetName];
+  if (!preset) throw new Error(`Unknown metadata output preset: ${presetName}`);
+
+  return {
+    indent: options.indent ?? preset.indent,
+    filePaths: normalizeFilePathMode(options.filePaths ?? options.file_paths ?? preset.filePaths),
+  };
+}
+
+function normalizeFilePathMode(value: MetaFilePathMode): MetaFilePathMode {
+  if (value === 'concise' || value === 'full') return value;
+  throw new Error(`Unknown metadata file path mode: ${String(value)}`);
+}
+
+function hasOutputOverrides(options: ScanOptions): boolean {
+  return (
+    options.preset !== undefined ||
+    options.indent !== undefined ||
+    options.filePaths !== undefined ||
+    options.file_paths !== undefined
+  );
+}
+
 function isInsidePath(parent: string, child: string): boolean {
   const relativePath = path.relative(parent, child);
   return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));

From ab4884055135183d9ded17dc227a482c30f1bfe3 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 18:40:40 +0100
Subject: [PATCH 51/72] Release meta output defaults

Make human and agent metadata presets scan deeply by default, while allowing explicit deep false overrides. Remove the generated Markdown title so output starts directly at the folder XML, simplify renderFolderSummary to return the rendered string, and release @davstack/meta 0.1.5 with the pending meta output changesets consumed.
---
 .changeset/meta-output-config.md     |  5 -----
 packages/meta/CHANGELOG.md           |  7 +++++++
 packages/meta/__tests__/meta.test.ts | 22 +++++++---------------
 packages/meta/package.json           |  2 +-
 packages/meta/src/cli-spec.ts        |  2 --
 packages/meta/src/index.ts           | 15 +++++++++------
 6 files changed, 24 insertions(+), 29 deletions(-)
 delete mode 100644 .changeset/meta-output-config.md

diff --git a/.changeset/meta-output-config.md b/.changeset/meta-output-config.md
deleted file mode 100644
index b3cd33d..0000000
--- a/.changeset/meta-output-config.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@davstack/meta": patch
----
-
-Add configurable output presets for human-readable and token-optimized folder metadata.
diff --git a/packages/meta/CHANGELOG.md b/packages/meta/CHANGELOG.md
index ca6e350..152201d 100644
--- a/packages/meta/CHANGELOG.md
+++ b/packages/meta/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @davstack/meta
 
+## 0.1.5
+
+### Patch Changes
+
+- Add configurable output presets for human-readable and token-optimized folder metadata.
+- Make metadata presets scan deeply by default and remove the generated Markdown title.
+
 ## 0.1.4
 
 ### Patch Changes
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index 74c2562..f33e174 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -31,9 +31,7 @@ describe('scanFolderMetadata', () => {
     );
 
     await expect(scanFolderMetadata(root)).resolves.toMatchInlineSnapshot(`
-      "# Folder Metadata
-
-      <folder path=".">
+      "<folder path=".">
       <file path="notes.md">
       - h1 Overview
       - h2 Details
@@ -111,9 +109,7 @@ describe('scanFolderMetadata', () => {
     await writeFile(path.join(root, 'child', 'grandchild', 'notes.md'), '# Nested\n');
 
     await expect(scanFolderMetadata(root, { deep: true })).resolves.toMatchInlineSnapshot(`
-      "# Folder Metadata
-
-      <folder path=".">
+      "<folder path=".">
       <file path="root.ts">
       [ln 1] const rootValue
       </file>
@@ -146,9 +142,7 @@ describe('scanFolderMetadata', () => {
     await writeFile(path.join(scanRoot, 'src', 'widget.ts'), 'export class Widget {}\n');
 
     await expect(scanFolderMetadata(scanRoot, { deep: true })).resolves.toMatchInlineSnapshot(`
-      "# Folder Metadata
-
-      <folder path="apps/web">
+      "<folder path="apps/web">
       <folder path="apps/web/src">
       	<file path="apps/web/src/widget.ts">
       	[ln 1] class Widget
@@ -167,9 +161,7 @@ describe('scanFolderMetadata', () => {
     await writeFile(path.join(scanRoot, '__tests__', 'log.test.ts'), 'export const SAMPLE = true\n');
 
     await expect(scanFolderMetadata(scanRoot, { deep: true, preset: 'agent' })).resolves.toMatchInlineSnapshot(`
-      "# Folder Metadata
-
-      <folder path="packages/context-compactor">
+      "<folder path="packages/context-compactor">
       <folder path="packages/context-compactor/__tests__">
       <file path="/log.test.ts">
       [ln 1] const SAMPLE
@@ -225,14 +217,14 @@ describe('generated folder metadata', () => {
     await expect(readFile(path.join(missing, GENERATED_META_FILE), 'utf8')).resolves.toBe(generated);
   });
 
-  test('deep scans child folders while the default view stays shallow', async () => {
+  test('default scans are deep while explicit deep false stays shallow', async () => {
     const root = await makeTempFolder();
     await mkdir(path.join(root, 'child'));
     await writeFile(path.join(root, 'root.ts'), 'export const rootValue = true\n');
     await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
 
-    const shallow = await scanFolderMetadata(root);
-    const deep = await scanFolderMetadata(root, { deep: true });
+    const deep = await scanFolderMetadata(root);
+    const shallow = await scanFolderMetadata(root, { deep: false });
 
     expect(shallow).toContain('rootValue');
     expect(shallow).not.toContain('childValue');
diff --git a/packages/meta/package.json b/packages/meta/package.json
index 4481b77..b2773fa 100644
--- a/packages/meta/package.json
+++ b/packages/meta/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/meta",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "license": "MIT",
   "type": "module",
   "description": "Generate concise folder metadata for agents.",
diff --git a/packages/meta/src/cli-spec.ts b/packages/meta/src/cli-spec.ts
index 970cbb8..21c695c 100644
--- a/packages/meta/src/cli-spec.ts
+++ b/packages/meta/src/cli-spec.ts
@@ -51,7 +51,6 @@ export const cliSpec: CliSpec = {
       flags: {
         deep: {
           type: 'boolean',
-          default: false,
           description: 'Recursively include child folders',
         },
         ...outputFlags,
@@ -68,7 +67,6 @@ export const cliSpec: CliSpec = {
       flags: {
         deep: {
           type: 'boolean',
-          default: false,
           description: 'Recursively include child folders',
         },
         ...outputFlags,
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 63a2576..9876963 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -24,16 +24,19 @@ export type MetaFilePathMode = 'concise' | 'full';
 export type MetaOutputPresetName = 'agent' | 'human';
 
 export type MetaOutputConfig = {
+  deep: boolean;
   indent: boolean;
   filePaths: MetaFilePathMode;
 };
 
 export const META_OUTPUT_PRESETS: Record<MetaOutputPresetName, MetaOutputConfig> = {
   human: {
+    deep: true,
     indent: true,
     filePaths: 'full',
   },
   agent: {
+    deep: true,
     indent: false,
     filePaths: 'concise',
   },
@@ -61,10 +64,9 @@ export async function scanFolderMetadata(folder: string, options: ScanOptions =
   const root = path.resolve(folder);
   const repoRoot = await findRepoRoot(root);
   const outputConfig = resolveOutputConfig(options);
-  const summary = await collectFolderSummary(root, repoRoot, root, options.deep === true, outputConfig);
+  const summary = await collectFolderSummary(root, repoRoot, root, outputConfig.deep, outputConfig);
 
-  const lines = ['# Folder Metadata', '', ...renderFolderSummary(summary, outputConfig), ''];
-  return lines.join('\n');
+  return `${renderFolderSummary(summary, outputConfig)}\n`;
 }
 
 export async function generateFolderMetadata(
@@ -139,7 +141,7 @@ function renderFolderSummary(
   summary: FolderSummary,
   outputConfig: MetaOutputConfig,
   depth = 0,
-): string[] {
+): string {
   const indent = outputConfig.indent ? '\t'.repeat(Math.max(0, depth - 1)) : '';
   const childIndent = outputConfig.indent ? '\t'.repeat(depth) : '';
   const lines = [`${indent}<folder path="${escapeAttribute(summary.path)}">`];
@@ -154,7 +156,7 @@ function renderFolderSummary(
   }
 
   for (const folder of summary.folders) {
-    lines.push(...renderFolderSummary(folder, outputConfig, depth + 1));
+    lines.push(renderFolderSummary(folder, outputConfig, depth + 1));
   }
 
   if (summary.omittedFiles.length > 0) {
@@ -166,7 +168,7 @@ function renderFolderSummary(
   }
 
   lines.push(`${indent}</folder>`);
-  return lines;
+  return lines.join('\n');
 }
 
 async function summarizeFile(
@@ -353,6 +355,7 @@ function resolveOutputConfig(options: ScanOptions): MetaOutputConfig {
   if (!preset) throw new Error(`Unknown metadata output preset: ${presetName}`);
 
   return {
+    deep: options.deep ?? preset.deep,
     indent: options.indent ?? preset.indent,
     filePaths: normalizeFilePathMode(options.filePaths ?? options.file_paths ?? preset.filePaths),
   };

From d93f7386e7c75cca2d24e7cff10501aa5caacb54 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 18:57:21 +0100
Subject: [PATCH 52/72] Release meta test call summaries

Summarize describe, test, and it calls in TypeScript-like files using their literal source titles and call-expression line ranges. This makes test-heavy folders informative without adding code excerpts, and releases @davstack/meta 0.1.6.
---
 packages/meta/CHANGELOG.md           |  6 ++++
 packages/meta/__tests__/meta.test.ts | 30 ++++++++++++++++
 packages/meta/package.json           |  2 +-
 packages/meta/src/index.ts           | 53 ++++++++++++++++++++++++++++
 4 files changed, 90 insertions(+), 1 deletion(-)

diff --git a/packages/meta/CHANGELOG.md b/packages/meta/CHANGELOG.md
index 152201d..c0a3dd5 100644
--- a/packages/meta/CHANGELOG.md
+++ b/packages/meta/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/meta
 
+## 0.1.6
+
+### Patch Changes
+
+- Summarize test and describe calls in TypeScript-like files using their literal source titles.
+
 ## 0.1.5
 
 ### Patch Changes
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/meta/__tests__/meta.test.ts
index f33e174..e9a2960 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/meta/__tests__/meta.test.ts
@@ -99,6 +99,36 @@ describe('scanFolderMetadata', () => {
     expect(metadata).not.toContain('omitted_files');
   });
 
+  test('summarizes vitest-style describe and test calls with literal titles', async () => {
+    const root = await makeTempFolder();
+    await writeFile(
+      path.join(root, 'detect.test.ts'),
+      `import { describe, expect, it, test } from 'vitest'
+
+describe('detectContentType', () => {
+  test("valid json object", () => {
+    expect(true).toBe(true)
+  })
+
+  it(\`keeps template titles real\`, () => {
+    expect(true).toBe(true)
+  })
+})
+`,
+    );
+
+    await expect(scanFolderMetadata(root)).resolves.toMatchInlineSnapshot(`
+      "<folder path=".">
+      <file path="detect.test.ts">
+      [ln 2-11] describe('detectContentType')
+      [ln 4-6] test("valid json object")
+      [ln 7-10] it(\`keeps template titles real\`)
+      </file>
+      </folder>
+      "
+    `);
+  });
+
   test('wraps deep child folders and reports omitted files per folder', async () => {
     const root = await makeTempFolder();
     await mkdir(path.join(root, 'child', 'grandchild'), { recursive: true });
diff --git a/packages/meta/package.json b/packages/meta/package.json
index b2773fa..611930d 100644
--- a/packages/meta/package.json
+++ b/packages/meta/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/meta",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "license": "MIT",
   "type": "module",
   "description": "Generate concise folder metadata for agents.",
diff --git a/packages/meta/src/index.ts b/packages/meta/src/index.ts
index 9876963..f34b73c 100644
--- a/packages/meta/src/index.ts
+++ b/packages/meta/src/index.ts
@@ -227,9 +227,25 @@ function extractTypeScriptSymbols(text: string): string[] {
       items.push(`${formatLineRange(range)} ${label} ${match[1]}`);
     }
   }
+  items.push(...extractTypeScriptTestCalls(source));
   return unique(items);
 }
 
+function extractTypeScriptTestCalls(text: string): string[] {
+  const items: string[] = [];
+  const pattern = /^\s*(describe|test|it)\s*\(\s*(['"`])((?:\\.|(?!\2)[\s\S])*?)\2/gm;
+
+  for (const match of text.matchAll(pattern)) {
+    const callName = match[1];
+    const quote = match[2];
+    const title = match[3];
+    const range = lineRangeForCallExpression(text, match.index ?? 0);
+    items.push(`${formatLineRange(range)} ${callName}(${quote}${title}${quote})`);
+  }
+
+  return items;
+}
+
 function extractPythonSymbols(text: string): string[] {
   const items: string[] = [];
   const lines = text.split(/\r?\n/);
@@ -309,6 +325,43 @@ function findMatchingBrace(text: string, openingBrace: number): number {
   return -1;
 }
 
+function lineRangeForCallExpression(text: string, index: number): { start: number; end: number } {
+  const start = lineNumberAt(text, index);
+  const openingParen = text.indexOf('(', index);
+  if (openingParen === -1) return { start, end: start };
+
+  const closingParen = findMatchingParen(text, openingParen);
+  if (closingParen === -1) return { start, end: start };
+  return { start, end: lineNumberAt(text, closingParen) };
+}
+
+function findMatchingParen(text: string, openingParen: number): number {
+  let depth = 0;
+  let quote: string | null = null;
+
+  for (let index = openingParen; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (char === '\\') {
+        index += 1;
+        continue;
+      }
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '(') depth += 1;
+    if (char === ')') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
 function lineRangeForPythonBlock(
   lines: string[],
   startIndex: number,

From a9c9c8367ae34e9f4fdd9f34c1cb835a5adde462 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 19:44:14 +0100
Subject: [PATCH 53/72] Rename meta package to peek

---
 .gitignore                                    |  1 +
 .../1-initial-concept.md                      | 28 +++----
 packages/meta/src/cli-spec.ts                 | 80 -------------------
 packages/{meta => peek}/CHANGELOG.md          |  8 +-
 packages/{meta => peek}/README.md             |  8 +-
 packages/{meta => peek}/__tests__/cli.test.ts | 32 ++------
 .../{meta => peek}/__tests__/meta.test.ts     | 62 +++++++-------
 .../bin/davstack-peek.mjs}                    |  2 +-
 packages/{meta => peek}/package.json          | 10 +--
 packages/peek/src/cli-spec.ts                 | 59 ++++++++++++++
 packages/{meta => peek}/src/cli.ts            |  0
 packages/{meta => peek}/src/index.ts          | 52 ++++++------
 packages/{meta => peek}/tsconfig.json         |  0
 packages/{meta => peek}/tsup.config.ts        |  0
 pnpm-lock.yaml                                | 10 +--
 vitest.workspace.ts                           |  4 +-
 16 files changed, 163 insertions(+), 193 deletions(-)
 rename notes/{davstack-meta => davstack-peek}/1-initial-concept.md (68%)
 delete mode 100644 packages/meta/src/cli-spec.ts
 rename packages/{meta => peek}/CHANGELOG.md (81%)
 rename packages/{meta => peek}/README.md (55%)
 rename packages/{meta => peek}/__tests__/cli.test.ts (60%)
 rename packages/{meta => peek}/__tests__/meta.test.ts (81%)
 rename packages/{meta/bin/davstack-meta.mjs => peek/bin/davstack-peek.mjs} (90%)
 rename packages/{meta => peek}/package.json (75%)
 create mode 100644 packages/peek/src/cli-spec.ts
 rename packages/{meta => peek}/src/cli.ts (100%)
 rename packages/{meta => peek}/src/index.ts (90%)
 rename packages/{meta => peek}/tsconfig.json (100%)
 rename packages/{meta => peek}/tsup.config.ts (100%)

diff --git a/.gitignore b/.gitignore
index bc88dd4..61319f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,6 +13,7 @@ public/dist
 .turbo
 coverage
 .folder-meta.generated.md
+.folder-peek.generated.md
 .davstack/evals/
 /temp
 paper.md
diff --git a/notes/davstack-meta/1-initial-concept.md b/notes/davstack-peek/1-initial-concept.md
similarity index 68%
rename from notes/davstack-meta/1-initial-concept.md
rename to notes/davstack-peek/1-initial-concept.md
index 62f32b5..a2ac4be 100644
--- a/notes/davstack-meta/1-initial-concept.md
+++ b/notes/davstack-peek/1-initial-concept.md
@@ -1,7 +1,7 @@
-# Davstack Meta Initial Concept
+# Davstack Peek Initial Concept
 
-Idea: add a small package/CLI, probably `@davstack/meta`, that generates concise
-folder-level metadata files for agents.
+Idea: add a small package/CLI, `@davstack/peek`, that prints concise
+folder-level peek files for agents.
 
 ## Motivation
 
@@ -12,21 +12,21 @@ act like a compact table of contents for source and docs.
 ## Possible CLI
 
 ```text
-npx @davstack/meta gen ./path-to-folder
-npx @davstack/meta view ./path-to-folder
-npx @davstack/meta view ./path-to-folder --deep
+npx @davstack/peek ./path-to-folder
+npx @davstack/peek ./path-to-folder --agent
+npx @davstack/peek ./path-to-folder --human
 ```
 
 ## `gen`
 
 `gen` scans a folder and writes a concise generated markdown file in that
-folder, likely something like `.folder-meta.generated.md`.
+folder, likely something like `.folder-peek.generated.md`.
 
 Initial scope:
 
 - Include markdown, TypeScript, and Python files.
 - Skip files ignored by git.
-- Skip generated metadata files themselves.
+- Skip generated peek files themselves.
 - Prefer concise structural summaries over content summaries.
 
 For markdown:
@@ -44,12 +44,12 @@ For Python:
 
 - Include functions, classes, constants, and module docstring where useful.
 
-## `view`
+## Peek
 
-`view` prints existing metadata for a folder. If the metadata file does not
+The CLI prints existing peek output for a folder. If the peek file does not
 exist, it can generate it on the spot.
 
-`--deep` could recursively include child folder metadata, either by generating
+`--deep` could recursively include child folder output, either by generating
 missing child files or by doing a direct recursive scan.
 
 ## Output Shape
@@ -74,7 +74,7 @@ There may be two useful output levels:
 
 ## Git Hygiene
 
-Generated metadata files should probably be gitignored by default. The package
+Generated peek files should probably be gitignored by default. The package
 could also provide a recommended `.gitignore` entry.
 
 ## Agent Workflow
@@ -82,9 +82,9 @@ could also provide a recommended `.gitignore` entry.
 An agent can run:
 
 ```text
-npx @davstack/meta view packages/open-agents/src --deep
+npx @davstack/peek packages/open-agents/src --deep
 ```
 
-Then use the metadata as a cheap routing map before opening source files. This
+Then use the output as a cheap routing map before opening source files. This
 could pair well with open-agent handoff testing because history/context pointers
 are more useful when agents can cheaply inspect repo structure too.
diff --git a/packages/meta/src/cli-spec.ts b/packages/meta/src/cli-spec.ts
deleted file mode 100644
index 21c695c..0000000
--- a/packages/meta/src/cli-spec.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import type { CliSpec } from '@davstack/cli-utils';
-import type { MetaFilePathMode, MetaOutputPresetName, ScanOptions } from './index.js';
-
-const outputFlags = {
-  human: {
-    type: 'boolean',
-    default: false,
-    description: 'Use human-readable output defaults: indented XML and full repo-relative file paths',
-  },
-  agent: {
-    type: 'boolean',
-    default: false,
-    description: 'Use token-optimized output defaults: no indentation and concise file paths',
-  },
-  indent: {
-    type: 'boolean',
-    description: 'Indent nested folder output',
-  },
-  file_paths: {
-    type: 'string',
-    description: 'File path style: concise or full',
-  },
-} as const;
-
-function resolveCliScanOptions(flags: Record<string, unknown>): ScanOptions {
-  const human = flags.human === true;
-  const agent = flags.agent === true;
-  if (human && agent) throw new Error('Use only one output preset: --human or --agent');
-
-  const preset: MetaOutputPresetName | undefined = agent ? 'agent' : human ? 'human' : undefined;
-  const filePaths = flags.file_paths;
-  if (filePaths !== undefined && filePaths !== 'concise' && filePaths !== 'full') {
-    throw new Error('--file_paths must be "concise" or "full"');
-  }
-
-  return {
-    deep: flags.deep as boolean,
-    preset,
-    indent: flags.indent as boolean | undefined,
-    filePaths: filePaths as MetaFilePathMode | undefined,
-  };
-}
-
-export const cliSpec: CliSpec = {
-  name: 'davstack-meta',
-  description: 'Generate and view concise folder metadata for agents.',
-  commands: {
-    gen: {
-      description: 'Write .folder-meta.generated.md in a folder',
-      positionals: [{ name: 'path', required: true, description: 'Folder to scan' }],
-      flags: {
-        deep: {
-          type: 'boolean',
-          description: 'Recursively include child folders',
-        },
-        ...outputFlags,
-      },
-      run: async (ctx) => {
-        const { generateFolderMetadata } = await import('./index.js');
-        const result = await generateFolderMetadata(ctx.positionals[0], resolveCliScanOptions(ctx.flags));
-        console.log(result.path);
-      },
-    },
-    view: {
-      description: 'Print existing metadata, generating it when missing',
-      positionals: [{ name: 'path', required: true, description: 'Folder to view' }],
-      flags: {
-        deep: {
-          type: 'boolean',
-          description: 'Recursively include child folders',
-        },
-        ...outputFlags,
-      },
-      run: async (ctx) => {
-        const { viewFolderMetadata } = await import('./index.js');
-        console.log(await viewFolderMetadata(ctx.positionals[0], resolveCliScanOptions(ctx.flags)));
-      },
-    },
-  },
-};
diff --git a/packages/meta/CHANGELOG.md b/packages/peek/CHANGELOG.md
similarity index 81%
rename from packages/meta/CHANGELOG.md
rename to packages/peek/CHANGELOG.md
index c0a3dd5..71fe43a 100644
--- a/packages/meta/CHANGELOG.md
+++ b/packages/peek/CHANGELOG.md
@@ -1,4 +1,10 @@
-# @davstack/meta
+# @davstack/peek
+
+## 0.1.0
+
+### Minor Changes
+
+- Rename the package from `@davstack/meta` to `@davstack/peek` and make the CLI print a folder peek with `peek <path>` instead of requiring the `view` subcommand.
 
 ## 0.1.6
 
diff --git a/packages/meta/README.md b/packages/peek/README.md
similarity index 55%
rename from packages/meta/README.md
rename to packages/peek/README.md
index 63405df..7a08e90 100644
--- a/packages/meta/README.md
+++ b/packages/peek/README.md
@@ -1,10 +1,10 @@
-# @davstack/meta
+# @davstack/peek
 
-Generate concise, agent-friendly folder metadata.
+Print concise, agent-friendly folder summaries.
 
 ```sh
-davstack-meta gen .
-davstack-meta view . --deep
+npx @davstack/peek .
+npx @davstack/peek packages/context-compactor --agent
 ```
 
 The first version uses conservative text scanning and safe default ignores for
diff --git a/packages/meta/__tests__/cli.test.ts b/packages/peek/__tests__/cli.test.ts
similarity index 60%
rename from packages/meta/__tests__/cli.test.ts
rename to packages/peek/__tests__/cli.test.ts
index daba0bf..e3bb476 100644
--- a/packages/meta/__tests__/cli.test.ts
+++ b/packages/peek/__tests__/cli.test.ts
@@ -1,42 +1,27 @@
-import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, test, vi } from 'vitest';
 import { defineCli } from '@davstack/cli-utils';
-import { GENERATED_META_FILE } from '../src/index.js';
 import { cliSpec } from '../src/cli-spec.js';
 
 async function makeTempFolder() {
-  return await mkdtemp(path.join(os.tmpdir(), 'davstack-meta-cli-'));
+  return await mkdtemp(path.join(os.tmpdir(), 'davstack-peek-cli-'));
 }
 
-describe('davstack-meta CLI', () => {
+describe('peek CLI', () => {
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  test('gen writes metadata and prints the generated file path', async () => {
-    const root = await makeTempFolder();
-    await writeFile(path.join(root, 'README.md'), '# CLI\n');
-    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    const code = await defineCli(cliSpec).run(['gen', root]);
-
-    expect(code).toBe(0);
-    expect(log).toHaveBeenCalledWith(path.join(root, GENERATED_META_FILE));
-    await expect(readFile(path.join(root, GENERATED_META_FILE), 'utf8')).resolves.toContain(
-      'h1 CLI',
-    );
-  });
-
-  test('view prints existing metadata and supports deep generation', async () => {
+  test('prints existing metadata and supports deep generation', async () => {
     const root = await makeTempFolder();
     await mkdir(path.join(root, 'child'));
     await writeFile(path.join(root, 'README.md'), '# Root\n');
     await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
     const log = vi.spyOn(console, 'log').mockImplementation(() => {});
 
-    const code = await defineCli(cliSpec).run(['view', root, '--deep']);
+    const code = await defineCli(cliSpec).run([root, '--deep']);
 
     expect(code).toBe(0);
     const output = log.mock.calls.map(([value]) => String(value)).join('\n');
@@ -46,14 +31,13 @@ describe('davstack-meta CLI', () => {
     expect(output).toContain('childValue');
   });
 
-  test('view supports agent preset and explicit output overrides', async () => {
+  test('supports agent preset and explicit output overrides', async () => {
     const root = await makeTempFolder();
     await mkdir(path.join(root, 'child'));
     await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
     const log = vi.spyOn(console, 'log').mockImplementation(() => {});
 
     const code = await defineCli(cliSpec).run([
-      'view',
       root,
       '--deep',
       '--agent',
@@ -66,11 +50,11 @@ describe('davstack-meta CLI', () => {
     expect(output).toContain('\t<file path="child/child.ts">');
   });
 
-  test('view rejects conflicting output presets', async () => {
+  test('rejects conflicting output presets', async () => {
     const root = await makeTempFolder();
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
 
-    const code = await defineCli(cliSpec).run(['view', root, '--human', '--agent']);
+    const code = await defineCli(cliSpec).run([root, '--human', '--agent']);
 
     expect(code).toBe(1);
     expect(error.mock.calls.map(([value]) => String(value)).join('\n')).toContain(
diff --git a/packages/meta/__tests__/meta.test.ts b/packages/peek/__tests__/meta.test.ts
similarity index 81%
rename from packages/meta/__tests__/meta.test.ts
rename to packages/peek/__tests__/meta.test.ts
index e9a2960..9816bb3 100644
--- a/packages/meta/__tests__/meta.test.ts
+++ b/packages/peek/__tests__/meta.test.ts
@@ -5,19 +5,19 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { describe, expect, test } from 'vitest';
 import {
-  GENERATED_META_FILE,
-  generateFolderMetadata,
-  scanFolderMetadata,
-  viewFolderMetadata,
+  GENERATED_PEEK_FILE,
+  generateFolderPeek,
+  peekFolder,
+  scanFolderPeek,
 } from '../src/index.js';
 
 const execFileAsync = promisify(execFile);
 
 async function makeTempFolder() {
-  return await mkdtemp(path.join(os.tmpdir(), 'davstack-meta-'));
+  return await mkdtemp(path.join(os.tmpdir(), 'davstack-peek-'));
 }
 
-describe('scanFolderMetadata', () => {
+describe('scanFolderPeek', () => {
   test('summarizes markdown headings and top-level code symbols in deterministic order', async () => {
     const root = await makeTempFolder();
     await writeFile(path.join(root, 'notes.md'), '# Overview\n\n## Details\n');
@@ -30,7 +30,7 @@ describe('scanFolderMetadata', () => {
       'export interface Config {}\nexport type Mode = "fast"\nexport const value = 1\nexport function build() {}\nclass LocalThing {}\n',
     );
 
-    await expect(scanFolderMetadata(root)).resolves.toMatchInlineSnapshot(`
+    await expect(scanFolderPeek(root)).resolves.toMatchInlineSnapshot(`
       "<folder path=".">
       <file path="notes.md">
       - h1 Overview
@@ -55,16 +55,16 @@ describe('scanFolderMetadata', () => {
 
   test('skips generated metadata and default ignored folders', async () => {
     const root = await makeTempFolder();
-    await writeFile(path.join(root, GENERATED_META_FILE), '# stale generated file\n');
+    await writeFile(path.join(root, GENERATED_PEEK_FILE), '# stale generated file\n');
     await mkdir(path.join(root, 'node_modules'), { recursive: true });
     await writeFile(path.join(root, 'node_modules', 'ignored.ts'), 'export const ignored = true\n');
     await writeFile(path.join(root, 'visible.ts'), 'export const visible = true\n');
 
-    const metadata = await scanFolderMetadata(root, { deep: true });
+    const metadata = await scanFolderPeek(root, { deep: true });
 
     expect(metadata).toContain('path="visible.ts"');
     expect(metadata).toContain('const visible');
-    expect(metadata).not.toContain(GENERATED_META_FILE);
+    expect(metadata).not.toContain(GENERATED_PEEK_FILE);
     expect(metadata).not.toContain('ignored');
   });
 
@@ -75,7 +75,7 @@ describe('scanFolderMetadata', () => {
     await writeFile(path.join(root, 'ignored.ts'), 'export const ignored = true\n');
     await writeFile(path.join(root, 'visible.ts'), 'export const visible = true\n');
 
-    const metadata = await scanFolderMetadata(root);
+    const metadata = await scanFolderPeek(root);
 
     expect(metadata).toContain('visible.ts');
     expect(metadata).not.toContain('ignored.ts');
@@ -88,7 +88,7 @@ describe('scanFolderMetadata', () => {
     await writeFile(path.join(root, 'script.js'), 'export function boot() {\n  return true\n}\n');
     await writeFile(path.join(root, 'module.mjs'), 'export const mode = {\n  format: "esm"\n}\n');
 
-    const metadata = await scanFolderMetadata(root);
+    const metadata = await scanFolderPeek(root);
 
     expect(metadata).toContain('<file path="component.mdx">');
     expect(metadata).toContain('- h1 Component');
@@ -117,7 +117,7 @@ describe('detectContentType', () => {
 `,
     );
 
-    await expect(scanFolderMetadata(root)).resolves.toMatchInlineSnapshot(`
+    await expect(scanFolderPeek(root)).resolves.toMatchInlineSnapshot(`
       "<folder path=".">
       <file path="detect.test.ts">
       [ln 2-11] describe('detectContentType')
@@ -138,7 +138,7 @@ describe('detectContentType', () => {
     await writeFile(path.join(root, 'child', 'data.json'), '{"hidden":true}\n');
     await writeFile(path.join(root, 'child', 'grandchild', 'notes.md'), '# Nested\n');
 
-    await expect(scanFolderMetadata(root, { deep: true })).resolves.toMatchInlineSnapshot(`
+    await expect(scanFolderPeek(root, { deep: true })).resolves.toMatchInlineSnapshot(`
       "<folder path=".">
       <file path="root.ts">
       [ln 1] const rootValue
@@ -171,7 +171,7 @@ describe('detectContentType', () => {
     await mkdir(path.join(scanRoot, 'src'), { recursive: true });
     await writeFile(path.join(scanRoot, 'src', 'widget.ts'), 'export class Widget {}\n');
 
-    await expect(scanFolderMetadata(scanRoot, { deep: true })).resolves.toMatchInlineSnapshot(`
+    await expect(scanFolderPeek(scanRoot, { deep: true })).resolves.toMatchInlineSnapshot(`
       "<folder path="apps/web">
       <folder path="apps/web/src">
       	<file path="apps/web/src/widget.ts">
@@ -190,7 +190,7 @@ describe('detectContentType', () => {
     await mkdir(path.join(scanRoot, '__tests__'), { recursive: true });
     await writeFile(path.join(scanRoot, '__tests__', 'log.test.ts'), 'export const SAMPLE = true\n');
 
-    await expect(scanFolderMetadata(scanRoot, { deep: true, preset: 'agent' })).resolves.toMatchInlineSnapshot(`
+    await expect(scanFolderPeek(scanRoot, { deep: true, preset: 'agent' })).resolves.toMatchInlineSnapshot(`
       "<folder path="packages/context-compactor">
       <folder path="packages/context-compactor/__tests__">
       <file path="/log.test.ts">
@@ -205,46 +205,46 @@ describe('detectContentType', () => {
   test('explicit output options override preset defaults', async () => {
     const root = await makeTempFolder();
     await execFileAsync('git', ['init'], { cwd: root });
-    const scanRoot = path.join(root, 'packages', 'meta');
+    const scanRoot = path.join(root, 'packages', 'peek');
     await mkdir(path.join(scanRoot, 'src'), { recursive: true });
     await writeFile(path.join(scanRoot, 'src', 'index.ts'), 'export function scan() {}\n');
 
-    const metadata = await scanFolderMetadata(scanRoot, {
+    const metadata = await scanFolderPeek(scanRoot, {
       deep: true,
       preset: 'agent',
       indent: true,
       filePaths: 'full',
     });
 
-    expect(metadata).toContain('<file path="packages/meta/src/index.ts">');
-    expect(metadata).toContain('\t<file path="packages/meta/src/index.ts">');
+    expect(metadata).toContain('<file path="packages/peek/src/index.ts">');
+    expect(metadata).toContain('\t<file path="packages/peek/src/index.ts">');
   });
 });
 
-describe('generated folder metadata', () => {
-  test('gen writes the generated metadata file in the scanned folder', async () => {
+describe('generated folder peek', () => {
+  test('generate writes the generated peek file in the scanned folder', async () => {
     const root = await makeTempFolder();
     await writeFile(path.join(root, 'README.md'), '# Root\n');
 
-    const result = await generateFolderMetadata(root);
+    const result = await generateFolderPeek(root);
 
-    expect(result.path).toBe(path.join(root, GENERATED_META_FILE));
+    expect(result.path).toBe(path.join(root, GENERATED_PEEK_FILE));
     await expect(readFile(result.path, 'utf8')).resolves.toBe(result.content);
     expect(result.content).toContain('<file path="README.md">');
   });
 
-  test('view prints existing metadata, generating it when missing', async () => {
+  test('peek prints existing output, generating it when missing', async () => {
     const root = await makeTempFolder();
-    await writeFile(path.join(root, GENERATED_META_FILE), '# Existing\n');
+    await writeFile(path.join(root, GENERATED_PEEK_FILE), '# Existing\n');
 
-    await expect(viewFolderMetadata(root)).resolves.toBe('# Existing\n');
+    await expect(peekFolder(root)).resolves.toBe('# Existing\n');
 
     const missing = await makeTempFolder();
     await writeFile(path.join(missing, 'README.md'), '# Created\n');
 
-    const generated = await viewFolderMetadata(missing);
+    const generated = await peekFolder(missing);
     expect(generated).toContain('h1 Created');
-    await expect(readFile(path.join(missing, GENERATED_META_FILE), 'utf8')).resolves.toBe(generated);
+    await expect(readFile(path.join(missing, GENERATED_PEEK_FILE), 'utf8')).resolves.toBe(generated);
   });
 
   test('default scans are deep while explicit deep false stays shallow', async () => {
@@ -253,8 +253,8 @@ describe('generated folder metadata', () => {
     await writeFile(path.join(root, 'root.ts'), 'export const rootValue = true\n');
     await writeFile(path.join(root, 'child', 'child.ts'), 'export const childValue = true\n');
 
-    const deep = await scanFolderMetadata(root);
-    const shallow = await scanFolderMetadata(root, { deep: false });
+    const deep = await scanFolderPeek(root);
+    const shallow = await scanFolderPeek(root, { deep: false });
 
     expect(shallow).toContain('rootValue');
     expect(shallow).not.toContain('childValue');
diff --git a/packages/meta/bin/davstack-meta.mjs b/packages/peek/bin/davstack-peek.mjs
similarity index 90%
rename from packages/meta/bin/davstack-meta.mjs
rename to packages/peek/bin/davstack-peek.mjs
index 156d101..8bc18b1 100644
--- a/packages/meta/bin/davstack-meta.mjs
+++ b/packages/peek/bin/davstack-peek.mjs
@@ -8,7 +8,7 @@ const entry = path.join(here, '..', 'dist', 'cli.js')
 const child = spawn(process.execPath, [entry, ...process.argv.slice(2)], { stdio: 'inherit' })
 
 child.on('error', (err) => {
-  console.error('davstack-meta: launcher error:', err)
+  console.error('peek: launcher error:', err)
   process.exit(1)
 })
 child.on('exit', (code, signal) => {
diff --git a/packages/meta/package.json b/packages/peek/package.json
similarity index 75%
rename from packages/meta/package.json
rename to packages/peek/package.json
index 611930d..c90212b 100644
--- a/packages/meta/package.json
+++ b/packages/peek/package.json
@@ -1,16 +1,16 @@
 {
-  "name": "@davstack/meta",
-  "version": "0.1.6",
+  "name": "@davstack/peek",
+  "version": "0.1.0",
   "license": "MIT",
   "type": "module",
-  "description": "Generate concise folder metadata for agents.",
+  "description": "Peek at concise, agent-friendly folder summaries.",
   "scripts": {
     "build": "tsup",
     "prepublishOnly": "tsup",
-    "test": "pnpm -w exec vitest run --project meta"
+    "test": "pnpm -w exec vitest run --project peek"
   },
   "bin": {
-    "davstack-meta": "./bin/davstack-meta.mjs"
+    "peek": "./bin/davstack-peek.mjs"
   },
   "exports": {
     ".": {
diff --git a/packages/peek/src/cli-spec.ts b/packages/peek/src/cli-spec.ts
new file mode 100644
index 0000000..ebdd0ff
--- /dev/null
+++ b/packages/peek/src/cli-spec.ts
@@ -0,0 +1,59 @@
+import type { CliSpec } from '@davstack/cli-utils';
+import type { PeekFilePathMode, PeekOutputPresetName, ScanOptions } from './index.js';
+
+const outputFlags = {
+  human: {
+    type: 'boolean',
+    default: false,
+    description: 'Use human-readable output defaults: indented XML and full repo-relative file paths',
+  },
+  agent: {
+    type: 'boolean',
+    default: false,
+    description: 'Use token-optimized output defaults: no indentation and concise file paths',
+  },
+  indent: {
+    type: 'boolean',
+    description: 'Indent nested folder output',
+  },
+  file_paths: {
+    type: 'string',
+    description: 'File path style: concise or full',
+  },
+} as const;
+
+function resolveCliScanOptions(flags: Record<string, unknown>): ScanOptions {
+  const human = flags.human === true;
+  const agent = flags.agent === true;
+  if (human && agent) throw new Error('Use only one output preset: --human or --agent');
+
+  const preset: PeekOutputPresetName | undefined = agent ? 'agent' : human ? 'human' : undefined;
+  const filePaths = flags.file_paths;
+  if (filePaths !== undefined && filePaths !== 'concise' && filePaths !== 'full') {
+    throw new Error('--file_paths must be "concise" or "full"');
+  }
+
+  return {
+    deep: flags.deep as boolean,
+    preset,
+    indent: flags.indent as boolean | undefined,
+    filePaths: filePaths as PeekFilePathMode | undefined,
+  };
+}
+
+export const cliSpec: CliSpec = {
+  name: 'peek',
+  description: 'Print concise folder summaries for agents.',
+  positionals: [{ name: 'path', required: true, description: 'Folder to peek at' }],
+  flags: {
+    deep: {
+      type: 'boolean',
+      description: 'Recursively include child folders',
+    },
+    ...outputFlags,
+  },
+  run: async (ctx) => {
+    const { peekFolder } = await import('./index.js');
+    console.log(await peekFolder(ctx.positionals[0], resolveCliScanOptions(ctx.flags)));
+  },
+};
diff --git a/packages/meta/src/cli.ts b/packages/peek/src/cli.ts
similarity index 100%
rename from packages/meta/src/cli.ts
rename to packages/peek/src/cli.ts
diff --git a/packages/meta/src/index.ts b/packages/peek/src/index.ts
similarity index 90%
rename from packages/meta/src/index.ts
rename to packages/peek/src/index.ts
index f34b73c..e0a8a4d 100644
--- a/packages/meta/src/index.ts
+++ b/packages/peek/src/index.ts
@@ -3,15 +3,15 @@ import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 
-export const GENERATED_META_FILE = '.folder-meta.generated.md';
+export const GENERATED_PEEK_FILE = '.folder-peek.generated.md';
 const execFileAsync = promisify(execFile);
 
 export type ScanOptions = {
   deep?: boolean;
-  preset?: MetaOutputPresetName;
+  preset?: PeekOutputPresetName;
   indent?: boolean;
-  filePaths?: MetaFilePathMode;
-  file_paths?: MetaFilePathMode;
+  filePaths?: PeekFilePathMode;
+  file_paths?: PeekFilePathMode;
 };
 
 type FileSummary = {
@@ -20,16 +20,16 @@ type FileSummary = {
   items: string[];
 };
 
-export type MetaFilePathMode = 'concise' | 'full';
-export type MetaOutputPresetName = 'agent' | 'human';
+export type PeekFilePathMode = 'concise' | 'full';
+export type PeekOutputPresetName = 'agent' | 'human';
 
-export type MetaOutputConfig = {
+export type PeekOutputConfig = {
   deep: boolean;
   indent: boolean;
-  filePaths: MetaFilePathMode;
+  filePaths: PeekFilePathMode;
 };
 
-export const META_OUTPUT_PRESETS: Record<MetaOutputPresetName, MetaOutputConfig> = {
+export const PEEK_OUTPUT_PRESETS: Record<PeekOutputPresetName, PeekOutputConfig> = {
   human: {
     deep: true,
     indent: true,
@@ -58,9 +58,9 @@ const SKIP_DIRS = new Set([
   'node_modules',
 ]);
 
-const SKIP_FILES = new Set([GENERATED_META_FILE]);
+const SKIP_FILES = new Set([GENERATED_PEEK_FILE]);
 
-export async function scanFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
+export async function scanFolderPeek(folder: string, options: ScanOptions = {}): Promise<string> {
   const root = path.resolve(folder);
   const repoRoot = await findRepoRoot(root);
   const outputConfig = resolveOutputConfig(options);
@@ -69,27 +69,27 @@ export async function scanFolderMetadata(folder: string, options: ScanOptions =
   return `${renderFolderSummary(summary, outputConfig)}\n`;
 }
 
-export async function generateFolderMetadata(
+export async function generateFolderPeek(
   folder: string,
   options: ScanOptions = {},
 ): Promise<{ path: string; content: string }> {
   const root = path.resolve(folder);
-  const content = await scanFolderMetadata(root, options);
-  const outPath = path.join(root, GENERATED_META_FILE);
+  const content = await scanFolderPeek(root, options);
+  const outPath = path.join(root, GENERATED_PEEK_FILE);
   await mkdir(root, { recursive: true });
   await writeFile(outPath, content, 'utf8');
   return { path: outPath, content };
 }
 
-export async function viewFolderMetadata(folder: string, options: ScanOptions = {}): Promise<string> {
+export async function peekFolder(folder: string, options: ScanOptions = {}): Promise<string> {
   const root = path.resolve(folder);
-  const generatedPath = path.join(root, GENERATED_META_FILE);
+  const generatedPath = path.join(root, GENERATED_PEEK_FILE);
   try {
     if (!options.deep && !hasOutputOverrides(options)) return await readFile(generatedPath, 'utf8');
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
   }
-  return (await generateFolderMetadata(root, options)).content;
+  return (await generateFolderPeek(root, options)).content;
 }
 
 async function collectFolderSummary(
@@ -97,7 +97,7 @@ async function collectFolderSummary(
   repoRoot: string,
   dir: string,
   deep: boolean,
-  outputConfig: MetaOutputConfig,
+  outputConfig: PeekOutputConfig,
 ): Promise<FolderSummary> {
   const entries = await readdir(dir, { withFileTypes: true });
   const files: FileSummary[] = [];
@@ -139,7 +139,7 @@ function formatFolderPath(root: string, repoRoot: string, dir: string): string {
 
 function renderFolderSummary(
   summary: FolderSummary,
-  outputConfig: MetaOutputConfig,
+  outputConfig: PeekOutputConfig,
   depth = 0,
 ): string {
   const indent = outputConfig.indent ? '\t'.repeat(Math.max(0, depth - 1)) : '';
@@ -175,7 +175,7 @@ async function summarizeFile(
   root: string,
   repoRoot: string,
   fullPath: string,
-  outputConfig: MetaOutputConfig,
+  outputConfig: PeekOutputConfig,
 ): Promise<FileSummary | null> {
   const extension = path.extname(fullPath);
   const relativePath = formatFilePath(root, repoRoot, fullPath, outputConfig.filePaths);
@@ -395,17 +395,17 @@ function formatFilePath(
   root: string,
   repoRoot: string,
   fullPath: string,
-  filePaths: MetaFilePathMode,
+  filePaths: PeekFilePathMode,
 ): string {
   if (filePaths === 'concise') return `/${path.basename(fullPath)}`;
   const base = isInsidePath(repoRoot, fullPath) ? repoRoot : root;
   return toPosix(path.relative(base, fullPath));
 }
 
-function resolveOutputConfig(options: ScanOptions): MetaOutputConfig {
+function resolveOutputConfig(options: ScanOptions): PeekOutputConfig {
   const presetName = options.preset ?? 'human';
-  const preset = META_OUTPUT_PRESETS[presetName];
-  if (!preset) throw new Error(`Unknown metadata output preset: ${presetName}`);
+  const preset = PEEK_OUTPUT_PRESETS[presetName];
+  if (!preset) throw new Error(`Unknown peek output preset: ${presetName}`);
 
   return {
     deep: options.deep ?? preset.deep,
@@ -414,9 +414,9 @@ function resolveOutputConfig(options: ScanOptions): MetaOutputConfig {
   };
 }
 
-function normalizeFilePathMode(value: MetaFilePathMode): MetaFilePathMode {
+function normalizeFilePathMode(value: PeekFilePathMode): PeekFilePathMode {
   if (value === 'concise' || value === 'full') return value;
-  throw new Error(`Unknown metadata file path mode: ${String(value)}`);
+  throw new Error(`Unknown peek file path mode: ${String(value)}`);
 }
 
 function hasOutputOverrides(options: ScanOptions): boolean {
diff --git a/packages/meta/tsconfig.json b/packages/peek/tsconfig.json
similarity index 100%
rename from packages/meta/tsconfig.json
rename to packages/peek/tsconfig.json
diff --git a/packages/meta/tsup.config.ts b/packages/peek/tsup.config.ts
similarity index 100%
rename from packages/meta/tsup.config.ts
rename to packages/peek/tsup.config.ts
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 429260a..b7b270b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -99,11 +99,14 @@ importers:
         specifier: ^5.0.0
         version: 5.3.3
 
-  packages/meta:
+  packages/open-agents:
     dependencies:
       '@davstack/cli-utils':
         specifier: workspace:*
         version: link:../cli-utils
+      '@davstack/context-compactor':
+        specifier: workspace:*
+        version: link:../context-compactor
     devDependencies:
       '@types/node':
         specifier: ^25.9.1
@@ -115,14 +118,11 @@ importers:
         specifier: ^5.0.0
         version: 5.3.3
 
-  packages/open-agents:
+  packages/peek:
     dependencies:
       '@davstack/cli-utils':
         specifier: workspace:*
         version: link:../cli-utils
-      '@davstack/context-compactor':
-        specifier: workspace:*
-        version: link:../context-compactor
     devDependencies:
       '@types/node':
         specifier: ^25.9.1
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index ac20897..fb1d1e6 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -67,8 +67,8 @@ export default defineWorkspace([
 			},
 		},
 		test: {
-			name: 'meta',
-			root: './packages/meta',
+			name: 'peek',
+			root: './packages/peek',
 			environment: 'node',
 			include: ['__tests__/**/*.test.ts'],
 			exclude: ['**/node_modules/**'],

From c4cb6cb34237d5cbd43b4d3f7276c1061ba5c7ce Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 20:09:18 +0100
Subject: [PATCH 54/72] Add peek file line counts

---
 packages/peek/CHANGELOG.md           |  6 ++++
 packages/peek/__tests__/cli.test.ts  |  4 ++-
 packages/peek/__tests__/meta.test.ts | 42 +++++++++++++++++-----------
 packages/peek/package.json           |  4 +--
 packages/peek/src/cli-spec.ts        |  5 ++++
 packages/peek/src/index.ts           | 42 ++++++++++++++++++++++++----
 6 files changed, 79 insertions(+), 24 deletions(-)

diff --git a/packages/peek/CHANGELOG.md b/packages/peek/CHANGELOG.md
index 71fe43a..4a063b5 100644
--- a/packages/peek/CHANGELOG.md
+++ b/packages/peek/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/peek
 
+## 0.1.1
+
+### Patch Changes
+
+- Add default `lines="n"` attributes to file tags, with `--no-include-lines-count` to omit them.
+
 ## 0.1.0
 
 ### Minor Changes
diff --git a/packages/peek/__tests__/cli.test.ts b/packages/peek/__tests__/cli.test.ts
index e3bb476..5671763 100644
--- a/packages/peek/__tests__/cli.test.ts
+++ b/packages/peek/__tests__/cli.test.ts
@@ -27,7 +27,7 @@ describe('peek CLI', () => {
     const output = log.mock.calls.map(([value]) => String(value)).join('\n');
     expect(output).toContain('h1 Root');
     expect(output).toContain('<folder path="child">');
-    expect(output).toContain('<file path="child/child.ts">');
+    expect(output).toContain('<file path="child/child.ts" lines="1">');
     expect(output).toContain('childValue');
   });
 
@@ -43,11 +43,13 @@ describe('peek CLI', () => {
       '--agent',
       '--indent=true',
       '--file_paths=full',
+      '--no-include-lines-count',
     ]);
 
     expect(code).toBe(0);
     const output = log.mock.calls.map(([value]) => String(value)).join('\n');
     expect(output).toContain('\t<file path="child/child.ts">');
+    expect(output).not.toContain(' lines=');
   });
 
   test('rejects conflicting output presets', async () => {
diff --git a/packages/peek/__tests__/meta.test.ts b/packages/peek/__tests__/meta.test.ts
index 9816bb3..e9f0d5e 100644
--- a/packages/peek/__tests__/meta.test.ts
+++ b/packages/peek/__tests__/meta.test.ts
@@ -32,16 +32,16 @@ describe('scanFolderPeek', () => {
 
     await expect(scanFolderPeek(root)).resolves.toMatchInlineSnapshot(`
       "<folder path=".">
-      <file path="notes.md">
+      <file path="notes.md" lines="3">
       - h1 Overview
       - h2 Details
       </file>
-      <file path="sample.py">
+      <file path="sample.py" lines="7">
       [ln 1] const CONSTANT
       [ln 3-4] class Worker
       [ln 6-7] function run
       </file>
-      <file path="tools.ts">
+      <file path="tools.ts" lines="5">
       [ln 5] class LocalThing
       [ln 1] interface Config
       [ln 2] type Mode
@@ -90,11 +90,11 @@ describe('scanFolderPeek', () => {
 
     const metadata = await scanFolderPeek(root);
 
-    expect(metadata).toContain('<file path="component.mdx">');
+    expect(metadata).toContain('<file path="component.mdx" lines="1">');
     expect(metadata).toContain('- h1 Component');
-    expect(metadata).toContain('<file path="script.js">');
+    expect(metadata).toContain('<file path="script.js" lines="3">');
     expect(metadata).toContain('[ln 1-3] function boot');
-    expect(metadata).toContain('<file path="module.mjs">');
+    expect(metadata).toContain('<file path="module.mjs" lines="3">');
     expect(metadata).toContain('[ln 1-3] const mode');
     expect(metadata).not.toContain('omitted_files');
   });
@@ -119,7 +119,7 @@ describe('detectContentType', () => {
 
     await expect(scanFolderPeek(root)).resolves.toMatchInlineSnapshot(`
       "<folder path=".">
-      <file path="detect.test.ts">
+      <file path="detect.test.ts" lines="11">
       [ln 2-11] describe('detectContentType')
       [ln 4-6] test("valid json object")
       [ln 7-10] it(\`keeps template titles real\`)
@@ -140,15 +140,15 @@ describe('detectContentType', () => {
 
     await expect(scanFolderPeek(root, { deep: true })).resolves.toMatchInlineSnapshot(`
       "<folder path=".">
-      <file path="root.ts">
+      <file path="root.ts" lines="1">
       [ln 1] const rootValue
       </file>
       <folder path="child">
-      	<file path="child/child.py">
+      	<file path="child/child.py" lines="2">
       	[ln 1-2] function child_function
       	</file>
       	<folder path="child/grandchild">
-      		<file path="child/grandchild/notes.md">
+      		<file path="child/grandchild/notes.md" lines="1">
       		- h1 Nested
       		</file>
       	</folder>
@@ -174,7 +174,7 @@ describe('detectContentType', () => {
     await expect(scanFolderPeek(scanRoot, { deep: true })).resolves.toMatchInlineSnapshot(`
       "<folder path="apps/web">
       <folder path="apps/web/src">
-      	<file path="apps/web/src/widget.ts">
+      	<file path="apps/web/src/widget.ts" lines="1">
       	[ln 1] class Widget
       	</file>
       </folder>
@@ -193,7 +193,7 @@ describe('detectContentType', () => {
     await expect(scanFolderPeek(scanRoot, { deep: true, preset: 'agent' })).resolves.toMatchInlineSnapshot(`
       "<folder path="packages/context-compactor">
       <folder path="packages/context-compactor/__tests__">
-      <file path="/log.test.ts">
+      <file path="/log.test.ts" lines="1">
       [ln 1] const SAMPLE
       </file>
       </folder>
@@ -216,8 +216,18 @@ describe('detectContentType', () => {
       filePaths: 'full',
     });
 
-    expect(metadata).toContain('<file path="packages/peek/src/index.ts">');
-    expect(metadata).toContain('\t<file path="packages/peek/src/index.ts">');
+    expect(metadata).toContain('<file path="packages/peek/src/index.ts" lines="1">');
+    expect(metadata).toContain('\t<file path="packages/peek/src/index.ts" lines="1">');
+  });
+
+  test('can omit line counts from file tags', async () => {
+    const root = await makeTempFolder();
+    await writeFile(path.join(root, 'visible.ts'), 'export const visible = true\n');
+
+    const metadata = await scanFolderPeek(root, { includeLinesCount: false });
+
+    expect(metadata).toContain('<file path="visible.ts">');
+    expect(metadata).not.toContain(' lines=');
   });
 });
 
@@ -230,7 +240,7 @@ describe('generated folder peek', () => {
 
     expect(result.path).toBe(path.join(root, GENERATED_PEEK_FILE));
     await expect(readFile(result.path, 'utf8')).resolves.toBe(result.content);
-    expect(result.content).toContain('<file path="README.md">');
+    expect(result.content).toContain('<file path="README.md" lines="1">');
   });
 
   test('peek prints existing output, generating it when missing', async () => {
@@ -260,7 +270,7 @@ describe('generated folder peek', () => {
     expect(shallow).not.toContain('childValue');
     expect(deep).toContain('rootValue');
     expect(deep).toContain('<folder path="child">');
-    expect(deep).toContain('<file path="child/child.ts">');
+    expect(deep).toContain('<file path="child/child.ts" lines="1">');
     expect(deep).toContain('childValue');
   });
 });
diff --git a/packages/peek/package.json b/packages/peek/package.json
index c90212b..e2d1f28 100644
--- a/packages/peek/package.json
+++ b/packages/peek/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/peek",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "type": "module",
   "description": "Peek at concise, agent-friendly folder summaries.",
@@ -10,7 +10,7 @@
     "test": "pnpm -w exec vitest run --project peek"
   },
   "bin": {
-    "peek": "./bin/davstack-peek.mjs"
+    "peek": "bin/davstack-peek.mjs"
   },
   "exports": {
     ".": {
diff --git a/packages/peek/src/cli-spec.ts b/packages/peek/src/cli-spec.ts
index ebdd0ff..b13f2aa 100644
--- a/packages/peek/src/cli-spec.ts
+++ b/packages/peek/src/cli-spec.ts
@@ -20,6 +20,10 @@ const outputFlags = {
     type: 'string',
     description: 'File path style: concise or full',
   },
+  'include-lines-count': {
+    type: 'boolean',
+    description: 'Include total line counts on file tags',
+  },
 } as const;
 
 function resolveCliScanOptions(flags: Record<string, unknown>): ScanOptions {
@@ -38,6 +42,7 @@ function resolveCliScanOptions(flags: Record<string, unknown>): ScanOptions {
     preset,
     indent: flags.indent as boolean | undefined,
     filePaths: filePaths as PeekFilePathMode | undefined,
+    includeLinesCount: flags['include-lines-count'] as boolean | undefined,
   };
 }
 
diff --git a/packages/peek/src/index.ts b/packages/peek/src/index.ts
index e0a8a4d..a51453f 100644
--- a/packages/peek/src/index.ts
+++ b/packages/peek/src/index.ts
@@ -12,11 +12,14 @@ export type ScanOptions = {
   indent?: boolean;
   filePaths?: PeekFilePathMode;
   file_paths?: PeekFilePathMode;
+  includeLinesCount?: boolean;
+  include_lines_count?: boolean;
 };
 
 type FileSummary = {
   path: string;
   kind: 'markdown' | 'typescript' | 'python';
+  lines: number;
   items: string[];
 };
 
@@ -27,6 +30,7 @@ export type PeekOutputConfig = {
   deep: boolean;
   indent: boolean;
   filePaths: PeekFilePathMode;
+  includeLinesCount: boolean;
 };
 
 export const PEEK_OUTPUT_PRESETS: Record<PeekOutputPresetName, PeekOutputConfig> = {
@@ -34,11 +38,13 @@ export const PEEK_OUTPUT_PRESETS: Record<PeekOutputPresetName, PeekOutputConfig>
     deep: true,
     indent: true,
     filePaths: 'full',
+    includeLinesCount: true,
   },
   agent: {
     deep: true,
     indent: false,
     filePaths: 'concise',
+    includeLinesCount: true,
   },
 };
 
@@ -147,7 +153,8 @@ function renderFolderSummary(
   const lines = [`${indent}<folder path="${escapeAttribute(summary.path)}">`];
 
   for (const file of summary.files) {
-    lines.push(`${childIndent}<file path="${escapeAttribute(file.path)}">`);
+    const lineCount = outputConfig.includeLinesCount ? ` lines="${file.lines}"` : '';
+    lines.push(`${childIndent}<file path="${escapeAttribute(file.path)}"${lineCount}>`);
     for (const item of file.items) {
       const prefix = item.startsWith('[ln ') ? '' : '- ';
       lines.push(`${childIndent}${prefix}${item}`);
@@ -182,15 +189,30 @@ async function summarizeFile(
 
   if (extension === '.md' || extension === '.mdx') {
     const text = await readFile(fullPath, 'utf8');
-    return { path: relativePath, kind: 'markdown', items: extractMarkdownHeadings(text) };
+    return {
+      path: relativePath,
+      kind: 'markdown',
+      lines: countLines(text),
+      items: extractMarkdownHeadings(text),
+    };
   }
   if (isTypeScriptLikeFile(extension, fullPath)) {
     const text = await readFile(fullPath, 'utf8');
-    return { path: relativePath, kind: 'typescript', items: extractTypeScriptSymbols(text) };
+    return {
+      path: relativePath,
+      kind: 'typescript',
+      lines: countLines(text),
+      items: extractTypeScriptSymbols(text),
+    };
   }
   if (extension === '.py') {
     const text = await readFile(fullPath, 'utf8');
-    return { path: relativePath, kind: 'python', items: extractPythonSymbols(text) };
+    return {
+      path: relativePath,
+      kind: 'python',
+      lines: countLines(text),
+      items: extractPythonSymbols(text),
+    };
   }
   return null;
 }
@@ -411,6 +433,8 @@ function resolveOutputConfig(options: ScanOptions): PeekOutputConfig {
     deep: options.deep ?? preset.deep,
     indent: options.indent ?? preset.indent,
     filePaths: normalizeFilePathMode(options.filePaths ?? options.file_paths ?? preset.filePaths),
+    includeLinesCount:
+      options.includeLinesCount ?? options.include_lines_count ?? preset.includeLinesCount,
   };
 }
 
@@ -419,12 +443,20 @@ function normalizeFilePathMode(value: PeekFilePathMode): PeekFilePathMode {
   throw new Error(`Unknown peek file path mode: ${String(value)}`);
 }
 
+function countLines(text: string): number {
+  if (text.length === 0) return 0;
+  const newlineCount = text.match(/\r\n|\r|\n/g)?.length ?? 0;
+  return newlineCount + (/(?:\r\n|\r|\n)$/.test(text) ? 0 : 1);
+}
+
 function hasOutputOverrides(options: ScanOptions): boolean {
   return (
     options.preset !== undefined ||
     options.indent !== undefined ||
     options.filePaths !== undefined ||
-    options.file_paths !== undefined
+    options.file_paths !== undefined ||
+    options.includeLinesCount !== undefined ||
+    options.include_lines_count !== undefined
   );
 }
 

From dfbd1185b54dc53f78d04f9d5d7e47b0baa8ddeb Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 20:50:01 +0100
Subject: [PATCH 55/72] Improve peek help and scan speed

---
 packages/cli-utils/CHANGELOG.md               |   6 ++
 packages/cli-utils/__tests__/cli-help.test.ts |  20 ++++
 packages/cli-utils/package.json               |   2 +-
 packages/cli-utils/src/cli-help.ts            |  21 +++-
 packages/cli-utils/src/cli.ts                 |   3 +
 packages/peek/CHANGELOG.md                    |   7 ++
 packages/peek/package.json                    |   2 +-
 packages/peek/src/cli-spec.ts                 |  11 ++
 packages/peek/src/index.ts                    | 102 ++++++++++++++----
 9 files changed, 147 insertions(+), 27 deletions(-)

diff --git a/packages/cli-utils/CHANGELOG.md b/packages/cli-utils/CHANGELOG.md
index 0f31fce..c3545ab 100644
--- a/packages/cli-utils/CHANGELOG.md
+++ b/packages/cli-utils/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/cli-utils
 
+## 1.3.2
+
+### Patch Changes
+
+- Improve generated CLI help with examples, defaults, boolean negation forms, and string value hints.
+
 ## 1.3.1
 
 ### Patch Changes
diff --git a/packages/cli-utils/__tests__/cli-help.test.ts b/packages/cli-utils/__tests__/cli-help.test.ts
index 510d2c2..9897bfe 100644
--- a/packages/cli-utils/__tests__/cli-help.test.ts
+++ b/packages/cli-utils/__tests__/cli-help.test.ts
@@ -23,6 +23,26 @@ test('formatHelp renders name, description, flags, defaults', () => {
   expect(out).toContain('5180');
   expect(out).toContain('Listen port');
   expect(out).toContain('--verbose');
+  expect(out).toContain('--no-verbose');
+});
+
+test('formatHelp renders examples, defaults, and string value hints', () => {
+  const spec: CliSpec = {
+    name: 'demo',
+    description: 'A demo tool',
+    examples: ['demo . --fast'],
+    defaults: ['fast mode is on'],
+    flags: {
+      mode: { type: 'string', values: ['fast', 'slow'], description: 'Run mode' },
+    },
+    run: () => 0,
+  };
+  const out = formatHelp([], spec);
+  expect(out).toContain('Examples:');
+  expect(out).toContain('demo . --fast');
+  expect(out).toContain('Defaults:');
+  expect(out).toContain('fast mode is on');
+  expect(out).toContain('--mode <fast|slow>');
 });
 
 test('formatHelp shows env-var fallback when configured', () => {
diff --git a/packages/cli-utils/package.json b/packages/cli-utils/package.json
index 3787f53..debc937 100644
--- a/packages/cli-utils/package.json
+++ b/packages/cli-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/cli-utils",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "license": "MIT",
   "type": "module",
   "description": "Tiny CLI helper shared by @davstack/logs-server and vitest-server.",
diff --git a/packages/cli-utils/src/cli-help.ts b/packages/cli-utils/src/cli-help.ts
index dca8e76..36cf1f2 100644
--- a/packages/cli-utils/src/cli-help.ts
+++ b/packages/cli-utils/src/cli-help.ts
@@ -27,6 +27,18 @@ export function formatHelp(commandPath: string[], spec: CliSpec): string {
   lines.push(`  ${usageBits.join(' ')}`);
   lines.push('');
 
+  if (node.examples && node.examples.length) {
+    lines.push('Examples:');
+    for (const example of node.examples) lines.push(`  ${example}`);
+    lines.push('');
+  }
+
+  if (node.defaults && node.defaults.length) {
+    lines.push('Defaults:');
+    for (const value of node.defaults) lines.push(`  ${value}`);
+    lines.push('');
+  }
+
   if (node.positionals && node.positionals.length) {
     lines.push('Positionals:');
     for (const p of node.positionals) lines.push(formatPositional(p));
@@ -61,8 +73,13 @@ function formatPositional(p: Positional): string {
 
 function formatFlag(name: string, def: FlagSpec): string {
   const bits: string[] = [];
-  bits.push(`--${name}`);
-  bits.push(`<${def.type}>`);
+  if (def.type === 'boolean') {
+    bits.push(`--${name} / --no-${name}`);
+  } else {
+    const valueHint = def.values?.length ? def.values.join('|') : def.type;
+    bits.push(`--${name}`);
+    bits.push(`<${valueHint}>`);
+  }
   const meta: string[] = [];
   if (def.default !== undefined) meta.push(`default: ${JSON.stringify(def.default)}`);
   if (def.env) meta.push(`env: ${def.env}`);
diff --git a/packages/cli-utils/src/cli.ts b/packages/cli-utils/src/cli.ts
index 00251a0..f9bef00 100644
--- a/packages/cli-utils/src/cli.ts
+++ b/packages/cli-utils/src/cli.ts
@@ -19,6 +19,7 @@ export type FlagSpec = {
   required?: boolean;
   description?: string;
   env?: string;
+  values?: readonly string[];
 };
 
 export type Positional = {
@@ -29,6 +30,8 @@ export type Positional = {
 
 export type CommandSpec = {
   description?: string;
+  examples?: string[];
+  defaults?: string[];
   positionals?: Positional[];
   flags?: Record<string, FlagSpec>;
   commands?: Record<string, CommandSpec>;
diff --git a/packages/peek/CHANGELOG.md b/packages/peek/CHANGELOG.md
index 4a063b5..86e9158 100644
--- a/packages/peek/CHANGELOG.md
+++ b/packages/peek/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @davstack/peek
 
+## 0.1.2
+
+### Patch Changes
+
+- Make `--help` more agent-friendly with examples, defaults, boolean negation forms, and file path value hints.
+- Speed up scans by batching git-ignore checks per directory and scanning child folders/files concurrently.
+
 ## 0.1.1
 
 ### Patch Changes
diff --git a/packages/peek/package.json b/packages/peek/package.json
index e2d1f28..53299d4 100644
--- a/packages/peek/package.json
+++ b/packages/peek/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/peek",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
   "description": "Peek at concise, agent-friendly folder summaries.",
diff --git a/packages/peek/src/cli-spec.ts b/packages/peek/src/cli-spec.ts
index b13f2aa..4c53565 100644
--- a/packages/peek/src/cli-spec.ts
+++ b/packages/peek/src/cli-spec.ts
@@ -18,6 +18,7 @@ const outputFlags = {
   },
   file_paths: {
     type: 'string',
+    values: ['concise', 'full'],
     description: 'File path style: concise or full',
   },
   'include-lines-count': {
@@ -49,6 +50,16 @@ function resolveCliScanOptions(flags: Record<string, unknown>): ScanOptions {
 export const cliSpec: CliSpec = {
   name: 'peek',
   description: 'Print concise folder summaries for agents.',
+  examples: [
+    'peek .',
+    'peek packages/context-compactor --agent',
+    'peek . --human',
+    'peek . --file_paths=full --no-include-lines-count',
+  ],
+  defaults: [
+    '--human behavior: deep scan, indented output, full file paths, line counts',
+    '--agent behavior: deep scan, no indentation, concise file paths, line counts',
+  ],
   positionals: [{ name: 'path', required: true, description: 'Folder to peek at' }],
   flags: {
     deep: {
diff --git a/packages/peek/src/index.ts b/packages/peek/src/index.ts
index a51453f..d8d32dc 100644
--- a/packages/peek/src/index.ts
+++ b/packages/peek/src/index.ts
@@ -1,4 +1,4 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
@@ -70,7 +70,15 @@ export async function scanFolderPeek(folder: string, options: ScanOptions = {}):
   const root = path.resolve(folder);
   const repoRoot = await findRepoRoot(root);
   const outputConfig = resolveOutputConfig(options);
-  const summary = await collectFolderSummary(root, repoRoot, root, outputConfig.deep, outputConfig);
+  const fileLimit = createLimiter(64);
+  const summary = await collectFolderSummary(
+    root,
+    repoRoot,
+    root,
+    outputConfig.deep,
+    outputConfig,
+    fileLimit,
+  );
 
   return `${renderFolderSummary(summary, outputConfig)}\n`;
 }
@@ -104,31 +112,44 @@ async function collectFolderSummary(
   dir: string,
   deep: boolean,
   outputConfig: PeekOutputConfig,
+  fileLimit: <T>(task: () => Promise<T>) => Promise<T>,
 ): Promise<FolderSummary> {
   const entries = await readdir(dir, { withFileTypes: true });
-  const files: FileSummary[] = [];
-  const folders: FolderSummary[] = [];
+  const fileTasks: Array<Promise<{ name: string; summary: FileSummary | null }>> = [];
+  const folderTasks: Array<Promise<FolderSummary>> = [];
   const omittedFiles: string[] = [];
+  const ignoredPaths = await checkIgnoredPaths(root, entries.map((entry) => path.join(dir, entry.name)));
 
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     const fullPath = path.join(dir, entry.name);
-    if (await isGitIgnored(root, fullPath)) continue;
+    if (ignoredPaths.has(toPosix(path.relative(root, fullPath)))) continue;
 
     if (entry.isDirectory()) {
       if (!deep || shouldSkipDirectory(entry.name)) continue;
-      folders.push(await collectFolderSummary(root, repoRoot, fullPath, deep, outputConfig));
+      folderTasks.push(collectFolderSummary(root, repoRoot, fullPath, deep, outputConfig, fileLimit));
       continue;
     }
     if (!entry.isFile() || shouldSkipFile(entry.name)) continue;
 
-    const summary = await summarizeFile(root, repoRoot, fullPath, outputConfig);
-    if (summary) {
-      files.push(summary);
-    } else {
-      omittedFiles.push(entry.name);
-    }
+    fileTasks.push(
+      fileLimit(async () => ({
+        name: entry.name,
+        summary: await summarizeFile(root, repoRoot, fullPath, outputConfig),
+      })),
+    );
   }
 
+  const fileResults = await Promise.all(fileTasks);
+  const files = fileResults
+    .map((result) => result.summary)
+    .filter((summary): summary is FileSummary => summary !== null);
+  omittedFiles.push(
+    ...fileResults
+      .filter((result) => result.summary === null)
+      .map((result) => result.name),
+  );
+  const folders = await Promise.all(folderTasks);
+
   return {
     path: formatFolderPath(root, repoRoot, dir),
     files: files.sort((a, b) => a.path.localeCompare(b.path)),
@@ -307,6 +328,25 @@ function unique(items: string[]): string[] {
   return Array.from(new Set(items));
 }
 
+function createLimiter(maxConcurrent: number): <T>(task: () => Promise<T>) => Promise<T> {
+  let active = 0;
+  const queue: Array<() => void> = [];
+
+  return async function limit<T>(task: () => Promise<T>): Promise<T> {
+    if (active >= maxConcurrent) {
+      await new Promise<void>((resolve) => queue.push(resolve));
+    }
+
+    active += 1;
+    try {
+      return await task();
+    } finally {
+      active -= 1;
+      queue.shift()?.();
+    }
+  };
+}
+
 function lineNumberAt(text: string, index: number): number {
   let lineNumber = 1;
   for (let offset = 0; offset < index; offset += 1) {
@@ -477,18 +517,34 @@ function escapeText(value: string): string {
   return value.replace(/&/g, '&amp;').replace(/</g, '&lt;');
 }
 
-async function isGitIgnored(root: string, fullPath: string): Promise<boolean> {
-  const relativePath = toPosix(path.relative(root, fullPath));
-  if (!relativePath || relativePath.startsWith('..')) return false;
+async function checkIgnoredPaths(root: string, fullPaths: string[]): Promise<Set<string>> {
+  const relativePaths = fullPaths
+    .map((fullPath) => toPosix(path.relative(root, fullPath)))
+    .filter((relativePath) => relativePath && !relativePath.startsWith('..'));
+
+  if (relativePaths.length === 0) return new Set();
+
+  return await new Promise((resolve) => {
+    const child = spawn('git', ['-C', root, 'check-ignore', '--stdin'], {
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    let stdout = '';
+
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk;
+    });
+    child.on('error', () => resolve(new Set()));
+    child.on('close', (code) => {
+      if (code !== 0 && code !== 1) {
+        resolve(new Set());
+        return;
+      }
+      resolve(new Set(stdout.split(/\r?\n/).filter(Boolean)));
+    });
 
-  try {
-    await execFileAsync('git', ['-C', root, 'check-ignore', '--quiet', '--', relativePath]);
-    return true;
-  } catch (error) {
-    const code = (error as { code?: number | string }).code;
-    if (code === 1 || code === 128 || code === 'ENOENT') return false;
-    return false;
-  }
+    child.stdin.end(relativePaths.join('\n'));
+  });
 }
 
 async function findRepoRoot(root: string): Promise<string> {

From 6310f6b7a475badd15d52a828c593fa640787845 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 20:53:22 +0100
Subject: [PATCH 56/72] Fix peek published dependency range

---
 packages/peek/CHANGELOG.md | 6 ++++++
 packages/peek/package.json | 4 ++--
 pnpm-lock.yaml             | 2 +-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/packages/peek/CHANGELOG.md b/packages/peek/CHANGELOG.md
index 86e9158..f3f1aea 100644
--- a/packages/peek/CHANGELOG.md
+++ b/packages/peek/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @davstack/peek
 
+## 0.1.3
+
+### Patch Changes
+
+- Publish with an npm-resolvable `@davstack/cli-utils` dependency range.
+
 ## 0.1.2
 
 ### Patch Changes
diff --git a/packages/peek/package.json b/packages/peek/package.json
index 53299d4..8abc6e5 100644
--- a/packages/peek/package.json
+++ b/packages/peek/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/peek",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "MIT",
   "type": "module",
   "description": "Peek at concise, agent-friendly folder summaries.",
@@ -31,7 +31,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@davstack/cli-utils": "workspace:*"
+    "@davstack/cli-utils": "^1.3.2"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b7b270b..b8d2b49 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -121,7 +121,7 @@ importers:
   packages/peek:
     dependencies:
       '@davstack/cli-utils':
-        specifier: workspace:*
+        specifier: ^1.3.2
         version: link:../cli-utils
     devDependencies:
       '@types/node':

From 1e81d36453b911de6a3990933b634891450625f3 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 21:31:57 +0100
Subject: [PATCH 57/72] Sort peek symbols by source line

---
 packages/peek/__tests__/meta.test.ts | 21 ++++++++++++++++++-
 packages/peek/src/index.ts           | 30 ++++++++++++++++++++++------
 2 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/packages/peek/__tests__/meta.test.ts b/packages/peek/__tests__/meta.test.ts
index e9f0d5e..acd8d36 100644
--- a/packages/peek/__tests__/meta.test.ts
+++ b/packages/peek/__tests__/meta.test.ts
@@ -42,11 +42,30 @@ describe('scanFolderPeek', () => {
       [ln 6-7] function run
       </file>
       <file path="tools.ts" lines="5">
-      [ln 5] class LocalThing
       [ln 1] interface Config
       [ln 2] type Mode
       [ln 3] const value
       [ln 4] function build
+      [ln 5] class LocalThing
+      </file>
+      </folder>
+      "
+    `);
+  });
+
+  test('orders TypeScript symbols by source line', async () => {
+    const root = await makeTempFolder();
+    await writeFile(
+      path.join(root, 'ordered.ts'),
+      'export function first() {}\nexport type Middle = string\nexport class Last {}\n',
+    );
+
+    await expect(scanFolderPeek(root)).resolves.toMatchInlineSnapshot(`
+      "<folder path=".">
+      <file path="ordered.ts" lines="3">
+      [ln 1] function first
+      [ln 2] type Middle
+      [ln 3] class Last
       </file>
       </folder>
       "
diff --git a/packages/peek/src/index.ts b/packages/peek/src/index.ts
index d8d32dc..c64e452 100644
--- a/packages/peek/src/index.ts
+++ b/packages/peek/src/index.ts
@@ -251,7 +251,7 @@ function extractMarkdownHeadings(text: string): string[] {
 }
 
 function extractTypeScriptSymbols(text: string): string[] {
-  const items: string[] = [];
+  const items: Array<{ start: number; value: string }> = [];
   const source = stripBlockComments(text);
   const patterns: Array<[RegExp, string]> = [
     [/^(?:export\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/gm, 'class'],
@@ -267,15 +267,18 @@ function extractTypeScriptSymbols(text: string): string[] {
   for (const [pattern, label] of patterns) {
     for (const match of source.matchAll(pattern)) {
       const range = lineRangeForTypeScriptSymbol(source, match.index ?? 0);
-      items.push(`${formatLineRange(range)} ${label} ${match[1]}`);
+      items.push({
+        start: range.start,
+        value: `${formatLineRange(range)} ${label} ${match[1]}`,
+      });
     }
   }
   items.push(...extractTypeScriptTestCalls(source));
-  return unique(items);
+  return uniqueSortedItems(items);
 }
 
-function extractTypeScriptTestCalls(text: string): string[] {
-  const items: string[] = [];
+function extractTypeScriptTestCalls(text: string): Array<{ start: number; value: string }> {
+  const items: Array<{ start: number; value: string }> = [];
   const pattern = /^\s*(describe|test|it)\s*\(\s*(['"`])((?:\\.|(?!\2)[\s\S])*?)\2/gm;
 
   for (const match of text.matchAll(pattern)) {
@@ -283,7 +286,10 @@ function extractTypeScriptTestCalls(text: string): string[] {
     const quote = match[2];
     const title = match[3];
     const range = lineRangeForCallExpression(text, match.index ?? 0);
-    items.push(`${formatLineRange(range)} ${callName}(${quote}${title}${quote})`);
+    items.push({
+      start: range.start,
+      value: `${formatLineRange(range)} ${callName}(${quote}${title}${quote})`,
+    });
   }
 
   return items;
@@ -328,6 +334,18 @@ function unique(items: string[]): string[] {
   return Array.from(new Set(items));
 }
 
+function uniqueSortedItems(items: Array<{ start: number; value: string }>): string[] {
+  const seen = new Set<string>();
+  return items
+    .sort((a, b) => a.start - b.start || a.value.localeCompare(b.value))
+    .filter((item) => {
+      if (seen.has(item.value)) return false;
+      seen.add(item.value);
+      return true;
+    })
+    .map((item) => item.value);
+}
+
 function createLimiter(maxConcurrent: number): <T>(task: () => Promise<T>) => Promise<T> {
   let active = 0;
   const queue: Array<() => void> = [];

From 7964765202cef0aabbb2030b476ed2ef79e96703 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 21:38:35 +0100
Subject: [PATCH 58/72] Summarize TypeScript class methods in peek

---
 packages/peek/__tests__/meta.test.ts | 38 +++++++++++++++
 packages/peek/src/index.ts           | 72 ++++++++++++++++++++++++++++
 2 files changed, 110 insertions(+)

diff --git a/packages/peek/__tests__/meta.test.ts b/packages/peek/__tests__/meta.test.ts
index acd8d36..a49d61d 100644
--- a/packages/peek/__tests__/meta.test.ts
+++ b/packages/peek/__tests__/meta.test.ts
@@ -72,6 +72,44 @@ describe('scanFolderPeek', () => {
     `);
   });
 
+  test('summarizes TypeScript class methods', async () => {
+    const root = await makeTempFolder();
+    await writeFile(
+      path.join(root, 'widget.ts'),
+      `export class Widget {
+  constructor(
+    private readonly name: string,
+  ) {}
+
+  static async create(): Promise<Widget> {
+    return new Widget('demo')
+  }
+
+  private boot(): void {
+    this.createTask()
+  }
+
+  stats(): { total: number } {
+    return { total: 1 }
+  }
+}
+`,
+    );
+
+    await expect(scanFolderPeek(root)).resolves.toMatchInlineSnapshot(`
+      "<folder path=".">
+      <file path="widget.ts" lines="17">
+      [ln 1-17] class Widget
+      [ln 2-4] method constructor
+      [ln 6-8] method create
+      [ln 10-12] method boot
+      [ln 14-16] method stats
+      </file>
+      </folder>
+      "
+    `);
+  });
+
   test('skips generated metadata and default ignored folders', async () => {
     const root = await makeTempFolder();
     await writeFile(path.join(root, GENERATED_PEEK_FILE), '# stale generated file\n');
diff --git a/packages/peek/src/index.ts b/packages/peek/src/index.ts
index c64e452..aa9b398 100644
--- a/packages/peek/src/index.ts
+++ b/packages/peek/src/index.ts
@@ -271,6 +271,9 @@ function extractTypeScriptSymbols(text: string): string[] {
         start: range.start,
         value: `${formatLineRange(range)} ${label} ${match[1]}`,
       });
+      if (label === 'class') {
+        items.push(...extractTypeScriptClassMethods(source, match.index ?? 0));
+      }
     }
   }
   items.push(...extractTypeScriptTestCalls(source));
@@ -295,6 +298,75 @@ function extractTypeScriptTestCalls(text: string): Array<{ start: number; value:
   return items;
 }
 
+function extractTypeScriptClassMethods(
+  text: string,
+  classIndex: number,
+): Array<{ start: number; value: string }> {
+  const openingBrace = text.indexOf('{', classIndex);
+  if (openingBrace === -1) return [];
+  const closingBrace = findMatchingBrace(text, openingBrace);
+  if (closingBrace === -1) return [];
+
+  const classBody = text.slice(openingBrace + 1, closingBrace);
+  const bodyOffset = openingBrace + 1;
+  const items: Array<{ start: number; value: string }> = [];
+  const methodPattern =
+    /^([ \t]+)(?:(?:public|private|protected|static|async|override|readonly|get|set)\s+)*([A-Za-z_$][\w$]*)\s*\(/gm;
+  const matches = Array.from(classBody.matchAll(methodPattern));
+  const memberIndent = Math.min(...matches.map((match) => match[1]?.length ?? 0));
+
+  for (const match of matches) {
+    if ((match[1]?.length ?? 0) !== memberIndent) continue;
+    const name = match[2];
+    if (!name || ['if', 'for', 'while', 'switch', 'catch'].includes(name)) continue;
+    const index = bodyOffset + (match.index ?? 0);
+    const blockRange = lineRangeForTypeScriptMethod(text, index, closingBrace);
+    items.push({
+      start: blockRange.start,
+      value: `${formatLineRange(blockRange)} method ${name}`,
+    });
+  }
+
+  return items;
+}
+
+function lineRangeForTypeScriptMethod(
+  text: string,
+  index: number,
+  classClosingBrace: number,
+): { start: number; end: number } {
+  const start = lineNumberAt(text, index);
+  const openingParen = text.indexOf('(', index);
+  if (openingParen === -1 || openingParen > classClosingBrace) return { start, end: start };
+
+  const closingParen = findMatchingParen(text, openingParen);
+  if (closingParen === -1 || closingParen > classClosingBrace) return { start, end: start };
+
+  const openingBrace = findMethodBodyOpeningBrace(text, closingParen, classClosingBrace);
+  if (openingBrace === -1 || openingBrace > classClosingBrace) {
+    return { start, end: lineNumberAt(text, closingParen) };
+  }
+
+  const closingBrace = findMatchingBrace(text, openingBrace);
+  if (closingBrace === -1 || closingBrace > classClosingBrace) {
+    return { start, end: lineNumberAt(text, closingParen) };
+  }
+
+  return { start, end: lineNumberAt(text, closingBrace) };
+}
+
+function findMethodBodyOpeningBrace(
+  text: string,
+  closingParen: number,
+  classClosingBrace: number,
+): number {
+  const lineEnd = text.indexOf('\n', closingParen);
+  const searchEnd = lineEnd === -1 ? classClosingBrace : Math.min(lineEnd, classClosingBrace);
+  const sameLineBrace = text.lastIndexOf('{', searchEnd);
+  if (sameLineBrace > closingParen) return sameLineBrace;
+  return text.indexOf('{', closingParen);
+}
+
 function extractPythonSymbols(text: string): string[] {
   const items: string[] = [];
   const lines = text.split(/\r?\n/);

From c7eafa8bf01ab689f788215ce3cffbfd690cff71 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 9 Jun 2026 21:42:38 +0100
Subject: [PATCH 59/72] Release peek symbol method summaries

---
 packages/peek/CHANGELOG.md | 7 +++++++
 packages/peek/package.json | 2 +-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/packages/peek/CHANGELOG.md b/packages/peek/CHANGELOG.md
index f3f1aea..f7547c1 100644
--- a/packages/peek/CHANGELOG.md
+++ b/packages/peek/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @davstack/peek
 
+## 0.1.4
+
+### Patch Changes
+
+- Sort TypeScript symbols by source line so file summaries match source order.
+- Summarize TypeScript class methods with line ranges inside large class summaries.
+
 ## 0.1.3
 
 ### Patch Changes
diff --git a/packages/peek/package.json b/packages/peek/package.json
index 8abc6e5..e17aa49 100644
--- a/packages/peek/package.json
+++ b/packages/peek/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/peek",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "MIT",
   "type": "module",
   "description": "Peek at concise, agent-friendly folder summaries.",

From 799078dbd594519e2a5a1bf3a5237b83362f2a81 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 10 Jun 2026 14:58:54 +0100
Subject: [PATCH 60/72] fix(explore skill): invoke global 'explore' binary, not
 'npx explore'

npx explore tries to fetch a nonexistent npm package; the CLI ships as a
pnpm-global linked binary. Regenerated init copy via gen:init-skills.
---
 packages/init/src/skills/explore.md | 6 +++---
 skills/explore/SKILL.md             | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/init/src/skills/explore.md b/packages/init/src/skills/explore.md
index a762e71..f12a04a 100644
--- a/packages/init/src/skills/explore.md
+++ b/packages/init/src/skills/explore.md
@@ -12,12 +12,12 @@ description: >-
 
 Scope tightly, then run (backgrounded — the harness notifies you):
 
-    npx explore submit --file ~/.davstack/specs/<slug>.md
+    explore submit --file ~/.davstack/specs/<slug>.md
 
 When the current conversation already contains the real context, prefer compact
 mode over writing a spec:
 
-    npx explore submit --compact-mode "audit supervisor handoffs"
+    explore submit --compact-mode "audit supervisor handoffs"
 
 Keep the inline compact prompt to roughly 5-10 words. Do not paste details,
 requirements, quotes, or file lists into it; the compact spec-writer reads the
@@ -27,7 +27,7 @@ history.
 
 For a **single scoped fact**, skip the spec file — inline it (no boilerplate):
 
-    npx explore submit '<goal>Exact signature + return type of resolve_query_adapter</goal> <scope>backend/src/query/adapter.py only</scope>'
+    explore submit '<goal>Exact signature + return type of resolve_query_adapter</goal> <scope>backend/src/query/adapter.py only</scope>'
 
 Many `--file` run in parallel from one command. Read the `result → <path>`
 file for the answer.
diff --git a/skills/explore/SKILL.md b/skills/explore/SKILL.md
index 5377da4..5fc9f37 100644
--- a/skills/explore/SKILL.md
+++ b/skills/explore/SKILL.md
@@ -10,12 +10,12 @@ description: >-
 
 Scope tightly, then run (backgrounded — the harness notifies you):
 
-    npx explore submit --file ~/.davstack/specs/<slug>.md
+    explore submit --file ~/.davstack/specs/<slug>.md
 
 When the current conversation already contains the real context, prefer compact
 mode over writing a spec:
 
-    npx explore submit --compact-mode "audit supervisor handoffs"
+    explore submit --compact-mode "audit supervisor handoffs"
 
 Keep the inline compact prompt to roughly 5-10 words. Do not paste details,
 requirements, quotes, or file lists into it; the compact spec-writer reads the
@@ -25,7 +25,7 @@ history.
 
 For a **single scoped fact**, skip the spec file — inline it (no boilerplate):
 
-    npx explore submit '<goal>Exact signature + return type of resolve_query_adapter</goal> <scope>backend/src/query/adapter.py only</scope>'
+    explore submit '<goal>Exact signature + return type of resolve_query_adapter</goal> <scope>backend/src/query/adapter.py only</scope>'
 
 Many `--file` run in parallel from one command. Read the `result → <path>`
 file for the answer.

From 83eea2c1172356a9fd712330485c84b7424356b6 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 10 Jun 2026 15:08:01 +0100
Subject: [PATCH 61/72] release: context-compactor@0.2.0, open-agents@1.3.0

---
 .changeset/context-compactor-spec-compaction.md |  6 ------
 packages/context-compactor/CHANGELOG.md         |  7 +++++++
 packages/context-compactor/package.json         |  2 +-
 packages/open-agents/CHANGELOG.md               | 11 +++++++++++
 packages/open-agents/package.json               |  2 +-
 5 files changed, 20 insertions(+), 8 deletions(-)
 delete mode 100644 .changeset/context-compactor-spec-compaction.md
 create mode 100644 packages/context-compactor/CHANGELOG.md

diff --git a/.changeset/context-compactor-spec-compaction.md b/.changeset/context-compactor-spec-compaction.md
deleted file mode 100644
index 7c09f5c..0000000
--- a/.changeset/context-compactor-spec-compaction.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-"@davstack/context-compactor": minor
-"@davstack/open-agents": minor
----
-
-Add `@davstack/context-compactor`: a TS-native, deterministic context-compaction package with structure-aware handlers (JSON, code, log, diff, text) and TOON output for arrays of uniform objects. open-agents now compacts spec-writer handoff history through it before generation, replacing the removed Headroom proxy integration.
diff --git a/packages/context-compactor/CHANGELOG.md b/packages/context-compactor/CHANGELOG.md
new file mode 100644
index 0000000..7bd5faf
--- /dev/null
+++ b/packages/context-compactor/CHANGELOG.md
@@ -0,0 +1,7 @@
+# @davstack/context-compactor
+
+## 0.2.0
+
+### Minor Changes
+
+- 81da911: Add `@davstack/context-compactor`: a TS-native, deterministic context-compaction package with structure-aware handlers (JSON, code, log, diff, text) and TOON output for arrays of uniform objects. open-agents now compacts spec-writer handoff history through it before generation, replacing the removed Headroom proxy integration.
diff --git a/packages/context-compactor/package.json b/packages/context-compactor/package.json
index b03eb9c..6f5d400 100644
--- a/packages/context-compactor/package.json
+++ b/packages/context-compactor/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/context-compactor",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "description": "Deterministic, TS-native context compaction for LLM agents: structure-aware reduction of tool outputs (JSON/code/logs) with retrieval pointers. No ML, no proxy.",
diff --git a/packages/open-agents/CHANGELOG.md b/packages/open-agents/CHANGELOG.md
index 09334b2..63b8bd4 100644
--- a/packages/open-agents/CHANGELOG.md
+++ b/packages/open-agents/CHANGELOG.md
@@ -1,5 +1,16 @@
 # @davstack/open-agents
 
+## 1.3.0
+
+### Minor Changes
+
+- 81da911: Add `@davstack/context-compactor`: a TS-native, deterministic context-compaction package with structure-aware handlers (JSON, code, log, diff, text) and TOON output for arrays of uniform objects. open-agents now compacts spec-writer handoff history through it before generation, replacing the removed Headroom proxy integration.
+
+### Patch Changes
+
+- Updated dependencies [81da911]
+  - @davstack/context-compactor@0.2.0
+
 ## 1.2.5
 
 ### Patch Changes
diff --git a/packages/open-agents/package.json b/packages/open-agents/package.json
index 62809a1..a2d06ec 100644
--- a/packages/open-agents/package.json
+++ b/packages/open-agents/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/open-agents",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "license": "MIT",
   "type": "module",
   "description": "Self-waiting Cursor-jobs primitive: delegate scoped explore (read-only) and fast-edit (mechanical) work to cursor-agent, harness-trackable, results persisted per job.",

From e4dfa236db6db0b28738e401e7df693640423481 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Wed, 10 Jun 2026 15:09:01 +0100
Subject: [PATCH 62/72] release: tui@0.5.5 (dependent bump)

---
 packages/tui/CHANGELOG.md | 7 +++++++
 packages/tui/package.json | 2 +-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/packages/tui/CHANGELOG.md b/packages/tui/CHANGELOG.md
index ae3fe48..3763a47 100644
--- a/packages/tui/CHANGELOG.md
+++ b/packages/tui/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @davstack/tui
 
+## 0.5.5
+
+### Patch Changes
+
+- Updated dependencies [81da911]
+  - @davstack/open-agents@1.3.0
+
 ## 0.5.4
 
 ### Patch Changes
diff --git a/packages/tui/package.json b/packages/tui/package.json
index 4b92a7d..fa178f5 100644
--- a/packages/tui/package.json
+++ b/packages/tui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@davstack/tui",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "license": "MIT",
   "type": "module",
   "description": "Long-running terminal UI that spawns, owns, and surfaces the davstack daemons (vitest-server, logs-server).",

From dffac9e5e34e14b75e21b5614eaac23d8572a10e Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 13:05:23 +0100
Subject: [PATCH 63/72] add notes

---
 feedback/explore-compact-vs-file.md           |  90 +++++++
 .../docs/telemetry-and-otel-strategy.md       | 220 ++++++++++++++++++
 2 files changed, 310 insertions(+)
 create mode 100644 feedback/explore-compact-vs-file.md
 create mode 100644 packages/logs-server/docs/telemetry-and-otel-strategy.md

diff --git a/feedback/explore-compact-vs-file.md b/feedback/explore-compact-vs-file.md
new file mode 100644
index 0000000..bc15212
--- /dev/null
+++ b/feedback/explore-compact-vs-file.md
@@ -0,0 +1,90 @@
+Reflections from running `explore` BOTH ways on the *same* task in one session, so this is a
+controlled A/B, not two unrelated jobs. Task: "produce a completion / gap-map for the
+enum-contains workstream — what's done vs outstanding vs superseded, judged against the actual
+code." I ran `--file <spec>` and `--compact-mode "map remaining enum-contains work against what
+we implemented"` back-to-back against an identical repo state, then diffed the two deliverables.
+Verdict up front: **for this task `--file` was the better output, but the reason is instructive
+and the two are genuinely complementary — neither alone was complete.**
+
+## What each produced
+
+- **`--file`** (scoped spec; I hand-wrote goal + the one supersession gotcha + the
+  committed-vs-uncommitted facts + explicit path scope): ~480-line gap-map grouped by workstream,
+  dual-sided evidence (the doc that states a goal AND the code path:line that does/doesn't satisfy
+  it), explicit DONE/PARTIAL/OUTSTANDING/SUPERSEDED labels, plus a supersession table.
+- **`--compact-mode`** (5-word inline, distilled the spec from the live transcript): one tight
+  status matrix + thematic evidence blocks. Leaner, faster to read.
+
+## The deciding difference: coverage mirrors the context source
+
+This is the real finding, and it predicts when to use which:
+
+- **`--file` covers what you point it at.** I scoped it to read `constraints/` source, so it found
+  the highest-value item in the whole audit: an existing unit test
+  (`test_substring_operator_rejected_when_allowed_values_present[contains]`) that the proposed
+  change **breaks** — a concrete ship blocker. I verified it; it does fail. Nothing in our
+  conversation had mentioned that test, so it could only be found by *systematically reading the
+  code*, which is exactly what a path-scoped spec forces.
+
+- **`--compact-mode` covers what the conversation knows.** It distilled the transcript, so it was
+  excellent at surfacing a *tension already latent in the discussion*: it independently flagged the
+  n=25-vs-r10 contradiction (baseline VSL 25/25→72 in one doc, 9/10→188 in another) as
+  "reconcile". That's a synthesis catch — it connected two things we'd touched. But it **missed the
+  breaking test**, because that test was never in the transcript.
+
+So the blind spots are symmetric and predictable: compact can't catch what wasn't discussed; file
+can't catch what you didn't scope. For a **completion/ship audit** — where unknown blockers and
+systematic coverage are the whole point — `--file` wins. For a **"where do we stand / what's
+inconsistent"** read, compact wins and at ~10× lower authoring effort (5 words vs a 40-line spec).
+
+## What compact got for free that file made me re-type
+
+Worth calling out for the SKILL.md guidance: the spec gotcha I most cared about — "later docs
+supersede earlier ones, here's the implementation reality" — compact inherited *for free* from the
+transcript. For `--file` I had to hand-write all of it into the spec, and if I'd forgotten the
+supersession note the file agent would have reported stale doc TODOs as open work. So the existing
+guidance ("prefer compact when the conversation already has the context") is right and earns its
+keep — compact is lower-effort AND less error-prone *for the context it can see*. The catch is only
+coverage of things outside the transcript.
+
+## Recommendations for the skill
+
+1. **Document the coverage-vs-context tradeoff explicitly in SKILL.md.** Current guidance frames
+   compact-vs-file as "is the context already in the conversation?" That's necessary but not
+   sufficient. Add: *compact's coverage is bounded by the transcript — it will not find blockers in
+   code that wasn't discussed. For completeness/audit/"did we miss anything" tasks, use `--file`
+   with explicit code scope, or run both.*
+
+2. **Offer a hybrid: `--compact-mode --also-scan <paths>`.** The ideal for this task was compact's
+   free transcript context PLUS a forced systematic read of named files. Today I had to choose. A
+   compact run that ALSO guarantees coverage of explicitly-named paths would have caught both the
+   contradiction and the breaking test in one job.
+
+3. **Running both is a cheap power-move — make it a documented pattern.** Two jobs on one task cost
+   little and the outputs covered each other's blind spots (file found the blocker, compact found
+   the contradiction). A one-liner in SKILL.md ("for high-stakes audits, fan out one compact + one
+   scoped file and diff them") would surface this.
+
+4. **For the deliverable shape: `--file`'s dual-sided evidence (doc-claim path:line + code-reality
+   path:line, side by side) is the more verifiable format** and should be the default the
+   spec-writer aims for, because it lets the caller re-derive each verdict in one click instead of
+   trusting a synthesis sentence.
+
+## Tool friction hit along the way (secondary, but worth fixing)
+
+- **The installed `.claude/skills/explore` copy was stale** — it pointed at an old
+  `bun .../scripts/explore.ts` CLI that rejected my inline `<goal>` with "shell-hostile chars" and
+  swept "stray 0-byte .test.ts litter". The real entrypoint is the global `explore` bin from
+  `@davstack/open-agents`. `npx explore` also failed ("could not determine executable"). A user
+  following SKILL.md's `npx explore submit` verbatim hits a dead end; the working invocation
+  (global bin, or pnpm-linked local) isn't obvious. Worth a one-line "if `npx explore` fails, the
+  bin is `@davstack/open-agents` — install/link it" note.
+- **Inline single-fact form `'<goal>..</goal> <scope>..</scope>'` is fragile** — the `<>?()` chars
+  trip a shell-hostility guard, so the documented single-fact path effectively forces you to
+  compact-mode or `--file` anyway. Either escape-handle it or drop the inline-tags form from the
+  docs.
+
+Net: both modes are good; the choice is "transcript-synthesis (compact, cheap)" vs
+"systematic-coverage-of-scoped-code (file, thorough)", and for anything where *missing something is
+the failure mode*, file — or both. The single most valuable upgrade would be letting compact-mode
+also take explicit `--also-scan` paths so you stop having to choose.
diff --git a/packages/logs-server/docs/telemetry-and-otel-strategy.md b/packages/logs-server/docs/telemetry-and-otel-strategy.md
new file mode 100644
index 0000000..405c501
--- /dev/null
+++ b/packages/logs-server/docs/telemetry-and-otel-strategy.md
@@ -0,0 +1,220 @@
+# Telemetry package: naming + OpenTelemetry strategy
+
+Design note / decision record. Captures a brainstorm on (1) renaming `logs-server`,
+(2) the Sentry↔OTel relationship and how close our store is to the OTel standard,
+(3) whether we *should* move toward OTel, and (4) the viewer / ecosystem strategy.
+
+Status: **direction agreed, churn scope not yet committed.** This is a forward-looking
+note, not yet implemented.
+
+---
+
+## 0. What this package actually is
+
+A **local, Sentry-shaped telemetry sink**. It ingests Sentry envelopes over HTTP and
+persists them to a per-repo SQLite file. One `logs` table holds three row kinds,
+discriminated by a `kind` column:
+
+- `kind='log'`   — log lines
+- `kind='span'`  — trace spans / transactions (with real `duration_ms`)
+- `kind='event'` — error/exception events (full stacktrace kept verbatim)
+
+Key properties:
+- **Optimized for coding agents** — one denormalized table queried with plain SQL.
+- **Lossless** — the full original payload is kept verbatim in the `data` column;
+  `attrs` is an *additional* convenience projection (flattened key→value) for terse
+  `->>'key'` queries. Nothing is dropped.
+- **Zero infra** — point your existing Sentry DSN at the local daemon; drop a `.db`
+  file to reset retention.
+
+---
+
+## 1. Naming: `logs-server` → `telemetry`
+
+**Problem:** "logs" describes 1 of 3 kinds — it undersells and mis-describes the package.
+The codebase had drifted into *three* competing vocabularies:
+- **logs** — package/bin/`.davstack/logs/` dir/`logs` table/docs
+- **diag** — `DIAG_*` env, `diag.*` attrs, `~/.claude/diag`, "the diag sink" comments
+- **telemetry** — README + package.json prose
+
+**Resolution:**
+- `diag` is **legacy** — it dates from when this was only a bug-diagnosis logger.
+  Diagnosis-specific behaviour already moved to the `diagnose` skill; the `diag.*`
+  bits are slated for cleanup/removal. So `diag` is **out** of the running.
+- "logs" is factually wrong. **Pick one word, use it at every layer.**
+- **Decision: `telemetry`.** It's the only word that's honest *and* collision-free at
+  every layer (package, dir, table, attr prefix) — it genuinely means "all the stuff
+  your app emits" and covers log+span+event without lying.
+
+**Words rejected and why:**
+- `trace`/`traces` — collides with `trace_id` (everywhere) and repeats the `logs` sin
+  (implies spans only).
+- `scope` — "Scope" is a core Sentry concept; collision in a Sentry-coupled tool.
+- `otel` — **over-claims**: implies OTLP-native ingest (we ingest Sentry envelopes, not
+  OTLP) and our schema isn't OTLP-conformant anyway. Also a brand/category error (OTel is
+  instrumentation+protocol, not a backend/sink). Don't bake a false promise into the name.
+- `activity` / `signals` — viable warmer/crisper roots (considered for the faint
+  "surveillance / phone-home" vibe of "telemetry"), but we stuck with `telemetry`.
+
+**Ambiguity (server vs viewer vs format):** solved by **role suffixes on a shared root**,
+matching the existing `vitest-server` convention — not by abandoning the root:
+- ingest daemon → `telemetry` (or `telemetry-server`)
+- viewer        → `telemetry-viewer` / a `telemetry view` subcommand
+- possible future subcommands: `telemetry listen` / `telemetry view`
+
+**Surveillance vibe:** kill it in the tagline ("never leaves your machine"), since this
+tool explicitly does *not* phone home.
+
+**Cost flagged (not yet committed):** it's a published package at v2.x. Renaming the npm
+package + the `logs` table is a breaking major (3.0) with migration, and the table rename
+ripples through every SQL recipe in the docs. Open question: package/bin/dir only, vs.
+also rename the `logs` table.
+
+---
+
+## 2. Sentry ↔ OTel: the relationship (clarifications)
+
+They are **not opposites.** Modern Sentry JS SDK (v8+) is **built on OpenTelemetry**, and
+our ingested data is already OTel-shaped (OTel `severity_number 1..24`, log body +
+attributes). We are already "doing OTel" — via a Sentry front door.
+
+Terminology (it's not a clean OTel-vs-OTLP split; OTLP is a *subset* of OTel):
+- **OTel (umbrella)** = data model + **semantic conventions** + SDKs + protocol.
+  The "modeling vocabulary" = the data-model + semantic-conventions specs.
+- **OTLP** = the wire protocol (HTTP/gRPC + protobuf/JSON) for transporting telemetry.
+- **Collector** = a separate deployable pipeline binary (sampling/redaction/fan-out).
+- **Sentry** = polished multi-language SDKs + a *proprietary envelope* wire format +
+  backend/UI. The "++" over raw OTel = better DX/docs, multi-language auto-instrumentation,
+  much better *error* tracking (mechanism/handled/stacktraces/error boundaries), and
+  extras like **Web Vitals** (`measurement.lcp` etc.).
+
+We chose Sentry as the **easy front door** and built our **own open local SQLite backend**
+→ no vendor lock-in on storage (more in the open-source spirit than it feels).
+
+---
+
+## 3. How close is our store to the OTel standard?
+
+**OTel-*inspired* and fully *correlatable*, but NOT OTLP-*conformant*.**
+
+Faithful to OTel:
+- **Trace correlation via `trace_id`** across all signals — the core OTel principle, nailed.
+- OTel severity model (`severity_number` 1..24; level→severity buckets match OTel exactly).
+- `recv_ts` is exactly OTel's **ObservedTimestamp** concept (server-observed vs client time).
+- All the OTel log primitives present (timestamp, trace/span ids, body, attributes).
+- **Typed attributes ARE preserved** (verbatim in `data`); `attrs` is a bonus projection,
+  not a lossy replacement.
+
+Deliberate divergences (mostly product-right for our niche):
+- **Signals merged into one table** (kind discriminator) — OTel keeps them separate. This
+  is the agent-optimization and it's correct for us.
+- Resource flattened into columns (`service`/`project`/`runtime`) vs an OTel Resource object.
+- Sentry span vocabulary (`op`/`status`/`description`) vs OTel `Name`/`Kind`/`StatusCode`.
+- Semantic-convention attrs are *preserved* but not *normalized/enforced*.
+
+Because `data` is **lossless**, we can project to OTLP later without having lost anything.
+
+---
+
+## 4. Should we move toward OTel? (strategy)
+
+Split the question: **OTel *modeling vocabulary* (cheap, helpful) vs OTLP *protocol +
+Collector* (heavy, fights our value prop).**
+
+**Lean IN (cheap wins):**
+- Preserve the semantic-convention attribute keys Sentry already emits (`http.*`, `db.*`)
+  instead of renaming to ad-hoc keys — makes a future viewer render generically.
+- Keep typed attributes (already do) and trace-correlation (already do).
+
+**Do NOT adopt:**
+- OTLP-as-our-storage protocol, or the Collector — production-aggregation infra that
+  breaks our "zero infra" pitch.
+- A metrics-signal pipeline — **not needed.** `duration_ms` + SQL `GROUP BY` covers
+  local-dev "metrics" (p95, counts, error rates). Real OTel metrics shine in *production
+  fleet* monitoring, not local single-dev debugging.
+- "Universal OTel sink/viewer" as a *goal* — that's a commodity space (Grafana, Jaeger);
+  it abandons our moat (simple, local, agent-first).
+
+**Keep our genuine advantages (do not sacrifice):**
+- Single denormalized table + SQL → optimal for an LLM reader (`WHERE trace_id = ?`
+  returns the full interleaved timeline, no UNION/join).
+- Zero infra (a sqlite file), one-line DSN setup, lossless `data`.
+- **Web Vitals / `measurement.*` are a real Sentry "++", not a gap** — keep them; they
+  export to OTel as span attributes (OTel tools just won't special-render them).
+
+**Table shape note:** logs + spans + events are all "events on a timeline" → one table
+fits them naturally. **Metrics** (if ever added) are aggregatable series → that would be
+the natural *second* table. 3 tables wouldn't complicate infra, but buys nothing for
+compatibility (the exporter reads any layout) and is worse for the headline agent query;
+use **views** if per-signal ergonomics are ever wanted.
+
+---
+
+## 5. Viewer / ecosystem strategy
+
+**Key fact:** otel-tui and otel-desktop-viewer are **OTLP *receivers*** — they listen on
+the wire (gRPC 4317 / HTTP 4318), hold telemetry in memory, and render it. They do **not**
+read a sqlite file.
+
+**Compatibility = a thin one-way OTLP *exporter* bridge** (cheap *because* `data` is
+lossless): `davstack telemetry export --otlp localhost:4318` reads rows and replays them
+as OTLP. This lights up otel-tui / Jaeger / Grafana **for free, with zero changes to our
+storage or Sentry ingest path.**
+
+- Make it **on-demand / incremental-poll**, NOT a live second sink. (Two always-on sinks
+  is the bad practice to avoid.) Incremental export (`WHERE id > last_seen` every ~10s,
+  encode OTLP, POST) is trivially cheap — the poll cost is a non-issue.
+- Steady-state footprint stays **one daemon**; the viewer is ephemeral.
+
+**Do NOT clone otel-tui into davstack tui.** davstack tui is **Ink + React + TypeScript**;
+otel-tui is **Go**. "Clone" across that boundary = a rewrite, or maintaining a foreign Go
+fork + shipping a second binary — exactly the custom-maintenance burden we want to avoid,
+and it *still* wouldn't embed (Go TUI takes over the terminal). It also wouldn't give
+topology (otel-tui doesn't do service maps) and renders our extras only generically.
+
+**Two integration levels, matched to language:**
+
+| Goal | Integrate by | How |
+|---|---|---|
+| Tap the ecosystem (Go tools: otel-tui/Jaeger/Grafana) | **protocol** | OTLP export; orchestrate as a subprocess (davstack tui "launch viewer" suspends Ink, hands over terminal, resumes) |
+| Inside davstack tui + native rendering of *our* shape | **code** | a small native **Ink/React panel reading sqlite directly** — same language, actually embeddable |
+
+Resolving the confusion: the thing you can truly *embed* in davstack tui is a **native
+panel** (not otel-tui — wrong language); the thing that *taps the ecosystem* is the **OTLP
+export** (not embedding). Reserve "custom" for the gaps the ecosystem won't render.
+
+---
+
+## 6. Topology (the one resource-model piece worth adopting)
+
+A service topology graph is **derivable from data we already capture**:
+- **Nodes** = services. **Edges** = a span in service A with a child span in service B.
+- We already have `trace_id` + `span_id` + `parent_span_id` (in attrs) + a per-row service.
+
+**The one gap = node identity.** Current `service` is `sdk.name`
+(`sentry.javascript.node` vs `…react`) — enough to tell *browser from server*, but not
+"api" from "worker" if both are Node. For real topology, capture a **logical
+`service.name`** per app (set once per service via a Sentry tag/attribute) and promote it
+to a column. Then: nodes = distinct service names; edges = cross-service parent/child spans;
+render in the **native** viewer (off-the-shelf OTel TUIs won't do this).
+
+This is *selective* adoption: take the one resource field topology needs, skip the rest of
+the resource spec.
+
+---
+
+## 7. Recommended sequence
+
+1. **(Decision)** Rename `logs` → `telemetry` (root + role suffixes). Decide churn scope:
+   package/bin/dir only vs. also the `logs` table (breaking 3.0 + doc-recipe churn).
+2. **Cheap OTel-vocabulary alignment**: preserve semantic-convention attr keys.
+3. **Ship the OTLP export + poll bridge first** — smallest ecosystem win; validates the
+   lossless-`data` → OTLP thesis; davstack tui gets a "launch viewer" action.
+4. **Build a native Ink panel only for the gaps** (topology, Web Vitals, error rows) — in
+   our own stack, where embedding is cheap and "custom" is justified.
+
+## Open questions
+- Rename churn scope (table or not?).
+- Whether to build the native viewer at all, or stop at the OTLP bridge.
+- Final tagline wording (carry "OpenTelemetry-shaped, Sentry-easy, never leaves your
+  machine").

From 0ad389dbf77d9bcb6232bd02c367c7d38c2ec503 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 13:05:33 +0100
Subject: [PATCH 64/72] add fix at commits skill

---
 skills/fix-at-commits/SKILL.md          |  18 ++
 skills/fix-at-commits/fix-at-commits.ts | 208 ++++++++++++++++++++++++
 2 files changed, 226 insertions(+)
 create mode 100644 skills/fix-at-commits/SKILL.md
 create mode 100644 skills/fix-at-commits/fix-at-commits.ts

diff --git a/skills/fix-at-commits/SKILL.md b/skills/fix-at-commits/SKILL.md
new file mode 100644
index 0000000..4a70b72
--- /dev/null
+++ b/skills/fix-at-commits/SKILL.md
@@ -0,0 +1,18 @@
+---
+name: fix-at-commits
+description: >-
+  Strip the stray leading `@` from unpushed commit messages (a PowerShell
+  here-string glitch that buries the real subject under a bare `@` line).
+  Use when commits show up as `@ <subject>` in git log or the first line
+  looks blank/invisible.
+---
+
+Run from the repo root (dry-run first, shows before/after):
+
+    bun ~/.claude/skills/fix-at-commits/fix-at-commits.ts            # preview
+    bun ~/.claude/skills/fix-at-commits/fix-at-commits.ts --apply    # rewrite
+
+Safe by design: only touches UNPUSHED commits, refuses detached HEAD / merge
+commits, never touches the working tree (pure `git commit-tree`), preserves
+author + dates, backs up the tip first, and verifies the rewritten tree is
+identical before moving the branch. Restore/cleanup commands are printed on apply.
diff --git a/skills/fix-at-commits/fix-at-commits.ts b/skills/fix-at-commits/fix-at-commits.ts
new file mode 100644
index 0000000..d1654f2
--- /dev/null
+++ b/skills/fix-at-commits/fix-at-commits.ts
@@ -0,0 +1,208 @@
+/**
+ * fix-at-commits.ts
+ *
+ * Fixes the "@ at the start of the commit message" corruption that sometimes
+ * happens when committing through PowerShell here-strings: the real first line
+ * ends up as a bare `@`, pushing the true subject down to line 2. `git log`
+ * then shows `@ <subject>` and any tool that shows only line 1 shows just `@`.
+ *
+ * What it does, carefully:
+ *   - Operates ONLY on UNPUSHED commits (`git rev-list HEAD --not --remotes`).
+ *     Anything already on a remote is never touched.
+ *   - Refuses to run on a detached HEAD or if the unpushed range contains a
+ *     merge commit (keeps us to simple linear history).
+ *   - Rebuilds commits with `git commit-tree` (pure plumbing): SAME tree, SAME
+ *     author + author/committer dates, only the message changes. Your working
+ *     tree and index are never touched.
+ *   - Dry-run by default. Pass `--apply` to actually rewrite.
+ *   - Before rewriting it saves a backup ref and, after rewriting, verifies the
+ *     new branch tip has a byte-identical tree to the backup. If anything looks
+ *     off it aborts without moving your branch.
+ *
+ * Usage (from repo root):
+ *   bun scripts/fix-at-commits.ts            # dry-run: show what would change
+ *   bun scripts/fix-at-commits.ts --apply    # rewrite the unpushed commits
+ */
+
+import { execFileSync } from "node:child_process";
+
+const APPLY = process.argv.includes("--apply");
+
+function git(args: string[], opts: { input?: string } = {}): string {
+  return execFileSync("git", args, {
+    input: opts.input,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+  }).toString();
+}
+
+function fail(msg: string): never {
+  console.error(`\n✖ ${msg}\n`);
+  process.exit(1);
+}
+
+/** Strip the leading `@` corruption from a raw commit message (%B). */
+function fixMessage(raw: string): string {
+  const lines = raw.split("\n");
+  if (lines[0]?.trim() === "@") {
+    // The classic case: a bare `@` line above the real subject. Drop it.
+    lines.shift();
+  } else if (/^@\s+/.test(lines[0] ?? "")) {
+    // Defensive: `@ subject` collapsed onto one line. Strip the prefix.
+    lines[0] = lines[0].replace(/^@\s+/, "");
+  } else {
+    return raw; // no corruption
+  }
+  return lines.join("\n");
+}
+
+// ── 1. Sanity: we must be on a real branch ──────────────────────────────────
+const branch = git(["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+if (branch === "HEAD") {
+  fail("HEAD is detached. Check out a branch first; refusing to rewrite.");
+}
+
+// ── 2. Collect unpushed commits, oldest → newest ────────────────────────────
+const unpushed = git(["rev-list", "--reverse", "HEAD", "--not", "--remotes"])
+  .split("\n")
+  .map((s) => s.trim())
+  .filter(Boolean);
+
+if (unpushed.length === 0) {
+  console.log("Nothing to do: no unpushed commits on this branch.");
+  process.exit(0);
+}
+
+// ── 3. Refuse merge commits in the range (keeps the rebuild linear & safe) ──
+const merges = git(["rev-list", "--reverse", "HEAD", "--not", "--remotes", "--merges"])
+  .split("\n")
+  .map((s) => s.trim())
+  .filter(Boolean);
+if (merges.length > 0) {
+  fail(
+    `Unpushed range contains merge commit(s):\n  ${merges.join("\n  ")}\n` +
+      `Refusing to rewrite automatically. Fix these by hand.`,
+  );
+}
+
+// ── 4. Figure out the base (parent of the oldest unpushed commit) ───────────
+const oldest = unpushed[0];
+const base = git(["rev-parse", `${oldest}^`]).trim();
+
+// ── 5. Capture each commit's metadata + computed new message ────────────────
+interface Plan {
+  sha: string;
+  tree: string;
+  msg: string;
+  newMsg: string;
+  changed: boolean;
+  an: string;
+  ae: string;
+  ad: string;
+  cn: string;
+  ce: string;
+  cd: string;
+}
+
+const SEP = "\x1f"; // unit separator: legal in argv, never in names/emails/ISO dates
+const plans: Plan[] = unpushed.map((sha) => {
+  // Pull author/committer identity + ISO dates in one separated record.
+  const rec = git([
+    "show",
+    "-s",
+    `--format=%an${SEP}%ae${SEP}%aI${SEP}%cn${SEP}%ce${SEP}%cI`,
+    sha,
+  ]);
+  const [an, ae, ad, cn, ce, cd] = rec.split(SEP);
+  const tree = git(["rev-parse", `${sha}^{tree}`]).trim();
+  const msg = git(["log", "-1", "--format=%B", sha]);
+  const newMsg = fixMessage(msg);
+  if (newMsg.trim().length === 0) {
+    fail(`Fixing ${sha} would leave an empty message. Aborting; nothing changed.`);
+  }
+  return { sha, tree, msg, newMsg, changed: newMsg !== msg, an, ae, ad, cn, ce, cd };
+});
+
+const changedCount = plans.filter((p) => p.changed).length;
+
+// ── 6. Report ───────────────────────────────────────────────────────────────
+console.log(`Branch:           ${branch}`);
+console.log(`Base (unchanged): ${base.slice(0, 12)}`);
+console.log(`Unpushed commits: ${plans.length}`);
+console.log(`Need fixing:      ${changedCount}\n`);
+
+for (const p of plans) {
+  if (!p.changed) continue;
+  const before = p.msg.split("\n")[0] || "(blank)";
+  const after = p.newMsg.split("\n")[0];
+  console.log(`  ${p.sha.slice(0, 8)}`);
+  console.log(`    before subject: ${JSON.stringify(before)}`);
+  console.log(`    after  subject: ${JSON.stringify(after)}`);
+}
+
+if (changedCount === 0) {
+  console.log("\nNo `@`-prefixed messages found. Nothing to do.");
+  process.exit(0);
+}
+
+if (!APPLY) {
+  console.log(`\nDry run. Re-run with --apply to rewrite these ${changedCount} commit(s).`);
+  process.exit(0);
+}
+
+// ── 7. Backup the current tip before doing anything ─────────────────────────
+const originalHead = git(["rev-parse", "HEAD"]).trim();
+const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+const backupRef = `refs/backup/fix-at-commits/${branch}/${stamp}`;
+git(["update-ref", backupRef, originalHead]);
+console.log(`\nBacked up current tip → ${backupRef}`);
+
+// ── 8. Rebuild the chain with commit-tree (does not touch working tree/index)
+let parent = base;
+for (const p of plans) {
+  const env = {
+    ...process.env,
+    GIT_AUTHOR_NAME: p.an,
+    GIT_AUTHOR_EMAIL: p.ae,
+    GIT_AUTHOR_DATE: p.ad,
+    GIT_COMMITTER_NAME: p.cn,
+    GIT_COMMITTER_EMAIL: p.ce,
+    GIT_COMMITTER_DATE: p.cd,
+  };
+  const newSha = execFileSync("git", ["commit-tree", p.tree, "-p", parent], {
+    input: p.newMsg,
+    encoding: "utf8",
+    env,
+  })
+    .toString()
+    .trim();
+  parent = newSha;
+}
+const newHead = parent;
+
+// ── 9. Verify the rebuilt tip is content-identical to the backup ────────────
+try {
+  git(["diff", "--quiet", originalHead, newHead]);
+} catch {
+  fail(
+    `Rebuilt tree differs from the original! NOT moving ${branch}.\n` +
+      `Original is safe at ${backupRef} (and your branch is unchanged).`,
+  );
+}
+const newCount = git(["rev-list", "--count", `${base}..${newHead}`]).trim();
+if (newCount !== String(plans.length)) {
+  fail(
+    `Commit count mismatch (${newCount} vs ${plans.length}). NOT moving ${branch}.\n` +
+      `Original is safe at ${backupRef}.`,
+  );
+}
+
+// ── 10. Move the branch (with old-value guard against concurrent changes) ───
+git(["update-ref", "-m", "fix-at-commits: strip leading @", `refs/heads/${branch}`, newHead, originalHead]);
+
+console.log(`\n✔ Rewrote ${changedCount} commit message(s). Trees verified identical.`);
+console.log(`  ${branch}: ${originalHead.slice(0, 12)} → ${newHead.slice(0, 12)}`);
+console.log(`\nIf anything looks wrong, restore with:`);
+console.log(`  git reset --hard ${backupRef}`);
+console.log(`Once you're happy, you can drop the backup:`);
+console.log(`  git update-ref -d ${backupRef}`);

From 5c4a33d06cfdb0d4603d5e3a5b96014d5f7a88ac Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 13:12:32 +0100
Subject: [PATCH 65/72] feat(fn): add @davstack/fn package

---
 packages/fn/.eslintrc.js                      |    8 +
 packages/fn/CHANGELOG.md                      |   19 +
 packages/fn/FUTURE-add-retries.spec.md        |  158 +
 packages/fn/README.md                         |  220 +
 packages/fn/fn-api.idea.ts                    |  174 +
 packages/fn/notes/improvements.md             |  316 ++
 packages/fn/notes/type-requirements.md        |    5 +
 packages/fn/notes/why-pipe-over-middleware.md |  170 +
 packages/fn/package.json                      |   39 +
 packages/fn/src/create-fn.ts                  |  444 ++
 packages/fn/src/errors.ts                     |  153 +
 packages/fn/src/index.ts                      |    9 +
 packages/fn/src/pipe.ts                       | 4247 +++++++++++++++++
 packages/fn/src/utils/form-data.ts            |   57 +
 .../fn/src/utils/init-procedure-factory.ts    |   96 +
 packages/fn/src/utils/type-utils.ts           |   41 +
 packages/fn/test/composition.test.ts          |  638 +++
 packages/fn/test/core.test.ts                 |  230 +
 packages/fn/test/error-reporting.test.ts      |  192 +
 packages/fn/test/error.test.ts                |  101 +
 .../fn/test/init-procedure-factory.test.ts    |   58 +
 packages/fn/test/test-utils.ts                |  118 +
 packages/fn/test/tracing.test.ts              |  166 +
 packages/fn/test/types.test.ts                |   60 +
 packages/fn/tsconfig.json                     |    8 +
 packages/fn/tsup.config.ts                    |    8 +
 pnpm-lock.yaml                                |  100 +-
 vitest.workspace.ts                           |   14 +
 28 files changed, 7837 insertions(+), 12 deletions(-)
 create mode 100644 packages/fn/.eslintrc.js
 create mode 100644 packages/fn/CHANGELOG.md
 create mode 100644 packages/fn/FUTURE-add-retries.spec.md
 create mode 100644 packages/fn/README.md
 create mode 100644 packages/fn/fn-api.idea.ts
 create mode 100644 packages/fn/notes/improvements.md
 create mode 100644 packages/fn/notes/type-requirements.md
 create mode 100644 packages/fn/notes/why-pipe-over-middleware.md
 create mode 100644 packages/fn/package.json
 create mode 100644 packages/fn/src/create-fn.ts
 create mode 100644 packages/fn/src/errors.ts
 create mode 100644 packages/fn/src/index.ts
 create mode 100644 packages/fn/src/pipe.ts
 create mode 100644 packages/fn/src/utils/form-data.ts
 create mode 100644 packages/fn/src/utils/init-procedure-factory.ts
 create mode 100644 packages/fn/src/utils/type-utils.ts
 create mode 100644 packages/fn/test/composition.test.ts
 create mode 100644 packages/fn/test/core.test.ts
 create mode 100644 packages/fn/test/error-reporting.test.ts
 create mode 100644 packages/fn/test/error.test.ts
 create mode 100644 packages/fn/test/init-procedure-factory.test.ts
 create mode 100644 packages/fn/test/test-utils.ts
 create mode 100644 packages/fn/test/tracing.test.ts
 create mode 100644 packages/fn/test/types.test.ts
 create mode 100644 packages/fn/tsconfig.json
 create mode 100644 packages/fn/tsup.config.ts

diff --git a/packages/fn/.eslintrc.js b/packages/fn/.eslintrc.js
new file mode 100644
index 0000000..5333046
--- /dev/null
+++ b/packages/fn/.eslintrc.js
@@ -0,0 +1,8 @@
+module.exports = {
+	root: true,
+	extends: ['@davstack/eslint-config/library.js'],
+	parser: '@typescript-eslint/parser',
+	parserOptions: {
+		project: true,
+	},
+};
diff --git a/packages/fn/CHANGELOG.md b/packages/fn/CHANGELOG.md
new file mode 100644
index 0000000..aecf7c7
--- /dev/null
+++ b/packages/fn/CHANGELOG.md
@@ -0,0 +1,19 @@
+# @davstack/service
+
+## 0.1.6
+
+### Patch Changes
+
+- change internals for trpc integration to try fix build type issues
+
+## 0.1.5
+
+### Patch Changes
+
+- fix tsup building broken types bug (zInfer name conflict)
+
+## 0.1.0
+
+### Minor Changes
+
+- bfde332: publish initial service version
diff --git a/packages/fn/FUTURE-add-retries.spec.md b/packages/fn/FUTURE-add-retries.spec.md
new file mode 100644
index 0000000..04445fb
--- /dev/null
+++ b/packages/fn/FUTURE-add-retries.spec.md
@@ -0,0 +1,158 @@
+```ts
+fn(['CallSaveManager', key])
+  .options({
+    retry: {
+      maxRetries: 5,
+      backoffFactor: 3
+    }
+  })
+  .input({...})
+```
+
+for now not implemented as changing the ai calls to be sequentail rather than parallel (and adding small delay beetween ai calls) inside @save-call-manger has sovled the issue
+(i think, lets see if issue comes up agian in future)
+
+retries are built into ai package but could be helpful to add as general reusable functioanlity to fn
+
+INSPIRATION (each one of tehse files also has tests that i could copy, just give credit at top of file):
+
+https://github.com/vercel/ai/blob/main/packages/ai/core/prompt/prepare-retries.ts
+
+```ts
+import { InvalidArgumentError } from '../../errors/invalid-argument-error';
+import {
+	RetryFunction,
+	retryWithExponentialBackoff,
+} from '../../util/retry-with-exponential-backoff';
+
+/**
+ * Validate and prepare retries.
+ */
+export function prepareRetries({
+	maxRetries,
+}: {
+	maxRetries: number | undefined;
+}): {
+	maxRetries: number;
+	retry: RetryFunction;
+} {
+	if (maxRetries != null) {
+		if (!Number.isInteger(maxRetries)) {
+			throw new InvalidArgumentError({
+				parameter: 'maxRetries',
+				value: maxRetries,
+				message: 'maxRetries must be an integer',
+			});
+		}
+
+		if (maxRetries < 0) {
+			throw new InvalidArgumentError({
+				parameter: 'maxRetries',
+				value: maxRetries,
+				message: 'maxRetries must be >= 0',
+			});
+		}
+	}
+
+	const maxRetriesResult = maxRetries ?? 2;
+
+	return {
+		maxRetries: maxRetriesResult,
+		retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult }),
+	};
+}
+```
+
+SOURCE 2: https://github.com/vercel/ai/blob/main/packages/ai/util/retry-with-exponential-backoff.ts
+
+how the factor works:
+
+1. Increase Retry Factor: Changing the exponential backoff factor from 2 to 5 could help, but:
+   With factor 2: intervals grow like 1s, 2s, 4s, 8s...
+   With factor 5: intervals grow much faster: 1s, 5s, 25s, 125s...
+   This gives Claude more time to recover between retries
+
+```ts
+import { APICallError } from '@ai-sdk/provider';
+import { delay, getErrorMessage, isAbortError } from '@ai-sdk/provider-utils';
+import { RetryError } from './retry-error';
+
+export type RetryFunction = <OUTPUT>(
+	fn: () => PromiseLike<OUTPUT>
+) => PromiseLike<OUTPUT>;
+
+/**
+The `retryWithExponentialBackoff` strategy retries a failed API call with an exponential backoff.
+You can configure the maximum number of retries, the initial delay, and the backoff factor.
+ */
+export const retryWithExponentialBackoff =
+	({
+		maxRetries = 2,
+		initialDelayInMs = 2000,
+		backoffFactor = 2,
+	} = {}): RetryFunction =>
+	async <OUTPUT>(f: () => PromiseLike<OUTPUT>) =>
+		_retryWithExponentialBackoff(f, {
+			maxRetries,
+			delayInMs: initialDelayInMs,
+			backoffFactor,
+		});
+
+async function _retryWithExponentialBackoff<OUTPUT>(
+	f: () => PromiseLike<OUTPUT>,
+	{
+		maxRetries,
+		delayInMs,
+		backoffFactor,
+	}: { maxRetries: number; delayInMs: number; backoffFactor: number },
+	errors: unknown[] = []
+): Promise<OUTPUT> {
+	try {
+		return await f();
+	} catch (error) {
+		if (isAbortError(error)) {
+			throw error; // don't retry when the request was aborted
+		}
+
+		if (maxRetries === 0) {
+			throw error; // don't wrap the error when retries are disabled
+		}
+
+		const errorMessage = getErrorMessage(error);
+		const newErrors = [...errors, error];
+		const tryNumber = newErrors.length;
+
+		if (tryNumber > maxRetries) {
+			throw new RetryError({
+				message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+				reason: 'maxRetriesExceeded',
+				errors: newErrors,
+			});
+		}
+
+		if (
+			error instanceof Error &&
+			APICallError.isInstance(error) &&
+			error.isRetryable === true &&
+			tryNumber <= maxRetries
+		) {
+			await delay(delayInMs);
+			return _retryWithExponentialBackoff(
+				f,
+				{ maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+				newErrors
+			);
+		}
+
+		if (tryNumber === 1) {
+			throw error; // don't wrap the error when a non-retryable error occurs on the first try
+		}
+
+		throw new RetryError({
+			message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+			reason: 'errorNotRetryable',
+			errors: newErrors,
+		});
+	}
+}
+```
diff --git a/packages/fn/README.md b/packages/fn/README.md
new file mode 100644
index 0000000..fc9a8df
--- /dev/null
+++ b/packages/fn/README.md
@@ -0,0 +1,220 @@
+# Davstack Service
+
+Davstack Service is simple and flexible library for building backend services with TypeScript.
+
+### Why Use Davstack Service?
+
+- 🏠 Simple and familiar syntax - middleware, input and outputs inspired by trpc procedures
+- 🧩 Flexible - Works well with next js server actions as well as trpc
+- ✅ Typescript first - inferred input/output types and middleware
+
+### Installation
+
+```bash
+npm install zod @davstack/service
+```
+
+Visit the [DavStack Service Docs](https://davstack.com/service/overview) for more information and examples, such as this [trpc usage example](https://davstack.com/service/trpc-usage-example).
+
+## Demo Usage
+
+- The service definition replaces tRPC procedures, but the syntax is very similar.
+- Once the service is integrated into tRPC routers, the API is the same as any other tRPC router.
+
+## Composing Services example
+
+```ts
+// api/services/invoice.ts
+import { authedService, publicService } from '@/lib/service';
+
+// Service composed from range of other services:
+
+export const mailAiGeneratedInvoice = authedService
+	.input(z.object({ to: z.string(), projectId: z.string() }))
+	.query(async ({ ctx, input }) => {
+		await checkSufficientCredits(ctx, { amount: 10 });
+
+		const pdf = await generatePdf(ctx, { html: project.invoiceHtml });
+
+		await sendEmail(ctx, {
+			to: input.to,
+			subject: 'Invoice',
+			body: 'Please find attached your invoice',
+			attachments: [{ filename: 'invoice.pdf', content: pdf }],
+		});
+
+		await deductCredits(ctx, { amount: 10 });
+
+		return 'Invoice sent';
+	});
+
+export const generatePdf = authedService
+	.input(z.object({ html: z.string() }))
+	.query(async ({ ctx, input }) => {
+		// complex business logic here
+		return pdf;
+	});
+
+export const sendEmail = authedService
+	.input(z.object({ to: z.string(), subject: z.string(), body: z.string() }))
+	.query(async ({ ctx, input }) => {
+		// complex business logic here
+		return 'Email sent';
+	});
+
+export const checkSufficientCredits = authedService
+	.input(z.object({ amount: z.number() }))
+	.query(async ({ ctx, input }) => {
+		// complex business logic here
+		return 'Sufficient funds';
+	});
+
+// ... etc
+```
+
+Integrate your services with tRPC with 0 boilerplate. Works just like any other tRPC router.
+
+```ts
+// api/router.ts
+
+import * as invoiceServices from '@/api/services/invoice';
+import { createTRPCRouter } from '@/lib/trpc';
+import {
+	createTrpcProcedureFromService,
+	createTrpcRouterFromServices,
+} from '@davstack/service';
+
+export const appRouter = createTRPCRouter({
+	invoice: createTrpcRouterFromServices(invoiceServices),
+});
+```
+
+### Middleware Example
+
+Define your services with reusable middleware in a separate file, and export them for reuse.
+
+```ts
+// lib/service.ts
+import { service } from '@davstack/service';
+import { db } from '@/lib/db';
+
+// Define the context types for your services
+export type PublicServiceCtx = {
+	user: { id: string; role: string } | undefined;
+	db: typeof db;
+};
+export type AuthedServiceCtx = Required<PublicServiceCtx>;
+
+// export your services
+export const publicService = service<PublicServiceCtx>();
+
+export const authedService = service<AuthedServiceCtx>().use(
+	async ({ ctx, next }) => {
+		// Only allows authenticate users to access this service
+		if (!ctx.user) {
+			throw new Error('Unauthorized');
+		}
+		return next(ctx);
+	}
+);
+
+export function createServiceCtx() {
+	const user = auth();
+	return { user, db };
+}
+```
+
+Import the public / authed service builders from the service
+
+```ts
+// api/services/some-service.ts
+import { publicService, authedService } from '@/lib/service';
+
+export const getSomePublicData = publicService.query(async ({ ctx }) => {
+	return 'Public data';
+});
+
+export const getSomeUserData = authedService.query(async ({ ctx }) => {
+	// will throw an error if ctx.user is undefined
+	return 'Protected data';
+});
+```
+
+Specify the input and output schemas for your service for validation and type safety, and use the ctx/input arguments to access the service context and input data.
+
+```ts
+// api/services/task-services.ts
+import { service } from '@davstack/service';
+import { z } from 'zod';
+
+const getTasks = service()
+	.input(z.object({ projectId: z.string() }))
+	.query(async ({ ctx, input }) => {
+		return ctx.db.tasks.findMany({ where: { projectId: input.projectId } });
+	});
+```
+
+### Direct Service Usage
+
+Unlike tRPC procedures, services can be called directly from anywhere in your backend, including within other services.
+
+```typescript
+const ctx = createServiceCtx(); // or get ctx from parent service
+const tasks = await getTasks(ctx, { projectId: '...' });
+```
+
+This allows you to build complex service logic by composing multiple services together.
+
+```typescript
+const getProjectDetails = service()
+	.input(z.object({ projectId: z.string() }))
+	.output(
+		z.object({
+			id: z.string(),
+			name: z.string(),
+			tasks: getTasks.outputSchema,
+		})
+	)
+	.query(async ({ ctx, input }) => {
+		const project = await getProject(ctx, { projectId: input.projectId });
+		const tasks = await getTasks(ctx, { projectId: input.projectId });
+		return { ...project, tasks };
+	});
+```
+
+### tRPC Integration
+
+Seamlessly integrate with tRPC to create type-safe API endpoints.
+
+```ts
+import { initTRPC } from '@trpc/server';
+import { createTrpcRouterFromServices } from '@davstack/service';
+import * as taskServices from './services/tasks';
+import * as projectServices from './services/projects';
+import { sendFeedback } from './services/send-feedback';
+
+const t = initTRPC();
+
+const appRouter = t.router({
+	tasks: createTrpcRouterFromServices(taskServices),
+	projects: createTrpcRouterFromServices(projectServices),
+	// or create a single procedure from a service
+	sendFeedback: createTrpcProcedureFromService(sendFeedback),
+});
+```
+
+NOTE: it is recommended to use the `* as yourServicesName` syntax. Otherwise, ctrl+click on the tRPC client handler will navigate you to the app router file, instead of the specific service definition.
+
+### Acknowledgements
+
+Davstack Store has been heavily inspired by [tRPC](https://trpc.io/), a fantastic library for building type-safe APIs. A big shout-out to the tRPC team for their amazing work.
+
+Nick-Lucas, a tRPC contributor, inspired the creation of Davstack Service with his [github comment](https://github.com/trpc/trpc/discussions/4839#discussioncomment-8224476). He suggested "making controllers minimal" and "to separate your business logic from the API logic", which is exactly what Davstack Service aims to do.
+
+### Contributing
+
+Contributions are welcome! Please read our [contributing guide](link-to-contributing-guide) for details on our code of conduct and the submission process.
+
+### License
+
+This project is licensed under the [MIT License](link-to-license). See the LICENSE file for details.
diff --git a/packages/fn/fn-api.idea.ts b/packages/fn/fn-api.idea.ts
new file mode 100644
index 0000000..204c135
--- /dev/null
+++ b/packages/fn/fn-api.idea.ts
@@ -0,0 +1,174 @@
+// @ts-nocheck
+
+import { baseFn, FnError, redactSensitive } from '@ream/fn';
+
+import { logger, redactSensitiveDataFromClaudeErrors } from '@api/lib/logger';
+import { enhance, prisma, type PrismaClient } from '@ream/db';
+
+import { z, ZodType } from 'zod';
+
+// const createServerFn = baseFn(key)
+// 		.use(baseContextMiddleware)
+// 		.use(loggingMiddleware)
+// 		.use(authedMiddleware)
+// 		.use(errorMiddleware);
+
+// const baseContextMiddleware = createMiddleware(({ ctx, next }) =>
+// 	next(createServiceCtx(ctx.user))
+// );
+
+
+// const errorMiddleware = createMiddleware(({ ctx, next }) => {
+// 	// wrap function in error handling
+// 	return next(ctx);
+// });
+
+// const loggingMiddleware = createMiddleware(({ ctx, next }) =>
+// 	// wrap function in logging
+// 	return next(ctx);
+// );
+// const authedMiddleware = createMiddleware(({ ctx, next }) => {
+// 	if (!ctx.user.id) {
+// 		throw new FnError({
+// 			code: 'UNAUTHORIZED',
+// 			message: 'Unauthorized',
+// 		});
+// 	}
+// 	return next(ctx);
+// });
+
+export const createServiceCtx = (
+	_user?: Partial<User> & { db?: PrismaClient }
+) => {
+	const user = {
+		id: _user?.id ?? '',
+		email: _user?.email ?? '',
+		role: 'USER' as const,
+	};
+
+	const db = _user?.db ?? enhance(prisma, { user });
+
+	return { db, user };
+};
+
+export type User = {
+	id: string;
+	email: string;
+	role?: 'USER' | 'ADMIN';
+};
+export type ServerFnCtx = {
+	logger: Logger;
+	db: PrismaClient;
+	user?: User;
+};
+export type ServerFnCtxAuthed = Required<ServerFnCtx>;
+
+export const createAuthedServerFn = createServerFn.use(
+	async ({ ctx, next }) => {
+		if (!ctx.user.id) {
+			throw new FnError({
+				code: 'UNAUTHORIZED',
+				message: 'Unauthorized',
+			});
+		}
+		return next(ctx);
+	}
+);
+
+export const createPublicServerFn = createServerFn;
+
+// Easier to type, but less ideal:
+// export const createAuthedServerFn = (key: string) =>
+// 	createServerFn<ServerFnCtxAuthed>(key).use(async ({ ctx, next }) => {
+// 		if (!ctx.user.id) {
+// 			throw new FnError({
+// 				code: 'UNAUTHORIZED',
+// 				message: 'Unauthorized',
+// 			});
+// 		}
+// 		return next(ctx);
+// 	});
+
+// export const createPublicServerFn = (key: string) =>
+// 	createServerFn<ServerFnCtx>(key).use(async ({ ctx, next }) => {
+// 		return next(ctx);
+// 	});
+
+// ===== Define Server Functions =====
+
+// basic example:
+
+const createChat = createAuthedServerFn({
+	name: 'createChat',
+	tags: ['chat'],
+	inputSchema: z.object({
+		title: z.string(),
+	}),
+	handler: async ({ input, ctx }) => {
+		return ctx.db.chat.create({
+			data: {
+				title: input.title,
+			},
+		});
+	},
+});
+
+// nested example:
+
+const sendWelcomeText = createAuthedServerFn({
+	name: 'sendWelcomeText',
+	tags: ['sms', 'credits'],
+	description: ` 
+	- Ensures the user has enough credits
+  - Generates a personalized welcome text
+  - Sends the welcome text to the user
+	`,
+	inputSchema: z.object({
+		chatId: z.string(),
+	}),
+	outputSchema: z.object({
+		success: z.boolean(),
+	}),
+	handler: async ({ input, ctx }) => {
+		const canSend = checkCredits({
+			ctx,
+			input: {
+				actionType: 'send-welcome-text',
+			},
+		});
+
+		if (!canSend) {
+			throw new FnError({
+				code: 'INSUFFICIENT_CREDITS',
+				message: 'Insufficient credits',
+			});
+		}
+
+		const personalizedWelcomeText = await generatePersonalizedWelcomeText({
+			ctx,
+		});
+
+		const status = await sendSms({
+			ctx,
+			input: {
+				phoneNumber: input.phoneNumber,
+				message: personalizedWelcomeText,
+			},
+		});
+
+		return status;
+	},
+});
+
+// ===== Use Server Functions =====
+
+const 
+
+const ctx = createServiceCtx(await getUser(cookies()));
+
+const chat = createChat({
+	ctx,
+	input: {
+		title: 'Hello',
+	},
+});
\ No newline at end of file
diff --git a/packages/fn/notes/improvements.md b/packages/fn/notes/improvements.md
new file mode 100644
index 0000000..937fa54
--- /dev/null
+++ b/packages/fn/notes/improvements.md
@@ -0,0 +1,316 @@
+Problem: Sentry not working
+
+- currently sentry not across express + railyway and next+vercel, so commmented out for now (and lots of ugly code)
+- if we always passed logger to ctx, then we could inject the logger alongside the user ctx eg createNextContext createExpressContext
+- PLAN: establish new pattern where logger is always passed to CTX
+
+Problem: Obfuscated error messages
+
+- We recreate errors in the wrapper, so we lose the original stack trace and get a loooong error message
+- We should alawys keep logger.error first param as the original error, to avoid info loss
+
+Small Improvements:
+
+- replace "wrapper" with just middleware
+- establish naming / meta pattern
+
+New API Design:
+
+Change Names:
+
+- baseFn -> createFn
+- authedService -> createAuthedFn
+- publicService -> createPublicFn
+
+So theres a bunch of complexity around managing the builder method and the middlware but i realised that perhaps its overkill and redudant because my existing impelemtnation (see attached doc of fn inside other codebase) was casting the type anyway so it was pretty pointless.
+
+We want to keep thigns as LIGHT and SIMPLE as possible to minimize surface area, maintance overhead, bugs, cognitive load, etc.
+
+
+
+```ts
+// lib/create-server-fn.ts
+
+export type User = {
+	id: string;
+	email: string;
+	role: 'USER' | 'ADMIN';
+};
+export type ServerFnCtx = {
+	logger: Logger;
+	db: PrismaClient;
+	user?: User;
+};
+export type ServerFnCtxAuthed = Required<ServerFnCtx>;
+
+function withBaseContext(fn: FnHandler<any, any, any>) {
+	return (opts: { ctx: unknown; input: unknown }) => {
+		const user = { id: '' };
+		return fn({
+			input: opts.input,
+			ctx: {
+				user,
+				db: enhance(prisma, { user }),
+				logger: createLogger({
+					level: 'info',
+					format: format.json(),
+				}),
+			},
+		});
+	};
+}
+
+function withLoggingMiddleware(fn: FnHandler<any, any, any>) {
+	return (opts: { ctx: unknown; input: unknown }) => {
+		const logger = opts.ctx.logger;
+		logger.info('-> fn called', {
+			fn: opts.ctx.fn.name,
+			input: opts.input,
+			ctx: opts.ctx,
+		});
+		const result = await fn(opts);
+		logger.info('<- fn result', {
+			fn: opts.ctx.fn.name,
+			result,
+		});
+		return result;
+	};
+}
+
+export const createPublicServerFn = (def: FnDef<PublicServerFnCtx>) => {
+	return createFn<PublicServerFnCtx>({
+		...def,
+		handler: pipe(
+			withBaseContext,
+			withLoggingMiddleware,
+			withErrorHandling,
+			def.handler
+		),
+	});
+};
+
+export const createAuthedServerFn = (def: FnDef<AuthedServerFnCtx>) => {
+	return createFn<AuthedServerFnCtx>({
+		...def,
+		handler: pipe(
+			withBaseContext,
+			withLoggingMiddleware,
+			withErrorHandling,
+			def.handler
+		),
+	});
+};
+
+export function createCtx() {
+	const user = getUserFromCookie();
+	return {
+		user,
+		db: enhance(prisma, { user }),
+		logger: createLogger({
+			level: 'info',
+			format: format.json(),
+		}),
+	};
+}
+```
+
+and then here is more examples of the API:
+
+## Define Functions
+
+```ts
+// server/chat
+
+const createChat = createAuthedServerFn({
+	name: 'createChat',
+	tags: ['chat'],
+	inputSchema: z.object({
+		title: z.string(),
+	}),
+	handler: async ({ input, ctx }) => {
+		return ctx.db.chat.create({
+			data: {
+				title: input.title,
+			},
+		});
+	},
+});
+```
+
+```ts
+// this is wawy too verbose, the other design is better
+const createChat = serverFn('createChat')
+	.input(
+		z.object({
+			title: z.string(),
+		})
+	)
+	.output(
+		z.object({
+			chat: z.object({
+				id: z.string(),
+				title: z.string(),
+			}),
+		})
+	)
+	.mutation(async ({ input, ctx }) => {
+		return ctx.db.chat.create({
+			data: {
+				title: input.title,
+			},
+		});
+	});
+```
+
+## Usage: Inside nested functions
+
+```ts
+const sendWelcomeText = createAuthedServerFn({
+	name: 'sendWelcomeText',
+	tags: ['sms', 'credits'],
+	description: ` 
+	- Ensures the user has enough credits
+  - Generates a personalized welcome text
+  - Sends the welcome text to the user
+	`,
+	inputSchema: z.object({
+		chatId: z.string(),
+	}),
+	outputSchema: z.object({
+		success: z.boolean(),
+	}),
+	handler: async ({ input, ctx }) => {
+		const canSend = checkCredits({
+			ctx,
+			input: {
+				actionType: 'send-welcome-text',
+			},
+		});
+
+		if (!canSend) {
+			throw new FnError({
+				code: 'INSUFFICIENT_CREDITS',
+				message: 'Insufficient credits',
+			});
+		}
+
+		const personalizedWelcomeText = await generatePersonalizedWelcomeText({
+			ctx,
+		});
+
+		const status = await sendSms({
+			ctx,
+			input: {
+				phoneNumber: input.phoneNumber,
+				message: personalizedWelcomeText,
+			},
+		});
+
+		return status;
+	},
+});
+```
+
+### Usage: TRPC
+
+```ts
+// router.ts
+
+const createFnProcedure = initCreateFnProcedure({ createContext });
+
+export const appRouter = createTRPCRouter({
+	chat: {
+		create: createFnProcedure(createChat, 'mutation'),
+		get: createFnProcedure(getChat, 'query'),
+	},
+});
+```
+
+```ts
+// app/api/[...trpc].ts
+
+//psuedo code - the point is that we need to create the CTX here and pass it down to the handler
+export { GET, POST } = createTRPCRequest(() => {
+	const ctx = createCtx();
+	handleRequest(ctx);
+});
+```
+
+```ts
+// app/chat/page.tsx
+const ChatPage = () => {
+	const { mutate } = api.chat.create.useMutation();
+	const { data } = api.chat.get.useQuery();
+};
+```
+
+### Usage: Server Actions
+
+Using Next.js Server Actions. Particularly useful for working with FILE UPLOADS or STREAMING responses - as trpc isn't a good fit for these.
+
+```ts
+// actions.ts
+'use server';
+
+const createFnAction = initCreateFnAction({ createCtx });
+
+export const createChatAction = createFnAction(createChat);
+export const uploadFileAction = createFnAction(uploadFile);
+```
+
+```ts
+// app/chat/page.tsx
+
+import { useMutation } from '@tanstack/react-query';
+
+const ChatPage = () => {
+	const { mutateAsync } = useMutation({
+		mutationFn: uploadFileAction,
+	});
+};
+```
+
+### Usage: LLM tools (FUTURE - ignore for now)
+
+Using the AI SDK `tool` function.
+
+```ts
+// tools.ts
+const createFnTool = fnToolOptions({ createCtx });
+
+export const tools = {
+	createChat: createFnTool(createChat),
+	uploadFile: createFnTool(uploadFile),
+};
+
+// or maybe this is better (so that we can use tool directly)
+// im trying to think of how to remove the dependency on ai sdk
+const fnToolOptions = initFnToolOptions({ createCtx });
+
+export const tools = {
+	createChat: tool(fnToolOptions(createChat)),
+	uploadFile: tool(fnToolOptions(uploadFile)),
+};
+
+// or maybe even:
+export const createChatTool = tool(fnToolOptions(createChat));
+export const uploadFileTool = tool(fnToolOptions(uploadFile));
+export const tools = { createChatTool, uploadFileTool };
+```
+
+### Usage: trigger.dev (FUTURE - ignore for now)
+
+```ts
+// tasks.ts
+const createFnTask = initCreateFnTask({ createCtx });
+
+export const createChatTask = createFnTask(createChat);
+export const uploadFileTask = createFnTask(uploadFile);
+
+// or maybe this is better (so that we can use task directly)
+// im trying to think of how to remove the dependency on trigger.dev
+const fnTaskOptions = initFnTaskOptions({ createCtx });
+
+export const createChatTask = task(fnTaskOptions(createChat));
+export const uploadFileTask = task(fnTaskOptions(uploadFile));
+```
diff --git a/packages/fn/notes/type-requirements.md b/packages/fn/notes/type-requirements.md
new file mode 100644
index 0000000..e24e632
--- /dev/null
+++ b/packages/fn/notes/type-requirements.md
@@ -0,0 +1,5 @@
+
+- user should be able to pass in input/output schema
+- if input schema is defined then should use z.input to infer TInput, else use void
+- if output schema is definde the should use z.output to infer TOutput, HOWEVER (IMPORANTLY) if no output schema is defined then should use the return type of the handler
+- we dont want to waste time perfectly settng up all the middleware types are there is ONE main usecase that we need the middleware types to work for (for now). That usecase is in composition.test.ts. I'ts about creating these authed vs public functions. We dont mind casting the ctx type in initCreateFn.
\ No newline at end of file
diff --git a/packages/fn/notes/why-pipe-over-middleware.md b/packages/fn/notes/why-pipe-over-middleware.md
new file mode 100644
index 0000000..cb6b691
--- /dev/null
+++ b/packages/fn/notes/why-pipe-over-middleware.md
@@ -0,0 +1,170 @@
+New API Design:
+
+Change Names:
+
+- baseFn -> createFn
+- authedService -> createAuthedFn
+- publicService -> createPublicFn
+
+So theres a bunch of complexity around managing the builder method and the middlware but i realised that perhaps its overkill and redudant because my existing impelemtnation (see attached doc of fn inside other codebase) was casting the type anyway so it was pretty pointless.
+
+We want to keep thigns as LIGHT and SIMPLE as possible to minimize surface area, maintance overhead, bugs, cognitive load, etc.
+
+So I was thinking, we coudl jsut make a simple config object and createFn, and either pass middleware in an array + typecast, or use a pipe function around the handler.
+
+option A: pass middleware in an array + typecast
+
+```ts
+const loggingMiddleware = createMiddleware(({ ctx, next }) =>
+// later we want indentation here to be based on the depth of the fn call, we can use logger.child or something like that, or add depth+1 to the ctx
+	ctx.logger.info('-> fn called', {
+		fn: ctx.fn.name,
+		input: ctx.input,
+		ctx: ctx.ctx,
+	})
+
+  const result = await next(ctx);
+
+  ctx.logger.info('<- fn result', {
+    fn: ctx.fn.name,
+    result,
+  })
+
+  return result;
+);
+const authedMiddleware = createMiddleware(({ ctx, next }) => {
+	if (!ctx.user.id) {
+		throw new FnError({
+			code: 'UNAUTHORIZED',
+			message: 'Unauthorized',
+		});
+	}
+	return next(ctx);
+});
+
+const createAuthedFn = (def: FnDef<any, any, any>) => {
+	return createFn({
+		...def,
+		middleware: [...(def.middleware ?? []), loggingMiddleware, authedMiddleware],
+	});
+};
+```
+
+option B: use a pipe function around the handler
+
+```ts
+// lib/create-server-fn.ts
+
+export type User = {
+	id: string;
+	email: string;
+	role: 'USER' | 'ADMIN';
+};
+export type ServerFnCtx = {
+	logger: Logger;
+	db: PrismaClient;
+	user?: User;
+};
+export type ServerFnCtxAuthed = Required<ServerFnCtx>;
+
+function withBaseContext(fn: FnHandler<any, any, any>) {
+	return (opts: { ctx: unknown; input: unknown }) => {
+		const user = { id: '' };
+		return fn({
+			input: opts.input,
+			ctx: {
+				user,
+				db: enhance(prisma, { user }),
+				logger: createLogger({
+					level: 'info',
+					format: format.json(),
+				}),
+			},
+		});
+	};
+}
+
+function withLoggingMiddleware(fn: FnHandler<any, any, any>) {
+	return (opts: { ctx: unknown; input: unknown }) => {
+		const logger = opts.ctx.logger;
+		logger.info('-> fn called', {
+			fn: opts.ctx.fn.name,
+			input: opts.input,
+			ctx: opts.ctx,
+		});
+		const result = await fn(opts);
+		logger.info('<- fn result', {
+			fn: opts.ctx.fn.name,
+			result,
+		});
+		return result;
+	};
+}
+
+export const createPublicServerFn = (def: FnDef<PublicServerFnCtx>) => {
+	return createFn<PublicServerFnCtx>({
+		...def,
+		handler: pipe(
+			withBaseContext,
+			withLoggingMiddleware,
+			withErrorHandling,
+			def.handler
+		),
+	});
+};
+
+export const createAuthedServerFn = (def: FnDef<AuthedServerFnCtx>) => {
+	return createFn<AuthedServerFnCtx>({
+		...def,
+		handler: pipe(
+			withBaseContext,
+			withLoggingMiddleware,
+			withErrorHandling,
+			def.handler
+		),
+	});
+};
+
+export function createCtx() {
+	const user = getUserFromCookie();
+	return {
+		user,
+		db: enhance(prisma, { user }),
+		logger: createLogger({
+			level: 'info',
+			format: format.json(),
+		}),
+	};
+}
+```
+
+### 3\. The Core Architectural Decision: Middleware vs. `pipe`
+
+This is the most important part of your new design. Let's compare Option A and Option B in detail.
+
+#### Option A: Middleware Array (`middleware: [...]`)
+
+This approach treats middleware as a list of layers in the configuration.
+
+- **Pros:**
+  - **Declarative:** It's very clear from looking at the `createAuthedFn` config what middleware is being applied.
+  - **Familiar:** This pattern is very common in web frameworks like Express, making it intuitive for many developers.
+- **Cons:**
+  - **Type Hell:** This is the deal-breaker. As you chain middleware, the context type can change (e.g., an early middleware adds `user` to the context). Managing these evolving types across a generic array is extremely difficult in TypeScript. You often end up with `any` or needing complex HKTs (Higher-Kinded Types), which completely defeats your goal of simplicity. Your own example (`FnDef<any, any, any>`) shows you've already hit this wall.
+  - **Implementation Complexity:** The `createFn` implementation needs a "runner" that iterates through the array, calls each middleware, and correctly handles the `next` function.
+
+#### Option B: Handler Composition (`handler: pipe(...)`)
+
+This approach treats middleware as simple function composition, where you wrap the core handler in layers of other functions.
+
+- **Pros:**
+  - ✅ **Rock-Solid Type Safety:** This is the biggest advantage. Standard function composition is something TypeScript handles beautifully. If you have `pipe(withAuth, withLogging, myHandler)`, TypeScript will automatically ensure the output of `withLogging` matches the input of `withAuth`, and so on. There's no type-casting and no `any`.
+  - ✅ **Implementation Simplicity:** Your `createFn` function becomes incredibly "dumb" and simple. It doesn't even need to know what middleware is. It just receives a final, fully-formed `handler` function and executes it. The complexity is pushed into the `pipe` utility, which is a standard, easily testable function.
+  - **Flexibility:** Developers aren't locked into your `middleware` abstraction. They can use your `pipe` utility, a third-party one (like from `fp-ts`), or just manually nest the function calls if they prefer.
+
+**Verdict & Recommendation:**
+
+**Option B (`pipe`) is decisively better and the clear path forward.** It aligns perfectly with your goals of simplicity, maintainability, and type safety. It avoids the hidden complexity of managing middleware context types, which is the exact trap that makes other frameworks so complicated internally.
+
+---
+
diff --git a/packages/fn/package.json b/packages/fn/package.json
new file mode 100644
index 0000000..ed5c5eb
--- /dev/null
+++ b/packages/fn/package.json
@@ -0,0 +1,39 @@
+{
+	"name": "@davstack/fn",
+	"version": "1.1.0",
+	"main": "./dist/index.js",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"sideEffects": false,
+	"license": "MIT",
+	"files": [
+		"dist/**"
+	],
+	"scripts": {
+		"build": "tsup src/index.ts --format esm,cjs --dts --dts-resolve",
+		"dev": "tsup src/index.ts --format esm,cjs --watch --dts --dts-resolve",
+		"lint": "eslint \"src/**/*.ts*\"",
+		"clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+	},
+	"devDependencies": {
+		"@davstack/eslint-config": "workspace:*",
+		"@davstack/tsconfig": "workspace:*",
+		"@types/react": "^18.2.61",
+		"@types/react-dom": "^18.2.19",
+		"eslint": "^8.57.0",
+		"react": "^18.2.0",
+		"tsup": "^8.0.2",
+		"typescript": "^5.3.3",
+		"zod": ">=3.25.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"dependencies": {
+		"@trpc/server": "^11.4.3",
+		"superjson": "^2.2.1"
+	},
+	"peerDependencies": {
+		"zod": "^3.25.0 || ^4.0.0"
+	}
+}
diff --git a/packages/fn/src/create-fn.ts b/packages/fn/src/create-fn.ts
new file mode 100644
index 0000000..5f828d3
--- /dev/null
+++ b/packages/fn/src/create-fn.ts
@@ -0,0 +1,444 @@
+/* eslint-disable no-unused-vars */
+
+import { FnError, isFnError } from './errors';
+import { isFormData, formDataToObject } from './utils/form-data';
+import { Simplify, zInfer, zInferInput, ZodTypeAny } from './utils/type-utils';
+
+// Re-export FnError for convenience
+export { FnError };
+
+// #region --- Fn Types ---
+
+type InferInput<TInputSchema> = TInputSchema extends ZodTypeAny
+	? zInferInput<TInputSchema>
+	: void;
+
+type MaybeZInfer<T> = T extends ZodTypeAny ? zInfer<T> : void;
+
+type InferOutput<TOutputSchema, THandler> = TOutputSchema extends ZodTypeAny
+	? zInfer<TOutputSchema>
+	: THandler extends (...args: any[]) => Promise<infer R>
+		? R
+		: THandler extends (...args: any[]) => infer R
+			? R
+			: any;
+
+type AnyObject = Record<string, any>;
+
+/**
+ * The core handler function's signature, generic over schema types (not inferred types).
+ */
+export type FnHandler<
+	TInputSchema extends ZodTypeAny | undefined = undefined,
+	TOutputSchema extends ZodTypeAny | undefined = undefined,
+	TContext extends AnyObject | undefined = undefined,
+> = (
+	args: {
+		// we use infer input on the caller (eg safeCall, or directDirect call with Fn(), but this handler type is used for the DEFINITION so internally we can trust we'll have the defaults so can use infer output instead (will be parsed)
+		input: MaybeZInfer<TInputSchema>;
+	} & (TContext extends undefined ? { ctx?: any } : { ctx: TContext })
+) => TOutputSchema extends ZodTypeAny
+	? zInfer<TOutputSchema> | Promise<zInfer<TOutputSchema>>
+	: any | Promise<any>;
+
+/**
+ * The definition object for creating a function. Uses schema types, not inferred types.
+ */
+export type FnDef<
+	TInputSchema extends ZodTypeAny | undefined = undefined,
+	TOutputSchema extends ZodTypeAny | undefined = undefined,
+	TContext extends AnyObject | undefined = undefined,
+> = {
+	name: string;
+	description?: string;
+	tags?: string[];
+	inputSchema?: TInputSchema;
+	outputSchema?: TOutputSchema;
+	handler: FnHandler<TInputSchema, TOutputSchema, TContext>;
+	middleware?: Middleware<any>[];
+};
+
+/**
+ * The standard result wrapper for safe calls.
+ */
+export type Result<T> =
+	| { data: T; error: null }
+	| { data: null; error: FnError | Error };
+
+export type OptionallyRequiredField<
+	K extends string,
+	Condition,
+	T extends Record<string, any>,
+> = Condition extends void | undefined
+	? Omit<T, K> & Partial<Pick<T, K>>
+	: unknown extends Condition
+		? Omit<T, K> & Partial<Pick<T, K>>
+		: T;
+
+/**
+ * Helper type for function arguments with optional input and context.
+ */
+// export type FnArgs<TInput = void, TContext extends AnyObject | undefined = undefined> = {
+// 	input: TInput;
+// 	ctx: TContext;
+// };
+
+// export type FnArgs<
+// 	TInput = void,
+// 	TContext extends AnyObject | undefined = undefined,
+// > = Simplify<
+// 	OptionallyRequiredField<
+// 		'input',
+// 		TInput,
+// 		OptionallyRequiredField<
+// 			'ctx',
+// 			TContext,
+// 			{
+// 				input: TInput;
+// 				ctx: TContext;
+// 			}
+// 		>
+// 	>
+// >;
+
+// /**
+export type FnArgs<
+	TInput = void,
+	TContext extends AnyObject | undefined = undefined,
+> = Simplify<
+	// Maybe input
+	(TInput extends undefined | void ? { input?: void } : { input: TInput }) &
+		// Maybe context
+		(TContext extends undefined ? { ctx?: undefined } : { ctx: TContext })
+>;
+
+/**
+ * The main, user-facing Function type. Clean types only.
+ */
+export type Fn<
+	TInputSchema extends ZodTypeAny | undefined = undefined,
+	TOutputSchema extends ZodTypeAny | undefined = undefined,
+	TContext extends AnyObject | undefined = undefined,
+	THandler extends FnHandler<TInputSchema, TOutputSchema, TContext> = FnHandler<
+		TInputSchema,
+		TOutputSchema,
+		TContext
+	>,
+> = FnDef<TInputSchema, TOutputSchema, TContext> &
+	// Maybe inputSchema
+	(TInputSchema extends undefined
+		? { inputSchema?: undefined }
+		: { inputSchema: TInputSchema }) &
+	// Maybe outputSchema
+	(TOutputSchema extends undefined
+		? { outputSchema?: undefined }
+		: { outputSchema: TOutputSchema }) & {
+		safeCall: (
+			args: FnArgs<InferInput<TInputSchema>, TContext>
+		) => Promise<Result<InferOutput<TOutputSchema, THandler>>>;
+	} & ((
+		args: FnArgs<InferInput<TInputSchema>, TContext>
+	) => Promise<InferOutput<TOutputSchema, THandler>>);
+
+// #endregion
+
+// #region --- Middleware  ---
+
+// Internal type for middleware that needs to work with any function definition
+type AnyFnDef = {
+	name: string;
+	description?: string;
+	tags?: string[];
+	inputSchema?: ZodTypeAny;
+	outputSchema?: ZodTypeAny;
+	handler: (...args: any[]) => any;
+	middleware?: Middleware<any>[];
+};
+
+export type Middleware<
+	TContext extends AnyObject | undefined = undefined,
+	TNewContext extends AnyObject | undefined = TContext,
+> = (opts: {
+	ctx: TContext;
+	input: unknown;
+	def: AnyFnDef;
+	next: (ctx?: TNewContext, input?: unknown) => Promise<unknown> | unknown;
+}) => Promise<unknown> | unknown;
+
+/**
+ * Helper to create properly typed middleware.
+ */
+export function createMiddleware<
+	TContext extends AnyObject | undefined = undefined,
+	TNewContext extends AnyObject | undefined = TContext,
+>(
+	middlewareFn: Middleware<TContext, TNewContext>
+): Middleware<TContext, TNewContext> {
+	return middlewareFn;
+}
+
+/**
+ * Executes a chain of middleware and the final handler.
+ */
+async function executeMiddleware<T>(opts: {
+	def: AnyFnDef;
+	args: { input: unknown; ctx: any };
+}): Promise<T> {
+	const { def, args } = opts;
+
+	const run = async (
+		index: number,
+		currentCtx: any,
+		currentInput: any
+	): Promise<T> => {
+		if (index >= (def.middleware?.length ?? 0)) {
+			// Pass the potentially modified context and the final input to the handler
+			return def.handler({ input: currentInput, ctx: currentCtx }) as T;
+		}
+
+		const middleware = def.middleware?.[index]!;
+
+		// The `next` function for this specific middleware.
+		// It will call `run` for the *next* middleware.
+		// If the current middleware provides a new context or input, we use it.
+		// Otherwise, we pass along the ones we received.
+		const next = (newCtx: any = currentCtx, newInput: any = currentInput) => {
+			return run(index + 1, newCtx, newInput);
+		};
+
+		return middleware({
+			ctx: currentCtx,
+			input: currentInput,
+			def,
+			next,
+		}) as T;
+	};
+
+	return run(0, args.ctx, args.input);
+}
+
+/**
+ * Enhances an error by wrapping it in an FnError (if it isn't one already),
+ * and adds a trace of function calls to the metadata.
+ * This ensures the original error `cause` and stack trace are preserved.
+ */
+function enhanceError(error: unknown, def: AnyFnDef, input: unknown): FnError {
+	const isOriginalFnError = error instanceof FnError;
+	// FnError.from will return the same instance if it's already an FnError
+	const fnError = FnError.from(error);
+
+	// If this is the first time we're wrapping the error, initialize the trace and add input
+	if (!isOriginalFnError) {
+		fnError.meta.functionTrace = [];
+		fnError.meta.input = input;
+	}
+
+	// Add the current function to the start of the trace to build a call stack
+	// e.g., [outerFn, middleFn, innerFn]
+	const trace = (fnError.meta.functionTrace || []) as string[];
+	trace.unshift(def.name);
+	fnError.meta.functionTrace = trace;
+
+	// The `functionName` should reflect the function that most recently handled the error
+	fnError.meta.functionName = def.name;
+
+	return fnError;
+}
+
+// #endregion
+
+// #region --- Default Middleware ---
+
+/**
+ * Input validation middleware.
+ */
+const withInputValidation = createMiddleware(({ ctx, input, def, next }) => {
+	const schema = def.inputSchema;
+	if (!schema) {
+		// If no schema, pass input through unchanged.
+		return next(ctx, input);
+	}
+
+	const dataToValidate = isFormData(input) ? formDataToObject(input) : input;
+
+	const result = (schema as any).safeParse(dataToValidate);
+	if (!result.success) {
+		throw new FnError({
+			code: 'INVALID_INPUT',
+			cause: result.error,
+			meta: { zodErrors: result.error.flatten() },
+		});
+	}
+	// Pass the PARSED data to the next middleware/handler.
+	return next(ctx, result.data);
+});
+
+/**
+ * Output validation middleware.
+ */
+const withOutputValidation = createMiddleware(
+	async ({ ctx, input, def, next }) => {
+		const schema = def.outputSchema;
+		// The call to next() needs to pass the input along
+		if (!schema) return next(ctx, input);
+
+		const result = await next(ctx, input); // pass input through
+		const validationResult = (schema as any).safeParse(result);
+		if (!validationResult.success) {
+			throw new FnError({
+				code: 'INVALID_OUTPUT',
+				cause: validationResult.error,
+				meta: { zodErrors: validationResult.error.flatten() },
+			});
+		}
+		return validationResult.data;
+	}
+);
+
+/**
+ * Error handling middleware that enhances thrown errors.
+ */
+const withThrowingErrorHandler = createMiddleware(
+	async ({ ctx, input, def, next }) => {
+		try {
+			return await next(ctx, input); // pass input through
+		} catch (error) {
+			throw enhanceError(error, def, input);
+		}
+	}
+);
+
+/**
+ * Middleware that formats the final result into a { data, error } object.
+ */
+const withSafeResultFormatter = createMiddleware(
+	async ({ ctx, input, def, next }) => {
+		try {
+			const data = await next(ctx, input); // pass input through
+			return { data, error: null };
+		} catch (error) {
+			return { data: null, error: error as FnError };
+		}
+	}
+);
+
+// #endregion
+
+// #region --- createFn ---
+
+/**
+ * Creates a new function with middleware and validation capabilities.
+ * Schema generics are only here to do the inference, then we return clean types.
+ */
+export function createFn<
+	TInputSchema extends ZodTypeAny | undefined = undefined,
+	TOutputSchema extends ZodTypeAny | undefined = undefined,
+	TContext extends AnyObject | undefined = undefined,
+	// need it for inferring the return type of the handler
+	THandler extends FnHandler<TInputSchema, TOutputSchema, TContext> = FnHandler<
+		TInputSchema,
+		TOutputSchema,
+		TContext
+	>,
+>(
+	def: FnDef<TInputSchema, TOutputSchema, TContext> & {
+		handler: THandler;
+	}
+): Fn<TInputSchema, TOutputSchema, TContext, THandler> {
+	// Infer the clean types from schemas/handler
+	type TInput = InferInput<TInputSchema>;
+	type TOutput = InferOutput<TOutputSchema, THandler>;
+
+	const getArgs = (args: any): { input: any; ctx: any } => {
+		const _args = args ?? {};
+		const input = 'input' in _args ? _args.input : undefined;
+		const ctx = 'ctx' in _args ? _args.ctx : {};
+		return { input, ctx };
+	};
+
+	// The pipeline for the direct, throwing call.
+	const directCall = async (args: any) => {
+		const callMiddleware: Middleware<any>[] = [
+			withThrowingErrorHandler,
+			// need to validate input so that we get eg defaults/transforms.
+			// for fully raw call can use .handler() directly
+			withInputValidation,
+			...(def.middleware || []),
+			withOutputValidation,
+		];
+
+		return executeMiddleware<TOutput>({
+			def: { ...def, middleware: callMiddleware } as AnyFnDef,
+			args: getArgs(args),
+		});
+	};
+
+	// The pipeline for the non-throwing, safe call.
+	const safeCall = async (
+		args: FnArgs<TInput, TContext>
+	): Promise<Result<TOutput>> => {
+		const safeCallMiddleware: Middleware<any>[] = [
+			withSafeResultFormatter, // 1. (Outer) Formats the final result.
+			withThrowingErrorHandler, // 2. Catches and enhances any errors.
+			withInputValidation, // 3. Validates input schema.
+			...(def.middleware || []), // 4. Executes user-defined middleware.
+			withOutputValidation, // 5. (Inner) Validates output schema.
+		];
+
+		return executeMiddleware<Result<TOutput>>({
+			def: { ...def, middleware: safeCallMiddleware } as AnyFnDef,
+			args: getArgs(args),
+		});
+	};
+
+	const { name, ...defWithoutName } = def;
+
+	const result = Object.assign(directCall, defWithoutName, { safeCall });
+
+	Object.defineProperty(result, 'name', {
+		value: def.name,
+		configurable: true,
+	});
+
+	return result as unknown as Fn<
+		TInputSchema,
+		TOutputSchema,
+		TContext,
+		THandler
+	>;
+}
+
+// #endregion
+
+// #region --- initCreateFn ---
+
+/**
+ * Primary initialization function - creates a function factory with pre-configured middleware.
+ * Only stores the context type, schema inference happens in the returned createFn calls.
+ */
+export function initCreateFn<
+	TContext extends AnyObject | undefined = undefined,
+>(middlewares?: Middleware<any>[]) {
+	return <
+		TInputSchema extends ZodTypeAny | undefined = undefined,
+		TOutputSchema extends ZodTypeAny | undefined = undefined,
+		THandler extends FnHandler<
+			TInputSchema,
+			TOutputSchema,
+			TContext
+		> = FnHandler<TInputSchema, TOutputSchema, TContext>,
+	>(
+		def: FnDef<TInputSchema, TOutputSchema, TContext> & {
+			handler: THandler;
+		}
+	): Fn<TInputSchema, TOutputSchema, TContext, THandler> =>
+		createFn<TInputSchema, TOutputSchema, TContext, THandler>({
+			...def,
+			middleware: [
+				...(middlewares || []),
+				...(def.middleware || []),
+			] as Middleware<any>[],
+		});
+}
+
+// #endregion
diff --git a/packages/fn/src/errors.ts b/packages/fn/src/errors.ts
new file mode 100644
index 0000000..60c22ad
--- /dev/null
+++ b/packages/fn/src/errors.ts
@@ -0,0 +1,153 @@
+/**
+ * Standardized error codes for Fn operations
+ */
+export const FnErrorCode = {
+	BAD_REQUEST: 'BAD_REQUEST',
+	UNAUTHORIZED: 'UNAUTHORIZED',
+	FORBIDDEN: 'FORBIDDEN',
+	NOT_FOUND: 'NOT_FOUND',
+	METHOD_NOT_SUPPORTED: 'METHOD_NOT_SUPPORTED',
+	TIMEOUT: 'TIMEOUT',
+	CONFLICT: 'CONFLICT',
+	PRECONDITION_FAILED: 'PRECONDITION_FAILED',
+	PAYLOAD_TOO_LARGE: 'PAYLOAD_TOO_LARGE',
+	UNPROCESSABLE_CONTENT: 'UNPROCESSABLE_CONTENT',
+	TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
+	CLIENT_CLOSED_REQUEST: 'CLIENT_CLOSED_REQUEST',
+	INTERNAL_SERVER_ERROR: 'INTERNAL_SERVER_ERROR',
+	NOT_IMPLEMENTED: 'NOT_IMPLEMENTED',
+	BAD_GATEWAY: 'BAD_GATEWAY',
+	SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
+	GATEWAY_TIMEOUT: 'GATEWAY_TIMEOUT',
+	INVALID_INPUT: 'INVALID_INPUT',
+	INVALID_OUTPUT: 'INVALID_OUTPUT',
+} as const;
+
+export type FnErrorCodeType = keyof typeof FnErrorCode;
+
+/**
+ * Options for creating a new FnError
+ */
+export interface FnErrorOptions {
+	code: FnErrorCodeType;
+	message?: string;
+	cause?: unknown; // Allow any cause
+	meta?: Record<string, unknown>;
+}
+
+/**
+ * Checks if an object is a plain object (not null, not array)
+ */
+function isObject(obj: unknown): obj is Record<string, unknown> {
+	return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+}
+
+/**
+ * Gets a message from an unknown error
+ */
+function getMessageFromUnknownError(err: unknown, fallback: string): string {
+	if (typeof err === 'string') {
+		return err;
+	}
+	if (isObject(err) && typeof err['message'] === 'string') {
+		return err['message'];
+	}
+	return fallback;
+}
+
+/**
+ * Custom error class for Fn operations
+ */
+export class FnError extends Error {
+	code: FnErrorCodeType;
+	cause?: unknown;
+	meta: Record<string, unknown>;
+	_reported?: boolean;
+
+	constructor(opts: FnErrorOptions) {
+		// Use custom message or default based on the error code
+		const message = opts.message || getDefaultErrorMessage(opts.code);
+		super(message, { cause: opts.cause });
+
+		this.name = 'FnError';
+		this.code = opts.code;
+		this.cause = opts.cause;
+		this.meta = opts.meta || {};
+
+		// Set prototype explicitly since TypeScript classes lose their prototype chain when extended
+		Object.setPrototypeOf(this, FnError.prototype);
+	}
+
+	/**
+	 * Mark the error as reported to prevent duplicate logging.
+	 * This is a mutable operation.
+	 */
+	markAsReported(): this {
+		this._reported = true;
+		return this;
+	}
+
+	/**
+	 * Creates an FnError from any error or object.
+	 * If the cause is already an FnError, it enhances it rather than re-wrapping,
+	 * preserving the original error identity and stack trace.
+	 */
+	static from(
+		cause: unknown,
+		opts: {
+			code?: FnErrorCodeType;
+			message?: string;
+			meta?: Record<string, unknown>;
+		} = {}
+	): FnError {
+		// If it's already an FnError, just enhance it without creating a new one
+		if (isFnError(cause)) {
+			if (opts.meta) {
+				// Merge the new meta data with existing data
+				cause.meta = { ...cause.meta, ...opts.meta };
+			}
+			// Apply other options if provided
+			if (opts.code) cause.code = opts.code;
+			if (opts.message) cause.message = opts.message;
+
+			return cause;
+		}
+
+		// Create a new FnError that references the original cause
+		return new FnError({
+			code: opts.code || 'INTERNAL_SERVER_ERROR',
+			message:
+				opts.message || getMessageFromUnknownError(cause, 'Unknown error'),
+			cause: cause,
+			meta: opts.meta || {},
+		});
+	}
+}
+
+/**
+ * Gets a default error message for a given error code
+ */
+function getDefaultErrorMessage(code: FnErrorCodeType): string {
+	switch (code) {
+		case 'BAD_REQUEST':
+			return 'Invalid request';
+		case 'UNAUTHORIZED':
+			return 'Not authenticated';
+		case 'FORBIDDEN':
+			return 'Not authorized';
+		case 'NOT_FOUND':
+			return 'Resource not found';
+		case 'INTERNAL_SERVER_ERROR':
+			return 'An unexpected error occurred';
+		// ... other cases\
+		default:
+			return `Error: ${code}`;
+	}
+}
+
+/**
+ * Type guard to check if an error is an FnError
+ */
+export function isFnError(error: unknown): error is FnError {
+	return error instanceof FnError;
+}
diff --git a/packages/fn/src/index.ts b/packages/fn/src/index.ts
new file mode 100644
index 0000000..42e1c64
--- /dev/null
+++ b/packages/fn/src/index.ts
@@ -0,0 +1,9 @@
+export * from './create-fn';
+export * from './errors';
+export * from './pipe';
+export * from './utils/type-utils';
+export * from './utils/init-procedure-factory';
+// export const helloWorld = () => {
+// 	console.log('Hello, world!');
+// 	return 'Hello, world!';
+// };
diff --git a/packages/fn/src/pipe.ts b/packages/fn/src/pipe.ts
new file mode 100644
index 0000000..b2051be
--- /dev/null
+++ b/packages/fn/src/pipe.ts
@@ -0,0 +1,4247 @@
+export function pipe<T0>(x0: T0): T0;
+export function pipe<T0, T1>(x0: T0, f1?: (x: T0) => T1): T1;
+export function pipe<T0, T1, T2>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2
+): T2;
+export function pipe<T0, T1, T2, T3>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3
+): T3;
+export function pipe<T0, T1, T2, T3, T4>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4
+): T4;
+export function pipe<T0, T1, T2, T3, T4, T5>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5
+): T5;
+export function pipe<T0, T1, T2, T3, T4, T5, T6>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6
+): T6;
+export function pipe<T0, T1, T2, T3, T4, T5, T6, T7>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7
+): T7;
+export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8
+): T8;
+export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9
+): T9;
+export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10
+): T10;
+export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11
+): T11;
+export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12
+): T12;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13
+): T13;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14
+): T14;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15
+): T15;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16
+): T16;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17
+): T17;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18
+): T18;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19
+): T19;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20
+): T20;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21
+): T21;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22
+): T22;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23
+): T23;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24
+): T24;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25
+): T25;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26
+): T26;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27
+): T27;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28
+): T28;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29
+): T29;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30
+): T30;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31
+): T31;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32
+): T32;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33
+): T33;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34
+): T34;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35
+): T35;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36
+): T36;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37
+): T37;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38
+): T38;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39
+): T39;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40
+): T40;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41
+): T41;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42
+): T42;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43
+): T43;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44
+): T44;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45
+): T45;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46
+): T46;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47
+): T47;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48
+): T48;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49
+): T49;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50
+): T50;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51
+): T51;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52
+): T52;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53
+): T53;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54
+): T54;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55
+): T55;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56
+): T56;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57
+): T57;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+	T58,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57,
+	f58?: (x: T57) => T58
+): T58;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+	T58,
+	T59,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57,
+	f58?: (x: T57) => T58,
+	f59?: (x: T58) => T59
+): T59;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+	T58,
+	T59,
+	T60,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57,
+	f58?: (x: T57) => T58,
+	f59?: (x: T58) => T59,
+	f60?: (x: T59) => T60
+): T60;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+	T58,
+	T59,
+	T60,
+	T61,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57,
+	f58?: (x: T57) => T58,
+	f59?: (x: T58) => T59,
+	f60?: (x: T59) => T60,
+	f61?: (x: T60) => T61
+): T61;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+	T58,
+	T59,
+	T60,
+	T61,
+	T62,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57,
+	f58?: (x: T57) => T58,
+	f59?: (x: T58) => T59,
+	f60?: (x: T59) => T60,
+	f61?: (x: T60) => T61,
+	f62?: (x: T61) => T62
+): T62;
+export function pipe<
+	T0,
+	T1,
+	T2,
+	T3,
+	T4,
+	T5,
+	T6,
+	T7,
+	T8,
+	T9,
+	T10,
+	T11,
+	T12,
+	T13,
+	T14,
+	T15,
+	T16,
+	T17,
+	T18,
+	T19,
+	T20,
+	T21,
+	T22,
+	T23,
+	T24,
+	T25,
+	T26,
+	T27,
+	T28,
+	T29,
+	T30,
+	T31,
+	T32,
+	T33,
+	T34,
+	T35,
+	T36,
+	T37,
+	T38,
+	T39,
+	T40,
+	T41,
+	T42,
+	T43,
+	T44,
+	T45,
+	T46,
+	T47,
+	T48,
+	T49,
+	T50,
+	T51,
+	T52,
+	T53,
+	T54,
+	T55,
+	T56,
+	T57,
+	T58,
+	T59,
+	T60,
+	T61,
+	T62,
+	T63,
+>(
+	x0: T0,
+	f1?: (x: T0) => T1,
+	f2?: (x: T1) => T2,
+	f3?: (x: T2) => T3,
+	f4?: (x: T3) => T4,
+	f5?: (x: T4) => T5,
+	f6?: (x: T5) => T6,
+	f7?: (x: T6) => T7,
+	f8?: (x: T7) => T8,
+	f9?: (x: T8) => T9,
+	f10?: (x: T9) => T10,
+	f11?: (x: T10) => T11,
+	f12?: (x: T11) => T12,
+	f13?: (x: T12) => T13,
+	f14?: (x: T13) => T14,
+	f15?: (x: T14) => T15,
+	f16?: (x: T15) => T16,
+	f17?: (x: T16) => T17,
+	f18?: (x: T17) => T18,
+	f19?: (x: T18) => T19,
+	f20?: (x: T19) => T20,
+	f21?: (x: T20) => T21,
+	f22?: (x: T21) => T22,
+	f23?: (x: T22) => T23,
+	f24?: (x: T23) => T24,
+	f25?: (x: T24) => T25,
+	f26?: (x: T25) => T26,
+	f27?: (x: T26) => T27,
+	f28?: (x: T27) => T28,
+	f29?: (x: T28) => T29,
+	f30?: (x: T29) => T30,
+	f31?: (x: T30) => T31,
+	f32?: (x: T31) => T32,
+	f33?: (x: T32) => T33,
+	f34?: (x: T33) => T34,
+	f35?: (x: T34) => T35,
+	f36?: (x: T35) => T36,
+	f37?: (x: T36) => T37,
+	f38?: (x: T37) => T38,
+	f39?: (x: T38) => T39,
+	f40?: (x: T39) => T40,
+	f41?: (x: T40) => T41,
+	f42?: (x: T41) => T42,
+	f43?: (x: T42) => T43,
+	f44?: (x: T43) => T44,
+	f45?: (x: T44) => T45,
+	f46?: (x: T45) => T46,
+	f47?: (x: T46) => T47,
+	f48?: (x: T47) => T48,
+	f49?: (x: T48) => T49,
+	f50?: (x: T49) => T50,
+	f51?: (x: T50) => T51,
+	f52?: (x: T51) => T52,
+	f53?: (x: T52) => T53,
+	f54?: (x: T53) => T54,
+	f55?: (x: T54) => T55,
+	f56?: (x: T55) => T56,
+	f57?: (x: T56) => T57,
+	f58?: (x: T57) => T58,
+	f59?: (x: T58) => T59,
+	f60?: (x: T59) => T60,
+	f61?: (x: T60) => T61,
+	f62?: (x: T61) => T62,
+	f63?: (x: T62) => T63
+): T63;
+
+export function pipe(x: any, ...fns: any[]) {
+	return fns.reduce((y: any, fn) => fn(y), x);
+}
diff --git a/packages/fn/src/utils/form-data.ts b/packages/fn/src/utils/form-data.ts
new file mode 100644
index 0000000..04d1516
--- /dev/null
+++ b/packages/fn/src/utils/form-data.ts
@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+/**
+ *  CREDIT: https://github.com/trpc/trpc/blob/72c684683626b54907cccf8a12f3a3d726471652/packages/next/src/app-dir/formDataToObject.ts
+ */
+
+export function isFormData(value: unknown): value is FormData {
+	if (typeof FormData === 'undefined') {
+		// FormData is not supported
+		return false;
+	}
+	return value instanceof FormData;
+}
+
+function set(
+	obj: Record<string, any>,
+	path: string[] | string,
+	value: unknown
+): void {
+	if (typeof path === 'string') {
+		path = path.split(/[\.\[\]]/).filter(Boolean);
+	}
+
+	if (path.length > 1) {
+		const p = path.shift()!;
+		const isArrayIndex = /^\d+$/.test(path[0]!);
+		obj[p] = obj[p] || (isArrayIndex ? [] : {});
+		set(obj[p], path, value);
+		return;
+	}
+	const p = path[0]!;
+	if (obj[p] === undefined) {
+		obj[p] = value;
+	} else if (Array.isArray(obj[p])) {
+		obj[p].push(value);
+	} else {
+		obj[p] = [obj[p], value];
+	}
+}
+
+export function formDataToObject(formData: FormData) {
+	const obj: Record<string, unknown> = {};
+
+	for (const [key, value] of formData.entries()) {
+		set(obj, key, value);
+	}
+
+	return obj;
+}
+
+export function getMaybeFormDataValue<T>(value: T | FormData): T {
+	if (isFormData(value)) {
+		return formDataToObject(value) as any;
+	}
+
+	return value;
+}
diff --git a/packages/fn/src/utils/init-procedure-factory.ts b/packages/fn/src/utils/init-procedure-factory.ts
new file mode 100644
index 0000000..2ed2263
--- /dev/null
+++ b/packages/fn/src/utils/init-procedure-factory.ts
@@ -0,0 +1,96 @@
+import {
+	AnyProcedureBuilder,
+	MutationProcedure,
+	QueryProcedure,
+} from '@trpc/server/unstable-core-do-not-import';
+import { z } from 'zod';
+import { zInferInput, ZodTypeAny, Simplify } from '..';
+
+/**
+ * Creates a factory function for tRPC procedures from Fn definitions
+ *
+ * @remarks
+ * This function deliberately uses a more flexible type definition than the full Fn type
+ * to avoid complex type compatibility issues between context types and middleware.
+ *
+ * Prior to introducing OptionallyRequiredField, using Fn<any,any,any,any,any> worked fine,
+ * but after adding that type helper, we encountered type compatibility issues with our more
+ * structured argument types.
+ *
+ * We're extracting only the essential properties needed for procedure creation rather
+ * than using the full Fn type to prevent TypeScript errors with OptionallyRequiredField
+ * and context type constraints when used with specific service contexts.
+ *
+ * In the future, we could consider using FnDef instead of Fn as the constraint, as it
+ * contains the definition properties without the call signatures that include the
+ * OptionallyRequiredField complexity.
+ *
+ * The type safety for the actual function implementations is handled elsewhere in the
+ * system, so this pragmatic approach allows us to create procedures without excessive
+ * type gymnastics.
+ */
+export function initProcedureFactory<
+	TProcedureBuilder extends AnyProcedureBuilder,
+>(procedureBuilder: TProcedureBuilder) {
+	return function createTrpcProcedureFromFn<
+		TFn extends {
+			inputSchema?: ZodTypeAny;
+			handler: (...args: any[]) => any;
+		},
+		TType extends 'mutation' | 'query',
+	>(fn: TFn & { (...args: any[]): Promise<any> }, type: TType) {
+		if (!fn.handler) {
+			throw new Error('Handler not defined');
+		}
+
+		type InputType = TFn['inputSchema'] extends ZodTypeAny
+			? zInferInput<TFn['inputSchema']>
+			: void;
+
+		type OutputType = Awaited<ReturnType<TFn['handler']>>;
+		// type OutputType =
+		//   ReturnType<TFn["handler"]> extends Promise<infer TOutput>
+		//     ? TOutput
+		//     : never;
+
+		type InputOutput = Simplify<{
+			input: InputType;
+			output: OutputType;
+			meta: Record<string, string>;
+		}>;
+
+		type ProcedureResult = TType extends 'mutation'
+			? MutationProcedure<InputOutput>
+			: QueryProcedure<InputOutput>;
+
+		const inputSchema = fn.inputSchema ?? z.void();
+		// TODO: Potentially integrate outputSchema validation in the future
+
+		// Define the handler function that will be used for both query and mutation
+		// This avoids duplicating the implementation and creating different stack frames
+		const handler = async ({ ctx, input }: { ctx: any; input: any }) => {
+			try {
+				// Directly call the function to avoid introducing unnecessary stack frames
+
+				return await fn({ input, ctx });
+			} catch (error) {
+				// Don't wrap the error here - let it propagate with its original stack
+				throw error;
+			}
+		};
+
+		if (type === 'mutation') {
+			return procedureBuilder
+				.input(inputSchema)
+				.mutation(handler) as unknown as ProcedureResult;
+		}
+
+		if (type === 'query') {
+			return procedureBuilder
+				.input(inputSchema)
+				.query(handler) as unknown as ProcedureResult;
+		}
+
+		throw new Error('Type not defined');
+	};
+}
diff --git a/packages/fn/src/utils/type-utils.ts b/packages/fn/src/utils/type-utils.ts
new file mode 100644
index 0000000..31f9391
--- /dev/null
+++ b/packages/fn/src/utils/type-utils.ts
@@ -0,0 +1,41 @@
+// CHANGED: Import from the stable v3 and v4 core subpaths
+import * as z3 from 'zod/v3';
+// import * as z4 from 'zod/v4/core';
+
+/**
+ * @link https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+export type Simplify<T> = T extends any[] | Date
+	? T
+	: { [K in keyof T]: T[K] } & {};
+
+//* MARK: OLD ------------
+// export type zInfer<T extends ZodTypeAny> = T['_output'];
+// export type zInferInput<T extends ZodTypeAny> = T['_input'];
+
+// export type ZodTypeAny = z3.ZodTypeAny;
+
+//* MARK: NEW ------------
+
+// NEW: Version-agnostic type inference for the schema's output type.
+// It uses conditional types to check if the provided schema is a v3 or v4 type.
+
+import * as z4 from 'zod/v4/core';
+export type zInfer<T> = T extends z3.ZodTypeAny
+	? z3.infer<T>
+	: T extends z4.$ZodType
+		? z4.output<T>
+		: never;
+
+// NEW: Version-agnostic type inference for the schema's input type.
+export type zInferInput<T> = T extends z3.ZodTypeAny
+	? z3.input<T>
+	: T extends z4.$ZodType
+		? z4.input<T>
+		: never;
+
+export type ZodTypeAny = z3.ZodTypeAny | z4.$ZodType;
+
+export function isZod4(schema: ZodTypeAny): schema is z4.$ZodType {
+	return '_zod' in schema;
+}
diff --git a/packages/fn/test/composition.test.ts b/packages/fn/test/composition.test.ts
new file mode 100644
index 0000000..ff425d0
--- /dev/null
+++ b/packages/fn/test/composition.test.ts
@@ -0,0 +1,638 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { z } from 'zod';
+import { initCreateFn, FnError } from '../src';
+import {
+	AuthedServerFnCtx,
+	createMockLogger,
+	mockDb,
+	ServerFnCtx,
+	loggingMiddleware,
+	authMiddleware,
+	authedLoggingMiddleware,
+	authedErrorLoggingMiddleware,
+	createTimingMiddleware,
+} from './test-utils';
+import { expectTypeOf } from 'vitest';
+
+describe('Clean Composition API', () => {
+	const logger = createMockLogger();
+	beforeEach(() => logger.cleanup());
+
+	describe('Middleware Creation', () => {
+		test('should create and use right runtime types', () => {
+			expect(typeof loggingMiddleware).toBe('function');
+			expect(typeof authMiddleware).toBe('function');
+			const timingMiddleware = createTimingMiddleware<ServerFnCtx>();
+			expect(typeof timingMiddleware).toBe('function');
+		});
+	});
+
+	describe('Function Factory Creation', () => {
+		test('should create clean public server function factory', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([loggingMiddleware]);
+
+			expect(typeof createServerFn).toBe('function');
+
+			const getPublicData = createServerFn({
+				name: 'getPublicData',
+				handler: async ({ ctx }) => {
+					return `Public data for ${ctx.user?.id || 'anonymous'}`;
+				},
+			});
+
+			expect(typeof getPublicData).toBe('function');
+			expect(typeof getPublicData.safeCall).toBe('function');
+			expect(getPublicData.name).toBe('getPublicData');
+
+			const result = await getPublicData({
+				ctx: { logger, db: mockDb, user: { id: 'user_123' } },
+			});
+
+			expect(typeof result).toBe('string');
+			expect(result).toBe('Public data for user_123');
+			expect(logger.info).toHaveBeenCalledWith("-> Calling 'getPublicData'");
+			expect(logger.info).toHaveBeenCalledWith("<- Finished 'getPublicData'");
+		});
+
+		test('should create clean authed server function factory', async () => {
+			const createAuthedServerFn = initCreateFn<AuthedServerFnCtx>([
+				authMiddleware,
+				authedLoggingMiddleware,
+			]);
+
+			expect(typeof createAuthedServerFn).toBe('function');
+
+			const getSecretData = createAuthedServerFn({
+				name: 'getSecretData',
+				handler: async ({ ctx }) => {
+					return `Secret data for ${ctx.user.id}`;
+				},
+			});
+
+			expect(typeof getSecretData).toBe('function');
+			expect(getSecretData.name).toBe('getSecretData');
+
+			// Should succeed with proper user
+			const result = await getSecretData({
+				ctx: { logger, db: mockDb, user: { id: 'user_123' } },
+			});
+
+			expect(typeof result).toBe('string');
+			expect(result).toBe('Secret data for user_123');
+			expect(logger.info).toHaveBeenCalledWith("-> Calling 'getSecretData'");
+			expect(logger.info).toHaveBeenCalledWith("<- Finished 'getSecretData'");
+		});
+
+		test('should throw auth error for unauthenticated requests', async () => {
+			const createAuthedServerFn = initCreateFn<AuthedServerFnCtx>([
+				authMiddleware,
+			]);
+
+			const protectedFn = createAuthedServerFn({
+				name: 'protected',
+				handler: async () => 'secret',
+			});
+
+			// Test with missing user
+			await expect(
+				protectedFn({ ctx: { logger, db: mockDb } } as any)
+			).rejects.toThrow(FnError);
+
+			// Test with undefined user
+			await expect(
+				protectedFn({ ctx: { logger, db: mockDb, user: undefined } } as any)
+			).rejects.toThrow('User is not authenticated');
+		});
+	});
+
+	describe('Complex Nested Function Calls', () => {
+		test('should handle nested function calls with proper context passing', async () => {
+			const createAuthedServerFn = initCreateFn<AuthedServerFnCtx>([
+				authMiddleware,
+				authedErrorLoggingMiddleware,
+			]);
+
+			// Create individual functions
+			const checkCredits = createAuthedServerFn({
+				name: 'checkCredits',
+				inputSchema: z.object({ cost: z.number() }),
+				handler: async ({ input, ctx }) => {
+					const credits = await ctx.db.credits.findFirst();
+					return credits!.amount > input.cost;
+				},
+			});
+
+			const sendSms = createAuthedServerFn({
+				name: 'sendSms',
+				handler: async () => {
+					return { success: true };
+				},
+			});
+
+			const sendWelcomeText = createAuthedServerFn({
+				name: 'sendWelcomeText',
+				handler: async ({ ctx }) => {
+					const hasEnoughCredits = await checkCredits({
+						ctx,
+						input: { cost: 5 },
+					});
+
+					if (!hasEnoughCredits) {
+						throw new FnError({
+							code: 'FORBIDDEN',
+							message: 'Insufficient credits',
+						});
+					}
+
+					return await sendSms({ ctx });
+				},
+			});
+
+			// Test successful flow
+			const user = { id: 'user_with_credits' };
+			const result = await sendWelcomeText({
+				ctx: { logger, db: mockDb, user },
+			});
+
+			expect(typeof result).toBe('object');
+			expect(result.success).toBe(true);
+
+			// Verify the logger was called for all functions in the chain
+			expect(logger.info).toHaveBeenCalledWith("-> Calling 'sendWelcomeText'");
+			expect(logger.info).toHaveBeenCalledWith("-> Calling 'checkCredits'");
+			expect(logger.info).toHaveBeenCalledWith("-> Calling 'sendSms'");
+		});
+
+		test('should handle errors in nested calls', async () => {
+			const createAuthedServerFn = initCreateFn<AuthedServerFnCtx>([
+				authMiddleware,
+				authedErrorLoggingMiddleware,
+			]);
+
+			const failingFn = createAuthedServerFn({
+				name: 'failing',
+				handler: async () => {
+					throw new Error('Something went wrong');
+				},
+			});
+
+			const callerFn = createAuthedServerFn({
+				name: 'caller',
+				handler: async ({ ctx }) => {
+					return await failingFn({ ctx });
+				},
+			});
+
+			await expect(
+				callerFn({ ctx: { logger, db: mockDb, user: { id: 'test' } } })
+			).rejects.toThrow('Something went wrong');
+
+			expect(logger.error).toHaveBeenCalledWith(
+				expect.any(Error),
+				"Error in 'failing'"
+			);
+		});
+	});
+
+	describe('Array-style middleware composition', () => {
+		test('should support array-style middleware initialization', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([
+				loggingMiddleware,
+				createTimingMiddleware<ServerFnCtx>(),
+			]);
+
+			expect(typeof createServerFn).toBe('function');
+
+			const testFn = createServerFn({
+				name: 'test',
+				handler: async () => 'result',
+			});
+
+			const result = await testFn({ ctx: { logger, db: mockDb } });
+
+			expect(typeof result).toBe('string');
+			expect(result).toBe('result');
+			expect(logger.info).toHaveBeenCalledWith("-> Calling 'test'");
+			expect(logger.info).toHaveBeenCalledWith("<- Finished 'test'");
+			expect(logger.info).toHaveBeenCalledWith(
+				expect.stringMatching(/'test' took \d+ms/)
+			);
+		});
+
+		test('should handle empty middleware array', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			expect(typeof createServerFn).toBe('function');
+
+			const simpleFn = createServerFn({
+				name: 'simple',
+				handler: async () => ({ message: 'no middleware' }),
+			});
+
+			const result = await simpleFn({ ctx: { logger, db: mockDb } });
+
+			expect(typeof result).toBe('object');
+			expect(result.message).toBe('no middleware');
+		});
+
+		test('should handle middleware without explicit array parameter', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>();
+
+			expect(typeof createServerFn).toBe('function');
+
+			const defaultFn = createServerFn({
+				name: 'default',
+				handler: async () => 'default behavior',
+			});
+
+			const result = await defaultFn({ ctx: { logger, db: mockDb } });
+
+			expect(typeof result).toBe('string');
+			expect(result).toBe('default behavior');
+		});
+	});
+
+	describe('SafeCall behavior', () => {
+		test('should return proper result structure from safeCall', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const testFn = createServerFn({
+				name: 'safeTest',
+				inputSchema: z.object({ value: z.string() }),
+				handler: async ({ input }) => ({
+					processed: input.value.toUpperCase(),
+				}),
+			});
+
+			const result = await testFn.safeCall({
+				input: { value: 'hello' },
+				ctx: { logger, db: mockDb },
+			});
+
+			expect(typeof result).toBe('object');
+			expect(result).toHaveProperty('data');
+			expect(result).toHaveProperty('error');
+			expect(result.error).toBeNull();
+			expect(result.data).toEqual({ processed: 'HELLO' });
+		});
+
+		test('should handle validation errors in safeCall', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const testFn = createServerFn({
+				name: 'validationTest',
+				inputSchema: z.object({ value: z.string() }),
+				handler: async ({ input }) => input.value,
+			});
+
+			const result = await testFn.safeCall({
+				input: { value: 123 } as any, // Invalid input
+				ctx: { logger, db: mockDb },
+			});
+
+			expect(typeof result).toBe('object');
+			expect(result.data).toBeNull();
+			expect(result.error).toBeInstanceOf(FnError);
+		});
+	});
+
+	describe('Input and Context Type Inference', () => {
+		test('should properly infer simple input types inside handler', () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const simpleInputFn = createServerFn({
+				name: 'simpleInput',
+				inputSchema: z.object({
+					title: z.string(),
+					count: z.number(),
+				}),
+				handler: async ({ input, ctx }) => {
+					// Type assertions for input
+					expectTypeOf(input).toEqualTypeOf<{
+						title: string;
+						count: number;
+					}>();
+					expectTypeOf(input.title).toEqualTypeOf<string>();
+					expectTypeOf(input.count).toEqualTypeOf<number>();
+
+					// Type assertions for context
+					expectTypeOf(ctx).toEqualTypeOf<ServerFnCtx>();
+
+					return `${input.title}: ${input.count}`;
+				},
+			});
+
+			// Verify function call signature
+			expectTypeOf(simpleInputFn).parameter(0).toEqualTypeOf<{
+				input: { title: string; count: number };
+				ctx: ServerFnCtx;
+			}>();
+			expectTypeOf(simpleInputFn).returns.resolves.toEqualTypeOf<string>();
+		});
+
+		test('should properly infer complex nested input types', () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const complexInputFn = createServerFn({
+				name: 'complexInput',
+				inputSchema: z.object({
+					user: z.object({
+						id: z.string(),
+						profile: z.object({
+							name: z.string(),
+							age: z.number().optional(),
+						}),
+					}),
+					metadata: z.record(z.any(), z.any()).optional(),
+					tags: z.array(z.string()),
+				}),
+				handler: async ({ input, ctx }) => {
+					// Type assertions for nested input structure
+					expectTypeOf(input).toEqualTypeOf<{
+						user: {
+							id: string;
+							profile: {
+								name: string;
+								age?: number;
+							};
+						};
+						metadata?: Record<string, any>;
+						tags: string[];
+					}>();
+
+					expectTypeOf(input.user.id).toEqualTypeOf<string>();
+					expectTypeOf(input.user.profile.name).toEqualTypeOf<string>();
+					expectTypeOf(input.user.profile.age).toEqualTypeOf<
+						number | undefined
+					>();
+					expectTypeOf(input.metadata).toEqualTypeOf<
+						Record<string, any> | undefined
+					>();
+					expectTypeOf(input.tags).toEqualTypeOf<string[]>();
+
+					// Context should remain unchanged
+					expectTypeOf(ctx).toEqualTypeOf<ServerFnCtx>();
+
+					return { success: true, userId: input.user.id };
+				},
+			});
+
+			expectTypeOf(complexInputFn).parameter(0).toMatchTypeOf<{
+				input: {
+					user: {
+						id: string;
+						profile: {
+							name: string;
+							age?: number;
+						};
+					};
+					metadata?: Record<string, any>;
+					tags: string[];
+				};
+				ctx: ServerFnCtx;
+			}>();
+		});
+
+		test('should handle no input schema correctly', () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const noInputFn = createServerFn({
+				name: 'noInput',
+				handler: async ({ input, ctx }) => {
+					// When no input schema is provided, input should be void
+					expectTypeOf(input).toEqualTypeOf<void>();
+					expectTypeOf(ctx).toEqualTypeOf<ServerFnCtx>();
+
+					return 'no input needed';
+				},
+			});
+
+			expectTypeOf(noInputFn).parameter(0).toEqualTypeOf<{
+				input?: void;
+				ctx: ServerFnCtx;
+			}>();
+		});
+
+		test('should properly infer authed context types in handler', () => {
+			const createAuthedServerFn = initCreateFn<AuthedServerFnCtx>([
+				authMiddleware,
+			]);
+
+			const authedFn = createAuthedServerFn({
+				name: 'authedFunction',
+				inputSchema: z.object({
+					action: z.enum(['create', 'update', 'delete']),
+				}),
+				handler: async ({ input, ctx }) => {
+					// Input type should be properly inferred
+					expectTypeOf(input).toEqualTypeOf<{
+						action: 'create' | 'update' | 'delete';
+					}>();
+					expectTypeOf(input.action).toEqualTypeOf<
+						'create' | 'update' | 'delete'
+					>();
+
+					// Context should be the authed version with required user
+					expectTypeOf(ctx).toEqualTypeOf<AuthedServerFnCtx>();
+					expectTypeOf(ctx.user).toEqualTypeOf<{ id: string }>();
+					expectTypeOf(ctx.user.id).toEqualTypeOf<string>();
+
+					return { action: input.action, userId: ctx.user.id };
+				},
+			});
+
+			expectTypeOf(authedFn).parameter(0).toEqualTypeOf<{
+				input: { action: 'create' | 'update' | 'delete' };
+				ctx: AuthedServerFnCtx;
+			}>();
+		});
+
+		test('should properly infer union and literal types', () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const unionTypeFn = createServerFn({
+				name: 'unionTypes',
+				inputSchema: z.object({
+					status: z.union([
+						z.literal('active'),
+						z.literal('inactive'),
+						z.literal('pending'),
+					]),
+					priority: z.enum(['low', 'medium', 'high']),
+					value: z.union([z.string(), z.number()]),
+				}),
+				handler: async ({ input, ctx }) => {
+					expectTypeOf(input).toEqualTypeOf<{
+						status: 'active' | 'inactive' | 'pending';
+						priority: 'low' | 'medium' | 'high';
+						value: string | number;
+					}>();
+
+					expectTypeOf(input.status).toEqualTypeOf<
+						'active' | 'inactive' | 'pending'
+					>();
+					expectTypeOf(input.priority).toEqualTypeOf<
+						'low' | 'medium' | 'high'
+					>();
+					expectTypeOf(input.value).toEqualTypeOf<string | number>();
+
+					return {
+						processedStatus: input.status,
+						processedPriority: input.priority,
+						processedValue: input.value,
+					};
+				},
+			});
+
+			expectTypeOf(unionTypeFn).returns.resolves.toEqualTypeOf<{
+				processedStatus: 'active' | 'inactive' | 'pending';
+				processedPriority: 'low' | 'medium' | 'high';
+				processedValue: string | number;
+			}>();
+		});
+
+		test('should properly infer types through middleware chain', () => {
+			const createAuthedServerFn = initCreateFn<AuthedServerFnCtx>([
+				authMiddleware,
+				authedLoggingMiddleware,
+			]);
+
+			const middlewareChainFn = createAuthedServerFn({
+				name: 'middlewareChain',
+				inputSchema: z.object({
+					data: z.object({
+						items: z.array(
+							z.object({
+								id: z.string(),
+								value: z.number(),
+							})
+						),
+					}),
+				}),
+				handler: async ({ input, ctx }) => {
+					// Even with middleware chain, types should be preserved
+					expectTypeOf(input).toEqualTypeOf<{
+						data: {
+							items: Array<{
+								id: string;
+								value: number;
+							}>;
+						};
+					}>();
+
+					expectTypeOf(input.data.items).toEqualTypeOf<
+						Array<{
+							id: string;
+							value: number;
+						}>
+					>();
+
+					// Context should still be the correct authed type
+					expectTypeOf(ctx).toEqualTypeOf<AuthedServerFnCtx>();
+					expectTypeOf(ctx.user.id).toEqualTypeOf<string>();
+
+					return input.data.items.map((item) => ({
+						...item,
+						processed: true,
+					}));
+				},
+			});
+
+			expectTypeOf(middlewareChainFn).returns.resolves.toEqualTypeOf<
+				Array<{
+					id: string;
+					value: number;
+					processed: boolean;
+				}>
+			>();
+		});
+
+		test('should handle optional input fields correctly', () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const optionalFieldsFn = createServerFn({
+				name: 'optionalFields',
+				inputSchema: z.object({
+					required: z.string(),
+					optional: z.string().optional(),
+					withDefault: z.string().default('default-value'),
+					nullable: z.string().nullable(),
+				}),
+				handler: async ({ input, ctx }) => {
+					expectTypeOf(input).toEqualTypeOf<{
+						required: string;
+						optional?: string | undefined;
+						withDefault: string;
+						nullable: string | null;
+					}>();
+
+					expectTypeOf(input.required).toEqualTypeOf<string>();
+					expectTypeOf(input.optional).toEqualTypeOf<string | undefined>();
+					expectTypeOf(input.withDefault).toEqualTypeOf<string >();
+					expectTypeOf(input.nullable).toEqualTypeOf<string | null>();
+
+					return {
+						required: input.required,
+						hasOptional: input.optional !== undefined,
+						withDefault: input.withDefault,
+						isNullable: input.nullable === null,
+					};
+				},
+			});
+
+			expectTypeOf(optionalFieldsFn).parameter(0).toMatchTypeOf<{
+				input: {
+					required: string;
+					optional?: string;
+					withDefault?: string; // Zod default makes this optional in input
+					nullable: string | null;
+				};
+				ctx: ServerFnCtx;
+			}>();
+		});
+
+		test('should properly type safeCall results', async () => {
+			const createServerFn = initCreateFn<ServerFnCtx>([]);
+
+			const typedFn = createServerFn({
+				name: 'typedSafeCall',
+				inputSchema: z.object({ value: z.number() }),
+				handler: async ({ input }) => ({
+					doubled: input.value * 2,
+					original: input.value,
+				}),
+			});
+
+			const result = await typedFn.safeCall({
+				input: { value: 42 },
+				ctx: { logger: createMockLogger(), db: mockDb },
+			});
+
+			type SuccessResult = {
+				data: { doubled: number; original: number };
+				error: null;
+			};
+			type ErrorResult = {
+				data: null;
+				error: FnError | Error;
+			};
+
+			expectTypeOf(result).toEqualTypeOf<SuccessResult | ErrorResult>();
+
+			if (result.error === null) {
+				expectTypeOf(result).toEqualTypeOf<SuccessResult>();
+			} else {
+				expectTypeOf(result).toEqualTypeOf<ErrorResult>();
+			}
+
+			if (!result.error) {
+				expectTypeOf(result.data).toEqualTypeOf<{
+					doubled: number;
+					original: number;
+				}>();
+			} else {
+				expectTypeOf(result.error).toEqualTypeOf<FnError | Error>();
+			}
+		});
+	});
+});
diff --git a/packages/fn/test/core.test.ts b/packages/fn/test/core.test.ts
new file mode 100644
index 0000000..3a845e4
--- /dev/null
+++ b/packages/fn/test/core.test.ts
@@ -0,0 +1,230 @@
+import { describe, test, expect } from 'vitest';
+import { createFn, FnError } from '../src';
+import { z } from 'zod';
+
+// Test function definition used across different suites
+const testFn = createFn({
+	name: 'testFn',
+	inputSchema: z.object({ title: z.string() }),
+	outputSchema: z.object({ id: z.string(), title: z.string() }),
+	handler: async ({ input }) => {
+		if (input.title === 'throw') {
+			throw new Error('Raw handler error');
+		}
+		// Return invalid output shape to test output validation
+		if (input.title === 'invalid-output') {
+			return { id: 123, title: 'invalid' } as any;
+		}
+		return { id: 'chat_123', title: input.title };
+	},
+});
+
+//* MARK: Core
+describe('Core `createFn` API', () => {
+	test('should create a function with definition properties attached', () => {
+		expect(typeof testFn).toBe('function');
+		expect(testFn.name).toBe('testFn');
+		expect(testFn.inputSchema).toBeDefined();
+		expect(testFn.outputSchema).toBeDefined();
+		expect(testFn.handler).toBeDefined();
+	});
+
+	// MARK: Direct Call -> myFn({})
+	describe('Direct Call (`myFn({})`)', () => {
+		test('should return data directly on success', async () => {
+			const result = await testFn({ input: { title: 'Success' } });
+			expect(result).toEqual({ id: 'chat_123', title: 'Success' });
+		});
+
+		test('should THROW an INVALID_INPUT error for invalid input', async () => {
+			const promise = testFn({ input: { title: 123 } as any });
+			await expect(promise).rejects.toThrow(FnError);
+			await expect(promise).rejects.toHaveProperty('code', 'INVALID_INPUT');
+		});
+
+		test('should THROW an INVALID_OUTPUT error for invalid output', async () => {
+			const promise = testFn({ input: { title: 'invalid-output' } });
+			await expect(promise).rejects.toThrow(FnError);
+			await expect(promise).rejects.toHaveProperty('code', 'INVALID_OUTPUT');
+		});
+
+		test('should THROW an enhanced FnError for handler errors', async () => {
+			const promise = testFn({ input: { title: 'throw' } });
+			await expect(promise).rejects.toThrow(FnError);
+			await expect(promise).rejects.toHaveProperty(
+				'code',
+				'INTERNAL_SERVER_ERROR'
+			);
+			await expect(promise).rejects.toHaveProperty(
+				'message',
+				'Raw handler error'
+			);
+		});
+	});
+
+	// MARK: Safe Call -> myFn.safeCall({})
+	describe('.safeCall()', () => {
+		test('should return { data, error: null } on success', async () => {
+			const { data, error } = await testFn.safeCall({
+				input: { title: 'Test' },
+			});
+			expect(error).toBeNull();
+			expect(data).toEqual({ id: 'chat_123', title: 'Test' });
+		});
+
+		test('should RETURN an INVALID_INPUT error for invalid input', async () => {
+			const { data, error } = await testFn.safeCall({
+				input: { title: 123 } as any,
+			});
+			expect(data).toBeNull();
+			expect(error).toBeInstanceOf(FnError);
+			expect((error as FnError).code).toBe('INVALID_INPUT');
+		});
+
+		test('should RETURN an INVALID_OUTPUT error for invalid output', async () => {
+			const { data, error } = await testFn.safeCall({
+				input: { title: 'invalid-output' },
+			});
+			expect(data).toBeNull();
+			expect(error).toBeInstanceOf(FnError);
+			expect((error as FnError).code).toBe('INVALID_OUTPUT');
+		});
+
+		test('should RETURN an INTERNAL_SERVER_ERROR for handler errors', async () => {
+			const { data, error } = await testFn.safeCall({
+				input: { title: 'throw' },
+			});
+			expect(data).toBeNull();
+			expect(error).toBeInstanceOf(FnError);
+			expect((error as FnError).code).toBe('INTERNAL_SERVER_ERROR');
+		});
+	});
+
+	// MARK: Handler Call -> myFn.handler({})
+	describe('.handler()', () => {
+		test('should return data on success without validation', async () => {
+			const result = await testFn.handler({
+				input: { title: 'Success' },
+			});
+			expect(result).toEqual({ id: 'chat_123', title: 'Success' });
+		});
+
+		test('should NOT validate input', async () => {
+			// show throw with direct call, due to input validation
+			await expect(
+				testFn({
+					input: { title: null } as any,
+				})
+			).rejects.toThrow(FnError);
+
+			// should NOT throw with handler call, as it bypasses input validation
+			await expect(
+				testFn.handler({
+					input: { title: null } as any,
+				})
+			).resolves.not.toThrow(FnError);
+		});
+
+		test('should NOT validate output', async () => {
+			// This returns a shape that would fail output validation.
+			const result = await testFn.handler({
+				input: { title: 'invalid-output' },
+			});
+			expect(result).toEqual({ id: 123, title: 'invalid' });
+		});
+
+		test('should throw a RAW (non-FnError) error on failure', async () => {
+			const promise = testFn.handler({
+				input: { title: 'throw' },
+			});
+			// It should reject with the original Error, not an FnError.
+			await expect(promise).rejects.toThrow('Raw handler error');
+			await expect(promise).rejects.not.toBeInstanceOf(FnError);
+		});
+	});
+});
+
+//* MARK: FormData
+describe('FormData Handling', () => {
+	const processForm = createFn({
+		name: 'processForm',
+		inputSchema: z.object({
+			name: z.string(),
+			age: z.coerce.number(), // Use coerce for FormData strings
+			isAdmin: z.coerce.boolean().default(false),
+		}),
+		handler: async ({ input }) => {
+			return `Name: ${input.name}, Age: ${input.age}, Admin: ${input.isAdmin}`;
+		},
+	});
+
+	test('should handle FormData input in .safeCall()', async () => {
+		const formData = new FormData();
+		formData.append('name', 'John Doe');
+		formData.append('age', '30');
+
+		const { data, error } = await processForm.safeCall({
+			input: formData as any,
+		});
+
+		expect(error).toBeNull();
+		expect(data).toBe('Name: John Doe, Age: 30, Admin: false');
+	});
+
+	test('should handle FormData input in direct call', async () => {
+		const formData = new FormData();
+		formData.append('name', 'Jane Doe');
+		formData.append('age', '25');
+		formData.append('isAdmin', 'true');
+
+		const result = await processForm({ input: formData as any });
+
+		expect(result).toBe('Name: Jane Doe, Age: 25, Admin: true');
+	});
+
+	test('should return INVALID_INPUT for malformed FormData in .safeCall()', async () => {
+		const formData = new FormData();
+		formData.append('name', 'Missing Age');
+		// 'age' is missing, which is required by the schema.
+
+		const { data, error } = await processForm.safeCall({
+			input: formData as any,
+		});
+
+		expect(data).toBeNull();
+		expect(error).toBeInstanceOf(FnError);
+		if (error instanceof FnError) {
+			expect(error.code).toBe('INVALID_INPUT');
+		}
+	});
+
+	test('should handle complex nested objects from FormData', async () => {
+		const processNestedForm = createFn({
+			name: 'processNestedForm',
+			inputSchema: z.object({
+				user: z.object({
+					name: z.string(),
+				}),
+				items: z.array(z.object({ id: z.coerce.number() })),
+			}),
+			handler: async ({ input }) => {
+				return `User: ${input.user.name}, Items: ${input.items
+					.map((i) => i.id)
+					.join(',')}`;
+			},
+		});
+
+		const formData = new FormData();
+		formData.append('user.name', 'Nested User5');
+		formData.append('items[0].id', '101');
+		formData.append('items[1].id', '102');
+
+		const { data, error } = await processNestedForm.safeCall({
+			input: formData as any,
+		});
+
+		expect(error).toBeNull();
+		console.dir(data, { depth: null });
+		expect(data).not.toBe('User: Nested User, Items: 101,102');
+	});
+});
diff --git a/packages/fn/test/error-reporting.test.ts b/packages/fn/test/error-reporting.test.ts
new file mode 100644
index 0000000..fb79d48
--- /dev/null
+++ b/packages/fn/test/error-reporting.test.ts
@@ -0,0 +1,192 @@
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+import {
+	createFn,
+	FnError,
+	createMiddleware,
+	initCreateFn,
+	isFnError,
+} from '../src';
+
+// --- Test Setup: A Simple Logger and a Focused Middleware ---
+
+/**
+ * A helper to create an error with a distinct, deep stack trace for testing.
+ */
+const createOriginalError = (message: string): Error => {
+	try {
+		// Use named functions so they are clearly identifiable in the stack trace.
+		function createErrorFrame1() {
+			function createErrorFrame2() {
+				throw new Error(message);
+			}
+			createErrorFrame2();
+		}
+		createErrorFrame1();
+	} catch (e) {
+		return e as Error;
+	}
+	throw new Error('Fallback error'); // Should not be reached
+};
+
+/**
+ * A simple logger that adheres to the principle of not being "too smart".
+ * It has a single `error` method that we can spy on.
+ */
+const createSimpleLogger = () => ({
+	error: vi.fn((_error: Error, _context?: Record<string, unknown>) => {
+		// In a real implementation, this would send the error and context
+		// to a service like Sentry, Pino, etc.
+	}),
+	cleanup: () => {
+		vi.clearAllMocks();
+	},
+});
+
+type TestContext = {
+	logger: ReturnType<typeof createSimpleLogger>;
+};
+
+/**
+ * This middleware embodies the new, simpler philosophy. It's designed to:
+ * 1. Catch any error.
+ * 2. If the error is new, pass the ORIGINAL error to the logger.
+ * 3. Mark the error as reported to prevent duplicates.
+ * 4. Re-throw the error to allow it to bubble up and be decorated by other middleware.
+ */
+const reportingMiddleware = createMiddleware<TestContext>(
+	async ({ ctx, def, next }) => {
+		try {
+			return await next();
+		} catch (error) {
+			const fnError = FnError.from(error);
+
+			if (!fnError._reported) {
+				// --- Key Change: Logging the *original* cause ---
+				// If there's a cause, log that. Otherwise, log the error itself.
+				// This ensures the logger gets the error with the original stack trace.
+				const errorToLog =
+					fnError.cause instanceof Error ? fnError.cause : fnError;
+				ctx.logger.error(errorToLog, {
+					functionName: def.name,
+					message: 'An error was reported',
+				});
+
+				fnError.markAsReported();
+			}
+
+			// Re-throw the (potentially wrapped) error to allow the default
+			// error handler to build the `functionTrace`.
+			throw fnError;
+		}
+	}
+);
+
+// --- The Test Suite ---
+
+describe('Robust Error Reporting with a Simple Logger', () => {
+	const logger = createSimpleLogger();
+
+	// Create a function factory with our realistic reporting middleware.
+	const createReportingFn = initCreateFn<TestContext>([reportingMiddleware]);
+
+	// Define a set of nested functions.
+	const innerFn = createReportingFn({
+		name: 'innerFn',
+		handler: () => {
+			throw createOriginalError('Critical failure in the core.');
+		},
+	});
+
+	const middleFn = createReportingFn({
+		name: 'middleFn',
+		handler: async ({ ctx }) => {
+			return await innerFn({ ctx });
+		},
+	});
+
+	const outerFn = createReportingFn({
+		name: 'outerFn',
+		handler: async ({ ctx }) => {
+			return await middleFn({ ctx });
+		},
+	});
+
+	beforeEach(() => {
+		logger.cleanup();
+	});
+
+	test('should report the error exactly once', async () => {
+		await expect(outerFn({ ctx: { logger } })).rejects.toThrow(FnError);
+		expect(logger.error).toHaveBeenCalledTimes(1);
+	});
+
+	test('EMPIRICAL PROOF: The logger receives the ORIGINAL, untouched error object', async () => {
+		const originalError = createOriginalError('test error');
+		const fnThatThrows = createReportingFn({
+			name: 'fnThatThrows',
+			handler: () => {
+				throw originalError;
+			},
+		});
+
+		await expect(fnThatThrows({ ctx: { logger } })).rejects.toThrow();
+
+		// --- THE KEY ASSERTION ---
+		// We check the first argument passed to our simple logger's `error` method.
+		// It should be the *exact same object* as the one we originally threw.
+		const loggedError = logger.error.mock.calls[0][0];
+		expect(loggedError).toBe(originalError);
+
+		// Verify its stack trace is the original one.
+		expect(loggedError.stack).toContain('createErrorFrame1');
+		expect(loggedError.stack).toContain('createErrorFrame2');
+	});
+
+	test('The final THROWN error contains the complete, ordered function trace for the caller', async () => {
+		const promise = outerFn({ ctx: { logger } });
+		const caughtError = (await promise.catch((e) => e)) as FnError;
+
+		// The final error that the user/caller catches should be the fully decorated FnError.
+		expect(caughtError).toBeInstanceOf(FnError);
+
+		// The metadata should be from the outermost function that handled the error.
+		expect(caughtError.meta.functionName).toBe('outerFn');
+
+		// The functionTrace should show the full path the error bubbled up through.
+		expect(caughtError.meta.functionTrace).toEqual([
+			'outerFn',
+			'middleFn',
+			'innerFn',
+		]);
+	});
+
+	test('The logged error and the final thrown error are different objects with different stacks', async () => {
+		// Run the function only ONCE and capture the thrown error.
+		const thrownError = (await outerFn({ ctx: { logger } }).catch(
+			(e) => e
+		)) as FnError;
+
+		// Now, get the error that was logged during that single run.
+		const loggedError = logger.error.mock.calls[0][0] as Error;
+
+		// The logged error is the original, the thrown error is the wrapper.
+		expect(loggedError).not.toBe(thrownError);
+		expect(thrownError.cause).toBe(loggedError);
+
+		// Their stacks should be different.
+		const loggedStack = loggedError.stack;
+		const thrownStack = thrownError.stack;
+
+		// console.log('loggedError', loggedError);
+		// console.log('--------------------------------');
+		// console.log('thrownError', thrownError);
+		// console.log('--------------------------------');
+		// console.log('loggedStack', loggedStack);
+		// console.log('--------------------------------');
+		// console.log('thrownStack', thrownStack);
+
+		expect(loggedStack).not.toEqual(thrownStack);
+		expect(loggedStack).toContain('createErrorFrame2'); // Original error's stack
+		expect(thrownStack).toMatch(/(?:Function|FnError)\.from/); // Wrapper's stack (frame name varies by V8 version)
+	});
+});
diff --git a/packages/fn/test/error.test.ts b/packages/fn/test/error.test.ts
new file mode 100644
index 0000000..60419b2
--- /dev/null
+++ b/packages/fn/test/error.test.ts
@@ -0,0 +1,101 @@
+import { describe, test, expect } from 'vitest';
+import { z } from 'zod';
+import { createFn, FnError } from '../src';
+
+/**
+ * A helper to create an error with a distinct, deep stack trace for testing.
+ */
+const createOriginalError = (message: string): Error => {
+	try {
+		function createErrorFrame1() {
+			function createErrorFrame2() {
+				throw new Error(message);
+			}
+			createErrorFrame2();
+		}
+		createErrorFrame1();
+	} catch (e) {
+		return e as Error;
+	}
+	throw new Error('Fallback error'); // Should not be reached
+};
+
+describe('Core Error Handling', () => {
+	const basicFn = createFn({
+		name: 'basicFn',
+		inputSchema: z.object({ id: z.string().min(1) }),
+		outputSchema: z.object({ success: z.boolean() }),
+		handler: ({ input }) => {
+			if (input.id === 'throw-raw') {
+				throw createOriginalError('Raw error from handler');
+			}
+			if (input.id === 'throw-fn-error') {
+				throw new FnError({
+					code: 'FORBIDDEN',
+					message: 'Custom FnError from handler',
+				});
+			}
+			if (input.id === 'invalid-output') {
+				return { wrong: 'shape' } as any;
+			}
+			return { success: true };
+		},
+	});
+
+	test('direct call should throw FnError on input validation failure', async () => {
+		const promise = basicFn({ input: { id: '' } });
+		await expect(promise).rejects.toThrow(FnError);
+		await expect(promise).rejects.toHaveProperty('code', 'INVALID_INPUT');
+	});
+
+	test('safeCall should return FnError on input validation failure', async () => {
+		const { data, error } = await basicFn.safeCall({ input: { id: '' } });
+		expect(data).toBeNull();
+		expect(error).toBeInstanceOf(FnError);
+		expect(error).toHaveProperty('code', 'INVALID_INPUT');
+	});
+
+	test('direct call should throw FnError on output validation failure', async () => {
+		const promise = basicFn({ input: { id: 'invalid-output' } });
+		await expect(promise).rejects.toThrow(FnError);
+		await expect(promise).rejects.toHaveProperty('code', 'INVALID_OUTPUT');
+	});
+
+	test('safeCall should return FnError on output validation failure', async () => {
+		const { data, error } = await basicFn.safeCall({
+			input: { id: 'invalid-output' },
+		});
+		expect(data).toBeNull();
+		expect(error).toBeInstanceOf(FnError);
+		expect(error).toHaveProperty('code', 'INVALID_OUTPUT');
+	});
+
+	test('direct call should wrap raw handler error in FnError and preserve cause', async () => {
+		const promise = basicFn({ input: { id: 'throw-raw' } });
+		await expect(promise).rejects.toThrow(FnError);
+
+		const caughtError = (await promise.catch((e) => e)) as FnError;
+		expect(caughtError.code).toBe('INTERNAL_SERVER_ERROR');
+		expect(caughtError.message).toBe('Raw error from handler');
+
+		// Check that the original error is preserved as the cause
+		const cause = caughtError.cause;
+		expect(cause).toBeInstanceOf(Error);
+		if (cause instanceof Error) {
+			expect(cause.message).toBe('Raw error from handler');
+			// Verify the original stack trace is present
+			expect(cause.stack).toContain('createErrorFrame2');
+		}
+	});
+
+	test('direct call should preserve and enhance a thrown FnError', async () => {
+		const promise = basicFn({ input: { id: 'throw-fn-error' } });
+		await expect(promise).rejects.toThrow(FnError);
+
+		const caughtError = (await promise.catch((e) => e)) as FnError;
+		expect(caughtError.code).toBe('FORBIDDEN');
+		expect(caughtError.message).toBe('Custom FnError from handler');
+		// The default error handler should have added its own context
+		expect(caughtError.meta.functionName).toBe('basicFn');
+	});
+});
diff --git a/packages/fn/test/init-procedure-factory.test.ts b/packages/fn/test/init-procedure-factory.test.ts
new file mode 100644
index 0000000..189823e
--- /dev/null
+++ b/packages/fn/test/init-procedure-factory.test.ts
@@ -0,0 +1,58 @@
+// import { describe, test, expect } from 'vitest';
+// describe('initProcedureFactory', () => {
+// 	expect(true).toBe(true);
+// });
+import { describe, expect, test } from 'vitest';
+import { initProcedureFactory } from '../src/utils/init-procedure-factory';
+
+import { initTRPC } from '@trpc/server';
+import { MutationProcedure } from '@trpc/server/unstable-core-do-not-import';
+import { expectTypeOf } from 'vitest';
+import { z } from 'zod';
+import { createFn } from '../src';
+
+describe('initProcedureFactory', () => {
+	test('should create a hello world test', () => {
+		// Simple hello world test to verify the test setup works
+		const message = 'Hello World';
+		expect(message).toBe('Hello World');
+	});
+
+	test('should initialize a procedure factory', () => {
+		// Mock procedure builder
+
+		const t = initTRPC.create();
+		const baseProcedure = t.procedure;
+
+		// Create factory
+		const createFnProcedure = initProcedureFactory(baseProcedure);
+
+		// Verify factory is a function
+		expect(typeof createFnProcedure).toBe('function');
+
+		const createChat = createFn({
+			name: 'createChat',
+			description: 'Create a chat',
+			tags: ['chat'],
+			inputSchema: z.object({ title: z.string() }),
+			handler: async ({ input }) => {
+				return { id: 'chat_123', title: input.title };
+			},
+		});
+
+		const createChatProcedure = createFnProcedure(createChat, 'mutation');
+
+		expect(createChatProcedure).toBeDefined();
+		expectTypeOf<typeof createChatProcedure>().not.toBeUndefined();
+
+		// console.log('createChatProcedure', createChatProcedure);
+		// console.log('createChatProcedure.type:', typeof createChatProcedure);
+		expectTypeOf<typeof createChatProcedure>({} as any).toEqualTypeOf<
+			MutationProcedure<{
+				input: { title: string };
+				output: { id: string; title: string };
+				meta: Record<string, string>;
+			}>
+		>({} as any);
+	});
+});
diff --git a/packages/fn/test/test-utils.ts b/packages/fn/test/test-utils.ts
new file mode 100644
index 0000000..70b114b
--- /dev/null
+++ b/packages/fn/test/test-utils.ts
@@ -0,0 +1,118 @@
+// packages/fn/test/test-utils.ts
+import { vi } from 'vitest';
+import { z } from 'zod';
+import { createMiddleware, FnError } from '../src';
+
+// A mock logger to spy on calls
+export const createMockLogger = () => ({
+	info: vi.fn(),
+	error: vi.fn(),
+	warn: vi.fn(),
+	debug: vi.fn(),
+	// Method to clear mocks between tests
+	cleanup: function () {
+		this.info.mockClear();
+		this.error.mockClear();
+		this.warn.mockClear();
+		this.debug.mockClear();
+	},
+});
+
+// A mock DB client
+export const mockDb = {
+	chat: {
+		create: vi.fn(async (data) => ({ id: 'chat_123', ...data.data })),
+	},
+	credits: {
+		findFirst: vi.fn(async () => ({ amount: 100 })),
+	},
+};
+
+// Define shared context types
+export type ServerFnCtx = {
+	logger: ReturnType<typeof createMockLogger>;
+	db: typeof mockDb;
+	user?: { id: string };
+};
+export type AuthedServerFnCtx = Required<ServerFnCtx>;
+
+// Shared Zod schemas
+export const commonSchemas = {
+	createChatInput: z.object({ title: z.string() }),
+	createChatOutput: z.object({ id: z.string(), title: z.string() }),
+};
+
+// --- Reusable Middleware Helpers ---
+
+/**
+ * Creates a logging middleware that logs function entry and exit
+ */
+export const createLoggingMiddleware = <TContext extends { logger: any }>() =>
+	createMiddleware<TContext>(async ({ ctx, input, def, next }) => {
+		ctx.logger.info(`-> Calling '${def.name}'`);
+		const result = await next();
+		ctx.logger.info(`<- Finished '${def.name}'`);
+		return result;
+	});
+
+/**
+ * Creates an error-handling logging middleware that also logs errors
+ */
+export const createErrorLoggingMiddleware = <
+	TContext extends { logger: any },
+>() =>
+	createMiddleware<TContext>(async ({ ctx, input, def, next }) => {
+		try {
+			ctx.logger.info(`-> Calling '${def.name}'`);
+			const result = await next();
+			ctx.logger.info(`<- Finished '${def.name}'`);
+			return result;
+		} catch (error) {
+			ctx.logger.error(error, `Error in '${def.name}'`);
+			throw error;
+		}
+	});
+
+/**
+ * Creates an auth middleware that requires a user to be present
+ */
+export const createAuthMiddleware = <
+	TContext extends { user?: { id: string } },
+>() =>
+	createMiddleware<TContext>(async ({ ctx, input, def, next }) => {
+		if (!ctx.user?.id) {
+			throw new FnError({
+				code: 'UNAUTHORIZED',
+				message: 'User is not authenticated.',
+			});
+		}
+		return next();
+	});
+
+/**
+ * Creates a simple timing middleware for performance testing
+ */
+export const createTimingMiddleware = <TContext extends { logger: any }>() =>
+	createMiddleware<TContext>(async ({ ctx, input, def, next }) => {
+		const start = Date.now();
+		const result = await next();
+		const duration = Date.now() - start;
+		ctx.logger.info(`'${def.name}' took ${duration}ms`);
+		return result;
+	});
+
+// --- Pre-configured Middleware Instances ---
+
+export const loggingMiddleware = createLoggingMiddleware<ServerFnCtx>();
+export const errorLoggingMiddleware =
+	createErrorLoggingMiddleware<ServerFnCtx>();
+export const authMiddleware = createAuthMiddleware<AuthedServerFnCtx>();
+export const timingMiddleware = createTimingMiddleware<ServerFnCtx>();
+
+// Authed versions
+export const authedLoggingMiddleware =
+	createLoggingMiddleware<AuthedServerFnCtx>();
+export const authedErrorLoggingMiddleware =
+	createErrorLoggingMiddleware<AuthedServerFnCtx>();
+export const authedTimingMiddleware =
+	createTimingMiddleware<AuthedServerFnCtx>();
diff --git a/packages/fn/test/tracing.test.ts b/packages/fn/test/tracing.test.ts
new file mode 100644
index 0000000..fa5b381
--- /dev/null
+++ b/packages/fn/test/tracing.test.ts
@@ -0,0 +1,166 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { z } from 'zod';
+import { createFn, createMiddleware, initCreateFn } from '../src';
+
+// --- Test Setup: A Realistic Logger and Tracing Middleware ---
+
+/**
+ * A realistic, generic logger interface.
+ */
+interface ILogger {
+	info(message: string, ...data: any[]): void;
+	error(error: Error, ...data: any[]): void;
+	warn(message: string, ...data: any[]): void;
+	debug(message: string, ...data: any[]): void;
+	child(bindings: { name: string }): ILogger;
+}
+
+/**
+ * A logger implementation that writes to the console and manages
+ * a hierarchical prefix for context.
+ */
+class ConsoleLogger implements ILogger {
+	private context: string;
+
+	constructor(context: string = '') {
+		this.context = context;
+	}
+
+	info(message: string, ...data: any[]): void {
+		console.info(this.context, message, ...data);
+	}
+
+	error(error: Error, ...data: any[]): void {
+		console.error(this.context, error, ...data);
+	}
+
+	warn(message: string, ...data: any[]): void {
+		console.warn(this.context, message, ...data);
+	}
+
+	debug(message: string, ...data: any[]): void {
+		console.debug(this.context, message, ...data);
+	}
+
+	child(bindings: { name: string }): ILogger {
+		const newContext = this.context
+			? `${this.context} -> [${bindings.name}]`
+			: `[${bindings.name}]`;
+		return new ConsoleLogger(newContext);
+	}
+}
+
+type LogContext = {
+	logger: ILogger;
+};
+
+/**
+ * A middleware specifically for tracing function execution.
+ * It uses the generic logger to output trace information.
+ */
+const tracingMiddleware = createMiddleware<LogContext>(
+	async ({ ctx, def, input, next }) => {
+		const childLogger = ctx.logger.child({ name: def.name });
+		const startTime = Date.now();
+
+		childLogger.info('->', { input });
+
+		const result = await next({ ...ctx, logger: childLogger });
+		const durationMs = Date.now() - startTime;
+
+		childLogger.info('<-', { output: result, durationMs });
+		return result;
+	}
+);
+
+// --- The Test Suite ---
+
+describe('Hierarchical Tracing with a Console-Based Logger', () => {
+	// We will spy on console.info to capture log output.
+	const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+
+	const createTracedFn = initCreateFn<LogContext>([tracingMiddleware]);
+
+	// Define nested functions.
+	const innerFn = createTracedFn({
+		name: 'innerFn',
+		handler: async () => {
+			await new Promise((resolve) => setTimeout(resolve, 10));
+			return { result: 'inner-ok' };
+		},
+	});
+
+	const middleFn = createTracedFn({
+		name: 'middleFn',
+		handler: async ({ ctx }) => {
+			const innerResult = await innerFn({ ctx });
+			return { result: `middle-ok-for-${innerResult.result}` };
+		},
+	});
+
+	const outerFn = createTracedFn({
+		name: 'outerFn',
+		handler: async ({ ctx }) => {
+			const middleResult = await middleFn({ ctx });
+			return { result: `outer-ok-for-${middleResult.result}` };
+		},
+	});
+
+	// Ensure the spy is reset before each test.
+	beforeEach(() => {
+		consoleSpy.mockClear();
+	});
+
+	// Restore the original console.info after all tests.
+	afterEach(() => {
+		consoleSpy.mockRestore();
+	});
+
+	test('should call console.info with hierarchical context and rich objects', async () => {
+		const rootLogger = new ConsoleLogger();
+		await outerFn({ ctx: { logger: rootLogger } });
+
+		// Check that our logger was called the correct number of times.
+		expect(consoleSpy).toHaveBeenCalledTimes(6);
+
+		// --- Assert Entry Traces ---
+		expect(consoleSpy).toHaveBeenNthCalledWith(1, '[outerFn]', '->', {
+			input: undefined,
+		});
+		expect(consoleSpy).toHaveBeenNthCalledWith(
+			2,
+			'[outerFn] -> [middleFn]',
+			'->',
+			{ input: undefined }
+		);
+		expect(consoleSpy).toHaveBeenNthCalledWith(
+			3,
+			'[outerFn] -> [middleFn] -> [innerFn]',
+			'->',
+			{ input: undefined }
+		);
+
+		// --- Assert Exit Traces ---
+		const innerExitCall = consoleSpy.mock.calls[3];
+		expect(innerExitCall[0]).toBe('[outerFn] -> [middleFn] -> [innerFn]');
+		expect(innerExitCall[1]).toBe('<-');
+		expect(innerExitCall[2].output).toEqual({ result: 'inner-ok' });
+		expect(innerExitCall[2].durationMs).toBeGreaterThanOrEqual(10);
+
+		const middleExitCall = consoleSpy.mock.calls[4];
+		expect(middleExitCall[0]).toBe('[outerFn] -> [middleFn]');
+		expect(middleExitCall[1]).toBe('<-');
+		expect(middleExitCall[2].output).toEqual({
+			result: 'middle-ok-for-inner-ok',
+		});
+		expect(middleExitCall[2].durationMs).toBeGreaterThanOrEqual(10);
+
+		const outerExitCall = consoleSpy.mock.calls[5];
+		expect(outerExitCall[0]).toBe('[outerFn]');
+		expect(outerExitCall[1]).toBe('<-');
+		expect(outerExitCall[2].output).toEqual({
+			result: 'outer-ok-for-middle-ok-for-inner-ok',
+		});
+		expect(outerExitCall[2].durationMs).toBeGreaterThanOrEqual(10);
+	});
+});
diff --git a/packages/fn/test/types.test.ts b/packages/fn/test/types.test.ts
new file mode 100644
index 0000000..1189f5f
--- /dev/null
+++ b/packages/fn/test/types.test.ts
@@ -0,0 +1,60 @@
+import { describe, test, expect, expectTypeOf } from 'vitest';
+import { z } from 'zod';
+import { createFn, FnError, createMiddleware } from '../src/create-fn';
+
+// Mock context for testing
+type TestContext = {
+	user?: { id: string };
+	db?: {
+		users: {
+			find: (id: string) => Promise<{ id: string; name: string }>;
+		};
+	};
+};
+
+describe('Type System', () => {
+	test('should infer types for handler with input and default context', () => {
+		const inputSchema = z.object({ id: z.string() });
+
+		const fn = createFn({
+			name: 'test',
+			inputSchema,
+			handler: async ({ input, ctx }) => {
+				expectTypeOf(input).toEqualTypeOf<{ id: string }>();
+				// expectTypeOf(ctx).toEqualTypeOf<undefined>();
+				return { success: true, id: input.id };
+			},
+		});
+
+		expectTypeOf(fn).parameter(0).toEqualTypeOf<{
+			input: { id: string };
+			ctx?: undefined;
+		}>();
+		expectTypeOf(fn).returns.resolves.toEqualTypeOf<{
+			success: boolean;
+			id: string;
+		}>();
+
+		expectTypeOf(fn.inputSchema).not.toBeUndefined();
+		expectTypeOf(fn.outputSchema).toBeUndefined();
+
+		expectTypeOf(fn.inputSchema).toEqualTypeOf<typeof inputSchema>();
+	});
+
+	test('should handle functions with no context and no input', () => {
+		const fn = createFn({
+			name: 'ping',
+			handler: async ({ input, ctx }) => {
+				expectTypeOf(input).toEqualTypeOf<void>();
+				// expectTypeOf(ctx).toEqualTypeOf<never>();
+				return 'pong';
+			},
+		});
+
+		// Allows calling with no arguments at all
+		expectTypeOf(fn)
+			.parameter(0)
+			.toEqualTypeOf<{ input?: void; ctx?: undefined }>();
+		expectTypeOf(fn).returns.resolves.toEqualTypeOf<string>();
+	});
+});
diff --git a/packages/fn/tsconfig.json b/packages/fn/tsconfig.json
new file mode 100644
index 0000000..fa77e5b
--- /dev/null
+++ b/packages/fn/tsconfig.json
@@ -0,0 +1,8 @@
+{
+	"extends": "@davstack/tsconfig/node14.json",
+	"include": ["src/**/*.ts", "test/**/*.ts"],
+	"exclude": ["dist", "build", "node_modules"],
+	"compilerOptions": {
+		"lib": ["ES2022", "dom", "dom.iterable"]
+	}
+}
diff --git a/packages/fn/tsup.config.ts b/packages/fn/tsup.config.ts
new file mode 100644
index 0000000..675117a
--- /dev/null
+++ b/packages/fn/tsup.config.ts
@@ -0,0 +1,8 @@
+// tsup.config.ts
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+	dts: {
+		resolve: true,
+	},
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b8d2b49..9cd2e3f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -68,6 +68,43 @@ importers:
         specifier: ^5.0.0
         version: 5.3.3
 
+  packages/fn:
+    dependencies:
+      '@trpc/server':
+        specifier: ^11.4.3
+        version: 11.17.0(typescript@5.3.3)
+      superjson:
+        specifier: ^2.2.1
+        version: 2.2.6
+    devDependencies:
+      '@davstack/eslint-config':
+        specifier: workspace:*
+        version: link:../../tooling/eslint
+      '@davstack/tsconfig':
+        specifier: workspace:*
+        version: link:../../tooling/typescript
+      '@types/react':
+        specifier: ^18.2.61
+        version: 18.3.29
+      '@types/react-dom':
+        specifier: ^18.2.19
+        version: 18.3.7(@types/react@18.3.29)
+      eslint:
+        specifier: ^8.57.0
+        version: 8.57.0
+      react:
+        specifier: ^18.2.0
+        version: 18.3.1
+      tsup:
+        specifier: ^8.0.2
+        version: 8.5.1(tsx@4.22.3)(typescript@5.3.3)
+      typescript:
+        specifier: ^5.3.3
+        version: 5.3.3
+      zod:
+        specifier: '>=3.25.0'
+        version: 4.4.3
+
   packages/init:
     dependencies:
       '@inquirer/prompts':
@@ -391,7 +428,7 @@ packages:
       '@babel/core': 7.23.3
       '@babel/helper-compilation-targets': 7.22.15
       '@babel/helper-plugin-utils': 7.24.6
-      debug: 4.3.4
+      debug: 4.4.3
       lodash.debounce: 4.0.8
       resolve: 1.22.8
     transitivePeerDependencies:
@@ -2672,7 +2709,7 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       ajv: 6.12.6
-      debug: 4.3.4
+      debug: 4.4.3
       espree: 9.6.1
       globals: 13.24.0
       ignore: 5.3.1
@@ -2694,7 +2731,7 @@ packages:
     engines: {node: '>=10.10.0'}
     dependencies:
       '@humanwhocodes/object-schema': 2.0.2
-      debug: 4.3.4
+      debug: 4.4.3
       minimatch: 3.1.2
     transitivePeerDependencies:
       - supports-color
@@ -3877,6 +3914,15 @@ packages:
     resolution: {integrity: sha512-/Ew9etdRQKVMnm9fDaCG0JjyAOK/O7T0M97oum1aW4W+UR8ZhVVPBanIV7oWgHBiGlnVxV9M55PWQCHofDV07w==}
     dev: false
 
+  /@trpc/server@11.17.0(typescript@5.3.3):
+    resolution: {integrity: sha512-jbAOUe0PpUTCYqziyu+8vYXZdDXPudZgnEhWCQ2NjKnVEjfE93RqHTt1oycZJv/HNf51YlRXfEEwSIAbb161rw==}
+    hasBin: true
+    peerDependencies:
+      typescript: '>=5.7.2'
+    dependencies:
+      typescript: 5.3.3
+    dev: false
+
   /@tybys/wasm-util@0.10.2:
     resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
     requiresBuild: true
@@ -3960,6 +4006,14 @@ packages:
   /@types/prop-types@15.7.15:
     resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}
 
+  /@types/react-dom@18.3.7(@types/react@18.3.29):
+    resolution: {integrity: sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==}
+    peerDependencies:
+      '@types/react': ^18.0.0
+    dependencies:
+      '@types/react': 18.3.29
+    dev: true
+
   /@types/react@18.3.29:
     resolution: {integrity: sha512-ch0qJdr2JY0r04NXSprbK6TXOgnaJ1Tz23fm5W+z0/CBah6BSBc3n96h7K9GOtwh0HrilNWHIBzE1Ko4Dcw/Wg==}
     dependencies:
@@ -4171,7 +4225,7 @@ packages:
     dependencies:
       '@typescript-eslint/typescript-estree': 5.62.0(typescript@5.3.3)
       '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.3.3)
-      debug: 4.3.4
+      debug: 4.4.3
       eslint: 8.57.0
       tsutils: 3.21.0(typescript@5.3.3)
       typescript: 5.3.3
@@ -4245,7 +4299,7 @@ packages:
     dependencies:
       '@typescript-eslint/types': 5.62.0
       '@typescript-eslint/visitor-keys': 5.62.0
-      debug: 4.3.4
+      debug: 4.4.3
       globby: 11.1.0
       is-glob: 4.0.3
       semver: 7.5.4
@@ -4620,12 +4674,12 @@ packages:
     resolution: {integrity: sha512-6aN99yL695Hi9SuIk1oC88l9o0gmxL1nGWWQ/kNy81HigJ0FoaoTXpytCj6ItzgyCEwA9kF1wixsTuv5cjsgng==}
     dev: false
 
-  /acorn-jsx@5.3.2(acorn@8.11.3):
+  /acorn-jsx@5.3.2(acorn@8.16.0):
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
     dependencies:
-      acorn: 8.11.3
+      acorn: 8.16.0
     dev: true
 
   /acorn-walk@8.3.2:
@@ -5237,6 +5291,13 @@ packages:
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dev: false
 
+  /copy-anything@4.0.5:
+    resolution: {integrity: sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==}
+    engines: {node: '>=18'}
+    dependencies:
+      is-what: 5.5.0
+    dev: false
+
   /core-js-compat@3.37.1:
     resolution: {integrity: sha512-9TNiImhKvQqSUkOvk/mMRZzOANTiEVC7WaBNhHcKM7x+/5E1l5NvsysR19zuDQScE8k+kfQXWRN3AtS/eOSHpg==}
     dependencies:
@@ -6274,6 +6335,7 @@ packages:
   /eslint@8.57.0:
     resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options.
     hasBin: true
     dependencies:
       '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0)
@@ -6287,7 +6349,7 @@ packages:
       ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.3
-      debug: 4.3.4
+      debug: 4.4.3
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
       eslint-scope: 7.2.2
@@ -6322,8 +6384,8 @@ packages:
     resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
-      acorn: 8.11.3
-      acorn-jsx: 5.3.2(acorn@8.11.3)
+      acorn: 8.16.0
+      acorn-jsx: 5.3.2(acorn@8.16.0)
       eslint-visitor-keys: 3.4.3
     dev: true
 
@@ -7075,6 +7137,11 @@ packages:
       call-bind: 1.0.5
       get-intrinsic: 1.2.2
 
+  /is-what@5.5.0:
+    resolution: {integrity: sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==}
+    engines: {node: '>=18'}
+    dev: false
+
   /is-windows@1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
     engines: {node: '>=0.10.0'}
@@ -8192,7 +8259,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dependencies:
       loose-envify: 1.4.0
-    dev: false
 
   /read-pkg-up@7.0.1:
     resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==}
@@ -8898,6 +8964,13 @@ packages:
       ts-interface-checker: 0.1.13
     dev: true
 
+  /superjson@2.2.6:
+    resolution: {integrity: sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==}
+    engines: {node: '>=16'}
+    dependencies:
+      copy-anything: 4.0.5
+    dev: false
+
   /supports-color@5.5.0:
     resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
     engines: {node: '>=4'}
@@ -9293,7 +9366,6 @@ packages:
     resolution: {integrity: sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==}
     engines: {node: '>=14.17'}
     hasBin: true
-    dev: true
 
   /ufo@1.5.3:
     resolution: {integrity: sha512-Y7HYmWaFwPUmkoQCUIAYpKqkOf+SbVj/2fJJZ4RJMCfZp0rTGwRbzQD+HghfnhKOjL9E01okqz+ncJskGYfBNw==}
@@ -9862,3 +9934,7 @@ packages:
   /yoga-layout@3.2.1:
     resolution: {integrity: sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ==}
     dev: false
+
+  /zod@4.4.3:
+    resolution: {integrity: sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==}
+    dev: true
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index fb1d1e6..0d9dd4c 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -84,4 +84,18 @@ export default defineWorkspace([
 			exclude: ['**/node_modules/**'],
 		},
 	},
+	{
+		resolve: { alias: { vitest: vitestAlias } },
+		test: {
+			name: 'fn',
+			root: './packages/fn',
+			environment: 'node',
+			include: ['test/**/*.test.ts'],
+			exclude: ['**/node_modules/**'],
+			typecheck: {
+				enabled: true,
+				include: ['test/**/*.test.ts'],
+			},
+		},
+	},
 ]);

From 40b8db5cb04a7ed1f679d3587120cb3849f09eac Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:32:25 +0100
Subject: [PATCH 66/72] feat(fn)!: make core transport-agnostic

Remove pipe and .safeCall; drop @trpc/server + superjson deps. Use @davstack/try-catch for Result-style calls and the adapter packages for transport. BREAKING (major).
---
 .changeset/fn-v2-transport-agnostic.md        |   16 +
 packages/fn/notes/why-pipe-over-middleware.md |  170 -
 packages/fn/package.json                      |    4 -
 packages/fn/src/create-fn.ts                  |   47 +-
 packages/fn/src/index.ts                      |    2 -
 packages/fn/src/pipe.ts                       | 4247 -----------------
 .../fn/src/utils/init-procedure-factory.ts    |   96 -
 packages/fn/test/composition.test.ts          |   73 +-
 packages/fn/test/core.test.ts                 |   65 +-
 packages/fn/test/error.test.ts                |   22 +-
 .../fn/test/init-procedure-factory.test.ts    |   58 -
 11 files changed, 95 insertions(+), 4705 deletions(-)
 create mode 100644 .changeset/fn-v2-transport-agnostic.md
 delete mode 100644 packages/fn/notes/why-pipe-over-middleware.md
 delete mode 100644 packages/fn/src/pipe.ts
 delete mode 100644 packages/fn/src/utils/init-procedure-factory.ts
 delete mode 100644 packages/fn/test/init-procedure-factory.test.ts

diff --git a/.changeset/fn-v2-transport-agnostic.md b/.changeset/fn-v2-transport-agnostic.md
new file mode 100644
index 0000000..40002ff
--- /dev/null
+++ b/.changeset/fn-v2-transport-agnostic.md
@@ -0,0 +1,16 @@
+---
+"@davstack/fn": major
+---
+
+**Breaking — core is now transport-agnostic with zero runtime dependencies.**
+
+- **Removed `.safeCall`.** Wrap a direct call with `tryCatch` from the new
+  `@davstack/try-catch` package to get a `{ data, error }` result instead of a throw:
+  `const { data, error } = await tryCatch(() => myFn({ input, ctx }))`.
+- **Removed the `Result` type** (it now lives in `@davstack/try-catch`).
+- **Extracted the tRPC adapter (`initProcedureFactory`) to the new `@davstack/fn-trpc`
+  package.** Install `@davstack/fn-trpc` and import `initProcedureFactory` from there.
+- **Removed the `pipe` export** (dead code inherited from the old `store` package; the
+  middleware array is strictly more capable).
+- **Dropped `@trpc/server` and `superjson` from dependencies** (`superjson` was unused;
+  tRPC moved to `@davstack/fn-trpc`).
diff --git a/packages/fn/notes/why-pipe-over-middleware.md b/packages/fn/notes/why-pipe-over-middleware.md
deleted file mode 100644
index cb6b691..0000000
--- a/packages/fn/notes/why-pipe-over-middleware.md
+++ /dev/null
@@ -1,170 +0,0 @@
-New API Design:
-
-Change Names:
-
-- baseFn -> createFn
-- authedService -> createAuthedFn
-- publicService -> createPublicFn
-
-So theres a bunch of complexity around managing the builder method and the middlware but i realised that perhaps its overkill and redudant because my existing impelemtnation (see attached doc of fn inside other codebase) was casting the type anyway so it was pretty pointless.
-
-We want to keep thigns as LIGHT and SIMPLE as possible to minimize surface area, maintance overhead, bugs, cognitive load, etc.
-
-So I was thinking, we coudl jsut make a simple config object and createFn, and either pass middleware in an array + typecast, or use a pipe function around the handler.
-
-option A: pass middleware in an array + typecast
-
-```ts
-const loggingMiddleware = createMiddleware(({ ctx, next }) =>
-// later we want indentation here to be based on the depth of the fn call, we can use logger.child or something like that, or add depth+1 to the ctx
-	ctx.logger.info('-> fn called', {
-		fn: ctx.fn.name,
-		input: ctx.input,
-		ctx: ctx.ctx,
-	})
-
-  const result = await next(ctx);
-
-  ctx.logger.info('<- fn result', {
-    fn: ctx.fn.name,
-    result,
-  })
-
-  return result;
-);
-const authedMiddleware = createMiddleware(({ ctx, next }) => {
-	if (!ctx.user.id) {
-		throw new FnError({
-			code: 'UNAUTHORIZED',
-			message: 'Unauthorized',
-		});
-	}
-	return next(ctx);
-});
-
-const createAuthedFn = (def: FnDef<any, any, any>) => {
-	return createFn({
-		...def,
-		middleware: [...(def.middleware ?? []), loggingMiddleware, authedMiddleware],
-	});
-};
-```
-
-option B: use a pipe function around the handler
-
-```ts
-// lib/create-server-fn.ts
-
-export type User = {
-	id: string;
-	email: string;
-	role: 'USER' | 'ADMIN';
-};
-export type ServerFnCtx = {
-	logger: Logger;
-	db: PrismaClient;
-	user?: User;
-};
-export type ServerFnCtxAuthed = Required<ServerFnCtx>;
-
-function withBaseContext(fn: FnHandler<any, any, any>) {
-	return (opts: { ctx: unknown; input: unknown }) => {
-		const user = { id: '' };
-		return fn({
-			input: opts.input,
-			ctx: {
-				user,
-				db: enhance(prisma, { user }),
-				logger: createLogger({
-					level: 'info',
-					format: format.json(),
-				}),
-			},
-		});
-	};
-}
-
-function withLoggingMiddleware(fn: FnHandler<any, any, any>) {
-	return (opts: { ctx: unknown; input: unknown }) => {
-		const logger = opts.ctx.logger;
-		logger.info('-> fn called', {
-			fn: opts.ctx.fn.name,
-			input: opts.input,
-			ctx: opts.ctx,
-		});
-		const result = await fn(opts);
-		logger.info('<- fn result', {
-			fn: opts.ctx.fn.name,
-			result,
-		});
-		return result;
-	};
-}
-
-export const createPublicServerFn = (def: FnDef<PublicServerFnCtx>) => {
-	return createFn<PublicServerFnCtx>({
-		...def,
-		handler: pipe(
-			withBaseContext,
-			withLoggingMiddleware,
-			withErrorHandling,
-			def.handler
-		),
-	});
-};
-
-export const createAuthedServerFn = (def: FnDef<AuthedServerFnCtx>) => {
-	return createFn<AuthedServerFnCtx>({
-		...def,
-		handler: pipe(
-			withBaseContext,
-			withLoggingMiddleware,
-			withErrorHandling,
-			def.handler
-		),
-	});
-};
-
-export function createCtx() {
-	const user = getUserFromCookie();
-	return {
-		user,
-		db: enhance(prisma, { user }),
-		logger: createLogger({
-			level: 'info',
-			format: format.json(),
-		}),
-	};
-}
-```
-
-### 3\. The Core Architectural Decision: Middleware vs. `pipe`
-
-This is the most important part of your new design. Let's compare Option A and Option B in detail.
-
-#### Option A: Middleware Array (`middleware: [...]`)
-
-This approach treats middleware as a list of layers in the configuration.
-
-- **Pros:**
-  - **Declarative:** It's very clear from looking at the `createAuthedFn` config what middleware is being applied.
-  - **Familiar:** This pattern is very common in web frameworks like Express, making it intuitive for many developers.
-- **Cons:**
-  - **Type Hell:** This is the deal-breaker. As you chain middleware, the context type can change (e.g., an early middleware adds `user` to the context). Managing these evolving types across a generic array is extremely difficult in TypeScript. You often end up with `any` or needing complex HKTs (Higher-Kinded Types), which completely defeats your goal of simplicity. Your own example (`FnDef<any, any, any>`) shows you've already hit this wall.
-  - **Implementation Complexity:** The `createFn` implementation needs a "runner" that iterates through the array, calls each middleware, and correctly handles the `next` function.
-
-#### Option B: Handler Composition (`handler: pipe(...)`)
-
-This approach treats middleware as simple function composition, where you wrap the core handler in layers of other functions.
-
-- **Pros:**
-  - ✅ **Rock-Solid Type Safety:** This is the biggest advantage. Standard function composition is something TypeScript handles beautifully. If you have `pipe(withAuth, withLogging, myHandler)`, TypeScript will automatically ensure the output of `withLogging` matches the input of `withAuth`, and so on. There's no type-casting and no `any`.
-  - ✅ **Implementation Simplicity:** Your `createFn` function becomes incredibly "dumb" and simple. It doesn't even need to know what middleware is. It just receives a final, fully-formed `handler` function and executes it. The complexity is pushed into the `pipe` utility, which is a standard, easily testable function.
-  - **Flexibility:** Developers aren't locked into your `middleware` abstraction. They can use your `pipe` utility, a third-party one (like from `fp-ts`), or just manually nest the function calls if they prefer.
-
-**Verdict & Recommendation:**
-
-**Option B (`pipe`) is decisively better and the clear path forward.** It aligns perfectly with your goals of simplicity, maintainability, and type safety. It avoids the hidden complexity of managing middleware context types, which is the exact trap that makes other frameworks so complicated internally.
-
----
-
diff --git a/packages/fn/package.json b/packages/fn/package.json
index ed5c5eb..74da8ab 100644
--- a/packages/fn/package.json
+++ b/packages/fn/package.json
@@ -29,10 +29,6 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"dependencies": {
-		"@trpc/server": "^11.4.3",
-		"superjson": "^2.2.1"
-	},
 	"peerDependencies": {
 		"zod": "^3.25.0 || ^4.0.0"
 	}
diff --git a/packages/fn/src/create-fn.ts b/packages/fn/src/create-fn.ts
index 5f828d3..971a7af 100644
--- a/packages/fn/src/create-fn.ts
+++ b/packages/fn/src/create-fn.ts
@@ -58,13 +58,6 @@ export type FnDef<
 	middleware?: Middleware<any>[];
 };
 
-/**
- * The standard result wrapper for safe calls.
- */
-export type Result<T> =
-	| { data: T; error: null }
-	| { data: null; error: FnError | Error };
-
 export type OptionallyRequiredField<
 	K extends string,
 	Condition,
@@ -132,11 +125,7 @@ export type Fn<
 	// Maybe outputSchema
 	(TOutputSchema extends undefined
 		? { outputSchema?: undefined }
-		: { outputSchema: TOutputSchema }) & {
-		safeCall: (
-			args: FnArgs<InferInput<TInputSchema>, TContext>
-		) => Promise<Result<InferOutput<TOutputSchema, THandler>>>;
-	} & ((
+		: { outputSchema: TOutputSchema }) & ((
 		args: FnArgs<InferInput<TInputSchema>, TContext>
 	) => Promise<InferOutput<TOutputSchema, THandler>>);
 
@@ -308,20 +297,6 @@ const withThrowingErrorHandler = createMiddleware(
 	}
 );
 
-/**
- * Middleware that formats the final result into a { data, error } object.
- */
-const withSafeResultFormatter = createMiddleware(
-	async ({ ctx, input, def, next }) => {
-		try {
-			const data = await next(ctx, input); // pass input through
-			return { data, error: null };
-		} catch (error) {
-			return { data: null, error: error as FnError };
-		}
-	}
-);
-
 // #endregion
 
 // #region --- createFn ---
@@ -373,27 +348,9 @@ export function createFn<
 		});
 	};
 
-	// The pipeline for the non-throwing, safe call.
-	const safeCall = async (
-		args: FnArgs<TInput, TContext>
-	): Promise<Result<TOutput>> => {
-		const safeCallMiddleware: Middleware<any>[] = [
-			withSafeResultFormatter, // 1. (Outer) Formats the final result.
-			withThrowingErrorHandler, // 2. Catches and enhances any errors.
-			withInputValidation, // 3. Validates input schema.
-			...(def.middleware || []), // 4. Executes user-defined middleware.
-			withOutputValidation, // 5. (Inner) Validates output schema.
-		];
-
-		return executeMiddleware<Result<TOutput>>({
-			def: { ...def, middleware: safeCallMiddleware } as AnyFnDef,
-			args: getArgs(args),
-		});
-	};
-
 	const { name, ...defWithoutName } = def;
 
-	const result = Object.assign(directCall, defWithoutName, { safeCall });
+	const result = Object.assign(directCall, defWithoutName);
 
 	Object.defineProperty(result, 'name', {
 		value: def.name,
diff --git a/packages/fn/src/index.ts b/packages/fn/src/index.ts
index 42e1c64..95830a3 100644
--- a/packages/fn/src/index.ts
+++ b/packages/fn/src/index.ts
@@ -1,8 +1,6 @@
 export * from './create-fn';
 export * from './errors';
-export * from './pipe';
 export * from './utils/type-utils';
-export * from './utils/init-procedure-factory';
 // export const helloWorld = () => {
 // 	console.log('Hello, world!');
 // 	return 'Hello, world!';
diff --git a/packages/fn/src/pipe.ts b/packages/fn/src/pipe.ts
deleted file mode 100644
index b2051be..0000000
--- a/packages/fn/src/pipe.ts
+++ /dev/null
@@ -1,4247 +0,0 @@
-export function pipe<T0>(x0: T0): T0;
-export function pipe<T0, T1>(x0: T0, f1?: (x: T0) => T1): T1;
-export function pipe<T0, T1, T2>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2
-): T2;
-export function pipe<T0, T1, T2, T3>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3
-): T3;
-export function pipe<T0, T1, T2, T3, T4>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4
-): T4;
-export function pipe<T0, T1, T2, T3, T4, T5>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5
-): T5;
-export function pipe<T0, T1, T2, T3, T4, T5, T6>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6
-): T6;
-export function pipe<T0, T1, T2, T3, T4, T5, T6, T7>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7
-): T7;
-export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8
-): T8;
-export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9
-): T9;
-export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10
-): T10;
-export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11
-): T11;
-export function pipe<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12
-): T12;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13
-): T13;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14
-): T14;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15
-): T15;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16
-): T16;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17
-): T17;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18
-): T18;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19
-): T19;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20
-): T20;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21
-): T21;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22
-): T22;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23
-): T23;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24
-): T24;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25
-): T25;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26
-): T26;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27
-): T27;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28
-): T28;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29
-): T29;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30
-): T30;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31
-): T31;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32
-): T32;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33
-): T33;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34
-): T34;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35
-): T35;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36
-): T36;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37
-): T37;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38
-): T38;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39
-): T39;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40
-): T40;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41
-): T41;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42
-): T42;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43
-): T43;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44
-): T44;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45
-): T45;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46
-): T46;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47
-): T47;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48
-): T48;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49
-): T49;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50
-): T50;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51
-): T51;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52
-): T52;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53
-): T53;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54
-): T54;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55
-): T55;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56
-): T56;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57
-): T57;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
-	T58,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57,
-	f58?: (x: T57) => T58
-): T58;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
-	T58,
-	T59,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57,
-	f58?: (x: T57) => T58,
-	f59?: (x: T58) => T59
-): T59;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
-	T58,
-	T59,
-	T60,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57,
-	f58?: (x: T57) => T58,
-	f59?: (x: T58) => T59,
-	f60?: (x: T59) => T60
-): T60;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
-	T58,
-	T59,
-	T60,
-	T61,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57,
-	f58?: (x: T57) => T58,
-	f59?: (x: T58) => T59,
-	f60?: (x: T59) => T60,
-	f61?: (x: T60) => T61
-): T61;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
-	T58,
-	T59,
-	T60,
-	T61,
-	T62,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57,
-	f58?: (x: T57) => T58,
-	f59?: (x: T58) => T59,
-	f60?: (x: T59) => T60,
-	f61?: (x: T60) => T61,
-	f62?: (x: T61) => T62
-): T62;
-export function pipe<
-	T0,
-	T1,
-	T2,
-	T3,
-	T4,
-	T5,
-	T6,
-	T7,
-	T8,
-	T9,
-	T10,
-	T11,
-	T12,
-	T13,
-	T14,
-	T15,
-	T16,
-	T17,
-	T18,
-	T19,
-	T20,
-	T21,
-	T22,
-	T23,
-	T24,
-	T25,
-	T26,
-	T27,
-	T28,
-	T29,
-	T30,
-	T31,
-	T32,
-	T33,
-	T34,
-	T35,
-	T36,
-	T37,
-	T38,
-	T39,
-	T40,
-	T41,
-	T42,
-	T43,
-	T44,
-	T45,
-	T46,
-	T47,
-	T48,
-	T49,
-	T50,
-	T51,
-	T52,
-	T53,
-	T54,
-	T55,
-	T56,
-	T57,
-	T58,
-	T59,
-	T60,
-	T61,
-	T62,
-	T63,
->(
-	x0: T0,
-	f1?: (x: T0) => T1,
-	f2?: (x: T1) => T2,
-	f3?: (x: T2) => T3,
-	f4?: (x: T3) => T4,
-	f5?: (x: T4) => T5,
-	f6?: (x: T5) => T6,
-	f7?: (x: T6) => T7,
-	f8?: (x: T7) => T8,
-	f9?: (x: T8) => T9,
-	f10?: (x: T9) => T10,
-	f11?: (x: T10) => T11,
-	f12?: (x: T11) => T12,
-	f13?: (x: T12) => T13,
-	f14?: (x: T13) => T14,
-	f15?: (x: T14) => T15,
-	f16?: (x: T15) => T16,
-	f17?: (x: T16) => T17,
-	f18?: (x: T17) => T18,
-	f19?: (x: T18) => T19,
-	f20?: (x: T19) => T20,
-	f21?: (x: T20) => T21,
-	f22?: (x: T21) => T22,
-	f23?: (x: T22) => T23,
-	f24?: (x: T23) => T24,
-	f25?: (x: T24) => T25,
-	f26?: (x: T25) => T26,
-	f27?: (x: T26) => T27,
-	f28?: (x: T27) => T28,
-	f29?: (x: T28) => T29,
-	f30?: (x: T29) => T30,
-	f31?: (x: T30) => T31,
-	f32?: (x: T31) => T32,
-	f33?: (x: T32) => T33,
-	f34?: (x: T33) => T34,
-	f35?: (x: T34) => T35,
-	f36?: (x: T35) => T36,
-	f37?: (x: T36) => T37,
-	f38?: (x: T37) => T38,
-	f39?: (x: T38) => T39,
-	f40?: (x: T39) => T40,
-	f41?: (x: T40) => T41,
-	f42?: (x: T41) => T42,
-	f43?: (x: T42) => T43,
-	f44?: (x: T43) => T44,
-	f45?: (x: T44) => T45,
-	f46?: (x: T45) => T46,
-	f47?: (x: T46) => T47,
-	f48?: (x: T47) => T48,
-	f49?: (x: T48) => T49,
-	f50?: (x: T49) => T50,
-	f51?: (x: T50) => T51,
-	f52?: (x: T51) => T52,
-	f53?: (x: T52) => T53,
-	f54?: (x: T53) => T54,
-	f55?: (x: T54) => T55,
-	f56?: (x: T55) => T56,
-	f57?: (x: T56) => T57,
-	f58?: (x: T57) => T58,
-	f59?: (x: T58) => T59,
-	f60?: (x: T59) => T60,
-	f61?: (x: T60) => T61,
-	f62?: (x: T61) => T62,
-	f63?: (x: T62) => T63
-): T63;
-
-export function pipe(x: any, ...fns: any[]) {
-	return fns.reduce((y: any, fn) => fn(y), x);
-}
diff --git a/packages/fn/src/utils/init-procedure-factory.ts b/packages/fn/src/utils/init-procedure-factory.ts
deleted file mode 100644
index 2ed2263..0000000
--- a/packages/fn/src/utils/init-procedure-factory.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import {
-	AnyProcedureBuilder,
-	MutationProcedure,
-	QueryProcedure,
-} from '@trpc/server/unstable-core-do-not-import';
-import { z } from 'zod';
-import { zInferInput, ZodTypeAny, Simplify } from '..';
-
-/**
- * Creates a factory function for tRPC procedures from Fn definitions
- *
- * @remarks
- * This function deliberately uses a more flexible type definition than the full Fn type
- * to avoid complex type compatibility issues between context types and middleware.
- *
- * Prior to introducing OptionallyRequiredField, using Fn<any,any,any,any,any> worked fine,
- * but after adding that type helper, we encountered type compatibility issues with our more
- * structured argument types.
- *
- * We're extracting only the essential properties needed for procedure creation rather
- * than using the full Fn type to prevent TypeScript errors with OptionallyRequiredField
- * and context type constraints when used with specific service contexts.
- *
- * In the future, we could consider using FnDef instead of Fn as the constraint, as it
- * contains the definition properties without the call signatures that include the
- * OptionallyRequiredField complexity.
- *
- * The type safety for the actual function implementations is handled elsewhere in the
- * system, so this pragmatic approach allows us to create procedures without excessive
- * type gymnastics.
- */
-export function initProcedureFactory<
-	TProcedureBuilder extends AnyProcedureBuilder,
->(procedureBuilder: TProcedureBuilder) {
-	return function createTrpcProcedureFromFn<
-		TFn extends {
-			inputSchema?: ZodTypeAny;
-			handler: (...args: any[]) => any;
-		},
-		TType extends 'mutation' | 'query',
-	>(fn: TFn & { (...args: any[]): Promise<any> }, type: TType) {
-		if (!fn.handler) {
-			throw new Error('Handler not defined');
-		}
-
-		type InputType = TFn['inputSchema'] extends ZodTypeAny
-			? zInferInput<TFn['inputSchema']>
-			: void;
-
-		type OutputType = Awaited<ReturnType<TFn['handler']>>;
-		// type OutputType =
-		//   ReturnType<TFn["handler"]> extends Promise<infer TOutput>
-		//     ? TOutput
-		//     : never;
-
-		type InputOutput = Simplify<{
-			input: InputType;
-			output: OutputType;
-			meta: Record<string, string>;
-		}>;
-
-		type ProcedureResult = TType extends 'mutation'
-			? MutationProcedure<InputOutput>
-			: QueryProcedure<InputOutput>;
-
-		const inputSchema = fn.inputSchema ?? z.void();
-		// TODO: Potentially integrate outputSchema validation in the future
-
-		// Define the handler function that will be used for both query and mutation
-		// This avoids duplicating the implementation and creating different stack frames
-		const handler = async ({ ctx, input }: { ctx: any; input: any }) => {
-			try {
-				// Directly call the function to avoid introducing unnecessary stack frames
-
-				return await fn({ input, ctx });
-			} catch (error) {
-				// Don't wrap the error here - let it propagate with its original stack
-				throw error;
-			}
-		};
-
-		if (type === 'mutation') {
-			return procedureBuilder
-				.input(inputSchema)
-				.mutation(handler) as unknown as ProcedureResult;
-		}
-
-		if (type === 'query') {
-			return procedureBuilder
-				.input(inputSchema)
-				.query(handler) as unknown as ProcedureResult;
-		}
-
-		throw new Error('Type not defined');
-	};
-}
diff --git a/packages/fn/test/composition.test.ts b/packages/fn/test/composition.test.ts
index ff425d0..928e5af 100644
--- a/packages/fn/test/composition.test.ts
+++ b/packages/fn/test/composition.test.ts
@@ -41,7 +41,6 @@ describe('Clean Composition API', () => {
 			});
 
 			expect(typeof getPublicData).toBe('function');
-			expect(typeof getPublicData.safeCall).toBe('function');
 			expect(getPublicData.name).toBe('getPublicData');
 
 			const result = await getPublicData({
@@ -252,8 +251,8 @@ describe('Clean Composition API', () => {
 		});
 	});
 
-	describe('SafeCall behavior', () => {
-		test('should return proper result structure from safeCall', async () => {
+	describe('Direct call result behavior', () => {
+		test('direct call returns the value on success', async () => {
 			const createServerFn = initCreateFn<ServerFnCtx>([]);
 
 			const testFn = createServerFn({
@@ -264,19 +263,16 @@ describe('Clean Composition API', () => {
 				}),
 			});
 
-			const result = await testFn.safeCall({
+			const data = await testFn({
 				input: { value: 'hello' },
 				ctx: { logger, db: mockDb },
 			});
 
-			expect(typeof result).toBe('object');
-			expect(result).toHaveProperty('data');
-			expect(result).toHaveProperty('error');
-			expect(result.error).toBeNull();
-			expect(result.data).toEqual({ processed: 'HELLO' });
+			expect(typeof data).toBe('object');
+			expect(data).toEqual({ processed: 'HELLO' });
 		});
 
-		test('should handle validation errors in safeCall', async () => {
+		test('direct call throws FnError on validation error', async () => {
 			const createServerFn = initCreateFn<ServerFnCtx>([]);
 
 			const testFn = createServerFn({
@@ -285,14 +281,17 @@ describe('Clean Composition API', () => {
 				handler: async ({ input }) => input.value,
 			});
 
-			const result = await testFn.safeCall({
-				input: { value: 123 } as any, // Invalid input
-				ctx: { logger, db: mockDb },
-			});
+			let error: any;
+			try {
+				await testFn({
+					input: { value: 123 } as any, // Invalid input
+					ctx: { logger, db: mockDb },
+				});
+			} catch (e) {
+				error = e;
+			}
 
-			expect(typeof result).toBe('object');
-			expect(result.data).toBeNull();
-			expect(result.error).toBeInstanceOf(FnError);
+			expect(error).toBeInstanceOf(FnError);
 		});
 	});
 
@@ -591,11 +590,11 @@ describe('Clean Composition API', () => {
 			}>();
 		});
 
-		test('should properly type safeCall results', async () => {
+		test('should properly type direct call results', async () => {
 			const createServerFn = initCreateFn<ServerFnCtx>([]);
 
 			const typedFn = createServerFn({
-				name: 'typedSafeCall',
+				name: 'typedDirectCall',
 				inputSchema: z.object({ value: z.number() }),
 				handler: async ({ input }) => ({
 					doubled: input.value * 2,
@@ -603,36 +602,20 @@ describe('Clean Composition API', () => {
 				}),
 			});
 
-			const result = await typedFn.safeCall({
+			// The direct call resolves to the inferred output type (it throws on failure).
+			expectTypeOf<
+				Awaited<ReturnType<typeof typedFn>>
+			>().toEqualTypeOf<{ doubled: number; original: number }>();
+
+			const data = await typedFn({
 				input: { value: 42 },
 				ctx: { logger: createMockLogger(), db: mockDb },
 			});
 
-			type SuccessResult = {
-				data: { doubled: number; original: number };
-				error: null;
-			};
-			type ErrorResult = {
-				data: null;
-				error: FnError | Error;
-			};
-
-			expectTypeOf(result).toEqualTypeOf<SuccessResult | ErrorResult>();
-
-			if (result.error === null) {
-				expectTypeOf(result).toEqualTypeOf<SuccessResult>();
-			} else {
-				expectTypeOf(result).toEqualTypeOf<ErrorResult>();
-			}
-
-			if (!result.error) {
-				expectTypeOf(result.data).toEqualTypeOf<{
-					doubled: number;
-					original: number;
-				}>();
-			} else {
-				expectTypeOf(result.error).toEqualTypeOf<FnError | Error>();
-			}
+			expectTypeOf(data).toEqualTypeOf<{
+				doubled: number;
+				original: number;
+			}>();
 		});
 	});
 });
diff --git a/packages/fn/test/core.test.ts b/packages/fn/test/core.test.ts
index 3a845e4..a323499 100644
--- a/packages/fn/test/core.test.ts
+++ b/packages/fn/test/core.test.ts
@@ -62,39 +62,44 @@ describe('Core `createFn` API', () => {
 		});
 	});
 
-	// MARK: Safe Call -> myFn.safeCall({})
-	describe('.safeCall()', () => {
-		test('should return { data, error: null } on success', async () => {
-			const { data, error } = await testFn.safeCall({
+	// MARK: Direct Call thrown-error coverage
+	describe('direct call thrown errors', () => {
+		test('should return data on success', async () => {
+			const data = await testFn({
 				input: { title: 'Test' },
 			});
-			expect(error).toBeNull();
 			expect(data).toEqual({ id: 'chat_123', title: 'Test' });
 		});
 
-		test('should RETURN an INVALID_INPUT error for invalid input', async () => {
-			const { data, error } = await testFn.safeCall({
-				input: { title: 123 } as any,
-			});
-			expect(data).toBeNull();
+		test('should THROW an INVALID_INPUT error for invalid input', async () => {
+			let error: any;
+			try {
+				await testFn({ input: { title: 123 } as any });
+			} catch (e) {
+				error = e;
+			}
 			expect(error).toBeInstanceOf(FnError);
 			expect((error as FnError).code).toBe('INVALID_INPUT');
 		});
 
-		test('should RETURN an INVALID_OUTPUT error for invalid output', async () => {
-			const { data, error } = await testFn.safeCall({
-				input: { title: 'invalid-output' },
-			});
-			expect(data).toBeNull();
+		test('should THROW an INVALID_OUTPUT error for invalid output', async () => {
+			let error: any;
+			try {
+				await testFn({ input: { title: 'invalid-output' } });
+			} catch (e) {
+				error = e;
+			}
 			expect(error).toBeInstanceOf(FnError);
 			expect((error as FnError).code).toBe('INVALID_OUTPUT');
 		});
 
-		test('should RETURN an INTERNAL_SERVER_ERROR for handler errors', async () => {
-			const { data, error } = await testFn.safeCall({
-				input: { title: 'throw' },
-			});
-			expect(data).toBeNull();
+		test('should THROW an INTERNAL_SERVER_ERROR for handler errors', async () => {
+			let error: any;
+			try {
+				await testFn({ input: { title: 'throw' } });
+			} catch (e) {
+				error = e;
+			}
 			expect(error).toBeInstanceOf(FnError);
 			expect((error as FnError).code).toBe('INTERNAL_SERVER_ERROR');
 		});
@@ -158,16 +163,15 @@ describe('FormData Handling', () => {
 		},
 	});
 
-	test('should handle FormData input in .safeCall()', async () => {
+	test('should handle FormData input with defaults in direct call', async () => {
 		const formData = new FormData();
 		formData.append('name', 'John Doe');
 		formData.append('age', '30');
 
-		const { data, error } = await processForm.safeCall({
+		const data = await processForm({
 			input: formData as any,
 		});
 
-		expect(error).toBeNull();
 		expect(data).toBe('Name: John Doe, Age: 30, Admin: false');
 	});
 
@@ -182,16 +186,18 @@ describe('FormData Handling', () => {
 		expect(result).toBe('Name: Jane Doe, Age: 25, Admin: true');
 	});
 
-	test('should return INVALID_INPUT for malformed FormData in .safeCall()', async () => {
+	test('should throw INVALID_INPUT for malformed FormData in direct call', async () => {
 		const formData = new FormData();
 		formData.append('name', 'Missing Age');
 		// 'age' is missing, which is required by the schema.
 
-		const { data, error } = await processForm.safeCall({
-			input: formData as any,
-		});
+		let error: any;
+		try {
+			await processForm({ input: formData as any });
+		} catch (e) {
+			error = e;
+		}
 
-		expect(data).toBeNull();
 		expect(error).toBeInstanceOf(FnError);
 		if (error instanceof FnError) {
 			expect(error.code).toBe('INVALID_INPUT');
@@ -219,11 +225,10 @@ describe('FormData Handling', () => {
 		formData.append('items[0].id', '101');
 		formData.append('items[1].id', '102');
 
-		const { data, error } = await processNestedForm.safeCall({
+		const data = await processNestedForm({
 			input: formData as any,
 		});
 
-		expect(error).toBeNull();
 		console.dir(data, { depth: null });
 		expect(data).not.toBe('User: Nested User, Items: 101,102');
 	});
diff --git a/packages/fn/test/error.test.ts b/packages/fn/test/error.test.ts
index 60419b2..ecb3fef 100644
--- a/packages/fn/test/error.test.ts
+++ b/packages/fn/test/error.test.ts
@@ -48,9 +48,13 @@ describe('Core Error Handling', () => {
 		await expect(promise).rejects.toHaveProperty('code', 'INVALID_INPUT');
 	});
 
-	test('safeCall should return FnError on input validation failure', async () => {
-		const { data, error } = await basicFn.safeCall({ input: { id: '' } });
-		expect(data).toBeNull();
+	test('direct call should throw FnError on input validation failure (alt)', async () => {
+		let error: any;
+		try {
+			await basicFn({ input: { id: '' } });
+		} catch (e) {
+			error = e;
+		}
 		expect(error).toBeInstanceOf(FnError);
 		expect(error).toHaveProperty('code', 'INVALID_INPUT');
 	});
@@ -61,11 +65,13 @@ describe('Core Error Handling', () => {
 		await expect(promise).rejects.toHaveProperty('code', 'INVALID_OUTPUT');
 	});
 
-	test('safeCall should return FnError on output validation failure', async () => {
-		const { data, error } = await basicFn.safeCall({
-			input: { id: 'invalid-output' },
-		});
-		expect(data).toBeNull();
+	test('direct call should throw FnError on output validation failure (alt)', async () => {
+		let error: any;
+		try {
+			await basicFn({ input: { id: 'invalid-output' } });
+		} catch (e) {
+			error = e;
+		}
 		expect(error).toBeInstanceOf(FnError);
 		expect(error).toHaveProperty('code', 'INVALID_OUTPUT');
 	});
diff --git a/packages/fn/test/init-procedure-factory.test.ts b/packages/fn/test/init-procedure-factory.test.ts
deleted file mode 100644
index 189823e..0000000
--- a/packages/fn/test/init-procedure-factory.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-// import { describe, test, expect } from 'vitest';
-// describe('initProcedureFactory', () => {
-// 	expect(true).toBe(true);
-// });
-import { describe, expect, test } from 'vitest';
-import { initProcedureFactory } from '../src/utils/init-procedure-factory';
-
-import { initTRPC } from '@trpc/server';
-import { MutationProcedure } from '@trpc/server/unstable-core-do-not-import';
-import { expectTypeOf } from 'vitest';
-import { z } from 'zod';
-import { createFn } from '../src';
-
-describe('initProcedureFactory', () => {
-	test('should create a hello world test', () => {
-		// Simple hello world test to verify the test setup works
-		const message = 'Hello World';
-		expect(message).toBe('Hello World');
-	});
-
-	test('should initialize a procedure factory', () => {
-		// Mock procedure builder
-
-		const t = initTRPC.create();
-		const baseProcedure = t.procedure;
-
-		// Create factory
-		const createFnProcedure = initProcedureFactory(baseProcedure);
-
-		// Verify factory is a function
-		expect(typeof createFnProcedure).toBe('function');
-
-		const createChat = createFn({
-			name: 'createChat',
-			description: 'Create a chat',
-			tags: ['chat'],
-			inputSchema: z.object({ title: z.string() }),
-			handler: async ({ input }) => {
-				return { id: 'chat_123', title: input.title };
-			},
-		});
-
-		const createChatProcedure = createFnProcedure(createChat, 'mutation');
-
-		expect(createChatProcedure).toBeDefined();
-		expectTypeOf<typeof createChatProcedure>().not.toBeUndefined();
-
-		// console.log('createChatProcedure', createChatProcedure);
-		// console.log('createChatProcedure.type:', typeof createChatProcedure);
-		expectTypeOf<typeof createChatProcedure>({} as any).toEqualTypeOf<
-			MutationProcedure<{
-				input: { title: string };
-				output: { id: string; title: string };
-				meta: Record<string, string>;
-			}>
-		>({} as any);
-	});
-});

From a5b6891664324bd32bcb1cbec26535485fb92ecd Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:32:34 +0100
Subject: [PATCH 67/72] feat(try-catch): add @davstack/try-catch package

Zero-dep tryCatch(promiseOrThunk) -> { data, error } Result wrapper.
---
 .changeset/try-catch-initial.md               |  5 ++
 packages/try-catch/README.md                  | 48 +++++++++++++++++++
 .../try-catch/__tests__/try-catch.test.ts     | 47 ++++++++++++++++++
 packages/try-catch/package.json               | 34 +++++++++++++
 packages/try-catch/src/index.ts               | 42 ++++++++++++++++
 packages/try-catch/tsconfig.json              | 17 +++++++
 packages/try-catch/tsup.config.ts             | 14 ++++++
 7 files changed, 207 insertions(+)
 create mode 100644 .changeset/try-catch-initial.md
 create mode 100644 packages/try-catch/README.md
 create mode 100644 packages/try-catch/__tests__/try-catch.test.ts
 create mode 100644 packages/try-catch/package.json
 create mode 100644 packages/try-catch/src/index.ts
 create mode 100644 packages/try-catch/tsconfig.json
 create mode 100644 packages/try-catch/tsup.config.ts

diff --git a/.changeset/try-catch-initial.md b/.changeset/try-catch-initial.md
new file mode 100644
index 0000000..1e721b0
--- /dev/null
+++ b/.changeset/try-catch-initial.md
@@ -0,0 +1,5 @@
+---
+"@davstack/try-catch": minor
+---
+
+Initial release: `tryCatch(promiseOrThunk)` returns a `{ data, error }` result instead of throwing. Zero dependencies.
diff --git a/packages/try-catch/README.md b/packages/try-catch/README.md
new file mode 100644
index 0000000..feaa4dd
--- /dev/null
+++ b/packages/try-catch/README.md
@@ -0,0 +1,48 @@
+# @davstack/try-catch
+
+A tiny, zero-dependency helper that wraps a promise or thunk into a `{ data, error }` result — so you can skip the `try/catch` boilerplate and handle failures inline.
+
+## Install
+
+```bash
+npm install @davstack/try-catch
+```
+
+## Usage
+
+```ts
+import { tryCatch } from "@davstack/try-catch";
+
+// Promise form
+const { data, error } = await tryCatch(fetchUser(id));
+
+// Preferred: thunk form — also catches synchronous throws
+const { data, error } = await tryCatch(() => fetchUser(id));
+```
+
+Prefer the thunk form (`() => ...`) when the work might throw *synchronously*. Passing `tryCatch(doThing())` runs `doThing()` outside the internal try/catch, so a synchronous throw would escape uncaught. `tryCatch(() => doThing())` captures both sync and async failures.
+
+## Narrowing
+
+Exactly one of `data` or `error` is non-null. Discriminate on `error`:
+
+```ts
+const { data, error } = await tryCatch(() => fetchUser(id));
+if (error) {
+	// error is non-null here
+	return handle(error);
+}
+// data is narrowed to non-null here
+use(data);
+```
+
+## Pairs with @davstack/fn
+
+A [`@davstack/fn`](https://www.npmjs.com/package/@davstack/fn) direct call throws a typed `FnError` on bad input/output. Wrap it with `tryCatch` to get a result instead of a throw:
+
+```ts
+const { data, error } = await tryCatch(() => createUser({ input }));
+if (error) {
+	// handle the FnError
+}
+```
diff --git a/packages/try-catch/__tests__/try-catch.test.ts b/packages/try-catch/__tests__/try-catch.test.ts
new file mode 100644
index 0000000..be16adb
--- /dev/null
+++ b/packages/try-catch/__tests__/try-catch.test.ts
@@ -0,0 +1,47 @@
+import { describe, expect, test } from "vitest";
+import { tryCatch } from "../src";
+
+describe("tryCatch", () => {
+	test("resolves a promise to { data, error: null }", async () => {
+		const { data, error } = await tryCatch(Promise.resolve(42));
+		expect(data).toBe(42);
+		expect(error).toBeNull();
+	});
+
+	test("catches a rejected promise into { data: null, error }", async () => {
+		const boom = new Error("boom");
+		const { data, error } = await tryCatch(Promise.reject(boom));
+		expect(data).toBeNull();
+		expect(error).toBe(boom);
+	});
+
+	test("supports a thunk returning a value", async () => {
+		const { data, error } = await tryCatch(() => "hello");
+		expect(data).toBe("hello");
+		expect(error).toBeNull();
+	});
+
+	test("supports a thunk returning a promise", async () => {
+		const { data, error } = await tryCatch(async () => "async-hello");
+		expect(data).toBe("async-hello");
+		expect(error).toBeNull();
+	});
+
+	test("catches a synchronous throw from a thunk", async () => {
+		const boom = new Error("sync boom");
+		const { data, error } = await tryCatch(() => {
+			throw boom;
+		});
+		expect(data).toBeNull();
+		expect(error).toBe(boom);
+	});
+
+	test("catches an async throw from a thunk", async () => {
+		const boom = new Error("async boom");
+		const { data, error } = await tryCatch(async () => {
+			throw boom;
+		});
+		expect(data).toBeNull();
+		expect(error).toBe(boom);
+	});
+});
diff --git a/packages/try-catch/package.json b/packages/try-catch/package.json
new file mode 100644
index 0000000..40ae631
--- /dev/null
+++ b/packages/try-catch/package.json
@@ -0,0 +1,34 @@
+{
+	"name": "@davstack/try-catch",
+	"version": "0.1.0",
+	"license": "MIT",
+	"type": "module",
+	"description": "Tiny zero-dependency helper that wraps a promise or thunk into a { data, error } result — no try/catch boilerplate.",
+	"scripts": {
+		"build": "tsup",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "tsup",
+		"test": "pnpm -w exec vitest run --project try-catch"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist/**",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"devDependencies": {
+		"@types/node": "^25.9.1",
+		"tsup": "^8.0.0",
+		"typescript": "^5.0.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}
diff --git a/packages/try-catch/src/index.ts b/packages/try-catch/src/index.ts
new file mode 100644
index 0000000..9ea6cd0
--- /dev/null
+++ b/packages/try-catch/src/index.ts
@@ -0,0 +1,42 @@
+/**
+ * The result of a `tryCatch` call: exactly one of `data` or `error` is non-null.
+ *
+ * Discriminate on `error`:
+ *
+ * ```ts
+ * const { data, error } = await tryCatch(fetchUser());
+ * if (error) return handle(error);
+ * use(data); // narrowed to non-null
+ * ```
+ */
+export type Result<T, E = Error> =
+	| { data: T; error: null }
+	| { data: null; error: E };
+
+export type Awaitable<T> = T | Promise<T>;
+
+/**
+ * Wraps a promise (or a thunk returning a value/promise) and resolves to a
+ * `{ data, error }` result instead of throwing.
+ *
+ * Prefer the thunk form when the work might throw *synchronously* (before a
+ * promise is created) — passing `tryCatch(doThing())` evaluates `doThing()`
+ * outside the try/catch, so a synchronous throw would escape. `tryCatch(() =>
+ * doThing())` catches both sync and async failures.
+ *
+ * @example
+ * const { data, error } = await tryCatch(() => createUser({ input }));
+ * if (error) { ... }
+ */
+export async function tryCatch<T, E = Error>(
+	input: Promise<T> | (() => Awaitable<T>)
+): Promise<Result<T, E>> {
+	try {
+		const data = await (typeof input === "function"
+			? (input as () => Awaitable<T>)()
+			: input);
+		return { data, error: null };
+	} catch (error) {
+		return { data: null, error: error as E };
+	}
+}
diff --git a/packages/try-catch/tsconfig.json b/packages/try-catch/tsconfig.json
new file mode 100644
index 0000000..79c5052
--- /dev/null
+++ b/packages/try-catch/tsconfig.json
@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"lib": ["ES2022"],
+		"types": ["node"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"declaration": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": false,
+		"resolveJsonModule": true
+	},
+	"include": ["src/**/*"]
+}
diff --git a/packages/try-catch/tsup.config.ts b/packages/try-catch/tsup.config.ts
new file mode 100644
index 0000000..55b41e1
--- /dev/null
+++ b/packages/try-catch/tsup.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+	entry: {
+		index: "src/index.ts",
+	},
+	format: ["esm"],
+	target: "node18",
+	outDir: "dist",
+	dts: true,
+	clean: true,
+	splitting: false,
+	sourcemap: true,
+})

From 7f76113972c21d01e13b2a22a50169b56aa2fb0d Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:32:34 +0100
Subject: [PATCH 68/72] feat(fn-trpc): add tRPC adapter for @davstack/fn

initProcedureFactory turns a fn into a tRPC query/mutation procedure.
---
 .changeset/fn-trpc-initial.md                 |  5 +
 packages/fn-trpc/README.md                    | 44 +++++++++
 .../__tests__/init-procedure-factory.test.ts  | 54 +++++++++++
 packages/fn-trpc/package.json                 | 43 +++++++++
 packages/fn-trpc/src/index.ts                 | 96 +++++++++++++++++++
 packages/fn-trpc/tsconfig.json                | 21 ++++
 packages/fn-trpc/tsup.config.ts               | 15 +++
 7 files changed, 278 insertions(+)
 create mode 100644 .changeset/fn-trpc-initial.md
 create mode 100644 packages/fn-trpc/README.md
 create mode 100644 packages/fn-trpc/__tests__/init-procedure-factory.test.ts
 create mode 100644 packages/fn-trpc/package.json
 create mode 100644 packages/fn-trpc/src/index.ts
 create mode 100644 packages/fn-trpc/tsconfig.json
 create mode 100644 packages/fn-trpc/tsup.config.ts

diff --git a/.changeset/fn-trpc-initial.md b/.changeset/fn-trpc-initial.md
new file mode 100644
index 0000000..e7e8012
--- /dev/null
+++ b/.changeset/fn-trpc-initial.md
@@ -0,0 +1,5 @@
+---
+"@davstack/fn-trpc": minor
+---
+
+Initial release: tRPC adapter for `@davstack/fn` (`initProcedureFactory`), extracted from the core package.
diff --git a/packages/fn-trpc/README.md b/packages/fn-trpc/README.md
new file mode 100644
index 0000000..d6946aa
--- /dev/null
+++ b/packages/fn-trpc/README.md
@@ -0,0 +1,44 @@
+# @davstack/fn-trpc
+
+tRPC adapter for [`@davstack/fn`](https://www.npmjs.com/package/@davstack/fn). Turn a directly-callable `fn` into a tRPC procedure.
+
+`@davstack/fn` is a transport-agnostic server-function convention. This package provides `initProcedureFactory`, which bridges an `fn` into a tRPC `query` or `mutation` procedure while preserving the input/output types.
+
+## Install
+
+```bash
+npm install @davstack/fn-trpc @davstack/fn @trpc/server zod
+```
+
+## Usage
+
+```ts
+import { initTRPC } from '@trpc/server';
+import { createFn } from '@davstack/fn';
+import { initProcedureFactory } from '@davstack/fn-trpc';
+import { z } from 'zod';
+
+const t = initTRPC.create();
+
+// Build a factory bound to your base procedure
+const fnProcedure = initProcedureFactory(t.procedure);
+
+// Define a transport-agnostic fn
+const createChat = createFn({
+	name: 'createChat',
+	inputSchema: z.object({ title: z.string() }),
+	handler: async ({ input }) => {
+		return { id: 'chat_123', title: input.title };
+	},
+});
+
+// Turn it into a tRPC procedure
+const createChatProcedure = fnProcedure(createChat, 'mutation');
+
+// Use it in a router
+const appRouter = t.router({
+	createChat: createChatProcedure,
+});
+```
+
+Pass `'query'` instead of `'mutation'` to produce a query procedure.
diff --git a/packages/fn-trpc/__tests__/init-procedure-factory.test.ts b/packages/fn-trpc/__tests__/init-procedure-factory.test.ts
new file mode 100644
index 0000000..09d02b5
--- /dev/null
+++ b/packages/fn-trpc/__tests__/init-procedure-factory.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vitest';
+import { initProcedureFactory } from '../src';
+
+import { initTRPC } from '@trpc/server';
+import { MutationProcedure } from '@trpc/server/unstable-core-do-not-import';
+import { expectTypeOf } from 'vitest';
+import { z } from 'zod';
+import { createFn } from '@davstack/fn';
+
+describe('initProcedureFactory', () => {
+	test('should create a hello world test', () => {
+		// Simple hello world test to verify the test setup works
+		const message = 'Hello World';
+		expect(message).toBe('Hello World');
+	});
+
+	test('should initialize a procedure factory', () => {
+		// Mock procedure builder
+
+		const t = initTRPC.create();
+		const baseProcedure = t.procedure;
+
+		// Create factory
+		const createFnProcedure = initProcedureFactory(baseProcedure);
+
+		// Verify factory is a function
+		expect(typeof createFnProcedure).toBe('function');
+
+		const createChat = createFn({
+			name: 'createChat',
+			description: 'Create a chat',
+			tags: ['chat'],
+			inputSchema: z.object({ title: z.string() }),
+			handler: async ({ input }) => {
+				return { id: 'chat_123', title: input.title };
+			},
+		});
+
+		const createChatProcedure = createFnProcedure(createChat, 'mutation');
+
+		expect(createChatProcedure).toBeDefined();
+		expectTypeOf<typeof createChatProcedure>().not.toBeUndefined();
+
+		// console.log('createChatProcedure', createChatProcedure);
+		// console.log('createChatProcedure.type:', typeof createChatProcedure);
+		expectTypeOf<typeof createChatProcedure>({} as any).toEqualTypeOf<
+			MutationProcedure<{
+				input: { title: string };
+				output: { id: string; title: string };
+				meta: Record<string, string>;
+			}>
+		>({} as any);
+	});
+});
diff --git a/packages/fn-trpc/package.json b/packages/fn-trpc/package.json
new file mode 100644
index 0000000..acb0b47
--- /dev/null
+++ b/packages/fn-trpc/package.json
@@ -0,0 +1,43 @@
+{
+	"name": "@davstack/fn-trpc",
+	"version": "0.1.0",
+	"license": "MIT",
+	"type": "module",
+	"description": "tRPC adapter for @davstack/fn — turn directly-callable fns into tRPC procedures.",
+	"scripts": {
+		"build": "tsup",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "tsup",
+		"test": "pnpm -w exec vitest run --project fn-trpc"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist/**",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"dependencies": {
+		"@trpc/server": "^11.4.3"
+	},
+	"peerDependencies": {
+		"@davstack/fn": ">=2.0.0",
+		"zod": "^3.25.0 || ^4.0.0"
+	},
+	"devDependencies": {
+		"@davstack/fn": "workspace:*",
+		"@types/node": "^25.9.1",
+		"tsup": "^8.0.0",
+		"typescript": "^5.0.0",
+		"zod": ">=3.25.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}
diff --git a/packages/fn-trpc/src/index.ts b/packages/fn-trpc/src/index.ts
new file mode 100644
index 0000000..fd3561c
--- /dev/null
+++ b/packages/fn-trpc/src/index.ts
@@ -0,0 +1,96 @@
+import {
+	AnyProcedureBuilder,
+	MutationProcedure,
+	QueryProcedure,
+} from '@trpc/server/unstable-core-do-not-import';
+import { z } from 'zod';
+import { zInferInput, ZodTypeAny, Simplify } from '@davstack/fn';
+
+/**
+ * Creates a factory function for tRPC procedures from Fn definitions
+ *
+ * @remarks
+ * This function deliberately uses a more flexible type definition than the full Fn type
+ * to avoid complex type compatibility issues between context types and middleware.
+ *
+ * Prior to introducing OptionallyRequiredField, using Fn<any,any,any,any,any> worked fine,
+ * but after adding that type helper, we encountered type compatibility issues with our more
+ * structured argument types.
+ *
+ * We're extracting only the essential properties needed for procedure creation rather
+ * than using the full Fn type to prevent TypeScript errors with OptionallyRequiredField
+ * and context type constraints when used with specific service contexts.
+ *
+ * In the future, we could consider using FnDef instead of Fn as the constraint, as it
+ * contains the definition properties without the call signatures that include the
+ * OptionallyRequiredField complexity.
+ *
+ * The type safety for the actual function implementations is handled elsewhere in the
+ * system, so this pragmatic approach allows us to create procedures without excessive
+ * type gymnastics.
+ */
+export function initProcedureFactory<
+	TProcedureBuilder extends AnyProcedureBuilder,
+>(procedureBuilder: TProcedureBuilder) {
+	return function createTrpcProcedureFromFn<
+		TFn extends {
+			inputSchema?: ZodTypeAny;
+			handler: (...args: any[]) => any;
+		},
+		TType extends 'mutation' | 'query',
+	>(fn: TFn & { (...args: any[]): Promise<any> }, type: TType) {
+		if (!fn.handler) {
+			throw new Error('Handler not defined');
+		}
+
+		type InputType = TFn['inputSchema'] extends ZodTypeAny
+			? zInferInput<TFn['inputSchema']>
+			: void;
+
+		type OutputType = Awaited<ReturnType<TFn['handler']>>;
+		// type OutputType =
+		//   ReturnType<TFn["handler"]> extends Promise<infer TOutput>
+		//     ? TOutput
+		//     : never;
+
+		type InputOutput = Simplify<{
+			input: InputType;
+			output: OutputType;
+			meta: Record<string, string>;
+		}>;
+
+		type ProcedureResult = TType extends 'mutation'
+			? MutationProcedure<InputOutput>
+			: QueryProcedure<InputOutput>;
+
+		const inputSchema = fn.inputSchema ?? z.void();
+		// TODO: Potentially integrate outputSchema validation in the future
+
+		// Define the handler function that will be used for both query and mutation
+		// This avoids duplicating the implementation and creating different stack frames
+		const handler = async ({ ctx, input }: { ctx: any; input: any }) => {
+			try {
+				// Directly call the function to avoid introducing unnecessary stack frames
+
+				return await fn({ input, ctx });
+			} catch (error) {
+				// Don't wrap the error here - let it propagate with its original stack
+				throw error;
+			}
+		};
+
+		if (type === 'mutation') {
+			return procedureBuilder
+				.input(inputSchema)
+				.mutation(handler) as unknown as ProcedureResult;
+		}
+
+		if (type === 'query') {
+			return procedureBuilder
+				.input(inputSchema)
+				.query(handler) as unknown as ProcedureResult;
+		}
+
+		throw new Error('Type not defined');
+	};
+}
diff --git a/packages/fn-trpc/tsconfig.json b/packages/fn-trpc/tsconfig.json
new file mode 100644
index 0000000..83851f6
--- /dev/null
+++ b/packages/fn-trpc/tsconfig.json
@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"lib": ["ES2022"],
+		"types": ["node"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"declaration": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": false,
+		"resolveJsonModule": true,
+		"baseUrl": ".",
+		"paths": {
+			"@davstack/fn": ["../fn/src/index.ts"]
+		}
+	},
+	"include": ["src/**/*", "__tests__/**/*"]
+}
diff --git a/packages/fn-trpc/tsup.config.ts b/packages/fn-trpc/tsup.config.ts
new file mode 100644
index 0000000..b90b0aa
--- /dev/null
+++ b/packages/fn-trpc/tsup.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+	entry: {
+		index: "src/index.ts",
+	},
+	format: ["esm"],
+	target: "node18",
+	outDir: "dist",
+	dts: true,
+	clean: true,
+	splitting: false,
+	sourcemap: true,
+	external: ["@davstack/fn"],
+})

From ba99cf31ba5eda138eed60ccae95136e997e5b31 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:32:34 +0100
Subject: [PATCH 69/72] feat(fn-orpc): add oRPC adapter for @davstack/fn

initProcedureFactory turns a fn into an oRPC procedure (maps context -> ctx).
---
 .changeset/fn-orpc-initial.md              |   5 +
 packages/fn-orpc/README.md                 |  55 ++++++++
 packages/fn-orpc/__tests__/fn-orpc.test.ts | 151 +++++++++++++++++++++
 packages/fn-orpc/package.json              |  43 ++++++
 packages/fn-orpc/src/index.ts              |  99 ++++++++++++++
 packages/fn-orpc/tsconfig.json             |  21 +++
 packages/fn-orpc/tsup.config.ts            |  15 ++
 7 files changed, 389 insertions(+)
 create mode 100644 .changeset/fn-orpc-initial.md
 create mode 100644 packages/fn-orpc/README.md
 create mode 100644 packages/fn-orpc/__tests__/fn-orpc.test.ts
 create mode 100644 packages/fn-orpc/package.json
 create mode 100644 packages/fn-orpc/src/index.ts
 create mode 100644 packages/fn-orpc/tsconfig.json
 create mode 100644 packages/fn-orpc/tsup.config.ts

diff --git a/.changeset/fn-orpc-initial.md b/.changeset/fn-orpc-initial.md
new file mode 100644
index 0000000..23221a9
--- /dev/null
+++ b/.changeset/fn-orpc-initial.md
@@ -0,0 +1,5 @@
+---
+"@davstack/fn-orpc": minor
+---
+
+Initial release: oRPC transport adapter for @davstack/fn — turn directly-callable fns into oRPC procedures via `initProcedureFactory`.
diff --git a/packages/fn-orpc/README.md b/packages/fn-orpc/README.md
new file mode 100644
index 0000000..1e9349b
--- /dev/null
+++ b/packages/fn-orpc/README.md
@@ -0,0 +1,55 @@
+# @davstack/fn-orpc
+
+oRPC adapter for [`@davstack/fn`](https://www.npmjs.com/package/@davstack/fn). Turn a directly-callable `fn` into an [oRPC](https://orpc.unnoq.com/) procedure.
+
+`@davstack/fn` is a transport-agnostic server-function convention. This package provides `initProcedureFactory`, which bridges an `fn` into an oRPC procedure while preserving the input/output types.
+
+## Install
+
+```bash
+npm install @davstack/fn-orpc @davstack/fn @orpc/server zod
+```
+
+## Usage
+
+```ts
+import { os } from '@orpc/server';
+import { createFn } from '@davstack/fn';
+import { initProcedureFactory } from '@davstack/fn-orpc';
+import { z } from 'zod';
+
+// Build a factory bound to your oRPC builder.
+// Use `os.$context<MyCtx>()` if your fns rely on a typed context.
+const fnProcedure = initProcedureFactory(os);
+
+// Define a transport-agnostic fn
+const createChat = createFn({
+	name: 'createChat',
+	inputSchema: z.object({ title: z.string() }),
+	handler: async ({ input }) => {
+		return { id: 'chat_123', title: input.title };
+	},
+});
+
+// Turn it into an oRPC procedure
+const createChatProcedure = fnProcedure(createChat);
+
+// A router is just a plain object of procedures
+const router = {
+	createChat: createChatProcedure,
+};
+```
+
+The procedure's input and output types are preserved from the `fn`. oRPC has no
+query/mutation distinction at the builder level, so the factory takes only the
+`fn`. If you need OpenAPI metadata you can chain `.route(...)` on the result:
+
+```ts
+const createChatProcedure = fnProcedure(createChat).route({
+	method: 'POST',
+	path: '/chats',
+});
+```
+
+When the `fn` declares an `outputSchema`, it is forwarded to oRPC's `.output(...)`
+so responses are validated as well.
diff --git a/packages/fn-orpc/__tests__/fn-orpc.test.ts b/packages/fn-orpc/__tests__/fn-orpc.test.ts
new file mode 100644
index 0000000..fb8481a
--- /dev/null
+++ b/packages/fn-orpc/__tests__/fn-orpc.test.ts
@@ -0,0 +1,151 @@
+import { describe, expect, it, expectTypeOf } from 'vitest';
+import { os, createRouterClient } from '@orpc/server';
+import { createFn, FnError } from '@davstack/fn';
+import { z } from 'zod';
+import { initProcedureFactory } from '../src';
+
+describe('initProcedureFactory', () => {
+	it('returns a function', () => {
+		const fnProcedure = initProcedureFactory(os);
+		expect(typeof fnProcedure).toBe('function');
+	});
+
+	it('builds a procedure from a fn with inputSchema + handler and calls it via a router client', async () => {
+		const fnProcedure = initProcedureFactory(os);
+
+		const createChat = createFn({
+			name: 'createChat',
+			description: 'Create a chat',
+			inputSchema: z.object({ title: z.string() }),
+			handler: async ({ input }) => {
+				return { id: 'chat_123', title: input.title };
+			},
+		});
+
+		const createChatProcedure = fnProcedure(createChat);
+		expect(createChatProcedure).toBeDefined();
+
+		const router = { createChat: createChatProcedure };
+		const client = createRouterClient(router, { context: {} });
+
+		const result = await client.createChat({ title: 'hello' });
+		expect(result).toEqual({ id: 'chat_123', title: 'hello' });
+	});
+
+	it('works for a fn with no inputSchema (callable with no args)', async () => {
+		const fnProcedure = initProcedureFactory(os);
+
+		const ping = createFn({
+			name: 'ping',
+			handler: async () => {
+				return { ok: true };
+			},
+		});
+
+		const pingProcedure = fnProcedure(ping);
+		const router = { ping: pingProcedure };
+		const client = createRouterClient(router, { context: {} });
+
+		const result = await client.ping();
+		expect(result).toEqual({ ok: true });
+	});
+
+	it('maps oRPC context to fn ctx', async () => {
+		const fnProcedure = initProcedureFactory(os.$context<{ userId: string }>());
+
+		const whoami = createFn({
+			name: 'whoami',
+			handler: async ({ ctx }: { ctx: { userId: string } }) => {
+				return { userId: ctx.userId };
+			},
+		});
+
+		const whoamiProcedure = fnProcedure(whoami);
+		const router = { whoami: whoamiProcedure };
+		const client = createRouterClient(router, {
+			context: { userId: 'u_1' },
+		});
+
+		const result = await client.whoami();
+		expect(result).toEqual({ userId: 'u_1' });
+	});
+
+	it('propagates a FnError thrown by the handler', async () => {
+		const fnProcedure = initProcedureFactory(os);
+
+		const findChat = createFn({
+			name: 'findChat',
+			inputSchema: z.object({ id: z.string() }),
+			handler: async () => {
+				throw new FnError({ code: 'NOT_FOUND' });
+			},
+		});
+
+		const findChatProcedure = fnProcedure(findChat);
+		const router = { findChat: findChatProcedure };
+		const client = createRouterClient(router, { context: {} });
+
+		await expect(client.findChat({ id: 'missing' })).rejects.toMatchObject({
+			code: 'NOT_FOUND',
+		});
+	});
+
+	it('rejects when called with invalid input', async () => {
+		const fnProcedure = initProcedureFactory(os);
+
+		const createChat = createFn({
+			name: 'createChat',
+			inputSchema: z.object({ title: z.string() }),
+			handler: async ({ input }) => ({ id: '1', title: input.title }),
+		});
+
+		const router = { createChat: fnProcedure(createChat) };
+		const client = createRouterClient(router, { context: {} });
+
+		// title should be a string; passing a number must reject validation.
+		await expect(
+			// @ts-expect-error - invalid input on purpose
+			client.createChat({ title: 123 }),
+		).rejects.toThrow();
+	});
+
+	it('validates output against the fn outputSchema when present', async () => {
+		const fnProcedure = initProcedureFactory(os);
+
+		const getCount = createFn({
+			name: 'getCount',
+			outputSchema: z.object({ count: z.number() }),
+			handler: async () => {
+				return { count: 7 };
+			},
+		});
+
+		const router = { getCount: fnProcedure(getCount) };
+		const client = createRouterClient(router, { context: {} });
+
+		const result = await client.getCount();
+		expect(result).toEqual({ count: 7 });
+	});
+
+	it('preserves input/output types through the router client (type-level)', async () => {
+		const fnProcedure = initProcedureFactory(os);
+
+		const createChat = createFn({
+			name: 'createChat',
+			inputSchema: z.object({ title: z.string() }),
+			handler: async ({ input }) => {
+				return { id: 'chat_123', title: input.title };
+			},
+		});
+
+		const router = { createChat: fnProcedure(createChat) };
+		const client = createRouterClient(router, { context: {} });
+
+		const result = await client.createChat({ title: 'x' });
+
+		expectTypeOf(result).toEqualTypeOf<{ id: string; title: string }>();
+		expectTypeOf(client.createChat)
+			.parameter(0)
+			.toEqualTypeOf<{ title: string }>();
+	});
+});
diff --git a/packages/fn-orpc/package.json b/packages/fn-orpc/package.json
new file mode 100644
index 0000000..97822e1
--- /dev/null
+++ b/packages/fn-orpc/package.json
@@ -0,0 +1,43 @@
+{
+	"name": "@davstack/fn-orpc",
+	"version": "0.1.0",
+	"license": "MIT",
+	"type": "module",
+	"description": "oRPC adapter for @davstack/fn — turn directly-callable fns into oRPC procedures.",
+	"scripts": {
+		"build": "tsup",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "tsup",
+		"test": "pnpm -w exec vitest run --project fn-orpc"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist/**",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"dependencies": {
+		"@orpc/server": "^1.14.6"
+	},
+	"peerDependencies": {
+		"@davstack/fn": ">=2.0.0",
+		"zod": "^3.25.0 || ^4.0.0"
+	},
+	"devDependencies": {
+		"@davstack/fn": "workspace:*",
+		"@types/node": "^25.9.1",
+		"tsup": "^8.0.0",
+		"typescript": "^5.0.0",
+		"zod": ">=3.25.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}
diff --git a/packages/fn-orpc/src/index.ts b/packages/fn-orpc/src/index.ts
new file mode 100644
index 0000000..e668f78
--- /dev/null
+++ b/packages/fn-orpc/src/index.ts
@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import type {
+	Builder,
+	ProcedureBuilder,
+	DecoratedProcedure,
+	Schema,
+} from '@orpc/server';
+import { zInferInput, zInfer, ZodTypeAny, Simplify } from '@davstack/fn';
+
+/**
+ * Creates a factory function for oRPC procedures from Fn definitions.
+ *
+ * @remarks
+ * This function deliberately uses a more flexible type definition than the full
+ * Fn type to avoid complex type compatibility issues between context types and
+ * middleware, mirroring the approach used by `@davstack/fn-trpc`.
+ *
+ * We extract only the essential properties needed for procedure creation
+ * (`inputSchema`, `outputSchema`, `handler`) rather than using the full Fn type
+ * to prevent TypeScript errors with context type constraints when used with
+ * specific service contexts.
+ *
+ * Unlike the tRPC adapter, oRPC has no query/mutation distinction at the builder
+ * level (that is a `.route({ method })` concern), so this factory takes only the
+ * fn — call `.route(...)` on the returned procedure if you need OpenAPI metadata.
+ *
+ * The type safety for the actual function implementations is handled elsewhere in
+ * the system, so this pragmatic approach allows us to create procedures without
+ * excessive type gymnastics.
+ *
+ * @param procedureBuilder - An oRPC `Builder` or `ProcedureBuilder`, e.g. `os`
+ *   or `os.$context<MyCtx>()`.
+ */
+export function initProcedureFactory<
+	TProcedureBuilder extends
+		| Builder<any, any, any, any, any, any>
+		| ProcedureBuilder<any, any, any, any, any, any>,
+>(procedureBuilder: TProcedureBuilder) {
+	return function createOrpcProcedureFromFn<
+		TFn extends {
+			inputSchema?: ZodTypeAny;
+			outputSchema?: ZodTypeAny;
+			handler: (...args: any[]) => any;
+		} & ((...args: any[]) => Promise<any>),
+	>(fn: TFn) {
+		if (!fn.handler) {
+			throw new Error('Handler not defined');
+		}
+
+		type InputType = TFn['inputSchema'] extends ZodTypeAny
+			? Simplify<zInferInput<TFn['inputSchema']>>
+			: void;
+
+		// Prefer the declared output schema for the output type when present,
+		// otherwise fall back to the fn's resolved return type. We read this from
+		// the fn's own call signature (`Awaited<ReturnType<TFn>>`) rather than
+		// `TFn['handler']`, because the handler property on a createFn result is
+		// typed generically (FnHandler<...>) and does not carry the concrete
+		// return type, whereas the callable signature does.
+		type OutputType = TFn['outputSchema'] extends ZodTypeAny
+			? zInfer<TFn['outputSchema']>
+			: Awaited<ReturnType<TFn>>;
+
+		// A clean oRPC procedure result type with input/output inference wired up.
+		// oRPC infers client input/output from the schema generics, where a
+		// schema is a StandardSchemaV1<TInput, TOutput>, so we surface the fn's
+		// resolved input/output types through those slots.
+		type ProcedureResult = DecoratedProcedure<
+			Record<never, never>,
+			Record<never, never>,
+			Schema<InputType, InputType>,
+			Schema<OutputType, OutputType>,
+			Record<never, never>,
+			Record<never, never>
+		>;
+
+		const inputSchema = (fn.inputSchema ?? z.void()) as ZodTypeAny;
+
+		// Map oRPC's `context` to fn's `ctx`. Call the fn directly so the
+		// original FnError (and its stack) propagate unchanged.
+		const handler = async ({
+			input,
+			context,
+		}: {
+			input: any;
+			context: any;
+		}) => {
+			return fn({ input, ctx: context });
+		};
+
+		const withInput = (procedureBuilder as any).input(inputSchema);
+
+		const built = fn.outputSchema
+			? withInput.output(fn.outputSchema).handler(handler)
+			: withInput.handler(handler);
+
+		return built as unknown as ProcedureResult;
+	};
+}
diff --git a/packages/fn-orpc/tsconfig.json b/packages/fn-orpc/tsconfig.json
new file mode 100644
index 0000000..83851f6
--- /dev/null
+++ b/packages/fn-orpc/tsconfig.json
@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"lib": ["ES2022"],
+		"types": ["node"],
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"declaration": true,
+		"isolatedModules": true,
+		"verbatimModuleSyntax": false,
+		"resolveJsonModule": true,
+		"baseUrl": ".",
+		"paths": {
+			"@davstack/fn": ["../fn/src/index.ts"]
+		}
+	},
+	"include": ["src/**/*", "__tests__/**/*"]
+}
diff --git a/packages/fn-orpc/tsup.config.ts b/packages/fn-orpc/tsup.config.ts
new file mode 100644
index 0000000..b90b0aa
--- /dev/null
+++ b/packages/fn-orpc/tsup.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+	entry: {
+		index: "src/index.ts",
+	},
+	format: ["esm"],
+	target: "node18",
+	outDir: "dist",
+	dts: true,
+	clean: true,
+	splitting: false,
+	sourcemap: true,
+	external: ["@davstack/fn"],
+})

From 7da7448da83934265d394a7aa9406c0438965a63 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:32:46 +0100
Subject: [PATCH 70/72] chore: wire new fn packages into vitest workspace +
 lockfile

---
 pnpm-lock.yaml      | 229 +++++++++++++++++++++++++++++++++++++++-----
 vitest.workspace.ts |  50 ++++++++++
 2 files changed, 256 insertions(+), 23 deletions(-)

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9cd2e3f..8d30edb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -69,13 +69,6 @@ importers:
         version: 5.3.3
 
   packages/fn:
-    dependencies:
-      '@trpc/server':
-        specifier: ^11.4.3
-        version: 11.17.0(typescript@5.3.3)
-      superjson:
-        specifier: ^2.2.1
-        version: 2.2.6
     devDependencies:
       '@davstack/eslint-config':
         specifier: workspace:*
@@ -105,6 +98,50 @@ importers:
         specifier: '>=3.25.0'
         version: 4.4.3
 
+  packages/fn-orpc:
+    dependencies:
+      '@orpc/server':
+        specifier: ^1.14.6
+        version: 1.14.6
+    devDependencies:
+      '@davstack/fn':
+        specifier: workspace:*
+        version: link:../fn
+      '@types/node':
+        specifier: ^25.9.1
+        version: 25.9.1
+      tsup:
+        specifier: ^8.0.0
+        version: 8.5.1(tsx@4.22.3)(typescript@5.3.3)
+      typescript:
+        specifier: ^5.0.0
+        version: 5.3.3
+      zod:
+        specifier: '>=3.25.0'
+        version: 4.4.3
+
+  packages/fn-trpc:
+    dependencies:
+      '@trpc/server':
+        specifier: ^11.4.3
+        version: 11.17.0(typescript@5.3.3)
+    devDependencies:
+      '@davstack/fn':
+        specifier: workspace:*
+        version: link:../fn
+      '@types/node':
+        specifier: ^25.9.1
+        version: 25.9.1
+      tsup:
+        specifier: ^8.0.0
+        version: 8.5.1(tsx@4.22.3)(typescript@5.3.3)
+      typescript:
+        specifier: ^5.0.0
+        version: 5.3.3
+      zod:
+        specifier: '>=3.25.0'
+        version: 4.4.3
+
   packages/init:
     dependencies:
       '@inquirer/prompts':
@@ -171,6 +208,18 @@ importers:
         specifier: ^5.0.0
         version: 5.3.3
 
+  packages/try-catch:
+    devDependencies:
+      '@types/node':
+        specifier: ^25.9.1
+        version: 25.9.1
+      tsup:
+        specifier: ^8.0.0
+        version: 8.5.1(tsx@4.22.3)(typescript@5.3.3)
+      typescript:
+        specifier: ^5.0.0
+        version: 5.3.3
+
   packages/tui:
     dependencies:
       '@davstack/open-agents':
@@ -3018,6 +3067,133 @@ packages:
       '@nodelib/fs.scandir': 2.1.5
       fastq: 1.17.1
 
+  /@orpc/client@1.14.6:
+    resolution: {integrity: sha512-Y03NcTtmEJdxcqkKBkdGxqe1IHVpD9IorshG4PaTnz9dQIW+RYI8anRo7o0IlbBlzBICN+Ubo1rnw6bpkhagCQ==}
+    dependencies:
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+      '@orpc/standard-server-fetch': 1.14.6
+      '@orpc/standard-server-peer': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/contract@1.14.6:
+    resolution: {integrity: sha512-o4i2ciYWtALidF969S8yj/VFk7ZUmHHKaYGRVitX5K2uMaSB8lJM6TMyBKzRC5Clo99VPjCb9mcl6jMLEAgmKw==}
+    dependencies:
+      '@orpc/client': 1.14.6
+      '@orpc/shared': 1.14.6
+      '@standard-schema/spec': 1.1.0
+      openapi-types: 12.1.3
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/interop@1.14.6:
+    resolution: {integrity: sha512-ZjNaHH9754uUkC98DHfm9HaGnniFnFRLdXXBWL2u+o1TVzEbiNX8dA5+oChxoSTUD3GiwpjLjAuTWXvrbhm4fA==}
+    dev: false
+
+  /@orpc/server@1.14.6:
+    resolution: {integrity: sha512-aHn8dW2clr/fRZzMLbRsZ1Pe4AYxg7YmM3tSZSAkPjn5/3UaHnpuwWeY7LYPok23CGYUmjidTmJQjm0zm+vgoA==}
+    peerDependencies:
+      crossws: '>=0.3.4'
+      ws: '>=8.18.1'
+    peerDependenciesMeta:
+      crossws:
+        optional: true
+      ws:
+        optional: true
+    dependencies:
+      '@orpc/client': 1.14.6
+      '@orpc/contract': 1.14.6
+      '@orpc/interop': 1.14.6
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+      '@orpc/standard-server-aws-lambda': 1.14.6
+      '@orpc/standard-server-fastify': 1.14.6
+      '@orpc/standard-server-fetch': 1.14.6
+      '@orpc/standard-server-node': 1.14.6
+      '@orpc/standard-server-peer': 1.14.6
+      cookie: 1.1.1
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+      - fastify
+    dev: false
+
+  /@orpc/shared@1.14.6:
+    resolution: {integrity: sha512-P2W+DdrUq18kUiF7nIw5wDOA0SR41mM/NsVKDVRsdyhdHk9V9KDuW1JRymyMl+7Wo5SDeSr1Rm/VjA5v08+PHw==}
+    peerDependencies:
+      '@opentelemetry/api': '>=1.9.0'
+    peerDependenciesMeta:
+      '@opentelemetry/api':
+        optional: true
+    dependencies:
+      radash: 12.1.1
+      type-fest: 5.7.0
+    dev: false
+
+  /@orpc/standard-server-aws-lambda@1.14.6:
+    resolution: {integrity: sha512-8FQX0uBQ2OKkIrF0u5qpd9EH2uqaM1n37NJSw9bvQqLnqoSfzk0xzVkP5s+c8N0Gec6M9mnrLvB7aqQSlpPukw==}
+    dependencies:
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+      '@orpc/standard-server-fetch': 1.14.6
+      '@orpc/standard-server-node': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/standard-server-fastify@1.14.6:
+    resolution: {integrity: sha512-cwS7jRfc+yM8bFyEFVzVcXfgYLfy96KpdPBPUlIQLpInwYvMxePpENM3rEAJ3MHOfMHx1PT5LidrlbR7Npb1Cg==}
+    peerDependencies:
+      fastify: '>=5.6.1'
+    peerDependenciesMeta:
+      fastify:
+        optional: true
+    dependencies:
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+      '@orpc/standard-server-node': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/standard-server-fetch@1.14.6:
+    resolution: {integrity: sha512-XnwEnHaKMMBoilK0QVwgMsUvDbCXyz6CDoLgMN51v+p3VSnwjIkrMdOwbc/sj43z6T4irQDu9Zm8T1pxxh1L8w==}
+    dependencies:
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/standard-server-node@1.14.6:
+    resolution: {integrity: sha512-CmW/EPu1dxoppYMRmsK+F3Z22wMx74RLUtjRokXyRKu4XEX/Ja6nwD+xauQcAMiAQYkp39aCMofAW7BvA46Qcg==}
+    dependencies:
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+      '@orpc/standard-server-fetch': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/standard-server-peer@1.14.6:
+    resolution: {integrity: sha512-jwVGc5yRA5hk1F/W4yw45P2H4fbu4Tfsk62XijJBXRvtlSNKvvPAuwAd6jFv/fxnq2SH/uskgi91Ja9wgfnYDQ==}
+    dependencies:
+      '@orpc/shared': 1.14.6
+      '@orpc/standard-server': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
+  /@orpc/standard-server@1.14.6:
+    resolution: {integrity: sha512-75Oh4rAZb8K7P46d6v7R2JhjqjLLEo7Qs4+ABdF+f0m0uKM1oaykJWy7leqTJ+WaYm+uDbsZl/3nyWie9aeJTg==}
+    dependencies:
+      '@orpc/shared': 1.14.6
+    transitivePeerDependencies:
+      - '@opentelemetry/api'
+    dev: false
+
   /@oxc-parser/binding-android-arm-eabi@0.127.0:
     resolution: {integrity: sha512-0LC7ye4hvqbIKxAzThzvswgHLFu2AURKzYLeSVvLdu2TBOYWQDmHnTqPLeA597BcUCxiLqLsS4CJ5uoI5WYWCQ==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -5291,11 +5467,9 @@ packages:
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dev: false
 
-  /copy-anything@4.0.5:
-    resolution: {integrity: sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==}
+  /cookie@1.1.1:
+    resolution: {integrity: sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==}
     engines: {node: '>=18'}
-    dependencies:
-      is-what: 5.5.0
     dev: false
 
   /core-js-compat@3.37.1:
@@ -7137,11 +7311,6 @@ packages:
       call-bind: 1.0.5
       get-intrinsic: 1.2.2
 
-  /is-what@5.5.0:
-    resolution: {integrity: sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==}
-    engines: {node: '>=18'}
-    dev: false
-
   /is-windows@1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
     engines: {node: '>=0.10.0'}
@@ -7858,6 +8027,10 @@ packages:
       is-wsl: 2.2.0
     dev: true
 
+  /openapi-types@12.1.3:
+    resolution: {integrity: sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw==}
+    dev: false
+
   /optionator@0.9.3:
     resolution: {integrity: sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==}
     engines: {node: '>= 0.8.0'}
@@ -8222,6 +8395,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /radash@12.1.1:
+    resolution: {integrity: sha512-h36JMxKRqrAxVD8201FrCpyeNuUY9Y5zZwujr20fFO77tpUtGa6EZzfKw/3WaiBX95fq7+MpsuMLNdSnORAwSA==}
+    engines: {node: '>=14.18.0'}
+    dev: false
+
   /react-dom@18.2.0(react@18.3.1):
     resolution: {integrity: sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==}
     peerDependencies:
@@ -8964,13 +9142,6 @@ packages:
       ts-interface-checker: 0.1.13
     dev: true
 
-  /superjson@2.2.6:
-    resolution: {integrity: sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==}
-    engines: {node: '>=16'}
-    dependencies:
-      copy-anything: 4.0.5
-    dev: false
-
   /supports-color@5.5.0:
     resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
     engines: {node: '>=4'}
@@ -8996,6 +9167,11 @@ packages:
       tslib: 2.6.2
     dev: true
 
+  /tagged-tag@1.0.0:
+    resolution: {integrity: sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==}
+    engines: {node: '>=20'}
+    dev: false
+
   /tapable@2.2.1:
     resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==}
     engines: {node: '>=6'}
@@ -9324,6 +9500,13 @@ packages:
     engines: {node: '>=16'}
     dev: false
 
+  /type-fest@5.7.0:
+    resolution: {integrity: sha512-1URUxUqfHFM1c+zfSPsa3gnkO7Aq21qyH75SIduNYz4SzY964rn1X2vCMQaHSHhktiw+0kPa2iyb6PUpXqB6Vg==}
+    engines: {node: '>=20'}
+    dependencies:
+      tagged-tag: 1.0.0
+    dev: false
+
   /typed-array-buffer@1.0.0:
     resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==}
     engines: {node: '>= 0.4'}
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index 0d9dd4c..a0e90ef 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -84,6 +84,16 @@ export default defineWorkspace([
 			exclude: ['**/node_modules/**'],
 		},
 	},
+	{
+		resolve: { alias: { vitest: vitestAlias } },
+		test: {
+			name: 'try-catch',
+			root: './packages/try-catch',
+			environment: 'node',
+			include: ['__tests__/**/*.test.ts'],
+			exclude: ['**/node_modules/**'],
+		},
+	},
 	{
 		resolve: { alias: { vitest: vitestAlias } },
 		test: {
@@ -98,4 +108,44 @@ export default defineWorkspace([
 			},
 		},
 	},
+	{
+		resolve: {
+			alias: {
+				vitest: vitestAlias,
+				// fn isn't built during tests, so resolve @davstack/fn to source.
+				'@davstack/fn': path.join(here, 'packages/fn/src/index.ts'),
+			},
+		},
+		test: {
+			name: 'fn-trpc',
+			root: './packages/fn-trpc',
+			environment: 'node',
+			include: ['__tests__/**/*.test.ts'],
+			exclude: ['**/node_modules/**'],
+			typecheck: {
+				enabled: true,
+				include: ['__tests__/**/*.test.ts'],
+			},
+		},
+	},
+	{
+		resolve: {
+			alias: {
+				vitest: vitestAlias,
+				// fn isn't built during tests, so resolve @davstack/fn to source.
+				'@davstack/fn': path.join(here, 'packages/fn/src/index.ts'),
+			},
+		},
+		test: {
+			name: 'fn-orpc',
+			root: './packages/fn-orpc',
+			environment: 'node',
+			include: ['__tests__/**/*.test.ts'],
+			exclude: ['**/node_modules/**'],
+			typecheck: {
+				enabled: true,
+				include: ['__tests__/**/*.test.ts'],
+			},
+		},
+	},
 ]);

From 99503d00b325e2c0aff86723621efa2ef9b210ac Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:32:46 +0100
Subject: [PATCH 71/72] docs(fn): document try-catch + tRPC/oRPC adapters

Rewrite README for v2 (createFn/initCreateFn/middleware/FnError/tryCatch + adapters); add fn-error and pipe-vs-middleware eval notes.
---
 packages/fn/CHANGELOG.md                     |   2 +-
 packages/fn/README.md                        | 300 +++++++++----------
 packages/fn/notes/eval-fnerror.md            |  65 ++++
 packages/fn/notes/eval-pipe-vs-middleware.md |  82 +++++
 4 files changed, 282 insertions(+), 167 deletions(-)
 create mode 100644 packages/fn/notes/eval-fnerror.md
 create mode 100644 packages/fn/notes/eval-pipe-vs-middleware.md

diff --git a/packages/fn/CHANGELOG.md b/packages/fn/CHANGELOG.md
index aecf7c7..6d74c8d 100644
--- a/packages/fn/CHANGELOG.md
+++ b/packages/fn/CHANGELOG.md
@@ -1,4 +1,4 @@
-# @davstack/service
+# @davstack/fn
 
 ## 0.1.6
 
diff --git a/packages/fn/README.md b/packages/fn/README.md
index fc9a8df..5d51df2 100644
--- a/packages/fn/README.md
+++ b/packages/fn/README.md
@@ -1,220 +1,188 @@
-# Davstack Service
+# @davstack/fn
 
-Davstack Service is simple and flexible library for building backend services with TypeScript.
+A tiny, transport-agnostic convention for server functions. Define your business logic
+once as a plain, **directly-callable** async function with input/output validation and
+middleware — then call it from anywhere (a route handler, a server action, a script, or
+another fn). Attach a transport (tRPC, oRPC, HTTP) at the edge with a thin adapter, never
+in the core.
 
-### Why Use Davstack Service?
-
-- 🏠 Simple and familiar syntax - middleware, input and outputs inspired by trpc procedures
-- 🧩 Flexible - Works well with next js server actions as well as trpc
-- ✅ Typescript first - inferred input/output types and middleware
-
-### Installation
+The core has **zero runtime dependencies** and never throws abstraction at you: a fn is
+just a function you call with `{ input, ctx }`.
 
 ```bash
-npm install zod @davstack/service
+npm install @davstack/fn zod
 ```
 
-Visit the [DavStack Service Docs](https://davstack.com/service/overview) for more information and examples, such as this [trpc usage example](https://davstack.com/service/trpc-usage-example).
+> `zod` is a peer dependency (v3 or v4). Schemas are optional.
 
-## Demo Usage
+## Quick start
 
-- The service definition replaces tRPC procedures, but the syntax is very similar.
-- Once the service is integrated into tRPC routers, the API is the same as any other tRPC router.
+```ts
+import { createFn, FnError } from '@davstack/fn';
+import { z } from 'zod';
 
-## Composing Services example
+export const createChat = createFn({
+	name: 'createChat',
+	inputSchema: z.object({ title: z.string() }),
+	handler: async ({ input, ctx }) => {
+		return ctx.db.chat.create({ data: { title: input.title } });
+	},
+});
 
-```ts
-// api/services/invoice.ts
-import { authedService, publicService } from '@/lib/service';
-
-// Service composed from range of other services:
-
-export const mailAiGeneratedInvoice = authedService
-	.input(z.object({ to: z.string(), projectId: z.string() }))
-	.query(async ({ ctx, input }) => {
-		await checkSufficientCredits(ctx, { amount: 10 });
-
-		const pdf = await generatePdf(ctx, { html: project.invoiceHtml });
-
-		await sendEmail(ctx, {
-			to: input.to,
-			subject: 'Invoice',
-			body: 'Please find attached your invoice',
-			attachments: [{ filename: 'invoice.pdf', content: pdf }],
-		});
-
-		await deductCredits(ctx, { amount: 10 });
-
-		return 'Invoice sent';
-	});
-
-export const generatePdf = authedService
-	.input(z.object({ html: z.string() }))
-	.query(async ({ ctx, input }) => {
-		// complex business logic here
-		return pdf;
-	});
-
-export const sendEmail = authedService
-	.input(z.object({ to: z.string(), subject: z.string(), body: z.string() }))
-	.query(async ({ ctx, input }) => {
-		// complex business logic here
-		return 'Email sent';
-	});
-
-export const checkSufficientCredits = authedService
-	.input(z.object({ amount: z.number() }))
-	.query(async ({ ctx, input }) => {
-		// complex business logic here
-		return 'Sufficient funds';
-	});
-
-// ... etc
+// Call it directly — same `{ input, ctx }` shape as the handler.
+const chat = await createChat({ input: { title: 'Hello' }, ctx: { db } });
 ```
 
-Integrate your services with tRPC with 0 boilerplate. Works just like any other tRPC router.
-
-```ts
-// api/router.ts
+A fn validates its input (applying zod defaults/transforms), runs its middleware, runs the
+handler, then validates its output if an `outputSchema` is set. On any failure it **throws an
+`FnError`** (see [Errors](#errors)).
 
-import * as invoiceServices from '@/api/services/invoice';
-import { createTRPCRouter } from '@/lib/trpc';
-import {
-	createTrpcProcedureFromService,
-	createTrpcRouterFromServices,
-} from '@davstack/service';
+## Definition shape
 
-export const appRouter = createTRPCRouter({
-	invoice: createTrpcRouterFromServices(invoiceServices),
+```ts
+createFn({
+	name: 'sendWelcomeText',       // required — used in error traces & adapters
+	description: '...',            // optional
+	tags: ['sms', 'credits'],     // optional
+	inputSchema: z.object({ ... }),   // optional
+	outputSchema: z.object({ ... }),  // optional — validated on the way out
+	middleware: [/* fn-specific middleware */], // optional
+	handler: async ({ input, ctx }) => { ... },
 });
 ```
 
-### Middleware Example
+`input` is typed from `inputSchema` (or `void` if omitted). The handler's return type (or
+`outputSchema`) becomes the call's resolved type.
 
-Define your services with reusable middleware in a separate file, and export them for reuse.
+## Shared context & base middleware — `initCreateFn`
+
+Declare your context type once and pre-attach base middleware with `initCreateFn`. Everything
+built from it inherits that context type and middleware.
 
 ```ts
-// lib/service.ts
-import { service } from '@davstack/service';
-import { db } from '@/lib/db';
-
-// Define the context types for your services
-export type PublicServiceCtx = {
-	user: { id: string; role: string } | undefined;
-	db: typeof db;
-};
-export type AuthedServiceCtx = Required<PublicServiceCtx>;
-
-// export your services
-export const publicService = service<PublicServiceCtx>();
-
-export const authedService = service<AuthedServiceCtx>().use(
-	async ({ ctx, next }) => {
-		// Only allows authenticate users to access this service
-		if (!ctx.user) {
-			throw new Error('Unauthorized');
-		}
-		return next(ctx);
-	}
-);
+import { initCreateFn, createMiddleware, FnError } from '@davstack/fn';
 
-export function createServiceCtx() {
-	const user = auth();
-	return { user, db };
-}
+type PublicCtx = { db: Db; user?: { id: string } };
+type AuthedCtx = Required<PublicCtx>;
+
+const authMiddleware = createMiddleware<AuthedCtx>(async ({ ctx, next }) => {
+	if (!ctx.user?.id) throw new FnError({ code: 'UNAUTHORIZED' });
+	return next(); // short-circuits if you don't call it
+});
+
+export const createPublicFn = initCreateFn<PublicCtx>();
+export const createAuthedFn = initCreateFn<AuthedCtx>([authMiddleware]);
 ```
 
-Import the public / authed service builders from the service
+Now `createAuthedFn(...)` produces fns whose `ctx` is typed `AuthedCtx`, with `authMiddleware`
+always running first.
 
-```ts
-// api/services/some-service.ts
-import { publicService, authedService } from '@/lib/service';
+## Middleware
 
-export const getSomePublicData = publicService.query(async ({ ctx }) => {
-	return 'Public data';
+Middleware is an onion (Express/tRPC-style `next` chain). Each receives
+`{ ctx, input, def, next }` and can run code before/after `next`, swap the context or input
+(`next(newCtx, newInput)`), wrap it in `try/catch`, or short-circuit by not calling it.
+
+```ts
+const timing = createMiddleware(async ({ def, next }) => {
+	const start = performance.now();
+	const result = await next();
+	console.log(`${def.name} took ${performance.now() - start}ms`);
+	return result;
 });
+```
+
+## Composition
+
+Because fns are just callables, compose them by calling one inside another's handler — pass
+the same `ctx` through. Error traces accumulate across the call path (see below).
 
-export const getSomeUserData = authedService.query(async ({ ctx }) => {
-	// will throw an error if ctx.user is undefined
-	return 'Protected data';
+```ts
+export const sendWelcomeText = createAuthedFn({
+	name: 'sendWelcomeText',
+	inputSchema: z.object({ chatId: z.string() }),
+	handler: async ({ input, ctx }) => {
+		await checkCredits({ input: { actionType: 'welcome' }, ctx });
+		const text = await generateWelcomeText({ ctx });
+		return sendSms({ input: { chatId: input.chatId, message: text }, ctx });
+	},
 });
 ```
 
-Specify the input and output schemas for your service for validation and type safety, and use the ctx/input arguments to access the service context and input data.
+## Errors
+
+Failures throw an `FnError` — a typed error with a tRPC-style `code`, structured `meta`, and a
+`functionTrace` that accumulates the fn names along the call path (so a deep failure tells you
+*which business operations* were in play, not just a file:line stack).
 
 ```ts
-// api/services/task-services.ts
-import { service } from '@davstack/service';
-import { z } from 'zod';
+import { FnError, isFnError } from '@davstack/fn';
 
-const getTasks = service()
-	.input(z.object({ projectId: z.string() }))
-	.query(async ({ ctx, input }) => {
-		return ctx.db.tasks.findMany({ where: { projectId: input.projectId } });
-	});
+throw new FnError({ code: 'INSUFFICIENT_CREDITS', message: 'Not enough credits' });
 ```
 
-### Direct Service Usage
+Validation failures throw automatically with `code: 'INVALID_INPUT'` / `'INVALID_OUTPUT'` and
+the zod error in `meta.zodErrors`.
 
-Unlike tRPC procedures, services can be called directly from anywhere in your backend, including within other services.
+### Want a result instead of a throw?
 
-```typescript
-const ctx = createServiceCtx(); // or get ctx from parent service
-const tasks = await getTasks(ctx, { projectId: '...' });
-```
+There's no `.safeCall`. Wrap the direct call with [`tryCatch`](../try-catch) from the
+companion package:
+
+```ts
+import { tryCatch } from '@davstack/try-catch';
+import type { FnError } from '@davstack/fn';
 
-This allows you to build complex service logic by composing multiple services together.
-
-```typescript
-const getProjectDetails = service()
-	.input(z.object({ projectId: z.string() }))
-	.output(
-		z.object({
-			id: z.string(),
-			name: z.string(),
-			tasks: getTasks.outputSchema,
-		})
-	)
-	.query(async ({ ctx, input }) => {
-		const project = await getProject(ctx, { projectId: input.projectId });
-		const tasks = await getTasks(ctx, { projectId: input.projectId });
-		return { ...project, tasks };
-	});
+const { data, error } = await tryCatch<Chat, FnError>(() =>
+	createChat({ input: { title: 'Hello' }, ctx })
+);
+if (error) return handle(error); // typed FnError
+use(data);                       // narrowed to non-null
 ```
 
-### tRPC Integration
+Use the thunk form (`() => fn(...)`) so a synchronous throw is caught too.
+
+## Transport adapters
 
-Seamlessly integrate with tRPC to create type-safe API endpoints.
+The core knows nothing about transports. Attach one at the edge:
+
+- **tRPC** — [`@davstack/fn-trpc`](../fn-trpc) turns a fn into a tRPC procedure via
+  `initProcedureFactory`.
 
 ```ts
 import { initTRPC } from '@trpc/server';
-import { createTrpcRouterFromServices } from '@davstack/service';
-import * as taskServices from './services/tasks';
-import * as projectServices from './services/projects';
-import { sendFeedback } from './services/send-feedback';
-
-const t = initTRPC();
-
-const appRouter = t.router({
-	tasks: createTrpcRouterFromServices(taskServices),
-	projects: createTrpcRouterFromServices(projectServices),
-	// or create a single procedure from a service
-	sendFeedback: createTrpcProcedureFromService(sendFeedback),
+import { initProcedureFactory } from '@davstack/fn-trpc';
+
+const t = initTRPC.create();
+const fromFn = initProcedureFactory(t.procedure);
+
+export const appRouter = t.router({
+	createChat: fromFn(createChat, 'mutation'),
 });
 ```
 
-NOTE: it is recommended to use the `* as yourServicesName` syntax. Otherwise, ctrl+click on the tRPC client handler will navigate you to the app router file, instead of the specific service definition.
+- **oRPC** — [`@davstack/fn-orpc`](../fn-orpc) turns a fn into an oRPC procedure via
+  `initProcedureFactory` (no query/mutation arg — chain `.route()` for OpenAPI).
 
-### Acknowledgements
+```ts
+import { os } from '@orpc/server';
+import { initProcedureFactory } from '@davstack/fn-orpc';
 
-Davstack Store has been heavily inspired by [tRPC](https://trpc.io/), a fantastic library for building type-safe APIs. A big shout-out to the tRPC team for their amazing work.
+const fromFn = initProcedureFactory(os);
 
-Nick-Lucas, a tRPC contributor, inspired the creation of Davstack Service with his [github comment](https://github.com/trpc/trpc/discussions/4839#discussioncomment-8224476). He suggested "making controllers minimal" and "to separate your business logic from the API logic", which is exactly what Davstack Service aims to do.
+export const router = {
+	createChat: fromFn(createChat),
+};
+```
 
-### Contributing
+## Companion packages
 
-Contributions are welcome! Please read our [contributing guide](link-to-contributing-guide) for details on our code of conduct and the submission process.
+| Package | What it does |
+| --- | --- |
+| [`@davstack/try-catch`](../try-catch) | `tryCatch(promiseOrThunk)` → `{ data, error }` (zero-dep) |
+| [`@davstack/fn-trpc`](../fn-trpc) | tRPC adapter (`initProcedureFactory`) |
+| [`@davstack/fn-orpc`](../fn-orpc) | oRPC adapter (`initProcedureFactory`) |
 
-### License
+## License
 
-This project is licensed under the [MIT License](link-to-license). See the LICENSE file for details.
+MIT
diff --git a/packages/fn/notes/eval-fnerror.md b/packages/fn/notes/eval-fnerror.md
new file mode 100644
index 0000000..ad603fe
--- /dev/null
+++ b/packages/fn/notes/eval-fnerror.md
@@ -0,0 +1,65 @@
+# Evaluation: why `FnError`? Is it needed? (verdict: yes — keep it)
+
+> Analysis of `src/errors.ts` and how it's used. Opposite conclusion to
+> [`eval-pipe-vs-middleware.md`](./eval-pipe-vs-middleware.md): unlike `pipe`, `FnError`
+> earns its place.
+
+## TL;DR
+
+**Keep `FnError`.** It's load-bearing (used by every validation path, the `Result`/`safeCall`
+type, and the composition story) and gives you things plain `Error` can't, cheaply (~150
+lines). It's the core of the package's value prop, not redundant inheritance.
+
+## What it buys you over plain `Error`
+
+1. **Typed error `code`** (tRPC-style: `UNAUTHORIZED`, `NOT_FOUND`, `INVALID_INPUT`, …).
+   Lets `.safeCall()` consumers and HTTP/tRPC layers branch on the *kind* of failure without
+   string-matching messages. Plain `Error` has nothing here.
+
+2. **`functionTrace` across composed fns** — the headline feature (tested in
+   `test/error-reporting.test.ts:156` and `test/tracing.test.ts`). As an error bubbles
+   through nested fns, `enhanceError` does `trace.unshift(def.name)`, producing
+   `[outerFn, middleFn, innerFn]` — a *semantic* call path of your fn names/tags. A native
+   stack trace gives file:line and gets mangled across async boundaries; it won't tell you
+   which business operations were in play.
+
+3. **Idempotent `from()`** — if the cause is already an `FnError`, it *enhances in place*
+   rather than re-wrapping. This is exactly the fix for the `improvements.md` complaint
+   ("we recreate errors in the wrapper, so we lose the original stack trace and get a
+   loooong message"). Original `cause` + stack are preserved while the trace accumulates.
+
+4. **`markAsReported()` / `_reported`** — dedup flag so a nested error isn't logged 3× as it
+   bubbles through 3 fns (tested at `test/error-reporting.test.ts:63`). Plain `Error` can't
+   carry this cleanly.
+
+5. **Structured `meta`** (e.g. `zodErrors`, `input`) — `withInputValidation` /
+   `withOutputValidation` attach Zod's `.flatten()`, so `safeCall` callers get field-level
+   validation detail. This is the `error` half of the `{ data, error }` `Result`.
+
+## Is it strictly needed?
+
+You *could* throw plain `Error`s — but the moment you want codes, validation detail in
+`safeCall`, the cross-fn trace, or log dedup, you'd be reimplementing a worse subset of
+exactly this. Not redundant the way `pipe` is.
+
+`Result<T>` itself is typed as `{ data: T; error: null } | { data: null; error: FnError | Error }`,
+so `FnError` is baked into the public surface.
+
+## Why it's here (vs `pipe`)
+
+`pipe` is dead inheritance from `packages/store`. `FnError` is the core of the package's
+value prop — typed/validated errors with a composition-aware trace, framework-agnostic
+(works in tRPC, server actions, and plain direct calls). The `improvements.md` notes
+literally list the error problems (obfuscated messages, lost stack traces) that `FnError`
+is the solution to.
+
+## Optional cleanups (not blockers)
+
+- `cause?: unknown` is redeclared as an instance field and reassigned, even though
+  `super(message, { cause })` already sets `this.cause` (ES2022). Slightly redundant.
+- `getDefaultErrorMessage` only handles ~5 of the ~19 codes; the rest fall through to
+  `Error: ${code}`. Either fill them in or drop the switch and inline.
+
+## Conclusion
+
+**Keep `FnError`.** Delete `pipe`, keep this.
diff --git a/packages/fn/notes/eval-pipe-vs-middleware.md b/packages/fn/notes/eval-pipe-vs-middleware.md
new file mode 100644
index 0000000..fb4578e
--- /dev/null
+++ b/packages/fn/notes/eval-pipe-vs-middleware.md
@@ -0,0 +1,82 @@
+# Evaluation: is `pipe` worth keeping? (verdict: no — delete it)
+
+> Analysis of `src/pipe.ts` against what the package actually does.
+> See also the (now stale) design note [`why-pipe-over-middleware.md`](./why-pipe-over-middleware.md),
+> whose conclusion the shipped code contradicts.
+
+## TL;DR
+
+**Delete `pipe`.** It's dead code inherited from `packages/store`, it's unused, and for
+this package's needs the middleware array is *strictly more capable*. The one advantage
+`pipe` has (type-safe progressive context evolution) is something this package deliberately
+does **not** do.
+
+## What `pipe` actually is
+
+`src/pipe.ts` is 4247 lines, but the runtime is **2 lines** (the last ones in the file):
+
+```ts
+export function pipe(x: any, ...fns: any[]) {
+  return fns.reduce((y: any, fn) => fn(y), x);
+}
+```
+
+The other ~4245 lines are pure TypeScript overload signatures (one per arity,
+`pipe(x)` … `pipe(x, f1, …, f40)`) so chained types infer. They're erased at build —
+**zero bundle/runtime cost** (package is `sideEffects: false`, tree-shakeable). The real
+cost is type-check time, file noise, and maintenance.
+
+## Is it used?
+
+No. `pipe` is exported from `index.ts` but:
+
+- **not** used by `createFn` (which runs on the middleware array + `executeMiddleware`),
+- **not** referenced in any test,
+- **not** referenced in the README.
+
+It's orphaned — it came across when this code lived in `packages/store`.
+
+## Does `pipe` give any benefit here? No.
+
+### 1. Its one advantage is unused
+
+`why-pipe-over-middleware.md` argued `pipe` wins on **type-safe progressive context
+evolution** (middleware A adds `user`, so B + the handler then see `user` typed). But this
+package punts on that entirely:
+
+- `middleware?: Middleware<any>[]` — the array is typed `any`; context changes are **not**
+  tracked through the chain.
+- Context is declared **upfront** as one generic: `initCreateFn<AuthedServerFnCtx>([authMw])`.
+  In `test/composition.test.ts`, `ctx.user` is `{ id: string }` because the generic
+  *asserted* `AuthedServerFnCtx`, not because `authMw` narrowed it.
+
+So the design sidesteps the "type hell" the note worried about by just naming the full
+context type upfront. `pipe`'s only edge is therefore moot.
+
+### 2. `pipe` is strictly *less* expressive for this use case
+
+`pipe` is a linear `reduce`: value out → value in, every step runs, forward only. But all
+four built-in behaviors need *around* ("onion") semantics that `pipe` can't express:
+
+| Built-in middleware       | Needs…                                  | `pipe` can do it? |
+| ------------------------- | --------------------------------------- | ----------------- |
+| `withThrowingErrorHandler`| `try { await next() } catch` downstream | ❌ can't catch downstream |
+| `withSafeResultFormatter` | run after `next`, reshape to `{data,error}` | ❌ no "after" hook |
+| `withOutputValidation`    | validate the *result* of `next`         | ❌                |
+| auth middleware           | **short-circuit** (don't call `next`)   | ❌ pipe always runs every step |
+
+Plus every middleware receives `{ ctx, input, def, next }` together; a `pipe` step only
+gets the single piped value, so it can't see `def`/metadata or swap `input` + `ctx`
+independently.
+
+## Conclusion
+
+The `next`-chain (Express/tRPC style) is the right primitive, and it's what already shipped.
+`pipe` would be a downgrade: its theoretical edge is unused, and it loses the
+around/short-circuit semantics the package relies on.
+
+**Action:** delete `src/pipe.ts`, remove `export * from './pipe'` from `index.ts`, and remove
+the stale `why-pipe-over-middleware.md` note (the code went the other way).
+
+The only reason to keep `pipe` would be exposing it as a generic FP helper for consumers'
+own handler code — but nothing here uses it, and that's not fn-specific value.

From f89975056395a58925433ba952b4f9aa8e7a41d2 Mon Sep 17 00:00:00 2001
From: DawidWraga <dpwraga@gmail.com>
Date: Tue, 16 Jun 2026 19:42:57 +0100
Subject: [PATCH 72/72] docs(fn): add design-decisions and oRPC-internals
 research notes

---
 .../fn/notes/design-decisions-and-vision.md   | 362 +++++++++++++++
 packages/fn/notes/research-orpc-internals.md  | 430 ++++++++++++++++++
 2 files changed, 792 insertions(+)
 create mode 100644 packages/fn/notes/design-decisions-and-vision.md
 create mode 100644 packages/fn/notes/research-orpc-internals.md

diff --git a/packages/fn/notes/design-decisions-and-vision.md b/packages/fn/notes/design-decisions-and-vision.md
new file mode 100644
index 0000000..82b8cf8
--- /dev/null
+++ b/packages/fn/notes/design-decisions-and-vision.md
@@ -0,0 +1,362 @@
+# `@davstack/fn` — design decisions, evaluations & vision
+
+> A consolidated record of the design conversation about the future of this package:
+> the guiding philosophy, every decision with its rationale and caveats, the research
+> that informed them, and the deliberately-cautious near-term plan.
+>
+> Companion notes: `[eval-pipe-vs-middleware.md](./eval-pipe-vs-middleware.md)` (delete `pipe`),
+> `[eval-fnerror.md](./eval-fnerror.md)` (keep `FnError`),
+> `[research-orpc-internals.md](./research-orpc-internals.md)` (how hard owning HTTP is).
+> Private research (kept out of this repo): `~/dev/output-schema-migration-notes.md`.
+
+---
+
+## 1. What the package is
+
+`@davstack/fn` is a **transport-agnostic server-function convention**. You define a plain
+function with metadata:
+
+```ts
+createPublicServerFn({
+  name, description?, tags?,
+  inputSchema?, outputSchema?,
+  route?: { path, method },   // (proposed) marks it as a public HTTP endpoint
+  handler: async ({ input, ctx }) => { ... },
+})
+```
+
+The defining property — and the thing the user values most — is that **the fn is callable
+with the exact same `{ input, ctx }` as its handler**. No builder chain; a flat `{}` config
+object. This makes fns directly callable, portable, testable, and composable, independent of
+any transport.
+
+Real consumption today:
+
+- **titanium** uses it via `initCreateFn<Ctx>([...middleware])` → `createPublicServerFn` /
+`createAuthedServerFn`, with three middlewares (tracing, error-handling, auth). ~92 in-use
+fns. Currently bridged into **tRPC** through `initProcedureFactory` (a ~256-line `router.ts`
+with ~98 manual registrations).
+- **aftrak** does NOT use `@davstack/fn`; it uses **oRPC** directly (15 procedures, all with
+`.output()`). It is the reference for the oRPC + OpenAPI pattern.
+
+---
+
+## 2. The guiding philosophy (the principle everything else follows from)
+
+**Ports & adapters.** Business logic lives in plain, portable, directly-callable functions.
+Transport (tRPC / oRPC / HTTP) is a thin adapter bolted on at the edge — never the home of
+the logic.
+
+The user articulated this sharply: they *dislike* the "server-fn wrapped in tRPC/oRPC" model
+because it "feels like typing up all your business logic within a 3rd-party library." They
+*prefer* directly-callable functions because they're portable (usable in tests, other
+frameworks), and composable. This is the north star.
+
+Consequence: the package is really **two layers**, and they have very different risk profiles:
+
+- **Layer 1 — the directly-callable fn convention.** Good, safe, low-risk. This is your own
+code in plain-function form. Not lock-in.
+- **Layer 2 — the transport/codegen bridge.** Risky. Source of both the registration
+boilerplate *and* the IDE lag. Must stay thin, optional, and ejectable.
+
+---
+
+## 3. The cautionary tale & the test that keeps us honest
+
+The user was previously burned by `**@davstack/store`**: a custom-optimal solution that lost
+to standard-but-AI-trained alternatives because of the compatibility/education tax. The fear
+is repeating that — building a "framework" the world must adopt.
+
+**The ejectability test:** a *convention* is one you can throw away while keeping the durable
+artifacts; a *framework* owns your control flow and can't be removed without a rewrite.
+
+This package passes the test **as long as the durable artifact is a standard** (OpenAPI) and
+the durable logic is **your own plain functions**. The danger is only ever in Layer 2.
+
+A key clarification that resolved a lot of tension: there are two meanings of "standard."
+
+- ❌ *Evangelize a new governed spec the world must adopt* — this is the store trap. Avoid.
+- ✅ *Adopt the minimal convergent shape everyone already uses* (input + output + handler +
+name/description) — this is just naming the obvious. Safe.
+
+The fn shape is the second kind. So "make it a standard" is fine **if** it means "use the
+convergent shape + lean on existing standards," and dangerous **if** it means "get others to
+adopt open-fn and maintain governance/compat for external users."
+
+---
+
+## 4. Decision log
+
+Each entry: **decision · rationale · caveats · status.**
+
+### D1 — Delete `pipe`
+
+- **Decision:** remove `src/pipe.ts`, drop its export, remove the stale `why-pipe-over-middleware.md`.
+- **Rationale:** dead code inherited from `packages/store`. Unused by `createFn`, tests, or
+README. Its one theoretical advantage (type-safe progressive context evolution) is
+deliberately *not* used — context is declared upfront as one generic. The middleware array
+is strictly more capable (it needs around/onion semantics + short-circuit that `pipe`'s
+linear `reduce` can't express). The 2-line runtime is buried under ~4245 lines of overload
+signatures — pure type-check-time noise and a contributor to IDE lag.
+- **Caveat:** none. (Only reason to keep would be exposing a generic FP helper for consumers —
+not fn-specific value.)
+- **Status:** agreed. (See `eval-pipe-vs-middleware.md`.)
+
+### D2 — Keep `FnError`
+
+- **Decision:** retain `src/errors.ts`.
+- **Rationale:** load-bearing and earns its ~150 lines. Gives typed error `code`
+(tRPC-style), `functionTrace` accumulation across composed fns (semantic call path of fn
+names — survives async boundaries where native stacks don't), idempotent `from()` (enhances
+in place, preserves original cause/stack), `markAsReported()` dedup, and structured `meta`
+(zod field errors for the `Result` error half). Plain `Error` would mean reimplementing a
+worse subset. It's baked into the public `Result<T>` type.
+- **Caveat:** minor cleanups available (redundant `cause` field reassignment;
+`getDefaultErrorMessage` only covers ~5/19 codes).
+- **Status:** agreed — keep. (See `eval-fnerror.md`.)
+
+### D3 — Replace `.safeCall` with a standalone `tryCatch`
+
+- **Decision:** remove the `.safeCall` method from the fn object; ship a standalone
+`tryCatch(promise)` util (in its own package) that wraps any promise into `{ data, error }`.
+  ```ts
+  type Result<T, E = Error> = { data: T; error: null } | { data: null; error: E };
+  async function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>> {
+    try { return { data: await promise, error: null }; }
+    catch (error) { return { data: null, error: error as E }; }
+  }
+  ```
+- **Rationale:** makes the fn a *plain callable* (no methods bolted on) → maximally portable
+and composable, aligning with the core philosophy. The util is generic (works on any
+promise, not just fns) and uses the widely-recognized shape (good for the anti-store
+"use familiar patterns" goal). Lighter core.
+- **Caveats:** (1) type it `tryCatch<T, FnError>(...)` at fn call sites to keep typed-error
+branching. (2) `tryCatch(fn(args))` evaluates the promise eagerly, so errors thrown during
+*argument construction* aren't caught — a non-issue for async fns (they reject, never throw
+sync).
+- **Status:** agreed; near-term.
+
+### D4 — Standard Schema v1 instead of zod under the hood
+
+- **Decision:** type the core's schema fields as `StandardSchemaV1` rather than zod-specific
+types; validate via `schema['~standard'].validate(...)`; infer via
+`StandardSchemaV1.InferInput/InferOutput`.
+- **Rationale:**
+  - oRPC is itself built on Standard Schema, so `toOrpcRouter` passes schemas straight
+  through — native composition, zero impedance. (Standard Schema makes *more* sense for the
+  oRPC setup, not less.)
+  - Decouples the core from zod → users can bring zod / valibot / arktype.
+  - **Deletes the zod v3/v4 dual-support code** (`isZod4`, branched `zInfer`/`zInferInput`) —
+  so this is partly *subtraction*, not just refactor.
+  - Fixes the titanium **zod import-drift landmine** (`zod/v3` vs `zod` root on `zod@^3.25`
+  causing "two zod instances" errors) at the package boundary.
+- **The decisive caveat:** Standard Schema standardizes *validation*, **not** JSON-Schema
+generation. So the OpenAPI step needs a library-specific converter, registered with oRPC's
+generator. **zod → `@orpc/zod`** is the most mature (zod v4 also has native
+`z.toJSONSchema`). valibot/arktype converters exist but are less battle-tested.
+- **Net pattern:** **Standard Schema as the *interface* (core, lib-agnostic), zod as the
+*implementation* you actually write** (best OpenAPI conversion). The core never needs
+zod-specific behavior; anything lib-specific lives in the adapter layer where knowing it's
+zod is fine.
+- **Status:** agreed; folds into the core subtraction.
+
+### D5 — Make `outputSchema` required when `route` is set
+
+- **Decision:** require `outputSchema` iff the fn has a `route` (i.e. is publicly exposed);
+optional otherwise.
+- **Rationale (this is load-bearing, not cosmetic):**
+  1. **Cheaper types / fixes IDE lag.** The lag comes from output types inferred as
+    `Awaited<ReturnType<handler>>` *through* Kysely's heavy types, ×~98. Sourcing the type
+     from `outputSchema` (`InferOutput`) makes it an already-flat resolved type. This is the
+     enabling condition for a typed adapter without lag.
+  2. **OpenAPI is impossible without it** — you can't serialize an inferred TS type to JSON
+    Schema at runtime; you need a declared output schema.
+  3. **Runtime safety boundary** — catches handler bugs and stops leaking extra DB columns
+    (relevant to RLS/security work).
+  4. **Smoke tests** get an assertion target.
+- **Why `iff route` (not global):** kills the only weak case — void setter fns gaining nothing
+but `z.void()` boilerplate. `route` becomes both the "expose" switch *and* the
+"output required" trigger. Internal/void fns stay friction-free.
+- **Caveat — validate at the boundary, not on direct calls:** parse output at the HTTP edge
+(and always in dev to catch schema/handler drift); skip on internal direct calls so the
+hot portable-call path stays zero-overhead. Drift maintenance (schema vs `selectAll()` as
+columns change) is the real ongoing cost — supazod regen covers base tables; partial
+selects/joins drift and need discipline.
+- **Status:** agreed in principle; depends on adopting the `route` metadata.
+
+### D6 — Package split: dep-free core + separate adapter packages
+
+- **Decision:** core `@davstack/fn` carries **zero transport deps**. tRPC and oRPC adapters
+live in separate packages. `tryCatch` in its own package too.
+- **Rationale:** the live contradiction is a "transport-agnostic" core that hard-depends on
+`@trpc/server` + `superjson` in `dependencies`. Splitting is pure hygiene and *reduces*
+maintenance. It also makes each adapter individually optional/ejectable.
+- **Caveat / scope discipline:** split the core out, but do **not** build a general "plugin
+system"/ecosystem for hypothetical adapters — that's premature generalization (store trap).
+Build exactly the adapters you need (tRPC for titanium today, oRPC for aftrak); let any
+third adapter reveal the shared shape.
+- **Status:** agreed; near-term (see §6 plan).
+
+### D7 — OpenAPI is the *boundary*; oRPC is the *implementation*
+
+- **Decision:** treat `openapi.json` as the contract/boundary. Whatever serves it (oRPC now)
+is a swappable implementation detail.
+- **Rationale:** this resolves the apparent "OpenAPI vs oRPC" conflict — they're different
+layers. The client (orval-generated hooks) depends *only* on the spec, never imports oRPC.
+So you can later swap oRPC → your own generator+handler with **zero downstream change**.
+Independence is secured by the spec being the boundary — you get it *now* without owning the
+generator now.
+- **Caveat:** because the boundary is the spec, "use openapi" and "use the oRPC adapter" are
+both true simultaneously. Don't agonize over the choice; it's reversible.
+- **Status:** agreed as the principle.
+
+### D8 — Owning the HTTP layer: possible & cheap, but delegate for now
+
+- **Research verdict:** owning a standard-OpenAPI HTTP handler is a **~1-day, ~250–400 LOC**
+job. Our use case (orval → plain JSON REST) maps to oRPC's `OpenAPIHandler` family, **not**
+its `RPCHandler`/custom RPC protocol — and the RPC half (super-JSON typed codec for
+Date/Map/Set/bigint/File, RPC wire format, RPC client) is the bulk of oRPC's size and is
+**completely irrelevant** to us. MVP = match route (reuse `rou3` trie), parse JSON body +
+path/query, validate via Standard Schema, call fn, validate output, map error→status
+(~80 trivial LOC), return JSON; adapters ~30–50 LOC each. Long tail (bracket-notation nested
+query params, files/multipart, SSE/streaming, exotic coercion) is all deferrable.
+- **Decision:** **delegate to oRPC for now.** The user has no time to build/maintain HTTP.
+The research was still worth it: it proves you *could* own it cheaply, which permanently
+kills the "thin oRPC wrapper" anxiety.
+- **Why "thin wrapper" doesn't apply anyway:** your value was never HTTP serving — it's the
+fn-authoring layer, the internal/composition superset (oRPC has no concept of
+"functions that exist but aren't exposed"), and the OpenAPI projection. The adapter is the
+last ~5%.
+- **Status:** delegate now; owning is a documented, deferred option.
+
+### D9 — A registry `{ key: fn }` as the single source of truth
+
+- **Decision:** collect fns into a registry object; everything is a projection of it.
+  ```
+  registry { k: fn }  ─→ toOrpcRouter(registry) ─→ oRPC serves HTTP
+  (ALL fns)           │        └─→ oRPC emits openapi.json ─→ orval ─→ typed hooks
+                      └─→ smokeTest(registry) ─→ loop, call, assert output
+  ```
+- **Rationale:** one source feeds router, spec, and smoke tests. **Registry = all fns
+(superset); OpenAPI = the `route`d subset (projection).** Internal/composition fns live in
+the registry and feed smoke tests but never get a `route`, so never hit the public spec —
+the internal-layer value falls straight out of the design. Registry can be nested
+(`{ user: { list, create } }`) for grouping → oRPC structure / OpenAPI tags; `route` drives
+the actual HTTP path.
+- **Caveat:** `toOrpcRouter` should be a **generic mapper**, not 98 hand-registrations — that
+avoids replicating titanium's `router.ts` pain.
+- **Status:** agreed as the target shape (deferred with the oRPC/openapi decision).
+
+### D10 — Codegen is an explicit command, NOT in the watch script
+
+- **Decision:** `pnpm gen:api` = registry → `openapi.json` → orval → hooks. Run on demand.
+- **Rationale:** codegen-on-every-save is exactly the always-running magic machinery that
+causes noise/lag — the thing being escaped. Contract changes are infrequent and intentional
+(like migrations); handler-body edits (the common case) don't change the contract, so ~95%
+of saves shouldn't trigger codegen. Predictable > automatic, matching the low-abstraction
+values. Automate later only if manual runs become genuinely annoying (or have oRPC serve the
+spec live at `/openapi.json` and point orval at the endpoint).
+- **Status:** agreed (applies if/when the openapi/orval path is adopted).
+
+### D11 — Smoke tests from the registry
+
+- **Decision:** `smokeTest(registry)` loops every fn, calls it, asserts the result validates
+against its `outputSchema`.
+- **Rationale:** registry gives free enumeration; mandatory output schema gives the assertion
+target.
+- **Caveat (be honest about it):** valid inputs + a test ctx (db/user) are *not* free.
+Auto-coverable: `z.void()`/no-input fns. Everything else needs a registered fixture
+(e.g. an optional `examples`/`fixture` field on the fn, reusable as OpenAPI example
+payloads). The runner must **log which fns it skipped** — never report green on partial
+coverage.
+- **Status:** desirable; deferred.
+
+### D12 — Naming: `open-fn` vs keep `@davstack/fn` — UNDECIDED
+
+- **Arguments for keeping `fn`:** it's accurate and humble; already published at
+`@davstack/fn` v1.1.0 (renaming = churn); "open-X" implies an open *standard* with
+governance, which is the framing to avoid. You can *describe* it as "an open,
+transport-agnostic fn convention that compiles to OpenAPI" without renaming.
+- **Arguments for `open-fn`:** evokes OpenAPI; signals the interoperable/standard intent;
+brandable; with Standard Schema adoption the "open/interoperable" framing is more defensible.
+- **Status:** **open / undecided.** Leaning cautious (keep `fn`) but not settled.
+
+---
+
+## 5. The IDE-lag diagnosis (context for several decisions above)
+
+After running the tRPC-generation script on a titanium branch, the IDE began lagging badly.
+Most likely cause: the generated tRPC `AppRouter` over ~98 procedures, each inferring its
+output type *through* heavy Kysely query builders → tsserver type-instantiation blowup.
+Secondary contributors: the unused 60-overload `pipe`, and zod v3/v4 dual inference.
+
+Mitigations (which several decisions encode): source output types from `outputSchema` instead
+of inferring handler returns (D5); delete `pipe` (D1); move to Standard Schema (D4); prefer a
+data artifact (`openapi.json`) over a giant generated *typed* router file — **codegen that
+emits DATA is harmless; codegen that emits heavy TYPES is what lagged** (D7/D10). Confirm with
+`tsc --generateTrace` if needed.
+
+---
+
+## 6. The near-term plan (deliberately cautious)
+
+The user is intentionally limiting changes — **not yet committing** to going all-in on oRPC,
+or on the OpenAPI/orval direction. So for now:
+
+1. **Move `tryCatch` to a separate package** and export it; **remove `.safeCall`** (D3).
+2. **Swap to Standard Schema v1** over zod in the core (D4).
+3. **Move `@trpc/server` + `superjson` deps to a separate package** — but **keep tRPC
+  compatibility** (titanium still relies on it). I.e. move the **tRPC plugin/adapter
+   (`initProcedureFactory`) into its own package**, don't delete it (D6).
+4. **Create a separate oRPC adapter package** for the aftrak codebase (D6).
+5. **Delete `pipe`** (D1) and **keep `FnError`** (D2).
+
+Explicitly **deferred / not doing now:** owning the HTTP layer (D8), the registry+codegen+
+orval pipeline (D9/D10), smoke tests (D11), making `outputSchema` mandatory across titanium
+(D5 — the migration), and the final naming call (D12).
+
+> **Implementation status (branch `fn-near-term-plan`).** Done, in this order:
+>
+> 1. ✅ **Deleted `pipe`** (D1) — removed `src/pipe.ts` + its export + the stale
+>   `why-pipe-over-middleware.md` note.
+> 2. ✅ **Extracted `tryCatch` → new `@davstack/try-catch`** (zero-dep) and **removed
+>   `.safeCall`** (D3). Also removed the now-dead `Result` type and `withSafeResultFormatter`
+>    middleware from core. fn tests that used `.safeCall` now assert on the thrown `FnError`.
+> 3. ✅ **Extracted the tRPC adapter → new `@davstack/fn-trpc`** (D6); dropped `@trpc/server`
+>   **and** `superjson` from core deps (`superjson` was unused everywhere — dropped, not
+>    moved). **Core now has zero runtime dependencies.**
+>
+> **Paused here, before** the **oRPC adapter package** (D6, item 4) — by request, pending the
+> decision on whether to go all-in on oRPC/OpenAPI. Also **not done this round:** the Standard
+> Schema v1 swap (D4) — still zod-coupled for now. `FnError` kept (D2). fn bumped to a major
+> (`2.0.0`) via changeset; the two new packages start at `0.1.0`.
+
+This keeps every change either **pure subtraction** or **dependency-relocation** — no bets on
+the uncertain Layer-2 direction. The architecture stays open: adopting oRPC/OpenAPI later is a
+clean, additive step because the boundary (the spec) and the source of truth (plain fns)
+don't change.
+
+> **Don't forget the docs.** Several near-term changes are breaking and must be reflected in
+> the `README.md` (and `CHANGELOG.md` / a version bump): `.safeCall` removed in favour of the
+> standalone `tryCatch`, the Standard Schema swap (no longer zod-coupled), and the tRPC/oRPC
+> adapters moving to separate packages (new install + import paths). Update docs as part of
+> the same change, not after — stale examples are how a "simple" package starts feeling
+> untrustworthy.
+
+---
+
+## 7. Supporting research (summaries)
+
+**Output-schema migration effort** (private notes at `~/dev/output-schema-migration-notes.md`):
+aftrak already 15/15 with output schemas. titanium ~~92 fns, ~49 already have `outputSchema`
+(~~53%), ~43 missing. supazod `RowSchema` reuse + `z.coerce.date()` already solves the
+date-column killer; `.pick()`/`.extend()` patterns already in production. ~25 of the 43 are
+trivial/codemod-able, ~12–16 need hand-crafting (chart/stats/nested). **Total ~1.5–3 dev-days.**
+Risks: zod import drift (v3 vs root), runtime parse cost on hot list/live endpoints, loosely
+-typed Json columns, void-fn boilerplate.
+
+**oRPC internals** (`research-orpc-internals.md`): owning standard-OpenAPI HTTP is a ~1-day /
+250–400 LOC MVP; the hard, large parts of oRPC are the RPC protocol + exotic serializer, none
+of which our plain-JSON use case needs. The OpenAPI spec generator (`@orpc/openapi`, ~880 LOC)
+is fully decoupled from serving — reuse it build-time-only, or own a lean zod-only generator
+later.
\ No newline at end of file
diff --git a/packages/fn/notes/research-orpc-internals.md b/packages/fn/notes/research-orpc-internals.md
new file mode 100644
index 0000000..e8e3b10
--- /dev/null
+++ b/packages/fn/notes/research-orpc-internals.md
@@ -0,0 +1,430 @@
+# oRPC internals: how hard is it to OWN the HTTP-serving layer?
+
+Research target: `@orpc/server`, `@orpc/openapi`, `@orpc/openapi-client`, `@orpc/client`,
+`@orpc/contract`, `@orpc/standard-server*` at **v1.14.6**.
+
+Sources read (real dist):
+- `aftrak/web/node_modules/.pnpm/@orpc+server@1.14.6_.../dist/...` (server core + adapters)
+- `aftrak/web/node_modules/.pnpm/@orpc+standard-server@1.14.6/.../dist/index.mjs`
+- `aftrak/web/node_modules/.pnpm/@orpc+standard-server-fetch@1.14.6/.../dist/index.mjs`
+- `aftrak/web/node_modules/.pnpm/@orpc+client@1.14.6_.../dist/shared/client.D9eWXdBV.mjs`
+- `aftrak/web/node_modules/.pnpm/@orpc+contract@1.14.6_.../dist/...`
+- `@orpc/openapi@1.14.6` + `@orpc/openapi-client@1.14.6` (downloaded via `npm pack`, since aftrak
+  only installs `client`/`server`/`tanstack-query`, NOT the openapi packages).
+
+---
+
+## TL;DR verdict
+
+**Owning a minimal standard-OpenAPI HTTP handler is genuinely easy — roughly a day, ~250-400 LOC.**
+Our use case (orval-generated hooks → plain JSON REST endpoints) deliberately sidesteps almost
+everything that makes oRPC's serving layer big.
+
+The bulk of oRPC's serving complexity exists to support **its own RPC wire protocol** (`RPCHandler`,
+super-JSON-style typed codec, RPC client) and **edge features** (file uploads, SSE/event-iterators,
+"detailed" input/output structures, bracket-notation nested-query encoding, lazy/contract-first
+routers, hibernation, plugins, OTel spans). **None of those are on the critical path for plain JSON
+in / plain JSON out.**
+
+The one piece that is non-trivial and worth keeping an eye on is the **OpenAPI spec generator**
+(`@orpc/openapi`, ~880 LOC of Standard-Schema→JSON-Schema massaging). But that is *decoupled* from
+serving — you can use one without the other. And orval needs a spec from us regardless of how we
+serve.
+
+Recommendation: **own the handler, strongly consider owning the spec-gen too** (or use a thin
+schema-library-native converter like `zod-to-json-schema`), and **do not adopt oRPC's RPC stack at
+all** for the orval path. See the effort table at the end.
+
+---
+
+## 1. Layer map — which layers matter for us
+
+oRPC ships two parallel "handler" families on top of one shared engine.
+
+```
+                          @orpc/contract  (route config, ORPCError, defaults, Standard-Schema glue)
+                                  |
+   ┌──────────────────────────── @orpc/server (StandardHandler engine: match→decode→validate→call→encode) ───────────────────────────┐
+   |                                                                                                                                    |
+   |   RPCHandler  (server/dist/...)                            OpenAPIHandler  (@orpc/openapi)                                          |
+   |   ── custom RPC wire protocol                              ── standard REST: rou3 path matching, JSON body,                         |
+   |   ── StandardRPCCodec + super-JSON serializer             ── query/path params, bracket-notation, OpenAPI status codes            |
+   |   ── pairs with RPCLink (the @orpc RPC client)            ── StandardOpenAPICodec + StandardOpenAPISerializer                      |
+   |                                                                                                                                    |
+   └─ adapters: fetch / node / aws-lambda / fastify / bun-ws / ws / crossws / message-port (Request/Response ↔ "standard" request) ────┘
+                                  |
+   @orpc/standard-server  (transport-neutral helpers: SSE encode/decode, content-disposition, header merge)
+   @orpc/standard-server-fetch / -node  (Request/Response ↔ standard-request adapters)
+```
+
+| Layer | Package / file | Relevant to us? |
+|---|---|---|
+| **`OpenAPIHandler`** (standard REST) | `@orpc/openapi` `dist/shared/openapi.BB-W-NKv.mjs` (~205 LOC) | **YES** — this is the match we'd replicate |
+| `RPCHandler` (custom RPC protocol) | `@orpc/server` core | **NO** — only needed by the oRPC RPC client; orval doesn't use it |
+| `StandardHandler` engine | `@orpc/server` `dist/shared/server.ZxHCEN1h.mjs` (~226 LOC) | **YES (concept)** — the lifecycle we'd reimplement (small) |
+| OpenAPI spec generator | `@orpc/openapi` `dist/shared/openapi.BwdtJjDu.mjs` (~880 LOC) | **YES** — orval needs a spec; decoupled from serving |
+| `StandardOpenAPISerializer` (JSON + bracket) | `@orpc/openapi-client` `dist/shared/openapi-client.B2Q9qU5m.mjs` (~300 LOC) | **PARTLY** — JSON codec yes, bracket-notation only for nested query/form |
+| `StandardBracketNotationSerializer` | `@orpc/openapi-client` `dist/shared/openapi-client.t9fCAe3x.mjs` (~146 LOC) | **MOSTLY NO** — only for nested objects in query/form |
+| fetch adapter | `@orpc/server` `dist/adapters/fetch/index.mjs` (~167 LOC) | **YES (concept)** — trivial Request↔standard glue |
+| `ORPCError` + status table | `@orpc/client` `dist/shared/client.D9eWXdBV.mjs` | **YES** — the error→status mapping, ~80 LOC, trivial to copy |
+| RPC super-JSON serializer | `@orpc/client` RPC codec | **NO** — RPC protocol only |
+| event-iterator / SSE | `@orpc/standard-server` `dist/index.mjs` (~268 LOC) | **NO** (MVP) — only if we want streaming |
+| plugins, hibernation, batch, peer, ws | various | **NO** |
+
+**Conclusion for the framing question:** our client is orval-generated hooks hitting a standard
+OpenAPI/REST endpoint. That maps to **`OpenAPIHandler` + the OpenAPI spec generator**, and explicitly
+**NOT** to `RPCHandler` / `RPCLink` / the super-JSON RPC codec. The entire RPC half of oRPC is
+irrelevant to us.
+
+---
+
+## 2. Request lifecycle for the OpenAPI handler (end to end)
+
+The engine lives in `StandardHandler.handle()`
+(`@orpc/server/dist/shared/server.ZxHCEN1h.mjs`, lines ~33-112). `StandardOpenAPIHandler` just
+plugs in an OpenAPI-flavoured matcher + codec:
+
+```js
+// @orpc/openapi/dist/shared/openapi.BB-W-NKv.mjs:193
+class StandardOpenAPIHandler extends StandardHandler {
+  constructor(router, options) {
+    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
+    const bracketNotationSerializer = new StandardBracketNotationSerializer(options);
+    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
+    const matcher = new StandardOpenAPIMatcher(options);
+    const codec   = new StandardOpenAPICodec(serializer, options);
+    super(router, matcher, codec, options);
+  }
+}
+```
+
+The lifecycle (stripped of OTel spans / interceptors):
+
+1. **Prefix check** — bail with `{matched:false}` if pathname doesn't start with the mount prefix.
+2. **Route match** — `matcher.match(method, "/<pathname>")`.
+3. **Decode input** — `codec.decode(request, params, procedure)`. (`step = "decode_input"`)
+4. Wrap input in a span if it's an async iterator (irrelevant to us).
+5. **Build procedure client** and **call it** — `client(input, {signal, lastEventId})`
+   (`step = "call_procedure"`). Input/output validation happens *inside* this client.
+6. **Encode output** — `codec.encode(output, procedure)` → `{status, headers, body}`.
+7. **Error path** — any throw is caught; if it happened during `decode_input` and isn't already an
+   `ORPCError`, it becomes `BAD_REQUEST` (400); otherwise `toORPCError(e)`. Then
+   `codec.encodeError(error)`.
+
+```js
+// StandardHandler.handle() — error mapping excerpt
+const error = step === "decode_input" && !(e instanceof ORPCError)
+  ? new ORPCError("BAD_REQUEST", { message: "Malformed request. ...", cause: e })
+  : toORPCError(e);
+const response = this.codec.encodeError(error);
+return { matched: true, response };
+```
+
+### 2a. Route matching — `StandardOpenAPIMatcher`
+Uses the tiny **`rou3`** trie router (external dep). Patterns are translated from OpenAPI `{param}`
+syntax to rou3 syntax:
+
+```js
+// openapi.BB-W-NKv.mjs:113
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path)
+    .replace(/\/\{\+([^}]+)\}/g, "/**:$1")   // {+rest} -> wildcard
+    .replace(/\/\{([^}]+)\}/g,  "/:$1");      // {id}    -> :id
+}
+```
+Match returns `{path, procedure, params}`; params are URI-decoded
+(`decodeParams` → `tryDecodeURIComponent`). There's also lazy/contract-first router resolution
+(`pendingRouters`, `unlazy`) — **we don't need lazy routers.**
+
+### 2b. Input decoding — `StandardOpenAPICodec.decode`
+For the default **"compact"** input structure (the only one we'd use):
+
+```js
+// openapi.BB-W-NKv.mjs:16
+async decode(request, params, procedure) {
+  const inputStructure = ...; // "compact" by default
+  if (inputStructure === "compact") {
+    const data = request.method === "GET"
+      ? this.serializer.deserialize(request.url.searchParams)   // query → object
+      : this.serializer.deserialize(await request.body());      // JSON body → object
+    if (data === void 0) return params;
+    if (isObject(data)) return { ...params, ...data };          // merge path params
+    return data;
+  }
+  // "detailed": returns { params, query, headers, body } separately
+}
+```
+
+So for a `POST` with a JSON body and a `{id}` path param, the handler input is
+`{ ...pathParams, ...jsonBody }`. For `GET`, it's `{ ...pathParams, ...queryParams }`.
+`request.body()` is the standard-server body parser
+(`@orpc/standard-server-fetch` `toStandardBody`) which content-type-switches between JSON / FormData /
+URLSearchParams / SSE / Blob.
+
+### 2c. Input validation
+Inside the procedure client (`@orpc/server/dist/shared/server.DEBcqOjg.mjs:152`):
+
+```js
+async function validateInput(procedure, input) {
+  const schema = procedure["~orpc"].inputSchema;
+  if (!schema) return input;
+  const result = await schema["~standard"].validate(input);   // Standard Schema!
+  if (result.issues) {
+    throw new ORPCError("BAD_REQUEST", {
+      message: "Input validation failed",
+      data: { issues: result.issues },
+      cause: new ValidationError({ ... issues: result.issues, data: input }),
+    });
+  }
+  return result.value;
+}
+```
+Note: validation is via the **Standard Schema** `~standard.validate` contract — exactly what we
+already plan to use. Input failure → `BAD_REQUEST` (400) with `data.issues` carrying the raw issues.
+
+### 2d. Invoke handler / output validation
+`createProcedureClient` runs middlewares (we have none), calls the handler, then `validateOutput`:
+
+```js
+async function validateOutput(procedure, output) {
+  const schema = procedure["~orpc"].outputSchema;
+  if (!schema) return output;
+  const result = await schema["~standard"].validate(output);
+  if (result.issues) {
+    throw new ORPCError("INTERNAL_SERVER_ERROR", { ... }); // output fail → 500
+  }
+  return result.value;
+}
+```
+
+### 2e. Output serialization + response building
+```js
+// openapi.BB-W-NKv.mjs:48  (compact)
+encode(output, procedure) {
+  const successStatus = ...; // 200 default
+  return { status: successStatus, headers: {}, body: this.serializer.serialize(output) };
+}
+encodeError(error) {
+  return { status: error.status, headers: {},
+           body: this.serializer.serialize(error.toJSON(), { outputFormat: "plain" }) };
+}
+```
+The `{status, headers, body}` "standard response" is then turned into a real `Response` by the
+adapter (§6).
+
+---
+
+## 3. The genuinely hard parts — and do WE need them?
+
+| oRPC machinery | What it does | Where | Do WE need it (plain JSON OpenAPI + orval)? |
+|---|---|---|---|
+| **super-JSON RPC codec** (Date/Map/Set/bigint/File round-trip with a `meta` side-channel) | Lossless typed serialization for the **RPC** protocol | `@orpc/client` RPC codec (NOT in openapi) | **NO.** This is the RPC protocol. Standard OpenAPI uses plain JSON. |
+| **`StandardOpenAPIJsonSerializer`** (one-way JSON normalize: Date→ISO, Set→array, Map→entries, bigint/URL/RegExp→string, NaN→null, Blob detect) | Down-converts rich JS values to JSON-safe values **for output** | `openapi-client.B2Q9qU5m.mjs:8` | **Barely.** ~45 LOC, trivial to copy if our handlers ever return `Date`/`Set`. For pure JSON in/out you can even use `JSON.stringify`. Keep as a tiny optional helper. |
+| **Bracket-notation encode/decode** (`a[b][0]=x` ↔ nested object/array) | Encodes nested objects/arrays into flat query/form keys, decodes back | `openapi-client.t9fCAe3x.mjs` (~146 LOC) | **MOSTLY NO.** Only matters for **nested objects in query strings or form fields**. If our query params are flat scalars (the common REST case), `URLSearchParams` is enough. This is the single fiddliest file (push-style `a[]=` arrays, array→object promotion, escaping). Skip until a user actually nests query objects. |
+| **String→typed coercion of params** | `"123"`→`123`, `"true"`→`true` for path/query | **Not done by oRPC core** — see note below | **YES eventually, but it's on the schema side.** The bracket/JSON deserializers return **strings**. oRPC relies on the *schema converter / schema library* to coerce (e.g. zod's coercion, or oRPC's experimental input-coercion plugin). For us: use `z.coerce.*` (or valibot equivalents) in `inputSchema`, OR add a coercion pass. **MVP can punt** if path/query inputs are already strings or you coerce in schema. |
+| **multipart / file uploads** | `File`/`Blob` in request/response, content-disposition | `standard-server` + serializers | **NO (MVP).** Defer. Long-tail only if you serve binary. |
+| **streaming / event-iterator / SSE** | Async-generator handlers → `text/event-stream`, keepalive, resume via `last-event-id` | `@orpc/standard-server` `index.mjs` (~268 LOC) | **NO (MVP).** Big chunk of oRPC, entirely skippable unless we add streaming endpoints. |
+| **content-type negotiation** (JSON / form-urlencoded / multipart / event-stream / text / blob) | Picks a body parser by `content-type` | `standard-server-fetch` `toStandardBody` | **MINIMAL.** We only need `application/json` (+ maybe form-urlencoded). ~10 LOC. |
+| **"detailed" input/output structures** | `{params, query, headers, body}` in, `{status, headers, body}` out | codec + spec-gen | **NO (MVP).** Default is "compact"; detailed is opt-in. Skip unless a handler needs custom status/headers. |
+| **lazy / contract-first routers, hibernation, plugins, batch, peer, ws** | Code-splitting routers, durable-object hibernation, request batching, websockets | server core + plugins | **NO.** Not applicable to a simple function registry. |
+
+**Net:** the only "hard part" that is even arguably on our path is **bracket-notation nested
+query/form** and **param coercion**, and both are deferrable / schema-side. Everything else big in
+oRPC is RPC-protocol or edge-feature surface area we don't touch.
+
+---
+
+## 4. Error handling → HTTP status
+
+`ORPCError` (`@orpc/client/dist/shared/client.D9eWXdBV.mjs:91`) carries `{defined, code, status,
+message, data}`. Status is resolved from a fixed table:
+
+```js
+// client.D9eWXdBV.mjs:6  (COMMON_ORPC_ERROR_DEFS)
+BAD_REQUEST:400, UNAUTHORIZED:401, FORBIDDEN:403, NOT_FOUND:404, METHOD_NOT_SUPPORTED:405,
+NOT_ACCEPTABLE:406, TIMEOUT:408, CONFLICT:409, PRECONDITION_FAILED:412, PAYLOAD_TOO_LARGE:413,
+UNSUPPORTED_MEDIA_TYPE:415, UNPROCESSABLE_CONTENT:422, TOO_MANY_REQUESTS:429,
+CLIENT_CLOSED_REQUEST:499, INTERNAL_SERVER_ERROR:500, NOT_IMPLEMENTED:501, BAD_GATEWAY:502,
+SERVICE_UNAVAILABLE:503, GATEWAY_TIMEOUT:504
+```
+
+```js
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function isORPCErrorStatus(status) { return status < 200 || status >= 400; } // "this is an error response"
+```
+
+Error response body is `error.toJSON()`:
+```js
+toJSON() { return { defined: this.defined, code: this.code, status: this.status,
+                    message: this.message, data: this.data }; }
+```
+
+Validation errors specifically:
+- **Input** invalid → `ORPCError("BAD_REQUEST")` (400), `data.issues = [...standard-schema issues]`.
+- **Output** invalid → `ORPCError("INTERNAL_SERVER_ERROR")` (500).
+- **Malformed body / decode failure** → `BAD_REQUEST` (400).
+- Unknown thrown value → `toORPCError` wraps to `INTERNAL_SERVER_ERROR` (500).
+
+This whole subsystem is ~80 trivial LOC to own. We'd define our own `FnError` (or reuse this
+shape — it's a clean JSON contract orval-side already understands as just a JSON error body).
+
+---
+
+## 5. OpenAPI spec generation — and its coupling to serving
+
+`OpenAPIGenerator.generate(router, opts)` (`openapi.BwdtJjDu.mjs:504`) walks the router/contract,
+and for each procedure builds an OpenAPI 3.1.1 operation:
+- `method` from `route.method` (default POST), `path` from `route.path` → `toOpenAPIPath`.
+- **request**: converts `inputSchema` (Standard Schema) → JSON Schema via a pluggable
+  `CompositeSchemaConverter`, then splits it into **path params / query params / requestBody** based
+  on input structure + dynamic params + GET-vs-body. (`#request`, lines 647-740.)
+- **responses**: success response from `outputSchema` (`#successResponse`), plus an error response
+  per status derived from the contract's `errorMap` (`#errorResponse`).
+- finally `serializer.serialize(doc)` and returns the doc.
+
+The non-trivial weight here is the **JSON-Schema massaging** (lines 53-485): `LOGIC_KEYWORDS`,
+`isAnySchema`/`isNeverSchema`, `separateObjectSchema` (pull path params out of the body schema),
+`filterSchemaBranches` (peel `File` schemas into `multipart/form-data`), `simplifyComposedObjectJson
+SchemasAndRefs` (flatten anyOf/oneOf/allOf of objects), `expandUnionSchema`, deepObject-vs-explode
+decisions in `toOpenAPIParameters`. That's where the ~880 LOC goes.
+
+**BUT:** the generator needs a **schema converter** that turns *your* schema library into JSON
+Schema. oRPC ships separate `@orpc/zod`, `@orpc/valibot`, `@orpc/arktype` converter packages for
+that — the core generator is converter-agnostic (`CompositeSchemaConverter`).
+
+**Coupling verdict:**
+- **Spec-gen and the handler are fully decoupled.** `OpenAPIGenerator` lives in `@orpc/openapi`
+  alongside the handler but shares only small helpers (`toOpenAPIPath`, `standardizeHTTPPath`,
+  `getDynamicParams`). You can run the generator without ever serving, and serve without the
+  generator (the handler matches on routes, not on the spec).
+- For **us**: we need a spec for orval no matter what. We have two clean options:
+  1. **Own a minimal spec-gen** that handles only our supported schema shapes (objects of scalars +
+     nested objects/arrays). With a single fixed schema lib (say zod via `zod-to-json-schema`, which
+     aftrak already has) this is far less code than oRPC's library-agnostic monster — because we skip
+     the `File`/multipart/event-stream/detailed-structure branches and the union-flattening for
+     params.
+  2. **Reuse oRPC's `OpenAPIGenerator` + its zod converter** purely as a build-time dep, and still
+     own serving. Spec-gen is the part most worth *not* reinventing if we want broad schema support;
+     serving is the part most worth owning.
+
+---
+
+## 6. Adapter layer — framework-agnostic ↔ platform Request/Response
+
+The boundary is the **"standard request/response"** shape: a plain object
+`{ url:URL, method, headers, signal, body():Promise<...> }` in, `{ status, headers, body }` out.
+Adapters are thin translators. The fetch adapter:
+
+```js
+// @orpc/server/dist/adapters/fetch/index.mjs (FetchHandler.handle)
+const standardRequest = toStandardLazyRequest(request);              // Request -> standard
+const result = await this.standardHandler.handle(standardRequest, options);
+if (!result.matched) return result;
+return { matched: true, response: toFetchResponse(result.response) }; // standard -> Response
+```
+
+```js
+// @orpc/standard-server-fetch/dist/index.mjs:253 / :280
+function toStandardLazyRequest(request) {
+  return { url: new URL(request.url), signal: request.signal, method: request.method,
+           body: once(() => toStandardBody(request, { signal: request.signal })),
+           get headers() { ... toStandardHeaders(request.headers) ... } };
+}
+function toFetchResponse(response) {
+  const headers = toFetchHeaders(response.headers);
+  const body = toFetchBody(response.body, headers);   // JSON.stringify / FormData / stream / blob
+  return new Response(body, { headers, status: response.status });
+}
+```
+
+`toStandardBody` is the content-type switch (JSON/FormData/URLSearchParams/SSE/text/blob);
+`toFetchBody` picks an outgoing encoding (string JSON / FormData / ReadableStream for SSE / Blob).
+For **us**, this entire adapter collapses to: read `await request.json()` (or text + JSON.parse),
+read `request.headers`, `new URL(request.url)`; and on the way out `new Response(JSON.stringify(body),
+{status, headers:{'content-type':'application/json'}})`. The node adapter is the same idea over
+`IncomingMessage`/`ServerResponse`. **~30-50 LOC each, trivial.**
+
+---
+
+## 7. Size / effort estimate
+
+### LOC of each relevant oRPC piece (dist `.mjs`, v1.14.6)
+| Piece | LOC |
+|---|---|
+| OpenAPI handler (matcher + codec + handler class) | ~205 |
+| OpenAPI spec generator + schema massaging | ~880 |
+| StandardHandler engine (incl. interceptors/spans) | ~226 |
+| validate/middleware/procedure-client shared | ~418 |
+| OpenAPI JSON serializer + serializer wrapper + link codec | ~302 |
+| bracket-notation serializer | ~146 |
+| `ORPCError` + status table + helpers | ~150 (we'd use ~80) |
+| standard-server (SSE/headers/content-disposition) | ~268 |
+| standard-server-fetch adapter | ~300 |
+| fetch server adapter | ~167 |
+
+Most of those LOC are RPC-protocol, edge-features, OTel spans, interceptor plumbing, and
+library-agnostic schema gymnastics that **we don't need**.
+
+### What WE'D actually build for the MVP (standard JSON OpenAPI)
+A minimal owned handler that: matches route+method, parses JSON body + path + query params,
+validates input via Standard Schema, calls our fn, validates output, maps errors→status, returns
+JSON.
+
+| MVP component | Est. LOC | Notes |
+|---|---|---|
+| Route table + matcher | 40-100 | Use `rou3` (same dep oRPC uses) or a small regex matcher. `{id}`→`:id`. |
+| Request decode (JSON body + query→object + merge path params) | 30 | `await req.json()`, `Object.fromEntries(url.searchParams)`, merge. |
+| Standard-Schema input validation → 400 w/ issues | 20 | `schema['~standard'].validate(input)`. |
+| Call handler | 5 | |
+| Standard-Schema output validation → 500 | 15 | optional |
+| Error → status mapping + JSON error body | 40 | copy the status table + `toJSON` shape. |
+| Response build (`new Response(JSON.stringify(...))`) | 20 | |
+| fetch + node adapters | 60-100 | two thin translators. |
+| **MVP total** | **~250-400 LOC** | ~**0.5-1 day**. |
+
+### The long tail (add only when a real feature needs it)
+| Feature | Est. effort | Trigger |
+|---|---|---|
+| String→typed coercion of path/query params | ~0.5 day (or free via `z.coerce`) | non-string scalar params |
+| Bracket-notation nested query/form decode | ~1 day (port oRPC's ~146 LOC) | nested objects in query/form |
+| Rich-type output normalization (Date/Set/Map/bigint) | ~0.5 day (port ~45 LOC) | handlers returning rich JS types |
+| Multipart / file upload + download | 1-2 days | binary endpoints |
+| SSE / streaming / event-iterators | 2-4 days | streaming endpoints (this is a real chunk) |
+| Detailed input/output (custom status/headers per route) | ~1 day | per-route status/header control |
+| **OpenAPI spec generation** | 2-4 days to own well, OR ~0 days reusing `@orpc/openapi`+`@orpc/zod` build-time | orval needs a spec regardless |
+
+---
+
+## Recommendation: own the handler, decide spec-gen separately
+
+1. **Own the HTTP handler.** It is ~250-400 LOC for a fully standard JSON/OpenAPI experience and
+   removes the "we're just an oRPC wrapper" concern. oRPC's serving size is dominated by its **RPC
+   protocol** and **edge features we don't use**. Owning it also lets the `{name, description,
+   inputSchema, outputSchema, route, handler}` shape stay our own native concept instead of being
+   marshalled through oRPC contracts/procedures.
+
+2. **Do NOT adopt the RPC stack** (`RPCHandler`/`RPCLink`/super-JSON codec). It's irrelevant to
+   orval-consumes-OpenAPI and is the single biggest source of oRPC complexity.
+
+3. **Spec generation is the one place to think twice.** It's decoupled from serving, and orval needs
+   a spec from us either way. Two viable paths:
+   - *Lean & owned*: a focused generator over a single schema lib (e.g. zod →
+     `zod-to-json-schema`) covering objects/scalars/nested — much smaller than oRPC's
+     library-agnostic generator because we drop File/multipart/SSE/detailed/union-param branches.
+   - *Reuse at build time*: depend on `@orpc/openapi` + `@orpc/<schemalib>` only as a dev/build
+     dependency to emit the spec, while still owning runtime serving. This keeps us off oRPC at
+     runtime entirely (no oRPC in the server request path or the shipped client).
+
+4. **Borrow, don't depend, for the small gnarly bits.** The error/status table (~80 LOC), the
+   JSON-normalize serializer (~45 LOC), and (later) bracket-notation (~146 LOC) are clean,
+   self-contained, MIT-licensed files we can port verbatim when/if needed — no runtime dependency.
+
+5. **Keep `rou3`** as a tiny external dependency for routing (it's well-tested, ~a few KB, and oRPC
+   itself relies on it) unless you prefer a hand-rolled matcher.
+
+**Bottom line:** owning the standard-OpenAPI HTTP layer is a low-risk ~1-day MVP. The scary-looking
+size of oRPC is mostly its RPC protocol and optional features. The only piece with real ongoing cost
+is the spec generator, and that is independently swappable — you can own serving today and decide on
+spec-gen (own vs. build-time-reuse) separately.