@deepseek-insight/dsi 0.5.5

package/build/client/_app/version.json

@@ -0,0 +1 @@
+{"version":"1789100088232"}

package/build/client/favicon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+	<rect width="32" height="32" rx="7" fill="#41476D" />
+	<path d="M16 7c-4.97 0-9 3.8-9 8.49 0 2.63 1.26 4.98 3.23 6.54l.03 3.22c.01.38.44.6.76.4l3.17-1.99c.59.08 1.2.13 1.81.13 4.97 0 9-3.8 9-8.49S20.97 7 16 7z" fill="#fff" />
+	<circle cx="12.2" cy="15.6" r="1.5" fill="#41476D" />
+	<circle cx="16" cy="15.6" r="1.5" fill="#41476D" />
+	<circle cx="19.8" cy="15.6" r="1.5" fill="#41476D" />
+</svg>

package/build/env.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+// since env.js is an entrypoint, `dir` will point to the output directory
+const dir = path.dirname(fileURLToPath(import.meta.url));
+
+const expected_unprefixed = new Set(['LISTEN_PID', 'LISTEN_FDS']);
+
+const env_prefix = "";
+
+/**
+ * @param {string} name
+ * @param {any} [fallback]
+ */
+function env(name, fallback) {
+	const prefix = expected_unprefixed.has(name) ? '' : env_prefix;
+	const prefixed = prefix + name;
+	return prefixed in process.env ? process.env[prefixed] : fallback;
+}
+
+const integer_regexp = /^\d+$/;
+
+/**
+ * Throw a consistently-structured parsing error for environment variables.
+ * @param {string} name
+ * @param {any} value
+ * @param {string} description
+ * @returns {never}
+ */
+function parsing_error(name, value, description) {
+	throw new Error(
+		`Invalid value for environment variable ${name}: ${JSON.stringify(value)} (${description})`
+	);
+}
+
+/**
+ * Check the environment for a timeout value (non-negative integer) in seconds.
+ * @param {string} name
+ * @param {number} [fallback]
+ * @returns {number | undefined}
+ */
+function timeout_env(name, fallback) {
+	const raw = env(name, fallback);
+	if (!raw) {
+		return fallback;
+	}
+
+	if (!integer_regexp.test(raw)) {
+		parsing_error(name, raw, 'should be a non-negative integer');
+	}
+
+	const parsed = Number.parseInt(raw, 10);
+
+	// We don't technically need to check `Number.isNaN` because the value already passed the regexp test.
+	// However, just in case there's some new codepath introduced somewhere down the line, it's probably good
+	// to stick this in here.
+	if (Number.isNaN(parsed)) {
+		parsing_error(name, raw, 'should be a non-negative integer');
+	}
+
+	if (parsed < 0) {
+		parsing_error(name, raw, 'should be a non-negative integer');
+	}
+
+	return parsed;
+}
+
+export { dir, env, env_prefix, timeout_env };
+//# sourceMappingURL=env.js.map

package/build/handler.js

@@ -0,0 +1,23 @@
+import './shims.js';
+import 'node:fs';
+import 'node:path';
+import 'node:process';
+export { h as handler } from './server/chunks/handler-BshnD4Y4.js';
+import './server/chunks/index.js-I_pMeIwQ.js';
+import './server/chunks/manifest.js-DwhpAk_y.js';
+import './env.js';
+import 'node:buffer';
+import 'node:crypto';
+import 'node:http';
+import 'node:timers';
+import 'node:querystring';
+import 'node:stream';
+import './server/chunks/chunks/shared.js-C4-Py8s_.js';
+import './server/chunks/chunks/uneval.js-BJ9Qq2SF.js';
+import './server/chunks/chunks/utils.js-tOWCe9Wk.js';
+import 'node:url';
+import './server/chunks/chunks/internal.js-CQzEjdyk.js';
+import './server/chunks/chunks/server.js-DoCd0fEo.js';
+import './server/chunks/chunks/internal2.js-D-DAuSVh.js';
+import './server/chunks/chunks/exports.js-DMiPee3x.js';
+//# sourceMappingURL=handler.js.map

package/build/index.js

