dsh-more 0.0.1

package/dist/index.js

@@ -0,0 +1,937 @@
+// src/index.ts
+import { randomBytes } from "node:crypto";
+
+// src/patches/message-edit/host/index.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { SessionId as SessionId3 } from "@deepseek-ai/dsh-session";
+
+// src/platform/dsh/host/agent-session.ts
+import { SessionId } from "@deepseek-ai/dsh-session";
+
+// src/platform/dsh/host/error.ts
+var DshMoreError = class extends Error {
+  constructor(code, message, status = 400) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "DshMoreError";
+  }
+};
+
+// src/platform/dsh/host/agent-session.ts
+function requireLiveSession(ctx, sessionId) {
+  const session = ctx.sessions.get(SessionId(sessionId));
+  if (session === void 0) throw new DshMoreError("session-not-live", "\u8BF7\u5148\u6253\u5F00\u8FD9\u6761\u4F1A\u8BDD\u518D\u64CD\u4F5C\u3002", 409);
+  return session;
+}
+function requireIdleAgent(ctx, sessionId, session) {
+  const agent = ctx.agents.get(SessionId(sessionId));
+  if (agent === void 0 || agent.session !== session) {
+    throw new DshMoreError("session-not-live", "\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u53EF\u7EF4\u62A4\u7684 Agent\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u540E\u518D\u8BD5\u3002", 409);
+  }
+  if (agent.status !== "idle") throw new DshMoreError("session-busy", "\u4F1A\u8BDD\u4ECD\u5728\u751F\u6210\u6216\u6267\u884C\u5DE5\u5177\uFF0C\u8BF7\u7B49\u5F85\u5B83\u7A7A\u95F2\u540E\u518D\u64CD\u4F5C\u3002", 409);
+  return agent;
+}
+function runAgentMaintenance(agent, task) {
+  try {
+    return agent.runMaintenance(task);
+  } catch {
+    throw new DshMoreError("session-busy", "\u4F1A\u8BDD\u521A\u521A\u5F00\u59CB\u4E86\u65B0\u4EFB\u52A1\uFF0C\u8BF7\u7B49\u5F85\u5B83\u7A7A\u95F2\u540E\u91CD\u8BD5\u3002", 409);
+  }
+}
+
+// src/platform/dsh/host/confirmation.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+function encode(payload) {
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+function signature(secret, encoded) {
+  return createHmac("sha256", secret).update(encoded).digest();
+}
+function createConfirmationToken(secret, facts3, now = Date.now(), ttlMs = 5 * 6e4) {
+  const encoded = encode({ ...facts3, expiresAt: now + ttlMs });
+  return `${encoded}.${signature(secret, encoded).toString("base64url")}`;
+}
+function verifyConfirmationToken(secret, token, expected, now = Date.now()) {
+  const [encoded, receivedText, extra] = token.split(".");
+  if (encoded === void 0 || receivedText === void 0 || extra !== void 0) {
+    throw new DshMoreError("stale-preview", "\u786E\u8BA4\u4FE1\u606F\u65E0\u6548\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8\u3002", 409);
+  }
+  const received = Buffer.from(receivedText, "base64url");
+  const wanted = signature(secret, encoded);
+  if (received.length !== wanted.length || !timingSafeEqual(received, wanted)) {
+    throw new DshMoreError("stale-preview", "\u786E\u8BA4\u4FE1\u606F\u65E0\u6548\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8\u3002", 409);
+  }
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  } catch {
+    throw new DshMoreError("stale-preview", "\u786E\u8BA4\u4FE1\u606F\u65E0\u6548\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8\u3002", 409);
+  }
+  const same = payload.sessionId === expected.sessionId && payload.startTurn === expected.startTurn && payload.endTurn === expected.endTurn && payload.logRevision === expected.logRevision && payload.replaceGeneration === expected.replaceGeneration && payload.operation === expected.operation && payload.targetSeq === expected.targetSeq && payload.contentDigest === expected.contentDigest && payload.continuationSessionId === expected.continuationSessionId && payload.shadowedSeqs.length === expected.shadowedSeqs.length && payload.shadowedSeqs.every((seq, index) => seq === expected.shadowedSeqs[index]);
+  if (!same || !Number.isFinite(payload.expiresAt) || payload.expiresAt < now) {
+    throw new DshMoreError("stale-preview", "\u4F1A\u8BDD\u5DF2\u53D8\u5316\u6216\u786E\u8BA4\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8\u3002", 409);
+  }
+}
+
+// src/platform/dsh/host/wire.ts
+var MAX_BODY_BYTES = 64 * 1024;
+async function readJson(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const bytes = Buffer.from(chunk);
+    size += bytes.length;
+    if (size > MAX_BODY_BYTES) throw new DshMoreError("bad-request", "\u8BF7\u6C42\u5185\u5BB9\u8FC7\u5927\u3002");
+    chunks.push(bytes);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (text.trim() === "") return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new DshMoreError("bad-request", "\u8BF7\u6C42\u4E0D\u662F\u6709\u6548\u7684 JSON\u3002");
+  }
+}
+function requireString(value, key) {
+  const found = value?.[key];
+  if (typeof found !== "string" || found === "") throw new DshMoreError("bad-request", `\u7F3A\u5C11 ${key}\u3002`);
+  return found;
+}
+function requireInteger(value, key) {
+  const found = value?.[key];
+  if (!Number.isSafeInteger(found)) throw new DshMoreError("bad-request", `${key} \u5FC5\u987B\u662F\u6574\u6570\u3002`);
+  return found;
+}
+function write(res, status, body) {
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff"
+  });
+  res.end(JSON.stringify(body));
+}
+function writeOk(res, value) {
+  write(res, 200, { ok: true, value });
+}
+function writeError(res, error) {
+  if (error instanceof DshMoreError) {
+    write(res, error.status, { ok: false, error: { code: error.code, message: error.message } });
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  write(res, 500, { ok: false, error: { code: "internal", message } });
+}
+
+// src/patches/message-edit/shared.ts
+var MESSAGE_EDIT_PATCH_ID = "message-edit";
+
+// src/patches/message-edit/host/edit-continuation.ts
+import { createHash, randomUUID } from "node:crypto";
+import { resolveSessionPreset } from "@deepseek-ai/dsh-agent-presets";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId as SessionId2 } from "@deepseek-ai/dsh-session";
+
+// src/platform/dsh/host/session-history.ts
+function completedTurns(events) {
+  const starts = /* @__PURE__ */ new Map();
+  const turns = [];
+  for (const event of events) {
+    if (event.type === "turn/start") {
+      starts.set(event.data.turn, event.seq);
+      continue;
+    }
+    if (event.type !== "turn/end") continue;
+    const startSeq = starts.get(event.data.turn);
+    if (startSeq !== void 0) turns.push({ turn: event.data.turn, startSeq, endSeq: event.seq });
+  }
+  return turns.sort((left, right) => left.startSeq - right.startSeq);
+}
+
+// src/platform/dsh/host/runtime-context.ts
+var RUNTIME_CONTEXT_PLUGIN = "@deepseek-ai/dsh-system-prompt";
+var RUNTIME_CONTEXT_PREFIX = "Current runtime context. This snapshot supersedes earlier runtime-context snapshots.\n\n";
+function retainedRuntimeContexts(seed) {
+  for (let index = seed.length - 1; index >= 0; index -= 1) {
+    const event = seed[index];
+    if (event?.type !== "user/message") continue;
+    const source = event.data.source;
+    if (source.plugin !== RUNTIME_CONTEXT_PLUGIN) continue;
+    if (source.form === "snapshot" && Array.isArray(source.sections)) {
+      const sections = source.sections.filter((section) => {
+        const value = section;
+        return typeof value.name === "string" && typeof value.text === "string";
+      });
+      if (sections.length === source.sections.length) return sections.map((section) => ({ ...section }));
+    }
+    const [block] = event.data.content;
+    if (event.data.content.length === 1 && block?.type === "text" && block.text.startsWith(RUNTIME_CONTEXT_PREFIX)) {
+      return [{ name: "dsh-more:retained-runtime-context", text: block.text.slice(RUNTIME_CONTEXT_PREFIX.length) }];
+    }
+    return [];
+  }
+  return [];
+}
+function replaySeedRuntimeContext(agentCtx, seed) {
+  const retained = retainedRuntimeContexts(seed);
+  return agentCtx.on("system-prompt/assemble", async (_assembly, _context, next) => ({
+    ...await next(),
+    contexts: retained.map((context) => ({ ...context }))
+  }));
+}
+
+// src/patches/message-edit/host/edit-continuation.ts
+function textDigest(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function editedContent(original, text) {
+  const kept = original.filter((block) => block.type !== "text");
+  return [{ type: "text", text }, ...kept];
+}
+function inspectEditCut(session, targetSeq, editedText) {
+  const text = editedText.trim();
+  if (text === "") throw new DshMoreError("bad-request", "\u7F16\u8F91\u540E\u7684\u6D88\u606F\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+  if (text.length > 1e5) throw new DshMoreError("bad-request", "\u7F16\u8F91\u540E\u7684\u6D88\u606F\u8FC7\u957F\u3002");
+  const event = session.events[targetSeq];
+  if (event?.type !== "user/message" || event.data.source.kind !== "user" || event.surfaceOp !== "append") {
+    throw new DshMoreError("bad-request", "\u53EA\u80FD\u7F16\u8F91\u666E\u901A\u7528\u6237\u6D88\u606F\u3002");
+  }
+  const turns = completedTurns(session.events);
+  const owning = turns.find((turn) => targetSeq >= turn.startSeq && targetSeq <= turn.endSeq);
+  if (owning === void 0) throw new DshMoreError("invalid-turn-range", "\u8FD9\u6761\u6D88\u606F\u6240\u5C5E\u8F6E\u6B21\u5C1A\u672A\u5B8C\u6210\u3002", 409);
+  return {
+    targetSeq,
+    turn: owning.turn,
+    turnStartSeq: owning.startSeq,
+    laterTurnCount: turns.filter((turn) => turn.turn >= owning.turn).length,
+    contentDigest: textDigest(text)
+  };
+}
+function sourceMessage(session, targetSeq) {
+  const event = session.events[targetSeq];
+  if (event?.type !== "user/message") throw new DshMoreError("bad-request", "\u7528\u6237\u6D88\u606F\u4E0D\u5B58\u5728\u3002");
+  return event;
+}
+async function createEditedContinuation(ctx, sourceAgent, cut, editedText, childId = SessionId2(`session-${randomUUID()}`)) {
+  const source = sourceAgent.session;
+  const original = sourceMessage(source, cut.targetSeq);
+  const presetId = resolveSessionPreset(source);
+  const roster = ctx.get("agentPresets");
+  const request = source.requestHeader()?.config;
+  const seed = source.events.slice(0, cut.turnStartSeq);
+  let releaseRuntimeContextReplay;
+  const releaseReplay = () => {
+    const release = releaseRuntimeContextReplay;
+    releaseRuntimeContextReplay = void 0;
+    release?.();
+  };
+  const child = await ctx.agents.create({
+    sessionId: childId,
+    seed,
+    meta: {
+      ...source.header.cwd === void 0 ? {} : { cwd: source.header.cwd },
+      parentSession: source.id,
+      seedLength: cut.turnStartSeq,
+      ...presetId === void 0 ? {} : { agentPreset: presetId }
+    },
+    agentOptions: {
+      ...(request?.provider ?? sourceAgent.options.provider) === void 0 ? {} : { provider: request?.provider ?? sourceAgent.options.provider },
+      ...(request?.model ?? sourceAgent.options.model) === void 0 ? {} : { model: request?.model ?? sourceAgent.options.model },
+      ...sourceAgent.options.maxTokens === void 0 ? {} : { maxTokens: sourceAgent.options.maxTokens }
+    },
+    setup: (agentCtx) => {
+      roster?.composeFrom(agentCtx, sourceAgent.ctx);
+      releaseRuntimeContextReplay = replaySeedRuntimeContext(agentCtx, seed);
+    }
+  });
+  try {
+    const workspace = ctx.workspaceRegistry.list().find((candidate) => candidate.sessionIds.includes(source.id));
+    if (workspace !== void 0) await workspace.attachSession(childId);
+    await ctx.workspaceRegistry.archiveSession(source.id);
+    child.agent.followup(createUserMessage({
+      content: editedContent(original.data.content, editedText.trim()),
+      source: { kind: "user" }
+    }));
+    void child.agent.whenIdle().then(releaseReplay, releaseReplay);
+    return { sessionId: childId };
+  } catch (error) {
+    releaseReplay();
+    await child.dispose().catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/patches/message-edit/host/index.ts
+function facts(sessionId, session, cut, continuationSessionId) {
+  return {
+    sessionId,
+    startTurn: cut.turn,
+    endTurn: cut.turn,
+    logRevision: session.seq,
+    replaceGeneration: session.surface.replaceGeneration,
+    shadowedSeqs: [cut.turnStartSeq, Math.max(cut.turnStartSeq, session.seq - 1)],
+    operation: "edit-message",
+    targetSeq: cut.targetSeq,
+    contentDigest: cut.contentDigest,
+    continuationSessionId
+  };
+}
+function preview(ctx, secret, payload) {
+  const sessionId = requireString(payload, "sessionId");
+  const session = requireLiveSession(ctx, sessionId);
+  const cut = inspectEditCut(session, requireInteger(payload, "targetSeq"), requireString(payload, "text"));
+  const continuationSessionId = `session-${randomUUID2()}`;
+  return {
+    turn: cut.turn,
+    laterTurnCount: cut.laterTurnCount,
+    continuationSessionId,
+    confirmToken: createConfirmationToken(secret, facts(sessionId, session, cut, continuationSessionId))
+  };
+}
+async function commit(ctx, secret, payload) {
+  const sessionId = requireString(payload, "sessionId");
+  const session = requireLiveSession(ctx, sessionId);
+  const agent = requireIdleAgent(ctx, sessionId, session);
+  return runAgentMaintenance(agent, async (signal) => {
+    signal.throwIfAborted();
+    const text = requireString(payload, "text");
+    const cut = inspectEditCut(session, requireInteger(payload, "targetSeq"), text);
+    const continuationSessionId = requireString(payload, "continuationSessionId");
+    verifyConfirmationToken(secret, requireString(payload, "confirmToken"), facts(sessionId, session, cut, continuationSessionId));
+    const result = await createEditedContinuation(ctx, agent, cut, text, SessionId3(continuationSessionId));
+    signal.throwIfAborted();
+    return result;
+  });
+}
+var hostPatch = {
+  id: MESSAGE_EDIT_PATCH_ID,
+  routes: ({ ctx, confirmationSecret }) => ({
+    preview: (payload) => preview(ctx, confirmationSecret, payload),
+    commit: (payload) => commit(ctx, confirmationSecret, payload)
+  })
+};
+
+// src/patches/message-delete/host/index.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { SessionId as SessionId5 } from "@deepseek-ai/dsh-session";
+
+// src/patches/message-delete/shared.ts
+var MESSAGE_DELETE_PATCH_ID = "message-delete";
+
+// src/patches/message-delete/host/message-selection.ts
+import { toolPairingBalancedAfter, toolPairingBalancedBefore } from "@deepseek-ai/dsh-compaction";
+import { isAppendSurfaceEvent } from "@deepseek-ai/dsh-session";
+function assertDeletableTarget(session, seq) {
+  const event = session.events[seq];
+  if (event?.type === "user/message" && isAppendSurfaceEvent(event) && event.data.source.kind === "user") return;
+  if (event?.type === "assistant/message" && isAppendSurfaceEvent(event)) return;
+  throw new DshMoreError("bad-request", "\u53EA\u80FD\u5220\u9664\u4ECD\u5728\u5F53\u524D\u4E0A\u4E0B\u6587\u4E2D\u7684\u7528\u6237\u6D88\u606F\u6216\u52A9\u624B\u6D88\u606F\u3002");
+}
+function selectMessageDeletion(session, targetSeq) {
+  if (!Number.isSafeInteger(targetSeq) || targetSeq < 0) throw new DshMoreError("bad-request", "\u6D88\u606F\u5E8F\u53F7\u65E0\u6548\u3002");
+  const nodes = [...session.surface.nodes];
+  const targetIndex = nodes.indexOf(targetSeq);
+  if (targetIndex < 0) throw new DshMoreError("selection-empty", "\u8FD9\u6761\u6D88\u606F\u5DF2\u7ECF\u4E0D\u5728\u5F53\u524D\u6A21\u578B\u4E0A\u4E0B\u6587\u4E2D\u3002");
+  assertDeletableTarget(session, targetSeq);
+  let startIndex = targetIndex;
+  let endIndex = targetIndex;
+  while (!toolPairingBalancedBefore(session, nodes[startIndex])) {
+    startIndex -= 1;
+    if (startIndex < 0) throw new DshMoreError("invalid-turn-range", "\u65E0\u6CD5\u627E\u5230\u5B89\u5168\u7684\u5DE5\u5177\u8C03\u7528\u8D77\u70B9\u3002");
+  }
+  while (!toolPairingBalancedAfter(session, nodes[endIndex])) {
+    endIndex += 1;
+    if (endIndex >= nodes.length) throw new DshMoreError("invalid-turn-range", "\u5DE5\u5177\u8C03\u7528\u4ECD\u672A\u7ED3\u675F\uFF0C\u6682\u65F6\u4E0D\u80FD\u5220\u9664\u8FD9\u6761\u6D88\u606F\u3002");
+  }
+  const shadowedSeqs = nodes.slice(startIndex, endIndex + 1);
+  if (shadowedSeqs.length === 0) throw new DshMoreError("selection-empty", "\u6CA1\u6709\u53EF\u5220\u9664\u7684\u4E0A\u4E0B\u6587\u8282\u70B9\u3002");
+  return { targetSeq, shadowedSeqs };
+}
+
+// src/patches/message-delete/host/projection.ts
+import { isReplacementSurfaceEvent } from "@deepseek-ai/dsh-session";
+import { z } from "zod";
+
+// src/kernel/message-visibility.ts
+var MESSAGE_VISIBILITY_PROJECTION_KEY = "dshMoreMessageDelete";
+
+// src/platform/dsh/identity.ts
+var PLUGIN_NAME = "dsh-more";
+var PLUGIN_API_PREFIX = `/${PLUGIN_NAME}/api`;
+var PLUGIN_MUTATION_HEADER = "x-dsh-more";
+var PATCH_SETTINGS_NAMESPACE = PLUGIN_NAME;
+
+// src/patches/message-delete/host/projection.ts
+var schema = z.object({
+  deletedSeqs: z.array(z.number().int().nonnegative()),
+  hiddenTrajectoryKeys: z.array(z.string())
+});
+function deletionUpdate(event) {
+  if (!isReplacementSurfaceEvent(event)) return null;
+  let metadata;
+  if (event.type === "user/message") {
+    const source = event.data.source;
+    if (source.kind === "plugin" && source.plugin === PLUGIN_NAME) metadata = source;
+  } else if (event.type === "assistant/message") {
+    const replayState = event.data.message.source.replayState;
+    metadata = replayState?.dshMoreMessageDelete;
+  }
+  if (metadata?.operation !== "delete-message") return null;
+  if (!Array.isArray(metadata.deletedSeqs) || !metadata.deletedSeqs.every((seq) => Number.isSafeInteger(seq) && seq >= 0)) return null;
+  return {
+    seqs: [...metadata.deletedSeqs, event.seq],
+    trajectoryKeys: event.type === "assistant/message" ? [`assistant\0${String(event.data.turn)}\0${String(event.data.step)}`] : []
+  };
+}
+var messageDeleteProjection = {
+  key: MESSAGE_VISIBILITY_PROJECTION_KEY,
+  schema,
+  stateVersion: 3,
+  init: () => ({ deletedSeqs: [], hiddenTrajectoryKeys: [] }),
+  apply: (state, event) => {
+    const added = deletionUpdate(event);
+    if (added === null) return state;
+    const nextSeqs = [.../* @__PURE__ */ new Set([...state.deletedSeqs, ...added.seqs])].sort((a, b) => a - b);
+    const nextKeys = [.../* @__PURE__ */ new Set([...state.hiddenTrajectoryKeys, ...added.trajectoryKeys])];
+    if (nextSeqs.length === state.deletedSeqs.length && nextKeys.length === state.hiddenTrajectoryKeys.length) return state;
+    return { deletedSeqs: nextSeqs, hiddenTrajectoryKeys: nextKeys };
+  },
+  view: (state) => state
+};
+
+// src/patches/message-delete/host/rebuild.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { resolveSessionPreset as resolveSessionPreset2 } from "@deepseek-ai/dsh-agent-presets";
+import { CallId } from "@deepseek-ai/dsh-llm";
+import { Session, SessionId as SessionId4 } from "@deepseek-ai/dsh-session";
+function recordedDeletionSeqs(events) {
+  const deleted = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    let values;
+    if (event.type === "user/message") {
+      const source = event.data.source;
+      if (source.plugin === PLUGIN_NAME && source.operation === "delete-message") values = source.deletedSeqs;
+    } else if (event.type === "assistant/message") {
+      const replay = event.data.message.source.replayState;
+      const metadata = replay?.dshMoreMessageDelete;
+      if (metadata?.operation === "delete-message") values = metadata.deletedSeqs;
+    }
+    if (Array.isArray(values)) {
+      for (const seq of values) if (Number.isSafeInteger(seq) && seq >= 0) deleted.add(seq);
+    }
+    if (values !== void 0) deleted.add(event.seq);
+  }
+  return deleted;
+}
+function toolCalls(message) {
+  const calls = [];
+  for (const block of message.content) {
+    const value = block;
+    if (value.type !== "tool-call" || typeof value.name !== "string") continue;
+    const callId = typeof value.id === "string" ? value.id : typeof value.callId === "string" ? value.callId : void 0;
+    if (callId === void 0) continue;
+    calls.push({ callId, name: value.name, arguments: typeof value.arguments === "string" ? value.arguments : "{}" });
+  }
+  return calls;
+}
+function buildCleanSeed(source, selection) {
+  const deleted = recordedDeletionSeqs(source.events);
+  for (const seq of selection.shadowedSeqs) deleted.add(seq);
+  const survivors = source.surface.nodes.filter((seq) => !deleted.has(seq)).map((seq) => source.events[seq]).filter((event) => event !== void 0 && source.deriveEventMessage(event) !== null);
+  const rebuilt = Session.create(SessionId4(`session-rebuild-${randomUUID3()}`));
+  let turn = 0;
+  let step = 0;
+  let turnOpen = false;
+  let stepOpen = false;
+  let assistantSeen = false;
+  const loggedCalls = /* @__PURE__ */ new Set();
+  const closeStep = () => {
+    if (!stepOpen) return;
+    rebuilt.append("step/end", { turn, step });
+    stepOpen = false;
+    assistantSeen = false;
+    loggedCalls.clear();
+  };
+  const closeTurn = () => {
+    if (!turnOpen) return;
+    closeStep();
+    rebuilt.append("turn/end", { turn, reason: { kind: "completed" } });
+    turnOpen = false;
+  };
+  const openStep = () => {
+    if (!turnOpen) {
+      turn += 1;
+      step = 0;
+      rebuilt.append("turn/start", { turn });
+      turnOpen = true;
+    }
+    if (!stepOpen) {
+      step += 1;
+      rebuilt.append("step/start", { turn, step });
+      stepOpen = true;
+    }
+  };
+  for (const event of survivors) {
+    if (event.type === "user/message" && event.data.source.kind === "user" && turnOpen) closeTurn();
+    if (event.type === "assistant/message" && assistantSeen) closeStep();
+    openStep();
+    if (event.type === "user/message") {
+      rebuilt.append("user/message", event.data, { surfaceOp: "append" });
+      continue;
+    }
+    if (event.type === "assistant/message") {
+      rebuilt.append("assistant/message", {
+        turn,
+        step,
+        message: event.data.message,
+        ...event.data.usage === void 0 ? {} : { usage: event.data.usage }
+      }, { surfaceOp: "append" });
+      assistantSeen = true;
+      for (const call of toolCalls(event.data.message)) {
+        rebuilt.append("tool/call", { turn, step, callId: CallId(call.callId), name: call.name, arguments: call.arguments });
+        loggedCalls.add(call.callId);
+      }
+      continue;
+    }
+    if (event.type === "tool/result") {
+      const callId = String(event.data.message.source.callId);
+      if (!loggedCalls.has(callId)) {
+        rebuilt.append("tool/call", { turn, step, callId: event.data.message.source.callId, name: "restored-tool", arguments: "{}" });
+        loggedCalls.add(callId);
+      }
+      rebuilt.append("tool/result", { turn, step, message: event.data.message, ...event.data.error === void 0 ? {} : { error: event.data.error }, ...event.data.meta === void 0 ? {} : { meta: event.data.meta } }, { surfaceOp: "append" });
+    }
+  }
+  closeTurn();
+  return rebuilt.events;
+}
+async function createDeletedContinuation(ctx, sourceAgent, selection, childId = SessionId4(`session-${randomUUID3()}`)) {
+  const source = sourceAgent.session;
+  const presetId = resolveSessionPreset2(source);
+  const roster = ctx.get("agentPresets");
+  const request = source.requestHeader()?.config;
+  const provider = request?.provider ?? sourceAgent.options.provider;
+  const model = request?.model ?? sourceAgent.options.model;
+  const seed = buildCleanSeed(source, selection);
+  let firstTurnStarted = false;
+  let releaseRuntimeContextReplay;
+  let releaseStatusWatch;
+  const releaseReplay = () => {
+    const releaseContext = releaseRuntimeContextReplay;
+    const releaseStatus = releaseStatusWatch;
+    releaseRuntimeContextReplay = void 0;
+    releaseStatusWatch = void 0;
+    releaseContext?.();
+    releaseStatus?.();
+  };
+  const child = await ctx.agents.create({
+    sessionId: childId,
+    seed,
+    meta: {
+      ...source.header.cwd === void 0 ? {} : { cwd: source.header.cwd },
+      parentSession: source.id,
+      seedLength: seed.length,
+      ...presetId === void 0 ? {} : { agentPreset: presetId }
+    },
+    agentOptions: {
+      ...provider === void 0 ? {} : { provider },
+      ...model === void 0 ? {} : { model },
+      ...sourceAgent.options.maxTokens === void 0 ? {} : { maxTokens: sourceAgent.options.maxTokens }
+    },
+    setup: (agentCtx) => {
+      roster?.composeFrom(agentCtx, sourceAgent.ctx);
+      releaseRuntimeContextReplay = replaySeedRuntimeContext(agentCtx, seed);
+      releaseStatusWatch = agentCtx.on("agent/status", ({ status }) => {
+        if (status === "running") firstTurnStarted = true;
+        else if (firstTurnStarted) releaseReplay();
+      });
+    }
+  });
+  try {
+    const workspace = ctx.workspaceRegistry.list().find((candidate) => candidate.sessionIds.includes(source.id));
+    if (workspace !== void 0) await workspace.attachSession(childId);
+    await ctx.workspaceRegistry.archiveSession(source.id);
+    return { sessionId: childId };
+  } catch (error) {
+    releaseReplay();
+    await child.dispose().catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/patches/message-delete/host/index.ts
+function targetTurn(session, seq) {
+  return completedTurns(session.events).find((turn) => seq >= turn.startSeq && seq <= turn.endSeq)?.turn ?? 0;
+}
+function facts2(sessionId, session, selection, continuationSessionId) {
+  const turn = targetTurn(session, selection.targetSeq);
+  return {
+    sessionId,
+    startTurn: turn,
+    endTurn: turn,
+    logRevision: session.seq,
+    replaceGeneration: session.surface.replaceGeneration,
+    shadowedSeqs: selection.shadowedSeqs,
+    operation: "delete-message",
+    targetSeq: selection.targetSeq,
+    continuationSessionId
+  };
+}
+function preview2(ctx, secret, payload) {
+  const sessionId = requireString(payload, "sessionId");
+  const session = requireLiveSession(ctx, sessionId);
+  const selection = selectMessageDeletion(session, requireInteger(payload, "targetSeq"));
+  const continuationSessionId = `session-${randomUUID4()}`;
+  return {
+    affectedNodeCount: selection.shadowedSeqs.length,
+    continuationSessionId,
+    confirmToken: createConfirmationToken(secret, facts2(sessionId, session, selection, continuationSessionId))
+  };
+}
+async function commit2(ctx, secret, payload) {
+  const sessionId = requireString(payload, "sessionId");
+  const session = requireLiveSession(ctx, sessionId);
+  const agent = requireIdleAgent(ctx, sessionId, session);
+  return runAgentMaintenance(agent, async (signal) => {
+    signal.throwIfAborted();
+    const selection = selectMessageDeletion(session, requireInteger(payload, "targetSeq"));
+    const continuationSessionId = requireString(payload, "continuationSessionId");
+    verifyConfirmationToken(secret, requireString(payload, "confirmToken"), facts2(sessionId, session, selection, continuationSessionId));
+    const child = await createDeletedContinuation(ctx, agent, selection, SessionId5(continuationSessionId));
+    signal.throwIfAborted();
+    return { sessionId: child.sessionId, deletedSeqs: selection.shadowedSeqs };
+  });
+}
+var hostPatch2 = {
+  id: MESSAGE_DELETE_PATCH_ID,
+  setup: (ctx) => ctx.effect(
+    () => ctx.sessionProjections.register(messageDeleteProjection),
+    `${MESSAGE_DELETE_PATCH_ID}: projection`
+  ),
+  routes: ({ ctx, confirmationSecret }) => ({
+    preview: (payload) => preview2(ctx, confirmationSecret, payload),
+    commit: (payload) => commit2(ctx, confirmationSecret, payload)
+  })
+};
+
+// src/patches/session-delete/shared.ts
+var SESSION_DELETE_PATCH_ID = "session-delete";
+
+// src/patches/session-delete/host/live-session-handles.ts
+var TRACKER = Symbol.for("dsh-more.session-delete.live-session-handles");
+function trackedHandle(tracker, handle) {
+  let disposed = false;
+  const wrapped = {
+    agent: handle.agent,
+    dispose: async () => {
+      if (disposed) return;
+      disposed = true;
+      if (tracker.handles.get(handle.agent.id) === wrapped) tracker.handles.delete(handle.agent.id);
+      await handle.dispose();
+    }
+  };
+  tracker.handles.set(handle.agent.id, wrapped);
+  return wrapped;
+}
+function installLiveSessionHandleTracker(ctx) {
+  const registry = ctx.agents;
+  const existing = registry[TRACKER];
+  if (existing !== void 0) {
+    existing.references += 1;
+    return () => {
+      existing.references -= 1;
+    };
+  }
+  const originalCreate = registry.create;
+  const originalResume = registry.resume;
+  const tracker = { handles: /* @__PURE__ */ new Map() };
+  tracker.originalCreate = originalCreate;
+  tracker.originalResume = originalResume;
+  tracker.wrappedCreate = async (options) => trackedHandle(tracker, await originalCreate.call(registry, options));
+  tracker.wrappedResume = async (options) => trackedHandle(tracker, await originalResume.call(registry, options));
+  tracker.references = 1;
+  registry[TRACKER] = tracker;
+  registry.create = tracker.wrappedCreate;
+  registry.resume = tracker.wrappedResume;
+  return () => {
+    tracker.references -= 1;
+    if (tracker.references > 0 || registry[TRACKER] !== tracker) return;
+    if (registry.create === tracker.wrappedCreate) registry.create = tracker.originalCreate;
+    if (registry.resume === tracker.wrappedResume) registry.resume = tracker.originalResume;
+    delete registry[TRACKER];
+  };
+}
+function getLiveSessionHandle(ctx, sessionId) {
+  return ctx.agents[TRACKER]?.handles.get(sessionId);
+}
+
+// src/patches/session-delete/host/session-deletion.ts
+import { rm, stat } from "node:fs/promises";
+import { dirname, isAbsolute, relative } from "node:path";
+import { SessionId as SessionId6 } from "@deepseek-ai/dsh-session";
+function detachInternal(registry, sessionId, label) {
+  const internal = registry;
+  const entry = internal.store?.get(sessionId);
+  if (entry === void 0) return;
+  if (typeof internal.detachEntered !== "function") {
+    throw new DshMoreError("internal", `\u5F53\u524D DSH \u7248\u672C\u65E0\u6CD5\u5378\u8F7D\u5DF2\u52A0\u8F7D\u7684${label}\u3002`, 500);
+  }
+  internal.detachEntered(entry);
+}
+async function unloadLiveSession(ctx, sessionId) {
+  const agent = ctx.agents.get(sessionId);
+  const session = ctx.sessions.get(sessionId);
+  if (agent !== void 0) {
+    agent.cancel({ kind: "disposed" });
+    await agent.whenIdle();
+  }
+  if (session !== void 0) await ctx.sessions.flush(session);
+  const handle = getLiveSessionHandle(ctx, sessionId);
+  if (handle !== void 0) {
+    await handle.dispose();
+  } else {
+    if (agent !== void 0) {
+      const scope = agent.scope;
+      if (scope === void 0 || typeof scope.dispose !== "function") {
+        throw new DshMoreError("internal", "\u5F53\u524D DSH \u7248\u672C\u65E0\u6CD5\u5378\u8F7D\u5DF2\u52A0\u8F7D\u7684 Agent\u3002", 500);
+      }
+      await scope.dispose();
+      detachInternal(ctx.agents, sessionId, " Agent");
+    }
+    if (session !== void 0) detachInternal(ctx.sessions, sessionId, "\u4F1A\u8BDD");
+  }
+  if (ctx.agents.get(sessionId) !== void 0 || ctx.sessions.get(sessionId) !== void 0) {
+    throw new DshMoreError("internal", "\u4F1A\u8BDD\u505C\u6B62\u540E\u4ECD\u5904\u4E8E\u52A0\u8F7D\u72B6\u6001\uFF0C\u672A\u6267\u884C\u78C1\u76D8\u5220\u9664\u3002", 500);
+  }
+}
+function safeSessionDirectory(locationPath) {
+  if (!isAbsolute(locationPath)) {
+    throw new DshMoreError("internal", "\u5F53\u524D\u6301\u4E45\u5316\u540E\u7AEF\u6CA1\u6709\u8FD4\u56DE\u7EDD\u5BF9\u4F1A\u8BDD\u8DEF\u5F84\u3002", 409);
+  }
+  const sessionDir = dirname(locationPath);
+  const sessionsRoot = dirname(dirname(sessionDir));
+  const withinRoot = relative(sessionsRoot, sessionDir);
+  if (withinRoot === "" || withinRoot.startsWith("..") || isAbsolute(withinRoot)) {
+    throw new DshMoreError("internal", "\u6301\u4E45\u5316\u540E\u7AEF\u8FD4\u56DE\u4E86\u4E0D\u5B89\u5168\u7684\u4F1A\u8BDD\u8DEF\u5F84\u3002", 500);
+  }
+  return sessionDir;
+}
+async function deleteSessionPermanently(ctx, rawSessionId) {
+  const sessionId = SessionId6(rawSessionId);
+  const live = ctx.sessions.get(sessionId);
+  const header2 = (await ctx.sessionPersistence.list()).find((candidate) => candidate.id === sessionId) ?? live?.header;
+  if (header2 === void 0) throw new DshMoreError("not-found", "\u4F1A\u8BDD\u8BB0\u5F55\u4E0D\u5B58\u5728\u3002", 404);
+  const location = ctx.sessionPersistence.locate(header2);
+  if (location === void 0) {
+    throw new DshMoreError("internal", "\u5F53\u524D\u6301\u4E45\u5316\u540E\u7AEF\u4E0D\u652F\u6301\u9010\u4F1A\u8BDD\u7269\u7406\u5220\u9664\u3002", 409);
+  }
+  if (location.kind !== "jsonl") {
+    throw new DshMoreError("internal", `\u6301\u4E45\u5316\u540E\u7AEF ${location.kind} \u4E0D\u652F\u6301\u5B89\u5168\u7684\u9010\u76EE\u5F55\u5220\u9664\u3002`, 409);
+  }
+  const sessionDir = safeSessionDirectory(location.path);
+  await unloadLiveSession(ctx, sessionId);
+  const info = await stat(sessionDir).catch(() => void 0);
+  if (info !== void 0) {
+    if (!info.isDirectory()) throw new DshMoreError("internal", "\u4F1A\u8BDD\u6301\u4E45\u5316\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\u3002", 500);
+    await rm(sessionDir, { recursive: true, force: false });
+  }
+  const workspaces = ctx.workspaceRegistry.list().filter((candidate) => candidate.sessionIds.includes(sessionId));
+  await Promise.all(workspaces.map(async (workspace) => workspace.detachSession(sessionId)));
+  return { sessionId, deletedPath: sessionDir };
+}
+
+// src/patches/session-delete/host/index.ts
+var hostPatch3 = {
+  id: SESSION_DELETE_PATCH_ID,
+  setup: installLiveSessionHandleTracker,
+  routes: ({ ctx }) => ({
+    commit: async (payload) => {
+      const sessionId = requireString(payload, "sessionId");
+      if (requireString(payload, "confirmSessionId") !== sessionId) {
+        throw new DshMoreError("bad-request", "\u4F1A\u8BDD\u5220\u9664\u786E\u8BA4\u4E0D\u5339\u914D\u3002");
+      }
+      return deleteSessionPermanently(ctx, sessionId);
+    }
+  })
+};
+
+// src/generated/host-registry.ts
+var HOST_PATCHES = [hostPatch, hostPatch2, hostPatch3];
+
+// src/generated/patch-catalog.ts
+var DEFAULT_PATCH_SETTINGS = {
+  "message-edit": true,
+  "message-delete": true,
+  "session-delete": true
+};
+
+// src/kernel/host/activation.ts
+var NOOP = () => void 0;
+var HostPatchActivation = class {
+  constructor(ctx, patches) {
+    this.ctx = ctx;
+    this.byId = new Map(patches.map((patch) => [patch.id, patch]));
+  }
+  byId;
+  disposers = /* @__PURE__ */ new Map();
+  settings = { ...DEFAULT_PATCH_SETTINGS };
+  apply(next) {
+    for (const [id, patch] of this.byId) {
+      const enabled = next[id] === true;
+      const active = this.disposers.has(id);
+      if (enabled && !active) this.disposers.set(id, patch.setup?.(this.ctx) ?? NOOP);
+      else if (!enabled && active) {
+        const dispose = this.disposers.get(id);
+        this.disposers.delete(id);
+        dispose?.();
+      }
+    }
+    this.settings = { ...next };
+  }
+  isEnabled(id) {
+    return this.settings[id] === true && this.byId.has(id);
+  }
+  dispose() {
+    for (const dispose of [...this.disposers.values()].reverse()) dispose();
+    this.disposers.clear();
+  }
+};
+
+// src/kernel/host/settings.ts
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+
+// src/generated/host-settings-schema.ts
+import z2 from "@deepseek-ai/schemastery";
+var PatchSettingsSchema = z2.object({
+  "message-edit": z2.boolean().default(true),
+  "message-delete": z2.boolean().default(true),
+  "session-delete": z2.boolean().default(true)
+});
+
+// src/kernel/host/settings.ts
+var PATCH_SETTINGS_NAMESPACE2 = settingsNamespace(PATCH_SETTINGS_NAMESPACE);
+function installPatchSettings(ctx, activation) {
+  let source = () => DEFAULT_PATCH_SETTINGS;
+  activation.apply(source());
+  installSettingsSection(ctx, PATCH_SETTINGS_NAMESPACE2, PatchSettingsSchema, DEFAULT_PATCH_SETTINGS, {
+    setSource: (next) => {
+      source = next;
+    },
+    onChange: () => {
+      activation.apply(source());
+    }
+  });
+}
+
+// src/platform/dsh/host/trust.ts
+function header(req, name2) {
+  const value = req.headers[name2];
+  return typeof value === "string" ? value : void 0;
+}
+function parseAuthority(authority) {
+  try {
+    return new URL(`http://${authority}`);
+  } catch {
+    return void 0;
+  }
+}
+function isLoopback(hostname) {
+  if (hostname === "localhost" || hostname === "[::1]") return true;
+  const parts = hostname.split(".");
+  return parts.length === 4 && parts[0] === "127" && parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+function trustedAuthority(host, entries) {
+  return entries.some((entry) => {
+    const parsed = parseAuthority(entry);
+    if (parsed === void 0) return false;
+    return parsed.port === "" ? parsed.hostname === host.hostname : parsed.host === host.host;
+  });
+}
+function isTrustedMutationRequest(req, trustedHosts) {
+  if (header(req, PLUGIN_MUTATION_HEADER) !== "1") return false;
+  const hostText = header(req, "host");
+  if (hostText === void 0) return false;
+  const host = parseAuthority(hostText);
+  if (host === void 0 || !isLoopback(host.hostname) && !trustedAuthority(host, trustedHosts)) return false;
+  if (header(req, "sec-fetch-site") === "cross-site") return false;
+  const origin = header(req, "origin");
+  if (origin === void 0) return true;
+  try {
+    return new URL(origin).host === host.host;
+  } catch {
+    return false;
+  }
+}
+
+// src/platform/dsh/host/api-router.ts
+function collectRoutes(patches, runtime) {
+  const collected = /* @__PURE__ */ new Map();
+  for (const patch of patches) {
+    for (const [action, handler] of Object.entries(patch.routes(runtime))) {
+      const route = `${patch.id}/${action}`;
+      if (collected.has(route)) throw new Error(`Duplicate patch API route: ${route}`);
+      collected.set(route, { patchId: patch.id, handler });
+    }
+  }
+  return collected;
+}
+function registerPatchApi(ctx, patches, confirmationSecret, isEnabled) {
+  const host = ctx;
+  const routes = collectRoutes(patches, { ctx, confirmationSecret });
+  ctx.effect(() => ctx.webServer.register({
+    kind: "prefix",
+    path: PLUGIN_API_PREFIX,
+    handler: async (req, res) => {
+      if (!isTrustedMutationRequest(req, host.webRuntime.trustedHosts)) {
+        writeError(res, new DshMoreError("forbidden", "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB\u3002", 403));
+        return;
+      }
+      if (req.method !== "POST") {
+        writeError(res, new DshMoreError("method-not-allowed", "\u53EA\u63A5\u53D7 POST \u8BF7\u6C42\u3002", 405));
+        return;
+      }
+      const pathname = new URL(req.url ?? "/", "http://dsh.internal").pathname;
+      const routePrefix = `${PLUGIN_API_PREFIX}/`;
+      const route = pathname.startsWith(routePrefix) ? pathname.slice(routePrefix.length) : "";
+      const registered = routes.get(route);
+      if (registered === void 0) {
+        writeError(res, new DshMoreError("not-found", "\u672A\u77E5\u63A5\u53E3\u3002", 404));
+        return;
+      }
+      if (!isEnabled(registered.patchId)) {
+        writeError(res, new DshMoreError("patch-disabled", "\u8FD9\u4E2A\u8865\u4E01\u5F53\u524D\u5DF2\u5173\u95ED\u3002", 409));
+        return;
+      }
+      try {
+        writeOk(res, await registered.handler(await readJson(req)));
+      } catch (error) {
+        writeError(res, error);
+      }
+    }
+  }), `${PLUGIN_NAME}: patch API`);
+}
+
+// src/index.ts
+var name = PLUGIN_NAME;
+var inject = [
+  "webServer",
+  "webRuntime",
+  "agents",
+  "sessions",
+  "sessionPersistence",
+  "sessionProjections",
+  "workspaceRegistry",
+  "agentPresets",
+  "settings"
+];
+function apply(ctx) {
+  const activation = new HostPatchActivation(ctx, HOST_PATCHES);
+  ctx.effect(() => () => activation.dispose(), `${PLUGIN_NAME}: patch activation`);
+  installPatchSettings(ctx, activation);
+  registerPatchApi(ctx, HOST_PATCHES, randomBytes(32), (patchId) => activation.isEnabled(patchId));
+}
+export {
+  apply,
+  inject,
+  name
+};