codesesh 1.0.1 → 1.0.2

package/dist/{chunk-JHX5OLL4.js → chunk-VAUC2W7I.js}

@@ -121,7 +121,7 @@ function normalizeMessageParts(value) {
   });
 }
 
-// ../core/dist/chunk-ML3TMMX3.mjs
+// ../core/dist/chunk-LE5L4UBM.mjs
 import { chmodSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { basename, dirname, join } from "path";
 import { createHash } from "crypto";
@@ -159,6 +159,15 @@ import { homedir as homedir4, platform as platform3 } from "os";
 import { join as join13 } from "path";
 import { existsSync as existsSync11, readFileSync as readFileSync7, statSync as statSync8 } from "fs";
 import { dirname as dirname6, join as join14 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync4, realpathSync, statSync as statSync10 } from "fs";
+import { basename as basename9, join as join17 } from "path";
+import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync8, readSync as readSync2, statSync as statSync9 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join15, resolve as resolve2 } from "path";
+import * as zlib from "zlib";
+import { createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join16 } from "path";
 var registrations = [];
 function registerAgent(reg) {
   registrations.push(reg);
@@ -8054,6 +8063,1274 @@ var GrokAgent = class extends FileSystemSessionSource {
     ]);
   }
 };
+var DSH_FORMAT_VERSION = 0;
+var PROJECT_SLUG_MAX_LENGTH = 251;
+var STABLE_READ_ATTEMPTS = 3;
+var HEADER_PREFIX_BYTES = 64 * 1024;
+var ZSTD_MAGIC = 4247762216;
+var KNOWN_DSH_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "agent-preset/selected",
+  "agent/inbox/spliced",
+  "approval/asked",
+  "approval/decided",
+  "approval/policy",
+  "assistant/chunk",
+  "assistant/message",
+  "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",
+  "permission/preset",
+  "plan/mode",
+  "request/context",
+  "request/header",
+  "sandbox/mode",
+  "schedule/change",
+  "session/end-seed",
+  "session/title",
+  "session/title-llm-request",
+  "step/end",
+  "step/start",
+  "subagent/descriptor",
+  "todo/write",
+  "tool-workflow/agent-end",
+  "tool-workflow/agent-start",
+  "tool-workflow/run-end",
+  "tool-workflow/run-start",
+  "tool/call",
+  "tool/code-dispatch",
+  "tool/code-dispatch-start",
+  "tool/result",
+  "turn/end",
+  "turn/start",
+  "user/message",
+  "web/deepseek-search-llm-request"
+]);
+var TEXT_CHUNK_ROWS = /* @__PURE__ */ new Set(["text-chunks", "reasoning-chunks"]);
+var TOOL_CALL_CHUNK_ROW = "tool-call-chunks";
+var DshSessionLogError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DshSessionLogError";
+  }
+};
+function expandHomePath(path2) {
+  if (path2 === "~") return homedir5();
+  if (path2.startsWith("~/") || path2.startsWith("~\\")) return join15(homedir5(), path2.slice(2));
+  return path2;
+}
+function resolveDshDataRoot() {
+  const fromEnv = process.env["DSH_HOME"];
+  const selected = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join15(homedir5(), ".dsh");
+  return resolve2(expandHomePath(selected));
+}
+function dshSessionsRoot(dataRoot) {
+  return join15(dataRoot, "sessions");
+}
+function dshAttachmentsRoot(dataRoot) {
+  return join15(dataRoot, "attachments", "v1");
+}
+function dshLogFileName(encoding) {
+  return encoding === "zstd" ? "session.jsonl.zstd" : "session.jsonl";
+}
+function isSafeSegmentChar(ch) {
+  return /^[A-Za-z0-9._-]$/.test(ch);
+}
+function escapeCodeUnit(code) {
+  return `~${code.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function dshEncodeSegment(raw) {
+  if (raw.length === 0) throw new DshSessionLogError("cannot encode an empty path segment");
+  if (raw === ".") return "~002E";
+  if (raw === "..") return "~002E~002E";
+  let out = "";
+  for (let index = 0; index < raw.length; index += 1) {
+    const code = raw.charCodeAt(index);
+    const ch = String.fromCharCode(code);
+    out += ch !== "~" && isSafeSegmentChar(ch) ? ch : escapeCodeUnit(code);
+  }
+  return out;
+}
+function dshProjectKey(cwd) {
+  if (cwd.length === 0) throw new DshSessionLogError("cannot encode an empty project path");
+  let readable = "";
+  let separatorRun = false;
+  for (let index = 0; index < cwd.length; index += 1) {
+    const code = cwd.charCodeAt(index);
+    const ch = String.fromCharCode(code);
+    if (ch === "/" || ch === "\\" || ch === ":") {
+      if (!separatorRun) readable += "-";
+      separatorRun = true;
+      continue;
+    }
+    readable += ch !== "~" && isSafeSegmentChar(ch) ? ch : escapeCodeUnit(code);
+    separatorRun = false;
+  }
+  const slug = readable.replace(/^-+/, "") || "root";
+  return `--${slug.slice(0, PROJECT_SLUG_MAX_LENGTH)}--`;
+}
+function dshLogPath(sessionsRoot, cwd, id, encoding) {
+  const project = cwd === void 0 ? "_no-cwd" : dshProjectKey(cwd);
+  return join15(sessionsRoot, project, dshEncodeSegment(id), dshLogFileName(encoding));
+}
+function sameFileIdentity(before, after) {
+  return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeNs === after.mtimeNs && before.ctimeNs === after.ctimeNs;
+}
+function readDshFileSnapshot(sourcePath) {
+  for (let attempt = 0; attempt < STABLE_READ_ATTEMPTS; attempt += 1) {
+    const before = statSync9(sourcePath, { bigint: true });
+    const buffer = readFileSync8(sourcePath);
+    const after = statSync9(sourcePath, { bigint: true });
+    if (sameFileIdentity(before, after)) return { buffer, stats: after };
+  }
+  throw new DshSessionLogError(
+    `DSH session log ${JSON.stringify(sourcePath)} changed during every read attempt`
+  );
+}
+function dshFileIdentity(stats) {
+  return [stats.dev, stats.ino, stats.size, stats.mtimeNs, stats.ctimeNs].map(String);
+}
+function readFilePrefix(sourcePath, maxBytes) {
+  const handle = openSync2(sourcePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(maxBytes);
+    return buffer.subarray(0, readSync2(handle, buffer, 0, maxBytes, 0));
+  } finally {
+    closeSync2(handle);
+  }
+}
+function resolveZstdDecoder(sourcePath) {
+  const decoder = zlib.zstdDecompressSync;
+  if (typeof decoder !== "function") {
+    throw new DshSessionLogError(
+      `DSH session log ${JSON.stringify(sourcePath)} is Zstandard-compressed, but this Node runtime (${process.version}) has no native Zstandard decoder; DSH itself requires Node ^22.19.0 || >=24.0.0`
+    );
+  }
+  return decoder;
+}
+function scanZstdFrames(buffer, sourcePath, maxFrames = Number.POSITIVE_INFINITY) {
+  const frames = [];
+  let offset = 0;
+  const corrupt2 = (reason) => {
+    throw new DshSessionLogError(
+      `corrupt Zstandard session log ${JSON.stringify(sourcePath)}: ${reason}`
+    );
+  };
+  while (offset < buffer.length) {
+    const start = offset;
+    if (buffer.length - offset < 4) return { frames, tornStart: start };
+    if (buffer.readUInt32LE(offset) !== ZSTD_MAGIC)
+      corrupt2(`invalid frame magic at byte ${offset}`);
+    offset += 4;
+    if (offset === buffer.length) return { frames, tornStart: start };
+    const descriptor = buffer.readUInt8(offset);
+    offset += 1;
+    if ((descriptor & 24) !== 0) corrupt2(`reserved frame-header bit at byte ${offset - 1}`);
+    const contentSizeFlag = descriptor >>> 6;
+    const singleSegment = (descriptor & 32) !== 0;
+    const hasChecksum = (descriptor & 4) !== 0;
+    const dictionaryFlag = descriptor & 3;
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (buffer.length - offset < remainingHeaderBytes) return { frames, tornStart: start };
+    offset += remainingHeaderBytes;
+    for (; ; ) {
+      if (buffer.length - offset < 3) return { frames, tornStart: start };
+      const blockHeader = buffer.readUIntLE(offset, 3);
+      offset += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = blockHeader >>> 1 & 3;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 3) corrupt2(`reserved block type at byte ${offset - 3}`);
+      const payloadBytes = blockType === 1 ? 1 : blockSize;
+      if (buffer.length - offset < payloadBytes) return { frames, tornStart: start };
+      offset += payloadBytes;
+      if (lastBlock) break;
+    }
+    if (hasChecksum) {
+      if (buffer.length - offset < 4) return { frames, tornStart: start };
+      offset += 4;
+    }
+    frames.push({ start, end: offset });
+    if (frames.length === maxFrames) return { frames };
+  }
+  return { frames };
+}
+function decodeFrame(decoder, buffer, frame, sourcePath) {
+  try {
+    return decoder(buffer.subarray(frame.start, frame.end)).toString("utf8");
+  } catch (error) {
+    throw new DshSessionLogError(
+      `corrupt Zstandard session log ${JSON.stringify(sourcePath)}: frame at byte ${frame.start} failed validation`,
+      { cause: error }
+    );
+  }
+}
+function frameRecords(plaintext, sourcePath, frameStart) {
+  if (!plaintext.endsWith("\n")) {
+    throw new DshSessionLogError(
+      `corrupt Zstandard session log ${JSON.stringify(sourcePath)}: complete frame at byte ${frameStart} ends mid-record`
+    );
+  }
+  return plaintext.slice(0, -1).split("\n");
+}
+function warnTornTail(sourcePath, detail) {
+  getCoreDiagnostics()?.warn("dsh.torn_session_tail", { source_path: sourcePath, ...detail });
+}
+function readCompressedRecords(buffer, sourcePath, headerOnly) {
+  const decoder = resolveZstdDecoder(sourcePath);
+  const scan = scanZstdFrames(buffer, sourcePath, headerOnly ? 1 : Number.POSITIVE_INFINITY);
+  const first = scan.frames[0];
+  if (!first) {
+    throw new DshSessionLogError(
+      `DSH session log ${JSON.stringify(sourcePath)} has no complete header frame`
+    );
+  }
+  const headerPlaintext = decodeFrame(decoder, buffer, first, sourcePath);
+  if (headerPlaintext.indexOf("\n") !== headerPlaintext.length - 1) {
+    throw new DshSessionLogError(
+      `corrupt Zstandard session log ${JSON.stringify(sourcePath)}: header frame does not hold exactly one record`
+    );
+  }
+  const records = [headerPlaintext.slice(0, -1)];
+  if (headerOnly) return records;
+  for (const frame of scan.frames.slice(1)) {
+    records.push(
+      ...frameRecords(decodeFrame(decoder, buffer, frame, sourcePath), sourcePath, frame.start)
+    );
+  }
+  if (scan.tornStart !== void 0) {
+    warnTornTail(sourcePath, { encoding: "zstd", torn_start: scan.tornStart });
+  }
+  return records;
+}
+function readPlaintextRecords(buffer, sourcePath, headerOnly) {
+  const text = buffer.toString("utf8");
+  const newline = text.indexOf("\n");
+  if (newline === -1) {
+    throw new DshSessionLogError(
+      `DSH session log ${JSON.stringify(sourcePath)} has no complete header record`
+    );
+  }
+  if (headerOnly) return [text.slice(0, newline)];
+  const complete = text.endsWith("\n");
+  const records = (complete ? text.slice(0, -1) : text).split("\n");
+  if (!complete) {
+    records.pop();
+    warnTornTail(sourcePath, {
+      encoding: "none",
+      torn_bytes: text.length - text.lastIndexOf("\n") - 1
+    });
+  }
+  return records;
+}
+function readRecords(buffer, sourcePath, encoding, headerOnly) {
+  return encoding === "zstd" ? readCompressedRecords(buffer, sourcePath, headerOnly) : readPlaintextRecords(buffer, sourcePath, headerOnly);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function optionalString2(value, field, sourcePath) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: header ${field} must be a string`
+    );
+  }
+  return value;
+}
+function parseJsonRecord2(line, what, sourcePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: ${what} is not valid JSON`,
+      { cause: error }
+    );
+  }
+  if (!isRecord(parsed)) {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: ${what} is not an object`
+    );
+  }
+  return parsed;
+}
+function parseHeaderRecord(line, sourcePath) {
+  const parsed = parseJsonRecord2(line, "header line", sourcePath);
+  const version = parsed["version"];
+  if (typeof version !== "number" || version !== DSH_FORMAT_VERSION) {
+    throw new DshSessionLogError(
+      `unsupported DSH session format version ${JSON.stringify(version)} in ${JSON.stringify(sourcePath)}; this build reads version ${DSH_FORMAT_VERSION}`
+    );
+  }
+  const invalid = (reason) => {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: ${reason}`
+    );
+  };
+  if (parsed["type"] !== "session") invalid("first record is not a session header");
+  const id = parsed["id"];
+  if (typeof id !== "string" || id.length === 0) invalid("header id must be a non-empty string");
+  const createdAt = parsed["createdAt"];
+  if (!isCount(createdAt)) invalid("header createdAt must be a non-negative safe integer");
+  const delegationDepth = parsed["delegationDepth"];
+  if (!isCount(delegationDepth)) {
+    invalid("header delegationDepth must be a non-negative safe integer");
+  }
+  const seedLength = parsed["seedLength"];
+  if (seedLength !== void 0 && !isCount(seedLength)) {
+    invalid("header seedLength must be a non-negative safe integer");
+  }
+  const origin = parsed["origin"];
+  if (origin !== void 0 && origin !== "subagent") invalid("header origin must be 'subagent'");
+  return {
+    id,
+    createdAt,
+    cwd: optionalString2(parsed["cwd"], "cwd", sourcePath),
+    parentSession: optionalString2(parsed["parentSession"], "parentSession", sourcePath),
+    seedLength,
+    origin,
+    delegationDepth,
+    agentPreset: optionalString2(parsed["agentPreset"], "agentPreset", sourcePath)
+  };
+}
+function chunkRunMembers(data, payloadKey, tag, sourcePath) {
+  const malformed = (reason) => {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: malformed ${tag} storage row: ${reason}`
+    );
+  };
+  if (typeof data["turn"] !== "number" || typeof data["step"] !== "number" || typeof data["index"] !== "number") {
+    malformed("turn/step/index must be numbers");
+  }
+  const payload = data[payloadKey];
+  if (!Array.isArray(payload) || payload.length === 0 || payload.some((entry) => typeof entry !== "string")) {
+    malformed(`${payloadKey} must be a non-empty string array`);
+  }
+  const gaps = data["dt"];
+  if (!Array.isArray(gaps) || gaps.some((gap) => !Number.isSafeInteger(gap))) {
+    malformed("dt must be an array of safe integers");
+  }
+  const members = payload;
+  if (gaps.length !== members.length - 1) {
+    malformed(`dt length ${gaps.length} does not match ${members.length} members`);
+  }
+  return { members, gaps };
+}
+function expandChunkRow(row, tag, sourcePath) {
+  const malformed = (reason) => {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: malformed ${tag} storage row: ${reason}`
+    );
+  };
+  const seq0 = row["seq0"];
+  const time0 = row["time0"];
+  if (!isCount(seq0)) malformed("seq0 must be a non-negative safe integer");
+  if (!Number.isSafeInteger(time0)) malformed("time0 must be a safe integer");
+  const data = row["data"];
+  if (!isRecord(data)) malformed("data must be an object");
+  const payload = data;
+  const isToolCall = tag === TOOL_CALL_CHUNK_ROW;
+  const { members, gaps } = chunkRunMembers(
+    payload,
+    isToolCall ? "args" : "texts",
+    tag,
+    sourcePath
+  );
+  const callId = payload["id"];
+  const callName = payload["name"];
+  if (isToolCall) {
+    if (typeof callId !== "string") malformed("id must be a string");
+    if (callName !== void 0 && typeof callName !== "string") malformed("name must be a string");
+  }
+  if (!Number.isSafeInteger(seq0 + members.length - 1)) {
+    malformed("member seqs must stay safe integers");
+  }
+  const turn = payload["turn"];
+  const step = payload["step"];
+  const index = payload["index"];
+  const deltaType = tag === "text-chunks" ? "text-delta" : tag === "reasoning-chunks" ? "reasoning-delta" : "tool-call-delta";
+  const events = [];
+  let time = time0;
+  for (let member = 0; member < members.length; member += 1) {
+    if (member > 0) {
+      time += gaps[member - 1];
+      if (!Number.isSafeInteger(time)) malformed("member times must stay safe integers");
+    }
+    const chunk = isToolCall ? {
+      type: deltaType,
+      index,
+      id: callId,
+      ...callName !== void 0 ? { name: callName } : {},
+      argumentsDelta: members[member]
+    } : { type: deltaType, index, text: members[member] };
+    events.push({
+      type: "assistant/chunk",
+      seq: seq0 + member,
+      time,
+      data: { turn, step, chunk }
+    });
+  }
+  return events;
+}
+function decodeStorageRecord(line, sourcePath) {
+  const parsed = parseJsonRecord2(line, "event record", sourcePath);
+  const tag = parsed["type"];
+  if (typeof tag === "string" && (TEXT_CHUNK_ROWS.has(tag) || tag === TOOL_CALL_CHUNK_ROW)) {
+    return expandChunkRow(parsed, tag, sourcePath);
+  }
+  if (typeof tag !== "string" || tag.length === 0) {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: event record has no type`
+    );
+  }
+  if (!KNOWN_DSH_EVENT_TYPES.has(tag) && parsed["ignorable"] !== true) {
+    throw new DshSessionLogError(
+      `DSH session log ${JSON.stringify(sourcePath)} contains unsupported required event ${JSON.stringify(tag)}; upgrade CodeSesh to read it`
+    );
+  }
+  if (!isCount(parsed["seq"]) || !Number.isSafeInteger(parsed["time"])) {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: event ${JSON.stringify(tag)} has an invalid seq/time`
+    );
+  }
+  return [parsed];
+}
+function readDshSessionHeader(sourcePath, encoding) {
+  const prefix = readFilePrefix(sourcePath, HEADER_PREFIX_BYTES);
+  const line = firstRecordOf(prefix, sourcePath, encoding, prefix.length === HEADER_PREFIX_BYTES) ?? firstRecordOf(readFileSync8(sourcePath), sourcePath, encoding, false);
+  return parseHeaderRecord(line, sourcePath);
+}
+function firstRecordOf(buffer, sourcePath, encoding, mayBeTruncated) {
+  if (mayBeTruncated) {
+    const complete = encoding === "zstd" ? scanZstdFrames(buffer, sourcePath, 1).frames.length > 0 : buffer.includes(10);
+    if (!complete) return null;
+  }
+  return readRecords(buffer, sourcePath, encoding, true)[0];
+}
+function readDshSessionLog(sourcePath, encoding) {
+  const { buffer } = readDshFileSnapshot(sourcePath);
+  const records = readRecords(buffer, sourcePath, encoding, false);
+  const header = parseHeaderRecord(records[0], sourcePath);
+  const events = [];
+  for (let line = 1; line < records.length; line += 1) {
+    for (const event of decodeStorageRecord(records[line], sourcePath)) {
+      if (event.seq !== events.length) {
+        throw new DshSessionLogError(
+          `corrupt DSH session log ${JSON.stringify(sourcePath)}: seq ${event.seq} at record ${line} breaks the contiguous prefix (expected ${events.length})`
+        );
+      }
+      events.push(event);
+    }
+  }
+  if (header.seedLength !== void 0 && header.seedLength > events.length) {
+    throw new DshSessionLogError(
+      `corrupt DSH session log ${JSON.stringify(sourcePath)}: seedLength ${header.seedLength} exceeds ${events.length} events`
+    );
+  }
+  return { header, events };
+}
+var AGENT_NAME = "dsh";
+var IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif"
+]);
+var ATTACHMENT_ID_PATTERN = /^sha256:([a-f0-9]{64})$/;
+var IMAGE_UNAVAILABLE_TEXT = "Image attachment unavailable";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord2(value) {
+  return isRecord2(value) ? value : {};
+}
+function asText(value) {
+  return typeof value === "string" ? value : "";
+}
+function corrupt(context, reason) {
+  throw new DshSessionLogError(
+    `corrupt DSH session log ${JSON.stringify(context.sourcePath)}: ${reason}`
+  );
+}
+function warn(context, event, detail) {
+  getCoreDiagnostics()?.warn(event, {
+    agent: AGENT_NAME,
+    session_id: context.sessionId,
+    ...detail
+  });
+}
+var SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "user/message",
+  "assistant/message",
+  "tool/result"
+]);
+function isAppendOrigin(event, context) {
+  if (!SURFACE_EVENT_TYPES.has(event.type)) return false;
+  const op = event.surfaceOp;
+  if (op === "append") return true;
+  if (op === void 0) {
+    corrupt(
+      context,
+      `surface event ${JSON.stringify(event.type)} at seq ${event.seq} has no surfaceOp`
+    );
+  }
+  const replace = asRecord2(op);
+  if (replace["op"] !== "replace" || !Number.isSafeInteger(replace["start"]) || !Number.isSafeInteger(replace["end"])) {
+    corrupt(
+      context,
+      `surface event ${JSON.stringify(event.type)} at seq ${event.seq} has an invalid surfaceOp`
+    );
+  }
+  return false;
+}
+function readImageBlock(block, timeMs, context) {
+  const attachment = asRecord2(block["attachment"]);
+  const attachmentId = asText(attachment["attachmentId"]);
+  const mediaType = asText(attachment["mediaType"]);
+  const digest = ATTACHMENT_ID_PATTERN.exec(attachmentId)?.[1];
+  const reject = (reason) => {
+    warn(context, "dsh.attachment_unreadable", { attachment_id: attachmentId, reason });
+    return null;
+  };
+  if (!digest) return reject("invalid attachment reference");
+  if (!IMAGE_MEDIA_TYPES.has(mediaType)) return reject("unsupported media type");
+  let data;
+  try {
+    data = readFileSync9(join16(context.attachmentsRoot, "objects", digest.slice(0, 2), digest));
+  } catch {
+    return reject("attachment object is missing");
+  }
+  const declaredBytes = attachment["bytes"];
+  if (typeof declaredBytes === "number" && data.byteLength !== declaredBytes) {
+    return reject("attachment byte length does not match its reference");
+  }
+  if (createHash3("sha256").update(data).digest("hex") !== digest) {
+    return reject("attachment failed integrity verification");
+  }
+  return {
+    type: "image",
+    data: data.toString("base64"),
+    mime_type: mediaType,
+    time_created: timeMs
+  };
+}
+function convertContentBlocks(content, timeMs, context, canonicalCallIds) {
+  if (!Array.isArray(content)) return [];
+  const parts = [];
+  let droppedImages = 0;
+  for (const raw of content) {
+    const block = asRecord2(raw);
+    switch (block["type"]) {
+      case "text":
+      case "reasoning": {
+        const text = cleanInternalText(asText(block["text"]));
+        if (text) parts.push({ type: block["type"], text, time_created: timeMs });
+        break;
+      }
+      case "image": {
+        const image = readImageBlock(block, timeMs, context);
+        if (image) parts.push(image);
+        else droppedImages += 1;
+        break;
+      }
+      case "tool-call": {
+        const callId = asText(block["id"]);
+        if (callId && canonicalCallIds.has(callId)) break;
+        parts.push(buildToolPart2(callId, asText(block["name"]), block["arguments"], timeMs));
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (parts.length === 0 && droppedImages > 0) {
+    parts.push({ type: "text", text: IMAGE_UNAVAILABLE_TEXT, time_created: timeMs });
+  }
+  return parts;
+}
+function parseToolArguments(raw) {
+  if (typeof raw !== "string") return raw ?? {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function buildToolPart2(callId, name, rawArguments, timeMs) {
+  const tool = name.trim() || "tool";
+  return {
+    type: "tool",
+    tool,
+    title: tool.toLowerCase(),
+    callID: callId || void 0,
+    time_created: timeMs,
+    state: { status: "running", input: parseToolArguments(rawArguments) }
+  };
+}
+function nonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function readUsage(value) {
+  if (!isRecord2(value)) return null;
+  return {
+    inputTokens: nonNegative(value["inputTokens"]),
+    outputTokens: nonNegative(value["outputTokens"]),
+    cacheReadTokens: nonNegative(value["cacheReadTokens"]),
+    cacheWriteTokens: nonNegative(value["cacheWriteTokens"]),
+    reasoningTokens: nonNegative(value["reasoningTokens"])
+  };
+}
+function toMessageTokens(usage) {
+  const cacheRead = nonNegative(usage.cacheReadTokens);
+  const cacheCreate = nonNegative(usage.cacheWriteTokens);
+  const totalInput = nonNegative(usage.inputTokens) + cacheRead + cacheCreate;
+  const output = nonNegative(usage.outputTokens);
+  const reasoning = Math.min(nonNegative(usage.reasoningTokens), output);
+  return {
+    tokens: {
+      input: totalInput,
+      output: output - reasoning,
+      reasoning: reasoning || void 0,
+      cache_read: cacheRead || void 0,
+      cache_create: cacheCreate || void 0
+    },
+    totals: { input: totalInput, output, cacheRead, cacheCreate, cost: 0 }
+  };
+}
+var DshProjector = class {
+  constructor(context, seedLength, canonicalCallIds) {
+    this.context = context;
+    this.seedLength = seedLength;
+    this.canonicalCallIds = canonicalCallIds;
+  }
+  context;
+  seedLength;
+  canonicalCallIds;
+  builder = new TranscriptBuilder({ messageDefaults: "sparse" });
+  totals = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheCreate: 0,
+    cost: 0
+  };
+  modelUsage = {};
+  settledSteps = /* @__PURE__ */ new Set();
+  pending = null;
+  provider = null;
+  model = null;
+  ownTitle = null;
+  inheritedTitle = null;
+  subagentLabel = null;
+  firstHumanText = null;
+  updatedAt = 0;
+  project(events) {
+    for (const event of events) {
+      const own = event.seq >= this.seedLength;
+      if (own) this.updatedAt = Math.max(this.updatedAt, event.time);
+      this.consume(event, own);
+    }
+    this.flushPendingStep();
+    const result = this.builder.finish({
+      message_count: 0,
+      total_input_tokens: this.totals.input,
+      total_output_tokens: this.totals.output,
+      total_cache_read_tokens: this.totals.cacheRead || void 0,
+      total_cache_create_tokens: this.totals.cacheCreate || void 0,
+      total_cost: this.totals.cost,
+      cost_source: this.totals.cost > 0 ? "estimated" : void 0
+    });
+    return {
+      messages: result.messages,
+      stats: result.stats,
+      modelUsage: this.modelUsage,
+      title: this.resolveTitle(),
+      updatedAt: this.updatedAt
+    };
+  }
+  consume(event, own) {
+    switch (event.type) {
+      case "user/message":
+        this.consumeUserMessage(event, own);
+        return;
+      case "assistant/message":
+        this.consumeAssistantMessage(event, own);
+        return;
+      case "tool/call":
+        if (own) this.consumeToolCall(event);
+        return;
+      case "tool/result":
+        if (isAppendOrigin(event, this.context) && own) this.consumeToolResult(event);
+        return;
+      case "assistant/chunk":
+        if (own) this.consumeChunk(event);
+        return;
+      case "request/context":
+        this.consumeRequestContext(event);
+        return;
+      case "session/title":
+        this.consumeTitle(event, own);
+        return;
+      case "subagent/descriptor":
+        if (own) this.consumeSubagentDescriptor(event);
+        return;
+      default:
+        return;
+    }
+  }
+  consumeUserMessage(event, own) {
+    const appendOrigin = isAppendOrigin(event, this.context);
+    const data = asRecord2(event.data);
+    if (!appendOrigin || !own || asRecord2(data["source"])["kind"] !== "user") return;
+    const parts = convertContentBlocks(
+      data["content"],
+      event.time,
+      this.context,
+      this.canonicalCallIds
+    );
+    if (parts.length === 0) return;
+    this.builder.appendMessage({
+      id: asText(data["id"]) || `dsh-user-${event.seq}`,
+      role: "user",
+      timestampMs: event.time,
+      parts
+    });
+    this.firstHumanText ??= firstTextBlock(data["content"]);
+  }
+  consumeAssistantMessage(event, own) {
+    const appendOrigin = isAppendOrigin(event, this.context);
+    const data = asRecord2(event.data);
+    const turn = data["turn"];
+    const step = data["step"];
+    if (typeof turn === "number" && typeof step === "number") {
+      this.settleStep(turn, step);
+    }
+    if (!appendOrigin || !own) return;
+    const message = asRecord2(data["message"]);
+    const source = asRecord2(message["source"]);
+    const provider = asText(source["provider"]) || null;
+    const model = asText(source["model"]) || null;
+    if (provider) this.provider = provider;
+    if (model) this.model = model;
+    const parts = convertContentBlocks(
+      message["content"],
+      event.time,
+      this.context,
+      this.canonicalCallIds
+    );
+    const usage = readUsage(data["usage"]);
+    this.appendAssistant({
+      id: asText(message["id"]) || `dsh-assistant-${event.seq}`,
+      timeMs: event.time,
+      parts,
+      provider,
+      model,
+      usage
+    });
+  }
+  consumeToolCall(event) {
+    const data = asRecord2(event.data);
+    const callId = asText(data["callId"]);
+    const part = buildToolPart2(callId, asText(data["name"]), data["arguments"], event.time);
+    this.builder.appendToolCall(
+      part,
+      { id: callId, timestampMs: event.time, agent: AGENT_NAME },
+      { target: "current" }
+    );
+  }
+  consumeToolResult(event) {
+    const data = asRecord2(event.data);
+    const message = asRecord2(data["message"]);
+    const source = asRecord2(message["source"]);
+    if (source["kind"] !== "tool") {
+      corrupt(this.context, `tool/result at seq ${event.seq} is not sourced from a tool call`);
+    }
+    const callId = asText(source["callId"]);
+    const content = Array.isArray(message["content"]) ? message["content"] : [];
+    const block = asRecord2(content[0]);
+    if (content.length !== 1 || block["type"] !== "tool-result") {
+      corrupt(
+        this.context,
+        `tool/result at seq ${event.seq} must carry exactly one tool-result block`
+      );
+    }
+    if (asText(block["toolCallId"]) !== callId) {
+      corrupt(this.context, `tool/result at seq ${event.seq} disagrees with its call identity`);
+    }
+    const failed = block["isError"] === true || isRecord2(data["error"]);
+    const resolved = this.builder.resolveToolCall(callId, {
+      output: convertContentBlocks(
+        block["content"],
+        event.time,
+        this.context,
+        this.canonicalCallIds
+      ),
+      status: failed ? "error" : "completed",
+      metadata: data["meta"],
+      consume: true
+    });
+    if (!resolved) {
+      warn(this.context, "dsh.orphan_tool_result", { call_id: callId, seq: event.seq });
+    }
+  }
+  consumeChunk(event) {
+    const data = asRecord2(event.data);
+    const turn = data["turn"];
+    const step = data["step"];
+    if (typeof turn !== "number" || typeof step !== "number") return;
+    if (this.settledSteps.has(stepKey(turn, step))) return;
+    const pending2 = this.openStep(turn, step, event.time);
+    pending2.lastTime = event.time;
+    applyChunk(pending2, asRecord2(data["chunk"]));
+  }
+  consumeRequestContext(event) {
+    const data = asRecord2(event.data);
+    const provider = asText(data["provider"]);
+    const model = asText(data["model"]);
+    if (provider) this.provider = provider;
+    if (model) this.model = model;
+  }
+  consumeTitle(event, own) {
+    const title = normalizeTitleText(asText(asRecord2(event.data)["title"]));
+    if (!title) return;
+    if (own) this.ownTitle = title;
+    else this.inheritedTitle = title;
+  }
+  consumeSubagentDescriptor(event) {
+    const label = normalizeTitleText(asText(asRecord2(event.data)["label"]));
+    if (label) this.subagentLabel ??= label;
+  }
+  /** A settled message supersedes the streaming deltas of the same step. */
+  settleStep(turn, step) {
+    this.settledSteps.add(stepKey(turn, step));
+    if (this.pending?.turn === turn && this.pending.step === step) this.pending = null;
+  }
+  openStep(turn, step, timeMs) {
+    if (this.pending && (this.pending.turn !== turn || this.pending.step !== step)) {
+      this.flushPendingStep();
+    }
+    this.pending ??= {
+      turn,
+      step,
+      firstTime: timeMs,
+      lastTime: timeMs,
+      blocks: /* @__PURE__ */ new Map(),
+      usage: null
+    };
+    return this.pending;
+  }
+  /** Rebuild the assistant message of a step the log was cut short in. */
+  flushPendingStep() {
+    const pending2 = this.pending;
+    this.pending = null;
+    if (!pending2) return;
+    const parts = [];
+    for (const index of [...pending2.blocks.keys()].sort((a, b) => a - b)) {
+      const block = pending2.blocks.get(index);
+      if (block.type === "tool-call") {
+        if (this.canonicalCallIds.has(block.id)) continue;
+        parts.push(buildToolPart2(block.id, block.name, block.args, pending2.lastTime));
+        continue;
+      }
+      const text = cleanInternalText(block.text);
+      if (text) parts.push({ type: block.type, text, time_created: pending2.firstTime });
+    }
+    if (parts.length === 0) return;
+    this.appendAssistant({
+      id: `dsh-step-${pending2.turn}-${pending2.step}`,
+      timeMs: pending2.firstTime,
+      parts,
+      provider: this.provider,
+      model: this.model,
+      usage: pending2.usage
+    });
+  }
+  appendAssistant(input) {
+    const mapped = input.usage ? toMessageTokens(input.usage) : null;
+    const cost = mapped ? estimateTokenCost(input.model, mapped.tokens) ?? 0 : 0;
+    if (mapped) {
+      this.totals.input += mapped.totals.input;
+      this.totals.output += mapped.totals.output;
+      this.totals.cacheRead += mapped.totals.cacheRead;
+      this.totals.cacheCreate += mapped.totals.cacheCreate;
+      this.totals.cost += cost;
+      if (input.model) {
+        const billed = mapped.totals.input + mapped.totals.output;
+        this.modelUsage[input.model] = (this.modelUsage[input.model] ?? 0) + billed;
+      }
+    }
+    if (input.parts.length === 0) return;
+    this.builder.appendMessage({
+      id: input.id,
+      role: "assistant",
+      agent: AGENT_NAME,
+      timestampMs: input.timeMs,
+      parts: input.parts,
+      provider: input.provider,
+      model: input.model,
+      tokens: mapped?.tokens,
+      cost: cost || void 0,
+      costSource: cost > 0 ? "estimated" : void 0
+    });
+  }
+  resolveTitle() {
+    return this.ownTitle ?? this.subagentLabel ?? this.firstHumanText ?? this.inheritedTitle;
+  }
+};
+function stepKey(turn, step) {
+  return `${turn}:${step}`;
+}
+function firstTextBlock(content) {
+  if (!Array.isArray(content)) return null;
+  for (const raw of content) {
+    const block = asRecord2(raw);
+    if (block["type"] !== "text") continue;
+    const text = cleanInternalText(asText(block["text"]));
+    if (text) return text;
+  }
+  return null;
+}
+function applyChunk(pending2, chunk) {
+  const index = chunk["index"];
+  if (typeof index !== "number") {
+    if (chunk["type"] === "usage") pending2.usage = readUsage(chunk["usage"]);
+    return;
+  }
+  switch (chunk["type"]) {
+    case "text-delta":
+    case "reasoning-delta": {
+      const type = chunk["type"] === "text-delta" ? "text" : "reasoning";
+      const current = pending2.blocks.get(index);
+      const text = current && current.type === type ? current.text : "";
+      pending2.blocks.set(index, { type, text: text + asText(chunk["text"]) });
+      return;
+    }
+    case "tool-call-delta": {
+      const current = pending2.blocks.get(index);
+      const args = current && current.type === "tool-call" ? current.args : "";
+      const name = current && current.type === "tool-call" ? current.name : "";
+      pending2.blocks.set(index, {
+        type: "tool-call",
+        id: asText(chunk["id"]),
+        name: asText(chunk["name"]) || name,
+        args: args + asText(chunk["argumentsDelta"])
+      });
+      return;
+    }
+    case "block-end": {
+      const block = asRecord2(chunk["block"]);
+      if (block["type"] === "text" || block["type"] === "reasoning") {
+        pending2.blocks.set(index, { type: block["type"], text: asText(block["text"]) });
+      } else if (block["type"] === "tool-call") {
+        pending2.blocks.set(index, {
+          type: "tool-call",
+          id: asText(block["id"]),
+          name: asText(block["name"]),
+          args: asText(block["arguments"])
+        });
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+function collectCanonicalCallIds(events, context) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.type !== "tool/call") continue;
+    const callId = asText(asRecord2(event.data)["callId"]);
+    if (!callId) corrupt(context, `tool/call at seq ${event.seq} has no call id`);
+    if (ids.has(callId)) corrupt(context, `duplicate tool call id ${JSON.stringify(callId)}`);
+    ids.add(callId);
+  }
+  return ids;
+}
+function projectDshSession(options) {
+  const context = {
+    sessionId: options.header.id,
+    sourcePath: options.sourcePath,
+    attachmentsRoot: options.attachmentsRoot
+  };
+  const projector = new DshProjector(
+    context,
+    options.header.seedLength ?? 0,
+    collectCanonicalCallIds(options.events, context)
+  );
+  const projection = projector.project(options.events);
+  return {
+    ...projection,
+    updatedAt: projection.updatedAt || options.header.createdAt
+  };
+}
+var PARSER_REVISION = "dsh-parser-v1";
+var ENCODINGS = ["zstd", "none"];
+function encodingOfPath(sourcePath) {
+  return basename9(sourcePath) === dshLogFileName("zstd") ? "zstd" : "none";
+}
+function sameFile(left, right) {
+  if (left === right) return true;
+  try {
+    return realpathSync(left) === realpathSync(right);
+  } catch {
+    return false;
+  }
+}
+var DshAgent = class extends FileSystemSessionSource {
+  name = "dsh";
+  displayName = "DSH";
+  getSessionWatchPlan() {
+    const dataRoot = resolveDshDataRoot();
+    return {
+      status: "supported",
+      targets: [{ root: dataRoot, path: dshSessionsRoot(dataRoot) }]
+    };
+  }
+  isAvailable() {
+    try {
+      return this.listArtifacts().length > 0;
+    } catch {
+      return true;
+    }
+  }
+  listSessionSources(options) {
+    const sessionsRoot = dshSessionsRoot(resolveDshDataRoot());
+    const refs = [];
+    const seenIds = /* @__PURE__ */ new Map();
+    for (const artifact of this.listArtifacts()) {
+      const stats = this.statArtifact(artifact.sourcePath);
+      if (!stats) continue;
+      if (!matchesScanWindow(Number(stats.mtimeMs), options)) continue;
+      const header = this.enumerationStep(
+        "reading session headers",
+        artifact.sourcePath,
+        () => readDshSessionHeader(artifact.sourcePath, artifact.encoding)
+      );
+      this.assertStoredIdentity(sessionsRoot, artifact, header);
+      const previous = seenIds.get(header.id);
+      if (previous) {
+        throw new SessionScanError(this.name, "enumerating session sources", {
+          cause: new DshSessionLogError(
+            `duplicate DSH session id ${JSON.stringify(header.id)} in ${JSON.stringify(previous)} and ${JSON.stringify(artifact.sourcePath)}`
+          ),
+          sourcePath: artifact.sourcePath
+        });
+      }
+      seenIds.set(header.id, artifact.sourcePath);
+      refs.push({
+        sessionId: header.id,
+        sourcePath: artifact.sourcePath,
+        fingerprint: JSON.stringify([
+          PARSER_REVISION,
+          artifact.encoding,
+          ...dshFileIdentity(stats)
+        ])
+      });
+    }
+    return refs;
+  }
+  /** The scan window is applied during enumeration, so parsing needs no options. */
+  scanSessionSource(sourcePath) {
+    return getParsedSession(
+      this.scanSessionSourceResult({ sessionId: "", sourcePath, fingerprint: "" })
+    );
+  }
+  scanSessionSourceResult(source) {
+    const encoding = encodingOfPath(source.sourcePath);
+    const { header, projection } = this.parseSession(source.sourcePath, encoding);
+    if (projection.messages.length === 0) {
+      return filteredSession("no visible messages");
+    }
+    const head = {
+      id: header.id,
+      slug: `${this.name}/${header.id}`,
+      title: this.resolveTitle(header, projection),
+      directory: header.cwd ?? "",
+      ...header.parentSession ? { parent_reference: { agentName: this.name, sessionId: header.parentSession } } : {},
+      time_created: header.createdAt,
+      time_updated: projection.updatedAt,
+      stats: projection.stats,
+      ...Object.keys(projection.modelUsage).length > 0 ? { model_usage: projection.modelUsage } : {}
+    };
+    this.sessionMetaMap.set(head.id, {
+      id: head.id,
+      sourcePath: source.sourcePath,
+      sourceFingerprint: JSON.stringify([
+        PARSER_REVISION,
+        encoding,
+        ...dshFileIdentity(statSync10(source.sourcePath, { bigint: true }))
+      ]),
+      sourceMtimeMs: statSync10(source.sourcePath).mtimeMs,
+      encoding,
+      directory: head.directory,
+      title: head.title,
+      createdAt: head.time_created,
+      updatedAt: projection.updatedAt,
+      messageCount: projection.messages.length,
+      parentSessionId: header.parentSession ?? null
+    });
+    return parsedSession(head);
+  }
+  getSessionData(sessionId) {
+    const meta = this.sessionMetaMap.get(sessionId);
+    if (!meta) throw new Error(`Session not found: ${sessionId}`);
+    const { header, projection } = this.parseSession(meta.sourcePath, meta.encoding);
+    return {
+      reference: { agentName: this.name, sessionId: header.id },
+      id: header.id,
+      title: this.resolveTitle(header, projection),
+      slug: `${this.name}/${header.id}`,
+      directory: header.cwd ?? "",
+      ...header.parentSession ? { parent_reference: { agentName: this.name, sessionId: header.parentSession } } : {},
+      version: "0",
+      time_created: header.createdAt,
+      time_updated: projection.updatedAt,
+      stats: projection.stats,
+      messages: projection.messages
+    };
+  }
+  /**
+   * A cached head with no visible messages was materialized from context-only
+   * events; dropping it keeps blank sessions out of the list after a restart.
+   */
+  filterCachedSessions(sessions) {
+    return sessions.filter((session) => session.stats.message_count > 0);
+  }
+  parseSession(sourcePath, encoding) {
+    const dataRoot = resolveDshDataRoot();
+    const { header, events } = readDshSessionLog(sourcePath, encoding);
+    return {
+      header,
+      projection: projectDshSession({
+        header,
+        events,
+        sourcePath,
+        attachmentsRoot: dshAttachmentsRoot(dataRoot)
+      })
+    };
+  }
+  resolveTitle(header, projection) {
+    return resolveSessionTitle(projection.title, null, basenameTitle(header.cwd ?? null));
+  }
+  /**
+   * Walk `sessions/<project>/<session>/` and reject the layouts DSH itself
+   * refuses: a flat pre-directory artifact, and a root or session directory
+   * holding both physical encodings (which one is current is unknowable).
+   */
+  listArtifacts() {
+    const sessionsRoot = dshSessionsRoot(resolveDshDataRoot());
+    const artifacts = [];
+    let rootEncoding = null;
+    for (const project of this.listDirectories(sessionsRoot, true)) {
+      this.rejectLegacyLayout(project);
+      for (const sessionDir of this.listDirectories(project, false)) {
+        const present = ENCODINGS.filter(
+          (encoding2) => existsSync12(join17(sessionDir, dshLogFileName(encoding2)))
+        );
+        if (present.length === 0) continue;
+        if (present.length > 1) {
+          this.rejectEnumeration(
+            sessionDir,
+            `session directory ${JSON.stringify(sessionDir)} holds both physical encodings`
+          );
+        }
+        const encoding = present[0];
+        if (rootEncoding !== null && rootEncoding !== encoding) {
+          this.rejectEnumeration(
+            sessionDir,
+            `session root ${JSON.stringify(sessionsRoot)} mixes ${rootEncoding} and ${encoding} artifacts`
+          );
+        }
+        rootEncoding = encoding;
+        artifacts.push({ sourcePath: join17(sessionDir, dshLogFileName(encoding)), encoding });
+      }
+    }
+    return artifacts;
+  }
+  listDirectories(directory, tolerateMissing) {
+    try {
+      return readdirSync4(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join17(directory, entry.name));
+    } catch (error) {
+      if (tolerateMissing && isMissingDirectory(error)) return [];
+      throw new SessionScanError(this.name, "enumerating session sources", {
+        cause: error,
+        sourcePath: directory
+      });
+    }
+  }
+  rejectLegacyLayout(project) {
+    const legacy = readdirSync4(project, { withFileTypes: true }).find(
+      (entry) => entry.isFile() && (entry.name.endsWith(".jsonl") || entry.name.endsWith(".jsonl.zstd"))
+    );
+    if (!legacy) return;
+    this.rejectEnumeration(
+      join17(project, legacy.name),
+      `session artifact ${JSON.stringify(join17(project, legacy.name))} uses the unsupported flat-file layout`
+    );
+  }
+  /** The header's id and cwd must name exactly the artifact they were read from. */
+  assertStoredIdentity(sessionsRoot, artifact, header) {
+    let expected;
+    try {
+      expected = dshLogPath(sessionsRoot, header.cwd, header.id, artifact.encoding);
+    } catch (error) {
+      this.rejectEnumeration(
+        artifact.sourcePath,
+        `header id ${JSON.stringify(header.id)} cannot name a storage path`,
+        error
+      );
+    }
+    if (!sameFile(artifact.sourcePath, expected)) {
+      this.rejectEnumeration(
+        artifact.sourcePath,
+        `header identifies ${JSON.stringify(expected)}, not ${JSON.stringify(artifact.sourcePath)}`
+      );
+    }
+  }
+  enumerationStep(stage, sourcePath, read) {
+    try {
+      return read();
+    } catch (error) {
+      throw new SessionScanError(this.name, stage, { cause: error, sourcePath });
+    }
+  }
+  statArtifact(sourcePath) {
+    try {
+      return statSync10(sourcePath, { bigint: true });
+    } catch (error) {
+      if (isMissingDirectory(error)) return null;
+      throw new SessionScanError(this.name, "reading session source metadata", {
+        cause: error,
+        sourcePath
+      });
+    }
+  }
+  rejectEnumeration(sourcePath, reason, cause) {
+    throw new SessionScanError(this.name, "enumerating session sources", {
+      cause: new DshSessionLogError(reason, cause ? { cause } : void 0),
+      sourcePath
+    });
+  }
+};
+function isMissingDirectory(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return false;
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
 registerAgent({
   icon: "/icon/agent/claudecode.svg",
   iconColored: true,
@@ -8111,6 +9388,16 @@ registerAgent({
   toolStrategy: "custom",
   create: () => new PiAgent()
 });
+registerAgent({
+  icon: "/icon/agent/dsh.svg",
+  iconColored: true,
+  resolveDataRoot: resolveDshDataRoot,
+  // The DSH launcher hands inner arguments to a profile, so no single resume
+  // command holds across installations.
+  resumeCommandPrefix: null,
+  toolStrategy: "custom",
+  create: () => new DshAgent()
+});
 registerAgent({
   icon: "/icon/agent/cursor.svg",
   resolveDataRoot: resolveCursorDataRoot,
@@ -8659,15 +9946,15 @@ var SAMPLE_DASHBOARD_DATA = {
 // ../core/dist/index.mjs
 import { availableParallelism } from "os";
 import { Worker } from "worker_threads";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { spawnSync } from "child_process";
 import * as os from "os";
 import * as path from "path";
-import { createHash as createHash3 } from "crypto";
-import { resolve as resolve2, sep } from "path";
+import { createHash as createHash4 } from "crypto";
+import { resolve as resolve3, sep } from "path";
 import { existsSync as existsSync32, rmSync as rmSync2, unlinkSync } from "fs";
 import { existsSync as existsSync22 } from "fs";
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 import { homedir as homedir22 } from "os";
 import { createHash as createHash22 } from "crypto";
 import { randomUUID } from "crypto";
@@ -8681,11 +9968,11 @@ function fallbackDisplayName(input) {
 }
 var realFs = {
   exists(path2) {
-    return existsSync12(path2);
+    return existsSync13(path2);
   },
   readText(path2) {
     try {
-      return readFileSync8(path2, "utf8");
+      return readFileSync10(path2, "utf8");
     } catch {
       return null;
     }
@@ -8830,7 +10117,7 @@ function projectIdentityProjection(identity, resolverRevision, inputs) {
   return {
     identity,
     resolverRevision,
-    inputSignature: createHash3("sha256").update(JSON.stringify(inputs)).digest("hex")
+    inputSignature: createHash4("sha256").update(JSON.stringify(inputs)).digest("hex")
   };
 }
 function loose() {
@@ -8955,7 +10242,7 @@ function isPathScopeMatch(queryPath, sessionPath) {
   return session === queryPath || session.startsWith(queryPath + "/") || queryPath.startsWith(session + "/");
 }
 function normalizeScopePath(path2) {
-  return resolve2(path2).replaceAll(sep, "/");
+  return resolve3(path2).replaceAll(sep, "/");
 }
 var SMART_TAG_CLASSIFIER_REVISION = "smart-tags-v1";
 var TAG_ORDER = [
@@ -9046,12 +10333,12 @@ function hasEditedDocPath(value) {
   return Object.values(record).some(hasEditedDocPath);
 }
 var WORKER_LOG_MESSAGE_TYPE = "codesesh.worker-log";
-function isRecord(value) {
+function isRecord3(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function isWorkerLogMessage(value) {
-  if (!isRecord(value) || value.type !== WORKER_LOG_MESSAGE_TYPE) return false;
-  return typeof value.ts === "string" && value.ts.length > 0 && (value.level === "debug" || value.level === "info" || value.level === "warn" || value.level === "error") && typeof value.event === "string" && value.event.length > 0 && Number.isSafeInteger(value.pid) && Number(value.pid) > 0 && Number.isSafeInteger(value.threadId) && Number(value.threadId) >= 0 && isRecord(value.data);
+  if (!isRecord3(value) || value.type !== WORKER_LOG_MESSAGE_TYPE) return false;
+  return typeof value.ts === "string" && value.ts.length > 0 && (value.level === "debug" || value.level === "info" || value.level === "warn" || value.level === "error") && typeof value.event === "string" && value.event.length > 0 && Number.isSafeInteger(value.pid) && Number(value.pid) > 0 && Number.isSafeInteger(value.threadId) && Number(value.threadId) >= 0 && isRecord3(value.data);
 }
 var CODEX_PATCH_TYPES = /* @__PURE__ */ new Set([
   "edit_file",
@@ -9283,13 +10570,13 @@ function setSchemaEnsuredPath(path2) {
   schemaEnsuredPath = path2;
 }
 function getCacheDir2() {
-  return join15(homedir22(), ".cache", "codesesh");
+  return join18(homedir22(), ".cache", "codesesh");
 }
 function getCachePath2() {
-  return join15(getCacheDir2(), CACHE_FILENAME);
+  return join18(getCacheDir2(), CACHE_FILENAME);
 }
 function getLegacyCachePath() {
-  return join15(getCacheDir2(), LEGACY_CACHE_FILENAME);
+  return join18(getCacheDir2(), LEGACY_CACHE_FILENAME);
 }
 function hasCacheStorage() {
   return existsSync22(getCachePath2());
@@ -14829,4 +16116,4 @@ export {
   executeSessionSearch,
   filterSessionSearchCandidates
 };
-//# sourceMappingURL=chunk-JHX5OLL4.js.map
+//# sourceMappingURL=chunk-VAUC2W7I.js.map