@wrongstack/core 0.1.9 → 0.1.10

package/dist/storage/index.js

@@ -0,0 +1,1530 @@
+import { randomBytes, randomUUID } from 'crypto';
+import * as fsp from 'fs/promises';
+import * as path2 from 'path';
+import 'fs';
+import * as os from 'os';
+
+// src/storage/session-store.ts
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path2.dirname(targetPath);
+  await fsp.mkdir(dir, { recursive: true });
+  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fsp.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fsp.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fsp.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat3 = await fsp.stat(targetPath);
+      mode = stat3.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fsp.chmod(tmp, mode);
+    }
+    await fsp.rename(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fsp.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+// src/storage/session-store.ts
+var DefaultSessionStore = class {
+  dir;
+  events;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.events = opts.events;
+  }
+  async create(meta) {
+    await ensureDir(this.dir);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const id = meta.id ?? `${startedAt.replace(/[:.]/g, "-")}-${randomBytes(2).toString("hex")}`;
+    const file = path2.join(this.dir, `${id}.jsonl`);
+    let handle;
+    try {
+      handle = await fsp.open(file, "a", 384);
+    } catch (err) {
+      throw new Error(
+        `Failed to open session file: ${err instanceof Error ? err.message : String(err)}`,
+        {
+          cause: err
+        }
+      );
+    }
+    try {
+      return new FileSessionWriter(id, handle, startedAt, meta, { dir: this.dir, filePath: file });
+    } catch (err) {
+      await handle.close().catch(() => {
+      });
+      throw err;
+    }
+  }
+  async resume(id) {
+    const data = await this.load(id);
+    const file = path2.join(this.dir, `${id}.jsonl`);
+    let handle;
+    try {
+      handle = await fsp.open(file, "a", 384);
+    } catch (err) {
+      throw new Error(
+        `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+    const writer = new FileSessionWriter(
+      id,
+      handle,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      {
+        id,
+        model: data.metadata.model,
+        provider: data.metadata.provider
+      },
+      { resumed: true, dir: this.dir, filePath: file }
+    );
+    return { writer, data };
+  }
+  async load(id) {
+    const file = path2.join(this.dir, `${id}.jsonl`);
+    const raw = await fsp.readFile(file, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const events = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+          events.push(parsed);
+        }
+      } catch {
+      }
+    }
+    const meta = this.metaFromEvents(id, events);
+    const { messages, usage } = this.replay(events, id);
+    return { metadata: meta, events, messages, usage };
+  }
+  async list(limit = 20) {
+    try {
+      await ensureDir(this.dir);
+      const files = await fsp.readdir(this.dir);
+      const ids = files.filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(/\.jsonl$/, ""));
+      const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+      const out = sessions.filter((s) => s !== null);
+      out.sort((a, b) => {
+        if (a.startedAt < b.startedAt) return 1;
+        if (a.startedAt > b.startedAt) return -1;
+        return a.id.localeCompare(b.id);
+      });
+      return out.slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+  async summaryFor(id) {
+    const manifest = path2.join(this.dir, `${id}.summary.json`);
+    try {
+      const raw = await fsp.readFile(manifest, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      const full = path2.join(this.dir, `${id}.jsonl`);
+      const stat3 = await fsp.stat(full);
+      const summary = await this.summarize(id, stat3.mtime.toISOString());
+      await fsp.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+        console.warn(
+          `[session-store] Failed to write manifest for "${id}":`,
+          err instanceof Error ? err.message : String(err)
+        );
+      });
+      return summary;
+    }
+  }
+  async delete(id) {
+    await fsp.unlink(path2.join(this.dir, `${id}.jsonl`));
+    await fsp.unlink(path2.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
+  }
+  async summarize(id, mtime) {
+    try {
+      const data = await this.load(id);
+      const firstUser = data.events.find((e) => e.type === "user_input");
+      const title = firstUser && firstUser.type === "user_input" ? userInputTitle(firstUser.content) : "(empty session)";
+      return {
+        id,
+        title,
+        startedAt: data.metadata.startedAt,
+        model: data.metadata.model ?? "unknown",
+        provider: data.metadata.provider ?? "unknown",
+        tokenTotal: data.usage.input + data.usage.output
+      };
+    } catch {
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    }
+  }
+  metaFromEvents(id, events) {
+    const start = events.find((e) => e.type === "session_start");
+    const end = events.find((e) => e.type === "session_end");
+    return {
+      id,
+      startedAt: start?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      endedAt: end?.ts,
+      model: start?.model,
+      provider: start?.provider
+    };
+  }
+  replay(events, sessionId = "unknown") {
+    const messages = [];
+    let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    const openToolUses = /* @__PURE__ */ new Set();
+    for (const e of events) {
+      if (e.type === "user_input") {
+        openToolUses.clear();
+        messages.push({ role: "user", content: e.content });
+      } else if (e.type === "llm_response") {
+        messages.push({ role: "assistant", content: e.content });
+        for (const b of e.content) {
+          if (b.type === "tool_use") openToolUses.add(b.id);
+        }
+        usage = {
+          input: usage.input + (e.usage.input ?? 0),
+          output: usage.output + (e.usage.output ?? 0),
+          cacheRead: (usage.cacheRead ?? 0) + (e.usage.cacheRead ?? 0),
+          cacheWrite: (usage.cacheWrite ?? 0) + (e.usage.cacheWrite ?? 0)
+        };
+      } else if (e.type === "tool_result") {
+        if (!openToolUses.has(e.id)) {
+          this.events?.emit("session.damaged", {
+            sessionId,
+            detail: `Orphan tool_result "${e.id}" has no matching tool_use`
+          });
+          continue;
+        }
+        openToolUses.delete(e.id);
+        const content = [
+          {
+            type: "tool_result",
+            tool_use_id: e.id,
+            content: typeof e.content === "string" ? e.content : JSON.stringify(e.content),
+            is_error: e.isError
+          }
+        ];
+        const last = messages[messages.length - 1];
+        if (last && last.role === "user") {
+          if (Array.isArray(last.content)) {
+            last.content.push(...content);
+          } else if (typeof last.content === "string") {
+            last.content = [{ type: "text", text: last.content }, ...content];
+          } else {
+            messages.push({ role: "user", content });
+          }
+        } else {
+          messages.push({ role: "user", content });
+        }
+      }
+    }
+    if (openToolUses.size > 0) {
+      this.events?.emit("session.damaged", {
+        sessionId,
+        detail: `${openToolUses.size} tool_use blocks without matching results \u2014 replay truncated`
+      });
+      return { messages, usage };
+    }
+    return { messages, usage };
+  }
+};
+var FileSessionWriter = class {
+  constructor(id, handle, startedAt, meta, opts = {}) {
+    this.id = id;
+    this.handle = handle;
+    this.startedAt = startedAt;
+    this.meta = meta;
+    this.resumed = opts.resumed ?? false;
+    this.manifestFile = opts.dir ? path2.join(opts.dir, `${id}.summary.json`) : "";
+    this.filePath = opts.filePath ?? "";
+    this.summary = {
+      id,
+      title: "(empty session)",
+      startedAt,
+      model: meta.model ?? "unknown",
+      provider: meta.provider ?? "unknown",
+      tokenTotal: 0
+    };
+  }
+  id;
+  handle;
+  startedAt;
+  meta;
+  closed = false;
+  manifestFile;
+  summary;
+  tokenIn = 0;
+  tokenOut = 0;
+  filePath;
+  initDone = false;
+  resumed;
+  appendFailCount = 0;
+  lastAppendWarnAt = 0;
+  async writeSessionStart() {
+    if (this.initDone || this.closed) return;
+    this.initDone = true;
+    const record = `${JSON.stringify({
+      type: this.resumed ? "session_resumed" : "session_start",
+      ts: this.startedAt,
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    try {
+      if (this.filePath) {
+        await fsp.writeFile(this.filePath, record, { flag: "a", mode: 384 });
+      }
+    } catch {
+    }
+  }
+  async append(event) {
+    if (this.closed) return;
+    if (!this.initDone) {
+      await this.writeSessionStart();
+    }
+    this.observeForSummary(event);
+    try {
+      await this.handle.appendFile(`${JSON.stringify(event)}
+`, "utf8");
+    } catch (err) {
+      this.appendFailCount++;
+      const now = Date.now();
+      if (now - this.lastAppendWarnAt > 5e3) {
+        const suppressed = this.appendFailCount - 1;
+        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
+        console.warn(
+          "[session] append failed:",
+          err instanceof Error ? err.message : String(err),
+          tail
+        );
+        this.lastAppendWarnAt = now;
+        this.appendFailCount = 0;
+      }
+    }
+  }
+  /**
+   * Watch events as they're appended and keep the summary state hot, so
+   * `close()` can flush a `<id>.summary.json` manifest without re-reading
+   * the JSONL. `list()` reads only manifests, turning a per-session full
+   * parse into a single stat+read.
+   */
+  observeForSummary(event) {
+    if (event.type === "user_input" && this.summary.title === "(empty session)") {
+      this.summary = { ...this.summary, title: userInputTitle(event.content) };
+    } else if (event.type === "llm_response") {
+      this.tokenIn += event.usage.input;
+      this.tokenOut += event.usage.output;
+      this.summary = { ...this.summary, tokenTotal: this.tokenIn + this.tokenOut };
+    } else if (event.type === "session_end") {
+      const total = event.usage.input + event.usage.output;
+      if (total > 0) this.summary = { ...this.summary, tokenTotal: total };
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.manifestFile) {
+      try {
+        await fsp.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+      } catch {
+      }
+    }
+    try {
+      await this.handle.close();
+    } catch {
+    }
+  }
+};
+function userInputTitle(content) {
+  if (typeof content === "string") return content.slice(0, 60);
+  const text = content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+  return (text || "(non-text input)").slice(0, 60);
+}
+var QueueStore = class {
+  file;
+  constructor(opts) {
+    this.file = path2.join(opts.dir, "queue.json");
+  }
+  async write(items) {
+    if (items.length === 0) {
+      await this.clear();
+      return;
+    }
+    await atomicWrite(this.file, JSON.stringify(items), { mode: 384 });
+  }
+  async read() {
+    let raw;
+    try {
+      raw = await fsp.readFile(this.file, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return [];
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(parsed)) return [];
+    const out = [];
+    for (const v of parsed) {
+      if (isPersistedQueueItem(v)) out.push(v);
+    }
+    return out;
+  }
+  async clear() {
+    try {
+      await fsp.unlink(this.file);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return;
+      console.warn(`QueueStore.clear() failed for ${this.file}: ${err.message}`);
+    }
+  }
+};
+function isPersistedQueueItem(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return typeof o["displayText"] === "string" && Array.isArray(o["blocks"]);
+}
+var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
+var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)\]/g;
+var DefaultAttachmentStore = class {
+  items = /* @__PURE__ */ new Map();
+  refs = [];
+  nextSeq = { text: 0, image: 0, file: 0 };
+  spoolDir;
+  spoolThreshold;
+  constructor(opts = {}) {
+    this.spoolDir = opts.spoolDir;
+    this.spoolThreshold = opts.spoolThresholdBytes ?? DEFAULT_SPOOL_THRESHOLD;
+  }
+  async add(input) {
+    const seq = ++this.nextSeq[input.kind];
+    const id = `${kindPrefix(input.kind)}-${seq}-${randomBytes(3).toString("hex")}`;
+    const bytes = Buffer.byteLength(input.data, input.kind === "image" ? "base64" : "utf8");
+    let spooledPath;
+    let data = input.data;
+    if (this.spoolDir && bytes >= this.spoolThreshold) {
+      await fsp.mkdir(this.spoolDir, { recursive: true });
+      spooledPath = path2.join(this.spoolDir, `${id}.bin`);
+      await fsp.writeFile(spooledPath, input.data, input.kind === "image" ? "base64" : "utf8");
+      data = void 0;
+    }
+    const att = {
+      id,
+      kind: input.kind,
+      meta: input.meta ?? {},
+      data,
+      path: spooledPath,
+      bytes,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.items.set(id, att);
+    const ref = { id, kind: input.kind, seq, meta: att.meta };
+    this.refs.push(ref);
+    return ref;
+  }
+  async get(id) {
+    return this.items.get(id);
+  }
+  list() {
+    return [...this.refs];
+  }
+  async expand(text) {
+    const matches = [...text.matchAll(PLACEHOLDER_RE)];
+    if (matches.length === 0) return text ? [{ type: "text", text }] : [];
+    const blocks = [];
+    let lastIndex = 0;
+    for (const m of matches) {
+      const idx = m.index ?? 0;
+      const before = text.slice(lastIndex, idx);
+      if (before) blocks.push({ type: "text", text: before });
+      const kind = prefixToKind(m[1]);
+      const seq = Number(m[2]);
+      const ref = this.refs.find((r) => r.kind === kind && r.seq === seq);
+      const att = ref ? this.items.get(ref.id) : void 0;
+      if (!att) {
+        blocks.push({ type: "text", text: m[0] });
+      } else {
+        blocks.push(await this.toBlock(att));
+      }
+      lastIndex = idx + m[0].length;
+    }
+    const tail = text.slice(lastIndex);
+    if (tail) blocks.push({ type: "text", text: tail });
+    return mergeAdjacentText(blocks);
+  }
+  async clear() {
+    this.items.clear();
+    this.refs.length = 0;
+    this.nextSeq = { text: 0, image: 0, file: 0 };
+  }
+  async toBlock(att) {
+    if (att.kind === "image") {
+      const data = att.data ?? (att.path ? await fsp.readFile(att.path, { encoding: "base64" }) : "");
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: att.meta.mediaType ?? "image/png",
+          data
+        }
+      };
+    }
+    const raw = att.data ?? (att.path ? await fsp.readFile(att.path, "utf8") : "");
+    const label = att.meta.filename ? `<file path="${att.meta.filename}">` : "<pasted>";
+    const close = att.meta.filename ? "</file>" : "</pasted>";
+    return { type: "text", text: `${label}
+${raw}
+${close}` };
+  }
+};
+function kindPrefix(kind) {
+  return kind === "text" ? "pasted" : kind;
+}
+function prefixToKind(prefix) {
+  if (prefix === "pasted") return "text";
+  if (prefix === "image") return "image";
+  return "file";
+}
+function mergeAdjacentText(blocks) {
+  const out = [];
+  for (const b of blocks) {
+    const prev = out[out.length - 1];
+    if (b.type === "text" && prev && prev.type === "text") {
+      prev.text += b.text;
+    } else {
+      out.push(b);
+    }
+  }
+  return out;
+}
+var MAX_BYTES_TOTAL = 32e3;
+var DefaultMemoryStore = class {
+  files;
+  /**
+   * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
+   * `clear` are read-modify-write against a single file; without a lock,
+   * two concurrent calls on the same scope can read the same baseline and
+   * the later write silently drops the earlier entry. We chain each
+   * mutation onto the prior promise for the same scope so they run in
+   * issue order. Different scopes still proceed in parallel.
+   *
+   * The chain tracks only the last pending write. If a write fails, its
+   * error is caught and swallowed (line 43) so the chain stays alive for
+   * subsequent calls. A crash between atomicWrite() and backup copy leaves
+   * the file at its new content with no backup — acceptable for an optional
+   * backup whose worst case is losing a memory consolidation pass.
+   */
+  writeChain = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.files = {
+      "project-agents": opts.paths.inProjectAgentsFile,
+      "project-memory": opts.paths.projectMemory,
+      "user-memory": opts.paths.globalMemory
+    };
+  }
+  async runSerialized(scope, work) {
+    const prior = this.writeChain.get(scope) ?? Promise.resolve();
+    const next = prior.catch(() => void 0).then(work);
+    this.writeChain.set(scope, next);
+    try {
+      return await next;
+    } finally {
+      if (this.writeChain.get(scope) === next) {
+        this.writeChain.delete(scope);
+      }
+    }
+  }
+  async readAll() {
+    const parts = [];
+    for (const scope of ["project-agents", "project-memory", "user-memory"]) {
+      const body = await this.read(scope);
+      if (body.trim()) parts.push(`## ${labelOf(scope)}
+
+${body.trim()}`);
+    }
+    return parts.join("\n\n");
+  }
+  async read(scope) {
+    try {
+      return await fsp.readFile(this.files[scope], "utf8");
+    } catch {
+      return "";
+    }
+  }
+  async remember(text, scope = "project-memory") {
+    return this.runSerialized(scope, async () => {
+      const file = this.files[scope];
+      await ensureDir(path2.dirname(file));
+      let existing = "";
+      try {
+        existing = await fsp.readFile(file, "utf8");
+      } catch {
+      }
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
+      const entry = `
+- [${ts}] ${id} ${text.replace(/\n/g, " ")}
+`;
+      const next = existing.trim() ? existing.replace(/\n+$/, "") + entry : `# WrongStack Memory
+${entry}`;
+      await atomicWrite(file, next);
+      const buf = Buffer.byteLength(next, "utf8");
+      if (buf > MAX_BYTES_TOTAL) {
+        await this.consolidateUnsafe(scope);
+      }
+    });
+  }
+  async forget(query, scope = "project-memory") {
+    return this.runSerialized(scope, async () => this.forgetUnsafe(query, scope));
+  }
+  async forgetUnsafe(query, scope) {
+    const file = this.files[scope];
+    let existing;
+    try {
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+      return 0;
+    }
+    const needle = query.toLowerCase();
+    const idMatcher = /mem_\d+_\w+/;
+    let removed = 0;
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      if (idMatcher.test(query)) {
+        const afterBracket = trimmed.indexOf("] ");
+        if (afterBracket !== -1) {
+          const afterTs = trimmed.slice(afterBracket + 2);
+          const entryIdMatch = /^mem_\d+_\w+/.exec(afterTs);
+          if (entryIdMatch && entryIdMatch[0] === query) {
+            removed++;
+            return false;
+          }
+        }
+      }
+      if (trimmed.toLowerCase().includes(needle)) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    if (removed > 0) {
+      await atomicWrite(file, lines.join("\n"));
+    }
+    return removed;
+  }
+  async consolidate(scope) {
+    return this.runSerialized(scope, async () => this.consolidateUnsafe(scope));
+  }
+  async consolidateUnsafe(scope) {
+    const file = this.files[scope];
+    let existing;
+    try {
+      existing = await fsp.readFile(file, "utf8");
+    } catch {
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const lines = existing.split("\n").filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("- ")) return true;
+      const norm = trimmed.replace(/\[[^\]]+\]/, "").replace(/\bmem_\d+_\w+\s*/, "").trim().toLowerCase();
+      if (seen.has(norm)) return false;
+      seen.add(norm);
+      return true;
+    });
+    const next = lines.join("\n");
+    const backup = `${file}.bak.${Date.now()}`;
+    try {
+      await fsp.copyFile(file, backup);
+    } catch {
+    }
+    try {
+      await atomicWrite(file, next);
+    } catch {
+      return;
+    }
+  }
+  async clear(scope) {
+    if (scope) {
+      await this.runSerialized(scope, async () => atomicWrite(this.files[scope], ""));
+      return;
+    }
+    await Promise.all(
+      ["project-agents", "project-memory", "user-memory"].map(
+        (s) => this.runSerialized(s, async () => atomicWrite(this.files[s], ""))
+      )
+    );
+  }
+};
+function labelOf(scope) {
+  switch (scope) {
+    case "project-agents":
+      return "Project AGENTS.md";
+    case "project-memory":
+      return "Project memory";
+    case "user-memory":
+      return "User memory";
+  }
+}
+
+// src/storage/config-store.ts
+var DefaultConfigStore = class {
+  current;
+  watchers = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this.current = deepFreeze(structuredClone(initial));
+  }
+  get() {
+    return this.current;
+  }
+  getSection(key) {
+    return this.current[key];
+  }
+  getExtension(pluginName) {
+    const ext = this.current.extensions?.[pluginName];
+    return ext ? ext : FROZEN_EMPTY;
+  }
+  update(partial) {
+    const next = deepFreeze(structuredClone({ ...this.current, ...partial }));
+    if (next.version !== 1) {
+      throw new Error(`ConfigStore.update: version must remain 1, got ${String(next.version)}`);
+    }
+    const prev = this.current;
+    this.current = next;
+    for (const w of this.watchers) {
+      try {
+        w(next, prev);
+      } catch (err) {
+        console.error("[config-store] watcher threw:", err);
+      }
+    }
+    return next;
+  }
+  watch(cb) {
+    this.watchers.add(cb);
+    return () => this.watchers.delete(cb);
+  }
+};
+var FROZEN_EMPTY = Object.freeze({});
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Object.isFrozen(obj)) return obj;
+  for (const key of Object.keys(obj)) {
+    const v = obj[key];
+    if (v !== null && typeof v === "object" && !Object.isFrozen(v)) {
+      deepFreeze(v);
+    }
+  }
+  return Object.freeze(obj);
+}
+function decryptConfigSecrets(cfg, vault) {
+  return walk(cfg, vault, (v, key) => {
+    try {
+      return vault.decrypt(v);
+    } catch (err) {
+      console.warn(
+        `[secret-vault] Failed to decrypt "${key}":`,
+        err instanceof Error ? err.message : err
+      );
+      return "";
+    }
+  });
+}
+function walk(node, vault, transform) {
+  if (node === null || node === void 0) return node;
+  if (typeof node !== "object") return node;
+  if (Array.isArray(node)) {
+    return node.map((item) => walk(item, vault, transform));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === "string" && isSecretField(k)) {
+      out[k] = transform(v, k);
+    } else if (typeof v === "object" && v !== null) {
+      out[k] = walk(v, vault, transform);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var SECRET_KEY_PATTERN = /(?:apikey|api_key|authtoken|auth_token|bearer|secret|password|passwd|pwd|refreshtoken|refresh_token|sessionkey|session_key|access[_-]?token|private[_-]?key)/i;
+var NON_SECRET_OVERRIDES = /* @__PURE__ */ new Set(["publickey", "public_key"]);
+function isSecretField(name) {
+  const lc = name.toLowerCase();
+  if (NON_SECRET_OVERRIDES.has(lc)) return false;
+  return SECRET_KEY_PATTERN.test(lc);
+}
+
+// src/utils/safe-json.ts
+function safeParse(input, maxBytes = 5e6) {
+  if (input.length > maxBytes) {
+    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/storage/config-loader.ts
+var BEHAVIOR_DEFAULTS = {
+  version: 1,
+  context: {
+    warnThreshold: 0.6,
+    softThreshold: 0.75,
+    hardThreshold: 0.9,
+    autoCompact: true,
+    preserveK: 10,
+    eliseThreshold: 2e3
+  },
+  tools: {
+    defaultExecutionStrategy: "smart",
+    maxIterations: 100,
+    iterationTimeoutMs: 3e5,
+    sessionTimeoutMs: 18e5,
+    perIterationOutputCapBytes: 1e5,
+    autoExtendLimit: true
+  },
+  log: { level: "info" },
+  features: {
+    mcp: true,
+    plugins: true,
+    memory: true,
+    modelsRegistry: true,
+    skills: true
+  }
+};
+var ENV_MAP = {
+  WRONGSTACK_PROVIDER: (c, v) => {
+    c.provider = v;
+  },
+  WRONGSTACK_MODEL: (c, v) => {
+    c.model = v;
+  },
+  WRONGSTACK_API_KEY: (c, v) => {
+    c.apiKey = v;
+  },
+  WRONGSTACK_BASE_URL: (c, v) => {
+    c.baseUrl = v;
+  },
+  WRONGSTACK_LOG_LEVEL: (c, v) => {
+    if (!c.log) c.log = { level: "info" };
+    c.log.level = v;
+  }
+};
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object");
+}
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function deepMerge(base, patch) {
+  if (typeof base !== "object" || base === null) return patch ?? base;
+  if (typeof patch !== "object" || patch === null) return base;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    if (FORBIDDEN_PROTO_KEYS.has(k)) continue;
+    const existing = out[k];
+    if (Array.isArray(v)) {
+      if (Array.isArray(existing) && isPrimitiveArray(v) && isPrimitiveArray(existing)) {
+        out[k] = [.../* @__PURE__ */ new Set([...existing, ...v])];
+      } else {
+        out[k] = v;
+        if (process.env.WRONGSTACK_DEBUG_CONFIG) {
+          console.warn(
+            `[config] Non-primitive array for "${k}" replaced (global + local config merge). Global entries: ${existing?.length ?? 0}, local entries: ${v.length}.`
+          );
+        }
+      }
+    } else if (typeof v === "object" && v !== null && typeof existing === "object" && existing !== null) {
+      out[k] = deepMerge(existing, v);
+    } else if (v !== void 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+var DefaultConfigLoader = class {
+  paths;
+  strict;
+  vault;
+  extraSources;
+  constructor(opts) {
+    this.paths = opts.paths;
+    this.strict = opts.strict ?? false;
+    this.vault = opts.vault;
+    this.extraSources = opts.sources ?? [];
+  }
+  async load(opts = {}) {
+    let cfg = { ...BEHAVIOR_DEFAULTS };
+    const [global, local] = await Promise.all([
+      this.readJson(this.paths.globalConfig),
+      this.readJson(this.paths.projectLocalConfig)
+    ]);
+    cfg = deepMerge(cfg, global);
+    cfg = deepMerge(cfg, local);
+    for (const [key, fn] of Object.entries(ENV_MAP)) {
+      const v = process.env[key];
+      if (v) fn(cfg, v);
+    }
+    const sorted = [...this.extraSources].sort((a, b) => {
+      const pd = (a.priority ?? 50) - (b.priority ?? 50);
+      if (pd !== 0) return pd;
+      return a.name.localeCompare(b.name);
+    });
+    for (const src of sorted) {
+      try {
+        const patch = await src.read();
+        if (patch && Object.keys(patch).length > 0) {
+          cfg = deepMerge(cfg, patch);
+        }
+      } catch (err) {
+        console.warn(`Config source "${src.name}" failed`, err);
+      }
+    }
+    if (opts.cliFlags) {
+      cfg = deepMerge(cfg, opts.cliFlags);
+    }
+    if (this.vault) {
+      cfg = decryptConfigSecrets(cfg, this.vault);
+    }
+    if (cfg.providers) {
+      for (const pcfg of Object.values(cfg.providers)) {
+        if (!pcfg || typeof pcfg !== "object") continue;
+        const rawKeys = pcfg.apiKeys;
+        if (!Array.isArray(rawKeys) || rawKeys.length === 0) continue;
+        const keys = rawKeys.filter(
+          (k) => !!k && typeof k === "object" && typeof k.label === "string" && typeof k.apiKey === "string"
+        );
+        if (keys.length === 0) continue;
+        const existing = pcfg.apiKey;
+        if (existing && existing.length > 0) continue;
+        const activeLabel = pcfg.activeKey;
+        const chosen = activeLabel ? keys.find((k) => k.label === activeLabel) ?? keys[0] : keys[0];
+        if (chosen?.apiKey) {
+          pcfg.apiKey = chosen.apiKey;
+        }
+      }
+    }
+    this.validateBehavior(cfg);
+    if (this.strict) {
+      this.validateIdentity(cfg);
+    }
+    return Object.freeze(cfg);
+  }
+  async readJson(file) {
+    let raw;
+    try {
+      raw = await fsp.readFile(file, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.warn(`[config] Failed to read "${file}":`, err);
+      }
+      return {};
+    }
+    const parsed = safeParse(raw);
+    if (!parsed.ok || !parsed.value) {
+      console.warn(
+        `[config] Failed to parse "${file}": invalid JSON. Falling back to defaults for this layer.`
+      );
+      return {};
+    }
+    return parsed.value;
+  }
+  validateBehavior(cfg) {
+    if (cfg.version === void 0) throw new Error("Config: missing version field");
+    if (cfg.version !== 1) throw new Error(`Config: unsupported version ${cfg.version}`);
+    const c = cfg.context;
+    if (!c) throw new Error("Config: missing context section");
+    const fields = ["warnThreshold", "softThreshold", "hardThreshold"];
+    for (const f of fields) {
+      const v = c[f];
+      if (typeof v !== "number" || !Number.isFinite(v)) {
+        throw new Error(`Config: context.${String(f)} must be a finite number (got ${typeof v})`);
+      }
+    }
+    if (c.warnThreshold >= c.softThreshold || c.softThreshold >= c.hardThreshold) {
+      throw new Error("Config: context thresholds must satisfy warn < soft < hard");
+    }
+  }
+  validateIdentity(cfg) {
+    if (!cfg.provider) {
+      throw new Error(
+        "Config: no provider configured. Run `wstack init` or set WRONGSTACK_PROVIDER."
+      );
+    }
+    if (!cfg.model) {
+      throw new Error("Config: no model configured. Run `wstack init` or set WRONGSTACK_MODEL.");
+    }
+  }
+};
+
+// src/storage/config-migration.ts
+var ConfigMigrationError = class extends Error {
+  fromVersion;
+  targetVersion;
+  missingStep;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "ConfigMigrationError";
+    this.fromVersion = opts.fromVersion;
+    this.targetVersion = opts.targetVersion;
+    this.missingStep = opts.missingStep;
+  }
+};
+function runConfigMigrations(input, targetVersion, migrations) {
+  const initial = typeof input["version"] === "number" ? input["version"] : 1;
+  let current = { ...input };
+  let currentVersion = initial;
+  const applied = [];
+  let shouldPersist = false;
+  let guard = 0;
+  while (currentVersion !== targetVersion) {
+    if (++guard > 100) {
+      throw new ConfigMigrationError({
+        message: `Config migration looped past 100 steps (from v${initial} toward v${targetVersion})`,
+        fromVersion: initial,
+        targetVersion,
+        missingStep: currentVersion
+      });
+    }
+    const step = migrations.find((m) => m.from === currentVersion);
+    if (!step) {
+      throw new ConfigMigrationError({
+        message: `No migration registered from config v${currentVersion} (target v${targetVersion}). Update the framework or revert the config file.`,
+        fromVersion: initial,
+        targetVersion,
+        missingStep: currentVersion
+      });
+    }
+    const ctx = { fromVersion: currentVersion, shouldPersist: false };
+    const next = step.migrate(current, ctx);
+    if (typeof next["version"] !== "number" || next["version"] !== step.to) {
+      next["version"] = step.to;
+    }
+    current = next;
+    currentVersion = step.to;
+    applied.push(`v${step.from}\u2192v${step.to}`);
+    shouldPersist = shouldPersist || ctx.shouldPersist || step.from < step.to;
+  }
+  return { config: current, applied, shouldPersist };
+}
+var DEFAULT_CONFIG_MIGRATIONS = [];
+var LOCK_FILE = "active.json";
+var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var RecoveryLock = class {
+  file;
+  pid;
+  hostname;
+  maxAgeMs;
+  sessionStore;
+  probe;
+  constructor(opts) {
+    this.file = path2.join(opts.dir, LOCK_FILE);
+    this.pid = opts.pid ?? process.pid;
+    this.hostname = opts.hostname ?? os.hostname();
+    this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
+    this.sessionStore = opts.sessionStore;
+    this.probe = opts.isPidAlive ?? defaultIsPidAlive;
+  }
+  /**
+   * Examine the lockfile and decide whether it represents an abandoned
+   * session. Returns `null` if the file is missing, points to a live
+   * instance, references a clean-closed session, is too old, or is
+   * malformed. Otherwise returns enough detail to prompt the user.
+   *
+   * Important: this is a read-only check. We never delete an active
+   * lock from here — if another wstack instance is alive, the caller
+   * should bail or run with a fresh session instead.
+   */
+  async checkAbandoned() {
+    const lock = await this.readLock();
+    if (!lock) return null;
+    const ageMs = Date.now() - new Date(lock.startedAt).getTime();
+    if (Number.isNaN(ageMs) || ageMs < 0) {
+      return null;
+    }
+    if (ageMs > this.maxAgeMs) return null;
+    if (lock.hostname === this.hostname && this.probe(lock.pid)) {
+      return null;
+    }
+    let messageCount = 0;
+    if (this.sessionStore) {
+      try {
+        const data = await this.sessionStore.load(lock.sessionId);
+        const closed = data.events.some((e) => e.type === "session_end");
+        if (closed) return null;
+        messageCount = data.messages.length;
+      } catch {
+        return null;
+      }
+    }
+    return {
+      sessionId: lock.sessionId,
+      pid: lock.pid,
+      startedAt: lock.startedAt,
+      ageMs,
+      messageCount
+    };
+  }
+  /**
+   * Claim the lock for the given session. Overwrites any existing lock
+   * — the caller should have already handled abandonment (via
+   * `checkAbandoned`) before calling this.
+   */
+  async write(sessionId) {
+    await ensureDir(path2.dirname(this.file));
+    const lock = {
+      v: 1,
+      sessionId,
+      pid: this.pid,
+      hostname: this.hostname,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tmp = `${this.file}.tmp`;
+    await fsp.writeFile(tmp, JSON.stringify(lock), { mode: 384 });
+    await fsp.rename(tmp, this.file);
+  }
+  /**
+   * Release the lock. Idempotent — silently succeeds if the file is
+   * already gone (e.g. someone else cleared it, or the directory was
+   * wiped).
+   */
+  async clear() {
+    try {
+      await fsp.unlink(this.file);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return;
+      throw err;
+    }
+  }
+  async readLock() {
+    let raw;
+    try {
+      raw = await fsp.readFile(this.file, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return null;
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (!isLockFile(parsed)) return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+};
+function isLockFile(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return o["v"] === 1 && typeof o["sessionId"] === "string" && typeof o["pid"] === "number" && typeof o["hostname"] === "string" && typeof o["startedAt"] === "string";
+}
+function defaultIsPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+
+// src/storage/session-reader.ts
+var DefaultSessionReader = class {
+  store;
+  constructor(opts) {
+    this.store = opts.store;
+  }
+  async query(q = {}) {
+    const raw = await this.store.list(q.limit ? Math.max(q.limit * 4, 100) : 1e3);
+    const titleNeedle = q.titleContains?.toLowerCase();
+    const filtered = raw.filter((s) => {
+      if (q.since && s.startedAt < q.since) return false;
+      if (q.until && s.startedAt > q.until) return false;
+      if (q.provider && s.provider !== q.provider) return false;
+      if (q.model && s.model !== q.model) return false;
+      if (q.minTokens !== void 0 && s.tokenTotal < q.minTokens) return false;
+      if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
+      return true;
+    });
+    const out = filtered.map((s) => ({
+      id: s.id,
+      title: s.title,
+      startedAt: s.startedAt,
+      provider: s.provider,
+      model: s.model,
+      tokenTotal: s.tokenTotal
+    }));
+    return q.limit ? out.slice(0, q.limit) : out;
+  }
+  async *replay(sessionId) {
+    const data = await this.store.load(sessionId);
+    for (const e of data.events) yield e;
+  }
+  async search(q, sessionId) {
+    const limit = q.limit ?? 100;
+    const matcher = buildMatcher(q);
+    const allowedTypes = q.types ? new Set(q.types) : null;
+    const ids = sessionId ? [sessionId] : (await this.store.list(1e3)).map((s) => s.id);
+    const hits = [];
+    for (const id of ids) {
+      let data;
+      try {
+        data = await this.store.load(id);
+      } catch {
+        continue;
+      }
+      for (let i = 0; i < data.events.length; i++) {
+        const ev = data.events[i];
+        if (allowedTypes && !allowedTypes.has(ev.type)) continue;
+        const text = eventText(ev);
+        if (text === null) continue;
+        const hit = matcher(text);
+        if (!hit) continue;
+        hits.push({
+          sessionId: id,
+          eventIndex: i,
+          ts: ev.ts,
+          type: ev.type,
+          snippet: snippetOf(text, hit.start, hit.end)
+        });
+        if (hits.length >= limit) return hits;
+      }
+    }
+    return hits;
+  }
+  async export(sessionId, opts) {
+    const data = await this.store.load(sessionId);
+    const includeTools = opts.includeTools ?? true;
+    const includeDiagnostics = opts.includeDiagnostics ?? true;
+    const filtered = data.events.filter((e) => {
+      if (!includeTools && (e.type === "tool_use" || e.type === "tool_result" || e.type === "tool_call_start" || e.type === "tool_call_end")) {
+        return false;
+      }
+      if (!includeDiagnostics && (e.type === "error" || e.type === "compaction" || e.type === "message_truncated")) {
+        return false;
+      }
+      return true;
+    });
+    if (opts.format === "json") {
+      return JSON.stringify({ metadata: data.metadata, events: filtered }, null, 2);
+    }
+    if (opts.format === "text") {
+      return renderPlainText(data.metadata, filtered);
+    }
+    return renderMarkdown(data.metadata, filtered);
+  }
+  async metadata(sessionId) {
+    const data = await this.store.load(sessionId);
+    return data.metadata;
+  }
+};
+function buildMatcher(q) {
+  const ci = q.caseInsensitive ?? true;
+  if (q.regex) {
+    const flags = ci ? "i" : "";
+    const re = new RegExp(q.query, flags);
+    return (text) => {
+      const m = re.exec(text);
+      return m ? { start: m.index, end: m.index + m[0].length } : null;
+    };
+  }
+  const needle = ci ? q.query.toLowerCase() : q.query;
+  return (text) => {
+    const hay = ci ? text.toLowerCase() : text;
+    const idx = hay.indexOf(needle);
+    return idx === -1 ? null : { start: idx, end: idx + needle.length };
+  };
+}
+function eventText(e) {
+  switch (e.type) {
+    case "user_input":
+      return contentToString(e.content);
+    case "llm_response":
+      return contentToString(e.content);
+    case "tool_use":
+      return `${e.name} ${JSON.stringify(e.input)}`;
+    case "tool_result":
+      return typeof e.content === "string" ? e.content : JSON.stringify(e.content);
+    case "error":
+      return `${e.phase}: ${e.message}`;
+    case "session_start":
+    case "session_resumed":
+      return `${e.model}/${e.provider}`;
+    case "task_created":
+    case "task_completed":
+      return e.title;
+    case "task_failed":
+      return `${e.title}: ${e.error}`;
+    case "skill_activated":
+    case "skill_deactivated":
+      return e.skillName;
+    default:
+      return null;
+  }
+}
+function contentToString(content) {
+  if (typeof content === "string") return content;
+  return content.map((b) => {
+    switch (b.type) {
+      case "text":
+        return b.text;
+      case "tool_use":
+        return `[tool_use:${b.name} ${JSON.stringify(b.input)}]`;
+      case "tool_result":
+        return typeof b.content === "string" ? b.content : JSON.stringify(b.content);
+      default:
+        return "";
+    }
+  }).join("\n");
+}
+var SNIPPET_RADIUS = 60;
+function snippetOf(text, start, end) {
+  const from = Math.max(0, start - SNIPPET_RADIUS);
+  const to = Math.min(text.length, end + SNIPPET_RADIUS);
+  const prefix = from > 0 ? "\u2026" : "";
+  const suffix = to < text.length ? "\u2026" : "";
+  return prefix + text.slice(from, to).replace(/\s+/g, " ").trim() + suffix;
+}
+function renderMarkdown(meta, events) {
+  const lines = [];
+  lines.push(`# Session ${meta.id}`);
+  lines.push("");
+  if (meta.model || meta.provider) {
+    lines.push(`- **Model:** ${meta.provider ?? "?"}/${meta.model ?? "?"}`);
+  }
+  lines.push(`- **Started:** ${meta.startedAt}`);
+  if (meta.endedAt) lines.push(`- **Ended:** ${meta.endedAt}`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const e of events) {
+    switch (e.type) {
+      case "user_input": {
+        lines.push(`## User \u2014 ${e.ts}`);
+        lines.push("");
+        lines.push(contentToString(e.content));
+        lines.push("");
+        break;
+      }
+      case "llm_response": {
+        lines.push(`## Assistant \u2014 ${e.ts}`);
+        lines.push("");
+        lines.push(contentToString(e.content));
+        if (e.stopReason && e.stopReason !== "end_turn") {
+          lines.push("");
+          lines.push(`*stop: ${e.stopReason}*`);
+        }
+        lines.push("");
+        break;
+      }
+      case "tool_use": {
+        lines.push(`### Tool call: \`${e.name}\``);
+        lines.push("");
+        lines.push("```json");
+        lines.push(JSON.stringify(e.input, null, 2));
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+      case "tool_result": {
+        const body = typeof e.content === "string" ? e.content : JSON.stringify(e.content, null, 2);
+        lines.push(`### Tool result${e.isError ? " (error)" : ""}`);
+        lines.push("");
+        lines.push("```");
+        lines.push(body);
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+      case "error": {
+        lines.push(`> **Error** (${e.phase}): ${e.message}`);
+        lines.push("");
+        break;
+      }
+      case "compaction": {
+        lines.push(`> **Compaction**: ${e.before} \u2192 ${e.after} tokens`);
+        lines.push("");
+        break;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderPlainText(meta, events) {
+  const lines = [];
+  lines.push(
+    `Session ${meta.id} \u2014 ${meta.provider ?? "?"}/${meta.model ?? "?"} \u2014 started ${meta.startedAt}`
+  );
+  lines.push("".padEnd(72, "-"));
+  for (const e of events) {
+    switch (e.type) {
+      case "user_input":
+        lines.push(`[${e.ts}] USER`);
+        lines.push(contentToString(e.content));
+        lines.push("");
+        break;
+      case "llm_response":
+        lines.push(`[${e.ts}] ASSISTANT`);
+        lines.push(contentToString(e.content));
+        lines.push("");
+        break;
+      case "tool_use":
+        lines.push(`[${e.ts}] TOOL_USE ${e.name} ${JSON.stringify(e.input)}`);
+        break;
+      case "tool_result":
+        lines.push(
+          `[${e.ts}] TOOL_RESULT${e.isError ? " (error)" : ""} ${typeof e.content === "string" ? e.content : JSON.stringify(e.content)}`
+        );
+        break;
+      case "error":
+        lines.push(`[${e.ts}] ERROR (${e.phase}): ${e.message}`);
+        break;
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/storage/session-analyzer.ts
+var SessionAnalyzer = class {
+  analyze(events) {
+    const toolUsageCount = {};
+    const errors = [];
+    const modeChanges = [];
+    const tasksById = /* @__PURE__ */ new Map();
+    let sessionId = "";
+    for (const event of events) {
+      if (event.type === "session_start" || event.type === "session_resumed") {
+        if (!sessionId) sessionId = event.id;
+      }
+      if (event.type === "tool_use") {
+        toolUsageCount[event.name] = (toolUsageCount[event.name] ?? 0) + 1;
+      }
+      if (event.type === "error") {
+        errors.push({ ts: event.ts, phase: event.phase, message: event.message });
+      }
+      if (event.type === "mode_changed") {
+        modeChanges.push({ ts: event.ts, from: event.from, to: event.to });
+      }
+      if (event.type === "task_created") {
+        tasksById.set(event.taskId, {
+          taskId: event.taskId,
+          title: event.title,
+          status: "created",
+          createdAt: event.ts
+        });
+      }
+      if (event.type === "task_updated") {
+        const t = tasksById.get(event.taskId);
+        if (t) t.status = event.status;
+      }
+      if (event.type === "task_completed") {
+        const t = tasksById.get(event.taskId);
+        if (t) {
+          t.status = "completed";
+          t.completedAt = event.ts;
+        } else {
+          tasksById.set(event.taskId, {
+            taskId: event.taskId,
+            title: event.title,
+            status: "completed",
+            createdAt: event.ts,
+            completedAt: event.ts
+          });
+        }
+      }
+      if (event.type === "task_failed") {
+        const t = tasksById.get(event.taskId);
+        if (t) {
+          t.status = "failed";
+          t.completedAt = event.ts;
+        } else {
+          tasksById.set(event.taskId, {
+            taskId: event.taskId,
+            title: event.title,
+            status: "failed",
+            createdAt: event.ts,
+            completedAt: event.ts
+          });
+        }
+      }
+    }
+    return {
+      sessionId,
+      totalDuration: this.calcDuration(events),
+      toolUsageCount,
+      errorCount: errors.length,
+      modeChanges,
+      tasks: Array.from(tasksById.values())
+    };
+  }
+  query(events, filter) {
+    return events.filter((e) => {
+      if (filter.eventTypes?.length && !filter.eventTypes.includes(e.type)) return false;
+      if (filter.toolNames?.length && e.type === "tool_use") {
+        const toolEvent = e;
+        if (!filter.toolNames.includes(toolEvent.name)) return false;
+      }
+      if (filter.timeRange) {
+        const ts = new Date(e.ts).getTime();
+        const start = new Date(filter.timeRange.start).getTime();
+        const end = new Date(filter.timeRange.end).getTime();
+        if (ts < start || ts > end) return false;
+      }
+      return true;
+    });
+  }
+  calcDuration(events) {
+    if (events.length < 2) return 0;
+    const first = new Date(events[0].ts).getTime();
+    const last = new Date(events[events.length - 1].ts).getTime();
+    return last - first;
+  }
+};
+
+export { ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultMemoryStore, DefaultSessionReader, DefaultSessionStore, QueueStore, RecoveryLock, SessionAnalyzer, runConfigMigrations };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map