@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/evidence-ladder.ts

@@ -1,62 +0,0 @@
-/**
- * The evidence ladder (research doc S.1): how far a request's evidence goes,
- * one rung at a time, read only from the request ledger.
- *
- *   ran             a required check has a fresh passing receipt
- *   discriminating  the check fails once the request's changes are undone
- *                   (a guard instead still passes there, and does not count; S.7)
- *   independent     blind checks the model never touched pass
- *   human           the user accepted what only a person can judge
- *
- * Each rung is its own fact; a higher rung does not imply the ones below it.
- * The summary names the highest rung reached and the first gap, so the user
- * sees what the evidence shows and what it does not, without a percentage.
- */
-import type { RequestState } from "./request-state.ts";
-
-export type Rung = "met" | "missing" | "failed" | "not_run" | "not_applicable";
-export type EvidenceLadder = { ran: Rung; discriminating: Rung; independent: Rung; human: Rung; summary: string };
-export const RUNGS = ["ran", "discriminating", "independent", "human"] as const;
-
-const LABEL: Record<(typeof RUNGS)[number], string> = {
-  ran: "ran", discriminating: "tests the change", independent: "independent", human: "human accepted",
-};
-
-/** Null when the request had nothing to check: a conversation turn shows no ladder. */
-export function evidenceLadder(state: RequestState): EvidenceLadder | null {
-  if (state.status === "not_applicable") return null;
-  const evidence = state.evidence;
-  const ran: Rung = evidence.ran === "pass" ? "met" : evidence.ran === "fail" ? "failed" : evidence.ran === "not_applicable" ? "not_applicable" : "missing";
-  const discriminating: Rung = evidence.discriminating === "pass" ? "met" : evidence.discriminating === "vacuous" ? "failed"
-    : evidence.discriminating === "missing" ? "missing" : evidence.discriminating === "not_applicable" ? "not_applicable" : "not_run";
-  const independent: Rung = evidence.independent === "pass" ? "met" : evidence.independent === "fail" || evidence.independent === "exposed" ? "failed"
-    : evidence.independent === "not_applicable" ? "not_applicable" : "not_run";
-  const human: Rung = evidence.human === "accepted" ? "met" : evidence.human === "pending" ? "missing" : "not_applicable";
-  const rungs = { ran, discriminating, independent, human };
-  const reached = RUNGS.filter(rung => rungs[rung] === "met").at(-1);
-  const gap = RUNGS.find(rung => rungs[rung] === "failed" || rungs[rung] === "missing");
-  const why = !gap ? undefined
-    : gap === "ran" ? (ran === "failed" ? "the latest check failed" : state.acceptance ? "declared checks have not passed" : "changes not checked")
-    : gap === "discriminating" ? (discriminating === "missing" ? "no check tests the change; every check is a guard" : vacuousGap(state))
-    : gap === "independent" ? (evidence.independent === "exposed" ? "the model touched the blind checks" : "a blind check failed")
-    : "waiting for your /accept";
-  const summary = [reached ? `reached: ${LABEL[reached]}` : "nothing verified yet", ...(why ? [why] : [])].join(" · ");
-  return { ...rungs, summary };
-}
-
-/**
- * Which checks pass without the request's changes, by id. Only line mode
- * prints each check's counter-check; the sidebar shows just this summary, and
- * a guard the user asked for ("nothing else changed") reads differently from
- * a check that was meant to test the work (fix-ladder-names-vacuous-check).
- */
-function vacuousGap(state: RequestState): string {
-  const ids = state.criteria.filter(item => item.counter === "vacuous").map(item => item.id);
-  const named = ids.length <= 2 ? ids.join(", ") : `${ids.slice(0, 2).join(", ")} +${ids.length - 2}`;
-  return `${named} ${ids.length === 1 ? "passes" : "pass"} without the changes`;
-}
-
-/** One glyph per rung for narrow status chrome: ✓ met, ✗ failed, ○ missing or not run, · not applicable. */
-export function ladderGlyph(rung: Rung): string {
-  return rung === "met" ? "✓" : rung === "failed" ? "✗" : rung === "not_applicable" ? "·" : "○";
-}

package/src/core/evidence-links.ts

