@lingxi-ai-cn/dsh-session-export 0.1.0-rc.8 → 0.1.0-rc.9

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/host/session-export/README.md
+README.md: 31e7b0daddc83309a3b5207fc904b61e38a91894
+README.zh.md: 9cc58b5f6055601e0a4b6c981e89100717f7b5f5

package/README.md

@@ -2,10 +2,12 @@
 
 English | [中文](README.zh.md)
 
-Host-owned Session-log ZIP producer and native path writer. The `SessionLogExporter` service (`ctx.sessionLogExporter`) flushes each live Session before reading its persistence backend's raw artifact, streams the root artifact, optional descendants, and referenced images through bounded fflate compression, and never reconstructs stored logs from parsed events. `stream()` exposes the archive to a host transport; `writeToDirectory()` writes the same archive to an existing absolute directory and returns its exact final path.
+Host-owned Session-log ZIP producer, human-readable Markdown projection, and native path writer. The `SessionLogExporter` service (`ctx.sessionLogExporter`) flushes each live Session before reading its persistence backend's raw artifact, streams the root artifact, optional descendants, and referenced images through bounded fflate compression, and never reconstructs the raw archive from parsed events. `stream()` exposes the archive to a host transport; `writeToDirectory()` writes the same archive to an existing absolute directory and returns its exact final path. `writeMarkdownToDirectory()` separately reads the validated logical events and publishes a summary-only Markdown projection.
 
 The native writer creates an owner-only random sibling, forwards cancellation through root preparation, lineage, persistence, attachment reads, compression, and file writes, syncs and closes the complete file, then publishes it with an exclusive hard link. Existing exports are never overwritten: the first collision uses `-2`, followed by increasing suffixes. A failure before publication removes the partial sibling and leaves no final archive. The destination filesystem must support same-directory hard links.
 
+Markdown export is intentionally a human-readable projection, not a replacement for the raw archive. It includes the current surface of the root and optional descendants, bounded user/assistant text, tool names and bounded result summaries, and explicit sequence/time facts. Tool argument values are omitted by default and marked as omitted; the exporter does not offer a silent sensitive-detail mode. Image attachments use `attachment:<id>` reference-only links and are never copied into the Markdown file. The same private sibling, cancellation, `0600` mode, collision suffix, and exclusive hard-link publication rules apply to `.md` output.
+
 Expected preparation failures use `SessionLogExportError`: `services-unavailable`, `raw-artifacts-unsupported`, `session-not-found`, and `prepare-failed`. Destination and output failures use `destination-invalid` and `write-failed`. The operator-facing messages do not expose backend preparation errors; the original error remains attached as `cause` for host diagnostics. Signal cancellation preserves the signal's reason instead of becoming an export failure.
 
 The archive is diagnostic material containing the stored Session artifacts verbatim. Provider credential stores and transient OAuth progress are outside Session persistence and are never included, but prompts and tool arguments already present in the durable log remain present; consumers must choose an operator-controlled destination and treat the result as sensitive.
@@ -27,5 +29,6 @@ None. Export does not assemble or send provider requests.
 ## Known Limitations and Deferred Work
 
 - Persistence backends that do not expose per-Session raw artifacts cannot export; the shipped JSONL backend supports plaintext and zstd artifacts, while SQLite does not.
+- Markdown projection can use a backend's validated logical `inspect()` API even when raw-artifact ZIP export is unavailable; its attachment policy remains reference-only.
 - A tree export is a sequence of per-Session durability barriers and reads, not one atomic snapshot across the whole lineage; a live descendant may append after its artifact was read.
 - Native publication requires hard-link support in the selected directory. The service fails without publishing a partial final file when the filesystem rejects that operation.

package/README.zh.md

@@ -2,10 +2,12 @@
 
 [English](README.md) | 中文
 
