mednotes-opencode 0.1.0

package/.opencode/mednotes/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "medical-notes-workbench",
+  "version": "0.1.0",
+  "description": "Gemini CLI extension packaging for medical notes creation and processing.",
+  "private": true,
+  "engines": {
+    "node": ">=20.17.0"
+  },
+  "dependencies": {
+    "mddb": "^0.9.5"
+  },
+  "overrides": {
+    "sqlite3": "6.0.1"
+  }
+}

package/.opencode/mednotes/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "medical-notes-workbench"
+version = "0.1.0"
+description = "Workbench para criar, enriquecer e processar notas médicas Markdown/Obsidian."
+requires-python = ">=3.11"
+dependencies = [
+  "cryptography>=45",
+  "httpx>=0.27",
+  "keyring>=25,<26",
+  "Pillow>=10.0",
+  "pydantic>=2,<3",
+  "python-statemachine>=3.2,<4",
+  "PyYAML>=6.0",
+]
+
+[project.optional-dependencies]
+pdf = [
+  "pdfplumber>=0.11",
+  "pdf2image>=1.17",
+  "pytesseract>=0.3.10",
+]
+pdf-library = [
+  "PyMuPDF>=1.24,<2",
+  "pytesseract>=0.3.10",
+  "textual>=8.2.5",
+  "textual-image>=0.12.0; python_full_version >= '3.12'",
+]
+dev = [
+  "pytest>=8.0",
+  "pytest-asyncio>=0.23",
+]
+
+[tool.uv]
+required-version = ">=0.11.0"
+
+[project.scripts]
+enricher = "enricher.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

package/.opencode/mednotes/scripts/bootstrap_windows_python_uv.cmd

@@ -0,0 +1,13 @@
+@echo off
+setlocal
+
+set "SCRIPT_DIR=%~dp0"
+set "BOOTSTRAP=%SCRIPT_DIR%bootstrap_windows_python_uv.ps1"
+
+if not exist "%BOOTSTRAP%" (
+  echo Bootstrap script not found: %BOOTSTRAP% 1>&2
+  exit /b 1
+)
+
+powershell -NoProfile -ExecutionPolicy Bypass -File "%BOOTSTRAP%" %*
+exit /b %ERRORLEVEL%

package/.opencode/mednotes/scripts/bootstrap_windows_python_uv.ps1