@@ -1,68 +0,0 @@
-/** O.6: explicit evidence relationships are projections, never verification claims. */
-import type { LogEvent, ToolResultEvent } from "./events.ts";
-
-export type EvidenceLink = {
-  id: string; work: string; what: string; event: string;
-  resource?: string; version?: string;
-  freshness: "current" | "stale" | "unknown";
-  superseded_by?: string;
-};
-
-/** Normalize path spelling only; never infer basename, symlink or repository aliases. */
-export function resourceKey(path: string): string {
-  const parts: string[] = [];
-  for (const part of path.split("/")) {
-    if (!part || part === ".") continue;
-    if (part === ".." && parts.length > 0 && parts.at(-1) !== "..") parts.pop(); else parts.push(part);
-  }
-  return (path.startsWith("/") ? "/" : "") + parts.join("/");
-}
-
-export function observationResources(event: ToolResultEvent, input: unknown): string[] {
-  if (event.effect && "path" in event.effect) return [resourceKey(event.effect.path)];
-  if (!event.ok || input === null || typeof input !== "object") return [];
-  const args = input as Record<string, unknown>;
-  const paths = typeof args["path"] === "string" ? [args["path"]] : Array.isArray(args["paths"]) ? args["paths"] : [];
-  return [...new Set(paths.filter((path): path is string => typeof path === "string").map(resourceKey))];
-}
-
-export function observedVersion(events: readonly LogEvent[], resource: string): string | null | undefined {
-  let version: string | null | undefined;
-  for (const event of events) {
-    if (event.t === "tool_result" && event.effect && "path" in event.effect && resourceKey(event.effect.path) === resource) {
-      version = event.effect.kind === "read" ? event.effect.sha256 : event.effect.sha256_after;
-    }
-    if (event.t === "checkpoint" && event.phase === "applied") for (const [path, change] of Object.entries(event.changes)) {
-      if (resourceKey(path) === resource) version = change.after?.sha256 ?? null;
-    }
-  }
-  return version;
-}
-
-export function deriveEvidenceLinks(previous: readonly EvidenceLink[], events: readonly LogEvent[]): EvidenceLink[] {
-  const links = previous.map(link => ({ ...link }));
-  for (const event of events) {
-    if (event.t === "evidence_link") {
-      if (event.supersedes) for (const link of links) {
-        if (link.work === event.work && link.event === event.supersedes && link.superseded_by === undefined) link.superseded_by = event.id;
-      }
-      if (!links.some(link => link.id === event.id)) links.push({ id: event.id, work: event.work, what: event.what, event: event.source,
-        ...(event.resource !== undefined ? { resource: resourceKey(event.resource) } : {}),
-        ...(event.version !== undefined ? { version: event.version } : {}),
-        freshness: event.version === undefined || event.observed_version === undefined ? "unknown"
-          : event.version === event.observed_version ? "current" : "stale" });
-    }
-    for (const link of links) {
-      if (!link.resource || !link.version) continue;
-      if (event.t === "tool_result" && event.effect && "path" in event.effect && resourceKey(event.effect.path) === link.resource) {
-        const version = event.effect.kind === "read" ? event.effect.sha256 : event.effect.sha256_after;
-        link.freshness = version === link.version ? "current" : "stale";
-      }
-      if (event.t === "checkpoint" && event.phase === "applied") for (const [path, change] of Object.entries(event.changes)) {
-        if (resourceKey(path) === link.resource) link.freshness = change.after?.sha256 === link.version ? "current" : "stale";
-      }
-      if (event.t === "workspace_observation" && event.changed || event.t === "checkpoint" && event.phase === "unavailable") link.freshness = "unknown";
-    }
-  }
-  return links;
-}

package/src/core/evidence.ts

