@volter-ai-dev/supercode-ui 0.1.69 → 0.1.71

package/chunks/chunk-LS6JBXNT.mjs

@@ -0,0 +1,1237 @@
+// core.mjs
+var HARNESS_NAMES = Object.freeze({
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  gemini: "Gemini CLI",
+  goose: "Goose",
+  opencode: "OpenCode",
+  pi: "Pi",
+  grok: "Grok"
+});
+var DEFAULT_LABELS = Object.freeze({
+  chats: "Chats",
+  newChat: "New chat",
+  searchChats: "Search chats",
+  askAgent: "Ask your agent\u2026",
+  attachContext: "Attach files or images",
+  continueHere: "Continue here",
+  continueWithTerminal: "Continue with terminal",
+  joinLive: "Join live",
+  forkHere: "Fork here"
+});
+var EMPTY_UI_STATE = Object.freeze({
+  pill: Object.freeze({ tone: "off", label: "connecting\u2026" }),
+  startup: "connecting",
+  transcript: Object.freeze([]),
+  busy: false,
+  operation: null,
+  needsInput: false,
+  harness: "",
+  mode: "none",
+  strategy: null,
+  participant: Object.freeze({ kind: "local-user", label: null, origin: null }),
+  workspaceRef: Object.freeze({ kind: "none", value: null }),
+  mirror: null,
+  holder: null,
+  canSend: false,
+  canSteer: false,
+  canResume: false,
+  supportsResume: false,
+  continuationModes: Object.freeze([]),
+  canBranch: false,
+  supportsBranch: false,
+  canAttach: false,
+  supportsAttach: false,
+  canDetach: false,
+  canOpenTerminal: false,
+  canExport: false,
+  canReduce: false,
+  canInterrupt: false,
+  canRespond: false,
+  canConfigureSettings: false,
+  messaging: null,
+  workspace: "",
+  taskPlan: Object.freeze({ source: "none", items: Object.freeze([]), residueCount: 0, observedAt: null }),
+  semantics: Object.freeze({ fidelity: null, residue: Object.freeze([]), residueCount: 0, parseErrors: 0, rawRecords: 0, subagents: Object.freeze([]) }),
+  terminalHandoff: null,
+  exportBackTarget: null,
+  exportReceipt: null,
+  reductionReceipt: null,
+  interopSettings: null,
+  interopSettingsError: null,
+  harnessAuthentication: null,
+  error: null,
+  recoverable: false,
+  harnesses: Object.freeze([]),
+  history: Object.freeze({ sessionLimit: 0, hasMoreSessions: false, transcriptLimit: 120, hasEarlier: false }),
+  savedDraft: "",
+  attention: Object.freeze([]),
+  sessions: Object.freeze([]),
+  subagentInspector: null,
+  attached: null,
+  owned: null,
+  attachError: null,
+  agentPackage: null,
+  contributions: Object.freeze([]),
+  agentPackageError: null,
+  agentPackageCapabilityState: null,
+  agentPackageCapabilityError: null
+});
+var ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool", "reasoning", "request", "notice"]);
+var MODES = /* @__PURE__ */ new Set(["none", "control", "mirror"]);
+var STRATEGIES = /* @__PURE__ */ new Set(["start", "resume", "attach", "branch", "reduce"]);
+var STARTUP = /* @__PURE__ */ new Set(["connecting", "starting", "discovering", "ready"]);
+var FIDELITY = /* @__PURE__ */ new Set(["byte_lossless", "value_lossless", "semantic"]);
+var TOOL_CATEGORIES = /* @__PURE__ */ new Set(["read", "search", "edit", "command", "test", "web", "agent", "plan", "other"]);
+var TOOL_DETAILS = /* @__PURE__ */ new Set(["file", "matches", "diff", "terminal", "web", "agent", "plan", "fields"]);
+var AUTHENTICATION_PHASES = /* @__PURE__ */ new Set(["idle", "checking", "required", "configured", "unavailable", "launching", "awaiting_user", "verifying", "authenticated", "failed", "cancelled"]);
+var MAX_TOOL_FIELDS = 8;
+var MAX_TOOL_FIELD_CHARS = 800;
+var MAX_TOOL_PREVIEW_CHARS = 4e3;
+var MAX_CONTRIBUTIONS = 64;
+var MAX_CONTRIBUTION_JSON_DEPTH = 12;
+var MAX_CONTRIBUTION_COLLECTION = 100;
+var MAX_CONTRIBUTION_STRING_CHARS = 16e3;
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readHarnessAuthentication(value) {
+  const flow = record(value);
+  if (flow?.schema !== "supercode.harness-authentication-flow.v1" || !AUTHENTICATION_PHASES.has(flow.phase)) return null;
+  const plan = record(flow.plan);
+  const error = record(flow.error);
+  return {
+    schema: "supercode.harness-authentication-flow.v1",
+    revision: Number.isSafeInteger(flow.revision) ? Math.max(0, flow.revision) : 0,
+    phase: flow.phase,
+    harness: typeof flow.harness === "string" ? boundedString(flow.harness, 100) : null,
+    plan: plan ? {
+      method: plan.method === "device_code" ? "device_code" : "browser",
+      interaction: plan.interaction === "device_code" ? "device_code" : "browser",
+      browserBehavior: plan.browserBehavior === "none" ? "none" : "native_auto",
+      headless: plan.headless === true,
+      instructions: boundedString(plan.instructions, 2e3)
+    } : null,
+    error: error && typeof error.message === "string" ? { code: boundedString(error.code, 100), message: boundedString(error.message, 2e3) } : null
+  };
+}
+function string(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function number(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function nullableNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function relativeContributionPath(value) {
+  if (typeof value !== "string" || value.startsWith("/") || /^[a-z]:[\\/]/i.test(value)) return null;
+  return value.replaceAll("\\", "/").split("/").some((segment) => segment === "..") ? null : boundedString(value, 1e3);
+}
+function contributionJson(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return typeof value === "string" ? boundedString(value, MAX_CONTRIBUTION_STRING_CHARS) : value;
+  }
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (depth >= MAX_CONTRIBUTION_JSON_DEPTH || !value || typeof value !== "object" || seen.has(value)) {
+    return void 0;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result2 = [];
+    for (const item of value.slice(0, MAX_CONTRIBUTION_COLLECTION)) {
+      const normalized = contributionJson(item, depth + 1, seen);
+      if (normalized !== void 0) result2.push(normalized);
+    }
+    seen.delete(value);
+    return result2;
+  }
+  const source = record(value);
+  if (!source) return void 0;
+  const result = {};
+  for (const [key, item] of Object.entries(source).slice(0, MAX_CONTRIBUTION_COLLECTION)) {
+    const normalized = contributionJson(item, depth + 1, seen);
+    if (normalized !== void 0) result[boundedString(key, 200)] = normalized;
+  }
+  seen.delete(value);
+  return result;
+}
+function normalizeContributions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, MAX_CONTRIBUTIONS).flatMap((candidate) => {
+    const item = record(candidate);
+    const placement = record(item?.placement);
+    const source = relativeContributionPath(item?.source);
+    if (item?.schema !== "supercode/contribution-v1" || typeof item.id !== "string" || !item.id.trim() || typeof item.kind !== "string" || !item.kind.trim() || source === null) return [];
+    const data = contributionJson(item.data);
+    if (data === void 0) return [];
+    return [{
+      schema: "supercode/contribution-v1",
+      id: boundedString(item.id, 200),
+      kind: boundedString(item.kind, 100),
+      ...typeof item.title === "string" ? { title: boundedString(item.title, 500) } : {},
+      ...placement ? { placement: {
+        ...typeof placement.surface === "string" ? { surface: boundedString(placement.surface, 100) } : {},
+        ...typeof placement.region === "string" ? { region: boundedString(placement.region, 100) } : {}
+      } } : {},
+      data,
+      source
+    }];
+  });
+}
+function readAgentPackage(value) {
+  const agentPackage = record(value);
+  const capabilities = record(agentPackage?.capabilities);
+  const storage = record(agentPackage?.storage);
+  const relativePath = relativeContributionPath(storage?.relativePath);
+  if (agentPackage?.schemaVersion !== 1 || typeof agentPackage.id !== "string" || typeof agentPackage.name !== "string" || typeof agentPackage.version !== "string" || !capabilities || !Array.isArray(capabilities.required) || !Array.isArray(capabilities.optional) || !storage || relativePath === null) return null;
+  const resources = record(agentPackage.resources);
+  return {
+    id: boundedString(agentPackage.id, 200),
+    name: boundedString(agentPackage.name, 500),
+    version: boundedString(agentPackage.version, 100),
+    description: typeof agentPackage.description === "string" ? boundedString(agentPackage.description, 2e3) : null,
+    capabilities: {
+      required: capabilities.required.filter((item) => typeof item === "string").slice(0, 100).map((item) => boundedString(item, 200)),
+      optional: capabilities.optional.filter((item) => typeof item === "string").slice(0, 100).map((item) => boundedString(item, 200))
+    },
+    storage: { relativePath },
+    resources: resources ? Object.fromEntries(Object.entries(resources).flatMap(([id, candidate]) => {
+      const state = record(candidate);
+      if (state?.schema !== "supercode/package-resource-state-v1") return [];
+      if (state.status === "absent" && typeof state.contributionId === "string") {
+        return [[boundedString(id, 200), {
+          schema: "supercode/package-resource-state-v1",
+          status: "absent",
+          contributionId: boundedString(state.contributionId, 200)
+        }]];
+      }
+      if (state.status === "error" && typeof state.contributionId === "string" && typeof state.message === "string") {
+        return [[boundedString(id, 200), {
+          schema: "supercode/package-resource-state-v1",
+          status: "error",
+          contributionId: boundedString(state.contributionId, 200),
+          message: boundedString(state.message)
+        }]];
+      }
+      const resource = record(state?.resource);
+      const data = contributionJson(resource?.data);
+      if (state?.status !== "ready" || resource?.schema !== "supercode/package-resource-v1" || typeof resource.contributionId !== "string" || !["json", "text"].includes(resource.format) || typeof resource.mediaType !== "string" || data === void 0) return [];
+      return [[boundedString(id, 200), {
+        schema: "supercode/package-resource-state-v1",
+        status: "ready",
+        resource: {
+          schema: "supercode/package-resource-v1",
+          contributionId: boundedString(resource.contributionId, 200),
+          format: resource.format,
+          mediaType: boundedString(resource.mediaType, 200),
+          data
+        }
+      }]];
+    })) : {}
+  };
+}
+function readAgentPackageCapabilityState(value) {
+  const state = record(value);
+  if (!state) return null;
+  const fields = ["availableRequired", "missingRequired", "enabledOptional", "unavailableOptional"];
+  if (!fields.every((field) => Array.isArray(state[field]))) return null;
+  return {
+    ready: state.ready === true,
+    ...Object.fromEntries(fields.map((field) => [
+      field,
+      state[field].filter((item) => typeof item === "string").slice(0, 100).map((item) => boundedString(item, 200))
+    ]))
+  };
+}
+function relativeAge(updatedAt, now = Date.now()) {
+  if (typeof updatedAt !== "number" || !Number.isFinite(updatedAt) || updatedAt <= 0) return "";
+  const delta = Math.max(0, now - updatedAt);
+  if (delta < 6e4) return "now";
+  if (delta < 36e5) return `${Math.floor(delta / 6e4)}m ago`;
+  if (delta < 864e5) return `${Math.floor(delta / 36e5)}h ago`;
+  if (delta < 6048e5) return `${Math.floor(delta / 864e5)}d ago`;
+  return `${Math.floor(delta / 6048e5)}w ago`;
+}
+function boundedString(value, max = 2e3) {
+  if (typeof value !== "string") return "";
+  return value.length <= max ? value : `${value.slice(0, max)}\u2026`;
+}
+function argumentValue(argumentsText) {
+  if (!argumentsText) return null;
+  try {
+    return JSON.parse(argumentsText);
+  } catch {
+    return null;
+  }
+}
+function firstString(source, keys) {
+  for (const key of keys) {
+    if (typeof source?.[key] === "string" && source[key].trim()) return source[key].trim();
+  }
+  return "";
+}
+function decodedLiteral(value) {
+  if (!value) return "";
+  if (value.startsWith('"')) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return "";
+    }
+  }
+  return value.slice(1, -1).replaceAll("\\n", "\n").replaceAll("\\t", "	").replaceAll("\\r", "\r").replaceAll("\\`", "`").replaceAll("\\'", "'").replaceAll("\\\\", "\\");
+}
+function sourceString(source, keys) {
+  if (!source) return "";
+  const names = keys.join("|");
+  const match = new RegExp(`(?:^|[,{\\s])["']?(?:${names})["']?\\s*:\\s*("(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|\`(?:\\\\.|[^\`\\\\])*\`)`).exec(source);
+  return decodedLiteral(match?.[1]);
+}
+function assignedString(source, keys) {
+  if (!source) return "";
+  const names = keys.join("|");
+  const match = new RegExp(`\\b(?:${names})\\s*=\\s*("(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|\`(?:\\\\.|[^\`\\\\])*\`)`).exec(source);
+  return decodedLiteral(match?.[1]);
+}
+function callArgumentSource(source, open) {
+  let depth = 1;
+  let quote = "";
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = open + 1; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = "";
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(") depth += 1;
+    else if (char === ")" && (depth -= 1) === 0) return source.slice(open + 1, index);
+  }
+  return source.slice(open + 1);
+}
+function toolCalls(source) {
+  const calls = [];
+  let quote = "";
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0; index < source.length && calls.length < 8; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = "";
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (!source.startsWith("tools.", index) || /[A-Za-z0-9_$]/.test(source[index - 1] ?? "")) continue;
+    const nameStart = index + 6;
+    let nameEnd = nameStart;
+    while (/[A-Za-z0-9_$]/.test(source[nameEnd] ?? "")) nameEnd += 1;
+    let open = nameEnd;
+    while (/\s/.test(source[open] ?? "")) open += 1;
+    if (nameEnd === nameStart || source[open] !== "(") continue;
+    calls.push({ name: source.slice(nameStart, nameEnd), arguments: callArgumentSource(source, open) });
+    index = open;
+  }
+  return calls;
+}
+function toolEnvelope(entry) {
+  const value = argumentValue(entry.arguments);
+  const source = typeof value === "string" ? value : value === null ? entry.arguments ?? "" : "";
+  const calls = source ? toolCalls(source) : [];
+  const tools = [...new Set(calls.map((call) => call.name))];
+  const name = tools.length === 1 ? tools[0] : entry.label ?? "tool";
+  return { args: record(value), source, callSource: calls[0]?.arguments ?? "", tools, name };
+}
+function patchPath(source) {
+  return /\*\*\* (?:Update|Add|Delete) File:\s*([^\r\n]*?)(?=\\[nr]|[\r\n]|$)/.exec(source)?.[1]?.trim() ?? "";
+}
+function explicitNumber(sources, keys) {
+  for (const source of sources) {
+    for (const key of keys) {
+      const value = source?.[key];
+      const parsed = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+      if (typeof parsed === "number" && Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return null;
+}
+function toolDetail(category) {
+  return { read: "file", search: "matches", edit: "diff", command: "terminal", test: "terminal", web: "web", agent: "agent", plan: "plan" }[category] ?? "fields";
+}
+function usefulToolFields(args) {
+  if (!args) return [];
+  const hidden = /* @__PURE__ */ new Set(["command", "cmd", "file_path", "target_file", "path", "query", "pattern", "url", "patch", "diff", "old_string", "new_string", "content", "prompt", "description", "task", "plan", "todos"]);
+  return Object.entries(args).flatMap(([key, value]) => {
+    if (hidden.has(key) || value === null || value === void 0) return [];
+    const rendered = typeof value === "string" ? value : JSON.stringify(value);
+    if (!rendered) return [];
+    return [{ label: key.replaceAll(/[_-]+/g, " ").replace(/^./, (letter) => letter.toLocaleUpperCase()), value: boundedString(rendered, MAX_TOOL_FIELD_CHARS) }];
+  }).slice(0, MAX_TOOL_FIELDS);
+}
+function planItems(args) {
+  const source = Array.isArray(args?.plan) ? args.plan : Array.isArray(args?.todos) ? args.todos : [];
+  return source.flatMap((item) => {
+    if (typeof item === "string" && item.trim()) return [{ label: boundedString(item.trim(), 300), status: "" }];
+    const value = record(item);
+    const label = firstString(value, ["step", "title", "content", "text"]);
+    if (!label) return [];
+    return [{ label: boundedString(label, 300), status: firstString(value, ["status"]) }];
+  }).slice(0, 12);
+}
+function agentItems(name, resultText) {
+  if (!/list.?agents/i.test(name)) return [];
+  return (resultText ?? "").split("\n").flatMap((line) => {
+    const parts = line.trim().split(/\s+·\s+/).filter(Boolean);
+    return parts.length > 1 ? [{ label: boundedString(parts[0], 120), status: boundedString(parts.slice(1).join(" \xB7 "), 180) }] : [];
+  }).slice(0, 12);
+}
+function editPreview(args, resultText, source) {
+  const direct = firstString(args, ["patch", "diff"]);
+  if (direct) return direct;
+  const oldText = firstString(args, ["old_string"]);
+  const newText = firstString(args, ["new_string"]);
+  if (oldText || newText) {
+    return [
+      ...oldText.split("\n").map((line) => `- ${line}`),
+      ...newText.split("\n").map((line) => `+ ${line}`)
+    ].join("\n");
+  }
+  const patch = /\*\*\* Begin Patch[\s\S]*?\*\*\* End Patch/.exec(source ?? "")?.[0];
+  if (patch) return patch;
+  return /^(?:diff --git|@@ |--- |\+\+\+ )/m.test(resultText ?? "") ? resultText : "";
+}
+function toolResultEnvelope(resultText) {
+  const match = /^Script (?:completed|failed)\r?\nWall time ([0-9.]+) seconds\r?\nOutput:\r?\n([\s\S]*)$/.exec(resultText ?? "");
+  if (!match) {
+    try {
+      const value = JSON.parse(resultText ?? "");
+      const object = record(value);
+      return {
+        preview: typeof value === "string" ? value : firstString(object, ["output", "message", "text", "summary", "result"]) || resultText || "",
+        value: object,
+        durationMs: null
+      };
+    } catch {
+      return { preview: resultText ?? "", value: null, durationMs: null };
+    }
+  }
+  const durationMs = Number(match[1]) * 1e3;
+  try {
+    const value = record(JSON.parse(match[2]));
+    return {
+      preview: typeof value?.output === "string" ? value.output : match[2],
+      value,
+      durationMs: Number.isFinite(durationMs) ? durationMs : null
+    };
+  } catch {
+    return { preview: match[2], value: null, durationMs: Number.isFinite(durationMs) ? durationMs : null };
+  }
+}
+function semanticAgentPreview(name, status, outcome) {
+  const normalized = name.toLocaleLowerCase();
+  if (status === "error") return outcome.preview;
+  if (/^(?:agent|task)$|spawn.?agent/.test(normalized) && outcome.preview) return "Agent is working in the background.";
+  if (/send.?message|followup.?task/.test(normalized) && outcome.preview) {
+    return /resumed from transcript|resumedAgentId/i.test(outcome.preview) ? "Agent resumed in the background." : "Message delivered.";
+  }
+  return outcome.preview;
+}
+function verificationCommand(command) {
+  let shell = "";
+  let quote = "";
+  let escaped = false;
+  for (const char of command) {
+    if (escaped) {
+      escaped = false;
+      shell += quote ? " " : char;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      shell += quote ? " " : char;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = "";
+      shell += " ";
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      shell += " ";
+      continue;
+    }
+    shell += char;
+  }
+  return /(?:^|[;&|]\s*)(?:(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|typecheck|lint|build)|cargo\s+(?:test|clippy|build|check|fmt)|npx\s+(?:vitest|tsc|eslint|playwright)|pytest\b|go\s+test\b)/i.test(shell);
+}
+function classifyTool(name, command) {
+  const normalized = name.toLocaleLowerCase();
+  if (/write_stdin|^wait$/.test(normalized)) return "command";
+  if (/update.?plan|todo|checklist|taskcreate|taskupdate|create.?goal|update.?goal/.test(normalized)) return "plan";
+  if (/search.?replace|edit|write|patch|replace|create_file|apply_patch/.test(normalized)) return "edit";
+  if (/read|view|open_file|list_dir/.test(normalized)) return "read";
+  if (/web.?search|web.?fetch|fetch.?url/.test(normalized)) return "web";
+  if (/search|find|grep|glob|toolsearch/.test(normalized)) return "search";
+  if (/browser|web|fetch|url/.test(normalized)) return "web";
+  if (/agent|subagent|send.?message|delegate|followup.?task|taskstop|taskoutput|^task$/.test(normalized)) return "agent";
+  if (/test|typecheck|lint|build/.test(normalized)) return "test";
+  if (/terminal|bash|shell|command|exec|write_stdin|^wait$/.test(normalized)) return verificationCommand(command) ? "test" : "command";
+  return "other";
+}
+function toolAction(status, category, name, tools) {
+  const position = status === "pending" ? 0 : status === "error" ? 2 : 1;
+  if (tools.length > 1) return [`Running ${tools.length} actions`, `Ran ${tools.length} actions`, `${tools.length} actions failed`][position];
+  const normalized = name.toLocaleLowerCase();
+  if (/send.?message|followup.?task/.test(normalized)) return ["Messaging agent", "Messaged agent", "Agent message failed"][position];
+  if (/taskstop|interrupt.?agent|kill_command_or_subagent/.test(normalized)) return ["Stopping agent", "Stopped agent", "Stop failed"][position];
+  if (/list.?agents|taskoutput|wait.?agent/.test(normalized)) return ["Checking agents", "Checked agents", "Agent check failed"][position];
+  if (/get_command_or_subagent_output|write_stdin|^wait$/.test(normalized)) return ["Waiting for", "Checked", "Check failed"][position];
+  if (/web.?search/.test(normalized)) return ["Searching web", "Searched web", "Web search failed"][position];
+  if (/web.?fetch|fetch.?url/.test(normalized)) return ["Fetching page", "Fetched page", "Page fetch failed"][position];
+  if (/^skill$|use.?skill|load.?skill/.test(normalized)) return ["Loading skill", "Loaded skill", "Skill load failed"][position];
+  if (/taskcreate/.test(normalized)) return ["Adding task", "Added task", "Task creation failed"][position];
+  if (/taskupdate/.test(normalized)) return ["Updating task", "Updated task", "Task update failed"][position];
+  if (/create.?goal/.test(normalized)) return ["Creating goal", "Created goal", "Goal creation failed"][position];
+  if (/update.?goal/.test(normalized)) return ["Updating goal", "Updated goal", "Goal update failed"][position];
+  const actions = {
+    read: ["Reading", "Read", "Read failed"],
+    search: ["Searching", "Searched", "Search failed"],
+    edit: ["Editing", "Edited", "Edit failed"],
+    command: ["Running command", "Ran command", "Command failed"],
+    test: ["Running tests", "Ran tests", "Tests failed"],
+    web: ["Browsing", "Browsed", "Browser action failed"],
+    agent: ["Starting agent", "Started agent", "Agent failed"],
+    plan: ["Updating plan", "Updated plan", "Plan update failed"]
+  };
+  return actions[category]?.[position] ?? (status === "error" ? `${name} failed` : name.replaceAll(/[_-]+/g, " "));
+}
+function createToolPresentation(entry) {
+  const envelope = toolEnvelope(entry);
+  const args = envelope.args;
+  const outcome = toolResultEnvelope(entry.resultText);
+  const patchSource = assignedString(envelope.source, ["patch"]) || envelope.source;
+  const command = firstString(args, ["command", "cmd"]) || sourceString(envelope.callSource, ["command", "cmd"]);
+  const category = classifyTool(envelope.name, command || envelope.source || entry.arguments || "");
+  const path = firstString(args, ["file_path", "target_file", "target_directory", "path"]) || sourceString(envelope.callSource, ["file_path", "target_file", "target_directory", "path"]) || patchPath(patchSource);
+  const query = firstString(args, ["query", "pattern"]) || sourceString(envelope.callSource, ["query", "pattern", "q"]);
+  const url = firstString(args, ["url"]) || sourceString(envelope.callSource, ["url", "ref_id"]);
+  const subject = firstString(args, ["subject", "description", "summary", "task", "objective", "prompt"]) || sourceString(envelope.callSource, ["subject", "description", "summary", "task", "objective", "prompt"]);
+  const agentTarget = category === "agent" ? firstString(record(outcome.value), ["command", "name"]) || firstString(args, ["target", "task_name", "taskId", "task_id", "agentId", "agent_id", "resume", "team_name"]) || sourceString(envelope.callSource, ["target", "task_name", "taskId", "task_id", "agentId", "agent_id", "resume", "team_name"]) : "";
+  const skillTarget = /^skill$|use.?skill|load.?skill/i.test(envelope.name) ? firstString(args, ["skill", "name"]) || sourceString(envelope.callSource, ["skill", "name"]) : "";
+  const background = /get_command_or_subagent_output|kill_command_or_subagent/i.test(envelope.name) ? "background task" : /write_stdin|^wait$/i.test(envelope.name) ? "background command" : "";
+  const items = category === "agent" ? agentItems(envelope.name, outcome.preview) : planItems(args);
+  const taskId = firstString(args, ["taskId", "task_id"]);
+  const planTarget = category === "plan" ? items.length ? `${items.length} ${items.length === 1 ? "item" : "items"}` : taskId ? `task ${taskId}` : "" : "";
+  const target = path || command || query || url || subject || agentTarget || skillTarget || background || planTarget || (envelope.tools.length > 1 ? `${envelope.tools.length} coordinated actions` : toolTarget(entry.arguments));
+  const previewSource = category === "edit" ? editPreview(args, outcome.preview, patchSource) : category === "agent" ? semanticAgentPreview(envelope.name, entry.status ?? "completed", outcome) : outcome.preview;
+  const result = record(entry.resultContent);
+  const metadata = record(entry.metadata);
+  const resultMetadata = record(result?.metadata);
+  return {
+    name: boundedString(envelope.name, 120),
+    action: boundedString(toolAction(entry.status ?? "completed", category, envelope.name, envelope.tools), 120),
+    category,
+    detail: toolDetail(category),
+    target: boundedString(target, 300),
+    command: boundedString(command, MAX_TOOL_FIELD_CHARS),
+    path: boundedString(path, MAX_TOOL_FIELD_CHARS),
+    query: boundedString(query, MAX_TOOL_FIELD_CHARS),
+    url: boundedString(url, MAX_TOOL_FIELD_CHARS),
+    subject: boundedString(subject, MAX_TOOL_FIELD_CHARS),
+    preview: boundedString(previewSource, MAX_TOOL_PREVIEW_CHARS),
+    fields: usefulToolFields(args),
+    items,
+    tools: envelope.tools,
+    exitCode: explicitNumber([outcome.value, result, resultMetadata, metadata], ["exit_code", "exitCode", "pi_bash_exit_code"]),
+    durationMs: explicitNumber([outcome.value, result, resultMetadata, metadata], ["duration_ms", "durationMs", "elapsed_ms", "elapsedMs", "totalDurationMs"]) ?? outcome.durationMs,
+    additions: explicitNumber([result, resultMetadata, metadata], ["additions", "lines_added"]),
+    deletions: explicitNumber([result, resultMetadata, metadata], ["deletions", "lines_removed"]),
+    matches: explicitNumber([result, resultMetadata, metadata], ["matches", "match_count", "result_count"])
+  };
+}
+function readToolPresentation(value, entry) {
+  const generated = createToolPresentation(entry);
+  const item = record(value);
+  if (!item) return generated;
+  const fields = Array.isArray(item.fields) ? item.fields.flatMap((raw) => {
+    const field = record(raw);
+    return field && typeof field.label === "string" && typeof field.value === "string" ? [{ label: boundedString(field.label, 80), value: boundedString(field.value, MAX_TOOL_FIELD_CHARS) }] : [];
+  }).slice(0, MAX_TOOL_FIELDS) : generated.fields;
+  const items = Array.isArray(item.items) ? item.items.flatMap((raw) => {
+    const planItem = record(raw);
+    return planItem && typeof planItem.label === "string" ? [{ label: boundedString(planItem.label, 300), status: boundedString(planItem.status, 40) }] : [];
+  }).slice(0, 12) : generated.items;
+  const tools = Array.isArray(item.tools) ? item.tools.filter((tool) => typeof tool === "string").map((tool) => boundedString(tool, 120)).slice(0, 8) : generated.tools;
+  return {
+    name: boundedString(item.name, 120) || generated.name,
+    action: boundedString(item.action, 120) || generated.action,
+    category: TOOL_CATEGORIES.has(item.category) ? item.category : generated.category,
+    detail: TOOL_DETAILS.has(item.detail) ? item.detail : generated.detail,
+    target: boundedString(item.target, 300) || generated.target,
+    command: boundedString(item.command, MAX_TOOL_FIELD_CHARS) || generated.command,
+    path: boundedString(item.path, MAX_TOOL_FIELD_CHARS) || generated.path,
+    query: boundedString(item.query, MAX_TOOL_FIELD_CHARS) || generated.query,
+    url: boundedString(item.url, MAX_TOOL_FIELD_CHARS) || generated.url,
+    subject: boundedString(item.subject, MAX_TOOL_FIELD_CHARS) || generated.subject,
+    preview: boundedString(item.preview, MAX_TOOL_PREVIEW_CHARS) || generated.preview,
+    fields,
+    items,
+    tools,
+    exitCode: nullableNumber(item.exitCode) ?? generated.exitCode,
+    durationMs: nullableNumber(item.durationMs) ?? generated.durationMs,
+    additions: nullableNumber(item.additions) ?? generated.additions,
+    deletions: nullableNumber(item.deletions) ?? generated.deletions,
+    matches: nullableNumber(item.matches) ?? generated.matches
+  };
+}
+var OPAQUE_RAW_CHARS = 4e3;
+function opaqueEntry(item) {
+  const previouslyOpaque = item.role === "opaque";
+  let raw;
+  if (previouslyOpaque && typeof item.raw === "string") {
+    raw = item.raw;
+  } else {
+    try {
+      raw = JSON.stringify(item, null, 2) ?? "";
+    } catch {
+      raw = "[unserializable entry payload]";
+    }
+  }
+  const kind = previouslyOpaque && typeof item.kind === "string" ? item.kind : typeof item.role === "string" ? item.role : "";
+  return {
+    id: item.id,
+    role: "opaque",
+    kind: boundedString(kind, 120) || "unknown",
+    text: typeof item.text === "string" ? boundedString(item.text, OPAQUE_RAW_CHARS) : "",
+    ts: nullableNumber(item.ts),
+    truncated: item.truncated === true || raw.length > OPAQUE_RAW_CHARS,
+    raw: boundedString(raw, OPAQUE_RAW_CHARS)
+  };
+}
+function readTranscript(value) {
+  if (!Array.isArray(value)) return [];
+  const result = [];
+  for (const candidate of value) {
+    const item = record(candidate);
+    if (!item || typeof item.id !== "string") continue;
+    if (typeof item.text !== "string" || !ROLES.has(item.role)) {
+      result.push(opaqueEntry(item));
+      continue;
+    }
+    const entry = {
+      id: item.id,
+      role: item.role,
+      text: item.text,
+      ts: nullableNumber(item.ts),
+      truncated: item.truncated === true,
+      ...Number.isSafeInteger(item.messageIndex) && item.messageIndex > 0 ? { messageIndex: item.messageIndex } : {}
+    };
+    for (const key of ["label", "arguments", "resultText", "code"]) {
+      if (typeof item[key] === "string") entry[key] = item[key];
+    }
+    if (["pending", "completed", "error"].includes(item.status)) entry.status = item.status;
+    if (item.role === "tool") entry.presentation = readToolPresentation(item.presentation, entry);
+    if (typeof item.streaming === "boolean") entry.streaming = item.streaming;
+    if (Array.isArray(item.context)) {
+      entry.context = item.context.flatMap((raw) => {
+        const context = record(raw);
+        return context && typeof context.label === "string" && typeof context.detail === "string" ? [{
+          ...typeof context.id === "string" ? { id: context.id } : {},
+          ...typeof context.kind === "string" ? { kind: context.kind } : {},
+          label: context.label,
+          detail: context.detail
+        }] : [];
+      });
+    }
+    if (Array.isArray(item.images)) {
+      entry.images = item.images.flatMap((raw) => {
+        const image = record(raw);
+        return image && typeof image.label === "string" ? [{
+          ...typeof image.id === "string" ? { id: image.id } : {},
+          label: image.label,
+          ...typeof image.url === "string" ? { url: image.url } : {},
+          ...typeof image.reference === "string" && image.reference.length <= 4e3 ? { reference: image.reference } : {},
+          ...typeof image.mediaType === "string" && image.mediaType.startsWith("image/") && image.mediaType.length <= 100 ? { mediaType: image.mediaType } : {},
+          ...Number.isSafeInteger(image.byteSize) && image.byteSize >= 0 ? { byteSize: image.byteSize } : {}
+        }] : [];
+      }).slice(0, 4);
+    }
+    const request = record(item.request);
+    if (request && typeof request.requestKind === "string" && typeof request.payloadText === "string") {
+      entry.request = {
+        requestId: request.requestId,
+        requestKind: request.requestKind,
+        payloadText: request.payloadText,
+        options: Array.isArray(request.options) ? request.options.flatMap((raw) => {
+          const option = record(raw);
+          return option && typeof option.optionId === "string" && typeof option.name === "string" ? [{ optionId: option.optionId, name: option.name, kind: string(option.kind, "other") }] : [];
+        }) : [],
+        cancellable: request.cancellable === true,
+        status: request.status === "responded" ? "responded" : "pending",
+        resolution: record(request.resolution)
+      };
+    }
+    result.push(entry);
+  }
+  return result;
+}
+function readParticipant(value) {
+  const participant = record(value);
+  if (!participant) return { kind: "local-user", label: null, origin: null };
+  return {
+    kind: ["local-user", "foreign", "unknown"].includes(participant.kind) ? participant.kind : "unknown",
+    label: typeof participant.label === "string" && participant.label ? boundedString(participant.label, 200) : null,
+    origin: typeof participant.origin === "string" && participant.origin ? boundedString(participant.origin, 100) : null
+  };
+}
+function readWorkspaceRef(value, fallbackPath = "") {
+  const ref = record(value);
+  if (ref && ["repo", "none", "channel"].includes(ref.kind)) {
+    return {
+      kind: ref.kind,
+      value: ref.kind === "none" ? null : typeof ref.value === "string" && ref.value ? boundedString(ref.value, 500) : null
+    };
+  }
+  return fallbackPath ? { kind: "repo", value: boundedString(fallbackPath, 500) } : { kind: "none", value: null };
+}
+function readMirror(value) {
+  const mirror = record(value);
+  if (!mirror || typeof mirror.canonicalHarness !== "string" || !mirror.canonicalHarness) return null;
+  return {
+    canonicalHarness: boundedString(mirror.canonicalHarness, 100),
+    canonicalKey: typeof mirror.canonicalKey === "string" && mirror.canonicalKey ? boundedString(mirror.canonicalKey, 300) : null,
+    bounded: mirror.bounded === true,
+    truncated: mirror.truncated === true,
+    origin: typeof mirror.origin === "string" && mirror.origin ? boundedString(mirror.origin, 200) : null
+  };
+}
+function readHolder(value) {
+  const holder = record(value);
+  if (!holder) return null;
+  const surface = typeof holder.surface === "string" && holder.surface ? boundedString(holder.surface, 100) : null;
+  return {
+    surface,
+    canTakeOver: holder.canTakeOver === true && surface !== null && surface !== "supercode"
+  };
+}
+var TRIGGER_KINDS = ["human", "channel", "cron", "heartbeat", "webhook", "parent", "api", "unknown"];
+function readTrigger(value) {
+  const trigger = record(value);
+  if (!trigger) return null;
+  const kind = trigger.kind === "manual" ? "human" : trigger.kind;
+  return {
+    kind: TRIGGER_KINDS.includes(kind) ? kind : "unknown",
+    label: typeof trigger.label === "string" && trigger.label ? boundedString(trigger.label, 200) : null,
+    surface: typeof trigger.surface === "string" && trigger.surface ? boundedString(trigger.surface, 300) : null
+  };
+}
+function readCrossSurface(value) {
+  const moved = record(value);
+  if (!moved || typeof moved.state !== "string" || !moved.state) return null;
+  return {
+    state: boundedString(moved.state, 100),
+    platform: typeof moved.platform === "string" && moved.platform ? boundedString(moved.platform, 100) : null,
+    error: typeof moved.error === "string" && moved.error ? boundedString(moved.error, 500) : null
+  };
+}
+function readRecurring(value) {
+  const recurring = record(value);
+  if (!recurring || typeof recurring.groupKey !== "string" || !recurring.groupKey) return null;
+  const runs = Number.isSafeInteger(recurring.runs) && recurring.runs > 0 ? recurring.runs : 1;
+  return {
+    groupKey: boundedString(recurring.groupKey, 300),
+    runs,
+    lastStatus: ["ok", "failed", "mixed"].includes(recurring.lastStatus) ? recurring.lastStatus : null
+  };
+}
+function readSessions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((raw) => {
+    const row = record(raw);
+    if (!row || typeof row.key !== "string" || typeof row.harness !== "string") return [];
+    return [{
+      key: row.key,
+      harness: row.harness,
+      name: string(row.name),
+      cwd: string(row.cwd),
+      title: string(row.title),
+      preview: string(row.preview),
+      age: string(row.age),
+      previewUpdatedAt: nullableNumber(row.previewUpdatedAt),
+      updatedAt: nullableNumber(row.updatedAt),
+      messages: nullableNumber(row.messages),
+      active: row.active === true,
+      writable: row.writable === true,
+      live: row.live === true,
+      runtimeStatus: row.runtimeStatus === "running" || row.runtimeStatus === "busy" || row.runtimeStatus === "idle" ? row.runtimeStatus : null,
+      ...Number.isSafeInteger(row.subagentCount) && row.subagentCount > 0 ? { subagentCount: row.subagentCount } : {},
+      activity: ACTIVITY_PRIORITY[row.activity] !== void 0 ? row.activity : void 0,
+      ...row.participant !== void 0 ? { participant: readParticipant(row.participant) } : {},
+      workspaceRef: readWorkspaceRef(row.workspaceRef, string(row.cwd)),
+      ...readMirror(row.mirror) ? { mirror: readMirror(row.mirror) } : {},
+      ...readTrigger(row.trigger) ? { trigger: readTrigger(row.trigger) } : {},
+      ...readRecurring(row.recurring) ? { recurring: readRecurring(row.recurring) } : {},
+      ...readCrossSurface(row.crossSurface) ? { crossSurface: readCrossSurface(row.crossSurface) } : {}
+    }];
+  });
+}
+function readSubagentInspector(value) {
+  const inspector = record(value);
+  if (!inspector || typeof inspector.parentKey !== "string" || !inspector.parentKey) return null;
+  return {
+    parentKey: inspector.parentKey,
+    parentTitle: boundedString(string(inspector.parentTitle), 500),
+    status: ["loading", "ready", "error"].includes(inspector.status) ? inspector.status : "loading",
+    items: readSessions(inspector.items).slice(0, 100),
+    selectedKey: typeof inspector.selectedKey === "string" && inspector.selectedKey ? inspector.selectedKey : null,
+    transcript: readTranscript(inspector.transcript).slice(-120),
+    error: typeof inspector.error === "string" ? boundedString(inspector.error) : null
+  };
+}
+function readAttached(value) {
+  const item = record(value);
+  if (!item || typeof item.harness !== "string") return null;
+  return { key: string(item.key), harness: item.harness, name: string(item.name), cwd: string(item.cwd), title: string(item.title) };
+}
+function readTaskPlan(value) {
+  const plan = record(value);
+  if (!plan) return { ...EMPTY_UI_STATE.taskPlan, items: [] };
+  return {
+    source: ["codex-update-plan", "claude-tasks", "opencode-todos"].includes(plan.source) ? plan.source : "none",
+    items: Array.isArray(plan.items) ? plan.items.flatMap((raw) => {
+      const item = record(raw);
+      if (!item || typeof item.id !== "string" || typeof item.title !== "string") return [];
+      return [{
+        id: item.id,
+        title: item.title,
+        status: ["pending", "in_progress", "completed", "cancelled", "unknown"].includes(item.status) ? item.status : "unknown",
+        ...typeof item.nativeStatus === "string" ? { nativeStatus: item.nativeStatus } : {},
+        ...Array.isArray(item.blockedBy) ? { blockedBy: item.blockedBy.filter((value2) => typeof value2 === "string") } : {}
+      }];
+    }) : [],
+    residueCount: number(plan.residueCount),
+    observedAt: nullableNumber(plan.observedAt)
+  };
+}
+function readSemantics(value) {
+  const semantics = record(value);
+  if (!semantics) return { ...EMPTY_UI_STATE.semantics, residue: [], subagents: [] };
+  return {
+    fidelity: FIDELITY.has(semantics.fidelity) ? semantics.fidelity : null,
+    residue: Array.isArray(semantics.residue) ? semantics.residue.filter((item) => typeof item === "string") : [],
+    residueCount: number(semantics.residueCount),
+    parseErrors: number(semantics.parseErrors),
+    rawRecords: number(semantics.rawRecords),
+    subagents: Array.isArray(semantics.subagents) ? semantics.subagents.flatMap((raw) => {
+      const child = record(raw);
+      if (!child || typeof child.id !== "string" || typeof child.source !== "string") return [];
+      return [{ id: child.id, source: child.source, model: typeof child.model === "string" ? child.model : null, messages: number(child.messages), fidelity: FIDELITY.has(child.fidelity) ? child.fidelity : "semantic" }];
+    }) : []
+  };
+}
+function readTerminalHandoff(value) {
+  const handoff = record(value);
+  if (!handoff || typeof handoff.program !== "string" || !handoff.program.trim() || !Array.isArray(handoff.arguments) || !handoff.arguments.every((argument) => typeof argument === "string") || typeof handoff.cwd !== "string") return null;
+  return { program: handoff.program, arguments: [...handoff.arguments], cwd: handoff.cwd };
+}
+function readExportReceipt(value) {
+  const receipt = record(value);
+  if (!receipt || typeof receipt.targetHarness !== "string" || !["byte_lossless", "value_lossless", "semantic"].includes(receipt.fidelity) || typeof receipt.path !== "string" || !receipt.path.trim() || !Number.isInteger(receipt.files) || receipt.files < 1 || !Number.isInteger(receipt.residueCount) || receipt.residueCount < 0) return null;
+  return {
+    targetHarness: receipt.targetHarness,
+    fidelity: receipt.fidelity,
+    path: receipt.path,
+    files: receipt.files,
+    residueCount: receipt.residueCount
+  };
+}
+function readReductionReceipt(value) {
+  const receipt = record(value);
+  if (!receipt || typeof receipt.sourceTokens !== "number" || !Number.isFinite(receipt.sourceTokens) || typeof receipt.reducedTokens !== "number" || !Number.isFinite(receipt.reducedTokens) || receipt.sourceTokens <= receipt.reducedTokens || receipt.reducedTokens < 0 || typeof receipt.ratio !== "number" || !Number.isFinite(receipt.ratio) || receipt.ratio <= 1 || typeof receipt.sidecarId !== "string" || !receipt.sidecarId.trim() || receipt.verified !== true || receipt.reversible !== true || typeof receipt.targetHarness !== "string" || !receipt.targetHarness.trim()) return null;
+  return {
+    sourceTokens: receipt.sourceTokens,
+    reducedTokens: receipt.reducedTokens,
+    ratio: receipt.ratio,
+    sidecarId: receipt.sidecarId,
+    verified: true,
+    reversible: true,
+    targetHarness: receipt.targetHarness
+  };
+}
+function readInteropSettings(value) {
+  const report = record(value);
+  if (report?.schema !== "supercode.harness-interop-settings.v1" || typeof report.harness !== "string" || typeof report.revision !== "string" || !Array.isArray(report.controls) || !Array.isArray(report.advisories)) return null;
+  const controls = report.controls.slice(0, 20).flatMap((raw) => {
+    const control = record(raw);
+    if (!control || typeof control.key !== "string" || typeof control.label !== "string") return [];
+    return [{
+      key: boundedString(control.key, 200),
+      nativeKey: boundedString(control.native_key ?? control.nativeKey, 200),
+      label: boundedString(control.label, 300),
+      description: boundedString(control.description),
+      scope: ["user", "project", "managed", "command_line"].includes(control.scope) ? control.scope : "user",
+      sourcePath: boundedString(control.source_path ?? control.sourcePath, 4e3),
+      configuredValue: typeof (control.configured_value ?? control.configuredValue) === "string" ? boundedString(control.configured_value ?? control.configuredValue, 500) : null,
+      effectiveValue: typeof (control.effective_value ?? control.effectiveValue) === "string" ? boundedString(control.effective_value ?? control.effectiveValue, 500) : null,
+      effectiveKnown: (control.effective_known ?? control.effectiveKnown) === true,
+      effectiveNote: boundedString(control.effective_note ?? control.effectiveNote),
+      choices: Array.isArray(control.choices) ? control.choices.slice(0, 20).flatMap((candidate) => {
+        const choice = record(candidate);
+        return choice && typeof choice.value === "string" && typeof choice.label === "string" ? [{
+          value: boundedString(choice.value, 500),
+          label: boundedString(choice.label, 300),
+          description: boundedString(choice.description),
+          ...typeof choice.risk === "string" ? { risk: boundedString(choice.risk) } : {}
+        }] : [];
+      }) : [],
+      writable: control.writable === true,
+      resettable: control.resettable === true,
+      requiresRestart: (control.requires_restart ?? control.requiresRestart) === true
+    }];
+  });
+  const advisories = report.advisories.slice(0, 20).flatMap((raw) => {
+    const advisory = record(raw);
+    const recommendation = record(advisory?.recommendation);
+    const change = record(recommendation?.change);
+    if (!advisory || !recommendation || !change || typeof advisory.code !== "string" || typeof advisory.title !== "string" || typeof advisory.setting !== "string" || typeof change.key !== "string") return [];
+    return [{
+      code: boundedString(advisory.code, 200),
+      severity: ["info", "warning", "error"].includes(advisory.severity) ? advisory.severity : "warning",
+      title: boundedString(advisory.title, 500),
+      message: boundedString(advisory.message),
+      setting: boundedString(advisory.setting, 200),
+      recommendation: {
+        label: boundedString(recommendation.label, 500),
+        description: boundedString(recommendation.description),
+        consequence: boundedString(recommendation.consequence),
+        change: {
+          key: boundedString(change.key, 200),
+          value: typeof change.value === "string" ? boundedString(change.value, 500) : null
+        },
+        command: boundedString(recommendation.command, 4e3)
+      }
+    }];
+  });
+  return {
+    schema: "supercode.harness-interop-settings.v1",
+    harness: report.harness,
+    revision: boundedString(report.revision, 500),
+    controls,
+    advisories
+  };
+}
+function normalizeUiState(value) {
+  const raw = record(value) ?? {};
+  const pill = record(raw.pill);
+  const history = record(raw.history);
+  const attachError = record(raw.attachError);
+  const canResume = raw.canResume === true;
+  const continuationModes = Array.isArray(raw.continuationModes) ? [...new Set(raw.continuationModes.filter((mode) => mode === "headless" || mode === "terminal"))] : canResume ? ["headless"] : [];
+  return {
+    pill: { tone: ["live", "warn", "dead"].includes(pill?.tone) ? pill.tone : "off", label: string(pill?.label, "connecting\u2026") },
+    startup: STARTUP.has(raw.startup) ? raw.startup : "connecting",
+    transcript: readTranscript(raw.transcript),
+    busy: raw.busy === true,
+    operation: typeof raw.operation === "string" ? raw.operation : null,
+    needsInput: raw.needsInput === true,
+    harness: string(raw.harness),
+    mode: MODES.has(raw.mode) ? raw.mode : "none",
+    strategy: STRATEGIES.has(raw.strategy) ? raw.strategy : null,
+    canSend: raw.canSend === true,
+    canSteer: raw.canSteer === true,
+    canResume,
+    supportsResume: raw.supportsResume === true,
+    continuationModes,
+    canBranch: raw.canBranch === true,
+    supportsBranch: raw.supportsBranch === true,
+    canAttach: raw.canAttach === true,
+    supportsAttach: raw.supportsAttach === true,
+    canDetach: raw.canDetach === true,
+    canOpenTerminal: raw.canOpenTerminal === true,
+    canExport: raw.canExport === true,
+    canReduce: raw.canReduce === true,
+    canInterrupt: raw.canInterrupt === true,
+    canRespond: raw.canRespond === true,
+    canConfigureSettings: raw.canConfigureSettings === true,
+    messaging: raw.messaging === "live_peer" ? "live_peer" : null,
+    workspace: string(raw.workspace),
+    workspaceRef: readWorkspaceRef(raw.workspaceRef, string(raw.workspace)),
+    participant: readParticipant(raw.participant),
+    mirror: readMirror(raw.mirror),
+    holder: readHolder(raw.holder),
+    taskPlan: readTaskPlan(raw.taskPlan),
+    semantics: readSemantics(raw.semantics),
+    terminalHandoff: readTerminalHandoff(raw.terminalHandoff),
+    exportBackTarget: typeof raw.exportBackTarget === "string" ? raw.exportBackTarget : null,
+    exportReceipt: readExportReceipt(raw.exportReceipt),
+    reductionReceipt: readReductionReceipt(raw.reductionReceipt),
+    interopSettings: readInteropSettings(raw.interopSettings),
+    interopSettingsError: typeof raw.interopSettingsError === "string" ? boundedString(raw.interopSettingsError) : null,
+    harnessAuthentication: readHarnessAuthentication(raw.harnessAuthentication),
+    error: typeof raw.error === "string" ? raw.error : null,
+    recoverable: raw.recoverable === true,
+    harnesses: Array.isArray(raw.harnesses) ? raw.harnesses.flatMap((candidate) => {
+      const item = record(candidate);
+      if (!item || typeof item.id !== "string") return [];
+      const startable = item.startable === true;
+      const launchModes = Array.isArray(item.launchModes) ? [...new Set(item.launchModes.filter((mode) => mode === "headless" || mode === "terminal"))] : startable ? ["headless"] : [];
+      const preferredLaunchMode = launchModes.includes(item.preferredLaunchMode) ? item.preferredLaunchMode : launchModes.includes("terminal") ? "terminal" : launchModes[0] ?? null;
+      const capabilities = record(item.capabilities);
+      return [{
+        id: item.id,
+        label: string(item.label, harnessDisplayName(item.id)),
+        installed: item.installed === true,
+        startable,
+        reason: typeof item.reason === "string" ? boundedString(item.reason) : null,
+        auth: ["ready", "configured", "required", "unknown"].includes(item.auth) ? item.auth : "unknown",
+        runtime: ["ready", "degraded", "unavailable"].includes(item.runtime) ? item.runtime : startable ? "ready" : "unavailable",
+        protocol: boundedString(item.protocol, 100),
+        repair: typeof item.repair === "string" ? boundedString(item.repair, 4e3) : null,
+        capabilities: {
+          start: capabilities?.start === true,
+          resume: capabilities?.resume === true,
+          attach: capabilities?.attach === true,
+          send: capabilities?.send === true,
+          interrupt: capabilities?.interrupt === true,
+          steer: capabilities?.steer === true,
+          respond: capabilities?.respond === true
+        },
+        launchModes,
+        preferredLaunchMode
+      }];
+    }) : [],
+    history: { sessionLimit: number(history?.sessionLimit), hasMoreSessions: history?.hasMoreSessions === true, transcriptLimit: number(history?.transcriptLimit, 120), hasEarlier: history?.hasEarlier === true },
+    savedDraft: string(raw.savedDraft),
+    attention: Array.isArray(raw.attention) ? raw.attention.flatMap((candidate) => {
+      const item = record(candidate);
+      return item && typeof item.key === "string" && ["unseen", "finished", "failed"].includes(item.kind) ? [{ key: item.key, kind: item.kind, ...typeof item.preview === "string" ? { preview: item.preview } : {}, ...Number.isSafeInteger(item.afterMessages) && item.afterMessages >= 0 ? { afterMessages: item.afterMessages } : {}, ...Number.isSafeInteger(item.unreadCount) && item.unreadCount > 0 ? { unreadCount: item.unreadCount } : {} }] : [];
+    }) : [],
+    sessions: readSessions(raw.sessions),
+    subagentInspector: readSubagentInspector(raw.subagentInspector),
+    attached: readAttached(raw.attached),
+    owned: readAttached(raw.owned),
+    attachError: attachError && typeof attachError.key === "string" && typeof attachError.message === "string" ? { key: attachError.key, message: attachError.message } : null,
+    agentPackage: readAgentPackage(raw.agentPackage),
+    contributions: normalizeContributions(raw.contributions),
+    agentPackageError: typeof raw.agentPackageError === "string" ? boundedString(raw.agentPackageError) : null,
+    agentPackageCapabilityState: readAgentPackageCapabilityState(raw.agentPackageCapabilityState),
+    agentPackageCapabilityError: typeof raw.agentPackageCapabilityError === "string" ? boundedString(raw.agentPackageCapabilityError) : null
+  };
+}
+function harnessDisplayName(id) {
+  return HARNESS_NAMES[id] ?? id;
+}
+function sessionDisplayName(session) {
+  const title = session.title?.trim();
+  return title && title !== session.name ? title : session.name || "Untitled chat";
+}
+function sessionActivity(state, row) {
+  if (row.activity && ACTIVITY_PRIORITY[row.activity] !== void 0) return row.activity;
+  if (state.needsInput && row.active) return "needs-input";
+  if (state.busy && row.active) return "working";
+  if (row.runtimeStatus === "busy") return "working";
+  const attention = state.attention.find((item) => item.key === row.key)?.kind;
+  if (attention) return attention;
+  if (row.runtimeStatus === "running") return "running";
+  if (row.live || row.runtimeStatus === "idle") return "recent";
+  return "idle";
+}
+var ACTIVITY_PRIORITY = Object.freeze({
+  "needs-input": 70,
+  failed: 60,
+  working: 50,
+  unseen: 40,
+  finished: 30,
+  running: 20,
+  recent: 10,
+  idle: 0
+});
+function activityDetail(activity, preview, pill) {
+  if (preview) return preview;
+  if (activity === "needs-input") return "Needs input";
+  if (activity === "failed") return "Run failed";
+  if (activity === "working") return "Working\u2026";
+  if (activity === "finished") return "Finished";
+  if (activity === "unseen") return "New reply";
+  if (activity === "running") return "Session is running";
+  return pill || "Agent chats";
+}
+function projectAgentActivity(value) {
+  const state = normalizeUiState(value);
+  const attentionByKey = new Map(state.attention.map((item) => [item.key, item]));
+  const sessionsByKey = new Map(state.sessions.map((row) => [row.key, row]));
+  const unreadCount = state.attention.reduce((total, item) => total + (item.unreadCount ?? 1), 0);
+  const unreadTone = state.attention.length > 0 && state.attention.every((item) => sessionsByKey.get(item.key)?.writable) ? "attention" : "neutral";
+  const ranked = state.sessions.map((row, index) => {
+    const activity2 = sessionActivity(state, row);
+    return {
+      row,
+      index,
+      activity: activity2,
+      priority: ACTIVITY_PRIORITY[activity2] ?? 0,
+      active: row.active || row.key === state.attached?.key || row.key === state.owned?.key,
+      updatedAt: row.previewUpdatedAt ?? row.updatedAt ?? 0
+    };
+  }).sort((left, right) => right.priority - left.priority || Number(right.active) - Number(left.active) || right.updatedAt - left.updatedAt || left.index - right.index);
+  const selected = ranked[0];
+  const fallback = state.attached ?? state.owned;
+  const harness = selected?.row.harness ?? fallback?.harness ?? state.harness;
+  const activity = selected?.activity ?? (state.needsInput ? "needs-input" : state.busy ? "working" : state.startup === "ready" ? "idle" : "recent");
+  const attention = selected ? attentionByKey.get(selected.row.key) : null;
+  const preview = selected?.row.preview || attention?.preview || "";
+  return {
+    harness,
+    sessionKey: selected?.row.key ?? fallback?.key ?? null,
+    title: selected ? sessionDisplayName(selected.row) : fallback ? sessionDisplayName(fallback) : "Agent chats",
+    detail: activityDetail(activity, preview, state.pill.label),
+    activity,
+    unreadCount,
+    unreadTone
+  };
+}
+function filterSessions(rows, query) {
+  const needle = query.trim().toLocaleLowerCase();
+  if (!needle) return [...rows];
+  return rows.filter((row) => [row.name, row.title, row.preview, row.cwd, row.harness, harnessDisplayName(row.harness)].some((value) => typeof value === "string" && value.toLocaleLowerCase().includes(needle)));
+}
+function groupConversation(entries) {
+  const blocks = [];
+  for (const entry of entries) {
+    if (entry.role !== "tool") {
+      blocks.push({ kind: "entry", id: entry.id, entry });
+      continue;
+    }
+    const previous = blocks.at(-1);
+    if (previous?.kind === "activity") previous.entries.push(entry);
+    else blocks.push({ kind: "activity", id: `activity:${entry.id}`, entries: [entry] });
+  }
+  return blocks;
+}
+function toolCategory(entry) {
+  if (TOOL_CATEGORIES.has(entry.presentation?.category)) return entry.presentation.category;
+  const envelope = toolEnvelope(entry);
+  const command = firstString(envelope.args, ["command", "cmd"]) || sourceString(envelope.source, ["command", "cmd"]);
+  return classifyTool(envelope.name, command || envelope.source || entry.arguments || "");
+}
+function toolTarget(argumentsText) {
+  if (!argumentsText) return "";
+  try {
+    const args = JSON.parse(argumentsText);
+    for (const key of ["file_path", "target_file", "path", "command", "cmd", "query", "pattern", "url"]) {
+      if (typeof args?.[key] === "string") return args[key];
+    }
+  } catch {
+    return argumentsText.length > 120 ? `${argumentsText.slice(0, 117)}\u2026` : argumentsText;
+  }
+  return "";
+}
+function compactToolTarget(target, workspace) {
+  const prefix = workspace && !workspace.endsWith("/") ? `${workspace}/` : workspace;
+  return prefix && target.startsWith(prefix) ? target.slice(prefix.length) : target;
+}
+function activitySummary(entries) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) counts.set(toolCategory(entry), (counts.get(toolCategory(entry)) ?? 0) + 1);
+  const failed = entries.filter((entry) => entry.status === "error").length;
+  const pending = entries.filter((entry) => entry.status === "pending").length;
+  if (pending) return `${entries.length} actions in progress`;
+  if (failed) return `${entries.length} actions \xB7 ${failed} failed`;
+  if ([...counts.keys()].every((key) => key === "read" || key === "search")) return `Explored ${entries.length} ${entries.length === 1 ? "item" : "items"}`;
+  const nouns = { read: ["read", "reads"], search: ["search", "searches"], edit: ["edit", "edits"], command: ["command", "commands"], test: ["test run", "test runs"], web: ["web action", "web actions"], agent: ["agent action", "agent actions"], plan: ["plan update", "plan updates"], other: ["action", "actions"] };
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([category, count]) => `${count} ${nouns[category][count === 1 ? 0 : 1]}`).join(" \xB7 ");
+}
+function canContinueHere(state) {
+  if (state.mode !== "mirror" || state.canSend) return false;
+  const row = state.attached?.key ? state.sessions.find((item) => item.key === state.attached.key) : null;
+  return Boolean(row) && state.canResume && row.runtimeStatus !== "running" && row.runtimeStatus !== "busy" && row.runtimeStatus !== "idle";
+}
+function operationLabel(operation) {
+  if (!operation) return "";
+  const labels = { discover: "Refreshing chats\u2026", observe: "Loading recent messages\u2026", attach: "Opening chat\u2026", start: "Starting new chat\u2026", resume: "Continuing here\u2026", join: "Joining live session\u2026", detach: "Detaching to read-only\u2026", branch: "Starting continuation\u2026", reduce: "Reducing context and verifying reversibility\u2026", terminal: "Preparing terminal handoff\u2026", export: "Exporting losslessly\u2026", steer: "Steering agent\u2026", interrupt: "Stopping agent\u2026", respond: "Sending response\u2026", configureHarness: "Updating harness settings\u2026", loadEarlier: "Loading earlier messages\u2026", loadSessions: "Loading more chats\u2026", refresh: "Retrying\u2026" };
+  return labels[operation] ?? `${operation.replaceAll("_", " ")}\u2026`;
+}
+function terminalCommand(handoff) {
+  const quote = (value) => /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+  return [handoff.program, ...handoff.arguments].map(quote).join(" ");
+}
+function isSendKey(event) {
+  return event.key === "Enter" && !event.shiftKey && !event.isComposing;
+}
+
+export {
+  DEFAULT_LABELS,
+  relativeAge,
+  createToolPresentation,
+  normalizeUiState,
+  harnessDisplayName,
+  sessionDisplayName,
+  sessionActivity,
+  projectAgentActivity,
+  filterSessions,
+  groupConversation,
+  toolCategory,
+  compactToolTarget,
+  activitySummary,
+  canContinueHere,
+  operationLabel,
+  terminalCommand,
+  isSendKey
+};