@basou/core 0.4.0 → 0.6.0

package/dist/index.js

@@ -21,27 +21,6 @@ function summarizeAdapterOutput(_stream, _raw) {
   throw new Error("adapter_output summary is not implemented in this release");
 }
 
-// src/approval/approval-store.ts
-import { readdir } from "fs/promises";
-import { join } from "path";
-
-// src/lib/error-codes.ts
-function findErrorCode(error, code, depth = 4) {
-  let cur = error;
-  for (let i = 0; i < depth && cur instanceof Error; i++) {
-    const c = cur.code;
-    if (typeof c === "string" && c === code) return true;
-    cur = cur.cause;
-  }
-  return false;
-}
-
-// src/schemas/approval.schema.ts
-import { z as z2 } from "zod";
-
-// src/schemas/shared.schema.ts
-import { z } from "zod";
-
 // src/ids/ulid.ts
 import { isValid as isValidUlid, monotonicFactory } from "ulid";
 var ID_PREFIXES = Object.freeze(["ws", "task", "ses", "evt", "appr", "decision"]);
@@ -67,12 +46,565 @@ function isValidPrefixedId(value) {
   return isValidUlid(ulidPart);
 }
 
+// src/stats/active-time.ts
+var ACTIVE_GAP_CAP_MS = 5 * 60 * 1e3;
+var ENGAGED_TURNS_METHOD = "engaged-turns";
+var TURN_INTERVALS_METHOD = "turn-intervals";
+function activeTimeFromTimestamps(timestampsMs, capMs) {
+  const sorted = timestampsMs.filter((t) => Number.isFinite(t)).sort((a, b) => a - b);
+  const raw = [];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const curr = sorted[i];
+    if (prev === void 0 || curr === void 0) continue;
+    const gap = curr - prev;
+    if (gap <= 0) continue;
+    raw.push([prev, prev + Math.min(gap, capMs)]);
+  }
+  const intervals = mergeIntervals(raw);
+  return { ms: sumDurations(intervals), intervals };
+}
+function mergeIntervals(intervals) {
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const [start, end] of sorted) {
+    const last = merged[merged.length - 1];
+    if (last !== void 0 && start <= last[1]) {
+      if (end > last[1]) last[1] = end;
+    } else {
+      merged.push([start, end]);
+    }
+  }
+  return merged;
+}
+function unionDurationMs(intervals) {
+  const merged = mergeIntervals(intervals);
+  return { ms: sumDurations(merged), merged };
+}
+function intervalsMsToIso(intervals) {
+  return intervals.map(([start, end]) => ({
+    start: new Date(start).toISOString(),
+    end: new Date(end).toISOString()
+  }));
+}
+function intervalsIsoToMs(intervals) {
+  const out = [];
+  for (const { start, end } of intervals) {
+    const s = Date.parse(start);
+    const e = Date.parse(end);
+    if (Number.isFinite(s) && Number.isFinite(e) && e >= s) out.push([s, e]);
+  }
+  return out;
+}
+function sumDurations(intervals) {
+  let total = 0;
+  for (const [start, end] of intervals) total += end - start;
+  return total;
+}
+
+// src/adapters/claude-code/transcript-importer.ts
+var CLAUDE_IMPORT_SOURCE = "claude-code-import";
+function claudeTranscriptToImportPayload(records, options) {
+  const placeholderSessionId = prefixedUlid("ses");
+  const askAnswers = indexAskAnswers(records);
+  const derived = [];
+  const relatedFiles = /* @__PURE__ */ new Set();
+  let minTs;
+  let maxTs;
+  let workingDir;
+  let claudeSessionId;
+  let outputTokens = 0;
+  let inputTokens = 0;
+  let cachedInputTokens = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const engagementTsMs = [];
+  const seenEngagementMessageIds = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const ts = readString(record.timestamp);
+    if (ts === void 0) continue;
+    if (minTs === void 0 || Date.parse(ts) < Date.parse(minTs)) minTs = ts;
+    if (maxTs === void 0 || Date.parse(ts) > Date.parse(maxTs)) maxTs = ts;
+    if (workingDir === void 0) workingDir = readString(record.cwd);
+    if (claudeSessionId === void 0) claudeSessionId = readString(record.sessionId);
+    if (record.isSidechain !== true) {
+      const tsMs = Date.parse(ts);
+      if (Number.isFinite(tsMs)) {
+        const recType = readString(record.type);
+        if (recType === "user") {
+          if (isHumanUserMessage(record)) engagementTsMs.push(tsMs);
+        } else if (recType === "assistant") {
+          const msg = isObject(record.message) ? record.message : void 0;
+          const mid = msg !== void 0 ? readString(msg.id) : void 0;
+          if (mid === void 0 || !seenEngagementMessageIds.has(mid)) {
+            if (mid !== void 0) seenEngagementMessageIds.add(mid);
+            engagementTsMs.push(tsMs);
+          }
+        }
+      }
+    }
+    if (readString(record.type) !== "assistant") continue;
+    const message = isObject(record.message) ? record.message : void 0;
+    const usage = message !== void 0 && isObject(message.usage) ? message.usage : void 0;
+    if (usage !== void 0) {
+      const messageId = message !== void 0 ? readString(message.id) : void 0;
+      const alreadyCounted = messageId !== void 0 && seenMessageIds.has(messageId);
+      if (!alreadyCounted) {
+        if (messageId !== void 0) seenMessageIds.add(messageId);
+        outputTokens += readNonNegInt(usage.output_tokens);
+        inputTokens += readNonNegInt(usage.input_tokens);
+        cachedInputTokens += readNonNegInt(usage.cache_read_input_tokens);
+      }
+    }
+    const cwd = readString(record.cwd) ?? workingDir ?? ".";
+    for (const item of toolUses(record)) {
+      const name = readString(item.name);
+      const input = isObject(item.input) ? item.input : void 0;
+      if (input === void 0) continue;
+      if (name === "Bash") {
+        const command = readString(input.command);
+        if (command !== void 0) {
+          derived.push(commandExecutedEvent(ts, placeholderSessionId, command, cwd));
+        }
+        continue;
+      }
+      if (name === "AskUserQuestion") {
+        const useId = readString(item.id);
+        const answers = useId !== void 0 ? askAnswers.get(useId) : void 0;
+        if (answers !== void 0) {
+          for (const [question, answer] of Object.entries(answers)) {
+            if (question.length === 0) continue;
+            const answerStr = typeof answer === "string" && answer.length > 0 ? answer : void 0;
+            const title = answerStr !== void 0 ? `${question} -> ${answerStr}` : question;
+            derived.push(decisionRecordedEvent(ts, placeholderSessionId, title));
+          }
+        }
+        continue;
+      }
+      if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
+        const path2 = readString(input.file_path) ?? readString(input.notebook_path);
+        if (path2 !== void 0) {
+          const changeType = name === "Write" ? "added" : "modified";
+          relatedFiles.add(path2);
+          derived.push(fileChangedEvent(ts, placeholderSessionId, path2, changeType));
+        }
+      }
+    }
+  }
+  if (minTs === void 0 || maxTs === void 0) return null;
+  if (derived.length === 0) return null;
+  derived.sort((a, b) => Date.parse(a.occurred_at) - Date.parse(b.occurred_at));
+  const events = [
+    sessionStartedEvent(minTs, placeholderSessionId),
+    ...derived,
+    sessionEndedEvent(maxTs, placeholderSessionId)
+  ];
+  const externalId = options.externalId ?? claudeSessionId;
+  const commandCount = derived.reduce((n, e) => e.type === "command_executed" ? n + 1 : n, 0);
+  const fileCount = relatedFiles.size;
+  const date = minTs.slice(0, 10);
+  const label = `claude-code ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}, ${fileCount} ${fileCount === 1 ? "file" : "files"}`;
+  const active = engagementTsMs.length >= 2 ? activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS) : void 0;
+  const metricsFields = {
+    ...outputTokens > 0 ? { output_tokens: outputTokens } : {},
+    ...inputTokens > 0 ? { input_tokens: inputTokens } : {},
+    ...cachedInputTokens > 0 ? { cached_input_tokens: cachedInputTokens } : {},
+    ...active !== void 0 && active.ms > 0 ? {
+      active_time_ms: active.ms,
+      active_intervals: intervalsMsToIso(active.intervals),
+      active_gap_cap_ms: ACTIVE_GAP_CAP_MS,
+      active_time_method: ENGAGED_TURNS_METHOD
+    } : {}
+  };
+  const metrics = Object.keys(metricsFields).length > 0 ? metricsFields : void 0;
+  const payload = {
+    schema_version: "0.1.0",
+    session: {
+      label,
+      workspace_id: options.workspaceId,
+      source: {
+        kind: CLAUDE_IMPORT_SOURCE,
+        version: "0.1.0",
+        ...externalId !== void 0 ? { external_id: externalId } : {}
+      },
+      started_at: minTs,
+      ended_at: maxTs,
+      // Validated against the canonical enum here; importSessionFromJson
+      // overwrites it with the literal "imported" regardless.
+      status: "imported",
+      working_directory: workingDir ?? ".",
+      invocation: { command: "claude", args: [], exit_code: null },
+      related_files: [...relatedFiles].sort(),
+      summary: null,
+      ...metrics !== void 0 ? { metrics } : {}
+    },
+    events
+  };
+  return payload;
+}
+function baseEvent(occurredAt, sessionId) {
+  return {
+    schema_version: "0.1.0",
+    id: prefixedUlid("evt"),
+    session_id: sessionId,
+    occurred_at: occurredAt,
+    source: CLAUDE_IMPORT_SOURCE
+  };
+}
+function sessionStartedEvent(occurredAt, sessionId) {
+  return { ...baseEvent(occurredAt, sessionId), type: "session_started" };
+}
+function sessionEndedEvent(occurredAt, sessionId) {
+  return { ...baseEvent(occurredAt, sessionId), type: "session_ended" };
+}
+function commandExecutedEvent(occurredAt, sessionId, command, cwd) {
+  return {
+    ...baseEvent(occurredAt, sessionId),
+    type: "command_executed",
+    command: "bash",
+    args: ["-c", command],
+    cwd,
+    exit_code: null,
+    duration_ms: 0
+  };
+}
+function fileChangedEvent(occurredAt, sessionId, path2, changeType) {
+  return {
+    ...baseEvent(occurredAt, sessionId),
+    type: "file_changed",
+    path: path2,
+    change_type: changeType
+  };
+}
+function decisionRecordedEvent(occurredAt, sessionId, title) {
+  return {
+    ...baseEvent(occurredAt, sessionId),
+    type: "decision_recorded",
+    decision_id: prefixedUlid("decision"),
+    title
+  };
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNonNegInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHumanUserMessage(record) {
+  const message = isObject(record.message) ? record.message : void 0;
+  if (message === void 0) return false;
+  const content = message.content;
+  if (typeof content === "string") return content.length > 0;
+  if (Array.isArray(content)) {
+    return content.some((block) => {
+      if (!isObject(block)) return false;
+      const type = readString(block.type);
+      return type !== void 0 && type !== "tool_result";
+    });
+  }
+  return false;
+}
+function toolUses(record) {
+  const message = isObject(record.message) ? record.message : void 0;
+  const content = message !== void 0 && Array.isArray(message.content) ? message.content : [];
+  const result = [];
+  for (const item of content) {
+    if (isObject(item) && readString(item.type) === "tool_use") {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function indexAskAnswers(records) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const result = record.toolUseResult;
+    if (!isObject(result)) continue;
+    const answers = result.answers;
+    if (!isObject(answers)) continue;
+    const message = isObject(record.message) ? record.message : void 0;
+    const content = message !== void 0 && Array.isArray(message.content) ? message.content : [];
+    for (const item of content) {
+      if (isObject(item) && readString(item.type) === "tool_result") {
+        const id = readString(item.tool_use_id);
+        if (id !== void 0) byId.set(id, answers);
+      }
+    }
+  }
+  return byId;
+}
+
+// src/adapters/codex/rollout-importer.ts
+var CODEX_IMPORT_SOURCE = "codex-import";
+function codexRolloutToImportPayload(records, options) {
+  const placeholderSessionId = prefixedUlid("ses");
+  const outputsByCallId = indexOutputs(records);
+  const turnStartMsByTurnId = indexTaskStarts(records);
+  const derived = [];
+  let minTs;
+  let maxTs;
+  let workingDir;
+  let codexSessionId;
+  let lastTokenTotals;
+  const engagementTsMs = [];
+  const completions = [];
+  const completedTurnIds = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    const ts = readString2(record.timestamp);
+    if (ts === void 0) continue;
+    if (minTs === void 0 || Date.parse(ts) < Date.parse(minTs)) minTs = ts;
+    if (maxTs === void 0 || Date.parse(ts) > Date.parse(maxTs)) maxTs = ts;
+    const payload2 = isObject2(record.payload) ? record.payload : void 0;
+    if (payload2 === void 0) continue;
+    if (readString2(record.type) === "session_meta") {
+      if (workingDir === void 0) workingDir = readString2(payload2.cwd);
+      if (codexSessionId === void 0) codexSessionId = readString2(payload2.id);
+      continue;
+    }
+    if (readString2(record.type) === "event_msg" && readString2(payload2.type) === "token_count") {
+      const info = isObject2(payload2.info) ? payload2.info : void 0;
+      const totals = info !== void 0 && isObject2(info.total_token_usage) ? info.total_token_usage : void 0;
+      if (totals !== void 0) lastTokenTotals = totals;
+      continue;
+    }
+    if (readString2(record.type) === "event_msg") {
+      const pt = readString2(payload2.type);
+      if (pt === "user_message" || pt === "agent_message" || pt === "task_started" || pt === "task_complete") {
+        const tsMs = Date.parse(ts);
+        if (Number.isFinite(tsMs)) engagementTsMs.push(tsMs);
+      }
+      if (pt === "task_complete") {
+        const turnId = readString2(payload2.turn_id);
+        if (turnId === void 0 || !completedTurnIds.has(turnId)) {
+          if (turnId !== void 0) completedTurnIds.add(turnId);
+          completions.push({
+            interval: turnIntervalFromComplete(ts, payload2, turnStartMsByTurnId),
+            durationMs: readNonNegInt2(payload2.duration_ms)
+          });
+        }
+      }
+      continue;
+    }
+    if (readString2(record.type) !== "response_item") continue;
+    if (readString2(payload2.type) !== "function_call") continue;
+    if (readString2(payload2.name) !== "exec_command") continue;
+    const command = readExecCommand(payload2.arguments);
+    if (command === void 0) continue;
+    const cwd = command.workdir ?? workingDir ?? ".";
+    const output = readCallId(payload2.call_id, outputsByCallId);
+    const execTsMs = Date.parse(ts);
+    if (Number.isFinite(execTsMs)) engagementTsMs.push(execTsMs);
+    derived.push(
+      commandExecutedEvent2(ts, placeholderSessionId, command.cmd, cwd, {
+        exitCode: parseExitCode(output),
+        durationMs: parseWallTimeMs(output)
+      })
+    );
+  }
+  if (minTs === void 0 || maxTs === void 0) return null;
+  if (derived.length === 0) return null;
+  derived.sort((a, b) => Date.parse(a.occurred_at) - Date.parse(b.occurred_at));
+  const events = [
+    sessionStartedEvent2(minTs, placeholderSessionId),
+    ...derived,
+    sessionEndedEvent2(maxTs, placeholderSessionId)
+  ];
+  const externalId = options.externalId ?? codexSessionId;
+  const commandCount = derived.length;
+  const date = minTs.slice(0, 10);
+  const label = `codex ${date}: ${commandCount} ${commandCount === 1 ? "command" : "commands"}`;
+  const minTsMs = Date.parse(minTs);
+  const turnIntervals = [];
+  let machineActiveMs = 0;
+  let allCompletedTurnsHaveDuration = true;
+  for (const { interval, durationMs } of completions) {
+    if (durationMs <= 0) allCompletedTurnsHaveDuration = false;
+    if (interval === void 0) continue;
+    const start = Number.isFinite(minTsMs) ? Math.max(interval[0], minTsMs) : interval[0];
+    const end = interval[1];
+    if (!(start < end)) continue;
+    turnIntervals.push([start, end]);
+    machineActiveMs += Math.min(durationMs, end - start);
+  }
+  const pointResult = activeTimeFromTimestamps(engagementTsMs, ACTIVE_GAP_CAP_MS);
+  const active = turnIntervals.length > 0 || pointResult.intervals.length > 0 ? unionDurationMs([...turnIntervals, ...pointResult.intervals]) : void 0;
+  const activeMethod = turnIntervals.length > 0 ? TURN_INTERVALS_METHOD : ENGAGED_TURNS_METHOD;
+  const machineActive = allCompletedTurnsHaveDuration ? machineActiveMs : 0;
+  const tokenFields = lastTokenTotals === void 0 ? {} : {
+    ...readNonNegInt2(lastTokenTotals.output_tokens) > 0 ? { output_tokens: readNonNegInt2(lastTokenTotals.output_tokens) } : {},
+    ...readNonNegInt2(lastTokenTotals.input_tokens) > 0 ? { input_tokens: readNonNegInt2(lastTokenTotals.input_tokens) } : {},
+    ...readNonNegInt2(lastTokenTotals.cached_input_tokens) > 0 ? { cached_input_tokens: readNonNegInt2(lastTokenTotals.cached_input_tokens) } : {},
+    ...readNonNegInt2(lastTokenTotals.reasoning_output_tokens) > 0 ? { reasoning_output_tokens: readNonNegInt2(lastTokenTotals.reasoning_output_tokens) } : {}
+  };
+  const metricsFields = {
+    ...tokenFields,
+    ...active !== void 0 && active.ms > 0 ? {
+      active_time_ms: active.ms,
+      active_intervals: intervalsMsToIso(active.merged),
+      active_gap_cap_ms: ACTIVE_GAP_CAP_MS,
+      active_time_method: activeMethod
+    } : {},
+    ...machineActive > 0 ? { machine_active_time_ms: machineActive } : {}
+  };
+  const metrics = Object.keys(metricsFields).length > 0 ? metricsFields : void 0;
+  const payload = {
+    schema_version: "0.1.0",
+    session: {
+      label,
+      workspace_id: options.workspaceId,
+      source: {
+        kind: CODEX_IMPORT_SOURCE,
+        version: "0.1.0",
+        ...externalId !== void 0 ? { external_id: externalId } : {}
+      },
+      started_at: minTs,
+      ended_at: maxTs,
+      // Validated against the canonical enum here; importSessionFromJson
+      // overwrites it with the literal "imported" regardless.
+      status: "imported",
+      working_directory: workingDir ?? ".",
+      invocation: { command: "codex", args: [], exit_code: null },
+      related_files: [],
+      summary: null,
+      ...metrics !== void 0 ? { metrics } : {}
+    },
+    events
+  };
+  return payload;
+}
+function baseEvent2(occurredAt, sessionId) {
+  return {
+    schema_version: "0.1.0",
+    id: prefixedUlid("evt"),
+    session_id: sessionId,
+    occurred_at: occurredAt,
+    source: CODEX_IMPORT_SOURCE
+  };
+}
+function sessionStartedEvent2(occurredAt, sessionId) {
+  return { ...baseEvent2(occurredAt, sessionId), type: "session_started" };
+}
+function sessionEndedEvent2(occurredAt, sessionId) {
+  return { ...baseEvent2(occurredAt, sessionId), type: "session_ended" };
+}
+function commandExecutedEvent2(occurredAt, sessionId, command, cwd, outcome) {
+  return {
+    ...baseEvent2(occurredAt, sessionId),
+    type: "command_executed",
+    command: "bash",
+    args: ["-c", command],
+    cwd,
+    exit_code: outcome.exitCode,
+    duration_ms: outcome.durationMs
+  };
+}
+function readString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readNonNegInt2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readExecCommand(value) {
+  const raw = readString2(value);
+  if (raw === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isObject2(parsed)) return void 0;
+  const cmd = readString2(parsed.cmd);
+  if (cmd === void 0) return void 0;
+  return { cmd, workdir: readString2(parsed.workdir) };
+}
+function readCallId(value, outputs) {
+  const callId = readString2(value);
+  return callId !== void 0 ? outputs.get(callId) : void 0;
+}
+function turnIntervalFromComplete(endTs, payload, startMsByTurnId) {
+  const endMs = Date.parse(endTs);
+  if (!Number.isFinite(endMs)) return void 0;
+  const turnId = readString2(payload.turn_id);
+  const indexedStart = turnId !== void 0 ? startMsByTurnId.get(turnId) : void 0;
+  const durationMs = readNonNegInt2(payload.duration_ms);
+  const startMs = indexedStart !== void 0 ? indexedStart : durationMs > 0 ? endMs - durationMs : void 0;
+  if (startMs === void 0 || !(startMs < endMs)) return void 0;
+  return [startMs, endMs];
+}
+function indexTaskStarts(records) {
+  const byTurnId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (readString2(record.type) !== "event_msg") continue;
+    const payload = isObject2(record.payload) ? record.payload : void 0;
+    if (payload === void 0 || readString2(payload.type) !== "task_started") continue;
+    const turnId = readString2(payload.turn_id);
+    const startMs = Date.parse(readString2(record.timestamp) ?? "");
+    if (turnId !== void 0 && Number.isFinite(startMs) && !byTurnId.has(turnId)) {
+      byTurnId.set(turnId, startMs);
+    }
+  }
+  return byTurnId;
+}
+function parseExitCode(output) {
+  if (output === void 0) return null;
+  const match = output.match(/Process exited with code (-?\d+)/);
+  return match?.[1] !== void 0 ? Number.parseInt(match[1], 10) : null;
+}
+function parseWallTimeMs(output) {
+  if (output === void 0) return 0;
+  const match = output.match(/Wall time:\s*([\d.]+)\s*seconds/);
+  if (match?.[1] === void 0) return 0;
+  const seconds = Number.parseFloat(match[1]);
+  return Number.isFinite(seconds) ? Math.round(seconds * 1e3) : 0;
+}
+function indexOutputs(records) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (readString2(record.type) !== "response_item") continue;
+    const payload = isObject2(record.payload) ? record.payload : void 0;
+    if (payload === void 0) continue;
+    if (readString2(payload.type) !== "function_call_output") continue;
+    const callId = readString2(payload.call_id);
+    const output = readString2(payload.output);
+    if (callId !== void 0 && output !== void 0) byId.set(callId, output);
+  }
+  return byId;
+}
+
+// src/approval/approval-store.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+
+// src/lib/error-codes.ts
+function findErrorCode(error, code, depth = 4) {
+  let cur = error;
+  for (let i = 0; i < depth && cur instanceof Error; i++) {
+    const c = cur.code;
+    if (typeof c === "string" && c === code) return true;
+    cur = cur.cause;
+  }
+  return false;
+}
+
+// src/schemas/approval.schema.ts
+import { z as z2 } from "zod";
+
 // src/schemas/shared.schema.ts
