patchrelay 0.39.0 → 0.40.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.39.0",
-  "commit": "80d285a7e9bd",
-  "builtAt": "2026-04-11T20:04:29.313Z"
+  "version": "0.40.0",
+  "commit": "c1cef920f5e3",
+  "builtAt": "2026-04-11T22:19:02.944Z"
 }

package/dist/cli/commands/issues.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatWorktree } from "../formatters/text.js";
+import { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -36,6 +36,8 @@ export async function handleIssueCommand(params) {
             return await handleOpenCommand(nested);
         case "sessions":
             return await handleSessionsCommand(nested);
+        case "transcript-source":
+            return await handleTranscriptSourceCommand(nested);
         case "retry":
             return await handleRetryCommand(nested);
         case "close":
@@ -116,6 +118,30 @@ export async function handleOpenCommand(params) {
     const openCommand = buildOpenCommand(params.config, result.worktreePath, result.resumeThreadId);
     return await params.runInteractive(openCommand.command, openCommand.args);
 }
+export async function handleTranscriptSourceCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("transcript-source requires <issueKey>.");
+    }
+    const runFlag = params.parsed.flags.get("run");
+    let runId;
+    if (typeof runFlag === "string") {
+        const parsedRunId = Number(runFlag);
+        if (!Number.isSafeInteger(parsedRunId) || parsedRunId <= 0) {
+            throw new Error("--run must be a positive integer.");
+        }
+        runId = parsedRunId;
+    }
+    const result = params.data.transcriptSource(issueKey, runId);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    if (runId !== undefined && result.runId !== runId) {
+        throw new Error(`Run not found for ${issueKey}: ${runId}`);
+    }
+    writeOutput(params.stdout, params.json ? formatJson(result) : formatTranscriptSource(result));
+    return 0;
+}
 export async function handleSessionsCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/data.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
+import { resolveCodexSessionSource } from "../codex-session-source.js";
 import { extractCompletionCheck } from "../completion-check.js";
 import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
@@ -272,6 +273,25 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(run ? { releasedRunId: run.id } : {}),
         };
     }
+    transcriptSource(issueKey, runId) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const dbIssue = this.db.issues.getIssueByKey(issueKey);
+        const runs = this.db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId);
+        const selectedRun = runId !== undefined
+            ? runs.find((run) => run.id === runId)
+            : runs.slice().reverse().find((run) => run.threadId);
+        const threadId = selectedRun?.threadId ?? dbIssue.threadId;
+        return {
+            issue,
+            ...(selectedRun ? { runId: selectedRun.id, runType: selectedRun.runType, runStatus: selectedRun.status } : {}),
+            ...(threadId ? { threadId } : {}),
+            ...(selectedRun?.turnId ? { turnId: selectedRun.turnId } : {}),
+            ...(dbIssue.worktreePath ? { worktreePath: dbIssue.worktreePath } : {}),
+            ...(threadId ? { sessionSource: resolveCodexSessionSource(threadId) } : {}),
+        };
+    }
     sessions(issueKey) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)