@@ -0,0 +1,146 @@
+import http from 'node:http';
+import fs__default from 'node:fs';
+import process from 'node:process';
+import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-BshnD4Y4.js';
+import { env, timeout_env } from './env.js';
+import { rm } from 'node:fs/promises';
+import './shims.js';
+import 'node:buffer';
+import 'node:crypto';
+import 'node:path';
+import 'node:timers';
+import 'node:querystring';
+import 'node:stream';
+import './server/chunks/chunks/shared.js-C4-Py8s_.js';
+import './server/chunks/chunks/uneval.js-BJ9Qq2SF.js';
+import './server/chunks/chunks/utils.js-tOWCe9Wk.js';
+import './server/chunks/index.js-I_pMeIwQ.js';
+import './server/chunks/chunks/internal.js-CQzEjdyk.js';
+import './server/chunks/chunks/server.js-DoCd0fEo.js';
+import './server/chunks/chunks/internal2.js-D-DAuSVh.js';
+import './server/chunks/chunks/exports.js-DMiPee3x.js';
+import './server/chunks/manifest.js-DwhpAk_y.js';
+import 'node:url';
+
+const path = env('SOCKET_PATH', false);
+const host = env('HOST', '0.0.0.0');
+const port = env('PORT', !path && '3000');
+
+const shutdown_timeout = parseInt(env('SHUTDOWN_TIMEOUT', '30'));
+const idle_timeout = parseInt(env('IDLE_TIMEOUT', '0'));
+const listen_pid = parseInt(env('LISTEN_PID', '0'));
+const listen_fds = parseInt(env('LISTEN_FDS', '0'));
+// https://www.freedesktop.org/software/systemd/man/latest/sd_listen_fds.html
+const SD_LISTEN_FDS_START = 3;
+
+if (listen_pid !== 0 && listen_pid !== process.pid) {
+	throw new Error(`received LISTEN_PID ${listen_pid} but current process id is ${process.pid}`);
+}
+if (listen_fds > 1) {
+	throw new Error(
+		`only one socket is allowed for socket activation, but LISTEN_FDS was set to ${listen_fds}`
+	);
+}
+
+const socket_activation = listen_pid === process.pid && listen_fds === 1;
+
+let requests = 0;
+/** @type {NodeJS.Timeout | void} */
+let shutdown_timeout_id;
+/** @type {NodeJS.Timeout | void} */
+let idle_timeout_id;
+
+// Initialize the HTTP server here so that we can set properties before starting to listen.
+// Otherwise, polka delays creating the server until listen() is called. Settings these
+// properties after the server has started listening could lead to race conditions.
+const httpServer = http.createServer();
+
+const keep_alive_timeout = timeout_env('KEEP_ALIVE_TIMEOUT');
+if (keep_alive_timeout !== undefined) {
+	// Convert the keep-alive timeout from seconds to milliseconds (the unit Node.js expects).
+	httpServer.keepAliveTimeout = keep_alive_timeout * 1000;
+}
+
+const headers_timeout = timeout_env('HEADERS_TIMEOUT');
+if (headers_timeout !== undefined) {
+	// Convert the headers timeout from seconds to milliseconds (the unit Node.js expects).
+	httpServer.headersTimeout = headers_timeout * 1000;
+}
+
+const server = polka({ server: httpServer }).use(handler);
+
+if (socket_activation) {
+	server.listen({ fd: SD_LISTEN_FDS_START }, () => {
+		console.log(`Listening on file descriptor ${SD_LISTEN_FDS_START}`);
+	});
+} else {
+	if (path) {
+		try {
+			if (fs__default.statSync(path).size === 0) {
+				await rm(path);
+			}
+		} catch {
+			// ignore
+		}
+	}
+
+	server.listen({ path, host, port }, () => {
+		console.log(`Listening on ${format_listening_address(path, host, port, httpServer.address())}`);
+	});
+}
+
+/** @param {'SIGINT' | 'SIGTERM' | 'IDLE'} reason */
+function graceful_shutdown(reason) {
+	if (shutdown_timeout_id) return;
+
+	// If a connection was opened with a keep-alive header close() will wait for the connection to
+	// time out rather than close it even if it is not handling any requests, so call this first
+	httpServer.closeIdleConnections();
+
+	httpServer.close((error) => {
+		// occurs if the server is already closed
+		if (error) return;
+
+		if (shutdown_timeout_id) {
+			clearTimeout(shutdown_timeout_id);
+		}
+		if (idle_timeout_id) {
+			clearTimeout(idle_timeout_id);
+		}
+
+		// @ts-expect-error custom events cannot be typed
+		process.emit('sveltekit:shutdown', reason);
+	});
+
+	shutdown_timeout_id = setTimeout(() => httpServer.closeAllConnections(), shutdown_timeout * 1000);
+}
+
+httpServer.on(
+	'request',
+	/** @param {import('node:http').IncomingMessage} req */
+	(req) => {
+		requests++;
+
+		if (socket_activation && idle_timeout_id) {
+			idle_timeout_id = clearTimeout(idle_timeout_id);
+		}
+
+		req.on('close', () => {
+			requests--;
+
+			if (shutdown_timeout_id) {
+				// close connections as soon as they become idle, so they don't accept new requests
+				httpServer.closeIdleConnections();
+			}
+			if (requests === 0 && socket_activation && idle_timeout) {
+				idle_timeout_id = setTimeout(() => graceful_shutdown('IDLE'), idle_timeout * 1000);
+			}
+		});
+	}
+);
+
+process.on('SIGTERM', graceful_shutdown);
+process.on('SIGINT', graceful_shutdown);
+
+export { host, path, port, server };
+//# sourceMappingURL=index.js.map

