@jun133/kitty 0.0.8 → 0.0.9

package/dist/chunk-4BN45TQG.mjs

@@ -0,0 +1,654 @@
+import {
+  createEmptyCheckpoint,
+  createEmptySessionDiff,
+  createEmptyTaskState,
+  deriveTaskState,
+  deriveTodoItems,
+  normalizeSessionCheckpoint,
+  normalizeSessionDiffState,
+  normalizeSessionMemory,
+  normalizeSessionRecord,
+  normalizeSessionTodos,
+  normalizeSessionWorkset,
+  normalizeTodoItems
+} from "./chunk-3KMC6H5K.mjs";
+
+// src/session/store.ts
+import crypto from "crypto";
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/session/errors.ts
+var SessionStoreError = class extends Error {
+  code;
+  sessionPath;
+  constructor(message, options) {
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    this.name = this.constructor.name;
+    this.code = options.code;
+    this.sessionPath = options.sessionPath;
+  }
+};
+var SessionNotFoundError = class extends SessionStoreError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "SESSION_NOT_FOUND",
+      sessionPath: options.sessionPath,
+      cause: options.cause
+    });
+  }
+};
+var SessionCorruptError = class extends SessionStoreError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "SESSION_CORRUPT",
+      sessionPath: options.sessionPath,
+      cause: options.cause
+    });
+  }
+};
+var UnsupportedSessionSchemaError = class extends SessionStoreError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: "SESSION_UNSUPPORTED_SCHEMA",
+      sessionPath: options.sessionPath,
+      cause: options.cause
+    });
+  }
+};
+function createSessionNotFoundError(sessionId, sessionPath, cause) {
+  return new SessionNotFoundError(
+    `Session '${sessionId}' was not found at ${sessionPath}. Rebind the host or create a new formal session explicitly.`,
+    {
+      sessionPath,
+      cause
+    }
+  );
+}
+function createInvalidSessionJsonError(sessionPath, cause) {
+  return new SessionCorruptError(
+    `Session snapshot '${sessionPath}' is corrupt: invalid JSON. Fix or delete the broken snapshot before retrying.`,
+    {
+      sessionPath,
+      cause
+    }
+  );
+}
+function createSessionCorruptError(sessionPath, detail) {
+  return new SessionCorruptError(
+    `Session snapshot '${sessionPath}' is corrupt: ${detail}. Fix or delete the broken snapshot before retrying.`,
+    {
+      sessionPath
+    }
+  );
+}
+function createUnsupportedSessionSchemaError(sessionPath, receivedVersion, expectedVersion) {
+  return new UnsupportedSessionSchemaError(
+    `Session snapshot '${sessionPath}' has unsupported schema version '${String(receivedVersion)}'. Expected ${expectedVersion}. Rebuild the session snapshot instead of guessing.`,
+    {
+      sessionPath
+    }
+  );
+}
+
+// src/session/memoryAsset.ts
+import fs from "fs/promises";
+import path from "path";
+
+// src/runtime/memory/metadata.ts
+var EVIDENCE_PREFIX = "evidence:";
+var KIND_PREFIX = "kind:";
+var SCOPE_PREFIX = "scope:";
+var TAGS_PREFIX = "tags:";
+var UPDATED_PREFIX = "updated:";
+function parseRuntimeMemoryAssetMetadata(body, fallback) {
+  const title = readTitle(body);
+  const metadataLines = readMetadataLines(body);
+  const kind = readKind(metadataLines, fallback.kind);
+  const evidenceRefs = readEvidenceRefs(metadataLines, kind, fallback.basename);
+  return {
+    title,
+    kind,
+    updatedAt: readFirstMetadataValue(metadataLines, UPDATED_PREFIX),
+    evidenceRefs,
+    scope: readFirstMetadataValue(metadataLines, SCOPE_PREFIX),
+    tags: readCsvMetadataValues(metadataLines, TAGS_PREFIX)
+  };
+}
+function renderRuntimeMemoryAssetDocument(input) {
+  return [
+    `# ${input.title.trim()}`,
+    "",
+    `Kind: ${input.kind}`,
+    `Updated: ${input.timestamp}`,
+    renderOptionalLine("Evidence", normalizeList(input.evidenceRefs).join(", ")),
+    renderOptionalLine("Scope", input.scope?.trim()),
+    renderOptionalLine("Tags", normalizeList(input.tags).join(", ")),
+    "",
+    input.content.trim(),
+    ""
+  ].filter((line) => line !== void 0).join("\n");
+}
+function readTitle(body) {
+  const line = body.split(/\r?\n/).find((item) => item.trim().startsWith("# "));
+  return line?.replace(/^#\s+/, "").trim() || void 0;
+}
+function readMetadataLines(body) {
+  return body.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^[A-Za-z][A-Za-z -]*:/.test(line));
+}
+function readKind(lines, fallback) {
+  const value = readFirstMetadataValue(lines, KIND_PREFIX);
+  return isRuntimeMemoryAssetKind(value) ? value : fallback;
+}
+function readEvidenceRefs(lines, kind, basename) {
+  const refs = lines.filter((line) => line.toLowerCase().startsWith(EVIDENCE_PREFIX)).flatMap((line) => line.slice(EVIDENCE_PREFIX.length).split(",")).map((value) => value.trim()).filter(Boolean);
+  if (refs.length > 0) {
+    return [...new Set(refs)];
+  }
+  return kind === "session" ? [`session:${basename}`] : [];
+}
+function readFirstMetadataValue(lines, prefix) {
+  const line = lines.find((item) => item.toLowerCase().startsWith(prefix));
+  const value = line?.slice(prefix.length).trim();
+  return value || void 0;
+}
+function readCsvMetadataValues(lines, prefix) {
+  return normalizeList(
+    lines.filter((line) => line.toLowerCase().startsWith(prefix)).flatMap((line) => line.slice(prefix.length).split(","))
+  );
+}
+function normalizeList(values) {
+  return [...new Set((values ?? []).map((value) => value?.trim()).filter((value) => Boolean(value)))];
+}
+function renderOptionalLine(label, value) {
+  return value ? `${label}: ${value}` : void 0;
+}
+function isRuntimeMemoryAssetKind(value) {
+  return value === "evidence" || value === "project" || value === "session" || value === "user";
+}
+
+// src/session/memoryAsset.ts
+function getSessionMemoryAssetPath(memorySessionsDir, sessionId) {
+  return path.join(memorySessionsDir, `${sanitizeSessionId(sessionId)}.md`);
+}
+async function writeSessionMemoryAsset(input) {
+  const memory = input.session.sessionMemory;
+  if (!memory?.summary.trim()) {
+    await fs.rm(getSessionMemoryAssetPath(input.memorySessionsDir, input.session.id), { force: true }).catch(() => void 0);
+    return void 0;
+  }
+  await fs.mkdir(input.memorySessionsDir, { recursive: true });
+  const file = getSessionMemoryAssetPath(input.memorySessionsDir, input.session.id);
+  await fs.writeFile(file, renderSessionMemoryAsset(input.session), "utf8");
+  return file;
+}
+function renderSessionMemoryAsset(session) {
+  const memory = session.sessionMemory;
+  if (!memory) {
+    return "";
+  }
+  return renderRuntimeMemoryAssetDocument({
+    kind: "session",
+    title: "Session Memory",
+    timestamp: memory.updatedAt,
+    evidenceRefs: [`session:${session.id}`],
+    scope: session.id,
+    tags: ["same-session", "continuity"],
+    content: memory.summary
+  });
+}
+function sanitizeSessionId(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+// src/session/snapshot.ts
+var CURRENT_SESSION_SCHEMA_VERSION = 1;
+var SESSION_SNAPSHOT_KEYS = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "id",
+  "createdAt",
+  "updatedAt",
+  "cwd",
+  "title",
+  "messageCount",
+  "messages",
+  "sessionMemory",
+  "todoItems",
+  "taskState",
+  "checkpoint",
+  "sessionDiff",
+  "contextBudget",
+  "workset"
+]);
+function serializeSessionSnapshot(session) {
+  return `${JSON.stringify({
+    schemaVersion: CURRENT_SESSION_SCHEMA_VERSION,
+    ...session
+  }, null, 2)}
+`;
+}
+function parseSessionSnapshot(raw, sessionPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw createInvalidSessionJsonError(sessionPath, error);
+    }
+    throw error;
+  }
+  const record = expectRecord(parsed, sessionPath, "Session snapshot");
+  rejectUnknownSessionKeys(record, sessionPath);
+  const schemaVersion = record.schemaVersion;
+  if (schemaVersion !== CURRENT_SESSION_SCHEMA_VERSION) {
+    throw createUnsupportedSessionSchemaError(sessionPath, schemaVersion, CURRENT_SESSION_SCHEMA_VERSION);
+  }
+  const candidate = {
+    id: readRequiredString(record, "id", sessionPath),
+    createdAt: readRequiredString(record, "createdAt", sessionPath),
+    updatedAt: readRequiredString(record, "updatedAt", sessionPath),
+    cwd: readRequiredString(record, "cwd", sessionPath),
+    title: readOptionalString(record.title, "title", sessionPath),
+    messageCount: typeof record.messageCount === "number" ? Math.trunc(record.messageCount) : 0,
+    messages: readMessages(record.messages, sessionPath),
+    sessionMemory: normalizeSessionMemory(record.sessionMemory),
+    todoItems: readTodoItems(record.todoItems, sessionPath),
+    taskState: readOptionalObject(record.taskState, "taskState", sessionPath),
+    checkpoint: readOptionalObject(record.checkpoint, "checkpoint", sessionPath),
+    sessionDiff: readOptionalObject(record.sessionDiff, "sessionDiff", sessionPath),
+    contextBudget: readContextBudget(record.contextBudget, sessionPath),
+    workset: normalizeSessionWorkset(record.workset)
+  };
+  return normalizeLoadedSessionRecord(candidate);
+}
+function prepareSessionRecordForSave(session) {
+  const normalizedMessages = Array.isArray(session.messages) ? session.messages : [];
+  const prepared = {
+    ...session,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    title: session.title,
+    messageCount: normalizedMessages.length,
+    messages: normalizedMessages,
+    sessionMemory: normalizeSessionMemory(session.sessionMemory),
+    todoItems: deriveTodoItems(normalizedMessages, session.todoItems ?? []),
+    taskState: deriveTaskState(normalizedMessages, session.taskState)
+  };
+  return normalizeSessionDiffState(normalizeSessionCheckpoint({
+    ...prepared,
+    workset: normalizeSessionWorkset(prepared.workset)
+  }));
+}
+function normalizeLoadedSessionRecord(session) {
+  return normalizeSessionDiffState(normalizeSessionCheckpoint(
+    normalizeSessionTodos(normalizeSessionRecord(session))
+  ));
+}
+function rejectUnknownSessionKeys(record, sessionPath) {
+  const unknownKeys = Object.keys(record).filter((key) => !SESSION_SNAPSHOT_KEYS.has(key));
+  if (unknownKeys.length > 0) {
+    throw createSessionCorruptError(sessionPath, `unrecognized field(s): ${unknownKeys.join(", ")}`);
+  }
+}
+function readMessages(value, sessionPath) {
+  if (!Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, "messages must be an array");
+  }
+  return value.map((entry, index) => readMessage(entry, index, sessionPath));
+}
+function readTodoItems(value, sessionPath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  try {
+    return normalizeTodoItems(value);
+  } catch (error) {
+    throw createSessionCorruptError(sessionPath, error instanceof Error ? error.message : String(error));
+  }
+}
+function readContextBudget(value, sessionPath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const record = expectRecord(value, sessionPath, "contextBudget");
+  const version = record.version;
+  if (version !== 1) {
+    throw createSessionCorruptError(sessionPath, "contextBudget.version must be 1");
+  }
+  const compressionMode = readRequiredString(record, "compressionMode", sessionPath, "contextBudget");
+  if (compressionMode !== "none" && compressionMode !== "normal" && compressionMode !== "aggressive" && compressionMode !== "hard") {
+    throw createSessionCorruptError(sessionPath, "contextBudget.compressionMode must be one of none|normal|aggressive|hard");
+  }
+  return {
+    version,
+    limitChars: readRequiredNumber(record, "limitChars", sessionPath, "contextBudget"),
+    estimatedChars: readRequiredNumber(record, "estimatedChars", sessionPath, "contextBudget"),
+    remainingChars: readRequiredNumber(record, "remainingChars", sessionPath, "contextBudget"),
+    usageRatio: readRequiredNumber(record, "usageRatio", sessionPath, "contextBudget"),
+    compressed: readRequiredBoolean(record, "compressed", sessionPath, "contextBudget"),
+    compressionMode,
+    compressionReason: readRequiredString(record, "compressionReason", sessionPath, "contextBudget"),
+    sources: readContextBudgetSources(record.sources, sessionPath),
+    promptHotspots: readContextBudgetHotspots(record.promptHotspots, sessionPath),
+    cacheLayout: readContextCacheLayout(record.cacheLayout, sessionPath)
+  };
+}
+function readContextCacheLayout(value, sessionPath) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const record = expectRecord(value, sessionPath, "contextBudget.cacheLayout");
+  return {
+    stablePrefixFingerprint: readRequiredString(record, "stablePrefixFingerprint", sessionPath, "contextBudget.cacheLayout"),
+    volatileTailFingerprint: readRequiredString(record, "volatileTailFingerprint", sessionPath, "contextBudget.cacheLayout"),
+    stablePrefixChars: readRequiredNumber(record, "stablePrefixChars", sessionPath, "contextBudget.cacheLayout"),
+    volatileTailChars: readRequiredNumber(record, "volatileTailChars", sessionPath, "contextBudget.cacheLayout"),
+    stableSources: readStringArray(record.stableSources, sessionPath, "contextBudget.cacheLayout.stableSources"),
+    volatileSources: readStringArray(record.volatileSources, sessionPath, "contextBudget.cacheLayout.volatileSources")
+  };
+}
+function readContextBudgetSources(value, sessionPath) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, "contextBudget.sources must be an array");
+  }
+  return value.map((entry, index) => {
+    const record = expectRecord(entry, sessionPath, `contextBudget.sources[${index}]`);
+    const name = readRequiredString(record, "name", sessionPath, `contextBudget.sources[${index}]`);
+    if (name !== "systemPrompt" && name !== "nearFieldConversation" && name !== "conversationSummary" && name !== "compactedConversation") {
+      throw createSessionCorruptError(sessionPath, `contextBudget.sources[${index}].name is invalid`);
+    }
+    const messages = record.messages === void 0 ? void 0 : readRequiredNumber(record, "messages", sessionPath, `contextBudget.sources[${index}]`);
+    return {
+      name,
+      chars: readRequiredNumber(record, "chars", sessionPath, `contextBudget.sources[${index}]`),
+      messages
+    };
+  });
+}
+function readContextBudgetHotspots(value, sessionPath) {
+  if (!Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, "contextBudget.promptHotspots must be an array");
+  }
+  return value.map((entry, index) => {
+    const record = expectRecord(entry, sessionPath, `contextBudget.promptHotspots[${index}]`);
+    const layer = readRequiredString(record, "layer", sessionPath, `contextBudget.promptHotspots[${index}]`);
+    if (layer !== "static" && layer !== "profile" && layer !== "runtimeFacts") {
+      throw createSessionCorruptError(sessionPath, `contextBudget.promptHotspots[${index}].layer must be one of static|profile|runtimeFacts`);
+    }
+    return {
+      layer,
+      title: readRequiredString(record, "title", sessionPath, `contextBudget.promptHotspots[${index}]`),
+      chars: readRequiredNumber(record, "chars", sessionPath, `contextBudget.promptHotspots[${index}]`),
+      lines: readRequiredNumber(record, "lines", sessionPath, `contextBudget.promptHotspots[${index}]`)
+    };
+  });
+}
+function readStringArray(value, sessionPath, scope) {
+  if (!Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, `${scope} must be an array`);
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string") {
+      throw createSessionCorruptError(sessionPath, `${scope}[${index}] must be a string`);
+    }
+    return entry;
+  });
+}
+function readMessage(value, index, sessionPath) {
+  const record = expectRecord(value, sessionPath, `messages[${index}]`);
+  const role = readRequiredString(record, "role", sessionPath, `messages[${index}]`);
+  if (role !== "system" && role !== "user" && role !== "assistant" && role !== "tool") {
+    throw createSessionCorruptError(sessionPath, `messages[${index}].role must be one of system|user|assistant|tool`);
+  }
+  return {
+    role,
+    content: readMessageContent(record.content, sessionPath, `messages[${index}]`),
+    source: readMessageSource(record.source, sessionPath, `messages[${index}]`),
+    name: readOptionalString(record.name, "name", sessionPath, `messages[${index}]`),
+    tool_call_id: readOptionalString(record.tool_call_id, "tool_call_id", sessionPath, `messages[${index}]`),
+    tool_calls: readToolCalls(record.tool_calls, sessionPath, index),
+    reasoningContent: readOptionalString(record.reasoningContent, "reasoningContent", sessionPath, `messages[${index}]`),
+    createdAt: readRequiredString(record, "createdAt", sessionPath, `messages[${index}]`)
+  };
+}
+function readMessageContent(value, sessionPath, scope) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw createSessionCorruptError(sessionPath, `${scope}.content must be a string or null`);
+  }
+  return value;
+}
+function readToolCalls(value, sessionPath, index) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, `messages[${index}].tool_calls must be an array`);
+  }
+  return value.map((entry, toolIndex) => {
+    const record = expectRecord(entry, sessionPath, `messages[${index}].tool_calls[${toolIndex}]`);
+    const type = readRequiredString(record, "type", sessionPath, `messages[${index}].tool_calls[${toolIndex}]`);
+    if (type !== "function") {
+      throw createSessionCorruptError(sessionPath, `messages[${index}].tool_calls[${toolIndex}].type must be 'function'`);
+    }
+    const fn = readOptionalObject(record.function, "function", sessionPath, `messages[${index}].tool_calls[${toolIndex}]`);
+    if (!fn) {
+      throw createSessionCorruptError(sessionPath, `messages[${index}].tool_calls[${toolIndex}].function is required`);
+    }
+    return {
+      id: readRequiredString(record, "id", sessionPath, `messages[${index}].tool_calls[${toolIndex}]`),
+      type,
+      function: {
+        name: readRequiredString(fn, "name", sessionPath, `messages[${index}].tool_calls[${toolIndex}].function`),
+        arguments: readRequiredString(fn, "arguments", sessionPath, `messages[${index}].tool_calls[${toolIndex}].function`)
+      }
+    };
+  });
+}
+function readOptionalObject(value, fieldName, sessionPath, scope) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return expectRecord(value, sessionPath, scope ? `${scope}.${fieldName}` : fieldName);
+}
+function expectRecord(value, sessionPath, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw createSessionCorruptError(sessionPath, `${label} must be an object`);
+  }
+  return value;
+}
+function readRequiredString(record, key, sessionPath, scope) {
+  const value = readOptionalString(record[key], key, sessionPath, scope);
+  if (!value) {
+    throw createSessionCorruptError(sessionPath, `${scope ? `${scope}.` : ""}${key} is required`);
+  }
+  return value;
+}
+function readMessageSource(value, sessionPath, scope) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value !== "external" && value !== "internal") {
+    throw createSessionCorruptError(sessionPath, `${scope}.source must be external or internal`);
+  }
+  return value;
+}
+function readRequiredNumber(record, key, sessionPath, scope) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw createSessionCorruptError(sessionPath, `${scope ? `${scope}.` : ""}${key} must be a finite number`);
+  }
+  return value;
+}
+function readRequiredBoolean(record, key, sessionPath, scope) {
+  const value = record[key];
+  if (typeof value !== "boolean") {
+    throw createSessionCorruptError(sessionPath, `${scope ? `${scope}.` : ""}${key} must be a boolean`);
+  }
+  return value;
+}
+function readOptionalString(value, key, sessionPath, scope) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw createSessionCorruptError(sessionPath, `${scope ? `${scope}.` : ""}${key} must be a string`);
+  }
+  return value;
+}
+
+// src/session/store.ts
+var SessionStore = class {
+  constructor(sessionsDir, options = {}) {
+    this.sessionsDir = sessionsDir;
+    this.options = options;
+  }
+  async create(cwd) {
+    return createSessionRecord(cwd);
+  }
+  async save(session) {
+    const updated = prepareSessionRecordForSave(session);
+    await fs2.mkdir(this.sessionsDir, { recursive: true });
+    await fs2.writeFile(this.getPath(updated.id), serializeSessionSnapshot(updated), "utf8");
+    await writeSessionMemoryAsset({
+      memorySessionsDir: this.options.memorySessionsDir ?? this.defaultMemorySessionsDir(),
+      session: updated
+    });
+    return updated;
+  }
+  async load(id) {
+    const sessionPath = this.getPath(id);
+    const raw = await this.readSnapshotFile(id, sessionPath);
+    return parseSessionSnapshot(raw, sessionPath);
+  }
+  async loadLatest() {
+    const sessions = await this.list(1);
+    return sessions[0] ?? null;
+  }
+  async list(limit = 20) {
+    return (await this.listReadable(limit)).sessions;
+  }
+  async listReadable(limit = 20) {
+    await fs2.mkdir(this.sessionsDir, { recursive: true });
+    const entries = await fs2.readdir(this.sessionsDir, { withFileTypes: true });
+    const sessions = [];
+    const skipped = [];
+    for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".json"))) {
+      const sessionPath = path2.join(this.sessionsDir, entry.name);
+      try {
+        const raw = await fs2.readFile(sessionPath, "utf8");
+        sessions.push(parseSessionSnapshot(raw, sessionPath));
+      } catch (error) {
+        skipped.push(toSkippedSessionSnapshot(error, sessionPath));
+      }
+    }
+    return {
+      sessions: sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, limit),
+      skipped
+    };
+  }
+  async appendMessages(session, messages) {
+    const next = {
+      ...session,
+      messages: [...session.messages, ...messages]
+    };
+    return this.save(next);
+  }
+  getPath(id) {
+    return path2.join(this.sessionsDir, `${id}.json`);
+  }
+  defaultMemorySessionsDir() {
+    return path2.join(path2.dirname(this.sessionsDir), "memory", "sessions");
+  }
+  async readSnapshotFile(id, sessionPath) {
+    try {
+      return await fs2.readFile(sessionPath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw createSessionNotFoundError(id, sessionPath, error);
+      }
+      throw error;
+    }
+  }
+};
+function toSkippedSessionSnapshot(error, fallbackPath) {
+  if (error instanceof SessionStoreError) {
+    return {
+      path: error.sessionPath ?? fallbackPath,
+      code: error.code,
+      error: error.message
+    };
+  }
+  return {
+    path: fallbackPath,
+    code: "SESSION_READ_FAILED",
+    error: error instanceof Error ? error.message : String(error)
+  };
+}
+var InProcessSessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  async create(cwd) {
+    return createSessionRecord(cwd);
+  }
+  async save(session) {
+    const prepared = prepareSessionRecordForSave(session);
+    this.sessions.set(prepared.id, prepared);
+    return prepared;
+  }
+  async load(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw createSessionNotFoundError(id, `in-process:${id}`);
+    }
+    return session;
+  }
+  async loadLatest() {
+    const sessions = await this.list(1);
+    return sessions[0] ?? null;
+  }
+  async list(limit = 20) {
+    return [...this.sessions.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, limit);
+  }
+  async listReadable(limit = 20) {
+    return {
+      sessions: await this.list(limit),
+      skipped: []
+    };
+  }
+  async appendMessages(session, messages) {
+    return this.save({
+      ...session,
+      messages: [...session.messages, ...messages]
+    });
+  }
+};
+async function createSessionRecord(cwd) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return prepareSessionRecordForSave({
+    id: createSessionId(),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    cwd,
+    messageCount: 0,
+    messages: [],
+    taskState: createEmptyTaskState(timestamp),
+    checkpoint: createEmptyCheckpoint(timestamp),
+    sessionDiff: createEmptySessionDiff(timestamp)
+  });
+}
+function createSessionId() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+  const random = crypto.randomUUID().slice(0, 8);
+  return `${date}-${random}`;
+}
+
+export {
+  parseRuntimeMemoryAssetMetadata,
+  SessionStore,
+  InProcessSessionStore,
+  createSessionRecord
+};