+import { z } from "zod";
 var SchemaVersionSchema = z.literal("0.1.0");
 var IsoTimestampSchema = z.string().datetime({ offset: true });
 var createPrefixedIdSchema = (prefix) => {
   const refiner = (value) => isValidPrefixedId(value) && value.startsWith(`${prefix}_`);
-  return z.string().refine(refiner, { message: `Expected ${prefix}_<ULID>` });
+  return z.string().refine(refiner, { message: `Expected ${prefix}_<ULID>` }).meta({
+    pattern: `^${prefix}_[0-7][0-9A-HJKMNP-TV-Z]{25}$`,
+    description: `Basou ${prefix} id: \`${prefix}_\` followed by a 26-character Crockford Base32 ULID.`
+  });
 };
 var WorkspaceIdSchema = createPrefixedIdSchema("ws");
 var TaskIdSchema = createPrefixedIdSchema("task");
@@ -488,13 +1020,19 @@ var SessionStatusSchema = z4.enum([
 ]);
 var SessionSourceKindSchema = z4.enum([
   "claude-code-adapter",
+  "claude-code-import",
+  "codex-import",
   "human",
   "import",
   "terminal"
 ]);
 var SessionSourceSchema = z4.object({
   kind: SessionSourceKindSchema,
-  version: z4.literal("0.1.0")
+  version: z4.literal("0.1.0"),
+  // Optional id of the originating session in the SOURCE tool's own
+  // namespace (e.g. the Claude Code session UUID for a `claude-code-import`).
+  // Lets re-imports of the same source be deduplicated; absent for live runs.
+  external_id: z4.string().optional()
 });
 var InvocationSchema = z4.object({
   command: z4.string().min(1),
@@ -503,6 +1041,17 @@ var InvocationSchema = z4.object({
   // code; the same nullability is mirrored in CommandExecutedEventSchema.
   exit_code: z4.number().int().nullable()
 });
+var SessionMetricsSchema = z4.object({
+  output_tokens: z4.number().int().nonnegative().optional(),
+  input_tokens: z4.number().int().nonnegative().optional(),
+  cached_input_tokens: z4.number().int().nonnegative().optional(),
+  reasoning_output_tokens: z4.number().int().nonnegative().optional(),
+  active_time_ms: z4.number().int().nonnegative().optional(),
+  active_intervals: z4.array(z4.object({ start: IsoTimestampSchema, end: IsoTimestampSchema })).optional(),
+  active_gap_cap_ms: z4.number().int().nonnegative().optional(),
+  active_time_method: z4.string().optional(),
+  machine_active_time_ms: z4.number().int().nonnegative().optional()
+});
 var SessionInnerSchema = z4.object({
   id: SessionIdSchema,
   label: z4.string().optional(),
@@ -517,7 +1066,8 @@ var SessionInnerSchema = z4.object({
   invocation: InvocationSchema,
   related_files: z4.array(z4.string()).default([]),
   events_log: z4.string().default("events.jsonl"),
-  summary: z4.string().nullable().optional()
+  summary: z4.string().nullable().optional(),
+  metrics: SessionMetricsSchema.optional()
 });
 var SessionSchema = z4.object({
   schema_version: SchemaVersionSchema,
@@ -2905,18 +3455,14 @@ async function renderHandoff(input) {
   const latestSession = [...liveEntries].sort(
     (a, b) => Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at)
   )[0];
-  const allFiles = /* @__PURE__ */ new Set();
-  for (const e of entries) {
-    if (e.session.session.source.kind === "import") continue;
-    for (const f of e.session.session.related_files) allFiles.add(f);
-  }
-  const sortedFiles = [...allFiles].sort();
+  const latestFiles = latestSession?.session.session.related_files ?? [];
+  const sortedFiles = [...new Set(latestFiles)].sort();
   const displayedFiles = sortedFiles.slice(0, limit);
   const overflow = Math.max(0, sortedFiles.length - limit);
   const suspectCount = entries.filter((e) => e.suspect).length;
   const firstEntry = entries[0];
   const lastEntry = entries[entries.length - 1];
-  const sessionRange = firstEntry !== void 0 && lastEntry !== void 0 ? `${firstEntry.sessionId}..${lastEntry.sessionId}` : "";
+  const sessionRange = firstEntry !== void 0 && lastEntry !== void 0 ? `${shortIdWithPrefix(firstEntry.sessionId)}..${shortIdWithPrefix(lastEntry.sessionId)}` : "";
   const body = formatHandoffBody({
     nowIso: input.nowIso,
     sessionRange,
@@ -2956,18 +3502,23 @@ function formatHandoffBody(args) {
   lines.push("## \u73FE\u5728\u306E\u72B6\u614B");
   lines.push("");
   if (args.latestSession !== void 0) {
-    const sid = args.latestSession.sessionId;
     const status = args.latestSession.session.session.status;
-    lines.push(`- \u6700\u7D42 session: ${sid} (${status})`);
+    const label = args.latestSession.session.session.label;
+    const shortId = shortIdWithPrefix(args.latestSession.sessionId);
+    if (label !== void 0 && label !== "") {
+      lines.push(`- \u6700\u7D42 session: ${label} (${status}) [${shortId}]`);
+    } else {
+      lines.push(`- \u6700\u7D42 session: ${shortId} (${status})`);
+    }
   } else {
     lines.push("- \u6700\u7D42 session: (no live sessions)");
   }
   if (args.latestActivityRecord !== void 0) {
     const statusLabel = args.latestTaskDoc !== void 0 ? args.latestTaskDoc.task.task.status : "status unknown \u2014 task.md missing or invalid";
     const linkedCount = args.latestTaskDoc?.task.task.linked_sessions?.length;
-    const linkedSuffix = linkedCount !== void 0 && linkedCount > 1 ? ` (linked_sessions: ${linkedCount})` : "";
+    const linkedSuffix = linkedCount !== void 0 && linkedCount > 1 ? `, linked_sessions: ${linkedCount}` : "";
     lines.push(
-      `- \u6700\u7D42 task: ${args.latestActivityRecord.taskId} (${statusLabel}): ${args.latestActivityRecord.title}${linkedSuffix}`
+      `- \u6700\u7D42 task: ${args.latestActivityRecord.title} (${statusLabel}${linkedSuffix}) [${shortIdWithPrefix(args.latestActivityRecord.taskId)}]`
     );
   } else {
     lines.push("- \u6700\u7D42 task: (no tasks recorded yet)");
@@ -2988,7 +3539,7 @@ function formatHandoffBody(args) {
     lines.push("(no decisions recorded yet)");
   } else {
     const last = args.decisions[args.decisions.length - 1];
-    lines.push(`- ${last.decisionId}: ${last.title}`);
+    lines.push(`- ${last.title} [${shortIdWithPrefix(last.decisionId)}]`);
     lines.push("");
     lines.push(`(${args.decisions.length} decisions total \u2014 see decisions.md)`);
   }
@@ -3016,7 +3567,9 @@ function formatHandoffBody(args) {
     lines.push("(no pending tasks)");
   } else {
     for (const t of args.pendingTasks) {
-      lines.push(`- ${t.task.task.id} (${t.task.task.status}): ${t.task.task.title}`);
+      lines.push(
+        `- ${t.task.task.title} (${t.task.task.status}) [${shortIdWithPrefix(t.task.task.id)}]`
+      );
     }
   }
   lines.push("");
@@ -3085,6 +3638,11 @@ function shortHandoffId(sessionId) {
   if (sessionId.startsWith(SES)) return sessionId.slice(SES.length, SES.length + 10);
   return sessionId.slice(0, 10);
 }
+function shortIdWithPrefix(id) {
+  const sep = id.indexOf("_");
+  if (sep === -1) return id.slice(0, 10);
+  return id.slice(0, sep + 1) + id.slice(sep + 1, sep + 1 + 10);
+}
 
 // src/lib/duration.ts
 var DURATION_RE = /^([1-9]\d*)(ms|s|m|h)$/;
@@ -3300,6 +3858,9 @@ function classifySpawnError(error) {
   return new Error("Failed to spawn child process", { cause: error });
 }
 
+// src/schemas/json-schema.ts
+import { z as z11 } from "zod";
+
 // src/schemas/manifest.schema.ts
 import { z as z9 } from "zod";
 var ProjectSchema = z9.object({
@@ -3350,7 +3911,10 @@ var SessionInnerImportSchema = z10.object({
   workspace_id: WorkspaceIdSchema,
   source: z10.object({
     kind: SessionSourceKindSchema,
-    version: z10.literal("0.1.0")
+    version: z10.literal("0.1.0"),
+    // Source-tool-native id (e.g. Claude Code session UUID), retained so
+    // re-imports of the same source can be deduplicated.
+    external_id: z10.string().optional()
   }),
   started_at: IsoTimestampSchema,
   ended_at: IsoTimestampSchema.optional(),
@@ -3363,7 +3927,8 @@ var SessionInnerImportSchema = z10.object({
   }),
   related_files: z10.array(z10.string()).default([]),
   events_log: z10.string().optional(),
-  summary: z10.string().nullable().optional()
+  summary: z10.string().nullable().optional(),
+  metrics: SessionMetricsSchema.optional()
 }).strict();
 var SessionImportPayloadSchema = z10.object({
   schema_version: z10.string(),
@@ -3371,29 +3936,388 @@ var SessionImportPayloadSchema = z10.object({
   events: z10.array(EventSchema)
 }).strict();
 
+// src/schemas/json-schema.ts
+var JSON_SCHEMA_VERSION = "0.1.0";
+var ID_BASE = `https://basou.dev/schemas/${JSON_SCHEMA_VERSION}`;
+var JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+var DOCUMENTS = [
+  {
+    name: "manifest",
+    schema: ManifestSchema,
+    title: "Basou Manifest",
+    description: "The `.basou/manifest.yaml` workspace manifest."
+  },
+  {
+    name: "session",
+    schema: SessionSchema,
+    title: "Basou Session",
+    description: "A `.basou/sessions/<id>/session.yaml` session record."
+  },
+  {
+    name: "event",
+    schema: EventSchema,
+    title: "Basou Event",
+    description: "One line of a `.basou/sessions/<id>/events.jsonl` stream (a discriminated union over the event `type`)."
+  },
+  {
+    name: "task",
+    schema: TaskSchema,
+    title: "Basou Task",
+    description: "The YAML front matter of a `.basou/tasks/<id>.md` task document."
+  },
+  {
+    name: "approval",
+    schema: ApprovalSchema,
+    title: "Basou Approval",
+    description: "A `.basou/approvals/{pending,resolved}/<id>.yaml` approval record."
+  },
+  {
+    name: "status",
+    schema: StatusSchema,
+    title: "Basou Status",
+    description: "The `.basou/status.json` workspace status snapshot."
+  },
+  {
+    name: "task-index",
+    schema: TaskIndexSchema,
+    title: "Basou Task Index",
+    description: "The `.basou/tasks/index.json` task lookup index."
+  },
+  {
+    name: "session-import",
+    schema: SessionImportPayloadSchema,
+    title: "Basou Session Import Payload",
+    description: "The portable session payload consumed by `basou session import` (and produced by `basou session export`)."
+  }
+];
+function buildJsonSchemas() {
+  return DOCUMENTS.map((doc) => {
+    const generated = z11.toJSONSchema(doc.schema, { io: "input" });
+    const { $schema, ...rest } = generated;
+    const schema = {
+      $schema: typeof $schema === "string" ? $schema : JSON_SCHEMA_DIALECT,
+      $id: `${ID_BASE}/${doc.name}.schema.json`,
+      title: doc.title,
+      description: doc.description,
+      ...rest
+    };
+    return { name: doc.name, schema };
+  });
+}
+function serializeJsonSchema(schema) {
+  return `${JSON.stringify(schema, null, 2)}
+`;
+}
+
+// src/stats/work-stats.ts
+import { join as join11 } from "path";
+function resolveTimeZone(timeZone) {
+  if (timeZone !== void 0 && timeZone.length > 0) return timeZone;
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+var STATUS_ORDER = [
+  "completed",
+  "failed",
+  "running",
+  "interrupted",
+  "waiting_approval",
+  "initialized",
+  "imported",
+  "archived"
+];
+async function computeWorkStats(input) {
+  const { now } = input;
+  const timeZone = resolveTimeZone(input.timeZone);
+  const unreadableEmitted = /* @__PURE__ */ new Set();
+  const wrappedSkip = (sid, reason) => {
+    if (reason === "events_jsonl_unreadable") unreadableEmitted.add(sid);
+    input.onSessionSkip?.(sid, reason);
+  };
+  const loadOpts = { now, onSkip: wrappedSkip };
+  if (input.onWarning !== void 0) loadOpts.onWarning = input.onWarning;
+  const entries = await loadSessionEntries(input.paths, loadOpts);
+  const sessions = [];
+  for (const entry of entries) {
+    const events = [];
+    let eventsUnreadable = false;
+    try {
+      for await (const ev of replayEvents(join11(input.paths.sessions, entry.sessionId), {
+        onWarning: (w) => input.onWarning?.(w, entry.sessionId)
+      })) {
+        events.push(ev);
+      }
+    } catch {
+      eventsUnreadable = true;
+      if (!unreadableEmitted.has(entry.sessionId)) {
+        wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
+      }
+    }
+    sessions.push(
+      sessionWorkStatsFromEvents(
+        entry.sessionId,
+        entry.session.session,
+        events,
+        now,
+        eventsUnreadable
+      )
+    );
+  }
+  const allIntervals = [];
+  for (const s of sessions) allIntervals.push(...intervalsIsoToMs(s.activeIntervals));
+  const union = unionDurationMs(allIntervals);
+  return {
+    generatedAt: now.toISOString(),
+    activeGapCapMs: ACTIVE_GAP_CAP_MS,
+    timeZone,
+    totals: computeTotals(sessions, union.ms),
+    sessions,
+    bySource: computeBySource(sessions),
+    byStatus: computeByStatus(sessions),
+    byDay: computeByDay(sessions, union.merged, timeZone)
+  };
+}
+function sessionWorkStatsFromEvents(sessionId, inner, events, now, eventsUnreadable = false) {
+  let commandCount = 0;
+  let fileChangedCount = 0;
+  let decisionCount = 0;
+  let commandTimeMs = 0;
+  const timestamps = [];
+  for (const ev of events) {
+    const t = Date.parse(ev.occurred_at);
+    if (Number.isFinite(t)) timestamps.push(t);
+    if (ev.type === "command_executed") {
+      commandCount++;
+      commandTimeMs += ev.duration_ms;
+    } else if (ev.type === "file_changed") {
+      fileChangedCount++;
+    } else if (ev.type === "decision_recorded") {
+      decisionCount++;
+    }
+  }
+  const span = computeSpan(inner.started_at, inner.ended_at, now);
+  const tokens = readTokens(inner.metrics);
+  const active = resolveActiveTime(inner.metrics, timestamps);
+  const machineActiveTimeMs = inner.metrics?.machine_active_time_ms ?? 0;
+  return {
+    sessionId,
+    label: inner.label,
+    status: inner.status,
+    sourceKind: inner.source.kind,
+    startedAt: inner.started_at,
+    endedAt: inner.ended_at,
+    open: inner.ended_at === void 0,
+    sessionSpanMs: span.ms,
+    commandTimeMs,
+    activeTimeMs: active.ms,
+    activeTimeBasis: active.basis,
+    activeIntervals: intervalsMsToIso(active.intervals),
+    machineActiveTimeMs,
+    activeTimeMethod: inner.metrics?.active_time_method,
+    commandCount,
+    fileChangedCount,
+    decisionCount,
+    eventCount: events.length,
+    tokens,
+    availability: {
+      span: true,
+      commandTime: inner.source.kind !== "claude-code-import",
+      activeTime: active.intervals.length > 0,
+      tokens: hasTokens(tokens),
+      machineActive: machineActiveTimeMs > 0
+    },
+    spanClamped: span.clamped,
+    eventsUnreadable
+  };
+}
+function resolveActiveTime(metrics, eventTimestamps) {
+  const stored = metrics?.active_intervals;
+  if (stored !== void 0 && stored.length > 0) {
+    const intervals = intervalsIsoToMs(stored);
+    const ms = intervals.reduce((n, [start, end]) => n + (end - start), 0);
+    return { ms, intervals, basis: "engaged-turns" };
+  }
+  const derived = activeTimeFromTimestamps(eventTimestamps, ACTIVE_GAP_CAP_MS);
+  return { ms: derived.ms, intervals: derived.intervals, basis: "events" };
+}
+function computeSpan(startedAt, endedAt, now) {
+  const start = Date.parse(startedAt);
+  const end = endedAt !== void 0 ? Date.parse(endedAt) : now.getTime();
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return { ms: 0, clamped: true };
+  const raw = end - start;
+  return raw < 0 ? { ms: 0, clamped: true } : { ms: raw, clamped: false };
+}
+function readTokens(metrics) {
+  return {
+    output: metrics?.output_tokens ?? 0,
+    input: metrics?.input_tokens ?? 0,
+    cached: metrics?.cached_input_tokens ?? 0,
+    reasoning: metrics?.reasoning_output_tokens ?? 0
+  };
+}
+function hasTokens(t) {
+  return t.output > 0 || t.input > 0 || t.cached > 0 || t.reasoning > 0;
+}
+function emptyTokens() {
+  return { output: 0, input: 0, cached: 0, reasoning: 0 };
+}
+function addTokens(a, b) {
+  a.output += b.output;
+  a.input += b.input;
+  a.cached += b.cached;
+  a.reasoning += b.reasoning;
+}
+function computeTotals(sessions, billableActiveTimeMs) {
+  const tokens = emptyTokens();
+  const totals = {
+    sessionCount: sessions.length,
+    openSessionCount: 0,
+    sessionSpanMs: 0,
+    commandTimeMs: 0,
+    activeTimeMs: 0,
+    billableActiveTimeMs,
+    machineActiveTimeMs: 0,
+    commandCount: 0,
+    fileChangedCount: 0,
+    decisionCount: 0,
+    eventCount: 0,
+    tokens,
+    commandTimeReliable: true,
+    tokensAvailable: false,
+    machineActiveAvailable: false
+  };
+  for (const s of sessions) {
+    if (s.open) totals.openSessionCount++;
+    totals.sessionSpanMs += s.sessionSpanMs;
+    totals.commandTimeMs += s.commandTimeMs;
+    totals.activeTimeMs += s.activeTimeMs;
+    totals.machineActiveTimeMs += s.machineActiveTimeMs;
+    totals.commandCount += s.commandCount;
+    totals.fileChangedCount += s.fileChangedCount;
+    totals.decisionCount += s.decisionCount;
+    totals.eventCount += s.eventCount;
+    addTokens(tokens, s.tokens);
+    if (!s.availability.commandTime) totals.commandTimeReliable = false;
+    if (s.availability.tokens) totals.tokensAvailable = true;
+    if (s.availability.machineActive) totals.machineActiveAvailable = true;
+  }
+  return totals;
+}
+function computeBySource(sessions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    let row = map.get(s.sourceKind);
+    if (row === void 0) {
+      row = {
+        sourceKind: s.sourceKind,
+        sessionCount: 0,
+        sessionSpanMs: 0,
+        commandTimeMs: 0,
+        activeTimeMs: 0,
+        machineActiveTimeMs: 0,
+        commandCount: 0,
+        fileChangedCount: 0,
+        decisionCount: 0,
+        eventCount: 0,
+        tokens: emptyTokens(),
+        commandTimeReliable: true,
+        tokensAvailable: false,
+        machineActiveAvailable: false
+      };
+      map.set(s.sourceKind, row);
+    }
+    row.sessionCount++;
+    row.sessionSpanMs += s.sessionSpanMs;
+    row.commandTimeMs += s.commandTimeMs;
+    row.activeTimeMs += s.activeTimeMs;
+    row.machineActiveTimeMs += s.machineActiveTimeMs;
+    row.commandCount += s.commandCount;
+    row.fileChangedCount += s.fileChangedCount;
+    row.decisionCount += s.decisionCount;
+    row.eventCount += s.eventCount;
+    addTokens(row.tokens, s.tokens);
+    if (!s.availability.commandTime) row.commandTimeReliable = false;
+    if (s.availability.tokens) row.tokensAvailable = true;
+    if (s.availability.machineActive) row.machineActiveAvailable = true;
+  }
+  return [...map.values()].sort((a, b) => a.sourceKind.localeCompare(b.sourceKind));
+}
+function computeByStatus(sessions) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of sessions) counts.set(s.status, (counts.get(s.status) ?? 0) + 1);
+  const ordered = [];
+  for (const status of STATUS_ORDER) {
+    const count = counts.get(status);
+    if (count !== void 0 && count > 0) ordered.push({ status, count });
+  }
+  return ordered;
+}
+function computeByDay(sessions, unionMerged, timeZone) {
+  const days = /* @__PURE__ */ new Map();
+  const ensure = (date) => {
+    let day = days.get(date);
+    if (day === void 0) {
+      day = {
+        date,
+        billableActiveTimeMs: 0,
+        machineActiveTimeMs: 0,
+        sessionCount: 0,
+        commandCount: 0,
+        fileChangedCount: 0,
+        decisionCount: 0,
+        tokens: emptyTokens()
+      };
+      days.set(date, day);
+    }
+    return day;
+  };
+  for (const [start, end] of unionMerged) {
+    ensure(tzDate(start, timeZone)).billableActiveTimeMs += end - start;
+  }
+  for (const s of sessions) {
+    const startedMs = Date.parse(s.startedAt);
+    if (!Number.isFinite(startedMs)) continue;
+    const day = ensure(tzDate(startedMs, timeZone));
+    day.sessionCount++;
+    day.machineActiveTimeMs += s.machineActiveTimeMs;
+    day.commandCount += s.commandCount;
+    day.fileChangedCount += s.fileChangedCount;
+    day.decisionCount += s.decisionCount;
+    addTokens(day.tokens, s.tokens);
+  }
+  return [...days.values()].sort((a, b) => a.date.localeCompare(b.date));
+}
+function tzDate(ms, timeZone) {
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).format(new Date(ms));
+}
+
 // src/storage/basou-dir.ts
 import { lstat as lstat3, mkdir as mkdir3 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function basouPaths(repositoryRoot) {
-  const root = join11(repositoryRoot, ".basou");
-  const approvalsBase = join11(root, "approvals");
+  const root = join12(repositoryRoot, ".basou");
+  const approvalsBase = join12(root, "approvals");
   return {
     root,
-    sessions: join11(root, "sessions"),
-    tasks: join11(root, "tasks"),
+    sessions: join12(root, "sessions"),
+    tasks: join12(root, "tasks"),
     approvals: {
-      pending: join11(approvalsBase, "pending"),
-      resolved: join11(approvalsBase, "resolved")
+      pending: join12(approvalsBase, "pending"),
+      resolved: join12(approvalsBase, "resolved")
     },
-    locks: join11(root, "locks"),
-    logs: join11(root, "logs"),
-    raw: join11(root, "raw"),
-    tmp: join11(root, "tmp"),
+    locks: join12(root, "locks"),
+    logs: join12(root, "logs"),
+    raw: join12(root, "raw"),
+    tmp: join12(root, "tmp"),
     files: {
-      manifest: join11(root, "manifest.yaml"),
-      status: join11(root, "status.json"),
-      handoff: join11(root, "handoff.md"),
-      decisions: join11(root, "decisions.md")
+      manifest: join12(root, "manifest.yaml"),
+      status: join12(root, "status.json"),
+      handoff: join12(root, "handoff.md"),
+      decisions: join12(root, "decisions.md")
     }
   };
 }
@@ -3450,11 +4374,11 @@ function hasErrorCode3(error) {
 
 // src/storage/gitignore.ts
 import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var MARKER = "# Basou - default ignore";
 var BASOU_GITIGNORE_BLOCK = "# Basou - default ignore\n.basou/logs/\n.basou/raw/\n.basou/tmp/\n.basou/locks/\n.basou/status.json\n.basou/sessions/*/events.jsonl\n.basou/sessions/*/artifacts/\n.basou/approvals/pending/\n.basou/approvals/resolved/\n\n# Basou - default commit\n# .basou/manifest.yaml\n# .basou/handoff.md\n# .basou/decisions.md\n# .basou/tasks/\n# .basou/sessions/*/session.yaml\n# .basou/sessions/*/transcript.md\n# .basou/sessions/*/changed-files.json\n";
 async function appendBasouGitignore(repositoryRoot) {
-  const gitignorePath = join12(repositoryRoot, ".gitignore");
+  const gitignorePath = join13(repositoryRoot, ".gitignore");
   let body;
   let existed;
   try {
@@ -3668,7 +4592,7 @@ function hasErrorCode6(error) {
 // src/storage/session-import.ts
 import { mkdir as mkdir4, rm as rm2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function importSessionFromJson(paths, manifest, payload, options) {
   if (options.taskIdOverride !== void 0 && !TaskIdSchema.safeParse(options.taskIdOverride).success) {
     throw new Error(`Invalid task_id: ${options.taskIdOverride}`);
@@ -3693,7 +4617,7 @@ async function importSessionFromJson(paths, manifest, payload, options) {
       pathSanitizeReport
     };
   }
-  const sessionDir = join13(paths.sessions, newSessionId);
+  const sessionDir = join14(paths.sessions, newSessionId);
   try {
     await mkdir4(sessionDir, { recursive: true });
   } catch (error) {
@@ -3706,7 +4630,7 @@ async function importSessionFromJson(paths, manifest, payload, options) {
     throw error;
   }
   try {
-    const sessionYamlPath = join13(sessionDir, "session.yaml");
+    const sessionYamlPath = join14(sessionDir, "session.yaml");
     await linkYamlFile(sessionYamlPath, sessionRecord);
   } catch (error) {
     await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
@@ -3787,7 +4711,8 @@ function buildSessionRecord(input, manifest, newSessionId, options) {
     invocation: input.invocation,
     related_files: relatedSanitized.sanitized,
     events_log: "events.jsonl",
-    summary: input.summary ?? null
+    summary: input.summary ?? null,
+    ...input.metrics !== void 0 ? { metrics: input.metrics } : {}
   };
   return {
     record: { schema_version: "0.1.0", session: inner },
@@ -3801,10 +4726,13 @@ function buildSessionRecord(input, manifest, newSessionId, options) {
 // src/index.ts
 var BASOU_CORE_VERSION = "0.1.0";
 export {
+  ACTIVE_GAP_CAP_MS,
   ApprovalIdSchema,
   ApprovalSchema,
   ApprovalStatusSchema,
   BASOU_CORE_VERSION,
+  CLAUDE_IMPORT_SOURCE,
+  CODEX_IMPORT_SOURCE,
   ChildProcessRunner,
   DecisionIdSchema,
   EventIdSchema,
@@ -3815,6 +4743,7 @@ export {
   GENERATED_START,
   ID_PREFIXES,
   IsoTimestampSchema,
+  JSON_SCHEMA_VERSION,
   ManifestSchema,
   RiskLevelSchema,
   STUCK_THRESHOLD_MS,
@@ -3822,6 +4751,7 @@ export {
   SessionIdSchema,
   SessionImportPayloadSchema,
   SessionInnerImportSchema,
+  SessionMetricsSchema,
   SessionSchema,
   SessionSourceKindSchema,
   SessionStatusSchema,
@@ -3838,9 +4768,13 @@ export {
   archiveTask,
   assertBasouRootSafe,
   basouPaths,
+  buildJsonSchemas,
   buildStatusSnapshot,
   classifySuspect,
   claudeCodeAdapterMetadata,
+  claudeTranscriptToImportPayload,
+  codexRolloutToImportPayload,
+  computeWorkStats,
   createAdHocSessionWithEvent,
   createManifest,
   createTaskWithEvent,
@@ -3887,6 +4821,8 @@ export {
   sanitizePath,
   sanitizeRelatedFiles,
   sanitizeWorkingDirectory,
+  serializeJsonSchema,
+  sessionWorkStatsFromEvents,
   summarizeAdapterOutput,
   tryRemoteUrl,
   ulid,