patchrelay 0.36.17 → 0.36.19

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.17",
-  "commit": "a9609f2ce42d",
-  "builtAt": "2026-04-10T12:32:40.306Z"
+  "version": "0.36.19",
+  "commit": "4022639921ea",
+  "builtAt": "2026-04-10T13:21:18.771Z"
 }

package/dist/issue-query-service.js

@@ -1,13 +1,13 @@
-import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
-import { IssueOverviewQuery, parseStageReport, } from "./issue-overview-query.js";
+import { IssueOverviewQuery, } from "./issue-overview-query.js";
+import { PublicAgentSessionStatusQuery } from "./public-agent-session-status-query.js";
 export class IssueQueryService {
-    db;
     runStatusProvider;
     overviewQuery;
+    publicStatusQuery;
     constructor(db, codex, runStatusProvider) {
-        this.db = db;
         this.runStatusProvider = runStatusProvider;
         this.overviewQuery = new IssueOverviewQuery(db, codex, runStatusProvider);
+        this.publicStatusQuery = new PublicAgentSessionStatusQuery(db, this.overviewQuery);
     }
     async getIssueOverview(issueKey) {
         return await this.overviewQuery.getIssueOverview(issueKey);
@@ -16,45 +16,6 @@ export class IssueQueryService {
         return await this.runStatusProvider.getActiveRunStatus(issueKey);
     }
     async getPublicAgentSessionStatus(issueKey) {
-        const overview = await this.overviewQuery.getIssueOverview(issueKey);
-        if (!overview)
-            return undefined;
-        const issueRecord = this.db.issues.getIssueByKey(issueKey);
-        const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
-        const runs = (overview.runs ?? this.overviewQuery.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
-            run: {
-                id: run.id,
-                runType: run.runType,
-                status: run.status,
-                startedAt: run.startedAt,
-                ...(run.endedAt ? { endedAt: run.endedAt } : {}),
-            },
-            ...(run.report ? { report: run.report } : {}),
-        }));
-        return {
-            issue: {
-                issueKey: overview.issue.issueKey,
-                title: overview.issue.title,
-                issueUrl: overview.issue.issueUrl,
-                currentLinearState: overview.issue.currentLinearState,
-                ...(overview.session?.sessionState ? { sessionState: overview.session.sessionState } : {}),
-                factoryState: overview.issue.factoryState,
-                ...(overview.session?.prNumber !== undefined ? { prNumber: overview.session.prNumber } : {}),
-                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
-                ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
-                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
-                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
-                ...(issueRecord ? { ciRepairAttempts: issueRecord.ciRepairAttempts, queueRepairAttempts: issueRecord.queueRepairAttempts } : {}),
-                ...(overview.issue.waitingReason ? { waitingReason: overview.issue.waitingReason } : {}),
-                ...(overview.issue.statusNote ? { statusNote: overview.issue.statusNote } : {}),
-                ...(overview.session?.lastWakeReason ? { lastWakeReason: overview.session.lastWakeReason } : {}),
-            },
-            ...(overview.activeRun ? { activeRun: overview.activeRun } : {}),
-            ...(overview.latestRun ? { latestRun: overview.latestRun } : {}),
-            ...(overview.liveThread ? { liveThread: summarizeCurrentThread(overview.liveThread) } : {}),
-            ...(latestRunReport ? { latestReportSummary: extractStageSummary(latestRunReport) } : {}),
-            runs,
-            generatedAt: new Date().toISOString(),
-        };
+        return await this.publicStatusQuery.getStatus(issueKey);
     }
 }

package/dist/linear-agent-session-client.js