-宿主侧拥有的 Session 日志 ZIP 生产器与原生路径写入器。`SessionLogExporter` 服务（`ctx.sessionLogExporter`）会在读取持久化后端的原始工件前 flush 每个实时 Session，通过有界 fflate 压缩流式输出根工件、可选后代和引用的图片，并且绝不从解析后的事件重建存储日志。`stream()` 向宿主传输层提供归档；`writeToDirectory()` 把同一归档写入一个既有的绝对目录，并返回精确的最终路径。
+宿主侧拥有的 Session 日志 ZIP 生产器、人类可读 Markdown projection 与原生路径写入器。`SessionLogExporter` 服务（`ctx.sessionLogExporter`）会在读取持久化后端的原始工件前 flush 每个实时 Session，通过有界 fflate 压缩流式输出根工件、可选后代和引用的图片，并且绝不从解析事件重建原始归档。`stream()` 向宿主传输层提供归档；`writeToDirectory()` 把同一归档写入一个既有的绝对目录，并返回精确的最终路径。`writeMarkdownToDirectory()` 则独立读取已验证的逻辑事件并发布仅供摘要阅读的 Markdown projection。
 
 原生写入器先创建一个仅所有者可读写的随机同级文件，把取消转发到根工件准备、血缘、持久化、附件读取、压缩和文件写入，随后同步并关闭完整文件，最后通过排他硬链接发布。既有导出永远不会被覆盖：第一次冲突使用 `-2`，随后递增后缀。发布前的失败会删除局部同级文件，不留下最终归档。目标文件系统必须支持同目录硬链接。
 
+Markdown 导出明确是人类可读 projection，不替代原始归档。它包含根 Session 及可选后代的当前表层、有界的人类/助手文本、工具名称、有界结果摘要，以及明确的 seq/time 事实。工具参数值默认省略并明确标记；导出器不会提供静默的敏感详情模式。图片附件只使用 `attachment:<id>` 的仅引用链接，绝不复制到 Markdown 文件。同一私有同级临时文件、取消、`0600` 权限、冲突后缀和排他硬链接发布规则也适用于 `.md` 输出。
+
 预期的准备失败使用 `SessionLogExportError`：`services-unavailable`、`raw-artifacts-unsupported`、`session-not-found` 和 `prepare-failed`。目标与输出失败使用 `destination-invalid` 和 `write-failed`。面向操作者的消息不会泄露后端准备错误；原始错误保留为 `cause`，供宿主诊断。signal 取消会保留 signal 的 reason，而不会改写成导出失败。
 
 该归档是逐字包含所存 Session 工件的诊断材料。提供方凭据存储和 transient OAuth 进度位于 Session 持久化之外，绝不会包含在内；但已经进入持久日志的 prompt 与工具参数仍会保留，因此 Consumer 必须选择由操作者控制的目标位置，并把结果视为敏感材料。
@@ -27,5 +29,6 @@
 ## 已知限制与暂缓事项
 
 - 不提供逐 Session 原始工件的持久化后端无法导出；随附的 JSONL 后端支持明文与 zstd 工件，SQLite 尚不支持。
+- 即使原始工件 ZIP 不可用，Markdown projection 仍可使用后端已验证的逻辑 `inspect()` API；附件策略仍固定为仅引用。
 - 树导出是一系列逐 Session 的持久性屏障与读取，并非覆盖整条血缘的一次原子快照；实时后代可能在自身工件被读取后继续追加。
 - 原生发布要求所选目录支持硬链接。文件系统拒绝该操作时，服务会失败且不会发布局部最终文件。

package/lib/index.js

