@deepseek-insight/dsi 0.5.5

package/build/server/chunks/chunks/watcher.js-BelxjMOP.js

@@ -0,0 +1,473 @@
+import { c as readA2aConfig } from './insight-config.js-CfMPTA6Z.js';
+import { i as insertWaiting, o as openA2aDb, s as settleRow, p as pruneTerminalBefore, l as listWaiting } from './db.js-DcmO3JAx.js';
+import { g as getDshConnection } from './dsh-connection.js-DwihVtk_.js';
+import { a as entryForEvent, h as historyToEvents } from './dsh-events.js-BtDxaV6Q.js';
+
+//#region src/lib/server/a2a/matcher.ts
+/**
+* Classify a completed reply text against a delegation signature id.
+*
+* Tier 1 'exact'   — the trimmed reply ENDS WITH `_a2a_:<id>;` (the
+*                    instructed echo). "Trimmed" tolerates trailing
+*                    whitespace AND trailing code fences (Task 2.2-T:
+*                    "whitespace/code-fence around suffix → exact after
+*                    trim" — LLMs close their fences after echoing).
+* Tier 2 'attributed' — `_a2a_:<id>` appears anywhere in the text
+*                    (echoed but not terminal — partial compliance).
+* Tier 3 'none'    — the signature is absent: watermark-crossed only;
+*                    the watcher records replied_approx (certainty-
+*                    named; never a confident claim).
+*
+* Case-tolerant on the `_a2a_` marker and the id (the composer may be
+* typed in any case; ids are lowercase-canonical at mint/parse).
+*/
+function classifyReply(replyText, id) {
+	const text = replyText.toLowerCase();
+	const needle = `_a2a_:${id.toLowerCase()}`;
+	let tail = text.trimEnd();
+	for (let i = 0; i < 3 && tail.endsWith("```"); i++) tail = tail.slice(0, -3).trimEnd();
+	if (tail.endsWith(needle + ";")) return "exact";
+	if (text.includes(needle)) return "attributed";
+	return "none";
+}
+//#endregion
+//#region src/lib/server/a2a/watcher.ts
+/**
+* a2a-watcher (2026-08-25) — the two-lane delegation watcher: a cheap
+* batched LIST every fastPollMs (ONE session.list per tick for ALL
+* waiting targets), and a LEDGER read (history tail) only when a gate
+* opens — a completed new turn. Zero model calls by construction: the
+* watcher only READS spine rows and the ledger; any prompt/RPC that runs
+* a model is outside these paths (3.1-T spy-asserts the absence).
+*
+* SEQ lane (2026-08-25 bug fix): live hosts ship no `sessionStats.turns`
+* and their list projection's updatedAt/running never move on replies —
+* the LIST gate is structurally dead there (probe-verified). Rows with a
+* captured `watermark_seq` (the target ledger's newest event seq at
+* send, from the register route) are probed on a throttled second lane:
+* one history read per DISTINCT target per A2A_SEQ_PROBE_MS window; the
+* newest assistant/message past the watermark settles the row at its
+* true tier. Zero model calls still hold — history is a read.
+*
+* SPAN capture (2026-08-25 RCA #2, live a2a-30b51db8): a turn is N
+* assistant bubbles (narration before tool calls + one final digest),
+* but the delivered protocol line binds only the END — so `reply_text`
+* holding just the newest message froze everything the target narrated
+* on the way. Settle now stores the JOINED text of every assistant
+* message in the exchange's span. The span anchor is the delivered
+* prompt itself (the user message carrying `_a2a_:<id>;` — unique per
+* delegation), NOT the register-time watermark: registration can land
+* seconds after the prompt, by which time the target has already
+* narrated past it. A LATER delegation's prompt bounds the span, so
+* stacked mentions never swallow each other's replies. Classification
+* is unchanged — the end-signature tier contract (ADR §4) still rules.
+*
+* ADR: dev/architectural-decission/2026-08-26 - The a2a Signature —
+*      Correlation IDs and the Delegation Ledger.md §5 (two-lane
+*      detection contract) + The Mention Watcher ADR (detection half).
+* Spec: dev/specs/2026-08-25 - DSI a2a Signature and Delegation Ledger
+*      (PRD "Watcher sequence", tier map; Tasks 3.1/3.1-T).
+*
+* Module boundary (PRD communication map): watcher imports dsh-connection
+* only — NEVER dsh-rpc directly; the matcher is pure; the db owns writes.
+* Lifecycle: module-level singleton; registerWatch() ensures started;
+* ticker stops at zero waiting; boot sweep resumes.
+*
+* Config sync (W4 4.1): readA2aConfig() is applied ONCE at boot, before
+* the first sweep — runtime edits take effect on the next dev-server
+* restart (the no-cache reader contract). Test fakes inject timings
+* through configureWatcher; they run in files whose DSI_CONFIG_PATH is
+* pinned to a tmp void, so the boot sync never clobbers them.
+*/
+/** LIST-lane cadence — one batched session.list per tick (default 1s). */
+var A2A_FAST_POLL_MS = 1e3;
+/** Deadline for a reply before honest `timeout` (default 10 min). */
+var A2A_WATCH_TIMEOUT_MS = 6e5;
+/**
+* SEQ-lane probe cadence (2026-08-25 bug fix): when the host ships no
+* `sessionStats.turns` AND its list projection's updatedAt/running never
+* move on replies (probe-verified live), the LIST gate is structurally
+* dead — the target LEDGER's event seq is the only signal that moves.
+* One history read per DISTINCT waiting target per window; zero model
+* calls still hold (history is a read).
+*/
+var A2A_SEQ_PROBE_MS = 5e3;
+/**
+* SEQ-lane quiescence (2026-08-25 RCA follow-up, risk 1 — mid-turn latch):
+* the live host's `running` is inert, so the seq lane cannot ask "is the
+* target done?". Instead it watches the tail itself: a settle is allowed
+* only when the target's newest event seq has been UNCHANGED for this
+* long. A turn still writing keeps moving the tail and resets the clock —
+* the fragment-early settle (a2a-0e657adf) becomes impossible.
+*/
+var A2A_QUIESCENCE_MS = 3e3;
+/** Assemble one event's entry text via the shipped reader, or null. */
+function entryText(h) {
+	const entry = entryForEvent(historyToEvents([h])[0]);
+	if (entry === null) return null;
+	if (entry.kind !== "assistant-message" && entry.kind !== "user-message") return null;
+	return typeof entry.text === "string" && entry.text !== "" ? entry.text : null;
+}
+/**
+* Seq of the LAST user message carrying THIS exchange's signature — the
+* delivered protocol line makes every delegation's prompt uniquely
+* findable in the page (SPAN anchor #1). Null when the prompt is off the
+* tail page or the sender carried no signature.
+*/
+function promptAnchorSeq(page, id) {
+	let found = null;
+	for (const h of page.events) {
+		if (h.event.type !== "user/message") continue;
+		const text = entryText(h);
+		if (text === null) continue;
+		if (text.includes(`_a2a_:${id};`)) found = h.event.seq;
+	}
+	return found;
+}
+/**
+* Seq of the first prompt of any LATER delegation (any `_a2a_:` marker)
+* after `start` — the span's upper bound, so stacked mentions on one
+* target never swallow each other's replies. Null when none follows.
+*/
+function nextDelegationSeq(page, start) {
+	for (const h of page.events) {
+		if (h.event.seq <= start) continue;
+		if (h.event.type !== "user/message") continue;
+		const text = entryText(h);
+		if (text !== null && text.includes("_a2a_:a2a-")) return h.event.seq;
+	}
+	return null;
+}
+/**
+* Newest finalized assistant bubble from a history tail page, or null —
+* the LEGACY shape (pre-span): one message, no join. Kept as the
+* no-anchor fallback so a page without resolvable anchors never
+* over-captures history from before this exchange.
+*/
+function extractLatestAssistantText(page) {
+	for (let i = page.events.length - 1; i >= 0; i--) {
+		const h = page.events[i];
+		if (h.event.type !== "assistant/message") continue;
+		const text = entryText(h);
+		if (text === null) continue;
+		const turn = h.event.data?.turn;
+		return {
+			text,
+			turn: typeof turn === "number" ? turn : -1
+		};
+	}
+	return null;
+}
+/**
+* The exchange's full span (SPAN capture, 2026-08-25 RCA #2): every
+* non-empty assistant message after the anchor, JOINED with blank lines
+* — narration before tool calls included, empty tool-call bubbles
+* dropped, `turn` from the newest contributing message.
+*
+* Anchor precedence: (1) the delivered prompt's own signature line —
+* robust to late registration, which is exactly when a register-time
+* watermark strands early narration below it; (2) the register-time seq
+* watermark; (3) neither resolvable → legacy newest-only, never a
+* whole-page guess. When (1) applies, the next delegation's prompt
+* bounds the span (stacked mentions stay separate).
+*/
+function extractReplySpan(page, id, fallbackSeq) {
+	const prompt = promptAnchorSeq(page, id);
+	const anchor = prompt ?? fallbackSeq;
+	if (anchor === null) {
+		const latest = extractLatestAssistantText(page);
+		return latest === null ? null : {
+			...latest,
+			anchorSeq: -1
+		};
+	}
+	const bound = prompt === null ? null : nextDelegationSeq(page, prompt);
+	const parts = [];
+	for (const h of page.events) {
+		const seq = h.event.seq;
+		if (seq <= anchor) continue;
+		if (bound !== null && seq >= bound) break;
+		if (h.event.type !== "assistant/message") continue;
+		const text = entryText(h);
+		if (text === null) continue;
+		const turn = h.event.data?.turn;
+		parts.push({
+			text,
+			turn: typeof turn === "number" ? turn : -1
+		});
+	}
+	if (parts.length === 0) return null;
+	const last = parts[parts.length - 1];
+	return {
+		text: parts.map((p) => p.text).join("\n\n"),
+		turn: last.turn,
+		anchorSeq: anchor
+	};
+}
+/** exact→replied_exact · attributed→replied · none→replied_approx. */
+var TIER_TO_STATE = {
+	exact: "replied_exact",
+	attributed: "replied",
+	none: "replied_approx"
+};
+/** Degrade-lane note (PRD risk 2: host drops sessionStats.turns). */
+var TURNS_UNAVAILABLE = "turns unavailable — settled on updatedAt edge";
+/** SEQ-lane degrade note — the list projection never moved (2026-08-25). */
+var TURNS_UNAVAILABLE_SEQ = "turns unavailable — settled on ledger seq watermark";
+var timer = null;
+var pollMs = A2A_FAST_POLL_MS;
+var timeoutMs = A2A_WATCH_TIMEOUT_MS;
+var retentionDays = 90;
+var probeWindowMs = A2A_SEQ_PROBE_MS;
+var quiescenceMs = A2A_QUIESCENCE_MS;
+var dshSurface;
+var ticking = false;
+var listCalls = 0;
+var bootSwept = false;
+/** SEQ lane throttle — target → last probe wall-clock (ms). */
+var lastSeqProbe = /* @__PURE__ */ new Map();
+/** SEQ lane quiescence — target → the tail seq first seen UNCHANGED, and when. */
+var tailQuietSince = /* @__PURE__ */ new Map();
+/**
+* Config wiring (W4) — validated upstream by $lib/config gates; applied
+* live: a fastPollMs change re-arms the ticker at the new cadence.
+*/
+function configureWatcher(opts) {
+	if (opts.fastPollMs !== void 0) pollMs = opts.fastPollMs;
+	if (opts.watchTimeoutMs !== void 0) timeoutMs = opts.watchTimeoutMs;
+	if (opts.retentionDays !== void 0) retentionDays = opts.retentionDays;
+	if (opts.probeWindowMs !== void 0) probeWindowMs = opts.probeWindowMs;
+	if (opts.quiescenceMs !== void 0) quiescenceMs = opts.quiescenceMs;
+	if (opts.dsh !== void 0) dshSurface = opts.dsh;
+	if (timer !== null) {
+		clearInterval(timer);
+		timer = null;
+		if (pollMs > 0) armTicker();
+	}
+}
+/** Resolve the active DSH surface (injected fake or the real singleton). */
+function surface() {
+	return dshSurface ?? getDshConnection();
+}
+/** Arm the interval (only when there is something to watch). */
+function armTicker() {
+	if (timer !== null) return;
+	if (pollMs <= 0) return;
+	if (listWaiting().length === 0) return;
+	timer = setInterval(() => {
+		tick();
+	}, pollMs);
+}
+/**
+* Ensure the watcher runs: boot sweep (once) + arm the ticker if rows
+* are waiting. Idempotent — registerWatch and routes both call this.
+*/
+function ensureStarted() {
+	if (!bootSwept) {
+		syncConfigFromInsight();
+		sweepOnBoot();
+	}
+	armTicker();
+}
+/**
+* One-shot config sync at boot (W4 4.1): the file reader is the truth;
+* explicit configureWatcher values always win (tests, future callers).
+* Reads with NO path argument so the env seam (DSI_CONFIG_PATH) rules.
+*/
+function syncConfigFromInsight() {
+	const cfg = readA2aConfig();
+	if (pollMs === 1e3) pollMs = cfg.fastPollMs;
+	if (timeoutMs === 6e5) timeoutMs = cfg.watchTimeoutMs;
+	if (retentionDays === 90) retentionDays = cfg.retentionDays;
+}
+/** Stop when nothing is left to watch (the only stop site — same module). */
+function stopTickerIfIdle() {
+	if (timer !== null && listWaiting().length === 0) {
+		clearInterval(timer);
+		timer = null;
+	}
+}
+/**
+* ONE tick = ONE batched session.list for ALL waiting targets, then the
+* per-row gate; gate-open rows read the LEDGER once and settle at their
+* tier. Timeout/gone are watcher-native (checked before any history read).
+*/
+async function tick() {
+	if (ticking) return;
+	ticking = true;
+	try {
+		const waiting = listWaiting();
+		if (waiting.length === 0) {
+			stopTickerIfIdle();
+			return;
+		}
+		listCalls++;
+		const list = await surface().listSessions();
+		const spine = /* @__PURE__ */ new Map();
+		for (const row of list.items) spine.set(row.sessionId, row);
+		const ledgers = /* @__PURE__ */ new Map();
+		const seqLedgers = /* @__PURE__ */ new Map();
+		const now = Date.now();
+		for (const row of waiting) {
+			const target = spine.get(row.toSession);
+			if (target === void 0) {
+				settleRow({
+					id: row.id,
+					state: "gone",
+					error: `target ${row.toSession} left the spine`
+				});
+				continue;
+			}
+			if (now - row.sentAt >= timeoutMs) {
+				settleRow({
+					id: row.id,
+					state: "timeout",
+					error: `no reply within ${timeoutMs}ms`
+				});
+				continue;
+			}
+			if (gateOpen(row, target)) {
+				const group = ledgers.get(row.toSession);
+				if (group === void 0) ledgers.set(row.toSession, {
+					rows: [row],
+					target
+				});
+				else group.rows.push(row);
+				continue;
+			}
+			if (row.watermarkSeq !== null && now - (lastSeqProbe.get(row.toSession) ?? 0) >= probeWindowMs) {
+				const group = seqLedgers.get(row.toSession);
+				if (group === void 0) seqLedgers.set(row.toSession, {
+					rows: [row],
+					target
+				});
+				else group.rows.push(row);
+			}
+		}
+		for (const [sessionId, group] of ledgers) await settleViaHistory(sessionId, group.rows, group.target);
+		for (const [sessionId, group] of seqLedgers) {
+			lastSeqProbe.set(sessionId, now);
+			await settleViaSeqWatermark(sessionId, group.rows, group.target);
+		}
+		stopTickerIfIdle();
+	} catch {} finally {
+		ticking = false;
+	}
+}
+/**
+* The gate: a NEW completed turn since the watermark, and not mid-run.
+* turns null → degrade lane (updatedAt edge + running false), flagged
+* `turns_unavailable` on settle.
+*/
+function gateOpen(row, target) {
+	if (target.turns !== null) return target.turns > row.watermarkTurn && target.running === false;
+	return target.updatedAt > row.sentAt && target.running === false;
+}
+/**
+* LEDGER lane: one history tail read for the target → per-row tier
+* classification → single settle UPDATE each. A turn whose text carries
+* the id for ANY waiting row settles that row (page-level per-row match).
+*/
+async function settleViaHistory(sessionId, rows, target) {
+	let page;
+	try {
+		page = await surface().history(sessionId);
+	} catch {
+		return;
+	}
+	for (const row of rows) {
+		const span = extractReplySpan(page, row.id, row.watermarkSeq);
+		if (span === null) {
+			settleRow({
+				id: row.id,
+				state: "replied_approx",
+				error: "turn completed without assistant text"
+			});
+			continue;
+		}
+		const tier = classifyReply(span.text, row.id);
+		settleRow({
+			id: row.id,
+			state: TIER_TO_STATE[tier],
+			replyText: span.text,
+			replyTurn: span.turn,
+			...target.turns === null ? { error: TURNS_UNAVAILABLE } : {}
+		});
+	}
+}
+/**
+* SEQ lane (2026-08-25 fix): one history read per DISTINCT target per
+* probe window; per row, the NEWEST finalized assistant message whose
+* event seq exceeds the row's captured seq watermark is the reply.
+*
+* Quiescence gate (RCA follow-up, risk 1): the live host's `running` is
+* inert, so "is the target done?" is answered by the tail itself — settle
+* only when the target's newest event seq has been UNCHANGED for
+* quiescenceMs. A turn still writing keeps moving the tail (every probe
+* that sees a new tail records it and returns without settling); the
+* first-ever probe also just records. Silence-then-settle means the
+* FINAL message is the newest past the watermark — the fragment-early
+* settle is impossible. Rows whose reply hasn't landed stay waiting; the
+* deadline lane owns them if it never does.
+*/
+async function settleViaSeqWatermark(sessionId, rows, target) {
+	let page;
+	try {
+		page = await surface().history(sessionId);
+	} catch {
+		return;
+	}
+	const tailSeq = page.events.length > 0 ? page.events[page.events.length - 1].event.seq : -1;
+	const quiet = tailQuietSince.get(sessionId);
+	const now = Date.now();
+	if (quiet === void 0 || quiet.seq !== tailSeq) {
+		tailQuietSince.set(sessionId, {
+			seq: tailSeq,
+			at: now
+		});
+		return;
+	}
+	if (now - quiet.at < quiescenceMs) return;
+	const degrade = target.turns === null ? { error: TURNS_UNAVAILABLE_SEQ } : {};
+	for (const row of rows) {
+		const span = extractReplySpan(page, row.id, row.watermarkSeq);
+		if (span === null) continue;
+		const tier = classifyReply(span.text, row.id);
+		settleRow({
+			id: row.id,
+			state: TIER_TO_STATE[tier],
+			replyText: span.text,
+			replyTurn: span.turn,
+			...degrade
+		});
+	}
+}
+/**
+* Sweep on boot (dev-server restart mid-watch): expire stale waiting rows
+* past the deadline, prune terminal rows past retention, resume the
+* ticker if waiting rows remain. Runs once per process before the first
+* tick (ensureStarted guards with bootSwept).
+*/
+function sweepOnBoot() {
+	bootSwept = true;
+	const db = openA2aDb();
+	const now = Date.now();
+	const stale = db.prepare(`SELECT id FROM a2a_exchange WHERE state = 'waiting' AND sent_at + ? <= ?`).all(timeoutMs, now);
+	for (const r of stale) settleRow({
+		id: r.id,
+		state: "timeout",
+		error: `no reply within ${timeoutMs}ms (boot sweep)`
+	}, db);
+	pruneTerminalBefore(now - retentionDays * 24 * 60 * 60 * 1e3, db);
+}
+/**
+* Register a watch (INSERT waiting) and ensure the watcher runs. The
+* registration route (3.2) calls this server-side at send.
+*/
+function registerWatch(row) {
+	insertWaiting(row);
+	ensureStarted();
+}
+
+export { configureWatcher as c, ensureStarted as e, registerWatch as r };
+//# sourceMappingURL=watcher.js-BelxjMOP.js.map