@@ -0,0 +1,109 @@
+import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+export class LinearAgentSessionClient {
+    config;
+    db;
+    linearProvider;
+    logger;
+    feed;
+    constructor(config, db, linearProvider, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    ensureAgentSessionIssue(issue) {
+        if (issue.agentSessionId) {
+            return issue;
+        }
+        const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+        if (!recoveredAgentSessionId)
+            return issue;
+        this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
+        return this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            agentSessionId: recoveredAgentSessionId,
+        });
+    }
+    async emitActivity(issue, content, options) {
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
+        if (!syncedIssue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
+            if (!linear)
+                return;
+            const allowEphemeral = content.type === "thought" || content.type === "action";
+            await linear.createAgentActivity({
+                agentSessionId: syncedIssue.agentSessionId,
+                content,
+                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: syncedIssue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
+            this.feed?.publish({
+                level: "warn",
+                kind: "linear",
+                issueKey: syncedIssue.issueKey,
+                projectId: syncedIssue.projectId,
+                status: "linear_error",
+                summary: `Linear activity failed: ${msg}`,
+            });
+        }
+    }
+    async syncSessionPlan(issue, linear, options) {
+        if (!issue.agentSessionId || !linear.updateAgentSession) {
+            return;
+        }
+        const externalUrls = buildAgentSessionExternalUrls(this.config, {
+            ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+            ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+        });
+        await linear.updateAgentSession({
+            agentSessionId: issue.agentSessionId,
+            plan: buildAgentSessionPlanForIssue(issue, options),
+            ...(externalUrls ? { externalUrls } : {}),
+        });
+    }
+    async syncCodexPlan(issue, params) {
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
+        if (!syncedIssue.agentSessionId)
+            return;
+        const plan = params.plan;
+        if (!Array.isArray(plan))
+            return;
+        const STATUS_MAP = {
+            pending: "pending",
+            inProgress: "inProgress",
+            completed: "completed",
+        };
+        const steps = plan.map((entry) => {
+            const e = entry;
+            const step = typeof e.step === "string" ? e.step : String(e.step ?? "");
+            const status = typeof e.status === "string" ? (STATUS_MAP[e.status] ?? "pending") : "pending";
+            return { content: step, status };
+        });
+        const fullPlan = [
+            { content: "Prepare workspace", status: "completed" },
+            ...steps,
+            { content: "Merge", status: "pending" },
+        ];
+        try {
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            await linear.updateAgentSession({
+                agentSessionId: syncedIssue.agentSessionId,
+                plan: fullPlan,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: syncedIssue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
+        }
+    }
+}

package/dist/linear-progress-reporter.js

@@ -0,0 +1,185 @@
+import { sanitizeOperatorFacingCommand, sanitizeOperatorFacingText } from "./presentation-text.js";
+const PROGRESS_THROTTLE_MS = 5_000;
+const MAX_PROGRESS_TEXT_LENGTH = 220;
+export class LinearProgressReporter {
+    db;
+    emitActivity;
+    progressThrottle = new Map();
+    workingOnPublishedRuns = new Set();
+    agentMessageBuffers = new Map();
+    agentMessageProgressPublished = new Set();
+    constructor(db, emitActivity) {
+        this.db = db;
+        this.emitActivity = emitActivity;
+    }
+    maybeEmitProgress(notification, run) {
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+        if (!issue)
+            return;
+        const agentSentence = this.consumeAgentMessageSentence(notification, run);
+        const workingOn = resolveWorkingOnActivity(notification, agentSentence?.sentence);
+        if (workingOn && !this.workingOnPublishedRuns.has(run.id)) {
+            this.workingOnPublishedRuns.add(run.id);
+            void this.emitActivity(issue, workingOn);
+        }
+        const progress = resolveEphemeralProgressActivity(notification, agentSentence?.sentence);
+        if (!progress)
+            return;
+        if (!progress.bypassThrottle) {
+            const now = Date.now();
+            const lastEmit = this.progressThrottle.get(run.id) ?? 0;
+            if (now - lastEmit < PROGRESS_THROTTLE_MS)
+                return;
+            this.progressThrottle.set(run.id, now);
+        }
+        void this.emitActivity(issue, progress.activity, { ephemeral: true });
+    }
+    clearProgress(runId) {
+        this.progressThrottle.delete(runId);
+        this.workingOnPublishedRuns.delete(runId);
+        for (const key of this.agentMessageBuffers.keys()) {
+            if (key.startsWith(`${runId}:`)) {
+                this.agentMessageBuffers.delete(key);
+            }
+        }
+        for (const key of this.agentMessageProgressPublished) {
+            if (key.startsWith(`${runId}:`)) {
+                this.agentMessageProgressPublished.delete(key);
+            }
+        }
+    }
+    consumeAgentMessageSentence(notification, run) {
+        const messageKey = resolveAgentMessageKey(notification, run);
+        if (!messageKey)
+            return undefined;
+        if (this.agentMessageProgressPublished.has(messageKey))
+            return undefined;
+        const delta = resolveAgentMessageDelta(notification);
+        if (delta) {
+            const previous = this.agentMessageBuffers.get(messageKey) ?? "";
+            const next = `${previous}${delta}`;
+            this.agentMessageBuffers.set(messageKey, next);
+            const sentence = extractFirstCompletedSentence(next);
+            if (!sentence)
+                return undefined;
+            this.agentMessageProgressPublished.add(messageKey);
+            return { sentence };
+        }
+        const completedText = resolveCompletedAgentMessageText(notification);
+        if (!completedText)
+            return undefined;
+        const sentence = extractFirstSentence(completedText);
+        if (!sentence)
+            return undefined;
+        this.agentMessageProgressPublished.add(messageKey);
+        return { sentence };
+    }
+}
+function resolveWorkingOnActivity(notification, agentSentence) {
+    const summary = resolveWorkingOnSummary(notification) ?? agentSentence;
+    if (!summary)
+        return undefined;
+    return { type: "response", body: `Working on: ${summary}` };
+}
+function resolveEphemeralProgressActivity(notification, agentSentence) {
+    if (notification.method === "item/started") {
+        const item = notification.params.item;
+        if (!item)
+            return undefined;
+        const type = typeof item.type === "string" ? item.type : undefined;
+        if (type === "commandExecution") {
+            const cmd = item.command;
+            const cmdStr = Array.isArray(cmd)
+                ? sanitizeOperatorFacingCommand(cmd.map((part) => String(part)).join(" "))
+                : sanitizeOperatorFacingCommand(typeof cmd === "string" ? cmd : undefined);
+            return { activity: { type: "action", action: "Running", parameter: truncateProgressText(cmdStr ?? "command", 120) } };
+        }
+        if (type === "mcpToolCall") {
+            const server = typeof item.server === "string" ? item.server : "";
+            const tool = typeof item.tool === "string" ? item.tool : "";
+            return { activity: { type: "action", action: "Using", parameter: `${server}/${tool}` } };
+        }
+        if (type === "dynamicToolCall") {
+            const tool = typeof item.tool === "string" ? item.tool : "tool";
+            return { activity: { type: "action", action: "Using", parameter: tool } };
+        }
+    }
+    if (agentSentence) {
+        return {
+            activity: { type: "thought", body: agentSentence },
+            bypassThrottle: true,
+        };
+    }
+    return undefined;
+}
+function resolveWorkingOnSummary(notification) {
+    if (notification.method !== "turn/plan/updated") {
+        return undefined;
+    }
+    const plan = notification.params.plan;
+    if (!Array.isArray(plan))
+        return undefined;
+    const ranked = plan
+        .map((entry) => entry)
+        .filter((entry) => typeof entry.step === "string" && entry.step.trim().length > 0)
+        .sort((a, b) => rankPlanStatus(a.status) - rankPlanStatus(b.status));
+    const first = ranked[0];
+    return summarizeProgressSentence(typeof first?.step === "string" ? first.step : undefined);
+}
+function rankPlanStatus(status) {
+    return status === "inProgress" ? 0
+        : status === "pending" ? 1
+            : status === "completed" ? 2
+                : 3;
+}
+function resolveAgentMessageKey(notification, run) {
+    if (notification.method === "item/agentMessage/delta") {
+        const itemId = typeof notification.params.itemId === "string" ? notification.params.itemId : undefined;
+        return itemId ? `${run.id}:${itemId}` : undefined;
+    }
+    if (notification.method === "item/completed") {
+        const item = notification.params.item;
+        const itemId = typeof item?.id === "string" ? item.id : undefined;
+        const itemType = typeof item?.type === "string" ? item.type : undefined;
+        return itemId && itemType === "agentMessage" ? `${run.id}:${itemId}` : undefined;
+    }
+    return undefined;
+}
+function resolveAgentMessageDelta(notification) {
+    if (notification.method !== "item/agentMessage/delta") {
+        return undefined;
+    }
+    return typeof notification.params.delta === "string" ? notification.params.delta : undefined;
+}
+function resolveCompletedAgentMessageText(notification) {
+    if (notification.method !== "item/completed") {
+        return undefined;
+    }
+    const item = notification.params.item;
+    if (!item || item.type !== "agentMessage")
+        return undefined;
+    return typeof item.text === "string" ? item.text : undefined;
+}
+function extractFirstSentence(text) {
+    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
+    if (!sanitized)
+        return undefined;
+    const match = sanitized.match(/^(.+?[.!?])(?:\s|$)/);
+    return truncateProgressText((match?.[1] ?? sanitized).trim(), MAX_PROGRESS_TEXT_LENGTH);
+}
+function extractFirstCompletedSentence(text) {
+    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
+    if (!sanitized)
+        return undefined;
+    const match = sanitized.match(/^(.+?[.!?])(?:\s|$)/);
+    return match?.[1] ? truncateProgressText(match[1].trim(), MAX_PROGRESS_TEXT_LENGTH) : undefined;
+}
+function summarizeProgressSentence(text) {
+    const summary = extractFirstSentence(text);
+    if (!summary)
+        return undefined;
+    return summary.endsWith(".") || summary.endsWith("!") || summary.endsWith("?") ? summary : `${summary}.`;
+}
+function truncateProgressText(text, maxLength) {
+    return text.length <= maxLength ? text : `${text.slice(0, maxLength - 3).trimEnd()}...`;
+}