patchrelay 0.7.7 → 0.7.9

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.7.7",
-  "commit": "b39ec3de1f37",
-  "builtAt": "2026-03-17T09:39:30.228Z"
+  "version": "0.7.9",
+  "commit": "9f2abbe93f17",
+  "builtAt": "2026-03-17T10:42:10.173Z"
 }

package/dist/config.js

@@ -54,7 +54,6 @@ const configSchema = z.object({
         level: z.enum(["debug", "info", "warn", "error"]).default("info"),
         format: z.literal("logfmt").default("logfmt"),
         file_path: z.string().min(1).default(getDefaultLogPath()),
-        webhook_archive_dir: z.string().optional(),
     }),
     database: z.object({
         path: z.string().min(1).default(getDefaultDatabasePath()),
@@ -314,7 +313,6 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
         throw new Error(`Missing env var ${parsed.linear.token_encryption_key_env}`);
     }
     const logFilePath = env.PATCHRELAY_LOG_FILE ?? parsed.logging.file_path;
-    const webhookArchiveDir = env.PATCHRELAY_WEBHOOK_ARCHIVE_DIR ?? parsed.logging.webhook_archive_dir;
     const oauthRedirectUri = parsed.linear.oauth.redirect_uri ?? deriveLinearOAuthRedirectUri(parsed.server);
     const config = {
         server: {
@@ -333,7 +331,6 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
             level: env.PATCHRELAY_LOG_LEVEL ?? parsed.logging.level,
             format: parsed.logging.format,
             filePath: ensureAbsolutePath(logFilePath),
-            ...(webhookArchiveDir ? { webhookArchiveDir: ensureAbsolutePath(webhookArchiveDir) } : {}),
         },
         database: {
             path: ensureAbsolutePath(env.PATCHRELAY_DB_PATH ?? parsed.database.path),

package/dist/index.js

@@ -24,9 +24,6 @@ async function main() {
     await enforceServiceEnvPermissions(getAdjacentEnvFilePaths(configPath).serviceEnvPath);
     await ensureDir(dirname(config.database.path));
     await ensureDir(dirname(config.logging.filePath));
-    if (config.logging.webhookArchiveDir) {
-        await ensureDir(config.logging.webhookArchiveDir);
-    }
     for (const project of config.projects) {
         await ensureDir(project.worktreeRoot);
     }

package/dist/linear-client.js

@@ -15,6 +15,10 @@ export class LinearGraphqlClient {
           identifier
           title
           url
+          delegate {
+            id
+            name
+          }
           state {
             id
             name
@@ -65,6 +69,10 @@ export class LinearGraphqlClient {
             identifier
             title
             url
+            delegate {
+              id
+              name
+            }
             state {
               id
               name
@@ -290,6 +298,8 @@ export class LinearGraphqlClient {
             ...(issue.state?.name ? { stateName: issue.state.name } : {}),
             ...(issue.team?.id ? { teamId: issue.team.id } : {}),
             ...(issue.team?.key ? { teamKey: issue.team.key } : {}),
+            ...(issue.delegate?.id ? { delegateId: issue.delegate.id } : {}),
+            ...(issue.delegate?.name ? { delegateName: issue.delegate.name } : {}),
             workflowStates: (issue.team?.states?.nodes ?? []).map((state) => ({
                 id: state.id,
                 name: state.name,

package/dist/preflight.js

@@ -66,12 +66,6 @@ export async function runPreflight(config) {
     checks.push(...checkPath("database", path.dirname(config.database.path), "directory", { createIfMissing: true, writable: true }));
     checks.push(checkDatabaseSchema(config));
     checks.push(...checkPath("logging", path.dirname(config.logging.filePath), "directory", { createIfMissing: true, writable: true }));
-    if (config.logging.webhookArchiveDir) {
-        checks.push(...checkPath("archive", config.logging.webhookArchiveDir, "directory", { createIfMissing: true, writable: true }));
-    }
-    else {
-        checks.push(warn("archive", "Raw webhook archival is disabled"));
-    }
     if (config.projects.length === 0) {
         checks.push(warn("projects", "No projects are configured yet; add one with `patchrelay project apply <id> <repo-path>` before connecting Linear"));
     }

package/dist/service-webhook-processor.js

@@ -10,6 +10,7 @@ import { normalizeWebhook } from "./webhooks.js";
 export class ServiceWebhookProcessor {
     config;
     stores;
+    linearProvider;
     enqueueIssue;
     logger;
     feed;
@@ -20,6 +21,7 @@ export class ServiceWebhookProcessor {
     constructor(config, stores, linearProvider, codex, enqueueIssue, logger, feed) {
         this.config = config;
         this.stores = stores;
+        this.linearProvider = linearProvider;
         this.enqueueIssue = enqueueIssue;
         this.logger = logger;
         this.feed = feed;
@@ -115,13 +117,15 @@ export class ServiceWebhookProcessor {
             }
             this.stores.webhookEvents.assignWebhookProject(webhookEventId, project.id);
             const receipt = this.ensureEventReceipt(event, project.id, normalized.issue.id);
-            const issueState = this.desiredStageRecorder.record(project, normalized, receipt ? { eventReceiptId: receipt.id } : undefined);
-            const observation = describeWebhookObservation(normalized, issueState.delegatedToPatchRelay);
+            const hydrated = await this.hydrateIssueContext(project.id, normalized);
+            const hydratedIssue = hydrated.issue ?? normalized.issue;
+            const issueState = this.desiredStageRecorder.record(project, hydrated, receipt ? { eventReceiptId: receipt.id } : undefined);
+            const observation = describeWebhookObservation(hydrated, issueState.delegatedToPatchRelay);
             if (observation) {
                 this.feed?.publish({
                     level: "info",
                     kind: observation.kind,
-                    issueKey: normalized.issue.identifier,
+                    issueKey: hydratedIssue.identifier,
                     projectId: project.id,
                     ...(observation.status ? { status: observation.status } : {}),
                     summary: observation.summary,
@@ -129,45 +133,45 @@ export class ServiceWebhookProcessor {
                 });
             }
             await this.agentSessionHandler.handle({
-                normalized,
+                normalized: hydrated,
                 project,
                 issue: issueState.issue,
                 desiredStage: issueState.desiredStage,
                 delegatedToPatchRelay: issueState.delegatedToPatchRelay,
             });
-            await this.commentHandler.handle(normalized, project);
+            await this.commentHandler.handle(hydrated, project);
             this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
             this.markEventReceiptProcessed(event.webhookId, "processed");
             if (issueState.desiredStage) {
                 this.feed?.publish({
                     level: "info",
                     kind: "stage",
-                    issueKey: normalized.issue.identifier,
+                    issueKey: hydratedIssue.identifier,
                     projectId: project.id,
                     stage: issueState.desiredStage,
                     status: "queued",
                     summary: `Queued ${issueState.desiredStage} workflow`,
-                    detail: `Triggered by ${normalized.triggerEvent}${normalized.issue.stateName ? ` from ${normalized.issue.stateName}` : ""}.`,
+                    detail: `Triggered by ${hydrated.triggerEvent}${hydratedIssue.stateName ? ` from ${hydratedIssue.stateName}` : ""}.`,
                 });
                 this.logger.info({
                     webhookEventId,
                     webhookId: event.webhookId,
                     projectId: project.id,
-                    issueKey: normalized.issue.identifier,
-                    issueId: normalized.issue.id,
+                    issueKey: hydratedIssue.identifier,
+                    issueId: hydratedIssue.id,
                     desiredStage: issueState.desiredStage,
                     delegatedToPatchRelay: issueState.delegatedToPatchRelay,
                 }, "Recorded desired stage from webhook and enqueued issue execution");
-                this.enqueueIssue(project.id, normalized.issue.id);
+                this.enqueueIssue(project.id, hydratedIssue.id);
                 return;
             }
             this.logger.info({
                 webhookEventId,
                 webhookId: event.webhookId,
                 projectId: project.id,
-                issueKey: normalized.issue.identifier,
-                issueId: normalized.issue.id,
-                triggerEvent: normalized.triggerEvent,
+                issueKey: hydratedIssue.identifier,
+                issueId: hydratedIssue.id,
+                triggerEvent: hydrated.triggerEvent,
                 delegatedToPatchRelay: issueState.delegatedToPatchRelay,
             }, "Processed webhook without enqueuing a new stage run");
         }
@@ -194,6 +198,37 @@ export class ServiceWebhookProcessor {
             throw err;
         }
     }
+    async hydrateIssueContext(projectId, normalized) {
+        if (!normalized.issue) {
+            return normalized;
+        }
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
+            return normalized;
+        }
+        if (hasCompleteIssueContext(normalized.issue)) {
+            return normalized;
+        }
+        const linear = await this.linearProvider.forProject(projectId);
+        if (!linear) {
+            return normalized;
+        }
+        try {
+            const liveIssue = await linear.getIssue(normalized.issue.id);
+            return {
+                ...normalized,
+                issue: mergeIssueMetadata(normalized.issue, liveIssue),
+            };
+        }
+        catch (error) {
+            this.logger.warn({
+                projectId,
+                issueId: normalized.issue.id,
+                triggerEvent: normalized.triggerEvent,
+                error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
+            }, "Failed to hydrate sparse Linear issue context for agent session webhook");
+            return normalized;
+        }
+    }
     assignEventReceiptContext(webhookId, projectId, linearIssueId) {
         const receipt = this.lookupEventReceipt(webhookId);
         if (!receipt) {
@@ -234,6 +269,24 @@ export class ServiceWebhookProcessor {
         return this.stores.eventReceipts.getEventReceipt(inserted.id);
     }
 }
+function hasCompleteIssueContext(issue) {
+    return Boolean(issue.stateName && issue.delegateId && issue.teamId && issue.teamKey);
+}
+function mergeIssueMetadata(issue, liveIssue) {
+    return {
+        ...issue,
+        ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
+        ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
+        ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
+        ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
+        ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),
+        ...(issue.stateName ? {} : liveIssue.stateName ? { stateName: liveIssue.stateName } : {}),
+        ...(issue.delegateId ? {} : liveIssue.delegateId ? { delegateId: liveIssue.delegateId } : {}),
+        ...(issue.delegateName ? {} : liveIssue.delegateName ? { delegateName: liveIssue.delegateName } : {}),
+        labelNames: issue.labelNames.length > 0 ? issue.labelNames : (liveIssue.labels ?? []).map((label) => label.name),
+    };
+}
 function describeWebhookObservation(normalized, delegatedToPatchRelay) {
     switch (normalized.triggerEvent) {
         case "delegateChanged":

package/dist/service-webhooks.js

@@ -1,4 +1,3 @@
-import { archiveWebhook } from "./webhook-archive.js";
 import { normalizeWebhook } from "./webhooks.js";
 import { redactSensitiveHeaders, timestampMsWithinSkew, verifyHmacSha256Hex } from "./utils.js";
 export async function acceptIncomingWebhook(params) {
@@ -35,15 +34,6 @@ export async function acceptIncomingWebhook(params) {
     const headersJson = JSON.stringify(sanitizedHeaders);
     const payloadJson = JSON.stringify(payload);
     logWebhookSummary(params.logger, normalized);
-    await archiveAcceptedPayload({
-        config: params.config,
-        logger: params.logger,
-        webhookId: params.webhookId,
-        receivedAt,
-        headers: params.headers,
-        rawBody: params.rawBody,
-        payload,
-    });
     const stored = params.stores.webhookEvents.insertWebhookEvent({
         webhookId: params.webhookId,
         receivedAt,
@@ -127,22 +117,3 @@ function logWebhookSummary(logger, normalized) {
         issueId: normalized.issue?.id,
     }, "Webhook metadata");
 }
-async function archiveAcceptedPayload(params) {
-    if (!params.config.logging.webhookArchiveDir) {
-        return;
-    }
-    try {
-        const archivePath = await archiveWebhook({
-            archiveDir: params.config.logging.webhookArchiveDir,
-            webhookId: params.webhookId,
-            receivedAt: params.receivedAt,
-            headers: redactSensitiveHeaders(params.headers),
-            rawBody: params.rawBody,
-            payload: params.payload,
-        });
-        params.logger.debug({ webhookId: params.webhookId, archivePath }, "Archived webhook to local file");
-    }
-    catch (error) {
-        params.logger.error({ webhookId: params.webhookId, error }, "Failed to archive webhook to local file");
-    }
-}

package/dist/stage-agent-activity-publisher.js

@@ -8,7 +8,7 @@ export class StageAgentActivityPublisher {
         this.linearProvider = linearProvider;
         this.logger = logger;
     }
-    async publishForSession(projectId, agentSessionId, content) {
+    async publishForSession(projectId, agentSessionId, content, options) {
         const linear = await this.linearProvider.forProject(projectId);
         if (!linear) {
             return;
@@ -17,7 +17,7 @@ export class StageAgentActivityPublisher {
             await linear.createAgentActivity({
                 agentSessionId,
                 content,
-                ephemeral: content.type === "thought" || content.type === "action",
+                ephemeral: options?.ephemeral ?? (content.type === "thought" || content.type === "action"),
             });
         }
         catch (error) {
@@ -27,11 +27,11 @@ export class StageAgentActivityPublisher {
             }, "Failed to publish Linear agent activity");
         }
     }
-    async publishForIssue(issue, content) {
+    async publishForIssue(issue, content, options) {
         if (!issue.activeAgentSessionId) {
             return;
         }
-        await this.publishForSession(issue.projectId, issue.activeAgentSessionId, content);
+        await this.publishForSession(issue.projectId, issue.activeAgentSessionId, content, options);
     }
     async updateSession(params) {
         const linear = await this.linearProvider.forProject(params.projectId);

package/dist/stage-lifecycle-publisher.js

@@ -84,12 +84,9 @@ export class StageLifecyclePublisher {
             await linear.createAgentActivity({
                 agentSessionId: issue.activeAgentSessionId,
                 content: {
-                    type: "action",
-                    action: "running_workflow",
-                    parameter: stage,
-                    result: `PatchRelay started the ${stage} workflow.`,
+                    type: "thought",
+                    body: `PatchRelay started the ${stage} workflow and is working in the background.`,
                 },
-                ephemeral: true,
             });
             return true;
         }

package/dist/webhook-agent-session-handler.js

@@ -66,9 +66,9 @@ export class AgentSessionWebhookHandler {
             if (desiredStage) {
                 await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
                 await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "response",
-                    body: `PatchRelay picked this up and is preparing the ${desiredStage} workflow.`,
-                });
+                    type: "thought",
+                    body: `PatchRelay started working on the ${desiredStage} workflow and is preparing the workspace.`,
+                }, { ephemeral: false });
                 return;
             }
             if (activeStage) {
@@ -137,9 +137,9 @@ export class AgentSessionWebhookHandler {
         if (!activeRunLease && desiredStage) {
             await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
             await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "response",
-                body: `PatchRelay received your prompt and is preparing the ${desiredStage} workflow.`,
-            });
+                type: "thought",
+                body: `PatchRelay is preparing the ${desiredStage} workflow from your latest prompt.`,
+            }, { ephemeral: false });
             return;
         }
         if (!activeRunLease && !desiredStage && (promptBody || promptContext)) {

package/dist/webhooks.js

@@ -1,9 +1,55 @@
+function getPayloadRecord(payload) {
+    return payload;
+}
+function getPayloadData(payload) {
+    return asRecord(getPayloadRecord(payload).data) ?? getPayloadRecord(payload);
+}
+function getNestedRecord(record, path) {
+    let current = record;
+    for (const segment of path) {
+        const currentRecord = asRecord(current);
+        if (!currentRecord) {
+            return undefined;
+        }
+        current = currentRecord[segment];
+    }
+    return asRecord(current);
+}
+function getFirstNestedRecord(record, paths) {
+    for (const path of paths) {
+        const candidate = getNestedRecord(record, path);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function looksLikeIssueRecord(record) {
+    if (!record) {
+        return false;
+    }
+    return Boolean(getString(record, "identifier") ||
+        getString(record, "title") ||
+        getString(record, "delegateId") ||
+        asRecord(record.delegate) ||
+        asRecord(record.team) ||
+        asRecord(record.state) ||
+        Array.isArray(record.labels));
+}
 function deriveTriggerEvent(payload) {
-    if (payload.type === "AgentSessionEvent") {
-        if (payload.action === "created") {
+    const data = getPayloadData(payload);
+    const hasAgentSession = Boolean(getFirstNestedRecord(data, [
+        ["agentSession"],
+        ["session"],
+        ["agentSessionEvent", "agentSession"],
+        ["payload", "agentSession"],
+        ["resource", "agentSession"],
+    ])) || Boolean(getString(data, "agentSessionId"));
+    if (payload.type === "AgentSessionEvent" || payload.type === "AgentSession" || hasAgentSession) {
+        if (payload.action === "created" || payload.action === "create") {
             return "agentSessionCreated";
         }
-        if (payload.action === "prompted") {
+        if (payload.action === "prompted" || payload.action === "prompt") {
             return "agentPrompted";
         }
         return "issueUpdated";
@@ -93,28 +139,42 @@ function extractLabelNames(record) {
     return [];
 }
 function extractIssueMetadata(payload) {
-    const data = asRecord(payload.data);
-    if (!data) {
-        return undefined;
-    }
+    const data = getPayloadData(payload);
+    const sessionRecord = getFirstNestedRecord(data, [
+        ["agentSession"],
+        ["session"],
+        ["agentSessionEvent", "agentSession"],
+        ["payload", "agentSession"],
+        ["resource", "agentSession"],
+    ]) ?? data;
+    const commentRecord = getFirstNestedRecord(data, [["comment"]]);
+    const notificationRecord = getFirstNestedRecord(data, [["notification"]]) ?? data;
     const issueRecord = payload.type === "Issue"
         ? data
-        : payload.type === "AgentSessionEvent"
-            ? (() => {
-                const sessionRecord = asRecord(data.agentSession) ?? data;
-                return asRecord(sessionRecord.issue) ?? asRecord(data.issue) ?? sessionRecord;
-            })()
-            : payload.type === "AppUserNotification"
-                ? (() => {
-                    const notificationRecord = asRecord(data.notification) ?? data;
-                    return (asRecord(notificationRecord.issue) ??
-                        asRecord(asRecord(notificationRecord.comment)?.issue) ??
-                        asRecord(data.issue));
-                })()
-                : (() => {
-                    const nestedIssue = asRecord(data.issue);
-                    return nestedIssue ?? data;
-                })();
+        : payload.type === "AppUserNotification"
+            ? getFirstNestedRecord(notificationRecord, [["issue"], ["comment", "issue"]]) ?? getFirstNestedRecord(data, [["issue"]])
+            : getFirstNestedRecord(data, [
+                ["issue"],
+                ["agentSession", "issue"],
+                ["session", "issue"],
+                ["agentSessionEvent", "issue"],
+                ["agentSessionEvent", "agentSession", "issue"],
+                ["payload", "issue"],
+                ["payload", "agentSession", "issue"],
+                ["resource", "issue"],
+                ["resource", "agentSession", "issue"],
+                ["comment", "issue"],
+                ["comment", "parent", "issue"],
+                ["comment", "commentThread", "issue"],
+                ["comment", "parentEntity", "issue"],
+                ["parent", "issue"],
+                ["commentThread", "issue"],
+                ["parentEntity", "issue"],
+                ["notification", "issue"],
+                ["notification", "comment", "issue"],
+            ]) ??
+                (looksLikeIssueRecord(sessionRecord) ? sessionRecord : undefined) ??
+                (looksLikeIssueRecord(commentRecord) ? commentRecord : undefined);
     if (!issueRecord) {
         return undefined;
     }
@@ -184,16 +244,24 @@ function extractActorMetadata(payload) {
     return fallbacks.find(Boolean);
 }
 function extractCommentMetadata(payload) {
-    if (payload.type !== "Comment") {
-        return undefined;
-    }
-    const data = asRecord(payload.data);
-    if (!data) {
+    const data = getPayloadData(payload);
+    const commentRecord = payload.type === "Comment"
+        ? data
+        : getFirstNestedRecord(data, [
+            ["comment"],
+            ["agentSession", "comment"],
+            ["session", "comment"],
+            ["agentSessionEvent", "comment"],
+            ["payload", "comment"],
+            ["resource", "comment"],
+            ["notification", "comment"],
+        ]);
+    if (!commentRecord) {
         return undefined;
     }
-    const id = getString(data, "id");
-    const body = getString(data, "body");
-    const userRecord = asRecord(data.user);
+    const id = getString(commentRecord, "id");
+    const body = getString(commentRecord, "body");
+    const userRecord = asRecord(commentRecord.user);
     const userName = getString(userRecord ?? {}, "name");
     if (!id) {
         return undefined;
@@ -205,23 +273,43 @@ function extractCommentMetadata(payload) {
     };
 }
 function extractAgentSessionMetadata(payload) {
-    if (payload.type !== "AgentSessionEvent") {
+    const data = getPayloadData(payload);
+    const sessionRecord = getFirstNestedRecord(data, [
+        ["agentSession"],
+        ["session"],
+        ["agentSessionEvent", "agentSession"],
+        ["payload", "agentSession"],
+        ["resource", "agentSession"],
+    ]) ?? (payload.type === "AgentSession" ? data : undefined);
+    if (payload.type !== "AgentSessionEvent" && payload.type !== "AgentSession" && !sessionRecord && !getString(data, "agentSessionId")) {
         return undefined;
     }
-    const data = asRecord(payload.data);
-    if (!data) {
-        return undefined;
-    }
-    const sessionRecord = asRecord(data.agentSession) ?? data;
-    const id = getString(sessionRecord, "id") ?? getString(data, "agentSessionId");
+    const id = getString(sessionRecord ?? {}, "id") ?? getString(data, "agentSessionId");
     if (!id) {
         return undefined;
     }
-    const agentActivity = asRecord(data.agentActivity);
-    const commentRecord = asRecord(data.comment) ?? asRecord(sessionRecord.comment);
-    const promptContext = getString(data, "promptContext") ?? getString(sessionRecord, "promptContext");
-    const promptBody = getString(agentActivity ?? {}, "body") ?? getString(commentRecord ?? {}, "body");
-    const issueCommentId = getString(commentRecord ?? {}, "id");
+    const agentActivity = getFirstNestedRecord(data, [
+        ["agentActivity"],
+        ["agentSession", "agentActivity"],
+        ["session", "agentActivity"],
+        ["agentSessionEvent", "agentActivity"],
+        ["payload", "agentActivity"],
+        ["resource", "agentActivity"],
+    ]);
+    const commentRecord = getFirstNestedRecord(data, [
+        ["comment"],
+        ["agentSession", "comment"],
+        ["session", "comment"],
+        ["agentSessionEvent", "comment"],
+        ["payload", "comment"],
+        ["resource", "comment"],
+    ]) ??
+        getFirstNestedRecord(sessionRecord, [["comment"]]);
+    const promptContext = getString(data, "promptContext") ?? getString(sessionRecord ?? {}, "promptContext");
+    const promptBody = getString(agentActivity ?? {}, "body") ??
+        getString(commentRecord ?? {}, "body") ??
+        getString(data, "body");
+    const issueCommentId = getString(commentRecord ?? {}, "id") ?? getString(data, "issueCommentId");
     return {
         id,
         ...(promptContext ? { promptContext } : {}),
@@ -230,10 +318,7 @@ function extractAgentSessionMetadata(payload) {
     };
 }
 function extractInstallationMetadata(payload) {
-    const data = asRecord(payload.data);
-    if (!data) {
-        return undefined;
-    }
+    const data = getPayloadData(payload);
     if (payload.type === "PermissionChange") {
         const organizationId = getString(data, "organizationId");
         const oauthClientId = getString(data, "oauthClientId");

package/package.json

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

package/dist/webhook-archive.js

@@ -1,24 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-const REDACTED_HEADERS = new Set(["authorization", "cookie", "set-cookie", "linear-signature"]);
-function sanitizePathSegment(value) {
-    return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
-}
-export async function archiveWebhook(params) {
-    const datePrefix = params.receivedAt.slice(0, 10);
-    const directory = path.join(params.archiveDir, datePrefix);
-    const fileName = `${params.receivedAt.replace(/[:.]/g, "-")}-${sanitizePathSegment(params.webhookId)}.json`;
-    const filePath = path.join(directory, fileName);
-    await mkdir(directory, { recursive: true });
-    await writeFile(filePath, JSON.stringify({
-        webhookId: params.webhookId,
-        receivedAt: params.receivedAt,
-        headers: redactHeaders(params.headers),
-        rawBodyUtf8: params.rawBody.toString("utf8"),
-        payload: params.payload,
-    }, null, 2), "utf8");
-    return filePath;
-}
-function redactHeaders(headers) {
-    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, REDACTED_HEADERS.has(key.toLowerCase()) ? "[redacted]" : value]));
-}