package/build/server/chunks/entries/endpoints/api/a2a/_id_/_server.ts.js-B4HUNFZv.js

@@ -0,0 +1,37 @@
+import { g as getRow } from '../../../../../chunks/db.js-DcmO3JAx.js';
+import { j as json } from '../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import '../../../../../chunks/config.js-BBYogCe7.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import 'node:sqlite';
+import '../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/a2a/[id]/+server.ts
+/**
+* /api/a2a/[id] (2026-08-25) — one ledger row (debug-friendly single
+* lookup; the chip join uses the list route).
+*
+* Spec: dev/specs/2026-08-25 - DSI a2a Signature and Delegation Ledger
+*      (PRD communication map; Tasks 3.2/3.2-T). 404 on unknown id.
+*/
+var GET = ({ params }) => {
+	const row = getRow(params.id);
+	if (row === null) return json({
+		ok: false,
+		error: {
+			code: "not-found",
+			message: `no a2a exchange ${params.id}`
+		}
+	}, { status: 404 });
+	return json({
+		ok: true,
+		row
+	});
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-B4HUNFZv.js.map

package/build/server/chunks/entries/endpoints/api/a2a/_server.ts.js-JDV_oqbX.js

@@ -0,0 +1,61 @@
+import { a as listRecent } from '../../../../chunks/db.js-DcmO3JAx.js';
+import { e as ensureStarted } from '../../../../chunks/watcher.js-BelxjMOP.js';
+import { j as json } from '../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import '../../../../chunks/config.js-BBYogCe7.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import 'node:sqlite';
+import '../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import '../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/a2a/+server.ts
+/**
+* /api/a2a (2026-08-25) — the a2a read surface: recent ledger rows for the
+* sender-panel chip join (W4), newest first, optional from-filter.
+*
+* Spec: dev/specs/2026-08-25 - DSI a2a Signature and Delegation Ledger
+*      (PRD communication map "routes → browser"; Tasks 3.2/3.2-T).
+*
+* Read-only: browser code never imports $lib/server (BC-2) — this JSON
+* route is its only window onto the ledger. Never exposes the DB path.
+*
+* Boot re-arm (2026-08-25 RCA follow-up, risk 2): a dev-server restart
+* mid-watch left waiting rows with a dead ticker until the next register.
+* The browser chip already polls this route on the spine's 5s cadence —
+* the idempotent ensureStarted() below means any open page revives the
+* watcher within one cadence (and the once-per-process boot sweep expires
+* stale rows honestly). The route stays read-only in the DB sense: it
+* never writes rows itself.
+*/
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var GET = ({ url }) => {
+	ensureStarted();
+	const from = url.searchParams.get("from") ?? void 0;
+	const rawLimit = url.searchParams.get("limit");
+	let limit = DEFAULT_LIMIT;
+	if (rawLimit !== null) {
+		const parsed = Number.parseInt(rawLimit, 10);
+		if (Number.isNaN(parsed) || parsed < 1) return json({
+			ok: false,
+			error: {
+				code: "bad-limit",
+				message: "limit must be a positive integer"
+			}
+		}, { status: 400 });
+		limit = Math.min(parsed, MAX_LIMIT);
+	}
+	const rows = listRecent(limit, from);
+	return json({
+		ok: true,
+		rows
+	});
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-JDV_oqbX.js.map

package/build/server/chunks/entries/endpoints/api/a2a/register/_server.ts.js-Dxwc-7-5.js

@@ -0,0 +1,99 @@
+import { c as readA2aConfig } from '../../../../../chunks/insight-config.js-CfMPTA6Z.js';
+import { g as getDshConnection } from '../../../../../chunks/dsh-connection.js-DwihVtk_.js';
+import { c as configureWatcher, r as registerWatch } from '../../../../../chunks/watcher.js-BelxjMOP.js';
+import { m as mintA2aId } from '../../../../../chunks/a2a-protocol.js-C77mVg2Q.js';
+import { j as json } from '../../../../../chunks/utils.js-tOWCe9Wk.js';
+import '../../../../../chunks/config.js-BBYogCe7.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../chunks/db.js-DcmO3JAx.js';
+import 'node:sqlite';
+import '../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/a2a/register/+server.ts
+/**
+* /api/a2a/register (2026-08-25) — record one delegation at send: INSERT
+* the waiting row (server mints the id when absent) and ensure the
+* watcher runs. The composer (runMention, 3.3) calls this AFTER the
+* prompt receipt — prompt first, register second (order is the contract).
+*
+* ADR: dev/architectural-decission/2026-08-26 - The a2a Signature —
+*      Correlation IDs and the Delegation Ledger.md §6 (INSERT-at-send).
+* Spec: dev/specs/2026-08-25 - DSI a2a Signature and Delegation Ledger
+*      (Tasks 3.2/3.2-T; PRD communication map "composer → server").
+*/
+/** Strict body validation — honest 400s, never silent guesses. */
+function readBody(raw) {
+	if (raw === null || typeof raw !== "object") return { error: "body must be an object" };
+	const b = raw;
+	if (typeof b.from !== "string" || b.from === "") return { error: "\"from\" must be a non-empty string" };
+	if (typeof b.to !== "string" || b.to === "") return { error: "\"to\" must be a non-empty string" };
+	if (typeof b.message !== "string" || b.message === "") return { error: "\"message\" must be a non-empty string" };
+	if (typeof b.watermark !== "number" || !Number.isInteger(b.watermark)) return { error: "\"watermark\" must be an integer" };
+	if (b.id !== void 0 && (typeof b.id !== "string" || b.id === "")) return { error: "\"id\" must be a non-empty string when present" };
+	return {
+		from: b.from,
+		to: b.to,
+		message: b.message,
+		watermark: b.watermark,
+		...b.id !== void 0 ? { id: b.id } : {}
+	};
+}
+var POST = async ({ request }) => {
+	let raw;
+	try {
+		raw = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const parsed = readBody(raw);
+	if ("error" in parsed) return json({
+		ok: false,
+		error: {
+			code: "bad-body",
+			message: parsed.error
+		}
+	}, { status: 400 });
+	const id = parsed.id ?? mintA2aId();
+	try {
+		const cfg = readA2aConfig();
+		configureWatcher({
+			fastPollMs: cfg.fastPollMs,
+			watchTimeoutMs: cfg.watchTimeoutMs,
+			retentionDays: cfg.retentionDays
+		});
+	} catch {}
+	let watermarkSeq = null;
+	if (parsed.watermark < 0) try {
+		const events = (await getDshConnection().history(parsed.to)).events ?? [];
+		watermarkSeq = events.length > 0 ? events[events.length - 1].event.seq : -1;
+	} catch {
+		watermarkSeq = null;
+	}
+	registerWatch({
+		id,
+		fromSession: parsed.from,
+		toSession: parsed.to,
+		message: parsed.message,
+		watermarkTurn: parsed.watermark,
+		watermarkSeq,
+		sentAt: Date.now()
+	});
+	return json({
+		ok: true,
+		id
+	});
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-Dxwc-7-5.js.map