@@ -1,240 +0,0 @@
-/** Shared executed-evidence rules for handoff derivation and the turn watchdog. */
-import type { EvidenceQuery, LogEvent, ToolResultEvent } from "./events.ts";
-import type { Evidence } from "./handoff.ts";
-import { changedPaths } from "./checkpoints.ts";
-
-type CommandEffect = Extract<NonNullable<ToolResultEvent["effect"]>, { kind: "command" }>;
-export type CommandResult = ToolResultEvent & { effect: CommandEffect };
-export function isCommandResult(event: LogEvent): event is CommandResult {
-  return event.t === "tool_result" && event.effect?.kind === "command";
-}
-export function matchesQuery(query: EvidenceQuery, effect: CommandEffect): boolean {
-  return "gate" in query ? effect.gate === query.gate : effect.cmd === query.command;
-}
-export function evidenceStale(events: readonly LogEvent[], evidence: Evidence, initially = false): boolean {
-  const start = events.findIndex((event) => event.id === evidence.event_id);
-  let stale = initially;
-  for (const event of events.slice(start + 1)) {
-    if (event.t === "tool_result" && event.effect?.kind === "edit") stale = true;
-    if (event.t === "checkpoint" && (event.phase === "unavailable" || event.phase === "applied" && changedPaths(event.changes).length > 0)) stale = true;
-    if (event.t === "workspace_observation" && event.fingerprint === undefined ||
-        event.t === "tool_result" && event.effect?.kind === "command" && event.effect.workspace_observed === false || event.t === "user_bash") stale = true;
-    const sha = event.t === "workspace_observation" ? event.fingerprint
-      : event.t === "tool_result" && event.effect?.kind === "command" ? event.effect.workspace_sha256 : undefined;
-    const scope = event.t === "workspace_observation" ? event.scope : event.t === "tool_result" && event.effect?.kind === "command" ? event.effect.workspace_scope : undefined;
-    if (sha !== undefined && evidence.workspace_sha256 !== undefined) stale = evidence.workspace_scope === "source-v1"
-      ? stale || scope !== evidence.workspace_scope || sha !== evidence.workspace_sha256 : scope !== undefined || sha !== evidence.workspace_sha256;
-  }
-  return stale;
-}
-
-export type EvidenceResolution = { ok: true; evidence: Evidence } | {
-  ok: false; reason: "no_matching_event" | "nonzero_exit" | "stale_workspace"; exit?: number;
-};
-
-/** D11/O.2: callers supply only the current segment's prefix before the claim. */
-export function resolveEvidence(events: readonly LogEvent[], query: EvidenceQuery, afterEvent?: string): EvidenceResolution {
-  const start = afterEvent === undefined ? 0 : events.findIndex(event => event.id === afterEvent) + 1;
-  const result = events.slice(start).findLast(event => isCommandResult(event) && matchesQuery(query, event.effect));
-  if (!result || !isCommandResult(result)) return { ok: false, reason: "no_matching_event" };
-  if (result.effect.exit !== 0) return { ok: false, reason: "nonzero_exit", exit: result.effect.exit };
-  if (result.effect.workspace_observed === false) return { ok: false, reason: "stale_workspace" };
-  const evidence: Evidence = { command: result.effect.cmd, exit: result.effect.exit, at: result.at, event_id: result.id,
-    ...(result.effect.workspace_scope ? { workspace_scope: result.effect.workspace_scope } : {}),
-    ...(result.effect.gate !== undefined ? { gate: result.effect.gate } : {}),
-    ...(result.effect.workspace_sha256 ? { workspace_sha256: result.effect.workspace_sha256 } : {}) };
-  return evidenceStale(events, evidence) ? { ok: false, reason: "stale_workspace" } : { ok: true, evidence };
-}
-
-export function eligibleProgressChecks(events: readonly LogEvent[], claimed: ReadonlySet<string>, failingGates: { has(gate: string): boolean }): Set<string> {
-  const eligible = new Set<string>();
-  for (const event of events) {
-    if (!isCommandResult(event)) continue;
-    const gate = event.effect.gate;
-    if (event.effect.exit !== 0 || event.effect.workspace_observed === false || (gate === undefined && !claimed.has(event.id)) || (gate !== undefined && failingGates.has(gate))) continue;
-    if (!evidenceStale(events, { command: event.effect.cmd, exit: 0, at: event.at, event_id: event.id,
-      ...(event.effect.workspace_scope ? { workspace_scope: event.effect.workspace_scope } : {}),
-      ...(event.effect.workspace_sha256 === undefined ? {} : { workspace_sha256: event.effect.workspace_sha256 }) })) eligible.add(event.id);
-  }
-  return eligible;
-}
-
-/** An exchange can verify a gate or claim only an already executed command. */
-export function exchangeProgressChecks(events: readonly LogEvent[]): Set<string> {
-  const commands: CommandResult[] = [], claimed = new Set<string>(), gates = new Map<string, number>();
-  for (const event of events) {
-    if (isCommandResult(event)) {
-      commands.push(event);
-      if (event.effect.gate !== undefined) gates.set(event.effect.gate, event.effect.exit);
-    } else if (event.t === "claim") {
-      const command = commands.findLast((result) => matchesQuery(event.evidence, result.effect));
-      if (command?.effect.exit === 0) claimed.add(command.id);
-    }
-  }
-  return eligibleProgressChecks(events, claimed, new Set([...gates].filter(([, exit]) => exit !== 0).map(([gate]) => gate)));
-}
-
-/**
- * D11: classify an actual verifier invocation, never a runner word in data.
- *
- * Only command shapes whose exit 0 proves every gate in them exited 0 are
- * read: simple commands joined by `&&` (the chain stops at the first failure),
- * each optionally ending in output redirects to fixed paths (a redirect that
- * cannot open fails the command, it never masks one). Anything that can turn
- * a failure into exit 0 or run text the log does not show -- `;`, `||`,
- * pipes, background jobs, subshells, expansions, input redirects -- rejects
- * the whole command, as before. A chain's gates join with `+` in order, so a
- * failed chain is recorded as that chain failing, not as one of its parts.
- */
-export function classifyGate(gates: Readonly<Record<string, string>>, command: string): string | undefined {
-  const segments = gateSegments(command);
-  if (!segments) return undefined;
-  const names = [...new Set(segments.flatMap((words) => segmentGates(gates, words)))];
-  return names.length === 0 ? undefined : names.join("+");
-}
-
-type ShellToken = { kind: "word"; value: string } | { kind: "and" } | { kind: "redirect"; target: boolean };
-
-/**
- * A deliberately small tokenizer, not a shell parser (M.2): it accepts the
- * subset above and returns undefined for everything else, so an unfamiliar
- * construct can only lose a gate, never forge one. Quotes may hold plain text
- * only; `$`, backticks and backslashes are rejected even inside them.
- */
-function shellTokens(command: string): ShellToken[] | undefined {
-  const tokens: ShellToken[] = [];
-  let word: string | undefined, i = 0;
-  const end = () => { if (word !== undefined) tokens.push({ kind: "word", value: word }); word = undefined; };
-  while (i < command.length) {
-    const c = command[i]!;
-    if (c === " " || c === "\t") { end(); i++; continue; }
-    if (c === "#" && word === undefined) break; // a comment runs to the end of the (single) line
-    if (c === "'" || c === '"') {
-      const close = command.indexOf(c, i + 1);
-      if (close < 0) return undefined;
-      const quoted = command.slice(i + 1, close);
-      if (/[$`\\\n\r]/.test(quoted)) return undefined;
-      word = (word ?? "") + quoted; i = close + 1; continue;
-    }
-    if (c === "&" && command[i + 1] === "&") { end(); tokens.push({ kind: "and" }); i += 2; continue; }
-    if (c === ">" || c === "&" && command[i + 1] === ">") {
-      // An unquoted 1 or 2 directly before `>` is the descriptor, not a word.
-      if (c === ">" && (word === "1" || word === "2") && /[12]$/.test(command.slice(0, i))) word = undefined;
-      end();
-      i += c === "&" ? 2 : 1;
-      if (command[i] === ">") i++;
-      if (c === ">" && command[i] === "&") {
-        if (!/^[12](?![^\s&])/.test(command.slice(i + 1))) return undefined;
-        tokens.push({ kind: "redirect", target: false }); i += 2; continue;
-      }
-      if (command[i] === "|") return undefined;
-      tokens.push({ kind: "redirect", target: true }); continue;
-    }
-    if (/[\n\r;&|<`$(){}\\]/.test(c)) return undefined;
-    word = (word ?? "") + c; i++;
-  }
-  end();
-  return tokens;
-}
-
-/** The `&&`-joined segments' words with trailing output redirects removed. */
-function gateSegments(command: string): string[][] | undefined {
-  const tokens = shellTokens(command);
-  if (!tokens) return undefined;
-  const segments: string[][] = [[]];
-  let redirected = false, needTarget = false;
-  for (const token of tokens) {
-    const words = segments.at(-1)!;
-    if (token.kind === "and") {
-      if (needTarget || words.length === 0) return undefined;
-      segments.push([]); redirected = false; continue;
-    }
-    if (token.kind === "redirect") {
-      if (needTarget || words.length === 0) return undefined;
-      redirected = true; needTarget = token.target; continue;
-    }
-    if (needTarget) { needTarget = false; continue; }
-    // Only trailing redirects are stripped; one before an argument is rejected.
-    if (redirected) return undefined;
-    words.push(token.value);
-  }
-  return needTarget || segments.at(-1)!.length === 0 ? undefined : segments;
-}
-
-const INFORMATIONAL = ["--version", "-V", "--help", "-h", "--collect-only", "--listTests", "--showConfig", "--init", "--fixtures", "--markers"];
-
-/** One simple command's gates: none, the runner's gate, or a target runner's gate targets. */
-function segmentGates(gates: Readonly<Record<string, string>>, tokens: readonly string[]): string[] {
-  if (tokens.some((t) => INFORMATIONAL.includes(t))) return [];
-  const first = tokens[0] ?? "";
-  const runner = own(TARGET_RUNNERS, first);
-  if (runner && !Object.hasOwn(gates, first)) return targetGates(gates, runner, tokens.slice(1));
-  const single = runnerGate(gates, tokens);
-  return single === undefined ? [] : [single];
-}
-
-function runnerGate(gates: Readonly<Record<string, string>>, tokens: readonly string[]): string | undefined {
-  let i = 0;
-  const first = tokens[0];
-  if (["bun", "npm", "pnpm", "yarn"].includes(first ?? "") && tokens[1] === "test") return own(gates, "test");
-  if (first === "python" || first === "python3") {
-    if (tokens[1] !== "-m") return undefined;
-    i = 2;
-  } else if (["npx", "bunx", "uvx"].includes(first ?? "")) i = 1;
-  else if (["uv", "poetry", "pdm", "pipenv"].includes(first ?? "")) {
-    if (tokens[1] !== "run") return undefined;
-    i = 2;
-  } else if (["bun", "npm", "pnpm", "yarn"].includes(first ?? "") && tokens[1] === "run") i = 2;
-  const executable = tokens[i];
-  if (executable === "cargo" && !["test", "check", "clippy", "build"].includes(tokens[i + 1] ?? "")) return undefined;
-  if (executable === "vitest" && ["list", "init"].includes(tokens[i + 1] ?? "")) return undefined;
-  return own(gates, executable ?? "");
-}
-
-/** A table lookup that a word like `constructor` cannot satisfy through the prototype. */
-function own<T>(table: Readonly<Record<string, T>>, key: string): T | undefined {
-  return Object.hasOwn(table, key) ? table[key] : undefined;
-}
-
-/**
- * Options a target runner may carry and still prove its targets ran. An
- * allowlist on purpose: an unknown option might be a dry run, a touch or an
- * ignore-errors switch (exit 0 without the targets passing), so it makes the
- * segment not a gate rather than being guessed at.
- */
-type TargetRunner = { withValue: readonly string[]; flags: readonly string[]; attached: RegExp; argsAfterDashes: boolean };
-const TARGET_RUNNERS: Readonly<Record<string, TargetRunner>> = {
-  make: { withValue: ["-C", "-f", "--directory", "--file", "--makefile"],
-    flags: ["-k", "-s", "-B", "-w", "-r", "-R", "--keep-going", "--silent", "--quiet", "--always-make", "--print-directory", "--no-print-directory"],
-    attached: /^(?:-C.+|-f.+|-j\d*|--(?:directory|file|makefile|jobs)=.+|--jobs)$/, argsAfterDashes: false },
-  just: { withValue: ["-f", "-d", "--justfile", "--working-directory"], flags: ["-q", "-v", "--quiet", "--verbose"],
-    attached: /^--(?:justfile|working-directory)=.+$/, argsAfterDashes: false },
-  task: { withValue: ["-d", "-t", "--dir", "--taskfile"], flags: ["-s", "-v", "-p", "-f", "--silent", "--verbose", "--parallel", "--force"],
-    attached: /^--(?:dir|taskfile)=.+$/, argsAfterDashes: true },
-};
-
-/**
- * `make build size test`: the runner exits 0 only when every target
- * succeeded, so each target named after a configured gate key (exactly, or
- * as `<key>-…` / `<key>:…`) is that gate; other targets do not weaken it. No
- * gate target, or no target at all (the default goal is unknown), is no gate.
- */
-function targetGates(gates: Readonly<Record<string, string>>, runner: TargetRunner, args: readonly string[]): string[] {
-  const keys = Object.keys(gates).sort((a, b) => b.length - a.length);
-  const names: string[] = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]!;
-    if (arg === "--") { if (runner.argsAfterDashes) break; return []; }
-    if (arg.startsWith("-")) {
-      if (runner.withValue.includes(arg)) { if (++i >= args.length) return []; continue; }
-      if (arg === "-j" && /^\d+$/.test(args[i + 1] ?? "")) { i++; continue; }
-      if (runner.flags.includes(arg) || runner.attached.test(arg)) continue;
-      return [];
-    }
-    if (arg.includes("=")) continue; // a variable override, not a target
-    if (/[*?[\]~]/.test(arg)) return [];
-    const key = keys.find((k) => arg === k || arg.startsWith(`${k}-`) || arg.startsWith(`${k}:`));
-    if (key !== undefined) names.push(gates[key]!);
-  }
-  return names;
-}

