@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.9

package/dist/builtin/workflows/builtin/chunk-qwzvgxnq.js

@@ -0,0 +1,404 @@
+import {
+  fold_usage
+} from "./chunk-7at6dnkr.js";
+import {
+  build_scoring_prompt,
+  scoring_prompt_reads,
+  warm_first_fan_out
+} from "./chunk-7430zyas.js";
+import {
+  stableArtifactRoot
+} from "./chunk-wpckd35c.js";
+import {
+  VERIFICATION_SCALE,
+  decide_verification,
+  normalize_criteria,
+  parse_rubric
+} from "./chunk-cg9tmks0.js";
+import {
+  workflow
+} from "./chunk-bfkmzv9h.js";
+import {
+  withSteeringPropagationContext
+} from "./chunk-0x6e303p.js";
+
+// dist/builtin/workflows/builtin/adversarial-verification.ts
+import { Type as Type2 } from "typebox";
+
+// dist/builtin/workflows/builtin/adversarial-verification-runner.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+
+// dist/builtin/workflows/builtin/adversarial-verification-prompts.ts
+var GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+var READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
+function renderWorkerPrompt(task) {
+  return `<role>
+You produce a candidate solution for independent verification.
+</role>
+
+<success_criteria>
+The task is complete and important claims have observable support. Preserve concrete evidence and state every validation performed.
+</success_criteria>
+
+<stop_rules>
+Stop when the candidate is complete and validated where practical, or state the evidence still missing.
+</stop_rules>
+
+<output_format>
+A self-contained candidate with actions taken, evidence, validation, and remaining risks. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<objective>
+${task}
+</objective>`;
+}
+function renderConsolidatorPrompt(task, candidatePath, scorePaths, repairsCompleted, maxRepairs) {
+  return `<artifacts>
+Candidate: ${candidatePath}
+Confirmed criterion score reports: ${scorePaths.join(", ")}
+</artifacts>
+
+<role>
+You consolidate confirmed verifier findings into actionable repair guidance. You do not decide whether verification is approved; the deterministic verification gate already made that decision.
+</role>
+
+<decision_rules>
+Preserve every confirmed veto or blocking finding in remaining_work verbatim. Explain concrete repairs and validation steps. Repair budget: ${repairsCompleted}/${maxRepairs}.
+</decision_rules>
+
+<output_format>
+Call structured_output with repair_guidance (a concise actionable repair plan) and remaining_work (the unresolved findings as strings). Never emit an approval or rejection decision. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<objective>
+Consolidate findings for the candidate produced for: ${task}
+</objective>`;
+}
+function renderRepairPrompt(task, candidatePath, reviewPath) {
+  return `<artifacts>
+Read the current candidate at ${candidatePath} and consolidated findings at ${reviewPath}.
+</artifacts>
+
+<role>
+You repair a candidate using independent blocking findings.
+</role>
+
+<success_criteria>
+Every actionable blocker is addressed, relevant validation is rerun, and valid prior work is retained.
+</success_criteria>
+
+<evidence_rules>
+Do not dismiss a finding without contrary evidence. Report commands run, observed output, and file:line evidence where applicable. ${GROUNDED_REPORTING}
+</evidence_rules>
+
+<stop_rules>
+Stop when all actionable blockers are repaired and validated, or list any blocker that remains with the missing evidence.
+</stop_rules>
+
+<output_format>
+A complete replacement candidate with repair summary, evidence, validation, and remaining risks. ${READABLE_REPORT}
+</output_format>
+
+<objective>
+Repair the candidate for: ${task}
+</objective>`;
+}
+
+// dist/builtin/workflows/builtin/adversarial-verification-runner.ts
+var DEFAULT_CRITERIA = {
+  task_fit: "The candidate satisfies the literal task.",
+  evidence: "Important claims cite observable evidence, and file findings cite file:line where applicable.",
+  completeness: "Relevant validation is executed and reported with commands run and observed output, and no blocking correctness, safety, or completeness gap remains."
+};
+var QUORUM_FRACTION = 1;
+var criterionScoreSchema = Type.Object({
+  criterion_id: Type.String(),
+  score: VERIFICATION_SCALE.schema,
+  evidence: Type.Array(Type.String()),
+  findings: Type.Array(Type.Object({
+    finding: Type.String(),
+    severity: Type.Union([Type.Literal("veto"), Type.Literal("blocking"), Type.Literal("note")])
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+var consolidatorSchema = Type.Object({
+  repair_guidance: Type.String(),
+  remaining_work: Type.Array(Type.String())
+}, { additionalProperties: false });
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && keys.every((key) => (key in value));
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function isCriterionFinding(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["finding", "severity"]) && typeof value.finding === "string" && (value.severity === "veto" || value.severity === "blocking" || value.severity === "note");
+}
+function isCriterionScore(value, criterionId) {
+  return value !== undefined && isRecord(value) && hasOnlyKeys(value, ["criterion_id", "score", "evidence", "findings"]) && value.criterion_id === criterionId && typeof value.score === "number" && Number.isInteger(value.score) && value.score >= VERIFICATION_SCALE.min && value.score <= VERIFICATION_SCALE.max && isStringArray(value.evidence) && Array.isArray(value.findings) && value.findings.every(isCriterionFinding);
+}
+function isConsolidatedReport(value) {
+  return value !== undefined && isRecord(value) && hasOnlyKeys(value, ["repair_guidance", "remaining_work"]) && typeof value.repair_guidance === "string" && isStringArray(value.remaining_work);
+}
+function structured(value, guard) {
+  return guard(value) ? value : undefined;
+}
+function resolveCriteria(value) {
+  if (value === undefined) {
+    return { groundTruthNote: "", criteria: normalize_criteria(DEFAULT_CRITERIA) };
+  }
+  if (typeof value === "string")
+    return parse_rubric(value);
+  if (isStringRecord(value))
+    return { groundTruthNote: "", criteria: normalize_criteria(value) };
+  throw new TypeError("criteria must be a criteria.md string or a record of criterion descriptions");
+}
+function renderCriteriaMarkdown(criteria) {
+  const lines = ["# Verification criteria"];
+  if (criteria.groundTruthNote.length > 0)
+    lines.push("## Ground Truth Note", criteria.groundTruthNote);
+  lines.push("## Criteria");
+  for (const item of criteria.criteria) {
+    lines.push(`### ${item.name} {#${item.id}}`, item.description);
+  }
+  return `${lines.join(`
+
+`)}
+`;
+}
+function meanScore(scores) {
+  if (scores.length === 0)
+    return 0;
+  return scores.reduce((total, score) => total + score.score, 0) / scores.length;
+}
+function toCriterionScore(report) {
+  return {
+    criterionId: report.criterion_id,
+    score: report.score,
+    evidence: report.evidence,
+    findings: report.findings
+  };
+}
+function findingText(decision) {
+  return decision.findings.map((finding) => finding.finding);
+}
+function quorumEvidence(missing, invalidCount, expectedCount, reaskLimit) {
+  return `Quorum failure: ${missing} of ${expectedCount} criterion scores remain missing after ${reaskLimit} re-ask wave(s); ${invalidCount} report attempts were invalid or missing.`;
+}
+function stageName(cell, reaskWave) {
+  return reaskWave === 0 ? cell.name : `${cell.name}-reask-${reaskWave}`;
+}
+function verifierOutputFormat(criterionId) {
+  return `Call structured_output with criterion_id (set to ${criterionId}), score (1–20), evidence (string array), and findings containing finding and severity (veto, blocking, or note).`;
+}
+function scoreStep(cell, reaskWave, head, criteriaPath) {
+  const promptHead = {
+    ...head,
+    outputFormat: verifierOutputFormat(cell.criterion.id)
+  };
+  return {
+    name: stageName(cell, reaskWave),
+    prompt: build_scoring_prompt(promptHead, cell.criterion),
+    context: "fresh",
+    reads: [criteriaPath, ...scoring_prompt_reads(promptHead)],
+    schema: criterionScoreSchema
+  };
+}
+async function writeInvalid(path, stage) {
+  const marker = { invalid: true, stage };
+  await writeFile(path, `${JSON.stringify(marker, null, 2)}
+`);
+}
+async function runAdversarialVerification(ctx) {
+  const root = await stableArtifactRoot(ctx, "adversarial-verification");
+  const criteriaPath = join(root, "criteria.md");
+  const candidatePath = join(root, "candidate.md");
+  const resolvedCriteria = resolveCriteria(ctx.inputs.criteria);
+  await writeFile(criteriaPath, renderCriteriaMarkdown(resolvedCriteria));
+  await ctx.task("worker", { prompt: renderWorkerPrompt(ctx.inputs.task), context: "fresh", output: candidatePath, outputMode: "file-only" });
+  const verifierCount = ctx.inputs.verifier_count ?? 3;
+  const maxRepairs = ctx.inputs.max_repairs ?? 2;
+  const acceptMean = ctx.inputs.accept_mean ?? 14;
+  const reaskLimit = Math.max(0, Math.floor(ctx.inputs.reask_limit ?? 1));
+  const expectedCount = resolvedCriteria.criteria.length * verifierCount;
+  let repairsCompleted = 0;
+  let consecutiveIndeterminate = 0;
+  let finalDecision;
+  let finalMean = 0;
+  let scoreTablePath;
+  let reviewReportPath;
+  let remainingWork = [];
+  for (let round = 0;; round += 1) {
+    const candidateBody = await readFile(candidatePath, "utf8");
+    const scoringHead = {
+      task: ctx.inputs.task,
+      groundTruthNote: resolvedCriteria.groundTruthNote,
+      candidates: [{ path: candidatePath, body: candidateBody }],
+      scaleAnchors: VERIFICATION_SCALE.anchors
+    };
+    const cells = [];
+    for (const criterion of resolvedCriteria.criteria) {
+      for (let index = 0;index < verifierCount; index += 1) {
+        const name = `verifier-${round}-${criterion.id}-${index + 1}`;
+        cells.push({
+          criterion,
+          verifierIndex: index + 1,
+          name,
+          artifactPath: join(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
+        });
+      }
+    }
+    const runWave = async (pending2, reaskWave) => {
+      if (pending2.length === 0)
+        return { valid: [], invalid: [], results: [] };
+      const reports = await warm_first_fan_out(ctx, pending2.map((cell) => scoreStep(cell, reaskWave, scoringHead, criteriaPath)), () => scoringHead, { concurrency: Math.min(pending2.length, 4), failFast: false });
+      const byName = new Map;
+      for (const report of reports) {
+        const name = report.name ?? report.stageName;
+        if (name !== undefined)
+          byName.set(name, report);
+      }
+      const valid = [];
+      const invalid = [];
+      for (const cell of pending2) {
+        const report = byName.get(stageName(cell, reaskWave));
+        const artifactPath = reaskWave === 0 ? cell.artifactPath : cell.artifactPath.replace(/\.json$/, `-reask-${reaskWave}.json`);
+        if (isCriterionScore(report?.structured, cell.criterion.id)) {
+          await writeFile(artifactPath, `${JSON.stringify(report.structured, null, 2)}
+`);
+          valid.push({ cell, report: report.structured, artifactPath });
+        } else {
+          await writeInvalid(artifactPath, stageName(cell, reaskWave));
+          invalid.push(cell);
+        }
+      }
+      return { valid, invalid, results: reports };
+    };
+    const roundResults = [];
+    let pending = [...cells];
+    const validResults = [];
+    let invalidCount = 0;
+    for (let reaskWave = 0;reaskWave <= reaskLimit; reaskWave += 1) {
+      const wave = await runWave(pending, reaskWave);
+      roundResults.push(...wave.results);
+      validResults.push(...wave.valid);
+      invalidCount += wave.invalid.length;
+      pending = [...wave.invalid];
+      if (pending.length === 0)
+        break;
+    }
+    const validReportsByCell = new Map(validResults.map((item) => [item.cell.name, item.report]));
+    const scoreReports = cells.flatMap((cell) => {
+      const report = validReportsByCell.get(cell.name);
+      return report === undefined ? [] : [report];
+    });
+    const scores = scoreReports.map(toCriterionScore);
+    const roundResult = { scores, invalidCount, expectedCount };
+    const decision = decide_verification(roundResult, { acceptMean, quorumFraction: QUORUM_FRACTION });
+    finalDecision = decision;
+    finalMean = meanScore(scoreReports);
+    scoreTablePath = join(root, `verification-summary-${round}.json`);
+    reviewReportPath = join(root, `review-${round}.json`);
+    const summary = {
+      scores: scoreReports,
+      mean: finalMean,
+      invalidCount,
+      decision,
+      usage: fold_usage(roundResults)
+    };
+    if (decision.kind === "accept") {
+      remainingWork = [];
+      await writeFile(scoreTablePath, `${JSON.stringify(summary, null, 2)}
+`);
+      await writeFile(reviewReportPath, `${JSON.stringify({ decision, remaining_work: [] }, null, 2)}
+`);
+      break;
+    }
+    if (decision.kind === "indeterminate") {
+      consecutiveIndeterminate += 1;
+      remainingWork = [quorumEvidence(decision.missing, invalidCount, expectedCount, reaskLimit)];
+      await writeFile(scoreTablePath, `${JSON.stringify(summary, null, 2)}
+`);
+      await writeFile(reviewReportPath, `${JSON.stringify({ decision, evidence: remainingWork, remaining_work: remainingWork }, null, 2)}
+`);
+      if (consecutiveIndeterminate >= 2)
+        break;
+      continue;
+    }
+    consecutiveIndeterminate = 0;
+    const confirmedFindings = findingText(decision);
+    const scorePaths = validResults.map((item) => item.artifactPath);
+    const consolidated = await ctx.task(`consolidate-findings-${round}`, {
+      prompt: renderConsolidatorPrompt(ctx.inputs.task, candidatePath, scorePaths, repairsCompleted, maxRepairs),
+      context: "fresh",
+      reads: [candidatePath, criteriaPath, ...scorePaths],
+      schema: consolidatorSchema
+    });
+    const fallbackRemaining = confirmedFindings.length > 0 ? confirmedFindings : [`Mean score ${decision.mean} is below the acceptance threshold ${acceptMean}.`];
+    const consolidatedReport = structured(consolidated.structured, isConsolidatedReport) ?? { repair_guidance: "Confirmed verifier findings require repair.", remaining_work: fallbackRemaining };
+    remainingWork = fallbackRemaining;
+    await writeFile(scoreTablePath, `${JSON.stringify(summary, null, 2)}
+`);
+    await writeFile(reviewReportPath, `${JSON.stringify({ ...consolidatedReport, remaining_work: remainingWork }, null, 2)}
+`);
+    if (repairsCompleted >= maxRepairs)
+      break;
+    repairsCompleted += 1;
+    await ctx.task(`repair-${repairsCompleted}`, {
+      prompt: renderRepairPrompt(ctx.inputs.task, candidatePath, reviewReportPath),
+      context: "fresh",
+      reads: [candidatePath, reviewReportPath],
+      output: candidatePath,
+      outputMode: "file-only"
+    });
+  }
+  return {
+    approved: finalDecision.kind === "accept",
+    mean_score: finalMean,
+    score_table_path: scoreTablePath,
+    repairs_completed: repairsCompleted,
+    candidate_path: candidatePath,
+    review_report_path: reviewReportPath,
+    remaining_work: finalDecision.kind === "accept" ? [] : remainingWork
+  };
+}
+
+// dist/builtin/workflows/builtin/adversarial-verification.ts
+var adversarial_verification_default = workflow({
+  name: "adversarial-verification",
+  description: "Produce a candidate, score independent per-criterion verifier reports, and apply a deterministic mean-and-veto gate with bounded repairs.",
+  heartbeatIntervalMinutes: 15,
+  inputs: {
+    task: Type2.String({ description: "Task whose candidate result must be independently verified." }),
+    verifier_count: Type2.Integer({ minimum: 1, maximum: 5, default: 3, description: "Number of independent verifiers for each criterion per round." }),
+    max_repairs: Type2.Integer({ minimum: 0, maximum: 5, default: 2, description: "Maximum candidate repair rounds before rejection." }),
+    criteria: Type2.Union([
+      Type2.String(),
+      Type2.Record(Type2.String(), Type2.String())
+    ], { default: DEFAULT_CRITERIA, description: "Criteria record of name-to-description entries, or criteria.md markdown." }),
+    accept_mean: Type2.Number({ default: 14, description: "Mean score required for acceptance on the 1–20 verification scale." }),
+    reask_limit: Type2.Integer({ minimum: 0, default: 1, description: "Maximum bounded re-ask waves for invalid criterion reports." })
+  },
+  outputs: {
+    approved: Type2.Boolean({ description: "Whether the deterministic mean-and-veto gate accepted the candidate." }),
+    mean_score: Type2.Number({ description: "Mean score of the final round's schema-valid criterion reports." }),
+    score_table_path: Type2.String({ description: "Path to the final round per-criterion score summary." }),
+    repairs_completed: Type2.Integer({ description: "Number of repair rounds performed." }),
+    candidate_path: Type2.String({ description: "Path to the final candidate artifact." }),
+    review_report_path: Type2.String({ description: "Path to the final consolidated findings or quorum report." }),
+    remaining_work: Type2.Array(Type2.String(), { description: "Unresolved findings or quorum evidence when not approved." })
+  },
+  run: async (ctx) => await runAdversarialVerification(withSteeringPropagationContext(ctx))
+});
+
+export { adversarial_verification_default };

package/dist/builtin/workflows/builtin/chunk-qx2ptjs3.js

@@ -0,0 +1,215 @@
+import {
+  APP_NAME,
+  SessionManager,
+  getExportTemplateDir,
+  getResolvedThemeColors,
+  getThemeExportColors,
+  normalizePath,
+  resolvePath
+} from "./chunk-x2ghn0je.js";
+import"./chunk-5wgwscd0.js";
+
+// src/core/export-html/index.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { basename, join as join2 } from "path";
+
+// src/core/export-html/template-script.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var EXPORT_HTML_TEMPLATE_SCRIPT_CHUNKS = [
+  "data-tree.js",
+  "tree-filter-render.js",
+  "message-tools.js",
+  "entries-navigation.js",
+  "initialization.js"
+];
+function readExportHtmlTemplateScript(templateDir) {
+  return EXPORT_HTML_TEMPLATE_SCRIPT_CHUNKS.map((fileName) => readFileSync(join(templateDir, "template-js", fileName), "utf-8")).join("");
+}
+
+// src/core/export-html/index.ts
+function parseColor(color) {
+  const hexMatch = color.match(/^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
+  if (hexMatch) {
+    return {
+      r: Number.parseInt(hexMatch[1], 16),
+      g: Number.parseInt(hexMatch[2], 16),
+      b: Number.parseInt(hexMatch[3], 16)
+    };
+  }
+  const rgbMatch = color.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  if (rgbMatch) {
+    return {
+      r: Number.parseInt(rgbMatch[1], 10),
+      g: Number.parseInt(rgbMatch[2], 10),
+      b: Number.parseInt(rgbMatch[3], 10)
+    };
+  }
+  return;
+}
+function getLuminance(r, g, b) {
+  const toLinear = (c) => {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function adjustBrightness(color, factor) {
+  const parsed = parseColor(color);
+  if (!parsed)
+    return color;
+  const adjust = (c) => Math.min(255, Math.max(0, Math.round(c * factor)));
+  return `rgb(${adjust(parsed.r)}, ${adjust(parsed.g)}, ${adjust(parsed.b)})`;
+}
+function deriveExportColors(baseColor) {
+  const parsed = parseColor(baseColor);
+  if (!parsed) {
+    return {
+      pageBg: "rgb(24, 24, 30)",
+      cardBg: "rgb(30, 30, 36)",
+      infoBg: "rgb(60, 55, 40)"
+    };
+  }
+  const luminance = getLuminance(parsed.r, parsed.g, parsed.b);
+  const isLight = luminance > 0.5;
+  if (isLight) {
+    return {
+      pageBg: adjustBrightness(baseColor, 0.96),
+      cardBg: baseColor,
+      infoBg: `rgb(${Math.min(255, parsed.r + 10)}, ${Math.min(255, parsed.g + 5)}, ${Math.max(0, parsed.b - 20)})`
+    };
+  }
+  return {
+    pageBg: adjustBrightness(baseColor, 0.7),
+    cardBg: adjustBrightness(baseColor, 0.85),
+    infoBg: `rgb(${Math.min(255, parsed.r + 20)}, ${Math.min(255, parsed.g + 15)}, ${parsed.b})`
+  };
+}
+function generateThemeVars(themeName) {
+  const colors = getResolvedThemeColors(themeName);
+  const lines = [];
+  for (const [key, value] of Object.entries(colors)) {
+    lines.push(`--${key}: ${value};`);
+  }
+  const themeExport = getThemeExportColors(themeName);
+  const userMessageBg = colors.userMessageBg || "#343541";
+  const derivedColors = deriveExportColors(userMessageBg);
+  lines.push(`--exportPageBg: ${themeExport.pageBg ?? derivedColors.pageBg};`);
+  lines.push(`--exportCardBg: ${themeExport.cardBg ?? derivedColors.cardBg};`);
+  lines.push(`--exportInfoBg: ${themeExport.infoBg ?? derivedColors.infoBg};`);
+  return lines.join(`
+      `);
+}
+function generateHtml(sessionData, themeName) {
+  const templateDir = getExportTemplateDir();
+  const template = readFileSync2(join2(templateDir, "template.html"), "utf-8");
+  const templateCss = readFileSync2(join2(templateDir, "template.css"), "utf-8");
+  const templateJs = readExportHtmlTemplateScript(templateDir);
+  const markedJs = readFileSync2(join2(templateDir, "vendor", "marked.min.js"), "utf-8");
+  const hljsJs = readFileSync2(join2(templateDir, "vendor", "highlight.min.js"), "utf-8");
+  const themeVars = generateThemeVars(themeName);
+  const colors = getResolvedThemeColors(themeName);
+  const themeExport = getThemeExportColors(themeName);
+  const derivedExportColors = deriveExportColors(colors.userMessageBg || "#343541");
+  const bodyBg = themeExport.pageBg ?? derivedExportColors.pageBg;
+  const containerBg = themeExport.cardBg ?? derivedExportColors.cardBg;
+  const infoBg = themeExport.infoBg ?? derivedExportColors.infoBg;
+  const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64");
+  const css = templateCss.replace("{{THEME_VARS}}", themeVars).replace("{{BODY_BG}}", bodyBg).replace("{{CONTAINER_BG}}", containerBg).replace("{{INFO_BG}}", infoBg);
+  return template.replace("{{CSS}}", css).replace("{{JS}}", templateJs).replace("{{SESSION_DATA}}", sessionDataBase64).replace("{{MARKED_JS}}", markedJs).replace("{{HIGHLIGHT_JS}}", hljsJs);
+}
+var TEMPLATE_RENDERED_TOOLS = new Set(["bash", "read", "write", "edit", "ls"]);
+function preRenderCustomTools(entries, toolRenderer) {
+  const renderedTools = {};
+  for (const entry of entries) {
+    if (entry.type !== "message")
+      continue;
+    const msg = entry.message;
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "toolCall" && !TEMPLATE_RENDERED_TOOLS.has(block.name)) {
+          const callHtml = toolRenderer.renderCall(block.id, block.name, block.arguments);
+          if (callHtml) {
+            renderedTools[block.id] = { callHtml };
+          }
+        }
+      }
+    }
+    if (msg.role === "toolResult" && msg.toolCallId) {
+      const toolName = msg.toolName || "";
+      const existing = renderedTools[msg.toolCallId];
+      if (existing || !TEMPLATE_RENDERED_TOOLS.has(toolName)) {
+        const rendered = toolRenderer.renderResult(msg.toolCallId, toolName, msg.content, msg.details, msg.isError || false);
+        if (rendered) {
+          renderedTools[msg.toolCallId] = {
+            ...existing,
+            resultHtmlCollapsed: rendered.collapsed,
+            resultHtmlExpanded: rendered.expanded
+          };
+        }
+      }
+    }
+  }
+  return renderedTools;
+}
+async function exportSessionToHtml(sm, state, options) {
+  const opts = typeof options === "string" ? { outputPath: options } : options || {};
+  const sessionFile = sm.getSessionFile();
+  if (!sessionFile) {
+    throw new Error("Cannot export in-memory session to HTML");
+  }
+  if (!existsSync(sessionFile)) {
+    throw new Error("Nothing to export yet - start a conversation first");
+  }
+  const entries = sm.getEntries();
+  let renderedTools;
+  if (opts.toolRenderer) {
+    renderedTools = preRenderCustomTools(entries, opts.toolRenderer);
+    if (Object.keys(renderedTools).length === 0) {
+      renderedTools = undefined;
+    }
+  }
+  const sessionData = {
+    header: sm.getHeader(),
+    entries,
+    leafId: sm.getLeafId(),
+    systemPrompt: state?.systemPrompt,
+    tools: state?.tools?.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })),
+    renderedTools
+  };
+  const html = generateHtml(sessionData, opts.themeName);
+  let outputPath = opts.outputPath ? normalizePath(opts.outputPath) : undefined;
+  if (!outputPath) {
+    const sessionBasename = basename(sessionFile, ".jsonl");
+    outputPath = `${APP_NAME}-session-${sessionBasename}.html`;
+  }
+  writeFileSync(outputPath, html, "utf8");
+  return outputPath;
+}
+async function exportFromFile(inputPath, options) {
+  const opts = typeof options === "string" ? { outputPath: options } : options || {};
+  const resolvedInputPath = resolvePath(inputPath);
+  if (!existsSync(resolvedInputPath)) {
+    throw new Error(`File not found: ${resolvedInputPath}`);
+  }
+  const sm = SessionManager.open(resolvedInputPath);
+  const sessionData = {
+    header: sm.getHeader(),
+    entries: sm.getEntries(),
+    leafId: sm.getLeafId(),
+    systemPrompt: undefined,
+    tools: undefined
+  };
+  const html = generateHtml(sessionData, opts.themeName);
+  let outputPath = opts.outputPath ? normalizePath(opts.outputPath) : undefined;
+  if (!outputPath) {
+    const inputBasename = basename(resolvedInputPath, ".jsonl");
+    outputPath = `${APP_NAME}-session-${inputBasename}.html`;
+  }
+  writeFileSync(outputPath, html, "utf8");
+  return outputPath;
+}
+export {
+  exportFromFile,
+  exportSessionToHtml
+};