@@ -4,6 +4,8 @@ import { basename, extname, isAbsolute, join } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 import { Zip, ZipDeflate } from "fflate";
+import { foldSurface } from "@deepseek-ai/dsh-session";
+import { extractSessionEventText } from "@deepseek-ai/dsh-session-query";
 //#region lib/types/zip.js
 /**
 * Host-side Session ZIP producer: streams one archive whose files are the
@@ -360,6 +362,207 @@ function streamSessionLogZip(deps, root, sessionId, includeDescendants, compress
 	});
 }
 //#endregion
+//#region lib/types/markdown.js
+/** Human-readable Markdown projection for durable Session history. */
+/**
+* Resolve the Markdown projection services from a composed Host context.
+* @param ctx - composed Host context containing Session query and persistence services.
+* @returns the services used by Markdown projection.
+*/
+function sessionMarkdownExportDeps(ctx) {
+	const sessionQuery = ctx.get("sessionQuery");
+	const sessionPersistence = ctx.get("sessionPersistence");
+	if (sessionQuery === void 0 || sessionPersistence === void 0) throw new Error("session Markdown export requires session-query and session-persistence services");
+	return {
+		sessionQuery,
+		sessionPersistence,
+		sessions: ctx.get("sessions")
+	};
+}
+/**
+* Build a safe suggested filename for one Markdown projection.
+* @param sessionId - Session identity included in the filename.
+* @returns a sanitized Markdown filename.
+*/
+function sessionMarkdownFilename(sessionId) {
+	return `dsh-session-${sessionId.replace(/[^A-Za-z0-9_-]/gu, "_")}.md`;
+}
+const MAX_MARKDOWN_OUTPUT_CHARS = 4194304;
+const MAX_BLOCK_CHARS = 16384;
+/**
+* Render a bounded, summary-only Markdown document from one Session lineage.
+*
+* Raw event artifacts remain the source of truth in the ZIP export. This
+* projection intentionally omits tool argument values, includes bounded tool
+* result summaries, and emits attachment references without copying bytes.
+* @param deps - services used to load and query the Session lineage.
+* @param request - projection scope and attachment policy.
+* @param signal - cancellation signal for persistence and lineage reads.
+* @returns the bounded human-readable Markdown projection.
+*/
+async function renderSessionMarkdown(deps, request, signal) {
+	const attachmentPolicy = request.attachmentPolicy;
+	if (attachmentPolicy !== void 0 && attachmentPolicy !== "reference") throw new Error("unsupported Session Markdown attachment policy");
+	const sources = [await loadMarkdownSource(deps, request.sessionId, signal)];
+	if (request.includeDescendants) {
+		const lineage = await deps.sessionQuery.traceSession(request.sessionId, signal);
+		const seen = /* @__PURE__ */ new Set([request.sessionId]);
+		const append = async (nodes) => {
+			for (const node of nodes) {
+				signal.throwIfAborted();
+				const id = node.session.header.id;
+				if (seen.has(id)) continue;
+				seen.add(id);
+				sources.push(await loadMarkdownSource(deps, id, signal));
+				await append(node.descendants);
+			}
+		};
+		await append(lineage.descendants);
+	}
+	const lines = [
+		"# DeepSeek Harness Session",
+		"",
+		`- Root Session: \`${safeInline(String(request.sessionId))}\``,
+		`- Included descendants: ${request.includeDescendants ? "yes" : "no"}`,
+		"- Export: human-readable Markdown projection; the raw ZIP remains the source-of-truth archive.",
+		"- Tool arguments: omitted by default; only bounded result summaries are shown.",
+		"- Attachments: reference-only (`attachment:<id>`); attachment bytes are not copied.",
+		""
+	];
+	for (const [index, source] of sources.entries()) {
+		signal.throwIfAborted();
+		if (index > 0) lines.push("");
+		lines.push(`## Session \`${safeInline(String(source.header.id))}\``);
+		lines.push(`- Workspace: \`${safeInline(source.header.cwd ?? "(no workspace)")}\``);
+		lines.push(`- Created: ${formatTime(source.header.createdAt)}`);
+		lines.push("");
+		appendSurface(lines, source.events);
+	}
+	const output = `${lines.join("\n").trimEnd()}\n`;
+	if (output.length > MAX_MARKDOWN_OUTPUT_CHARS) return `${output.slice(0, MAX_MARKDOWN_OUTPUT_CHARS).trimEnd()}\n\n[Older Markdown content omitted at the export bound.]\n`;
+	return output;
+}
+async function loadMarkdownSource(deps, sessionId, signal) {
+	signal.throwIfAborted();
+	if (deps.sessions !== void 0) {
+		const live = deps.sessions.get(sessionId);
+		if (live !== void 0) await deps.sessions.flush(live);
+	}
+	signal.throwIfAborted();
+	const loaded = await deps.sessionPersistence.inspect(sessionId, signal);
+	signal.throwIfAborted();
+	return {
+		header: structuredClone(loaded.meta),
+		events: loaded.events.map((event) => structuredClone(event))
+	};
+}
+function appendSurface(lines, events) {
+	const bySeq = new Map(events.map((event) => [event.seq, event]));
+	const calls = /* @__PURE__ */ new Map();
+	for (const event of events) if (event.type === "tool/call") calls.set(String(event.data.callId), {
+		name: event.data.name,
+		arguments: event.data.arguments
+	});
+	const surface = foldSurface(events).nodes;
+	let rendered = 0;
+	for (const seq of surface) {
+		const event = bySeq.get(seq);
+		if (event === void 0) continue;
+		const renderedLines = renderSurfaceEvent(event, calls);
+		if (renderedLines.length === 0) continue;
+		if (rendered > 0) lines.push("");
+		lines.push(...renderedLines);
+		rendered += 1;
+	}
+	if (rendered === 0) lines.push("_No human-visible surface events._");
+}
+function renderSurfaceEvent(event, calls) {
+	if (event.type === "user/message") return renderMessage(event.data.source.kind === "user" ? "User" : "Context", event.seq, event.time, extractSessionEventText(event), event.data.content);
+	if (event.type === "assistant/message") return renderMessage("Assistant", event.seq, event.time, extractSessionEventText(event), event.data.message.content);
+	if (event.type !== "tool/result") return [];
+	const callId = String(event.data.message.source.callId);
+	const call = calls.get(callId);
+	const result = boundedText(extractSessionEventText(event), MAX_BLOCK_CHARS);
+	const lines = [
+		`### Tool: ${safeInline(call?.name ?? `call ${callId}`)}`,
+		`- Sequence: ${event.seq}`,
+		`- Time: ${formatTime(event.time)}`,
+		"- Arguments: omitted in summary export.",
+		`- Outcome: ${event.data.error === void 0 ? "completed" : "error"}`,
+		"Result summary:",
+		...fenced(result.text)
+	];
+	if (result.truncated) lines.push("[Tool result summary truncated at the export bound.]");
+	appendAttachmentReferences(lines, event.data.message.content);
+	return lines;
+}
+function renderMessage(role, seq, time, text, content) {
+	const bounded = boundedText(text, MAX_BLOCK_CHARS);
+	if (bounded.text === "" && attachmentIds(content).length === 0) return [];
+	const lines = [
+		`### ${role}`,
+		`- Sequence: ${seq}`,
+		`- Time: ${formatTime(time)}`
+	];
+	if (bounded.text !== "") lines.push(...blockquote(bounded.text));
+	if (bounded.truncated) lines.push("[Message content truncated at the export bound.]");
+	appendAttachmentReferences(lines, content);
+	return lines;
+}
+function appendAttachmentReferences(lines, content) {
+	const ids = attachmentIds(content);
+	if (ids.length === 0) return;
+	lines.push(`- Attachments (reference-only): ${ids.map((id) => `\`attachment:${safeInline(id)}\``).join(", ")}`);
+}
+function attachmentIds(value) {
+	const ids = /* @__PURE__ */ new Set();
+	const visit = (current) => {
+		if (Array.isArray(current)) {
+			for (const item of current) visit(item);
+			return;
+		}
+		if (typeof current !== "object" || current === null) return;
+		const record = current;
+		if (record.type === "image" && typeof record.attachment === "object" && record.attachment !== null) {
+			const id = record.attachment.attachmentId;
+			if (typeof id === "string" || typeof id === "number") ids.add(String(id));
+		}
+		visit(record.content);
+	};
+	visit(value);
+	return [...ids];
+}
+function boundedText(value, maxChars) {
+	const safe = value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/gu, "�").replace(/\r\n?/gu, "\n").trim();
+	if (safe.length <= maxChars) return {
+		text: safe,
+		truncated: false
+	};
+	return {
+		text: `${safe.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`,
+		truncated: true
+	};
+}
+function blockquote(value) {
+	return value.split("\n").map((line) => line === "" ? ">" : `> ${line}`);
+}
+function fenced(value) {
+	const longest = Math.max(0, ...value.match(/`+/gu)?.map((match) => match.length) ?? []);
+	const fence = "`".repeat(Math.max(3, longest + 1));
+	return [
+		fence,
+		value === "" ? "[empty]" : value,
+		fence
+	];
+}
+function safeInline(value) {
+	return value.replace(/[\u0000-\u001F\u007F-\u009F]/gu, "�").replace(/`/gu, "'").replace(/\s+/gu, " ").trim() || "(unknown)";
+}
+function formatTime(value) {
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? "unknown" : date.toISOString();
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * Host session-log export service: prepares the canonical stored-artifact ZIP,
@@ -531,6 +734,53 @@ var SessionLogExporter = class extends Service {
 			reader.releaseLock();
 		}
 	}
+	/**
+	* Render a summary-only human-readable Markdown projection and publish it
+	* atomically under the first available safe filename. The raw ZIP remains
+	* the diagnostic source of truth; tool arguments are omitted and attachment
+	* references are never copied into the Markdown file.
+	* @param request - root identity, descendant policy, and explicit attachment policy.
+	* @param directory - existing absolute host directory chosen by the operator.
+	* @param signal - complete projection, writing, and publication lifetime.
+	* @returns the exact published Markdown path and filename.
+	*/
+	async writeMarkdownToDirectory(request, directory, signal) {
+		signal.throwIfAborted();
+		if (!isAbsolute(directory)) throw new SessionLogExportError("destination-invalid", "Session Markdown export destination must be an absolute directory");
+		try {
+			if (!(await stat(directory)).isDirectory()) throw new Error("destination is not a directory");
+		} catch (error) {
+			throw new SessionLogExportError("destination-invalid", `Session Markdown export destination is not an accessible directory: ${directory}`, { cause: error });
+		}
+		let markdown;
+		try {
+			markdown = await renderSessionMarkdown(sessionMarkdownExportDeps(this.ctx), request, signal);
+			signal.throwIfAborted();
+		} catch (error) {
+			signal.throwIfAborted();
+			throw new SessionLogExportError("prepare-failed", "Session Markdown export failed to prepare the projection", { cause: error });
+		}
+		const filename = sessionMarkdownFilename(request.sessionId);
+		const tempPath = join(directory, `.${filename}.${randomUUID()}.tmp`);
+		let file;
+		try {
+			file = await open(tempPath, "wx", 384);
+			await writeChunk(file, new TextEncoder().encode(markdown), signal);
+			signal.throwIfAborted();
+			await file.sync();
+			await file.close();
+			file = void 0;
+			return await publishExclusive(tempPath, directory, filename, signal);
+		} catch (error) {
+			try {
+				await file?.close();
+			} catch {}
+			await rm(tempPath, { force: true });
+			signal.throwIfAborted();
+			if (error instanceof SessionLogExportError) throw error;
+			throw new SessionLogExportError("write-failed", "Session Markdown export failed while writing the projection", { cause: error });
+		}
+	}
 };
 //#endregion
-export { DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, SessionLogExportError, SessionLogExporter as default, flushLiveSessionLog, prepareSessionLogExport, sessionLogExportDeps, sessionLogZipEntries, sessionLogZipFilename, streamSessionLogZip };
+export { DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, SessionLogExportError, SessionLogExporter as default, flushLiveSessionLog, prepareSessionLogExport, renderSessionMarkdown, sessionLogExportDeps, sessionLogZipEntries, sessionLogZipFilename, sessionMarkdownExportDeps, sessionMarkdownFilename, streamSessionLogZip };

package/lib/types/index.d.ts

@@ -9,8 +9,11 @@ import z from '@deepseek-ai/schemastery';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 import type { SessionRawArtifact } from '@deepseek-ai/dsh-session-persistence';
 import { type SessionLogCompressionLevel, type SessionLogExportReady } from './zip.ts';
+import type { SessionMarkdownExportRequest } from './markdown.ts';
 export { DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, flushLiveSessionLog, sessionLogExportDeps, sessionLogZipEntries, sessionLogZipFilename, streamSessionLogZip, } from './zip.ts';
 export type { SessionLogCompressionLevel, SessionLogExportDeps, SessionLogExportReady, SessionLogZipEntry, } from './zip.ts';
+export { renderSessionMarkdown, sessionMarkdownExportDeps, sessionMarkdownFilename, } from './markdown.ts';
+export type { SessionMarkdownAttachmentPolicy, SessionMarkdownExportDeps, SessionMarkdownExportRequest, SessionMarkdownSessionStore, } from './markdown.ts';
 /** Stable failure categories shared by the native writer and host transports. */
 export type SessionLogExportErrorCode = 'services-unavailable' | 'raw-artifacts-unsupported' | 'session-not-found' | 'prepare-failed' | 'destination-invalid' | 'write-failed';
 /** Typed session-log export failure with a consumer-safe message. */
@@ -100,5 +103,16 @@ export default class SessionLogExporter extends Service {
      * @returns the exact published path and filename.
      */
     writeToDirectory(request: SessionLogExportRequest, directory: string, signal: AbortSignal): Promise<SessionLogExportFile>;
+    /**
+     * Render a summary-only human-readable Markdown projection and publish it
+     * atomically under the first available safe filename. The raw ZIP remains
+     * the diagnostic source of truth; tool arguments are omitted and attachment
+     * references are never copied into the Markdown file.
+     * @param request - root identity, descendant policy, and explicit attachment policy.
+     * @param directory - existing absolute host directory chosen by the operator.
+     * @param signal - complete projection, writing, and publication lifetime.
+     * @returns the exact published Markdown path and filename.
+     */
+    writeMarkdownToDirectory(request: SessionMarkdownExportRequest, directory: string, signal: AbortSignal): Promise<SessionLogExportFile>;
 }
 //# sourceMappingURL=index.d.ts.map

package/lib/types/markdown.d.ts

@@ -0,0 +1,56 @@
+/** Human-readable Markdown projection for durable Session history. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence';
+import type { SessionQueryEngine } from '@deepseek-ai/dsh-session-query';
+/** Attachment policy supported by the summary Markdown export. */
+export type SessionMarkdownAttachmentPolicy = 'reference';
+/** Request for one human-readable Session projection. */
+export interface SessionMarkdownExportRequest {
+    /** Root Session identity. */
+    readonly sessionId: SessionId;
+    /** Whether all known durable descendants are included. */
+    readonly includeDescendants: boolean;
+    /** Attachment handling; references are explicit and bytes are never copied. */
+    readonly attachmentPolicy?: SessionMarkdownAttachmentPolicy;
+}
+/** Services required to build a Markdown projection. */
+export interface SessionMarkdownExportDeps {
+    readonly sessionQuery: SessionQueryEngine;
+    readonly sessionPersistence: SessionPersistence;
+    readonly sessions: SessionMarkdownSessionStore | undefined;
+}
+/** Minimal live-session surface needed by the flush barrier. */
+export interface SessionMarkdownSessionStore {
+    get(id: SessionId): {
+        id: SessionId;
+    } | undefined;
+    flush(session: {
+        id: SessionId;
+    }): Promise<boolean>;
+}
+/**
+ * Resolve the Markdown projection services from a composed Host context.
+ * @param ctx - composed Host context containing Session query and persistence services.
+ * @returns the services used by Markdown projection.
+ */
+export declare function sessionMarkdownExportDeps(ctx: Context): SessionMarkdownExportDeps;
+/**
+ * Build a safe suggested filename for one Markdown projection.
+ * @param sessionId - Session identity included in the filename.
+ * @returns a sanitized Markdown filename.
+ */
+export declare function sessionMarkdownFilename(sessionId: string): string;
+/**
+ * Render a bounded, summary-only Markdown document from one Session lineage.
+ *
+ * Raw event artifacts remain the source of truth in the ZIP export. This
+ * projection intentionally omits tool argument values, includes bounded tool
+ * result summaries, and emits attachment references without copying bytes.
+ * @param deps - services used to load and query the Session lineage.
+ * @param request - projection scope and attachment policy.
+ * @param signal - cancellation signal for persistence and lineage reads.
+ * @returns the bounded human-readable Markdown projection.
+ */
+export declare function renderSessionMarkdown(deps: SessionMarkdownExportDeps, request: SessionMarkdownExportRequest, signal: AbortSignal): Promise<string>;
+//# sourceMappingURL=markdown.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lingxi-ai-cn/dsh-session-export",
   "description": "Host-owned streaming Session ZIP producer and atomic path writer",
-  "version": "0.1.0-rc.8",
+  "version": "0.1.0-rc.9",
   "publishConfig": {
     "access": "public"
   },
@@ -46,6 +46,7 @@
     "@deepseek-ai/cordis": "4.0.1",
     "@deepseek-ai/dsh-attachment": "0.1.0-rc.8",
     "@deepseek-ai/dsh-invariants": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.8",
     "@deepseek-ai/dsh-session": "0.1.0-rc.8",
     "@deepseek-ai/dsh-session-persistence": "0.1.0-rc.8",
     "@deepseek-ai/dsh-session-query": "0.1.0-rc.8",