@deepseek-insight/dsi 0.5.5

package/build/server/chunks/chunks/dsh-events.js-BtDxaV6Q.js

@@ -0,0 +1,706 @@
+//#region src/lib/utils/truncate.ts
+/**
+* Cut `text` to at most `max` characters. `max` <= 0 returns the full text
+* (max means "no limit" — documented contract, pinned by tests).
+*/
+function truncate(text, max) {
+	if (max <= 0 || text.length <= max) return {
+		head: text,
+		truncated: false,
+		cutChars: 0
+	};
+	return {
+		head: text.slice(0, max),
+		truncated: true,
+		cutChars: text.length - max
+	};
+}
+//#endregion
+//#region src/lib/services/conversation/dsh-events.ts
+/**
+* Internal harness markers that never render in the transcript: policy
+* snapshots, turn/step bookkeeping, projections, retry plumbing. They are
+* durable truth for the harness, noise for a conversation page.
+*
+* NOT silent since 2026-09-01: `request/header` carries the rendered system
+* prompt (`header.system`) — transcript content in DSH's own Chat — and now
+* maps to a `system-prompt` entry. `request/context` stays silent (route
+* metadata, no user-visible text).
+*/
+var SILENT_TYPES = /* @__PURE__ */ new Set([
+	"agent-preset/selected",
+	"agent/inbox/spliced",
+	"approval/decided",
+	"approval/policy",
+	"approval/asked",
+	"command/done",
+	"command/run",
+	"compaction/end",
+	"compaction/prune",
+	"compaction/start",
+	"compaction/summary",
+	"feedback/record",
+	"goal/change",
+	"hook/invoked",
+	"hook/result",
+	"llm/retry",
+	"llm/retry-started",
+	"assistant/attempt",
+	"permission/preset",
+	"plan/mode",
+	"request/context",
+	"sandbox/mode",
+	"schedule/change",
+	"session",
+	"session/end-seed",
+	"session/title",
+	"session/title-llm-request",
+	"step/end",
+	"step/start",
+	"subagent/catalog",
+	"subagent/descriptor",
+	"team/member",
+	"team/message/delivered",
+	"team/message/queued",
+	"team/task",
+	"todo/write",
+	"turn/start",
+	"web/deepseek-search-llm-request"
+]);
+/** Stable bubble id for one assistant step (chunk merge key). */
+function bubbleId(turn, step) {
+	return `a:${String(turn)}:${String(step)}`;
+}
+/** Extract validated image refs from a message content array (Wave 3 task
+*  3.1). Wire shape: {type:'image', attachment:{attachmentId, mediaType,
+*  bytes, width, height, name?}} (ImageBlock). Structural validation at the
+*  wire boundary; malformed attachments are skipped, never guessed into
+*  shape. Returns undefined when none survive (lean payloads, text-only
+*  entries unchanged). */
+function imageRefsOfContent(content) {
+	if (!Array.isArray(content)) return void 0;
+	const refs = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object" || part.type !== "image") continue;
+		const attachment = part.attachment;
+		if (!attachment || typeof attachment !== "object") continue;
+		const ref = attachment;
+		if (typeof ref.attachmentId !== "string" || typeof ref.mediaType !== "string" || typeof ref.bytes !== "number" || typeof ref.width !== "number" || typeof ref.height !== "number") continue;
+		refs.push({
+			attachmentId: ref.attachmentId,
+			mediaType: ref.mediaType,
+			bytes: ref.bytes,
+			width: ref.width,
+			height: ref.height,
+			...typeof ref.name === "string" ? { name: ref.name } : {}
+		});
+	}
+	return refs.length > 0 ? refs : void 0;
+}
+/** Join the text parts of a message content array; non-text blocks ignored. */
+function textOfContent(content) {
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const part of content) if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") parts.push(part.text);
+	return parts.join("\n");
+}
+/**
+* Context-injection family detection (task 2.4; BC-11: fixture-pinned wire
+* markers — tests/unit/fixtures/context-injection-sources.json, live rc.8
+* ledger 2026-08-21). Harness-injected context user/messages carry a
+* structural `source` marker; each producer has its own shape:
+*
+*   runtime-context  source = { kind:'plugin',
+*                                 plugin:'@deepseek-ai/dsh-system-prompt',
+*                                 form:'snapshot', sections:[…] }
+*                    + text opens "Current runtime context."
+*   instructions     source = { kind:'agent-instructions', form:'instructions',
+*                              baseline, changes:[{action,set,scope,path,digest}] }
+*                    (AGENTS.md workspace instructions)
+*   skill-catalog    source = { kind:'skill-catalog', form:'catalog',
+*                              entries:[{name,description}] }
+*   skill-invocation source = { kind:'skill-invocation', name,
+*                              form:'instructions' }
+*                    (the rendered <skill_content> body injected after a
+*                     user-explicit skill load — SkillInvocationSource,
+*                     dsh-skill; `name` is the invoked skill, surfaced as
+*                     the chip label)
+*   compaction       source = { kind:'plugin', plugin:'compact',
+*                              compactionId, sourceCommandId? }
+*                    (the /compact checkpoint replacement user/message —
+*                     preamble + <compacted-summary> body —
+*                     CompactionCheckpointSource, dsh-compaction/checkpoint;
+*                     the full summary rides the message text, so the
+*                     compaction/* lifecycle events stay silent)
+*
+* The family is OPEN (2026-08-31 audit): MessageSourceMap is
+* merge-extensible and kind:'plugin' carries ANY plugin name. After the
+* five tailored producers, detection falls through exactly the way DSH's
+* own client does (ui-chat contextProvenance / message.ts):
+*
+*   plugin           source = { kind:'plugin', plugin:<name>, form? }
+*                    (every other injecting plugin — tool-jobs notices,
+*                     user-approval policy changes, hooks relays,
+*                     time-context / tmux-context snapshots, …; the chip
+*                     is NAMED after the wire plugin string)
+*   recall           source = { kind:'session-reference', form:'recall',
+*                              references:[{label,…}] }
+*                    (cross-session context prepared by the host;
+*                     named after the first reference label)
+*   injected         any other non-'user' source kind
+*                    (webhook notices, team messages, future kinds — the
+*                     chip is NAMED after the wire kind string; an unknown
+*                     producer stays visible, never a silent bubble)
+*
+* The 1.4-pinned fixture is the contract; the tailored producers require
+* the STRUCTURAL marker (source.kind + producer-specific form/keys) —
+* plain text that merely quotes the words never matches. Since the
+* 2026-08-31 audit, everything else NON-'user' still surfaces as a
+* fall-through chip (plugin name / recall label / kind string) instead of
+* posing as the operator's own bubble; only kind:'user' and source-less
+* messages stay ordinary bubbles.
+*/
+var RUNTIME_CONTEXT_PLUGIN = "@deepseek-ai/dsh-system-prompt";
+var RUNTIME_CONTEXT_FORM = "snapshot";
+var RUNTIME_CONTEXT_TEXT_PREFIX = "Current runtime context.";
+function contextInjectionProducer(data) {
+	const source = data?.source;
+	if (!source || typeof source.kind !== "string") return void 0;
+	if (source.kind === "plugin") {
+		if (source.plugin === RUNTIME_CONTEXT_PLUGIN && source.form === RUNTIME_CONTEXT_FORM && textOfContent(data?.content).startsWith(RUNTIME_CONTEXT_TEXT_PREFIX)) return "runtime-context";
+		if (source.plugin === "compact") return "compaction";
+		return "plugin";
+	}
+	if (source.kind === "agent-instructions" && source.form === "instructions") return "instructions";
+	if (source.kind === "skill-catalog" && source.form === "catalog") return "skill-catalog";
+	if (source.kind === "skill-invocation" && source.form === "instructions") return "skill-invocation";
+	if (source.kind === "session-reference") return "recall";
+	if (source.kind !== "user") return "injected";
+}
+/** tool/call display summary: harness view title when present, else the raw
+* args truncated through the shared util (task 2.1 promotion — single
+* truncation implementation; marker-less head, the chip owns affordances). */
+function callSummary(event, argumentsRaw) {
+	const title = event.view?.view?.title;
+	if (typeof title === "string" && title.length > 0) return title;
+	const { head, truncated } = truncate(argumentsRaw, 120);
+	if (head.length > 0) return truncated ? `${head}…` : head;
+}
+/**
+* Map ONE raw event to its DsiEntry (or null when it renders nothing).
+*
+* Streaming bubbles are STORE state (applyLiveStream), never mapper output:
+* the live tail is seq-less and arrives beside the durable events, not as
+* one.
+*/
+function entryForEvent(event) {
+	if (SILENT_TYPES.has(event.type)) return null;
+	const data = event.data;
+	if (data === void 0) return {
+		kind: "unknown-event",
+		id: `ev:${event.seq}`,
+		seq: event.seq,
+		time: event.time,
+		eventType: event.type
+	};
+	switch (event.type) {
+		case "system/message": {
+			const message = data?.message;
+			const text = textOfContent(message?.content);
+			if (typeof text !== "string" || text.length === 0) return null;
+			return {
+				kind: "system-prompt",
+				id: `sp:${event.seq}`,
+				seq: event.seq,
+				time: event.time,
+				text
+			};
+		}
+		case "request/header": {
+			const system = (data?.header)?.system;
+			if (typeof system !== "string" || system.length === 0) return null;
+			return {
+				kind: "system-prompt",
+				id: `sp:${event.seq}`,
+				seq: event.seq,
+				time: event.time,
+				text: system
+			};
+		}
+		case "user/message": {
+			const text = textOfContent(data?.content);
+			const id = typeof data?.id === "string" ? `u:${data.id}` : `u:seq:${event.seq}`;
+			const imageRefs = imageRefsOfContent(data?.content);
+			const producer = contextInjectionProducer(data);
+			if (producer) {
+				const src = data.source;
+				return {
+					kind: "user-message",
+					id,
+					seq: event.seq,
+					time: event.time,
+					text,
+					meta: producer,
+					...src !== void 0 ? { metaSource: src } : {},
+					...imageRefs !== void 0 ? { imageRefs } : {}
+				};
+			}
+			return {
+				kind: "user-message",
+				id,
+				seq: event.seq,
+				time: event.time,
+				text,
+				...imageRefs !== void 0 ? { imageRefs } : {}
+			};
+		}
+		case "assistant/message": {
+			const message = data?.message;
+			const reasoning = firstOfType(message?.content, "reasoning");
+			const reasoningText = typeof reasoning?.text === "string" && reasoning.text.length > 0 ? reasoning.text : void 0;
+			const source = message?.source;
+			const usage = usageOf(data?.usage, source);
+			return {
+				kind: "assistant-message",
+				id: bubbleId(data?.turn, data?.step),
+				seq: event.seq,
+				time: event.time,
+				text: textOfContent(message?.content),
+				streaming: false,
+				...reasoningText !== void 0 ? {
+					reasoning: reasoningText,
+					reasoningStreaming: false
+				} : {},
+				...usage !== void 0 ? { usage } : {}
+			};
+		}
+		case "turn/end": {
+			const reason = data?.reason;
+			if (reason?.kind !== "error") return null;
+			const message = readStr(reason.error?.message) ?? "turn ended with an error";
+			return {
+				kind: "turn-error",
+				id: `te:${event.seq}`,
+				seq: event.seq,
+				time: event.time,
+				message,
+				...readStr(reason.error?.code) !== void 0 ? { code: readStr(reason.error?.code) } : {}
+			};
+		}
+		case "tool/ptc-dispatch-start":
+		case "tool/ptc-dispatch": {
+			const parentCallId = readStr(data?.parentCallId);
+			const subCallId = readStr(data?.subCallId);
+			if (parentCallId === void 0 || subCallId === void 0) return null;
+			const args = data?.arguments;
+			return {
+				kind: "code-dispatch",
+				id: `cd:${subCallId}`,
+				seq: event.seq,
+				time: event.time,
+				parentCallId,
+				subCallId,
+				name: readStr(data?.name) ?? "tool",
+				...args !== void 0 ? { argsRaw: JSON.stringify(args) } : {},
+				settled: event.type === "tool/ptc-dispatch",
+				...event.type === "tool/ptc-dispatch" ? {
+					isError: data?.isError === true,
+					contentText: textOfContent(data?.content) || void 0
+				} : {}
+			};
+		}
+		case "tool/call": {
+			const callId = readStr(data?.callId) ?? `seq:${event.seq}`;
+			const argsRaw = readStr(data?.arguments);
+			return {
+				kind: "tool-call",
+				id: `tc:${callId}`,
+				seq: event.seq,
+				time: event.time,
+				callId,
+				toolName: readStr(data?.name) ?? "tool",
+				summary: callSummary(event, argsRaw ?? ""),
+				argsRaw,
+				status: "pending"
+			};
+		}
+		case "tool-workflow/run-start": {
+			const runId = readStr(data?.runId) ?? `seq:${event.seq}`;
+			return {
+				kind: "workflow-run",
+				id: `wf:${runId}`,
+				seq: event.seq,
+				time: event.time,
+				runId,
+				name: readStr(data?.name) ?? "workflow",
+				status: "running",
+				agents: []
+			};
+		}
+		case "tool-workflow/agent-start": {
+			const runId = readStr(data?.runId) ?? `seq:${event.seq}`;
+			const memberSeq = typeof data?.seq === "number" ? data.seq : -1;
+			const phase = readStr(data?.phase);
+			return {
+				kind: "workflow-run",
+				id: `wf:${runId}`,
+				seq: event.seq,
+				time: event.time,
+				runId,
+				name: "",
+				status: "running",
+				agents: [{
+					seq: memberSeq,
+					label: readStr(data?.label) ?? `agent ${memberSeq}`,
+					childId: readStr(data?.childId) ?? "",
+					...phase !== void 0 ? { phase } : {},
+					status: "running",
+					startedAt: event.time
+				}]
+			};
+		}
+		case "tool-workflow/agent-end": {
+			const runId = readStr(data?.runId) ?? `seq:${event.seq}`;
+			const memberSeq = typeof data?.seq === "number" ? data.seq : -1;
+			const outcome = readStr(data?.outcome);
+			return {
+				kind: "workflow-run",
+				id: `wf:${runId}`,
+				seq: event.seq,
+				time: event.time,
+				runId,
+				name: "",
+				status: "running",
+				agents: [{
+					seq: memberSeq,
+					label: "",
+					childId: "",
+					status: outcome === "completed" || outcome === "failed" ? outcome : "cancelled",
+					startedAt: 0,
+					endedAt: event.time
+				}]
+			};
+		}
+		case "tool-workflow/run-end": {
+			const runId = readStr(data?.runId) ?? `seq:${event.seq}`;
+			const stopReason = readStr(data?.stopReason);
+			return {
+				kind: "workflow-run",
+				id: `wf:${runId}`,
+				seq: event.seq,
+				time: event.time,
+				runId,
+				name: "",
+				status: stopReason === "completed" ? "completed" : stopReason === "error" ? "failed" : "cancelled",
+				agents: []
+			};
+		}
+		case "tool/result": {
+			const message = data?.message;
+			const callId = readStr(message?.source?.callId) ?? `seq:${event.seq}`;
+			const resultPart = firstOfType(message?.content, "tool-result");
+			const resultText = textOfContent(resultPart?.content) || void 0;
+			return {
+				kind: "tool-result",
+				id: `tr:${callId}`,
+				seq: event.seq,
+				time: event.time,
+				callId,
+				toolName: "",
+				ok: !resultPart || resultPart.isError !== true,
+				summary: resultText,
+				resultText,
+				...readViewFrom(event.view) !== void 0 ? { readView: readViewFrom(event.view) } : {}
+			};
+		}
+		default: return {
+			kind: "unknown-event",
+			id: `ev:${event.seq}`,
+			seq: event.seq,
+			time: event.time,
+			eventType: event.type
+		};
+	}
+}
+/** Read a wire TokenUsage (assistant/message.data.usage) into its DSI
+* shape — structural and conservative: a non-numeric inputTokens declines
+* to undefined (the event carries no accounting). 2026-08-23. Route
+* attribution rides message.source when both parts are non-empty
+* (2026-09-09, DSH turn-usage parity). */
+function usageOf(v, source) {
+	const u = v;
+	if (u === void 0 || typeof u.inputTokens !== "number" || typeof u.outputTokens !== "number") return;
+	const opt = (n) => typeof n === "number" ? n : void 0;
+	const provider = typeof source?.provider === "string" && source.provider.length > 0 ? source.provider : void 0;
+	const model = typeof source?.model === "string" && source.model.length > 0 ? source.model : void 0;
+	return {
+		inputTokens: u.inputTokens,
+		outputTokens: u.outputTokens,
+		...opt(u.cacheReadTokens) !== void 0 ? { cacheReadTokens: opt(u.cacheReadTokens) } : {},
+		...opt(u.cacheWriteTokens) !== void 0 ? { cacheWriteTokens: opt(u.cacheWriteTokens) } : {},
+		...opt(u.reasoningTokens) !== void 0 ? { reasoningTokens: opt(u.reasoningTokens) } : {},
+		...provider !== void 0 && model !== void 0 ? {
+			provider,
+			model
+		} : {}
+	};
+}
+function readStr(v) {
+	return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function firstOfType(content, type) {
+	if (!Array.isArray(content)) return void 0;
+	return content.find((p) => p?.type === type);
+}
+/** Normalize a read-result presentation view (tool/result view.card ===
+* 'read') into DsiReadView. Structural and conservative: any malformed
+* member declines to undefined (the flat resultText path stays). BC-11:
+* the shape is read from the harness's own projection, never re-derived
+* by guessing at arguments. 2026-08-22. */
+function readViewFrom(view) {
+	const v = view?.view;
+	if (v === void 0 || v.card !== "read") return void 0;
+	const path = readStr(v.path);
+	if (path === void 0) return void 0;
+	const offset = v.offset;
+	const totalLines = v.totalLines;
+	const lines = v.lines;
+	if (typeof offset !== "number" || typeof totalLines !== "number" || !Array.isArray(lines)) return void 0;
+	const out = [];
+	for (const l of lines) {
+		const line = l;
+		if (typeof line?.number !== "number" || typeof line?.text !== "string") return void 0;
+		out.push({
+			number: line.number,
+			text: line.text
+		});
+	}
+	const lang = readStr(v.lang);
+	return {
+		path,
+		offset,
+		totalLines,
+		lines: out,
+		...lang !== void 0 ? { lang } : {}
+	};
+}
+/**
+* Merge incoming DsiEntry deltas into an existing list (id-keyed, idempotent):
+*
+*   assistant-message, same id, finalized — REPLACES (the assembled message
+*       is authoritative over any streamed prefix, text AND reasoning; this
+*       is how the durable assistant/message finalizes the live-tail bubble
+*       folded by the store's applyLiveStream);
+*   any other kind, known id — ignored (retransmit);
+*   unknown id — appended.
+*
+*   (Ledger v2 removed the durable chunk events whose fragments CONCAT'ed
+*   here while streaming; the live tail carries the full accumulation each
+*   poll and replaces wholesale in the store, outside this merge.)
+*
+* Tool lifecycle (Wave 1, task 1.2): tool/call is born status:'pending';
+* a paired tool/result flips it to pass/fail (result.ok, i.e. isError on the
+* wire) and carries durationMs = result.time − call.time — both directions of
+* arrival (cold load has call+result together; polls may deliver result into
+* a list that already holds the call). An orphan result (no call in the list)
+* keeps its honest state: name unknown → 'tool', duration undefined.
+*
+* Also pairs tool-result entries with their tool-call by callId (fills
+* toolName). Server cold load and client poll deltas share these rules.
+*/
+function mergeEntries(existing, incoming) {
+	const merged = existing.map((e) => ({ ...e }));
+	for (const entry of incoming) {
+		const at = merged.findIndex((e) => e.id === entry.id);
+		if (at === -1) {
+			merged.push({ ...entry });
+			continue;
+		}
+		const candidate = merged[at];
+		if (candidate.kind === "workflow-run" && entry.kind === "workflow-run") {
+			merged[at] = mergeWorkflowRun(candidate, entry);
+			continue;
+		}
+		if (candidate.kind === "code-dispatch" && entry.kind === "code-dispatch") {
+			if (entry.argsRaw !== void 0) candidate.argsRaw = entry.argsRaw;
+			candidate.time = entry.time > candidate.time ? entry.time : candidate.time;
+			if (entry.settled) {
+				candidate.settled = true;
+				candidate.isError = entry.isError;
+				candidate.contentText = entry.contentText;
+			}
+			continue;
+		}
+		const prev = candidate;
+		if (prev.kind === "assistant-message" && entry.kind === "assistant-message") {
+			if (!entry.streaming) {
+				const next = { ...entry };
+				if (next.reasoning === void 0 && prev.reasoning !== void 0) {
+					next.reasoning = prev.reasoning;
+					next.reasoningStreaming = false;
+				}
+				if (next.text === "") next.text = prev.text;
+				merged[at] = next;
+			}
+			continue;
+		}
+	}
+	const calls = /* @__PURE__ */ new Map();
+	for (const e of merged) if (e.kind === "tool-call") calls.set(e.callId, e);
+	for (const e of merged) {
+		if (e.kind !== "tool-result") continue;
+		const call = calls.get(e.callId);
+		if (call) {
+			if (!e.toolName || e.toolName === "" || e.toolName === "tool") e.toolName = call.toolName;
+			if (!e.durationMs && e.time >= call.time) e.durationMs = e.time - call.time;
+		}
+		if (!e.toolName || e.toolName === "") e.toolName = "tool";
+		if (call && call.status === "pending") call.status = e.ok ? "pass" : "fail";
+	}
+	foldCodeDispatches(merged);
+	return merged;
+}
+/**
+* Fold `code-dispatch` partials onto their parent tool-call entries
+* (ADR D1/D2, 2026-09-05). Start and settled partials merge by subCallId —
+* a settle fills content/isError and never un-settles; a late start after a
+* settle keeps the settle's facts. Entries fold by parentCallId → the call's
+* `dispatches` list in `<n>` submission order. Orphans (no parent call in
+* the list) are dropped — the fold never guesses a parent. Idempotent:
+* retransmitted partials rewrite the same facts; the folded entry carries
+* fresh arrays, so re-running never aliases a prior list.
+*/
+function foldCodeDispatches(entries) {
+	const bySub = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		if (e.kind !== "code-dispatch") continue;
+		const prev = bySub.get(e.subCallId);
+		if (prev === void 0) {
+			bySub.set(e.subCallId, e);
+			continue;
+		}
+		prev.time = e.time > prev.time ? e.time : prev.time;
+		if (e.argsRaw !== void 0) prev.argsRaw = e.argsRaw;
+		if (e.settled) {
+			prev.settled = true;
+			prev.isError = e.isError;
+			prev.contentText = e.contentText;
+		}
+	}
+	if (bySub.size === 0) return;
+	const calls = /* @__PURE__ */ new Map();
+	for (const e of entries) if (e.kind === "tool-call") calls.set(e.callId, e);
+	const grouped = /* @__PURE__ */ new Map();
+	for (const d of bySub.values()) {
+		const list = grouped.get(d.parentCallId) ?? [];
+		list.push(d);
+		grouped.set(d.parentCallId, list);
+	}
+	const orderOf = (subCallId) => {
+		const m = /:(?:code|ptc):(\d+)$/.exec(subCallId);
+		return m !== null ? Number(m[1]) : Number.MAX_SAFE_INTEGER;
+	};
+	for (const [parentCallId, list] of grouped) {
+		list.sort((a, b) => orderOf(a.subCallId) - orderOf(b.subCallId));
+		const call = calls.get(parentCallId);
+		if (call === void 0) continue;
+		const kept = new Map(call.dispatches?.map((d) => [d.subCallId, d]) ?? []);
+		const next = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const d of list) {
+			seen.add(d.subCallId);
+			const k = kept.get(d.subCallId);
+			const winner = d.settled ? d : k?.settled ? k : d;
+			next.push({
+				subCallId: d.subCallId,
+				name: d.name,
+				...winner.argsRaw !== void 0 ? { argsRaw: winner.argsRaw } : k?.argsRaw !== void 0 ? { argsRaw: k.argsRaw } : {},
+				settled: d.settled || (k?.settled ?? false),
+				...winner.isError !== void 0 ? { isError: winner.isError } : {},
+				...winner.contentText !== void 0 ? { contentText: winner.contentText } : {}
+			});
+		}
+		for (const d of kept.values()) if (!seen.has(d.subCallId)) next.push({ ...d });
+		next.sort((a, b) => orderOf(a.subCallId) - orderOf(b.subCallId));
+		call.dispatches = next;
+	}
+	for (let i = entries.length - 1; i >= 0; i--) if (entries[i].kind === "code-dispatch") entries.splice(i, 1);
+}
+/** Full ledger tail → merged render list (cold load; BC-4 reads the ledger). */
+function eventsToEntries(events) {
+	return collapseSystemPromptEntries(mergeEntries([], events.map(entryForEvent).filter((e) => e !== null)));
+}
+/**
+* Collapse repeated `system-prompt` entries to one row per DISTINCT text
+* (2026-09-01): a request/header is appended per epoch — initial, resume,
+* change, series — so an uncollapsed transcript would repeat the identical
+* "System prompt" row after every host restart or tools-only header bump.
+* DSH's own Chat decides per header (`showsPrompt`); DSI cannot, because
+* scroll-up pages map through fresh calls with no earlier-page state — so
+* the rule is textual and stateless: keep a system-prompt row only when its
+* text differs from the last KEPT one. Pure, order-preserving, idempotent;
+* safe to re-run at every merge point (mapped batches, client deltas,
+* prepended older pages).
+*/
+function collapseSystemPromptEntries(entries) {
+	let lastKept;
+	const out = [];
+	for (const e of entries) {
+		if (e.kind === "system-prompt") {
+			if (e.text === lastKept) continue;
+			lastKept = e.text;
+		}
+		out.push(e);
+	}
+	return out;
+}
+/**
+* Fold ONE workflow-run partial into the running entry (2026-08-31).
+* Partials carry only what their event proved — run-start owns the name,
+* agent-start appends a member, agent-end settles a member by its member
+* seq (label/childId are NEVER overwritten by a settle partial's empty
+* strings), run-end sets the terminal status. Idempotent: a retransmitted
+* partial rewrites the same facts; a running status never un-settles a
+* terminal one.
+*/
+function mergeWorkflowRun(prev, incoming) {
+	const agents = [...prev.agents];
+	for (const a of incoming.agents) {
+		const at = agents.findIndex((x) => x.seq === a.seq);
+		if (at === -1) {
+			agents.push({ ...a });
+			continue;
+		}
+		agents[at] = {
+			...agents[at],
+			label: agents[at].label === "" && a.label !== "" ? a.label : agents[at].label,
+			childId: agents[at].childId === "" && a.childId !== "" ? a.childId : agents[at].childId,
+			startedAt: agents[at].startedAt > 0 ? agents[at].startedAt : a.startedAt,
+			status: a.status !== "running" ? a.status : agents[at].status,
+			...a.phase !== void 0 ? { phase: a.phase } : {},
+			...a.endedAt !== void 0 ? { endedAt: a.endedAt } : {}
+		};
+	}
+	return {
+		...prev,
+		seq: Math.max(prev.seq, incoming.seq),
+		time: Math.max(prev.time, incoming.time),
+		name: prev.name !== "" ? prev.name : incoming.name,
+		status: incoming.status !== "running" ? incoming.status : prev.status,
+		agents
+	};
+}
+/** Ledger HistoryEntry[] → raw events with their presentation views carried
+* (2026-08-22): the harness attaches `view` BESIDE `event` on each history
+* entry — a plain `.map((h) => h.event)` drops it, and the read-result file
+* rendering lost its typed data. Views merge shallowly; the event's own
+* member (if a wire ever carries one) wins. */
+function historyToEvents(history) {
+	return history.map((h) => h.view === void 0 || h.event.view !== void 0 ? h.event : {
+		...h.event,
+		view: h.view
+	});
+}
+
+export { entryForEvent as a, collapseSystemPromptEntries as c, eventsToEntries as e, historyToEvents as h, mergeEntries as m, truncate as t };
+//# sourceMappingURL=dsh-events.js-BtDxaV6Q.js.map