dsh-last-turn-delete 0.1.0

package/lib/core.js

@@ -0,0 +1,252 @@
+/**
+ * dsh-last-turn-delete — host-side pure logic (no DSH runtime imports).
+ *
+ * Everything here is a plain function over the durable Session event log so
+ * it can be unit-tested without a DSH host:
+ *
+ * - {@link isDeleteMarker}  recognizes the marker user/message this plugin
+ *   appends as a surface replacement when a turn is deleted.
+ * - {@link findTailDeletionTarget} computes the *current* deletable tail:
+ *   the last on-surface `user/message` whose `source.kind === 'user'`.
+ * - {@link collectDeletedMessages} re-derives every deleted user message id
+ *   from the log (each marker replacement's shadowed span contains exactly
+ *   one genuine user message — the one the deletion removed).
+ * - {@link collectFailedCompactionGroups} / {@link newestDeletable} decide the
+ *   host-authoritative deletable tail: the last on-surface user message, or a
+ *   failed `/compact` card that sits after it (failed compactions are not
+ *   boundaries and may be deleted themselves).
+ *
+ * Deleting works on the *model-visible surface* (compaction's mechanism), so
+ * durable history is never rewritten: the user message and all its model
+ * responses stop being folded into future model context, while the original
+ * events stay in the log untouched (soft delete; nothing is lost).
+ */
+
+/** Package name — also the identity stored on every deletion marker. */
+export const PKG_NAME = "dsh-last-turn-delete";
+
+/**
+ * The marker user/message's source identity. The chat transcript folds only
+ * append-surface user messages, so this replacement never renders a row; it
+ * only occupies the surface slot where the deleted turn used to be.
+ */
+export function deletionMarkerSource() {
+	return {
+		kind: "plugin",
+		name: PKG_NAME,
+		operation: "delete"
+	};
+}
+
+/**
+ * Whether an event is one of this plugin's deletion markers: a
+ * `user/message` surface replacement carrying the plugin's source identity.
+ * @param event - one durable Session event.
+ * @returns true for marker replacements appended by this plugin.
+ */
+export function isDeleteMarker(event) {
+	if (event === null || typeof event !== "object") return false;
+	if (event.type !== "user/message") return false;
+	const op = event.surfaceOp;
+	if (op === null || typeof op !== "object" || op.op !== "replace") return false;
+	const source = event.data?.source;
+	if (source === null || typeof source !== "object") return false;
+	return source.kind === "plugin" && source.name === PKG_NAME && source.operation === "delete";
+}
+
+/**
+ * Locate the current deletable tail turn inside a session surface.
+ *
+ * The surface node list is the model-visible conversation in order
+ * (compaction already removed pre-boundary history from it, so "the last
+ * user message on the surface" is by construction *after* the newest compact
+ * boundary — deletion stops exactly at the boundary).
+ *
+ * @param nodes - current surface node seqs, in model-visible order
+ *   (`session.surface.nodes`).
+ * @param eventAt - maps a seq back to its durable event.
+ * @param requestedMessageId - the message id the client believes is the
+ *   deletable tail; used to reject a stale click.
+ * @returns
+ * - `{ status: "ok", messageId, startSeq, endSeq, shadowedSeqs }` when the
+ *   requested message is the current tail user message;
+ * - `{ status: "stale", currentMessageId }` when the tail user message moved
+ *   (its id differs from the request);
+ * - `{ status: "none" }` when there is no deletable tail user message (all
+ *   content is before the compact boundary, or the log has none).
+ */
+export function findTailDeletionTarget(nodes, eventAt, requestedMessageId) {
+	for (let index = nodes.length - 1; index >= 0; index -= 1) {
+		const seq = nodes[index];
+		const event = eventAt(seq);
+		if (event === null || typeof event !== "object") continue;
+		if (event.type !== "user/message") continue;
+		const source = event.data?.source;
+		if (source?.kind !== "user") continue; // injected context / marker nodes
+		if (requestedMessageId !== event.data?.id) {
+			return {
+				status: "stale",
+				currentMessageId: event.data?.id ?? null
+			};
+		}
+		const shadowedSeqs = nodes.slice(index);
+		return {
+			status: "ok",
+			messageId: event.data.id,
+			startSeq: nodes[index],
+			endSeq: shadowedSeqs[shadowedSeqs.length - 1],
+			shadowedSeqs
+		};
+	}
+	return { status: "none" };
+}
+
+/**
+ * Re-derive every deleted user message from a full durable event log.
+ *
+ * Each deletion marker replacement shadows one span; the span contains
+ * exactly one genuine (`source.kind === "user"`) `user/message` — the deleted
+ * prompt. Later deletions shadow later tails that may already include
+ * earlier markers, so each marker still yields its own deleted message.
+ * @param events - durable events in seq order.
+ * @returns deleted user messages sorted by seq: `{ messageId, seq }`.
+ */
+export function collectDeletedMessages(events) {
+	const found = [];
+	if (!Array.isArray(events)) return found;
+	for (const event of events) {
+		if (!isDeleteMarker(event)) continue;
+		const shadowed = event.sourceEventSeqs;
+		if (!Array.isArray(shadowed)) continue;
+		for (const seq of shadowed) {
+			const inner = events[seq];
+			if (inner === null || typeof inner !== "object") continue;
+			if (inner.type !== "user/message") continue;
+			const source = inner.data?.source;
+			if (source?.kind !== "user") continue;
+			found.push({
+				messageId: inner.data.id,
+				seq: inner.seq
+			});
+			break; // one genuine user message per deleted span
+		}
+	}
+	found.sort((left, right) => left.seq - right.seq);
+	return found;
+}
+
+/**
+ * Build the marker `user/message` that replaces a deleted turn on the
+ * surface. Its content is a short note (the fold derives the replacement
+ * into the model surface; durable payloads are never removed).
+ * @param messageId - new message id for the marker.
+ * @param text - optional marker text; defaults to a bilingual note.
+ * @returns the marker message payload.
+ */
+export function deletionMarkerMessage(messageId, text) {
+	return {
+		role: "user",
+		id: messageId,
+		content: [{
+			type: "text",
+			text: text ?? "（本条消息及其全部回复已被用户删除，请忽略 / This message and all its replies were deleted by the user — please ignore）"
+		}],
+		source: deletionMarkerSource()
+	};
+}
+
+/**
+ * The current deletable tail: the last on-surface genuine user message, or
+ * null when none exists (no user message, or everything is before the newest
+ * compact boundary / already soft-deleted). Host-authoritative answer to
+ * "where should the delete button sit".
+ * @param nodes - current surface node seqs in model-visible order.
+ * @param eventAt - maps a seq back to its durable event.
+ * @returns `{ messageId, seq } | null`.
+ */
+export function currentTailUserMessage(nodes, eventAt) {
+	if (!Array.isArray(nodes)) return null;
+	for (let index = nodes.length - 1; index >= 0; index -= 1) {
+		const event = eventAt(nodes[index]);
+		if (event === null || typeof event !== "object") continue;
+		if (event.type !== "user/message") continue;
+		const source = event.data?.source;
+		if (source?.kind !== "user") continue;
+		return {
+			messageId: event.data?.id ?? null,
+			seq: nodes[index]
+		};
+	}
+	return null;
+}
+
+/**
+ * A manual compaction group failed when the user's `/compact` command did not
+ * land a summary: its `command/done` outcome is an error (the engine may have
+ * appended a `compaction/start`/`compaction/end` error pair and no
+ * `compaction/summary`). Failed compactions never touched the surface, so they
+ * are not a compact boundary — the history below them stays deletable.
+ * @param events - durable events in seq order.
+ * @returns failed groups as `{ commandId, runSeq }[]` in seq order.
+ */
+export function collectFailedCompactionGroups(events) {
+	const groups = [];
+	if (!Array.isArray(events)) return groups;
+	const runsByCommand = new Map(); // commandId -> run seq
+	const done = new Map(); // commandId -> { kind, doneSeq }
+	for (let index = 0; index < events.length; index += 1) {
+		const event = events[index];
+		if (event === null || typeof event !== "object") continue;
+		if (event.type === "command/run") {
+			const commandId = event.data?.commandId;
+			if (typeof commandId === "string" && event.data?.name === "compact") {
+				runsByCommand.set(commandId, index);
+			}
+		} else if (event.type === "command/done") {
+			const commandId = event.data?.commandId;
+			if (typeof commandId === "string") {
+				done.set(commandId, event.data?.kind ?? "success");
+			}
+		}
+	}
+	// A `/compact` whose command ended in error (possibly with an aborted
+	// compaction/start…end pair and no compaction/summary) is a failed group;
+	// a command that completed successfully never produces an error outcome.
+	for (const [commandId, runSeq] of runsByCommand) {
+		if (done.get(commandId) !== "error") continue;
+		groups.push({ commandId, runSeq });
+	}
+	groups.sort((left, right) => left.runSeq - right.runSeq);
+	return groups;
+}
+
+/**
+ * The newest deletable item of a session: either the last on-surface genuine
+ * user message (a normal turn), or — when a failed `/compact` group is the
+ * newest content — that failed-compaction card itself. Successful compaction
+ * boundaries are never returned here; the surface already dropped everything
+ * before them.
+ * @param events - durable events in seq order (for failed-group discovery).
+ * @param nodes - current surface node seqs (model-visible user/assistant/tool).
+ * @param eventAt - maps a seq to its durable event.
+ * @param deletedCompactIds - previously soft-deleted failed `/compact` command ids.
+ * @returns `{ kind: "message", messageId, seq } | { kind: "compact", commandId, seq } | null`.
+ */
+export function newestDeletable(events, nodes, eventAt, deletedCompactIds = new Set()) {
+	const messageTail = currentTailUserMessage(nodes, eventAt);
+	const userSeq = messageTail === null ? -1 : messageTail.seq;
+	const groups = collectFailedCompactionGroups(events).filter((group) => !deletedCompactIds.has(group.commandId));
+	const newestGroup = groups.length === 0 ? null : groups[groups.length - 1];
+	if (newestGroup === null || newestGroup.runSeq < userSeq) {
+		return messageTail === null ? null : {
+			kind: "message",
+			messageId: messageTail.messageId,
+			seq: messageTail.seq
+		};
+	}
+	return {
+		kind: "compact",
+		commandId: newestGroup.commandId,
+		seq: newestGroup.runSeq
+	};
+}