@@ -0,0 +1,172 @@
+#Requires -Version 5.1
+<#
+.SYNOPSIS
+One-command bootstrap for resetting Windows Python to uv for Medical Notes Workbench.
+
+.DESCRIPTION
+This script is safe to run from an installed extension or through irm/iex. It
+downloads the latest reset script when possible, falls back to the bundled copy,
+and runs a full reset.
+#>
+
+[CmdletBinding()]
+param(
+    [string] $ExtensionRoot,
+    [string] $Branch = "gemini-cli-extension",
+    [switch] $SkipScriptUpdate,
+    [switch] $SkipChecks,
+    [switch] $NoElevate,
+    [switch] $RepairUserVenv,
+    [switch] $ElevateForGlobalPythonReset
+)
+
+$ErrorActionPreference = "Stop"
+
+function Write-Step {
+    param([string] $Message)
+    Write-Host ""
+    Write-Host "==> $Message" -ForegroundColor Cyan
+}
+
+function Test-IsAdmin {
+    $identity = [Security.Principal.WindowsIdentity]::GetCurrent()
+    $principal = New-Object Security.Principal.WindowsPrincipal($identity)
+    return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+}
+
+function Invoke-SelfElevatedIfNeeded {
+    if ($NoElevate -or (Test-IsAdmin)) {
+        return
+    }
+    if ($RepairUserVenv) {
+        Write-Step "Reparando ambiente persistente como usuario atual"
+        return
+    }
+    if (-not $ElevateForGlobalPythonReset) {
+        Write-Step "Executando reparo sem elevacao administrativa"
+        return
+    }
+
+    if (-not $PSCommandPath) {
+        Write-Warning "Nao estou como Administrador e nao consigo auto-elevar script sem arquivo. Continuando mesmo assim."
+        return
+    }
+
+    Write-Step "Reabrindo como Administrador"
+    $arguments = @(
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        "`"$PSCommandPath`"",
+        "-NoElevate"
+    )
+    if ($ExtensionRoot) {
+        $arguments += @("-ExtensionRoot", "`"$ExtensionRoot`"")
+    }
+    if ($Branch) {
+        $arguments += @("-Branch", "`"$Branch`"")
+    }
+    if ($SkipScriptUpdate) {
+        $arguments += "-SkipScriptUpdate"
+    }
+    if ($SkipChecks) {
+        $arguments += "-SkipChecks"
+    }
+    if ($RepairUserVenv) {
+        $arguments += "-RepairUserVenv"
+    }
+    if ($ElevateForGlobalPythonReset) {
+        $arguments += "-ElevateForGlobalPythonReset"
+    }
+
+    Start-Process -FilePath "powershell.exe" -ArgumentList ($arguments -join " ") -Verb RunAs | Out-Null
+    exit 0
+}
+
+function Resolve-ExtensionRoot {
+    if ($ExtensionRoot) {
+        return (Resolve-Path $ExtensionRoot).Path
+    }
+
+    if ($PSScriptRoot) {
+        $candidate = (Resolve-Path (Join-Path $PSScriptRoot "..") -ErrorAction SilentlyContinue)
+        if ($candidate -and (Test-Path (Join-Path $candidate.Path "pyproject.toml"))) {
+            return $candidate.Path
+        }
+    }
+
+    $default = Join-Path $HOME ".gemini\extensions\medical-notes-workbench"
+    if (Test-Path (Join-Path $default "pyproject.toml")) {
+        return $default
+    }
+
+    throw "Nao encontrei a extensao em $default. Instale/atualize medical-notes-workbench primeiro."
+}
+
+function Update-ResetScript {
+    param(
+        [string] $Root,
+        [string] $ResetScript
+    )
+
+    if ($SkipScriptUpdate) {
+        return
+    }
+
+    $url = "https://raw.githubusercontent.com/augustocaruso/medical-notes-workbench/$Branch/scripts/reset_windows_python_uv.ps1"
+    Write-Step "Atualizando reset script"
+    try {
+        [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+        $content = Invoke-WebRequest -Uri $url -UseBasicParsing
+        if (-not $content.Content -or $content.Content -notmatch "param\(") {
+            throw "conteudo remoto inesperado"
+        }
+        New-Item -ItemType Directory -Force (Split-Path -Parent $ResetScript) | Out-Null
+        if (Test-Path $ResetScript) {
+            Copy-Item -LiteralPath $ResetScript -Destination "$ResetScript.bak" -Force
+        }
+        Set-Content -LiteralPath $ResetScript -Value $content.Content -Encoding UTF8
+        Write-Host "Reset script atualizado: $ResetScript"
+    }
+    catch {
+        Write-Warning "Nao consegui atualizar reset script pelo GitHub: $($_.Exception.Message)"
+        if (-not (Test-Path $ResetScript)) {
+            throw "Reset script local tambem nao existe: $ResetScript"
+        }
+        Write-Host "Usando reset script local: $ResetScript"
+    }
+}
+
+if ([Environment]::OSVersion.Platform -ne [PlatformID]::Win32NT) {
+    throw "Este bootstrap e exclusivo para Windows."
+}
+
+Invoke-SelfElevatedIfNeeded
+
+$root = Resolve-ExtensionRoot
+$resetScript = Join-Path $root "scripts\reset_windows_python_uv.ps1"
+
+Update-ResetScript -Root $root -ResetScript $resetScript
+
+$resetParams = @{
+    ExtensionRoot = $root
+}
+if ($ElevateForGlobalPythonReset -and -not $RepairUserVenv) {
+    $resetParams.FullReset = $true
+}
+if ($SkipChecks) {
+    $resetParams.SkipChecks = $true
+}
+
+if ($RepairUserVenv) {
+    Write-Step "Executando reparo do ambiente persistente"
+}
+elseif ($ElevateForGlobalPythonReset) {
+    Write-Step "Executando reset completo"
+}
+else {
+    Write-Step "Executando reparo sem remocao global"
+}
+& $resetScript @resetParams
+exit $LASTEXITCODE

package/.opencode/mednotes/scripts/enrich_notes.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+"""Public CLI alias for the image enrichment workflow.
+
+Thin entrypoint: it only resolves the vendored library path and delegates to
+``enrich.workflow.cli``. The enrichment library lives at the canonical
+``src/enrich`` and is vendored into the extension's ``src/`` dir at build time;
+here we put that dir on ``sys.path`` so the import resolves in the shipped
+extension (and falls through to the editable install in dev).
+See ADR-0001 rule 10 (soft layout).
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_VENDORED_SRC = Path(__file__).resolve().parents[1] / "src"
+if str(_VENDORED_SRC) not in sys.path:
+    sys.path.insert(0, str(_VENDORED_SRC))
+
+from mednotes.domains.wiki.flows.enrich.workflow.cli import main  # noqa: E402
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.opencode/mednotes/scripts/full_reset_windows_python_uv.cmd

@@ -0,0 +1,13 @@
+@echo off
+setlocal
+
+set "SCRIPT_DIR=%~dp0"
+set "BOOTSTRAP_SCRIPT=%SCRIPT_DIR%bootstrap_windows_python_uv.ps1"
+
+if not exist "%BOOTSTRAP_SCRIPT%" (
+  echo Bootstrap script not found: %BOOTSTRAP_SCRIPT% 1>&2
+  exit /b 1
+)
+
+powershell -NoProfile -ExecutionPolicy Bypass -File "%BOOTSTRAP_SCRIPT%" %*
+exit /b %ERRORLEVEL%

package/.opencode/mednotes/scripts/hooks/antigravity_hook_status.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_NAME = "medical-notes-workbench";
+const STATUS_SCHEMA = "medical-notes-workbench.antigravity-hook-status-report.v1";
+const CURRENT_PLUGIN_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const GEMINI_EXTENSION_PATH_TOKEN = "${" + "extensionPath}";
+const GEMINI_EXTENSION_HOME_TOKEN = "~/.gemini/" + "extensions/medical-notes-workbench";
+const GEMINI_EXTENSIONS_COMMAND_TOKEN = "gemini " + "extensions ";
+const STALE_RUNTIME_TOKENS = [
+  GEMINI_EXTENSION_PATH_TOKEN,
+  GEMINI_EXTENSION_HOME_TOKEN,
+  GEMINI_EXTENSIONS_COMMAND_TOKEN,
+];
+const EXPECTED_AGENT_MODELS = new Map([
+  ["med-chat-triager.md", "Gemini 3.5 Flash (High)"],
+  ["med-publish-guard.md", "Gemini 3.5 Flash (High)"],
+  ["med-link-graph-curator.md", "Gemini 3.5 Flash (High)"],
+  ["med-flashcard-maker.md", "Gemini 3.1 Pro (High)"],
+  ["med-knowledge-architect.md", "Gemini 3.1 Pro (High)"],
+]);
+const EXPECTED_MODEL_LABELS = new Set(EXPECTED_AGENT_MODELS.values());
+const HOOK_STATUS_FILE = path.join(appHomeDir(), "antigravity-hooks", "status.json");
+
+function appHomeDir() {
+  return process.env.MEDNOTES_HOME || path.join(os.homedir(), ".mednotes");
+}
+
+function compactPath(value) {
+  const text = String(value || "");
+  if (!text) return "";
+  const home = os.homedir();
+  return text.startsWith(home) ? `~${text.slice(home.length)}` : text;
+}
+
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function hookFileStatus(file) {
+  const data = await readJson(file);
+  const serialized = data ? JSON.stringify(data) : "";
+  return {
+    path: compactPath(file),
+    exists: Boolean(data),
+    antigravity_schema: Boolean(data && !Object.hasOwn(data, "hooks") && serialized.includes("PreToolUse")),
+    has_pre_tool_use: serialized.includes("PreToolUse"),
+    has_post_tool_use: serialized.includes("PostToolUse"),
+    stale_gemini_schema: Boolean(data && Object.hasOwn(data, "hooks")),
+  };
+}
+
+function frontmatterModel(text) {
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return "";
+  const modelLine = match[1].match(/^model:\s*(.+?)\s*$/m);
+  if (!modelLine) return "";
+  return modelLine[1].replace(/^['"]|['"]$/g, "").trim();
+}
+
+async function agentStatus(pluginRoot) {
+  const agentsDir = path.join(pluginRoot, "agents");
+  try {
+    const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+    const files = entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith(".md"))
+      .map((entry) => path.join(agentsDir, entry.name))
+      .sort();
+    const stale_placeholders = [];
+    const models = [];
+    const unexpected_models = [];
+    for (const file of files) {
+      const text = await fs.readFile(file, "utf8");
+      for (const token of STALE_RUNTIME_TOKENS) {
+        if (text.includes(token)) stale_placeholders.push({ path: compactPath(file), token });
+      }
+      const filename = path.basename(file);
+      const model = frontmatterModel(text);
+      const expected = EXPECTED_AGENT_MODELS.get(filename) || "";
+      models.push({ path: compactPath(file), model, expected });
+      if (expected && model !== expected) {
+        unexpected_models.push({ path: compactPath(file), model, expected });
+      }
+    }
+    const model_status = files.length > 0 && unexpected_models.length === 0 ? "ok" : "needs_repair";
+    return {
+      status: files.length > 0 && stale_placeholders.length === 0 && model_status === "ok" ? "ok" : "needs_repair",
+      plugin_root: compactPath(pluginRoot),
+      count: files.length,
+      files: files.map(compactPath),
+      stale_placeholders,
+      model_status,
+      models,
+      unexpected_models,
+    };
+  } catch {
+    return {
+      status: "missing",
+      plugin_root: compactPath(pluginRoot),
+      count: 0,
+      files: [],
+      stale_placeholders: [],
+      model_status: "missing",
+      models: [],
+      unexpected_models: [],
+    };
+  }
+}
+
+async function selectedModelStatus() {
+  const settingsPath = path.join(os.homedir(), ".gemini", "antigravity-cli", "settings.json");
+  const settings = await readJson(settingsPath);
+  const model = typeof settings?.model === "string" ? settings.model : "";
+  return {
+    path: compactPath(settingsPath),
+    status: model ? "selected" : "missing",
+    model,
+    matches_plugin_agent_models: model ? EXPECTED_MODEL_LABELS.has(model) : false,
+  };
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const json = argv.includes("--json");
+  const configHook = path.join(os.homedir(), ".gemini", "config", "plugins", PLUGIN_NAME, "hooks.json");
+  const configNestedHook = path.join(os.homedir(), ".gemini", "config", "plugins", PLUGIN_NAME, "hooks", "hooks.json");
+  const importHook = path.join(os.homedir(), ".gemini", "antigravity-cli", "plugins", PLUGIN_NAME, "hooks.json");
+  const importNestedHook = path.join(
+    os.homedir(),
+    ".gemini",
+    "antigravity-cli",
+    "plugins",
+    PLUGIN_NAME,
+    "hooks",
+    "hooks.json",
+  );
+  const status = await readJson(HOOK_STATUS_FILE);
+  const hook_files = [
+    await hookFileStatus(configHook),
+    await hookFileStatus(configNestedHook),
+    await hookFileStatus(importHook),
+    await hookFileStatus(importNestedHook),
+  ];
+  const agents = await agentStatus(CURRENT_PLUGIN_ROOT);
+  const selected_model = await selectedModelStatus();
+  const installed = hook_files.some((item) => item.exists && item.antigravity_schema);
+  const stale = hook_files.some((item) => item.exists && item.stale_gemini_schema);
+  const invocation_seen = Boolean(status?.last_hook?.mode);
+  const report = {
+    schema: STATUS_SCHEMA,
+    status:
+      installed && invocation_seen && !stale && agents.status === "ok"
+        ? "ok"
+        : installed && !stale && agents.status === "ok"
+          ? "installed_no_invocation_seen"
+          : "needs_repair",
+    hook_files,
+    agents,
+    selected_model,
+    heartbeat: status || null,
+    next_action: invocation_seen
+      ? "Hooks Antigravity foram executados neste ambiente."
+      : "Abra ou reinicie a TUI e execute uma ferramenta simples, por exemplo um comando shell; depois rode este status novamente.",
+  };
+
+  if (json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  if (report.status === "ok") {
+    const last = report.heartbeat.last_hook;
+    process.stdout.write(`Hooks Antigravity: OK\n`);
+    process.stdout.write(`Ultima execucao: ${report.heartbeat.updated_at}\n`);
+    process.stdout.write(`Hook: ${last.mode} (${last.hook_event_name || "evento desconhecido"})\n`);
+    process.stdout.write(`Ferramenta: ${last.tool_name || "desconhecida"}\n`);
+    process.stdout.write(`Plugin root: ${last.plugin_root || "desconhecido"}\n`);
+    process.stdout.write(`Agents: OK (${report.agents.count} arquivos, sem placeholder Gemini antigo)\n`);
+    process.stdout.write(`Agent models: OK (${report.agents.model_status})\n`);
+    process.stdout.write(`Modelo selecionado: ${report.selected_model.model || "nao detectado"}\n`);
+  } else if (report.status === "installed_no_invocation_seen") {
+    process.stdout.write("Hooks Antigravity: instalados, mas nenhuma execucao foi registrada ainda.\n");
+    process.stdout.write(`Agents: OK (${report.agents.count} arquivos, sem placeholder Gemini antigo)\n`);
+    process.stdout.write(`Agent models: OK (${report.agents.model_status})\n`);
+    process.stdout.write(`Modelo selecionado: ${report.selected_model.model || "nao detectado"}\n`);
+    process.stdout.write(`${report.next_action}\n`);
+  } else {
+    process.stdout.write("Hooks Antigravity: precisam de reparo.\n");
+    for (const item of hook_files) {
+      process.stdout.write(
+        `- ${item.path}: ${item.exists ? (item.stale_gemini_schema ? "schema Gemini antigo" : "schema Antigravity") : "ausente"}\n`,
+      );
+    }
+    process.stdout.write(`Agents: ${report.agents.status} (${report.agents.count} arquivos)\n`);
+    for (const item of report.agents.stale_placeholders) {
+      process.stdout.write(`- ${item.path}: placeholder antigo ${item.token}\n`);
+    }
+    for (const item of report.agents.unexpected_models) {
+      process.stdout.write(`- ${item.path}: modelo ${item.model || "ausente"}, esperado ${item.expected}\n`);
+    }
+    process.stdout.write(`Modelo selecionado: ${report.selected_model.model || "nao detectado"}\n`);
+  }
+}
+
+await main();

package/.opencode/mednotes/scripts/hooks/mednotes_hook/adapters/antigravity.mjs

@@ -0,0 +1,169 @@
+import fs from "node:fs/promises";
+
+import { firstObject, firstString, normalizedArgs } from "./harness_payload.mjs";
+
+const TRANSCRIPT_READ_LIMIT_BYTES = 2 * 1024 * 1024;
+
+export function isAntigravityPayload(payload) {
+  return Boolean(
+    payload &&
+      typeof payload === "object" &&
+      (payload.toolCall || payload.hookEventName || payload.conversationId || payload.workspacePaths),
+  );
+}
+
+export function defaultAntigravityHookEventName(mode) {
+  if (mode === "capture-after-tool" || mode === "capture-agent-directive-after-tool") return "PostToolUse";
+  if (mode === "inject-agent-directive-before-agent") return "PreInvocation";
+  if (mode === "validate-agent-directive-after-agent") return "Stop";
+  return "PreToolUse";
+}
+
+export async function normalizePayloadForRuntime(payload, mode) {
+  const raw = payload && typeof payload === "object" ? payload : {};
+  if (!isAntigravityPayload(raw)) return raw;
+  const transcriptStep = await antigravityTranscriptStep(raw);
+  const toolCall = firstObject(raw.toolCall, transcriptStep.toolCall, transcriptStep.tool_call, transcriptStep.toolUse);
+  const args = normalizedArgs(toolCall.args || raw.tool_input || raw.toolInput || raw.parameters || raw.args || {});
+  const toolName = firstString(
+    toolCall.name,
+    raw.tool_name,
+    raw.toolName,
+    raw.name,
+    raw.tool,
+    transcriptStep.tool_name,
+    transcriptStep.toolName,
+  );
+  const cwd = firstString(args.cwd, raw.cwd, Array.isArray(raw.workspacePaths) ? raw.workspacePaths[0] : "");
+  return {
+    ...raw,
+    hook_event_name: raw.hookEventName || raw.hook_event_name || defaultAntigravityHookEventName(mode),
+    session_id: raw.conversationId || raw.session_id || "",
+    transcript_path: raw.transcriptPath || raw.transcript_path || "",
+    artifact_directory_path: raw.artifactDirectoryPath || raw.artifact_directory_path || "",
+    cwd,
+    tool_name: toolName,
+    original_request_name: toolName,
+    tool_input: args,
+    tool_response: normalizedToolResponse(
+      raw.toolResponse,
+      raw.toolResult,
+      raw.response,
+      raw.result,
+      transcriptStep.toolResponse,
+      transcriptStep.toolResult,
+      transcriptStep.response,
+      transcriptStep.result,
+      transcriptStep.output,
+      transcriptStep.content,
+    ),
+    antigravity_payload_seen: true,
+  };
+}
+
+export function renderAntigravityOutput(mode, result, payload) {
+  const output = result && typeof result === "object" ? result : {};
+  if (mode === "capture-after-tool" || mode === "capture-agent-directive-after-tool") return {};
+  const eventName = String(payload?.hook_event_name || "");
+  const context = output?.hookSpecificOutput?.additionalContext;
+  if (eventName === "PreInvocation" && typeof context === "string" && context.trim()) {
+    return {
+      injectSteps: [
+        {
+          ephemeralMessage: context,
+        },
+      ],
+    };
+  }
+  if (eventName === "Stop") {
+    if (output.decision === "deny") {
+      return {
+        decision: "continue",
+        reason: [output.agent_message, output.reason].filter(Boolean).join(" "),
+      };
+    }
+    return {};
+  }
+  if (eventName === "PreToolUse") {
+    if (!output.decision) return { decision: "allow" };
+    const details = [output.blocked_reason, output.directive_field, output.agent_message].filter(Boolean).join(" ");
+    const reason = [output.reason, details].filter(Boolean).join(" ");
+    return {
+      decision: output.decision,
+      ...(reason ? { reason } : {}),
+    };
+  }
+  if (!output.decision || output.decision === "allow") return {};
+  return output;
+}
+
+async function antigravityTranscriptStep(raw) {
+  const transcriptPath = firstString(raw.transcriptPath, raw.transcript_path);
+  if (!transcriptPath) return {};
+  try {
+    const stats = await fs.stat(transcriptPath);
+    if (!stats.isFile() || stats.size > TRANSCRIPT_READ_LIMIT_BYTES) return {};
+    const targetStepIdx = stepIndexFromPayload(raw);
+    const text = await fs.readFile(transcriptPath, "utf8");
+    let fallback = {};
+    for (const line of text.split(/\r?\n/)) {
+      const record = parseJsonLine(line);
+      if (!Object.keys(record).length) continue;
+      if (
+        record.toolCall ||
+        record.toolResponse ||
+        record.toolResult ||
+        record.response ||
+        record.result ||
+        record.output
+      ) {
+        fallback = record;
+      }
+      if (targetStepIdx && stepIndexFromTranscriptRecord(record) === targetStepIdx) return record;
+    }
+    return fallback;
+  } catch {
+    return {};
+  }
+}
+
+function normalizedToolResponse(...values) {
+  for (const value of values) {
+    if (value && typeof value === "object" && !Array.isArray(value)) return value;
+    if (typeof value === "string" && value.trim()) return { returnDisplay: value };
+  }
+  return {};
+}
+
+function stepIndexFromPayload(payload) {
+  return firstString(
+    payload?.stepIdx,
+    payload?.stepIndex,
+    payload?.step_idx,
+    payload?.toolStepIdx,
+    payload?.toolUseStepIdx,
+  );
+}
+
+function stepIndexFromTranscriptRecord(record) {
+  return firstString(
+    record?.stepIdx,
+    record?.stepIndex,
+    record?.step_idx,
+    record?.idx,
+    record?.index,
+    record?.toolStepIdx,
+    record?.toolUseStepIdx,
+  );
+}
+
+function parseJsonLine(line) {
+  const text = String(line || "").trim();
+  if (!text) return {};
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}