patchrelay 0.3.0 → 0.4.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.3.0",
-  "commit": "c82e03b38d6e",
-  "builtAt": "2026-03-13T01:42:32.759Z"
+  "version": "0.4.0",
+  "commit": "94bb0a0f517c",
+  "builtAt": "2026-03-13T09:13:16.897Z"
 }

package/dist/cli/commands/issues.js

@@ -101,18 +101,26 @@ export async function handleOpenCommand(params) {
     if (!issueKey) {
         throw new Error("open requires <issueKey>.");
     }
-    const result = params.data.open(issueKey);
-    if (!result) {
-        throw new Error(`Workspace not found for ${issueKey}`);
-    }
     if (params.json) {
+        const result = params.data.open(issueKey);
+        if (!result) {
+            throw new Error(`Workspace not found for ${issueKey}`);
+        }
         writeOutput(params.stdout, formatJson(result));
         return 0;
     }
     if (params.parsed.flags.get("print") === true) {
+        const result = params.data.open(issueKey);
+        if (!result) {
+            throw new Error(`Workspace not found for ${issueKey}`);
+        }
         writeOutput(params.stdout, formatOpen(result));
         return 0;
     }
+    const result = await params.data.prepareOpen(issueKey);
+    if (!result) {
+        throw new Error(`Workspace not found for ${issueKey}`);
+    }
     const openCommand = buildOpenCommand(params.config, result.workspace.worktreePath, result.resumeThreadId);
     return await params.runInteractive(openCommand.command, openCommand.args);
 }

package/dist/cli/data.js

@@ -1,6 +1,8 @@
+import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
 import { PatchRelayDatabase } from "../db.js";