package/src/core/execution.ts

@@ -1,18 +0,0 @@
-/** D5/D11: incomplete execution is unknown, never an instruction to run twice. */
-import type { LogEvent, AssistantBlock } from "./events.ts";
-
-export type PendingToolCall = Extract<AssistantBlock, { type: "tool_use" }> & { parent_call_id?: string; invocation_id?: string; origin?: "extension" };
-export function pendingToolCalls(events: readonly LogEvent[]): PendingToolCall[] {
-  const pending = new Map<string, PendingToolCall>();
-  for (const event of events) {
-    if (event.t === "assistant") {
-      for (const block of event.blocks) if (block.type === "tool_use") pending.set(block.call_id, block);
-    } else if (event.t === "tool_invocation") {
-      const existing = pending.get(event.call_id);
-      pending.set(event.call_id, { type: "tool_use", call_id: event.call_id, name: event.name, input: event.input ?? existing?.input ?? null,
-        invocation_id: event.id, ...(event.origin ? { origin: event.origin } : {}),
-        ...(event.parent_call_id ? { parent_call_id: event.parent_call_id } : {}) });
-    } else if (event.t === "tool_result") pending.delete(event.call_id);
-  }
-  return [...pending.values()];
-}

package/src/core/exhaustive.ts

@@ -1,18 +0,0 @@
-/**
- * Exhaustiveness for discriminated unions.
- *
- * `LogEvent` has ten variants and `Effect` three; the projection's claim to be
- * a total function rests on every switch over them covering every case. In the
- * default branch of such a switch the value narrows to `never`, so passing it
- * here compiles only while the switch is complete -- adding a variant turns
- * every incomplete switch into a type error rather than a silent fallthrough.
- *
- * This is the one exhaustiveness guarantee tsc will not give on its own: a
- * switch that misses a case is legal TypeScript, it just falls through.
- */
-export function assertNever(value: never, context: string): never {
-  throw new Error(
-    `${context}: unhandled variant ${JSON.stringify(value)} -- ` +
-      "a union gained a member without every switch over it being updated",
-  );
-}

