@youdie006/prodex 0.28.0 → 0.29.0

package/dist/chatgpt-browser.js

@@ -2462,6 +2462,62 @@ export function sidebarProjectNamesExpression() {
 // Read-only discovery for --project/setup --project: list the sidebar project
 // names exactly as ChatGPT renders them, so nobody has to guess spelling or
 // case. Polls briefly because the Projects section hydrates after navigation.
+/**
+ * Recent conversations with their titles, for the interactive "continue an
+ * existing chat" list.
+ */
+/**
+ * Point the dedicated tab at a conversation and wait until it is really there.
+ *
+ * `--target-url` confirms which conversation a send means; it deliberately does
+ * not navigate, so nothing moves a shared browser behind the user's back. When
+ * the user has just picked a conversation from a list, moving there IS the
+ * request, so the picker navigates first and then confirms.
+ */
+export async function navigateChatGptTabTo(url, options = {}) {
+    const port = resolveCdpPort(options.port);
+    const page = await findChatGptPage(port, 3_000);
+    if (!page.ok || !page.page)
+        return false;
+    const target = normalizeChatGptTargetUrl(url);
+    const cdp = await connectCdp(page.page.webSocketDebuggerUrl);
+    try {
+        await cdp.send("Runtime.enable");
+        await cdp.evaluate(`location.assign(${JSON.stringify(target)})`);
+        const deadline = Date.now() + Math.max(1_000, options.timeoutMs ?? 20_000);
+        while (Date.now() < deadline) {
+            await sleep(500);
+            try {
+                const here = await cdp.evaluate("location.href");
+                if (typeof here === "string" && chatGptUrlsReferToSameTarget(here, target))
+                    return true;
+            }
+            catch {
+                // Mid-navigation evaluate failures are expected; keep polling.
+            }
+        }
+        return false;
+    }
+    finally {
+        cdp.close();
+    }
+}
+export async function listRecentChatGptConversations(input = {}) {
+    const port = resolveCdpPort(input.port);
+    const page = await findChatGptPage(port, input.timeoutMs ?? 3_000);
+    if (!page.ok || !page.page)
+        return [];
+    const { recentConversationTitlesExpression } = await import("./tui.js");
+    try {
+        return ((await evaluateOnPage(page.page, recentConversationTitlesExpression(input.limit ?? 10), {
+            timeoutMs: 30_000
+        })) ?? []);
+    }
+    catch {
+        // Nothing to continue from is a normal answer here, not a failure.
+        return [];
+    }
+}
 export async function listChatGptSidebarProjects(input = {}) {
     const port = resolveCdpPort(input.port);
     const timeoutMs = input.timeoutMs ?? 15_000;

package/dist/cli-help.js

@@ -27,9 +27,9 @@ Ask / consult commands:
   prodex pro browser projects [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of sidebar project names (for --project)
   prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # recover a finished answer from a thread whose send timed out
   prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 300000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
-  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
-  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
 
 Bridge ledger (durable tasks/results/receipts/sessions under .bridge/):
   prodex init [--cwd /absolute/path/to/repo]
@@ -168,9 +168,9 @@ Commands:
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js]
   prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--attach path] [--tool deep-research|web-search|create-image] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"
-  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
-  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
+  prodex pro show <task-id|latest> [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]
 
 Use \`prodex pro ask\` for dry-run/manual previews.
 Use \`prodex pro browser ask\` only when you want an explicit visible-browser send.

package/dist/cli-pro.js

@@ -575,7 +575,7 @@ export async function runProCommand(rest, io, runCliFn) {
     if (subcommand === "latest") {
         if (printHelpIfRequested(proArgs, "pro latest", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"] }))
             return 0;
-        assertOnlyOptions(proArgs, "pro latest", ["--cwd", "--source-cli"]);
+        assertOnlyOptions(proArgs, "pro latest", ["--cwd", "--source-cli"], ["--json"]);
         const targetCwd = resolveCwdFlag(io.cwd, proArgs);
         const targetStore = new BridgeStore(targetCwd);
         const sourceCli = resolveOptionalFileFlag(io.cwd, proArgs, "--source-cli");
@@ -589,13 +589,19 @@ export async function runProCommand(rest, io, runCliFn) {
         }
         if (!consult)
             throw new Error("No GPT Pro answers found");
-        io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        if (proArgs.includes("--json")) {
+            const modelUsed = await recordedModelUsed(targetStore, consult.task.id);
+            io.stdout(formatProAnswerJson(consult, sourceCli, answerOptions, modelUsed ? { modelUsed } : {}));
+        }
+        else {
+            io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        }
         return 0;
     }
     if (subcommand === "show") {
         if (printHelpIfRequested(proArgs, "pro show", io.stdout, printProHelp, { valueFlags: ["--cwd", "--source-cli"], maxPositionals: 1 }))
             return 0;
-        const [taskId] = readPositionalsWithOptions(proArgs, "pro show", 1, ["--cwd", "--source-cli"]);
+        const [taskId] = readPositionalsWithOptions(proArgs, "pro show", 1, ["--cwd", "--source-cli"], ["--json"]);
         if (!taskId)
             throw new Error("pro show requires <task-id|latest>");
         const targetCwd = resolveCwdFlag(io.cwd, proArgs);
@@ -611,7 +617,13 @@ export async function runProCommand(rest, io, runCliFn) {
         }
         if (!consult)
             throw new Error(taskId === "latest" ? "No GPT Pro answers found" : `GPT Pro answer not found: ${taskId}`);
-        io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        if (proArgs.includes("--json")) {
+            const modelUsed = await recordedModelUsed(targetStore, consult.task.id);
+            io.stdout(formatProAnswerJson(consult, sourceCli, answerOptions, modelUsed ? { modelUsed } : {}));
+        }
+        else {
+            io.stdout(formatProAnswer(consult, sourceCli, answerOptions));
+        }
         return 0;
     }
     if (subcommand === "debate-prompt") {
@@ -1432,6 +1444,42 @@ export function browserSendBlockerFromError(error) {
         next_step: "Resolve the visible browser issue manually, then rerun the consult if needed."
     };
 }
+/**
+ * The same answer as `formatProAnswer`, shaped for a program.
+ *
+ * Every other read path is JSON; these two printed only the human rendering,
+ * so an agent after the thread or the model that produced an answer had to
+ * scrape prose.
+ */
+export function formatProAnswerJson(consult, sourceCli, options = {}, extras = {}) {
+    const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
+    return JSON.stringify({
+        task_id: consult.task.id,
+        status: consult.result.status,
+        thread: consult.task.provenance.thread ?? null,
+        created_at: consult.result.created_at,
+        answer: consult.result.summary,
+        ...(extras.modelUsed ? { model_used: extras.modelUsed } : {}),
+        warnings: consult.result.warnings ?? [],
+        ...(blocker ? { blocker } : {})
+    }, null, 2);
+}
+/**
+ * Which model actually answered, from the receipt that recorded the answer.
+ * It lives there rather than on the task because it is what ChatGPT tagged the
+ * message with, not what prodex asked for.
+ */
+async function recordedModelUsed(store, taskId) {
+    try {
+        const receipts = await store.listReceiptsReadOnly({ kind: "consult_answer_saved", task_id: taskId });
+        const value = receipts[0]?.metadata?.model_used;
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        // A missing or unreadable receipt just means the field is unknown.
+        return undefined;
+    }
+}
 export function formatProAnswer(consult, sourceCli, options = {}) {
     const blocker = sourceAwareProAnswerBlocker(consult, sourceCli, options);
     const summary = sourceAwareProAnswerSummary(consult.result.summary, consult.result.blocker, blocker);

package/dist/cli.js

@@ -70,6 +70,18 @@ async function runInteractiveUi(io) {
                 { label: "browser", value: browser }
             ];
         },
+        pinnedProject: async () => {
+            const { loadBrowserDefaults } = await import("./config.js");
+            return (await loadBrowserDefaults(io.cwd).catch(() => undefined))?.project;
+        },
+        listConversations: async () => {
+            const { listRecentChatGptConversations } = await import("./chatgpt-browser.js");
+            return listRecentChatGptConversations({});
+        },
+        openThread: async (url) => {
+            const { navigateChatGptTabTo } = await import("./chatgpt-browser.js");
+            return navigateChatGptTabTo(url, {});
+        },
         listProjects: async () => {
             const { listChatGptSidebarProjects } = await import("./chatgpt-browser.js");
             const listed = await listChatGptSidebarProjects({});

package/dist/tui-flow.js

@@ -0,0 +1,34 @@
+/**
+ * What the interactive picker asks, in the order it asks it.
+ *
+ * The first version asked for the prompt first and treated the kind of send as
+ * an afterthought, which is backwards: whether this is an ordinary chat or a
+ * ten-minute research run changes what you would type. Deciding the kind, then
+ * the destination, then writing the prompt matches how the request is actually
+ * formed - and it leaves the seconds spent choosing free for prodex to fetch
+ * the project and conversation lists the destination step needs.
+ */
+export const SEND_KINDS = [
+    { id: "chat", label: "Normal chat", hint: "ordinary Pro answer", tools: [] },
+    { id: "deep-research", label: "Deep research", hint: "browsed report, runs about 10 minutes", tools: ["deep-research"] },
+    { id: "web-search", label: "Web search", hint: "current facts, with sources", tools: ["web-search"] },
+    { id: "create-image", label: "Create image", tools: ["create-image"] }
+];
+/**
+ * One screen for the whole destination question. Splitting "which project" from
+ * "new thread or not" made the user answer twice for one decision, and left no
+ * way at all to say "that conversation, the one from yesterday".
+ */
+export function destinationChoices(pinnedProject) {
+    return [
+        { id: "continue", label: "Continue an existing conversation", hint: "pick from your recent chats" },
+        {
+            id: "new",
+            label: "New chat",
+            ...(pinnedProject ? { hint: `in your pinned project: ${pinnedProject}` } : { hint: "in the plain chat list" })
+        },
+        { id: "project", label: "New chat in an existing project", hint: "pick from your sidebar projects" },
+        { id: "project-new", label: "New chat in a new project" },
+        ...(pinnedProject ? [{ id: "no-project", label: "New chat, ignoring the pinned project" }] : [])
+    ];
+}

package/dist/tui-run.js

@@ -7,7 +7,9 @@
  * what keeps the interactive path from drifting away from the documented flags.
  */
 import readline from "node:readline";
-import { consultArgsFromChoices, moveCursor, progressLabel, renderContextPanel, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
+import { renderBanner } from "./banner.js";
+import { destinationChoices, SEND_KINDS } from "./tui-flow.js";
+import { consultArgsFromChoices, conversationThreadUrl, moveCursor, progressLabel, renderContextPanel, renderProgressBar, renderSelectList } from "./tui.js";
 const ESC = "";
 const CLEAR = `${ESC}[2J${ESC}[H`;
 // The alternate screen buffer: the terminal comes back exactly as it was, so a
@@ -115,38 +117,6 @@ function numericChoice(key, length) {
         return undefined;
     return digit - 1;
 }
-async function pickMany(io, input, header = "") {
-    let cursor = 0;
-    let selected = [];
-    for (;;) {
-        io.write(CLEAR +
-            header +
-            renderSelectList({
-                ...input,
-                cursor,
-                selected,
-                multi: true,
-                width: terminalWidth(),
-                color: colorEnabled(),
-                footer: "  space toggle   1-9 toggle directly   enter confirm (none is fine)   q cancel"
-            }) +
-            "\n");
-        const key = await readKey(io);
-        if (isCancel(key))
-            return undefined;
-        const typed = numericChoice(key, input.options.length);
-        if (typed !== undefined)
-            selected = toggleSelection(selected, typed);
-        else if (key.name === "up" || key.name === "k")
-            cursor = moveCursor(cursor, "up", input.options.length);
-        else if (key.name === "down" || key.name === "j")
-            cursor = moveCursor(cursor, "down", input.options.length);
-        else if (key.name === "space")
-            selected = toggleSelection(selected, cursor);
-        else if (isConfirm(key))
-            return selected;
-    }
-}
 /** Read one line with the terminal back in cooked mode, so editing works. */
 async function askLine(io, question) {
     io.input.setRawMode?.(false);
@@ -161,11 +131,6 @@ async function askLine(io, question) {
     keys?.drain();
     return answer.trim();
 }
-const TOOL_CHOICES = [
-    { id: "deep-research", label: "Deep research", hint: "browsed report, runs about 10 minutes" },
-    { id: "web-search", label: "Web search", hint: "current facts, with sources" },
-    { id: "create-image", label: "Create image" }
-];
 /**
  * Walk the questions a send needs, then run it with a moving progress bar.
  * Returns the process exit code.
@@ -179,85 +144,104 @@ export async function runInteractiveConsult(io, deps) {
     io.write(ALT_SCREEN_ON + HIDE_CURSOR);
     let header = "";
     try {
-        io.write(CLEAR);
-        // Gather the context WHILE the prompt is being typed. Reading the browser
-        // state takes a second or two, and doing it first left the screen blank for
-        // that long - anything typed into that gap was swallowed, prompt included.
+        // The logo is the program saying which program it is; the panel says what
+        // this send will use. Both belong above the first question, not nowhere.
+        const banner = colorEnabled() ? `${renderBanner({ color: true })}\n` : "";
+        io.write(CLEAR + banner);
+        // Everything the later screens need is fetched while the first question is
+        // being read, so no step waits on the network.
         const contextPromise = deps.describeContext?.().catch(() => []);
-        const prompt = await askLine(io, "Ask ChatGPT Pro\n\n  prompt: ");
-        // The panel still leads every question that follows, which is where it
-        // earns its place: choosing a project and tools without knowing the browser
-        // is down wastes every answer given before the failure.
+        const pinnedPromise = deps.pinnedProject?.().catch(() => undefined);
+        const conversationsPromise = deps.listConversations?.().catch(() => []);
+        const kindChoice = await pick(io, {
+            title: "What kind of send is this?",
+            step: { index: 1, total: 3 },
+            options: SEND_KINDS.map((kind) => ({ label: kind.label, ...(kind.hint ? { hint: kind.hint } : {}) }))
+        }, banner);
+        if (kindChoice === undefined)
+            return cancel(io);
+        const tools = SEND_KINDS[kindChoice].tools;
         const rows = (await contextPromise) ?? [];
         if (rows.length > 0)
-            header = `${renderContextPanel(rows, { color: colorEnabled(), width: terminalWidth() })}\n\n`;
-        if (prompt.length === 0) {
-            io.write("Nothing to ask.\n");
-            return 1;
-        }
-        const projectChoice = await pick(io, {
-            title: "Where should this consult land?",
-            step: { index: 1, total: 3 },
-            options: [
-                { label: "The chat that is already open", hint: "keeps the thread's context" },
-                { label: "An existing project" },
-                { label: "A new project" },
-                { label: "No project", hint: "plain chat list, ignores a pinned default" }
-            ]
+            header = `${banner}${renderContextPanel(rows, { color: colorEnabled(), width: terminalWidth() })}\n\n`;
+        else
+            header = banner;
+        const pinnedProject = await pinnedPromise;
+        const destinations = destinationChoices(pinnedProject);
+        const destinationChoice = await pick(io, {
+            title: "Where should it go?",
+            step: { index: 2, total: 3 },
+            options: destinations.map((entry) => ({ label: entry.label, ...(entry.hint ? { hint: entry.hint } : {}) }))
         }, header);
-        if (projectChoice === undefined)
+        if (destinationChoice === undefined)
             return cancel(io);
-        const modes = ["current", "existing", "new", "none"];
-        const projectMode = modes[projectChoice];
+        const destination = destinations[destinationChoice].id;
+        let projectMode = "current";
         let projectName;
-        if (projectMode === "existing") {
+        let targetUrl;
+        if (destination === "continue") {
+            const conversations = (await conversationsPromise) ?? [];
+            if (conversations.length === 0) {
+                io.write("\nNo recent conversations were readable. Start a new chat instead.\n");
+                return 1;
+            }
+            const chosen = await pick(io, { title: "Which conversation?", options: conversations.map((entry) => ({ label: entry.title })) }, header);
+            if (chosen === undefined)
+                return cancel(io);
+            targetUrl = conversationThreadUrl(conversations[chosen].id);
+        }
+        else if (destination === "project") {
             const projects = await deps.listProjects();
             if (projects.length === 0) {
                 io.write("\nNo projects are visible in the ChatGPT sidebar.\n");
                 return 1;
             }
-            const chosen = await pick(io, {
-                title: "Which project?",
-                options: projects.map((name) => ({ label: name }))
-            }, header);
+            const chosen = await pick(io, { title: "Which project?", options: projects.map((name) => ({ label: name })) }, header);
             if (chosen === undefined)
                 return cancel(io);
+            projectMode = "existing";
             projectName = projects[chosen];
         }
-        else if (projectMode === "new") {
-            projectName = await askLine(io, `${CLEAR}New project\n\n  name: `);
+        else if (destination === "project-new") {
+            projectName = await askLine(io, `${CLEAR}${header}New project\n\n  name: `);
             if (!projectName)
                 return cancel(io);
+            projectMode = "new";
+        }
+        else if (destination === "no-project") {
+            projectMode = "none";
+        }
+        // The prompt comes last: what you type depends on what you just decided.
+        io.write(CLEAR + header + SHOW_CURSOR);
+        const kindLabel = SEND_KINDS[kindChoice].label;
+        const prompt = await askLine(io, `${kindLabel}   Step 3 of 3\n\n  prompt: `);
+        io.write(HIDE_CURSOR);
+        if (prompt.length === 0) {
+            io.write("Nothing to ask.\n");
+            return 1;
         }
-        const toolChoice = await pickMany(io, {
-            title: "Turn on any composer tools for this send",
-            step: { index: 2, total: 3 },
-            options: TOOL_CHOICES.map((tool) => ({ label: tool.label, ...(tool.hint ? { hint: tool.hint } : {}) }))
-        }, header);
-        if (toolChoice === undefined)
-            return cancel(io);
-        const tools = toolChoice.map((index) => TOOL_CHOICES[index].id);
-        const threadChoice = await pick(io, {
-            title: "Start a fresh thread?",
-            step: { index: 3, total: 3 },
-            options: [
-                { label: "Continue the current thread", hint: "follow-ups keep context" },
-                { label: "Start a new chat", hint: "recommended for an unrelated question" }
-            ]
-        }, header);
-        if (threadChoice === undefined)
-            return cancel(io);
         const choices = {
             prompt,
             projectMode,
             ...(projectName ? { projectName } : {}),
+            ...(targetUrl ? { targetUrl } : {}),
             tools,
-            newChat: threadChoice === 1
+            newChat: !targetUrl
         };
         const args = consultArgsFromChoices(choices);
         // Leave the alternate screen before the send: the answer, the receipt id
         // and any blocker belong in the scrollback the user keeps.
         io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
+        // --target-url confirms which conversation a send means; it deliberately
+        // does not navigate. Picking one from a list IS a request to go there, so
+        // move the tab first and let the flag confirm it landed.
+        if (targetUrl && deps.openThread) {
+            io.write("Opening the conversation you picked...\n");
+            if (!(await deps.openThread(targetUrl))) {
+                io.write(`Could not open ${targetUrl} in the dedicated browser.\n`);
+                return 1;
+            }
+        }
         io.write(`Sending. Equivalent command:\n  prodex ${formatCommand(args)}\n\n`);
         // Deep research runs about ten minutes; an ordinary Pro answer, minutes.
         // Fill the bar against that so the wait has a shape.

package/dist/tui.js

@@ -10,6 +10,10 @@
  * The rendering and the choice-to-argument mapping are pure so they can be
  * tested without a terminal; only `runInteractiveConsult` touches stdin.
  */
+/** Where a conversation lives, given its id. */
+export function conversationThreadUrl(conversationId) {
+    return `https://chatgpt.com/c/${conversationId}`;
+}
 /**
  * Map the picker's answers onto the exact command line a person could have
  * typed. Keeping this a pure function means the interactive path cannot drift
@@ -20,6 +24,17 @@ export function consultArgsFromChoices(choices) {
     if (prompt.length === 0)
         throw new Error("The prompt is empty - there is nothing to ask.");
     const args = ["pro", "browser", "ask"];
+    // A picked conversation is the whole destination: the send rejects a project
+    // or a fresh chat alongside a pinned target, and rightly so.
+    if (choices.targetUrl) {
+        args.push("--target-url", choices.targetUrl, "--confirm-target");
+        for (const attachment of choices.attachments ?? [])
+            args.push("--attach", attachment);
+        for (const tool of choices.tools)
+            args.push("--tool", tool);
+        args.push("--", prompt);
+        return args;
+    }
     if (choices.newChat)
         args.push("--new-chat");
     if (choices.projectMode === "existing" || choices.projectMode === "new") {
@@ -38,6 +53,37 @@ export function consultArgsFromChoices(choices) {
     args.push("--", prompt);
     return args;
 }
+/**
+ * Recent conversations with their titles, for the "continue an existing chat"
+ * list. Only the sidebar listing is fetched - the transcripts themselves are
+ * large and nothing here needs them.
+ */
+export function recentConversationTitlesExpression(limit = 10) {
+    return `(async () => {
+  let token = "";
+  try {
+    const session = await fetch("/api/auth/session", { credentials: "include" });
+    if (!session.ok) return [];
+    const parsed = await session.json();
+    token = (parsed && parsed.accessToken) || "";
+  } catch (error) {
+    return [];
+  }
+  try {
+    const response = await fetch("/backend-api/conversations?offset=0&limit=${limit}&order=updated", {
+      credentials: "include",
+      headers: token ? { Authorization: "Bearer " + token } : {}
+    });
+    if (!response.ok) return [];
+    const listed = await response.json();
+    return ((listed && listed.items) || [])
+      .filter((item) => item && item.id)
+      .map((item) => ({ id: item.id, title: (item.title || "").trim() || "Untitled" }));
+  } catch (error) {
+    return [];
+  }
+})()`;
+}
 const ESC = "";
 const DIM = `${ESC}[2m`;
 const BOLD = `${ESC}[1m`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",