@smthrs/harness 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/ExternalTranscript.js

@@ -0,0 +1,826 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ExternalTranscript_exports = {};
+__export(ExternalTranscript_exports, {
+  AgentKind: () => AgentKind,
+  EditedFile: () => EditedFile,
+  Entry: () => Entry,
+  ExternalTranscriptError: () => ExternalTranscriptError,
+  ExternalTranscriptErrorCode: () => ExternalTranscriptErrorCode,
+  Part: () => Part,
+  claudeReleases: () => claudeReleases,
+  claudeStart: () => claudeStart,
+  codexReleases: () => codexReleases,
+  codexStart: () => codexStart,
+  decodeClaude: () => decodeClaude,
+  decodeCodex: () => decodeCodex
+});
+module.exports = __toCommonJS(ExternalTranscript_exports);
+var Fault = __toESM(require("@smthrs/flow/Fault"), 1);
+var import_effect = require("effect");
+const AgentKind = import_effect.Schema.Literals(["codex", "claude-code"]);
+const EditedFile = import_effect.Schema.Struct({
+  path: import_effect.Schema.String,
+  change: import_effect.Schema.Literals(["added", "modified", "deleted", "renamed"]),
+  renamed_to: import_effect.Schema.optional(import_effect.Schema.String),
+  diff: import_effect.Schema.String
+});
+const Part = import_effect.Schema.Union([
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("prompt"), text: import_effect.Schema.String }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("goal"), objective: import_effect.Schema.String, status: import_effect.Schema.String }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("text"), text: import_effect.Schema.String, final: import_effect.Schema.Boolean }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("reasoning"), text: import_effect.Schema.String }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("encrypted") }),
+  import_effect.Schema.Struct({
+    type: import_effect.Schema.Literal("tool"),
+    call_id: import_effect.Schema.String,
+    command: import_effect.Schema.String,
+    /** Set when every part of the command only reads, searches or lists: "Read mvp.md". */
+    reads: import_effect.Schema.Array(import_effect.Schema.String),
+    status: import_effect.Schema.Literals(["ok", "error", "running"]),
+    exit_code: import_effect.Schema.optional(import_effect.Schema.Number),
+    output: import_effect.Schema.String,
+    duration_ms: import_effect.Schema.Number
+  }),
+  import_effect.Schema.Struct({
+    type: import_effect.Schema.Literal("edit"),
+    call_id: import_effect.Schema.String,
+    files: import_effect.Schema.Array(EditedFile),
+    outcome: import_effect.Schema.Literals(["applied", "failed"])
+  }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("search"), call_id: import_effect.Schema.String, query: import_effect.Schema.String }),
+  import_effect.Schema.Struct({
+    type: import_effect.Schema.Literal("helper"),
+    call_id: import_effect.Schema.String,
+    agent: import_effect.Schema.String,
+    activity: import_effect.Schema.String
+  }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("compaction") }),
+  import_effect.Schema.Struct({ type: import_effect.Schema.Literal("error"), message: import_effect.Schema.String })
+]);
+const Entry = import_effect.Schema.Struct({
+  origin: import_effect.Schema.Literal("external"),
+  agent_kind: AgentKind,
+  format_version: import_effect.Schema.String,
+  session_id: import_effect.Schema.String,
+  /**
+   * The record this entry came from: `<session>:<line>`. A record that yields several entries numbers the later
+   * ones `<session>:<line>#<n>`.
+   */
+  source_id: import_effect.Schema.String,
+  read_only: import_effect.Schema.Literal(true),
+  seq: import_effect.Schema.Number,
+  /** Milliseconds since the epoch, from the record. */
+  at: import_effect.Schema.Number,
+  turn_id: import_effect.Schema.optional(import_effect.Schema.String),
+  /** `user` entries are the owner's; `assistant` entries are the agent's. */
+  role: import_effect.Schema.Literals(["user", "assistant"]),
+  part: Part
+});
+const ExternalTranscriptErrorCode = import_effect.Schema.Literals([
+  "missing_version",
+  "unsupported_version",
+  "unsupported_record",
+  "malformed_record"
+]);
+class ExternalTranscriptError extends import_effect.Schema.TaggedError()("harness/ExternalTranscriptError", {
+  code: ExternalTranscriptErrorCode,
+  message: import_effect.Schema.String,
+  line: import_effect.Schema.Number
+}) {
+}
+Fault.register(
+  "harness/ExternalTranscriptError",
+  {
+    // The agent wrote a transcript this release cannot read: a format change outside Smithers.
+    missing_version: "dependency",
+    unsupported_version: "dependency",
+    unsupported_record: "dependency",
+    malformed_record: "dependency"
+  }
+);
+const codexReleases = ["0.159", "0.160"];
+const codexStart = { pending: "", line: 0, seq: 0 };
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+const text = (value) => typeof value === "string" ? value : "";
+const list = (value) => Array.isArray(value) ? value : [];
+const basename = (path) => path.split("/").filter(Boolean).at(-1) ?? path;
+const parseRow = (raw) => {
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const helperName = (path) => basename(text(path)) || "helper";
+const reads = (parsed) => {
+  const parts = list(parsed).map(record);
+  if (parts.length === 0 || parts.some((part) => !["read", "search", "list_files"].includes(text(part["type"])))) {
+    return [];
+  }
+  return parts.map(
+    (part) => part["type"] === "read" ? `Read ${text(part["name"]) || basename(text(part["path"]))}` : part["type"] === "search" ? `Searched ${JSON.stringify(text(part["query"]))}${part["path"] ? ` in ${basename(text(part["path"]))}` : ""}` : `Listed ${basename(text(part["path"])) || "files"}`
+  );
+};
+const linesOf = (value) => value === "" ? [] : value.replace(/\n$/, "").split("\n");
+const wholeFile = (content, op) => {
+  const lines = linesOf(content);
+  if (lines.length === 0) return "";
+  return `@@ ${op === "+" ? `-0,0 +1,${lines.length}` : `-1,${lines.length} +0,0`} @@
+${lines.map((line) => `${op}${line}`).join("\n")}
+`;
+};
+const changeOf = (change) => typeof change["move_path"] === "string" ? "renamed" : change["type"] === "add" ? "added" : change["type"] === "delete" ? "deleted" : "modified";
+const codexSkippedRows = [
+  "turn_context",
+  "world_state",
+  "token_usage_record",
+  "compacted",
+  "inter_agent_communication_metadata"
+];
+const codexResponseItems = [
+  "message",
+  "reasoning",
+  "custom_tool_call",
+  "custom_tool_call_output",
+  "function_call",
+  "function_call_output",
+  "agent_message"
+];
+const codexSkippedEvents = ["task_started", "token_count", "thread_settings_applied"];
+const codexItems = [
+  "UserMessage",
+  "AgentMessage",
+  "Reasoning",
+  "CommandExecution",
+  "FileChange",
+  "ContextCompaction",
+  "SubAgentActivity",
+  "CollabAgentToolCall",
+  "Extension",
+  "McpToolCall",
+  "FunctionCallOutput",
+  "ImageView"
+];
+const partsText = (value) => typeof value === "string" ? value : list(value).map((each) => text(record(each)["text"])).filter(Boolean).join("\n");
+const itemPart = (item, took) => {
+  switch (item["type"]) {
+    case "UserMessage":
+      return {
+        role: "user",
+        part: { type: "prompt", text: list(item["content"]).map((each) => text(record(each)["text"])).join("\n") }
+      };
+    case "AgentMessage": {
+      const content = list(item["content"]).map(record);
+      const said = content.map((each) => text(each["text"])).filter(Boolean).join("\n");
+      if (content.some((each) => each["type"] === "encrypted_content")) {
+        return { role: "assistant", part: { type: "encrypted" } };
+      }
+      return { role: "assistant", part: { type: "text", text: said, final: item["phase"] === "final_answer" } };
+    }
+    case "Reasoning": {
+      const summary = list(item["summary_text"]).map(text).filter(Boolean).join("\n");
+      return summary === "" ? item["encrypted_content"] ? { role: "assistant", part: { type: "encrypted" } } : void 0 : { role: "assistant", part: { type: "reasoning", text: summary } };
+    }
+    case "CommandExecution": {
+      const exit = typeof item["exit_code"] === "number" ? item["exit_code"] : void 0;
+      const status = item["status"] === "in_progress" ? "running" : item["status"] === "completed" && (exit ?? 0) === 0 ? "ok" : "error";
+      return {
+        role: "assistant",
+        part: {
+          type: "tool",
+          call_id: text(item["id"]),
+          command: list(item["command"]).map(text).at(-1) ?? "",
+          reads: reads(item["parsed_cmd"]),
+          status,
+          ...exit === void 0 ? {} : { exit_code: exit },
+          output: text(item["aggregated_output"]) || text(item["formatted_output"]),
+          duration_ms: took
+        }
+      };
+    }
+    case "FileChange":
+      return {
+        role: "assistant",
+        part: {
+          type: "edit",
+          call_id: text(item["id"]),
+          outcome: item["status"] === "completed" ? "applied" : "failed",
+          files: Object.entries(record(item["changes"])).map(([path, value]) => {
+            const change = record(value);
+            return {
+              path,
+              change: changeOf(change),
+              ...typeof change["move_path"] === "string" ? { renamed_to: change["move_path"] } : {},
+              diff: text(change["unified_diff"]) || wholeFile(text(change["content"]), change["type"] === "delete" ? "-" : "+")
+            };
+          })
+        }
+      };
+    case "ContextCompaction":
+      return { role: "assistant", part: { type: "compaction" } };
+    case "SubAgentActivity":
+      return {
+        role: "assistant",
+        part: {
+          type: "helper",
+          call_id: text(item["id"]),
+          agent: helperName(item["agent_path"]),
+          activity: text(item["kind"])
+        }
+      };
+    case "CollabAgentToolCall": {
+      const agents = list(item["receiver_agents"]).map((each) => helperName(record(each)["agent_path"] ?? each));
+      return {
+        role: "assistant",
+        part: {
+          type: "helper",
+          call_id: text(item["id"]),
+          agent: agents.join(", ") || "helpers",
+          activity: text(item["tool"])
+        }
+      };
+    }
+    case "Extension": {
+      const action = record(item["action"]);
+      const query = text(item["query"]) || text(action["query"]) || text(action["pattern"]) || text(action["url"]);
+      return { role: "assistant", part: { type: "search", call_id: text(item["id"]), query } };
+    }
+    case "McpToolCall": {
+      const result = record(item["result"]);
+      const args = record(item["arguments"]);
+      const name = [text(item["server"]), text(item["tool"])].filter(Boolean).join(".");
+      const failed = item["status"] !== "completed" || result["isError"] === true;
+      return {
+        role: "assistant",
+        part: {
+          type: "tool",
+          call_id: text(item["id"]),
+          command: Object.keys(args).length === 0 ? name : `${name} ${JSON.stringify(args)}`,
+          reads: [],
+          status: item["status"] === "in_progress" ? "running" : failed ? "error" : "ok",
+          output: partsText(result["content"]) || text(record(item["error"])["message"]),
+          duration_ms: took
+        }
+      };
+    }
+    case "FunctionCallOutput":
+      return {
+        role: "assistant",
+        part: {
+          type: "tool",
+          call_id: text(item["id"]),
+          command: [text(item["namespace"]), text(item["name"])].filter(Boolean).join("."),
+          reads: [],
+          status: "ok",
+          output: partsText(item["output"]),
+          duration_ms: took
+        }
+      };
+    default:
+      return {
+        role: "assistant",
+        part: {
+          type: "tool",
+          call_id: text(item["id"]),
+          command: `view_image ${text(item["path"])}`,
+          reads: [`Read ${basename(text(item["path"]))}`],
+          status: "ok",
+          output: "",
+          duration_ms: took
+        }
+      };
+  }
+};
+const scriptFailed = (output) => !/^Script (?:completed|running)\b/.test(output);
+const failedPatchPath = (output) => /apply_patch verification failed: Failed to find expected lines in ([^\n]+):\n/.exec(output)?.[1];
+const profileOf = (profile, releases, release) => {
+  const minor = /^(\d+\.\d+)\./.exec(release)?.[1];
+  return minor !== void 0 && releases.includes(minor) ? `${profile}/${minor}` : void 0;
+};
+const decodeCodex = (state, chunk) => {
+  const lines = (state.pending + chunk).split("\n");
+  const pending = lines.pop();
+  let { line, seq, session, goal } = state;
+  const calls = new Map(Object.entries(state.calls ?? {}));
+  const entries = [];
+  const fail = (code, message) => import_effect.Result.fail(new ExternalTranscriptError({ code, message, line }));
+  const unread = (what, type) => typeof type === "string" && type !== "" ? fail("unsupported_record", `Codex wrote ${what} this release does not read: ${type}`) : fail("malformed_record", `Codex rollout line ${line} names no ${what.replace(/^an? /, "")} type.`);
+  for (const raw of lines) {
+    line++;
+    if (raw.trim() === "") continue;
+    const row = parseRow(raw);
+    if (row === void 0) return fail("malformed_record", `Codex rollout line ${line} is not a JSON record.`);
+    const payload = record(row["payload"]);
+    if (row["type"] === "session_meta") {
+      const release = text(payload["cli_version"]);
+      const format_version2 = profileOf("codex-rollout", codexReleases, release);
+      if (format_version2 === void 0) {
+        return fail(
+          "unsupported_version",
+          `Codex ${release || "(no release)"} wrote this rollout; supported: ${codexReleases.join(", ")}.`
+        );
+      }
+      session = { id: text(payload["id"]) || text(payload["session_id"]), format_version: format_version2, cwd: text(payload["cwd"]) };
+      continue;
+    }
+    if (session === void 0) {
+      return fail("missing_version", `Codex rollout line ${line} comes before its session record.`);
+    }
+    const found = [];
+    if (row["type"] === "response_item") {
+      if (!codexResponseItems.includes(text(payload["type"]))) return unread("a response item", payload["type"]);
+      switch (payload["type"]) {
+        case "custom_tool_call": {
+          const id = payload["call_id"], name = payload["name"], input = payload["input"];
+          if (typeof id !== "string" || id === "" || typeof name !== "string" || typeof input !== "string") {
+            return fail("malformed_record", `Codex tool request on line ${line} names no call, tool or input.`);
+          }
+          calls.set(id, { name, input });
+          break;
+        }
+        case "custom_tool_call_output": {
+          const id = text(payload["call_id"]);
+          const call = calls.get(id);
+          calls.delete(id);
+          const output = partsText(payload["output"]);
+          if (!scriptFailed(output)) break;
+          found.push({
+            role: "assistant",
+            part: {
+              type: "tool",
+              call_id: id,
+              command: call?.input ?? "",
+              reads: [],
+              status: "error",
+              output,
+              duration_ms: 0
+            }
+          });
+          const path = failedPatchPath(output);
+          if (path !== void 0) {
+            found.push({
+              role: "assistant",
+              part: { type: "edit", call_id: id, files: [{ path, change: "modified", diff: "" }], outcome: "failed" }
+            });
+          }
+          break;
+        }
+        case "agent_message": {
+          const content = payload["content"];
+          if (!Array.isArray(content)) {
+            return fail("malformed_record", `Codex agent message on line ${line} has no content list.`);
+          }
+          let encrypted = false;
+          const said = [];
+          for (const each of content) {
+            const block = record(each);
+            if (block["type"] === "encrypted_content") {
+              if (typeof block["encrypted_content"] !== "string" || block["encrypted_content"] === "") {
+                return fail("malformed_record", `Codex encrypted body on line ${line} is empty.`);
+              }
+              encrypted = true;
+            } else if (block["type"] === "input_text" || block["type"] === "output_text") {
+              if (typeof block["text"] !== "string") {
+                return fail("malformed_record", `Codex agent message on line ${line} has a text part without text.`);
+              }
+              said.push(block["text"]);
+            } else {
+              return unread("a message part", block["type"]);
+            }
+          }
+          const turn = text(record(payload["internal_chat_message_metadata_passthrough"])["turn_id"]);
+          if (encrypted) found.push({ role: "assistant", part: { type: "encrypted" }, turn });
+          else if (said.join("\n") !== "") {
+            found.push({ role: "assistant", part: { type: "text", text: said.join("\n"), final: false }, turn });
+          }
+          break;
+        }
+      }
+    } else if (row["type"] === "event_msg") {
+      switch (payload["type"]) {
+        case "item_completed": {
+          const started = payload["started_at_ms"], completed = payload["completed_at_ms"];
+          const took = typeof started === "number" && typeof completed === "number" ? completed - started : 0;
+          const item = record(payload["item"]);
+          if (!codexItems.includes(text(item["type"]))) return unread("an item", item["type"]);
+          if (item["type"] === "UserMessage" || item["type"] === "AgentMessage") {
+            const content = item["content"];
+            if (!Array.isArray(content)) {
+              return fail("malformed_record", `Codex message on line ${line} has no content list.`);
+            }
+            if (!content.some((each) => record(each)["type"] === "encrypted_content")) {
+              for (const each of content) {
+                const block = record(each);
+                if (block["type"] !== (item["type"] === "UserMessage" ? "text" : "Text")) {
+                  return unread("a message part", block["type"]);
+                }
+                if (typeof block["text"] !== "string") {
+                  return fail("malformed_record", `Codex message on line ${line} has a text part without text.`);
+                }
+              }
+            }
+          }
+          const part = itemPart(item, Number.isFinite(took) && took > 0 ? took : 0);
+          if (part !== void 0) found.push({ ...part, turn: text(payload["turn_id"]) });
+          break;
+        }
+        case "thread_goal_updated": {
+          const update = record(payload["goal"]);
+          const key = `${text(update["status"])}:${text(update["objective"])}`;
+          if (key !== goal) {
+            found.push({
+              role: "user",
+              part: { type: "goal", objective: text(update["objective"]), status: text(update["status"]) }
+            });
+          }
+          goal = key;
+          break;
+        }
+        case "task_complete": {
+          if (payload["error"] === void 0 || payload["error"] === null) break;
+          const message = text(record(payload["error"])["message"]);
+          if (message === "") return fail("malformed_record", `Codex failure on line ${line} gives no message.`);
+          found.push({ role: "assistant", part: { type: "error", message }, turn: text(payload["turn_id"]) });
+          break;
+        }
+        case "error":
+        case "turn_aborted": {
+          const message = text(payload["message"]) || text(payload["reason"]);
+          if (message === "") {
+            return fail("malformed_record", `Codex failure on line ${line} gives no message or reason.`);
+          }
+          found.push({ role: "assistant", part: { type: "error", message }, turn: text(payload["turn_id"]) });
+          break;
+        }
+        default:
+          if (!codexSkippedEvents.includes(text(payload["type"]))) return unread("an event", payload["type"]);
+      }
+    } else if (!codexSkippedRows.includes(text(row["type"]))) {
+      return unread("a record", row["type"]);
+    }
+    const at = Date.parse(text(row["timestamp"])) || 0;
+    const sessionId = session.id, format_version = session.format_version;
+    found.forEach(({ part, role, turn }, index) => {
+      entries.push({
+        origin: "external",
+        agent_kind: "codex",
+        format_version,
+        session_id: sessionId,
+        source_id: index === 0 ? `${sessionId}:${line}` : `${sessionId}:${line}#${index}`,
+        read_only: true,
+        seq: seq++,
+        at,
+        ...turn ? { turn_id: turn } : {},
+        role,
+        part
+      });
+    });
+  }
+  return import_effect.Result.succeed({
+    state: { pending, line, seq, session, goal, ...calls.size === 0 ? {} : { calls: Object.fromEntries(calls) } },
+    entries
+  });
+};
+const claudeReleases = ["2.1"];
+const claudeStart = { pending: "", line: 0, seq: 0, calls: {} };
+const blocksOf = (content) => typeof content === "string" ? [{ type: "text", text: content }] : list(content).map(record);
+const textOf = (blocks) => blocks.filter((block) => block["type"] === "text").map((block) => text(block["text"])).join("\n");
+const byOwner = (origin) => origin === void 0 || origin === null || record(origin)["kind"] === "human";
+const replacement = (before, after) => {
+  const removed = linesOf(before), added = linesOf(after);
+  if (removed.length + added.length === 0) return "";
+  return `@@ -1,${removed.length} +1,${added.length} @@
+${[...removed.map((line) => `-${line}`), ...added.map((line) => `+${line}`)].join("\n")}
+`;
+};
+const count = (value) => typeof value === "number" ? value : 0;
+const reportedPatch = (patch) => list(patch).map(record).map(
+  (hunk) => `@@ -${count(hunk["oldStart"])},${count(hunk["oldLines"])} +${count(hunk["newStart"])},${count(hunk["newLines"])} @@
+${list(hunk["lines"]).map(text).join("\n")}
+`
+).join("");
+const requestedPatch = (name, input) => {
+  switch (name) {
+    case "Write":
+      return wholeFile(text(input["content"]), "+");
+    case "NotebookEdit":
+      return wholeFile(text(input["new_source"]), "+");
+    case "MultiEdit":
+      return list(input["edits"]).map(record).map(
+        (edit) => replacement(text(edit["old_string"]), text(edit["new_string"]))
+      ).join("");
+    default:
+      return replacement(text(input["old_string"]), text(input["new_string"]));
+  }
+};
+const claudeReads = (name, input) => {
+  const path = text(input["path"]);
+  switch (name) {
+    case "Read":
+      return [`Read ${basename(text(input["file_path"]))}`];
+    case "Grep":
+    case "Glob":
+      return [`Searched ${JSON.stringify(text(input["pattern"]))}${path ? ` in ${basename(path)}` : ""}`];
+    case "LS":
+      return [`Listed ${basename(path) || "files"}`];
+    default:
+      return [];
+  }
+};
+const claudeToolPart = (id, call, result) => {
+  const name = call?.name ?? "";
+  const input = record(call?.input);
+  switch (name) {
+    case "Edit":
+    case "Write":
+    case "MultiEdit":
+    case "NotebookEdit":
+      return {
+        type: "edit",
+        call_id: id,
+        files: [{
+          path: text(input["file_path"]) || text(input["notebook_path"]),
+          change: name === "Write" && result.report["type"] === "create" ? "added" : "modified",
+          diff: reportedPatch(result.report["structuredPatch"]) || requestedPatch(name, input)
+        }],
+        outcome: result.failed ? "failed" : "applied"
+      };
+    case "WebSearch":
+      return { type: "search", call_id: id, query: text(input["query"]) };
+    case "WebFetch":
+      return { type: "search", call_id: id, query: text(input["url"]) };
+    case "Task":
+    case "Agent":
+      return {
+        type: "helper",
+        call_id: id,
+        agent: text(input["subagent_type"]) || "general-purpose",
+        activity: text(input["description"])
+      };
+  }
+  const exit = result.failed ? /^Exit code (\d+)/.exec(result.output)?.[1] : void 0;
+  return {
+    type: "tool",
+    call_id: id,
+    command: name === "Bash" ? text(input["command"]) : Object.keys(input).length === 0 ? name : `${name} ${JSON.stringify(input)}`,
+    reads: claudeReads(name, input),
+    status: result.failed ? "error" : "ok",
+    ...exit === void 0 ? {} : { exit_code: Number(exit) },
+    output: result.output,
+    duration_ms: result.took
+  };
+};
+const claudeSkippedRows = [
+  "mode",
+  "permission-mode",
+  "atis-latch",
+  "last-prompt",
+  "ai-title",
+  "custom-title",
+  "agent-name",
+  "queue-operation",
+  "file-history-snapshot",
+  "file-history-delta",
+  "cost-state",
+  "pr-link",
+  "bridge-session"
+];
+const claudeSkippedStatus = [
+  "turn_duration",
+  "informational",
+  "stop_hook_summary",
+  "away_summary",
+  "api_error",
+  "local_command",
+  "scheduled_task_fire",
+  "agents_killed",
+  "model_refusal_fallback"
+];
+const claudeSkippedAttachments = [
+  "agent_listing_delta",
+  "auto_mode",
+  "bash_output_audience_note",
+  "batching_reminder_sent",
+  "budget_usd",
+  "command_permissions",
+  "compact_file_reference",
+  "credential_org",
+  "date",
+  "deferred_tools_delta",
+  "deferred_tools_record",
+  "diagnostics",
+  "directory",
+  "edited_text_file",
+  "environment",
+  "file",
+  "goal_status",
+  "hook_additional_context",
+  "hook_cancelled",
+  "hook_non_blocking_error",
+  "hook_system_message",
+  "instructions",
+  "invoked_skills",
+  "max_turns_reached",
+  "mcp_instructions_delta",
+  "model",
+  "nested_memory",
+  "plan_mode",
+  "prompt_snapshot",
+  "read_truncation_notice",
+  "remote_session_change",
+  "sandbox_instructions",
+  "session_context",
+  "silent_turn_reminder",
+  "skill_listing",
+  "skill_mention",
+  "task_reminder",
+  "task_status",
+  "thinking_drop",
+  "thinking_stripped",
+  "total_tokens_reminder",
+  "ultra_effort_enter",
+  "ultra_effort_exit",
+  "workflow_keyword_request"
+];
+const ownerText = (said) => {
+  if (/^\[Request interrupted by user[^\]]*\]$/.test(said)) return { type: "error", message: said };
+  if (/^<(?:local-command-std(?:out|err)|bash-std(?:out|err))>/.test(said)) return void 0;
+  const command = /^<command-(?:name|message)>/.test(said) ? /<command-name>([^<]*)<\/command-name>/.exec(said)?.[1] : void 0;
+  if (command !== void 0) {
+    const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(said)?.[1]?.trim();
+    return { type: "prompt", text: args ? `${command} ${args}` : command };
+  }
+  const shell = /^<bash-input>([\s\S]*)<\/bash-input>$/.exec(said)?.[1];
+  return { type: "prompt", text: shell === void 0 ? said : `!${shell.trim()}` };
+};
+const decodeClaude = (state, chunk) => {
+  const lines = (state.pending + chunk).split("\n");
+  const pending = lines.pop();
+  let { line, seq, session, turn } = state;
+  const calls = new Map(Object.entries(state.calls));
+  const entries = [];
+  const fail = (code, message) => import_effect.Result.fail(new ExternalTranscriptError({ code, message, line }));
+  const unread = (what, type) => typeof type === "string" && type !== "" ? fail("unsupported_record", `Claude Code wrote ${what} this release does not read: ${type}`) : fail("malformed_record", `Claude Code transcript line ${line} names no ${what.replace(/^an? /, "")} type.`);
+  for (const raw of lines) {
+    line++;
+    if (raw.trim() === "") continue;
+    const row = parseRow(raw);
+    if (row === void 0) return fail("malformed_record", `Claude Code transcript line ${line} is not a JSON record.`);
+    if (claudeSkippedRows.includes(text(row["type"]))) continue;
+    if (!["user", "assistant", "system", "attachment"].includes(text(row["type"]))) {
+      return unread("a record", row["type"]);
+    }
+    if (typeof row["uuid"] !== "string") {
+      return fail("malformed_record", `Claude Code transcript line ${line} is a conversation record without a uuid.`);
+    }
+    const release = text(row["version"]);
+    if (release === "") return fail("missing_version", `Claude Code transcript line ${line} names no release.`);
+    const format_version = profileOf("claude-code", claudeReleases, release);
+    if (format_version === void 0) {
+      return fail(
+        "unsupported_version",
+        `Claude Code ${release} wrote this transcript; supported: ${claudeReleases.join(", ")}.`
+      );
+    }
+    session ??= text(row["sessionId"]) || void 0;
+    if (session === void 0) {
+      return fail("malformed_record", `Claude Code transcript line ${line} names no session.`);
+    }
+    const sessionId = session;
+    if (row["isSidechain"] === true) continue;
+    const at = Date.parse(text(row["timestamp"])) || 0;
+    if (row["type"] === "user" && typeof row["promptId"] === "string" && row["promptId"] !== "") {
+      turn = row["promptId"];
+    }
+    const found = [];
+    const said = (part) => found.push({ role: "assistant", part });
+    const message = record(row["message"]);
+    if ((row["type"] === "user" || row["type"] === "assistant") && typeof message["content"] !== "string" && !Array.isArray(message["content"])) {
+      return fail("malformed_record", `Claude Code transcript line ${line} has no message content.`);
+    }
+    switch (row["type"]) {
+      case "user": {
+        const blocks = blocksOf(message["content"]);
+        for (const block of blocks) {
+          if (block["type"] === "tool_result") {
+            const callId = text(block["tool_use_id"]);
+            const call = calls.get(callId);
+            calls.delete(callId);
+            const content = block["content"];
+            said(claudeToolPart(callId, call, {
+              failed: block["is_error"] === true,
+              output: typeof content === "string" ? content : textOf(list(content).map(record)),
+              report: record(row["toolUseResult"]),
+              took: call !== void 0 && call.at > 0 && at > call.at ? at - call.at : 0
+            }));
+          } else if (block["type"] !== "text" && block["type"] !== "image") {
+            return unread("a content block", block["type"]);
+          }
+        }
+        const words = textOf(blocks);
+        if (words === "" || row["isMeta"] === true || row["isCompactSummary"] === true || !byOwner(row["origin"])) break;
+        const part = ownerText(words);
+        if (part !== void 0) found.push({ role: part.type === "prompt" ? "user" : "assistant", part });
+        break;
+      }
+      case "assistant": {
+        const blocks = blocksOf(message["content"]);
+        if (row["isApiErrorMessage"] === true) {
+          said({ type: "error", message: textOf(blocks) || text(row["error"]) });
+          break;
+        }
+        for (const block of blocks) {
+          switch (block["type"]) {
+            case "text":
+              if (text(block["text"]) !== "") {
+                said({ type: "text", text: text(block["text"]), final: message["stop_reason"] === "end_turn" });
+              }
+              break;
+            case "thinking":
+              if (text(block["thinking"]) !== "") said({ type: "reasoning", text: text(block["thinking"]) });
+              break;
+            case "redacted_thinking":
+              break;
+            case "fallback":
+              break;
+            case "tool_use":
+              if (typeof block["id"] !== "string" || block["id"] === "") {
+                return fail("malformed_record", `Claude Code tool request on line ${line} names no call.`);
+              }
+              calls.set(block["id"], { name: text(block["name"]), input: block["input"] ?? {}, at });
+              break;
+            default:
+              return unread("a content block", block["type"]);
+          }
+        }
+        break;
+      }
+      case "system":
+        if (row["subtype"] === "compact_boundary") said({ type: "compaction" });
+        else if (!claudeSkippedStatus.includes(text(row["subtype"]))) return unread("a status record", row["subtype"]);
+        break;
+      case "attachment": {
+        const attachment = record(row["attachment"]);
+        if (attachment["type"] !== "queued_command") {
+          if (!claudeSkippedAttachments.includes(text(attachment["type"]))) {
+            return unread("an attachment", attachment["type"]);
+          }
+          break;
+        }
+        if (attachment["commandMode"] === "prompt" && attachment["isMeta"] !== true && byOwner(attachment["origin"])) {
+          const words = textOf(blocksOf(attachment["prompt"]));
+          if (words !== "") found.push({ role: "user", part: { type: "prompt", text: words } });
+        }
+        break;
+      }
+    }
+    found.forEach(({ part, role }, index) => {
+      entries.push({
+        origin: "external",
+        agent_kind: "claude-code",
+        format_version,
+        session_id: sessionId,
+        source_id: index === 0 ? `${sessionId}:${line}` : `${sessionId}:${line}#${index}`,
+        read_only: true,
+        seq: seq++,
+        at,
+        ...turn === void 0 ? {} : { turn_id: turn },
+        role,
+        part
+      });
+    });
+  }
+  return import_effect.Result.succeed({
+    state: { pending, line, seq, session, turn, calls: Object.fromEntries(calls) },
+    entries
+  });
+};
+//# sourceMappingURL=ExternalTranscript.js.map