package/build/server/chunks/chunks/a2a-protocol.js-C77mVg2Q.js

@@ -0,0 +1,52 @@
+//#region src/lib/services/chat/a2a-protocol.ts
+/** Minted id shape: `a2a-` + 16 lowercase hex chars (crypto random). */
+var MINT_HEX_CHARS = 16;
+/** The leading signature token: `***;` + the message after it. */
+var SIGNATURE_RE = new RegExp(`^_a2a_:(a2a-[0-9a-f]{1,64});\\s*([\\s\\S]*)$`, "i");
+/** Mint a fresh correlation id: `a2a-` + 16 hex from crypto random. */
+function mintA2aId() {
+	const bytes = new Uint8Array(MINT_HEX_CHARS / 2);
+	crypto.getRandomValues(bytes);
+	return `a2a-${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* Parse a leading `_a2a_:<id>;` token off a composer message.
+* Returns null when the token is absent, malformed (missing `;`, empty id,
+* non-hex id), or not leading — a signature mid-prose is never plumbing
+* (ADR §4 Trial A: prose echoes are the model's output, not the sender's).
+* Case-tolerant on marker and id; the id is normalized to lowercase.
+*/
+function parseA2aSignature(text) {
+	const m = SIGNATURE_RE.exec(text.trim());
+	if (m === null) return null;
+	return {
+		id: m[1].toLowerCase(),
+		message: m[2].trim()
+	};
+}
+/** The Trial-B instruction sentence (ADR §3 — mandatory injection). */
+function protocolSentence(id) {
+	return `Protocol: end your reply with exactly this signature as the final characters: _a2a_:${id};`;
+}
+/**
+* Append the Trial-B protocol line to a message (ADR §3: the delivered
+* message carries exactly one instruction line). A terminal period joins
+* unless the message already ends in punctuation; an empty message
+* delivers the protocol line alone.
+*/
+function injectProtocolLine(message, id) {
+	const m = message.trim();
+	if (m === "") return protocolSentence(id);
+	return `${m}${/[.!?]$/.test(m) ? " " : ". "}${protocolSentence(id)}`;
+}
+/**
+* Build the text actually delivered to the target session (Task 3.3's POST
+* body): strip any leading signature token, then inject the protocol line
+* for the id the ledger will track (minted or user-supplied).
+*/
+function buildDeliveredText(message, id) {
+	return injectProtocolLine(parseA2aSignature(message)?.message ?? message.trim(), id);
+}
+
+export { buildDeliveredText as b, mintA2aId as m, parseA2aSignature as p };
+//# sourceMappingURL=a2a-protocol.js-C77mVg2Q.js.map

package/build/server/chunks/chunks/app-config.svelte.js-Co9jacqT.js

@@ -0,0 +1,52 @@
+import { D as DEFAULT_SIDEBAR_PLACEMENT, a as DEFAULT_PANEL_MAX_ZOOM, b as DEFAULT_PANEL_MIN_ZOOM, c as DEFAULT_A2A_WATCH_TIMEOUT_MS, d as DEFAULT_A2A_FAST_POLL_MS, e as DEFAULT_HOME_REFRESH_MS, f as DEFAULT_STATS_BAR_MODE, g as DEFAULT_POLL_IDLE_MS, h as DEFAULT_ACCESS_CONFIRM_TIMEOUT_MS } from './config.js-BBYogCe7.js';
+
+//#region src/lib/services/config/app-config.svelte.ts
+function freshDefault() {
+	return {
+		chat: {
+			input: { maxRows: 15 },
+			accessConfirmTimeoutMs: DEFAULT_ACCESS_CONFIRM_TIMEOUT_MS,
+			macro: {
+				maxLines: 25,
+				maxDepth: 3
+			}
+		},
+		conversation: {
+			pollRunningMs: 500,
+			pollIdleMs: DEFAULT_POLL_IDLE_MS,
+			statsBar: DEFAULT_STATS_BAR_MODE,
+			collapsable: false,
+			progressiveFold: false
+		},
+		home: { refreshMs: DEFAULT_HOME_REFRESH_MS },
+		a2a: {
+			fastPollMs: DEFAULT_A2A_FAST_POLL_MS,
+			watchTimeoutMs: DEFAULT_A2A_WATCH_TIMEOUT_MS,
+			retentionDays: 90
+		},
+		panel: {
+			defaultWidth: 730,
+			minWidth: 480,
+			maxWidth: 860,
+			minZoom: DEFAULT_PANEL_MIN_ZOOM,
+			maxZoom: DEFAULT_PANEL_MAX_ZOOM
+		},
+		sidebar: {
+			defaultWidth: 280,
+			minWidth: 200,
+			maxWidth: 500,
+			placement: DEFAULT_SIDEBAR_PLACEMENT
+		}
+	};
+}
+var config = freshDefault();
+/**
+* Reactive config view. Read it inside an $effect/$derived — it updates
+* when the load lands (e.g. the prompt clamp re-measures on arrival).
+*/
+function appConfig() {
+	return config;
+}
+
+export { appConfig as a };
+//# sourceMappingURL=app-config.svelte.js-Co9jacqT.js.map

package/build/server/chunks/chunks/config.js-BBYogCe7.js

@@ -0,0 +1,123 @@
+/** DSH Host base URL; override with DSH_BASE_URL (tests, alternate hosts). */
+function dshBaseUrl() {
+	return process.env.DSH_BASE_URL || "http://127.0.0.1:3080";
+}
+/** `chat.accessConfirmTimeoutMs` default — how long the access chip waits
+*  for knob events after a successful /permission POST before clearing the
+*  pick with an honest "switch not confirmed" note. */
+var DEFAULT_ACCESS_CONFIRM_TIMEOUT_MS = 12e3;
+var DEFAULT_POLL_IDLE_MS = 2e3;
+/** `conversation.statsBar` default — the whole-ledger truth. */
+var DEFAULT_STATS_BAR_MODE = "full-ledger";
+/** Literal gate for `conversation.statsBar`: only the two known strings
+*  pass; anything else falls back to the default (same shape as
+*  resolveSidebarPlacement). Both config readers run it. */
+function resolveStatsBarMode(v) {
+	return v === "partial" || v === "full-ledger" ? v : DEFAULT_STATS_BAR_MODE;
+}
+/**
+* Boolean gates for the fold flags (ADR-0010 D2/A1): only strict booleans
+*  pass; a missing section or non-boolean key falls back to its default.
+*  Same discipline as resolveStatsBarMode — both config readers run it.
+*
+* @param v the raw `conversation` config section
+* @returns the resolved collapsable/progressiveFold pair
+*/
+function resolveConversationFlags(v) {
+	const rec = isConfigRecord(v) ? v : {};
+	return {
+		collapsable: typeof rec.collapsable === "boolean" ? rec.collapsable : false,
+		progressiveFold: typeof rec.progressiveFold === "boolean" ? rec.progressiveFold : false
+	};
+}
+/** `home.refreshMs` default — home list + spine refresh cadence (BC-7). */
+var DEFAULT_HOME_REFRESH_MS = 5e3;
+/** `a2a.fastPollMs` default — LIST-lane tick (ONE batched session.list for
+*  all waiting targets). 0 = fast lane OFF: the spine's own ~5s cadence
+*  (home.refreshMs) is the only motion — the kill-switch (PRD risk 3). */
+var DEFAULT_A2A_FAST_POLL_MS = 1e3;
+/** `a2a.watchTimeoutMs` default — deadline before an honest `timeout`
+*  settle (silence is never failure; the row keeps the error text). */
+var DEFAULT_A2A_WATCH_TIMEOUT_MS = 6e5;
+/** Resolve the whole `a2a` section at once — the single gate site both
+*  readers share (server read + browser apply): fastPollMs int [0, 60000]
+*  (0 disables the fast lane → spine cadence), watchTimeoutMs int
+*  [60000, 3600000], retentionDays int [1, 3650]; every miss reverts to
+*  its default. A non-record section is just three misses. */
+function resolveA2aConfig(section) {
+	const rec = isConfigRecord(section) ? section : {};
+	return {
+		fastPollMs: intWithin(rec.fastPollMs, 0, 6e4, DEFAULT_A2A_FAST_POLL_MS),
+		watchTimeoutMs: intWithin(rec.watchTimeoutMs, 6e4, 36e5, DEFAULT_A2A_WATCH_TIMEOUT_MS),
+		retentionDays: intWithin(rec.retentionDays, 1, 3650, 90)
+	};
+}
+var DEFAULT_PANEL_MIN_ZOOM = .25;
+var DEFAULT_PANEL_MAX_ZOOM = 1.25;
+/** `sidebar.placement` default — the out-of-zoom rail (by-design layout). */
+var DEFAULT_SIDEBAR_PLACEMENT = "none";
+/**
+* Placement literal gate: only the two known strings pass; missing,
+* typo'd, or foreign values fall back to the default. The exact same
+* gate runs server-side (readSidebarConfig) and client-side
+* (applyConfig) — a stale or foreign /api/config body can never smuggle
+* an unknown mode past the store.
+*/
+function resolveSidebarPlacement(v) {
+	return v === "panels-zoom" || v === "none" ? v : DEFAULT_SIDEBAR_PLACEMENT;
+}
+/** Integer within [min, max], else the fallback. */
+function intWithin(v, min, max, fallback) {
+	return typeof v === "number" && Number.isInteger(v) && v >= min && v <= max ? v : fallback;
+}
+/** Finite number within [min, max], else the fallback. */
+function numWithin(v, min, max, fallback) {
+	return typeof v === "number" && Number.isFinite(v) && v >= min && v <= max ? v : fallback;
+}
+/**
+* Resolve a width-bounds triple (panel or sidebar) from a config section:
+* bounds must be integers in [pxMin, pxMax] and crossed bounds (min > max)
+* revert BOTH to defaults (never an inverted clamp). defaultWidth accepts
+* any finite number and CLAMPS into the resolved bounds — the operator's
+* "tighten" intent survives, exactly like the use-site clamp would.
+*/
+function resolveWidthBounds(section, dflt, pxMin, pxMax) {
+	const rec = isConfigRecord(section) ? section : {};
+	let minWidth = intWithin(rec.minWidth, pxMin, pxMax, dflt.minWidth);
+	let maxWidth = intWithin(rec.maxWidth, pxMin, pxMax, dflt.maxWidth);
+	if (minWidth > maxWidth) {
+		minWidth = dflt.minWidth;
+		maxWidth = dflt.maxWidth;
+	}
+	const rawDefault = rec.defaultWidth;
+	const defaultWidth = typeof rawDefault === "number" && Number.isFinite(rawDefault) ? rawDefault : dflt.defaultWidth;
+	return {
+		minWidth,
+		maxWidth,
+		defaultWidth: Math.max(minWidth, Math.min(maxWidth, defaultWidth))
+	};
+}
+/**
+* Resolve a zoom-bounds pair: finite numbers in [zMin, zMax]; crossed
+* (min > max) reverts both to defaults.
+*/
+function resolveZoomBounds(section, dfltMin, dfltMax, zMin, zMax) {
+	const rec = isConfigRecord(section) ? section : {};
+	let minZoom = numWithin(rec.minZoom, zMin, zMax, dfltMin);
+	let maxZoom = numWithin(rec.maxZoom, zMin, zMax, dfltMax);
+	if (minZoom > maxZoom) {
+		minZoom = dfltMin;
+		maxZoom = dfltMax;
+	}
+	return {
+		minZoom,
+		maxZoom
+	};
+}
+/** POX guard: is this a plain object (not array/null)? Config sections only. */
+function isConfigRecord(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+export { DEFAULT_SIDEBAR_PLACEMENT as D, DEFAULT_PANEL_MAX_ZOOM as a, DEFAULT_PANEL_MIN_ZOOM as b, DEFAULT_A2A_WATCH_TIMEOUT_MS as c, DEFAULT_A2A_FAST_POLL_MS as d, DEFAULT_HOME_REFRESH_MS as e, DEFAULT_STATS_BAR_MODE as f, DEFAULT_POLL_IDLE_MS as g, DEFAULT_ACCESS_CONFIRM_TIMEOUT_MS as h, resolveSidebarPlacement as i, resolveWidthBounds as j, resolveZoomBounds as k, intWithin as l, resolveConversationFlags as m, resolveStatsBarMode as n, isConfigRecord as o, dshBaseUrl as p, resolveA2aConfig as r };
+//# sourceMappingURL=config.js-BBYogCe7.js.map

package/build/server/chunks/chunks/db.js-DcmO3JAx.js

@@ -0,0 +1,120 @@
+import { D as DSI_CONFIG_PATH } from './insight-config.js-CfMPTA6Z.js';
+import { mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+/**
+* Resolve the ledger path: explicit argument → `DSI_A2A_DB` env →
+* sibling of DSI_CONFIG_PATH (`~/.dsi/a2a.sqlite`).
+*/
+function resolveA2aDbPath(path) {
+	return process.env["DSI_A2A_DB"] ?? join(dirname(DSI_CONFIG_PATH), "a2a.sqlite");
+}
+var DDL = [`CREATE TABLE IF NOT EXISTS a2a_exchange (
+		id TEXT PRIMARY KEY,
+		from_session TEXT NOT NULL,
+		to_session TEXT NOT NULL,
+		message TEXT NOT NULL,
+		watermark_turn INTEGER NOT NULL,
+		watermark_seq INTEGER,
+		sent_at INTEGER NOT NULL,
+		state TEXT NOT NULL DEFAULT 'waiting',
+		reply_text TEXT,
+		reply_turn INTEGER,
+		settled_at INTEGER,
+		error TEXT
+	)`, `CREATE INDEX IF NOT EXISTS idx_a2a_waiting
+		ON a2a_exchange (sent_at)
+		WHERE state = 'waiting'`].join(";\n");
+/** v1→v2 (2026-08-25 bug fix): add watermark_seq to pre-fix ledgers. */
+var MIGRATE_V2 = `ALTER TABLE a2a_exchange ADD COLUMN watermark_seq INTEGER`;
+/**
+* Open (and ensure) the ledger. Idempotent: DDL re-runs safely, so a
+* second open of the same file is a no-op schema-wise (Task 2.1-T probe).
+*
+* Caching: an explicit `path` always returns a FRESH handle (test/tmp
+* isolation); the no-arg form memoizes one default handle per process —
+* the watcher and routes share it.
+*/
+var defaultDb = null;
+function openA2aDb(path) {
+	if (defaultDb !== null) return defaultDb;
+	const file = resolveA2aDbPath();
+	mkdirSync(dirname(file), { recursive: true });
+	const db = new DatabaseSync(file, { readOnly: false });
+	db.exec("PRAGMA journal_mode = WAL;");
+	db.exec(`${DDL};`);
+	try {
+		db.exec(MIGRATE_V2);
+	} catch {}
+	defaultDb = db;
+	return db;
+}
+function mapRow(r) {
+	return {
+		id: r.id,
+		fromSession: r.from_session,
+		toSession: r.to_session,
+		message: r.message,
+		watermarkTurn: r.watermark_turn,
+		watermarkSeq: r.watermark_seq ?? null,
+		sentAt: r.sent_at,
+		state: r.state,
+		replyText: r.reply_text ?? null,
+		replyTurn: r.reply_turn ?? null,
+		settledAt: r.settled_at ?? null,
+		error: r.error ?? null
+	};
+}
+/** INSERT one waiting row — the send itself (ADR §6: INSERT-at-send). */
+function insertWaiting(row, db = openA2aDb()) {
+	db.prepare(`INSERT INTO a2a_exchange
+			(id, from_session, to_session, message, watermark_turn, watermark_seq, sent_at, state)
+			VALUES (?, ?, ?, ?, ?, ?, ?, 'waiting')`).run(row.id, row.fromSession, row.toSession, row.message, row.watermarkTurn, row.watermarkSeq ?? null, row.sentAt);
+}
+/**
+* Settle a row — exactly once. Refuses: unknown id, a `waiting` target
+* state, or an already-terminal row (single-UPDATE guard: the WHERE
+* clause pins `state='waiting'`, so the database itself rejects any
+* second settle — no rewrites after settle, by construction).
+*/
+function settleRow(settle, db = openA2aDb()) {
+	const { id, state, replyText, replyTurn, error } = settle;
+	if (state === "waiting") throw new Error(`a2a settle refused for ${id}: 'waiting' is not a settle state`);
+	if (db.prepare(`UPDATE a2a_exchange
+				SET state = ?, reply_text = ?, reply_turn = ?, settled_at = ?, error = ?
+				WHERE id = ? AND state = 'waiting'`).run(state, replyText ?? null, replyTurn ?? null, Date.now(), error ?? null, id).changes !== 1) {
+		const current = db.prepare("SELECT state FROM a2a_exchange WHERE id = ?").get(id);
+		if (current === void 0) throw new Error(`a2a settle refused for ${id}: row not found`);
+		throw new Error(`a2a settle refused for ${id}: row is terminal ('${current.state}') — settled rows never change`);
+	}
+}
+/** All waiting rows, oldest first (the watcher's LIST-lane input). */
+function listWaiting(db = openA2aDb()) {
+	return db.prepare(`SELECT * FROM a2a_exchange WHERE state = 'waiting' ORDER BY sent_at ASC`).all().map(mapRow);
+}
+/** Recent rows, newest first — the read API's list (optional sender filter).
+* rowid DESC breaks same-ms ties: the later INSERT is the newer row. */
+function listRecent(limit = 20, fromSession, db = openA2aDb()) {
+	const sql = fromSession ? `SELECT * FROM a2a_exchange WHERE from_session = ? ORDER BY sent_at DESC, rowid DESC LIMIT ?` : `SELECT * FROM a2a_exchange ORDER BY sent_at DESC, rowid DESC LIMIT ?`;
+	const stmt = db.prepare(sql);
+	return (fromSession ? stmt.all(fromSession, limit) : stmt.all(limit)).map(mapRow);
+}
+/** One row or null. */
+function getRow(id, db = openA2aDb()) {
+	const r = db.prepare("SELECT * FROM a2a_exchange WHERE id = ?").get(id);
+	return r ? mapRow(r) : null;
+}
+/**
+* Retention (boot sweep only, W3): delete TERMINAL rows settled strictly
+* before the cutoff. Waiting rows are never pruned — an unresolved watch
+* outranks retention. Returns the number pruned.
+*/
+function pruneTerminalBefore(cutoffMs, db = openA2aDb()) {
+	const result = db.prepare(`DELETE FROM a2a_exchange
+				WHERE state != 'waiting' AND settled_at IS NOT NULL AND settled_at < ?`).run(cutoffMs);
+	return Number(result.changes);
+}
+
+export { listRecent as a, getRow as g, insertWaiting as i, listWaiting as l, openA2aDb as o, pruneTerminalBefore as p, settleRow as s };
+//# sourceMappingURL=db.js-DcmO3JAx.js.map