@@ -284,6 +304,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             .map((run) => {
             const summary = summarizeRun(run);
             const eventCount = this.db.runs.listThreadEvents(run.id).length;
+            const sessionSource = run.threadId ? resolveCodexSessionSource(run.threadId) : undefined;
             return {
                 runId: run.id,
                 runType: run.runType,
@@ -293,6 +314,7 @@ export class CliDataAccess extends CliOperatorApiClient {
                 ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
                 ...(summary ? { summary } : {}),
                 ...(run.failureReason ? { failureReason: run.failureReason } : {}),
+                ...(sessionSource ? { sessionSource } : {}),
                 eventCount,
                 eventCountAvailable: this.config.runner.codex.persistExtendedHistory || eventCount > 0,
                 startedAt: run.startedAt,

package/dist/cli/formatters/text.js

@@ -97,6 +97,29 @@ export function formatClose(result) {
 function formatTimestampRange(startedAt, endedAt) {
     return endedAt ? `${startedAt} -> ${endedAt}` : `${startedAt} -> running`;
 }
+function formatSessionSource(sessionSource) {
+    if (!sessionSource)
+        return undefined;
+    if (sessionSource.exists)
+        return sessionSource.path;
+    return sessionSource.error ?? "not found";
+}
+export function formatTranscriptSource(result) {
+    const lines = [
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Worktree", result.worktreePath),
+        value("Run", result.runId !== undefined
+            ? `#${result.runId}${result.runType ? ` ${result.runType}` : ""}${result.runStatus ? ` (${result.runStatus})` : ""}`
+            : undefined),
+        value("Thread", result.threadId),
+        value("Turn", result.turnId),
+        value("Session source", formatSessionSource(result.sessionSource)),
+        result.sessionSource?.startedAt ? value("Started", result.sessionSource.startedAt) : undefined,
+        result.sessionSource?.originator ? value("Originator", result.sessionSource.originator) : undefined,
+        result.sessionSource?.cwd ? value("Working directory", result.sessionSource.cwd) : undefined,
+    ].filter(Boolean);
+    return `${lines.join("\n")}\n`;
+}
 export function formatSessionHistory(result, buildOpenForThread) {
     const lines = [
         `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,
@@ -134,6 +157,18 @@ export function formatSessionHistory(result, buildOpenForThread) {
         else if (session.failureReason) {
             lines.push(value("Failure", truncateLine(session.failureReason)));
         }
+        if (session.sessionSource) {
+            lines.push(value("Session source", formatSessionSource(session.sessionSource)));
+            if (session.sessionSource.startedAt) {
+                lines.push(value("Started", session.sessionSource.startedAt));
+            }
+            if (session.sessionSource.originator) {
+                lines.push(value("Originator", session.sessionSource.originator));
+            }
+            if (session.sessionSource.cwd) {
+                lines.push(value("Working directory", session.sessionSource.cwd));
+            }
+        }
         if (session.threadId && result.worktreePath && buildOpenForThread) {
             const command = buildOpenForThread(session.threadId);
             lines.push(value("Open", formatCommand(command.command, command.args)));

package/dist/cli/help.js

@@ -37,6 +37,7 @@ export function rootHelpText() {
         "  issue watch <issueKey> [--json]                         Follow the active run until it settles",
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
         "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
+        "  issue transcript-source <issueKey> [--run <id>] [--json]  Show the raw Codex session file for one issue run",
         "  issue close <issueKey> [--failed] [--reason <text>] [--json]",
         "                                                          Force-close one issue and release any active run",
         "  service status [--json]                                 Show systemd state and local health",
@@ -150,6 +151,7 @@ export function issueHelpText() {
         "  path <issueKey>                 Print the issue worktree path",
         "  open <issueKey>                 Open Codex in the issue worktree",
         "  sessions <issueKey>             Show recorded Codex app-server sessions",
+        "  transcript-source <issueKey>    Show the raw Codex session file for one issue run",
         "  retry <issueKey>                Requeue a run",
         "  close <issueKey>                Force-close a stuck issue",
         "",
@@ -158,6 +160,7 @@ export function issueHelpText() {
         "  patchrelay issue show USE-54",
         "  patchrelay issue watch USE-54",
         "  patchrelay issue sessions USE-54",
+        "  patchrelay issue transcript-source USE-54",
         "  patchrelay close USE-54 --reason \"already handled manually\"",
     ].join("\n");
 }

package/dist/cli/index.js

@@ -64,6 +64,9 @@ function validateFlags(command, commandArgs, parsed) {
                 case "sessions":
                     assertKnownFlags(parsed, "issue", ["json"]);
                     return;
+                case "transcript-source":
+                    assertKnownFlags(parsed, "issue", ["run", "json"]);
+                    return;
                 case "retry":
                     assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
                     return;

package/dist/codex-session-source.js

@@ -0,0 +1,85 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+function resolveCodexHome(explicit) {
+    return explicit
+        ?? process.env.CODEX_HOME
+        ?? path.join(homedir(), ".codex");
+}
+function walkSessionFiles(directory, threadId, matches) {
+    const entries = readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walkSessionFiles(fullPath, threadId, matches);
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        if (entry.name.includes(threadId)) {
+            matches.push(fullPath);
+        }
+    }
+}
+function readSessionMeta(filePath) {
+    try {
+        const firstLine = readFileSync(filePath, "utf8").split(/\r?\n/, 1)[0];
+        if (!firstLine) {
+            return { error: "session file is empty" };
+        }
+        const parsed = JSON.parse(firstLine);
+        if (parsed.type !== "session_meta" || !parsed.payload || typeof parsed.payload !== "object" || Array.isArray(parsed.payload)) {
+            return { error: "session file does not start with session_meta" };
+        }
+        return { payload: parsed.payload };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function resolveCodexSessionSource(threadId, options) {
+    const codexHome = resolveCodexHome(options?.codexHome);
+    const sessionsDir = path.join(codexHome, "sessions");
+    if (!existsSync(sessionsDir)) {
+        return {
+            threadId,
+            codexHome,
+            sessionsDir,
+            exists: false,
+            error: `sessions directory not found: ${sessionsDir}`,
+        };
+    }
+    const matches = [];
+    walkSessionFiles(sessionsDir, threadId, matches);
+    matches.sort().reverse();
+    let firstError;
+    for (const candidate of matches) {
+        const { payload, error } = readSessionMeta(candidate);
+        if (payload && payload.id === threadId) {
+            return {
+                threadId,
+                codexHome,
+                sessionsDir,
+                exists: true,
+                path: candidate,
+                ...(typeof payload.id === "string" ? { sessionId: payload.id } : {}),
+                ...(typeof payload.timestamp === "string" ? { startedAt: payload.timestamp } : {}),
+                ...(typeof payload.cwd === "string" ? { cwd: payload.cwd } : {}),
+                ...(typeof payload.originator === "string" ? { originator: payload.originator } : {}),
+            };
+        }
+        if (!firstError && error) {
+            firstError = `${candidate}: ${error}`;
+        }
+    }
+    return {
+        threadId,
+        codexHome,
+        sessionsDir,
+        exists: false,
+        ...(firstError ? { error: firstError } : { error: `session file not found for thread ${threadId}` }),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.39.0",
+  "version": "0.40.0",
   "license": "MIT",
   "type": "module",
   "repository": {