grok-telegram-bot 2.3.0 → 2.4.0

package/scripts/smoke-exit-plan.ts

@@ -0,0 +1,274 @@
+/**
+ * Smoke-test plan exit over ACP without touching the running Telegram bot.
+ *
+ * Spawns its OWN `grok agent --no-leader --always-approve stdio` process,
+ * creates a fresh session, enters plan mode, writes a tiny plan, exits plan
+ * mode, and logs every reverse-request + tool result.
+ *
+ * Usage: npx tsx scripts/smoke-exit-plan.ts
+ */
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { autoApproveExitPlanMode, autoSkipAskUserQuestion, isAskUserQuestionMethod, isPlanExitMethod } from "../src/grok/plan-approval.js";
+
+const GROK = process.env.GROK_CLI_PATH?.trim() || join(homedir(), ".grok", "bin", "grok.exe");
+const CWD = process.env.SMOKE_CWD?.trim() || join(homedir(), "AppData", "Local", "Temp", "grok-plan-exit-smoke");
+
+type JsonRpc = {
+  jsonrpc?: string;
+  id?: number | string;
+  method?: string;
+  params?: unknown;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+};
+
+function main(): void {
+  mkdirSync(CWD, { recursive: true });
+  console.log("grok:", GROK);
+  console.log("cwd:", CWD);
+
+  const args = ["agent", "--no-leader", "--always-approve", "stdio"];
+  const proc = spawn(GROK, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: CWD,
+    env: { ...process.env },
+  }) as ChildProcessWithoutNullStreams;
+
+  let buf = "";
+  let nextId = 1;
+  const pending = new Map<number | string, { resolve: (v: unknown) => void; reject: (e: Error) => void; method: string }>();
+  const reverseLog: Array<{ method: string; params: unknown; result: unknown }> = [];
+  const toolEvents: Array<{ title?: string; status?: string; text?: string }> = [];
+  let sessionId = "";
+
+  proc.stderr.setEncoding("utf8");
+  proc.stderr.on("data", (c: string) => {
+    for (const line of c.split(/\r?\n/)) {
+      if (line.trim()) console.log("[stderr]", line.slice(0, 300));
+    }
+  });
+
+  proc.stdout.setEncoding("utf8");
+  proc.stdout.on("data", (chunk: string) => {
+    buf += chunk;
+    let idx: number;
+    while ((idx = buf.indexOf("\n")) !== -1) {
+      const line = buf.slice(0, idx).trim();
+      buf = buf.slice(idx + 1);
+      if (!line) continue;
+      let msg: JsonRpc;
+      try {
+        msg = JSON.parse(line) as JsonRpc;
+      } catch {
+        console.log("[non-json]", line.slice(0, 200));
+        continue;
+      }
+      handleMessage(msg);
+    }
+  });
+
+  function send(msg: object): void {
+    proc.stdin.write(JSON.stringify(msg) + "\n");
+  }
+
+  function request(method: string, params: unknown): Promise<unknown> {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      const t = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`timeout: ${method}`));
+      }, 120_000);
+      pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(t);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(t);
+          reject(e);
+        },
+        method,
+      });
+      send({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+
+  function handleMessage(msg: JsonRpc): void {
+    // Response to our request
+    if (msg.id !== undefined && msg.id !== null && pending.has(msg.id) && !msg.method) {
+      const p = pending.get(msg.id)!;
+      pending.delete(msg.id);
+      if (msg.error) p.reject(new Error(`${p.method}: ${msg.error.message}`));
+      else p.resolve(msg.result);
+      return;
+    }
+    // Reverse request
+    if (msg.id !== undefined && msg.id !== null && msg.method) {
+      const method = msg.method;
+      const params = (msg.params as Record<string, unknown>) || {};
+      console.log("\n<<< REVERSE REQUEST", method);
+      console.log("    params keys:", Object.keys(params));
+      console.log("    params sample:", JSON.stringify(params).slice(0, 500));
+
+      let result: unknown = null;
+      if (isPlanExitMethod(method)) {
+        result = autoApproveExitPlanMode(params);
+        console.log(">>> auto-approve exit:", JSON.stringify(result));
+      } else if (isAskUserQuestionMethod(method)) {
+        result = autoSkipAskUserQuestion(params);
+        console.log(">>> skip question:", JSON.stringify(result));
+      } else if (method === "session/request_permission") {
+        const opts = (params.options as Array<{ optionId: string }>) || [];
+        const first = opts[0]?.optionId;
+        result = first
+          ? { outcome: { outcome: "selected", optionId: first } }
+          : { outcome: { outcome: "cancelled" } };
+        console.log(">>> permission:", JSON.stringify(result));
+      } else {
+        console.log(">>> UNKNOWN reverse method — error method-not-found (same as old bot bug)");
+        send({
+          jsonrpc: "2.0",
+          id: msg.id,
+          error: { code: -32601, message: `unsupported client method: ${method}` },
+        });
+        reverseLog.push({ method, params, result: { error: -32601 } });
+        return;
+      }
+      reverseLog.push({ method, params, result });
+      send({ jsonrpc: "2.0", id: msg.id, result });
+      return;
+    }
+    // Notification
+    if (msg.method === "session/update") {
+      const p = msg.params as { sessionId?: string; update?: Record<string, unknown> };
+      const u = p?.update || {};
+      const kind = String(u.sessionUpdate || "");
+      if (kind === "tool_call" || kind === "tool_call_update") {
+        const title = typeof u.title === "string" ? u.title : undefined;
+        const status = typeof u.status === "string" ? u.status : undefined;
+        let text = "";
+        const content = u.content as unknown;
+        if (Array.isArray(content)) {
+          for (const c of content) {
+            const t = (c as { content?: { text?: string } })?.content?.text;
+            if (t) text += t;
+          }
+        }
+        toolEvents.push({ title, status, text: text.slice(0, 300) });
+        if (title?.toLowerCase().includes("plan") || status === "failed" || status === "completed") {
+          console.log(`[tool] ${kind} title=${title} status=${status} text=${text.slice(0, 200)}`);
+        }
+      }
+    }
+  }
+
+  async function run(): Promise<void> {
+    try {
+      const init = (await request("initialize", {
+        protocolVersion: 1,
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+        clientInfo: { name: "smoke-exit-plan", version: "0.0.1" },
+      })) as { authMethods?: Array<{ id: string }> };
+      console.log("initialized");
+
+      // Authenticate headless if needed
+      const methods = init.authMethods || [];
+      const authId =
+        methods.find((m) => /cached_token|api_key|xai/i.test(m.id))?.id ||
+        methods[0]?.id;
+      if (authId) {
+        try {
+          await request("authenticate", { methodId: authId, _meta: { headless: true } });
+          console.log("authenticated:", authId);
+        } catch (e) {
+          console.warn("auth soft-fail:", (e as Error).message);
+        }
+      }
+
+      const ns = (await request("session/new", { cwd: CWD, mcpServers: [] })) as { sessionId: string };
+      sessionId = ns.sessionId;
+      console.log("session:", sessionId);
+
+      // Force a quick enter+exit plan cycle.
+      const prompt =
+        "You MUST use tools. " +
+        "1) Call enter_plan_mode. " +
+        "2) Write a one-line plan into the plan file with search_replace or write. " +
+        "3) Immediately call exit_plan_mode. " +
+        "4) After exit succeeds, reply with exactly: PLAN_EXIT_OK. " +
+        "Do not do anything else.";
+
+      console.log("prompting…");
+      const result = await request("session/prompt", {
+        sessionId,
+        prompt: [{ type: "text", text: prompt }],
+      });
+      console.log("prompt result:", JSON.stringify(result).slice(0, 300));
+
+      // Find plan_mode.json
+      const enc = encodeURIComponent(CWD);
+      const sessDir = join(homedir(), ".grok", "sessions", enc, sessionId);
+      const planModePath = join(sessDir, "plan_mode.json");
+      console.log("\n=== plan_mode.json ===", planModePath);
+      if (existsSync(planModePath)) {
+        console.log(readFileSync(planModePath, "utf8"));
+      } else {
+        console.log("(missing)");
+      }
+
+      console.log("\n=== reverse requests ===");
+      console.log(JSON.stringify(reverseLog, null, 2));
+
+      console.log("\n=== plan-related tool events ===");
+      for (const t of toolEvents.filter((e) => (e.title || "").toLowerCase().includes("plan") || e.status === "failed")) {
+        console.log(JSON.stringify(t));
+      }
+
+      const exitFailed = toolEvents.some(
+        (e) =>
+          (e.title || "").toLowerCase().includes("exit") &&
+          e.status === "failed",
+      );
+      const exitOk = toolEvents.some(
+        (e) =>
+          (e.title || "").toLowerCase().includes("exit") &&
+          e.status === "completed",
+      );
+      const disconnected = toolEvents.some((e) => (e.text || "").includes("client disconnected"));
+
+      console.log("\n=== VERDICT ===");
+      console.log({ exitOk, exitFailed, disconnected, reverseCount: reverseLog.length });
+
+      writeFileSync(
+        join(CWD, "smoke-exit-plan-report.json"),
+        JSON.stringify({ reverseLog, toolEvents, exitOk, exitFailed, disconnected, sessionId }, null, 2),
+      );
+
+      if (!exitOk || exitFailed || disconnected) {
+        process.exitCode = 2;
+      }
+    } catch (e) {
+      console.error("SMOKE FAILED:", e);
+      process.exitCode = 1;
+    } finally {
+      try {
+        proc.kill();
+      } catch {
+        /* ignore */
+      }
+      setTimeout(() => process.exit(process.exitCode ?? 0), 500);
+    }
+  }
+
+  proc.on("error", (e) => {
+    console.error("spawn error", e);
+    process.exit(1);
+  });
+
+  void run();
+}
+
+main();

package/scripts/smoke-exit-shapes.ts

@@ -0,0 +1,252 @@
+/**
+ * Try multiple ExitPlanMode reverse-response shapes until plan mode goes Inactive
+ * or tool output says approved / implement.
+ *
+ * Does NOT touch the running Telegram bot.
+ */
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const GROK = process.env.GROK_CLI_PATH?.trim() || join(homedir(), ".grok", "bin", "grok.exe");
+const BASE = join(homedir(), "AppData", "Local", "Temp", "grok-plan-exit-shapes");
+
+type JsonRpc = {
+  id?: number | string;
+  method?: string;
+  params?: unknown;
+  result?: unknown;
+  error?: { code: number; message: string };
+};
+
+const SHAPES: Array<{ name: string; body: unknown }> = [
+  { name: "decision_approved", body: { decision: "approved", additional_feedback: "" } },
+  { name: "action_approved", body: { action: "approved", feedback: "" } },
+  { name: "outcome_approved", body: { outcome: "approved", feedback: "" } },
+  { name: "result_approved", body: { result: "approved" } },
+  { name: "approved_true", body: { approved: true, feedback: "" } },
+  { name: "ext_approved_null", body: { approved: null } },
+  { name: "ext_Approved_null", body: { Approved: null } },
+  { name: "ext_approved_obj", body: { approved: { feedback: "" } } },
+  { name: "ext_Approved_obj", body: { Approved: { additional_feedback: "" } } },
+  { name: "choice_approve", body: { choice: "approve" } },
+  { name: "choice_a", body: { choice: "a" } },
+  { name: "option_approve", body: { option: "approve", optionId: "approve" } },
+  { name: "status_approved", body: { status: "approved" } },
+  { name: "type_approved", body: { type: "approved", feedback: "" } },
+  { name: "kind_approved", body: { kind: "approved" } },
+  { name: "verdict_approved", body: { verdict: "approved", comments: "" } },
+  { name: "perm_style", body: { outcome: { outcome: "selected", optionId: "approve" } } },
+  { name: "string_approved", body: "approved" },
+  { name: "array_approved", body: ["approved", ""] },
+  { name: "empty", body: {} },
+];
+
+async function tryShape(shape: { name: string; body: unknown }): Promise<{
+  name: string;
+  planState?: string;
+  awaiting?: boolean;
+  toolText: string[];
+  reverseOk: boolean;
+}> {
+  const CWD = join(BASE, shape.name);
+  mkdirSync(CWD, { recursive: true });
+
+  const proc = spawn(GROK, ["agent", "--no-leader", "--always-approve", "stdio"], {
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: CWD,
+    env: { ...process.env },
+  }) as ChildProcessWithoutNullStreams;
+
+  let buf = "";
+  let nextId = 1;
+  const pending = new Map<number | string, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+  const toolText: string[] = [];
+  let reverseOk = false;
+  let sessionId = "";
+
+  const send = (msg: object) => proc.stdin.write(JSON.stringify(msg) + "\n");
+
+  const request = (method: string, params: unknown) =>
+    new Promise<unknown>((resolve, reject) => {
+      const id = nextId++;
+      const t = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`timeout ${method}`));
+      }, 90_000);
+      pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(t);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(t);
+          reject(e);
+        },
+      });
+      send({ jsonrpc: "2.0", id, method, params });
+    });
+
+  proc.stdout.setEncoding("utf8");
+  proc.stdout.on("data", (chunk: string) => {
+    buf += chunk;
+    let idx: number;
+    while ((idx = buf.indexOf("\n")) !== -1) {
+      const line = buf.slice(0, idx).trim();
+      buf = buf.slice(idx + 1);
+      if (!line) continue;
+      let msg: JsonRpc;
+      try {
+        msg = JSON.parse(line) as JsonRpc;
+      } catch {
+        continue;
+      }
+      if (msg.id !== undefined && msg.id !== null && pending.has(msg.id) && !msg.method) {
+        const p = pending.get(msg.id)!;
+        pending.delete(msg.id);
+        if (msg.error) p.reject(new Error(msg.error.message));
+        else p.resolve(msg.result);
+        return;
+      }
+      if (msg.id !== undefined && msg.id !== null && msg.method) {
+        const method = msg.method;
+        if (method === "_x.ai/exit_plan_mode" || method === "x.ai/exit_plan_mode") {
+          reverseOk = true;
+          send({ jsonrpc: "2.0", id: msg.id, result: shape.body });
+        } else if (method === "session/request_permission") {
+          const opts = ((msg.params as { options?: Array<{ optionId: string }> })?.options) || [];
+          const first = opts[0]?.optionId;
+          send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            result: first
+              ? { outcome: { outcome: "selected", optionId: first } }
+              : { outcome: { outcome: "cancelled" } },
+          });
+        } else if (method.includes("ask_user_question")) {
+          send({ jsonrpc: "2.0", id: msg.id, result: { SkipInterview: null } });
+        } else {
+          send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: { code: -32601, message: `unsupported: ${method}` },
+          });
+        }
+        return;
+      }
+      if (msg.method === "session/update") {
+        const u = (msg.params as { update?: Record<string, unknown> })?.update || {};
+        const kind = String(u.sessionUpdate || "");
+        if (kind === "tool_call_update" || kind === "tool_call") {
+          const content = u.content as unknown;
+          if (Array.isArray(content)) {
+            for (const c of content) {
+              const t = (c as { content?: { text?: string } })?.content?.text;
+              if (t) toolText.push(t.slice(0, 200));
+            }
+          }
+        }
+      }
+    }
+  });
+
+  try {
+    const init = (await request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      clientInfo: { name: "smoke-shapes", version: "0" },
+    })) as { authMethods?: Array<{ id: string }> };
+    const authId =
+      init.authMethods?.find((m) => /cached_token|api_key|xai/i.test(m.id))?.id ||
+      init.authMethods?.[0]?.id;
+    if (authId) {
+      try {
+        await request("authenticate", { methodId: authId, _meta: { headless: true } });
+      } catch {
+        /* soft */
+      }
+    }
+    const ns = (await request("session/new", { cwd: CWD, mcpServers: [] })) as { sessionId: string };
+    sessionId = ns.sessionId;
+
+    await request("session/prompt", {
+      sessionId,
+      prompt: [
+        {
+          type: "text",
+          text:
+            "Use tools only: 1) enter_plan_mode 2) write one line to the plan file 3) exit_plan_mode. " +
+            "After exit, reply PLAN_EXIT_OK. Nothing else.",
+        },
+      ],
+    });
+
+    const sessDir = join(homedir(), ".grok", "sessions", encodeURIComponent(CWD), sessionId);
+    const planModePath = join(sessDir, "plan_mode.json");
+    let planState: string | undefined;
+    let awaiting: boolean | undefined;
+    if (existsSync(planModePath)) {
+      const pm = JSON.parse(readFileSync(planModePath, "utf8")) as {
+        state?: string;
+        awaiting_plan_approval?: boolean;
+      };
+      planState = pm.state;
+      awaiting = pm.awaiting_plan_approval;
+    }
+
+    return { name: shape.name, planState, awaiting, toolText, reverseOk };
+  } finally {
+    try {
+      proc.kill();
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+async function main(): Promise<void> {
+  mkdirSync(BASE, { recursive: true });
+  const results = [];
+  for (const shape of SHAPES) {
+    process.stdout.write(`\n==== trying ${shape.name} ====\n`);
+    try {
+      const r = await tryShape(shape);
+      const joined = r.toolText.join(" | ");
+      const ok =
+        r.planState === "Inactive" ||
+        /approved the plan|Implement the plan|PLAN_EXIT_OK|plan mode has been disabled/i.test(joined);
+      const revise = /revise the plan|request(ed)? changes/i.test(joined);
+      const abandon = /abandon/i.test(joined);
+      const disconnected = /client disconnected/i.test(joined);
+      console.log({
+        name: r.name,
+        planState: r.planState,
+        awaiting: r.awaiting,
+        reverseOk: r.reverseOk,
+        ok,
+        revise,
+        abandon,
+        disconnected,
+        texts: r.toolText.slice(-3),
+      });
+      results.push({ ...r, ok, revise, abandon, disconnected });
+      if (ok) {
+        console.log("\n*** SUCCESS SHAPE ***", shape.name, JSON.stringify(shape.body));
+        break;
+      }
+    } catch (e) {
+      console.log("ERROR", shape.name, (e as Error).message);
+      results.push({ name: shape.name, error: (e as Error).message });
+    }
+  }
+  writeFileSync(join(BASE, "results.json"), JSON.stringify(results, null, 2));
+  console.log("\nWrote", join(BASE, "results.json"));
+  const win = results.find((r) => (r as { ok?: boolean }).ok);
+  process.exit(win ? 0 : 2);
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/scripts/smoke-import.mjs

@@ -0,0 +1,82 @@
+import { mkdtempSync, rmSync, readFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir, homedir } from "node:os";
+import { pathToFileURL } from "node:url";
+
+// Load compiled-less TS via tsx dynamic import of source
+const root = new URL("..", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+// On Windows pathToFileURL for dynamic import
+async function load(rel) {
+  const p = join(process.cwd(), rel);
+  return import(pathToFileURL(p).href);
+}
+
+const { IMPORT_SOURCES, getImportSource } = await load("src/import/sources.ts");
+const { listRunningFromSource } = await load("src/import/list-running.ts");
+const { readForeignHistory } = await load("src/import/history-readers.ts");
+const { buildImportPackage } = await load("src/import/build-import.ts");
+
+for (const src of IMPORT_SOURCES) {
+  const running = listRunningFromSource(src);
+  console.log("===", src.id, "running:", running.length);
+  for (const s of running.slice(0, 3)) {
+    const hist = readForeignHistory(src.format, src.sessionsRoot, s.sessionId);
+    console.log(
+      " -",
+      s.sessionId.slice(0, 18),
+      "entries=",
+      hist.length,
+      "bytes=",
+      s.historyBytes,
+      "cwd=",
+      (s.cwd || "").slice(0, 48),
+    );
+  }
+}
+
+const kiro = getImportSource("kiro");
+const kRunning = listRunningFromSource(kiro);
+const withHist = kRunning.find((s) => s.historyBytes > 1000) || kRunning[0];
+if (withHist) {
+  const dir = mkdtempSync(join(tmpdir(), "grok-imp-"));
+  const pkg = buildImportPackage(kiro, withHist, dir);
+  console.log("KIRO IMPORT", {
+    entries: pkg.entryCount,
+    chars: pkg.transcriptChars,
+    truncated: pkg.truncatedInline,
+  });
+  console.log("file size", readFileSync(pkg.transcriptPath, "utf8").length);
+  rmSync(dir, { recursive: true, force: true });
+}
+
+const codex = getImportSource("codex");
+const cRunning = listRunningFromSource(codex);
+if (cRunning[0]) {
+  const h = readForeignHistory(codex.format, codex.sessionsRoot, cRunning[0].sessionId);
+  console.log("codex first", cRunning[0].sessionId, "entries", h.length);
+}
+
+const claude = getImportSource("claude");
+const files = existsSync(claude.sessionsRoot)
+  ? readdirSync(claude.sessionsRoot).filter((f) => f.endsWith(".jsonl")).slice(0, 1)
+  : [];
+if (files[0]) {
+  const id = files[0].replace(/\.jsonl$/, "");
+  const h = readForeignHistory(claude.format, claude.sessionsRoot, id);
+  console.log("claude sample", id, "entries", h.length);
+}
+
+const msgRoot = join(homedir(), ".local", "share", "opencode", "storage", "message");
+if (existsSync(msgRoot)) {
+  const dirs = readdirSync(msgRoot).filter((d) => d.startsWith("ses_")).slice(0, 3);
+  for (const d of dirs) {
+    const h = readForeignHistory(
+      "opencode-storage",
+      join(homedir(), ".local", "share", "opencode"),
+      d,
+    );
+    console.log("opencode", d.slice(0, 24), "entries", h.length, h[0]?.role);
+  }
+}
+
+console.log("OK");

package/scripts/smoke-import.ts

@@ -0,0 +1,73 @@
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildImportPackage } from "../src/import/build-import.js";
+import { readForeignHistory } from "../src/import/history-readers.js";
+import { listRunningFromSource } from "../src/import/list-running.js";
+import { getImportSource, IMPORT_SOURCES } from "../src/import/sources.js";
+
+for (const src of IMPORT_SOURCES) {
+  const running = listRunningFromSource(src);
+  console.log("===", src.id, "running:", running.length);
+  for (const s of running.slice(0, 3)) {
+    const hist = readForeignHistory(src.format, src.sessionsRoot, s.sessionId);
+    console.log(
+      " -",
+      s.sessionId.slice(0, 18),
+      "entries=",
+      hist.length,
+      "bytes=",
+      s.historyBytes,
+      "cwd=",
+      (s.cwd || "").slice(0, 48),
+    );
+  }
+}
+
+const kiro = getImportSource("kiro")!;
+const kRunning = listRunningFromSource(kiro);
+const withHist = kRunning.find((s) => s.historyBytes > 1000) || kRunning[0];
+if (withHist) {
+  const dir = mkdtempSync(join(tmpdir(), "grok-imp-"));
+  const pkg = buildImportPackage(kiro, withHist, dir);
+  console.log("KIRO IMPORT", {
+    entries: pkg.entryCount,
+    chars: pkg.transcriptChars,
+    truncated: pkg.truncatedInline,
+  });
+  console.log("file size", readFileSync(pkg.transcriptPath, "utf8").length);
+  console.log("priming includes path", pkg.priming.includes(pkg.transcriptPath));
+  rmSync(dir, { recursive: true, force: true });
+}
+
+const codex = getImportSource("codex")!;
+const cRunning = listRunningFromSource(codex);
+if (cRunning[0]) {
+  const h = readForeignHistory(codex.format, codex.sessionsRoot, cRunning[0].sessionId);
+  console.log("codex first", cRunning[0].sessionId, "entries", h.length);
+}
+
+const claude = getImportSource("claude")!;
+const files = existsSync(claude.sessionsRoot)
+  ? readdirSync(claude.sessionsRoot).filter((f) => f.endsWith(".jsonl")).slice(0, 1)
+  : [];
+if (files[0]) {
+  const id = files[0]!.replace(/\.jsonl$/, "");
+  const h = readForeignHistory(claude.format, claude.sessionsRoot, id);
+  console.log("claude sample", id, "entries", h.length);
+}
+
+const msgRoot = join(homedir(), ".local", "share", "opencode", "storage", "message");
+if (existsSync(msgRoot)) {
+  const dirs = readdirSync(msgRoot).filter((d) => d.startsWith("ses_")).slice(0, 3);
+  for (const d of dirs) {
+    const h = readForeignHistory(
+      "opencode-storage",
+      join(homedir(), ".local", "share", "opencode"),
+      d,
+    );
+    console.log("opencode", d.slice(0, 24), "entries", h.length, h[0]?.role);
+  }
+}
+
+console.log("OK");