package/src/core/export.ts

@@ -1,179 +0,0 @@
-/**
- * Transcript serialisation. Pure: no I/O, no clock.
- *
- * The HTML has to be a single file a person can open offline. A stylesheet
- * or font loaded from a CDN is blank in the one situation export is for, so
- * nothing here emits a URL. Timestamps are passed in so this module cannot
- * invent "now".
- *
- * User text is escaped as HTML text. A transcript that contains
- * `<script>alert(1)</script>` must stay text; emitting it as a tag is XSS
- * from the log (card: feat-session-flags-and-export).
- */
-
-import type { AssistantBlock, LogEvent } from "./events.ts";
-import { counterVerdict } from "./acceptance.ts";
-import { assertNever } from "./exhaustive.ts";
-import { imageDescription } from "./images.ts";
-
-export interface HtmlMeta {
-  title: string;
-  /** ISO timestamp supplied by the caller. Never read from the clock here. */
-  exportedAt: string;
-  sessionId?: string;
-}
-
-export function toJsonl(events: readonly LogEvent[]): string {
-  if (events.length === 0) return "";
-  return events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-}
-
-export function toHtml(events: readonly LogEvent[], meta: HtmlMeta): string {
-  const title = escapeHtml(meta.title);
-  const when = escapeHtml(meta.exportedAt);
-  const id = meta.sessionId !== undefined ? escapeHtml(meta.sessionId) : "";
-  const body = events.map(eventHtml).join("\n");
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${title}</title>
-<style>
-body{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;max-width:72rem;margin:1.5rem auto;padding:0 1rem;color:#111;background:#fff;line-height:1.45}
-header{border-bottom:1px solid #ddd;padding-bottom:0.75rem;margin-bottom:1rem}
-header p{color:#555;margin:0.25rem 0 0}
-.event{margin:0.85rem 0;padding:0.55rem 0.8rem;border-left:3px solid #ccc;background:#fafafa}
-.user{border-color:#1565c0}
-.assistant{border-color:#2e7d32}
-.tool{border-color:#ef6c00}
-.meta{color:#666;font-size:0.8rem;margin-bottom:0.35rem}
-pre{white-space:pre-wrap;word-break:break-word;margin:0;font:inherit}
-</style>
-</head>
-<body>
-<header>
-<h1>${title}</h1>
-<p>exported ${when}${id.length > 0 ? ` · ${id}` : ""}</p>
-</header>
-<main>
-${body}
-</main>
-</body>
-</html>
-`;
-}
-
-/**
- * Most recent assistant text block. `/copy` is this string, not a
- * reconstruction of thinking or tool JSON.
- */
-export function lastAssistantText(events: readonly LogEvent[]): string | null {
-  for (let i = events.length - 1; i >= 0; i--) {
-    const e = events[i]!;
-    if (e.t !== "assistant") continue;
-    const parts: string[] = [];
-    for (const b of e.blocks) {
-      if (b.type === "text") parts.push(b.text);
-    }
-    if (parts.length > 0) return parts.join("");
-  }
-  return null;
-}
-
-function escapeHtml(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&#39;");
-}
-
-function eventHtml(e: LogEvent): string {
-  switch (e.t) {
-    case "tool_invocation": return wrap("event", "tool invocation", e.at, `${e.name} · ${e.call_id}${e.parent_call_id ? ` · parent ${e.parent_call_id}` : ""} · input ${e.input_ref.sha256} · schema ${e.schema_ref?.sha256 ?? "unavailable"}`);
-    case "checkpoint": return wrap("event", `file checkpoint ${e.phase}`, e.at, e.reason ?? Object.keys(e.changes).join("\n"));
-    case "workspace_observation": return wrap("event", "verification observation", e.at, e.fingerprint ?? e.reason ?? "unavailable");
-    case "extension": return e.display ? wrap("event", e.customType, e.at, e.content || JSON.stringify(e.data)) : "";
-    case "user":
-      return wrap("user", "user", e.at, [e.text, ...(e.images ?? []).map(imageDescription)].join("\n"));
-    case "user_bash": return wrap("tool", e.excludeFromContext ? "user bash (excluded)" : "user bash", e.at, `$ ${e.command}\n${e.content}`);
-    case "outcome": return wrap("event", e.outcome.status, e.at, `${e.outcome.reason}: ${e.reason}`);
-    case "guidance":
-      return wrap("event", `harness ${e.reason}`, e.at, e.text);
-    case "assistant":
-      return wrap("assistant", "assistant", e.at, assistantText(e.blocks));
-    case "interrupt":
-      return wrap("event", "interrupt", e.at, `cancelled ${e.user_id}`);
-    case "tool_result":
-      return wrap("tool", `tool_result ${e.ok ? "ok" : "fail"}`, e.at, [e.content, ...(e.images ?? []).map(imageDescription)].join("\n"));
-    case "cut":
-      return wrap("event", "cut", e.at, `${e.reason} → ${e.handoff_ref}`);
-    case "rewind":
-      return wrap("event", `rewind ${e.mode}`, e.at, e.prompt);
-    case "spawn":
-      return wrap("event", "spawn", e.at, e.purpose);
-    case "joined":
-      return wrap("event", "joined", e.at, e.summary);
-    case "adopt":
-      return wrap("event", "adopt", e.at, `branch ${e.branch.node}`);
-    case "discard":
-      return wrap("event", "discard", e.at, e.reason);
-    case "claim":
-      return wrap("event", "claim", e.at, e.what);
-    case "decision":
-      return wrap("event", "decision", e.at, `${e.chose} — ${e.because}`);
-    case "pitfall":
-      return wrap("event", "pitfall", e.at, `${e.tried} — ${e.failed_because}`);
-    case "blocked":
-      return wrap("event", "blocked", e.at, `${e.what} — ${e.reason}`);
-    case "question":
-      return wrap("event", "question", e.at, e.text);
-    case "next_action":
-      return wrap("event", "next_action", e.at, `${e.what} → ${e.next_action}`);
-    case "work_status":
-      return wrap("event", `work ${e.operation}`, e.at, `${e.work_id}: ${e.what}`);
-    case "evidence_link":
-      return wrap("event", "evidence link", e.at, `${e.work}: ${e.what} → ${e.source}`);
-    case "work_owner": case "work_dependencies": return wrap("event", e.t, e.at, JSON.stringify(e));
-    case "approval": return wrap("event", "approval", e.at,
-      [`${e.tool} · ${e.call_id} · ${e.decision} · ${e.source}`, ...(e.rule ? [`rule: ${e.rule}`] : []), ...(e.command !== undefined ? [`$ ${e.command}`] : [])].join("\n"));
-    case "skill_loaded": return wrap("event", "skill loaded", e.at, `${e.name} · ${e.path} · ${e.sha256} · ${e.mode}`);
-    case "process_exit": return wrap("event", "process exit", e.at, `${e.session} · exit ${e.exit} · output ${e.output.sha256}`);
-    case "acceptance_contract": return wrap("event", "acceptance contract", e.at, JSON.stringify(e.contract));
-    case "target_observation": return wrap("event", "runtime target", e.at, JSON.stringify(e.observation));
-    case "acceptance_decision": return wrap("event", "human acceptance", e.at, `${e.contract_id}: ${e.criterion}`);
-    case "counter_check": return wrap("event", "counter-check", e.at,
-      `${e.criterion}${e.guard ? " (guard)" : ""} · ${counterVerdict(e)}${"reason" in e ? ` · ${e.reason}` : ` · exit ${e.exit}`}`);
-    case "blind_check": return wrap("event", "blind check", e.at, `${e.check} · ${"reason" in e ? e.reason : `exit ${e.exit}`}${e.exposed ? ` · exposed: ${e.exposure ?? "yes"}` : ""}`);
-    case "goal": return wrap("event", e.action === "set" ? "goal set" : "goal cleared", e.at,
-      e.action === "set" ? `${e.objective}\naccepted: ${e.accepted.join(", ")}${e.rejected.length ? `\nrejected: ${e.rejected.join(", ")}` : ""}` : e.reason);
-    default:
-      return assertNever(e, "eventHtml");
-  }
-}
-
-function assistantText(blocks: readonly AssistantBlock[]): string {
-  const parts: string[] = [];
-  for (const b of blocks) {
-    switch (b.type) {
-      case "text":
-        parts.push(b.text);
-        break;
-      case "thinking":
-        parts.push(b.text);
-        break;
-      case "tool_use":
-        parts.push(`${b.name} ${JSON.stringify(b.input)}`);
-        break;
-      default:
-        return assertNever(b, "assistantText");
-    }
-  }
-  return parts.join("\n");
-}
-
-function wrap(cls: string, kind: string, at: string, text: string): string {
-  return `<article class="event ${cls}"><div class="meta">${escapeHtml(kind)} · ${escapeHtml(at)}</div><pre>${escapeHtml(text)}</pre></article>`;
-}

package/src/core/extension-flags.ts

@@ -1,14 +0,0 @@
-/** Typed extension flags are data; factories and the final CLI pass share their interpretation. */
-export interface ExtensionFlag { type: "string" | "boolean"; description?: string; default?: string | boolean }
-export interface FlagInput { value?: string; inline: boolean }
-export function extensionFlagValue(name: string, definition: ExtensionFlag, input?: FlagInput): string | boolean | undefined {
-  if (!input) return definition.default;
-  if (definition.type === "string") {
-    if (input.value === undefined) throw new Error(`--${name} requires a string value`);
-    return input.value;
-  }
-  if (input.value === "true") return true;
-  if (input.value === "false") return false;
-  if (input.inline) throw new Error(`--${name} requires true or false`);
-  return true;
-}