package/lib/index.js

@@ -0,0 +1,338 @@
+/**
+ * dsh-last-turn-delete — host Remote service.
+ *
+ * Two kinds of "delete the last thing" are supported:
+ *
+ * 1. Soft-delete the last *user turn* (the shipped mechanism): inside the
+ *    agent's serialized idle maintenance phase the service appends one
+ *    `user/message` surface replacement that shadows the target user message
+ *    and every later surface node (its model responses) up to the log tail.
+ *    Durable history is never rewritten — deleted content stops entering
+ *    future model context while the original events stay in the log.
+ *
+ * 2. Soft-delete a *failed `/compact` card*: a manual compaction whose
+ *    `command/done` outcome was an error never touched the model surface, so
+ *    it is not a compact boundary. It is recorded in this plugin's private
+ *    storage-domain sidecar and simply stops showing in the delete chain —
+ *    the chain then walks past it to the previous user message.
+ *
+ * Remote group: `lastTurnDelete`
+ *   - `delete({ sessionId, messageId })`  soft-deletes the tail user turn.
+ *   - `deleteCompact({ sessionId })`  forgets the newest failed `/compact` card.
+ *   - `tail({ sessionId })`  host-authoritative newest deletable item plus the
+ *     agent `running` flag
+ *     (`{ kind: "message", messageId } | { kind: "compact", commandId } | { kind: null }`, all `+ running`).
+ *   - `deleted({ sessionId })`  previously deleted user messages + compact ids.
+ *
+ * Methods are registered with @deepseek-ai/dsh-typert-protocol `Remote`
+ * markers; this file ships as plain ESM, so the marker initializers are
+ * applied with the equivalent manual calls against a throwaway instance.
+ */
+import { randomUUID } from "node:crypto";
+import { Service } from "@deepseek-ai/cordis";
+import { foldSurface } from "@deepseek-ai/dsh-session";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { z } from "zod";
+import {
+	collectDeletedMessages,
+	deletionMarkerMessage,
+	findTailDeletionTarget,
+	newestDeletable
+} from "./core.js";
+
+const GROUP = "lastTurnDelete";
+const DOMAIN_NAME = "dsh_last_turn_delete";
+
+/** Sidecar row schema: per-session id, identity-guarded, list of forgotten failed `/compact` command ids. */
+const compactRowSchema = z.object({
+	session: z.object({
+		createdAt: z.number().int().nonnegative(),
+		cwd: z.string().optional()
+	}),
+	compactCommandIds: z.array(z.string())
+});
+const compactDomainSpec = defineDomain({
+	name: DOMAIN_NAME,
+	version: 0,
+	tables: { sessions: domainTable(compactRowSchema) }
+});
+
+/**
+ * Mark `name` as a Remote method on the given service class.
+ *
+ * `Remote` is a TC39 standard method decorator: it registers a class-extra
+ * initializer that runs with `this` bound to an *instance* (the compiled
+ * `__runInitializers(this, _instanceExtraInitializers)` call happens in the
+ * constructor) and then marks `Object.getPrototypeOf(this)` — the class
+ * prototype. Plain ESM has no decorator syntax, so emulate exactly that:
+ * run the initializer against a throwaway instance.
+ */
+function markRemoteMethod(serviceClass, name) {
+	const receiver = Object.create(serviceClass.prototype);
+	Remote(name)(undefined, {
+		kind: "method",
+		name,
+		static: false,
+		private: false,
+		addInitializer(run) {
+			run.call(receiver);
+		}
+	});
+}
+
+function success(value) {
+	return Object.freeze({ ok: true, value });
+}
+
+function rejected(error) {
+	return Object.freeze({
+		ok: false,
+		error: Object.freeze(error)
+	});
+}
+
+function failure(code, message, details = {}) {
+	return rejected({ code, message, ...details });
+}
+
+function identityOf(header) {
+	return Object.freeze({
+		createdAt: header.createdAt,
+		...header.cwd === void 0 ? {} : { cwd: header.cwd }
+	});
+}
+
+function sameIdentity(row, header) {
+	return row.session.createdAt === header.createdAt && row.session.cwd === header.cwd;
+}
+
+/** One durable Session lifecycle bound to a storage-domain sidecar row. */
+function snapshotRow(header, ids) {
+	const copied = [...ids];
+	Object.freeze(copied);
+	return Object.freeze({
+		session: identityOf(header),
+		compactCommandIds: copied
+	});
+}
+
+/**
+ * The deletion Remote service. Injected services mirror the
+ * dsh-message-feedback consumer pattern (agents / sessions /
+ * sessionPersistence) plus the storage-domain sidecar.
+ */
+class LastTurnDeleteService extends TypertRemoteService {
+	static inject = ["agents", "sessions", "sessionPersistence", "storageDomain"];
+
+	table;
+
+	constructor(ctx) {
+		super(ctx, GROUP);
+	}
+
+	/** Open and own the one compact-forget sidecar domain. */
+	async [Service.init]() {
+		const domain = await this.ctx.storageDomain.open(compactDomainSpec);
+		this.ctx.effect(() => async () => {
+			await domain.close();
+		}, `${DOMAIN_NAME}.domainClose`);
+		this.table = domain.table("sessions");
+	}
+
+	/**
+	 * Resolve a session's durable events + identity (live agent first, cold
+	 * persistence otherwise). `eventAt`/nodes derive from the same array.
+	 * @returns `{ header, events } | null`.
+	 */
+	async resolveInspection(sessionId) {
+		const live = this.ctx.agents.get(sessionId);
+		if (live !== void 0) {
+			return {
+				sessionId,
+				header: live.session.header,
+				events: live.session.snapshotEvents(),
+				nodes: live.session.surface.nodes
+			};
+		}
+		const inspection = await this.ctx.sessionPersistence.inspect(sessionId);
+		if (inspection?.events === void 0) return null;
+		return {
+			sessionId,
+			header: inspection.meta,
+			events: inspection.events,
+			nodes: foldSurface(inspection.events).nodes
+		};
+	}
+
+	/** Stored (forgotten) failed-compact ids guarded by session identity. */
+	storedCompactIds(sessionId, header) {
+		const row = this.requireTable().get(sessionId);
+		if (row === void 0 || !sameIdentity(row, header)) return [];
+		return [...row.compactCommandIds];
+	}
+
+	async persistCompactIds(sessionId, header, ids) {
+		await this.requireTable().put(sessionId, snapshotRow(header, ids));
+	}
+
+	requireTable() {
+		if (this.table === void 0) throw new Error("last-turn-delete: sidecar domain is not initialized");
+		return this.table;
+	}
+
+	/**
+	 * Soft-delete the current tail user turn.
+	 * The agent must own the session and be idle; the call runs inside
+	 * `agent.runMaintenance` so queued waking input parks until the marker is
+	 * durably checkpointed.
+	 * @param request - session and the client-observed tail message id.
+	 * @returns `{ ok: true, value }` or an explicit business failure.
+	 */
+	async delete(request) {
+		const { sessionId, messageId } = request ?? {};
+		if (typeof sessionId !== "string" || typeof messageId !== "string") {
+			return failure("bad-request", "sessionId and messageId are required");
+		}
+		const agent = this.ctx.agents.get(sessionId);
+		if (agent === void 0) {
+			return failure("session-not-found", "no live agent owns this session", { sessionId });
+		}
+		let task;
+		try {
+			task = agent.runMaintenance(async () => {
+				const session = agent.session;
+				const target = findTailDeletionTarget(
+					session.surface.nodes,
+					(seq) => session.eventAt(seq) ?? null,
+					messageId
+				);
+				if (target.status === "none") {
+					return failure("no-target", "no deletable tail user message (compact boundary or empty)", { sessionId });
+				}
+				if (target.status === "stale") {
+					return failure("stale", "the tail user message changed; refresh and retry", {
+						sessionId,
+						currentMessageId: target.currentMessageId
+					});
+				}
+				const marker = deletionMarkerMessage(randomUUID());
+				session.append("user/message", marker, {
+					surfaceOp: { op: "replace", start: target.startSeq, end: target.endSeq },
+					sourceEventSeqs: target.shadowedSeqs
+				});
+				await this.ctx.sessions.flush(session);
+				return success({
+					sessionId,
+					messageId: target.messageId,
+					startSeq: target.startSeq,
+					endSeq: target.endSeq,
+					shadowedCount: target.shadowedSeqs.length
+				});
+			});
+		} catch (error) {
+			// runMaintenance throws synchronously when another driver or
+			// maintenance task owns the agent (busy / mid-stream).
+			return failure("busy", "the agent is running; retry once it is idle", { sessionId, cause: error?.message });
+		}
+		try {
+			return await task;
+		} catch (error) {
+			return failure("internal", "deletion failed", { sessionId, cause: error?.message });
+		}
+	}
+
+	/**
+	 * Forget one failed `/compact` card (the newest deletable item). A failed
+	 * compaction never changed the model surface, so nothing is shadowed — the
+	 * card is recorded in the sidecar and the delete chain moves past it.
+	 * @param request - session whose newest deletable item is a failed card.
+	 * @returns `{ ok: true, value: { commandId } }` or a business failure.
+	 */
+	async deleteCompact(request) {
+		const { sessionId } = request ?? {};
+		if (typeof sessionId !== "string") return failure("bad-request", "sessionId is required");
+		try {
+			const inspection = await this.resolveInspection(sessionId);
+			if (inspection === null) {
+				return failure("session-not-found", "no session or persistence record", { sessionId });
+			}
+			const { events, nodes, header } = inspection;
+			const eventAt = (seq) => events[seq] ?? null;
+			const candidate = newestDeletable(events, nodes, eventAt, new Set(this.storedCompactIds(inspection.sessionId, header)));
+			if (candidate === null || candidate.kind !== "compact") {
+				return failure("no-target", "no deletable failed compaction card", { sessionId });
+			}
+			const commandId = candidate.commandId;
+			await this.persistCompactIds(inspection.sessionId, inspection.header, [
+				...this.storedCompactIds(inspection.sessionId, inspection.header),
+				commandId
+			]);
+			return success({ sessionId, commandId });
+		} catch (error) {
+			return failure("internal", "could not delete the compaction card", { sessionId, cause: error?.message });
+		}
+	}
+
+	/**
+	 * Host-authoritative newest deletable item. Normal tail user message, or a
+	 * failed `/compact` card that sits after it (both may be walked through).
+	 * @param request - session to inspect.
+	 * @returns `{ ok: true, value }` where value is
+	 *   `{ kind: "message", messageId } | { kind: "compact", commandId } | { kind: null, messageId: null }`.
+	 */
+	async tail(request) {
+		const { sessionId } = request ?? {};
+		if (typeof sessionId !== "string") return failure("bad-request", "sessionId is required");
+		try {
+			const inspection = await this.resolveInspection(sessionId);
+			if (inspection === null) {
+				return failure("session-not-found", "no session or persistence record", { sessionId });
+			}
+			const { events, nodes, header } = inspection;
+			const liveAgent = this.ctx.agents.get(sessionId);
+			const running = liveAgent !== void 0 && liveAgent.status === "running";
+			const candidate = newestDeletable(events, nodes, (seq) => events[seq] ?? null, new Set(this.storedCompactIds(inspection.sessionId, header)));
+			if (candidate === null) {
+				return success({ kind: null, messageId: null, running });
+			}
+			if (candidate.kind === "compact") {
+				return success({ kind: "compact", commandId: candidate.commandId, running });
+			}
+			return success({ kind: "message", messageId: candidate.messageId, running });
+		} catch (error) {
+			return failure("internal", "could not resolve the deletable tail", { sessionId, cause: error?.message });
+		}
+	}
+
+	/**
+	 * List every previously soft-deleted item of a session: user messages
+	 * (derived from log markers) and forgotten failed-compact command ids
+	 * (sidecar).
+	 * @param request - session to inspect.
+	 * @returns `{ ok: true, value: { items, compactCommandIds } }`.
+	 */
+	async deleted(request) {
+		const { sessionId } = request ?? {};
+		if (typeof sessionId !== "string") return failure("bad-request", "sessionId is required");
+		try {
+			const inspection = await this.resolveInspection(sessionId);
+			if (inspection === null) {
+				return failure("session-not-found", "no session or persistence record", { sessionId });
+			}
+			return success({
+				items: collectDeletedMessages(inspection.events),
+				compactCommandIds: this.storedCompactIds(inspection.sessionId, inspection.header)
+			});
+		} catch (error) {
+			return failure("internal", "could not list deletions", { sessionId, cause: error?.message });
+		}
+	}
+}
+
+markRemoteMethod(LastTurnDeleteService, "delete");
+markRemoteMethod(LastTurnDeleteService, "deleteCompact");
+markRemoteMethod(LastTurnDeleteService, "deleted");
+markRemoteMethod(LastTurnDeleteService, "tail");
+
+export { LastTurnDeleteService, LastTurnDeleteService as default };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "dsh-last-turn-delete",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness (DSH) bundle: a delete button on the last user message that soft-deletes that turn — user message plus all its model replies — keeping it out of future model context, stepping back to the previous user message until a compact boundary or none remain (最后一条用户消息上的删除按钮：软删除该用户消息及其全部模型回复，不再进入后续模型上下文；按钮随后移到上一条用户消息，直到 compact 边界或无消息)",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/core.js",
+    "lib/client.js",
+    "cordis.patch.yml"
+  ],
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.5",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.2-alpha.5",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-alpha.5"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "license": "MIT",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "bundle",
+    "client",
+    "delete",
+    "message",
+    "turn"
+  ],
+  "scripts": {
+    "test": "node --test lib/core.test.mjs"
+  }
+}