+import { WorktreeManager } from "../worktree-manager.js";
 import { resolveWorkflowStage } from "../workflow-policy.js";
 function safeJsonParse(value) {
     if (!value) {
@@ -167,16 +169,43 @@ export class CliDataAccess {
         if (!worktree) {
             return undefined;
         }
-        const ledger = this.getLedgerIssueContext(worktree.issue.projectId, worktree.issue.linearIssueId);
-        const resumeThreadId = (ledger.issueControl?.activeRunLeaseId ? ledger.runLease?.threadId : undefined) ??
-            worktree.workspace.lastThreadId ??
-            worktree.issue.latestThreadId ??
-            ledger.runLease?.threadId;
+        const resumeThreadId = this.getStoredOpenThreadId(worktree);
         return {
             ...worktree,
             ...(resumeThreadId ? { resumeThreadId } : {}),
         };
     }
+    async prepareOpen(issueKey) {
+        const worktree = this.worktree(issueKey);
+        if (!worktree) {
+            return undefined;
+        }
+        await this.ensureOpenWorktree(worktree);
+        const existingThreadId = await this.resolveStoredOpenThreadId(worktree);
+        if (existingThreadId) {
+            return {
+                ...worktree,
+                resumeThreadId: existingThreadId,
+            };
+        }
+        const codex = await this.getCodex();
+        const thread = await codex.startThread({
+            cwd: worktree.workspace.worktreePath,
+        });
+        this.db.issueSessions.upsertIssueSession({
+            projectId: worktree.issue.projectId,
+            linearIssueId: worktree.issue.linearIssueId,
+            workspaceOwnershipId: worktree.workspace.id,
+            threadId: thread.id,
+            source: "operator_open",
+            ...(worktree.issue.activeAgentSessionId ? { linkedAgentSessionId: worktree.issue.activeAgentSessionId } : {}),
+        });
+        this.db.issueSessions.touchIssueSession(thread.id);
+        return {
+            ...worktree,
+            resumeThreadId: thread.id,
+        };
+    }
     retry(issueKey, options) {
         const issue = this.db.issueWorkflows.getTrackedIssueByKey(issueKey);
         if (!issue) {
@@ -331,6 +360,80 @@ export class CliDataAccess {
         }
         return this.db.issueWorkflows.getActiveWorkspaceForIssue(issue.projectId, issue.linearIssueId);
     }
+    getStoredOpenThreadId(worktree) {
+        return this.listOpenCandidateThreadIds(worktree).at(0);
+    }
+    async resolveStoredOpenThreadId(worktree) {
+        for (const threadId of this.listOpenCandidateThreadIds(worktree)) {
+            if (!(await this.canReadThread(threadId))) {
+                continue;
+            }
+            this.recordOpenThreadForIssue(worktree, threadId);
+            return threadId;
+        }
+        return undefined;
+    }
+    listOpenCandidateThreadIds(worktree) {
+        const ledger = this.getLedgerIssueContext(worktree.issue.projectId, worktree.issue.linearIssueId);
+        const sessions = this.db.issueSessions.listIssueSessionsForIssue(worktree.issue.projectId, worktree.issue.linearIssueId);
+        const candidates = [
+            ledger.issueControl?.activeRunLeaseId ? ledger.runLease?.threadId : undefined,
+            ...sessions.map((session) => session.threadId),
+            worktree.workspace.lastThreadId,
+            worktree.issue.latestThreadId,
+            ledger.runLease?.threadId,
+        ];
+        const seen = new Set();
+        const ordered = [];
+        for (const candidate of candidates) {
+            if (!candidate || seen.has(candidate)) {
+                continue;
+            }
+            seen.add(candidate);
+            ordered.push(candidate);
+        }
+        return ordered;
+    }
+    recordOpenThreadForIssue(worktree, threadId) {
+        const existing = this.db.issueSessions.getIssueSessionByThreadId(threadId);
+        if (existing) {
+            this.db.issueSessions.touchIssueSession(threadId);
+            return;
+        }
+        const runLease = this.db.runLeases.getRunLeaseByThreadId(threadId);
+        this.db.issueSessions.upsertIssueSession({
+            projectId: worktree.issue.projectId,
+            linearIssueId: worktree.issue.linearIssueId,
+            workspaceOwnershipId: runLease?.workspaceOwnershipId ?? worktree.workspace.id,
+            threadId,
+            source: runLease ? "stage_run" : "operator_open",
+            ...(runLease?.id !== undefined ? { runLeaseId: runLease.id } : {}),
+            ...(runLease?.parentThreadId ? { parentThreadId: runLease.parentThreadId } : {}),
+            ...(worktree.issue.activeAgentSessionId ? { linkedAgentSessionId: worktree.issue.activeAgentSessionId } : {}),
+        });
+        this.db.issueSessions.touchIssueSession(threadId);
+    }
+    async canReadThread(threadId) {
+        try {
+            const codex = await this.getCodex();
+            await codex.readThread(threadId, false);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async ensureOpenWorktree(worktree) {
+        if (existsSync(worktree.workspace.worktreePath)) {
+            return;
+        }
+        const project = this.config.projects.find((entry) => entry.id === worktree.repoId);
+        if (!project) {
+            throw new Error(`Project not found for ${worktree.repoId}`);
+        }
+        const worktreeManager = new WorktreeManager(this.config);
+        await worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktree.workspace.worktreePath, worktree.workspace.branchName);
+    }
     async connect(projectId) {
         return await this.requestJson("/api/oauth/linear/start", {
             ...(projectId ? { projectId } : {}),

package/dist/db/authoritative-ledger-store.js

@@ -141,6 +141,85 @@ export class AuthoritativeLedgerStore {
             .get(projectId, linearIssueId);
         return row ? mapWorkspaceOwnership(row) : undefined;
     }
+    upsertIssueSession(params) {
+        const now = isoNow();
+        this.connection
+            .prepare(`
+        INSERT INTO issue_sessions (
+          project_id, linear_issue_id, workspace_ownership_id, run_lease_id, thread_id, parent_thread_id,
+          source, linked_agent_session_id, created_at, updated_at, last_opened_at
+        ) VALUES (
+          @projectId, @linearIssueId, @workspaceOwnershipId, @runLeaseId, @threadId, @parentThreadId,
+          @source, @linkedAgentSessionId, @createdAt, @updatedAt, NULL
+        )
+        ON CONFLICT(thread_id) DO UPDATE SET
+          project_id = @projectId,
+          linear_issue_id = @linearIssueId,
+          workspace_ownership_id = @workspaceOwnershipId,
+          run_lease_id = CASE WHEN @setRunLeaseId = 1 THEN @runLeaseId ELSE issue_sessions.run_lease_id END,
+          parent_thread_id = CASE WHEN @setParentThreadId = 1 THEN @parentThreadId ELSE issue_sessions.parent_thread_id END,
+          source = @source,
+          linked_agent_session_id = CASE
+            WHEN @setLinkedAgentSessionId = 1 THEN @linkedAgentSessionId
+            ELSE issue_sessions.linked_agent_session_id
+          END,
+          updated_at = @updatedAt
+        `)
+            .run({
+            projectId: params.projectId,
+            linearIssueId: params.linearIssueId,
+            workspaceOwnershipId: params.workspaceOwnershipId,
+            runLeaseId: params.runLeaseId ?? null,
+            threadId: params.threadId,
+            parentThreadId: params.parentThreadId ?? null,
+            source: params.source,
+            linkedAgentSessionId: params.linkedAgentSessionId ?? null,
+            createdAt: now,
+            updatedAt: now,
+            setRunLeaseId: Number("runLeaseId" in params),
+            setParentThreadId: Number("parentThreadId" in params),
+            setLinkedAgentSessionId: Number("linkedAgentSessionId" in params),
+        });
+        return this.getIssueSessionByThreadId(params.threadId);
+    }
+    getIssueSessionByThreadId(threadId) {
+        const row = this.connection
+            .prepare("SELECT * FROM issue_sessions WHERE thread_id = ?")
+            .get(threadId);
+        return row ? mapIssueSession(row) : undefined;
+    }
+    listIssueSessionsForIssue(projectId, linearIssueId) {
+        const rows = this.connection
+            .prepare(`
+        SELECT * FROM issue_sessions
+        WHERE project_id = ? AND linear_issue_id = ?
+        ORDER BY
+          CASE WHEN last_opened_at IS NULL THEN 1 ELSE 0 END,
+          last_opened_at DESC,
+          id DESC
+        `)
+            .all(projectId, linearIssueId);
+        return rows.map((row) => mapIssueSession(row));
+    }
+    touchIssueSession(threadId) {
+        const now = isoNow();
+        const result = this.connection
+            .prepare(`
+        UPDATE issue_sessions
+        SET updated_at = @updatedAt,
+            last_opened_at = @lastOpenedAt
+        WHERE thread_id = @threadId
+        `)
+            .run({
+            threadId,
+            updatedAt: now,
+            lastOpenedAt: now,
+        });
+        if (result.changes < 1) {
+            return undefined;
+        }
+        return this.getIssueSessionByThreadId(threadId);
+    }
     createRunLease(params) {
         const result = this.connection
             .prepare(`
@@ -416,6 +495,22 @@ function mapRunLease(row) {
         ...(row.failure_reason === null ? {} : { failureReason: String(row.failure_reason) }),
     };
 }
+function mapIssueSession(row) {
+    return {
+        id: Number(row.id),
+        projectId: String(row.project_id),
+        linearIssueId: String(row.linear_issue_id),
+        workspaceOwnershipId: Number(row.workspace_ownership_id),
+        threadId: String(row.thread_id),
+        source: row.source,
+        ...(row.run_lease_id === null ? {} : { runLeaseId: Number(row.run_lease_id) }),
+        ...(row.parent_thread_id === null ? {} : { parentThreadId: String(row.parent_thread_id) }),
+        ...(row.linked_agent_session_id === null ? {} : { linkedAgentSessionId: String(row.linked_agent_session_id) }),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+        ...(row.last_opened_at === null ? {} : { lastOpenedAt: String(row.last_opened_at) }),
+    };
+}
 function mapObligation(row) {
     return {
         id: Number(row.id),

package/dist/db/issue-workflow-coordinator.js

@@ -146,6 +146,21 @@ export class IssueWorkflowCoordinator {
             ...(params.parentThreadId !== undefined ? { parentThreadId: params.parentThreadId } : {}),
             ...(params.turnId !== undefined ? { turnId: params.turnId } : {}),
         });
+        const stageRun = this.issueWorkflows.getStageRun(params.stageRunId);
+        if (!stageRun) {
+            return;
+        }
+        const issue = this.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
+        this.authoritativeLedger.upsertIssueSession({
+            projectId: stageRun.projectId,
+            linearIssueId: stageRun.linearIssueId,
+            workspaceOwnershipId: stageRun.workspaceId,
+            runLeaseId: stageRun.id,
+            threadId: params.threadId,
+            ...(params.parentThreadId !== undefined ? { parentThreadId: params.parentThreadId } : {}),
+            ...(issue?.activeAgentSessionId ? { linkedAgentSessionId: issue.activeAgentSessionId } : {}),
+            source: "stage_run",
+        });
     }
     finishStageRun(params) {
         const stageRun = this.issueWorkflows.getStageRun(params.stageRunId);
@@ -163,6 +178,20 @@ export class IssueWorkflowCoordinator {
             threadId: params.threadId,
             ...(params.turnId !== undefined ? { turnId: params.turnId } : {}),
         });
+        const runLease = this.authoritativeLedger.getRunLease(params.stageRunId);
+        if (runLease?.workspaceOwnershipId !== undefined) {
+            const issue = this.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
+            this.authoritativeLedger.upsertIssueSession({
+                projectId: stageRun.projectId,
+                linearIssueId: stageRun.linearIssueId,
+                workspaceOwnershipId: runLease.workspaceOwnershipId,
+                runLeaseId: params.stageRunId,
+                threadId: params.threadId,
+                ...(runLease.parentThreadId ? { parentThreadId: runLease.parentThreadId } : {}),
+                ...(issue?.activeAgentSessionId ? { linkedAgentSessionId: issue.activeAgentSessionId } : {}),
+                source: "stage_run",
+            });
+        }
         const workspace = this.authoritativeLedger.getWorkspaceOwnership(stageRun.workspaceId);
         if (workspace) {
             this.authoritativeLedger.upsertWorkspaceOwnership({

package/dist/db/migrations.js

@@ -91,6 +91,23 @@ CREATE TABLE IF NOT EXISTS run_leases (
   FOREIGN KEY(trigger_receipt_id) REFERENCES event_receipts(id) ON DELETE SET NULL
 );
 
+CREATE TABLE IF NOT EXISTS issue_sessions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id TEXT NOT NULL,
+  linear_issue_id TEXT NOT NULL,
+  workspace_ownership_id INTEGER NOT NULL,
+  run_lease_id INTEGER,
+  thread_id TEXT NOT NULL UNIQUE,
+  parent_thread_id TEXT,
+  source TEXT NOT NULL,
+  linked_agent_session_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  last_opened_at TEXT,
+  FOREIGN KEY(workspace_ownership_id) REFERENCES workspace_ownership(id) ON DELETE CASCADE,
+  FOREIGN KEY(run_lease_id) REFERENCES run_leases(id) ON DELETE SET NULL
+);
+
 CREATE TABLE IF NOT EXISTS run_reports (
   run_lease_id INTEGER PRIMARY KEY,
   summary_json TEXT,
@@ -170,6 +187,8 @@ CREATE TABLE IF NOT EXISTS oauth_states (
 CREATE INDEX IF NOT EXISTS idx_event_receipts_project_issue ON event_receipts(project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issue_control_ready ON issue_control(desired_stage, active_run_lease_id);
 CREATE INDEX IF NOT EXISTS idx_issue_projection_issue_key ON issue_projection(issue_key);
+CREATE INDEX IF NOT EXISTS idx_issue_sessions_issue ON issue_sessions(project_id, linear_issue_id, id DESC);
+CREATE INDEX IF NOT EXISTS idx_issue_sessions_last_opened ON issue_sessions(project_id, linear_issue_id, last_opened_at DESC, id DESC);
 CREATE INDEX IF NOT EXISTS idx_run_leases_active ON run_leases(status, project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_run_leases_thread ON run_leases(thread_id);
 CREATE INDEX IF NOT EXISTS idx_run_thread_events_run ON run_thread_events(run_lease_id, id);

package/dist/db.js

@@ -14,6 +14,7 @@ export class PatchRelayDatabase {
     eventReceipts;
     issueControl;
     workspaceOwnership;
+    issueSessions;
     runLeases;
     obligations;
     webhookEvents;
@@ -33,6 +34,7 @@ export class PatchRelayDatabase {
         this.eventReceipts = this.authoritativeLedger;
         this.issueControl = this.authoritativeLedger;
         this.workspaceOwnership = this.authoritativeLedger;
+        this.issueSessions = this.authoritativeLedger;
         this.runLeases = this.authoritativeLedger;
         this.obligations = this.authoritativeLedger;
         this.webhookEvents = new WebhookEventStore(this.connection);

package/package.json

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