@penclipai/server 2026.511.1 → 2026.512.0

package/dist/services/issues.js

@@ -10,6 +10,7 @@ import { buildInitialIssueMonitorFields, normalizeIssueExecutionPolicy } from ".
 import { instanceSettingsService } from "./instance-settings.js";
 import { redactCurrentUserText } from "../log-redaction.js";
 import { resolveIssueGoalId, resolveNextIssueGoalId } from "./issue-goal-fallback.js";
+import { getRunLogStore } from "./run-log-store.js";
 import { getDefaultCompanyGoal } from "./goals.js";
 import { isVerifiedIssueTreeControlInteractionWake, issueTreeControlService, } from "./issue-tree-control.js";
 import { parseIssueGraphLivenessIncidentKey } from "./recovery/origins.js";
@@ -21,6 +22,10 @@ const ISSUE_LIST_RELATED_QUERY_CHUNK_SIZE = 500;
 export const MAX_CHILD_ISSUES_CREATED_BY_HELPER = 25;
 const MAX_CHILD_COMPLETION_SUMMARIES = 20;
 const CHILD_COMPLETION_SUMMARY_BODY_MAX_CHARS = 500;
+const ISSUE_COMMENT_RUN_LOG_DERIVATION_MAX_LOG_BYTES = 2_000_000;
+const ISSUE_COMMENT_RUN_LOG_DERIVATION_CHUNK_BYTES = 256_000;
+const ISSUE_COMMENT_RUN_LOG_DERIVATION_END_SLACK_MS = 60_000;
+const ISSUE_COMMENT_RUN_LOG_DERIVATION_MAX_PARALLEL_READS = 8;
 function assertTransition(from, to) {
     if (from === to)
         return;
@@ -56,6 +61,52 @@ function buildReusedExecutionWorkspaceConfigPatchFromIssueSettings(settings) {
         workspaceRuntime: settings?.workspaceRuntime ?? null,
     };
 }
+function toTimestampMs(value) {
+    if (!value)
+        return null;
+    const date = value instanceof Date ? value : new Date(value);
+    const timestamp = date.getTime();
+    return Number.isFinite(timestamp) ? timestamp : null;
+}
+export function deriveIssueCommentRunLogAttribution(comments, runs) {
+    const derivedByCommentId = new Map();
+    for (const comment of comments) {
+        if (comment.authorAgentId || !comment.authorUserId || comment.createdByRunId)
+            continue;
+        const commentCreatedAtMs = toTimestampMs(comment.createdAt);
+        if (commentCreatedAtMs === null)
+            continue;
+        let bestMatch = null;
+        for (const run of runs) {
+            const runStartMs = toTimestampMs(run.startedAt ?? run.createdAt);
+            const runEndMs = toTimestampMs(run.finishedAt ?? run.createdAt);
+            if (runStartMs === null || runEndMs === null)
+                continue;
+            if (commentCreatedAtMs < runStartMs
+                || commentCreatedAtMs > runEndMs + ISSUE_COMMENT_RUN_LOG_DERIVATION_END_SLACK_MS) {
+                continue;
+            }
+            if (!run.logContent.includes(`comment id: ${comment.id}`))
+                continue;
+            const distanceMs = Math.abs(runEndMs - commentCreatedAtMs);
+            if (!bestMatch || distanceMs < bestMatch.distanceMs) {
+                bestMatch = {
+                    runId: run.runId,
+                    agentId: run.agentId,
+                    distanceMs,
+                };
+            }
+        }
+        if (!bestMatch)
+            continue;
+        derivedByCommentId.set(comment.id, {
+            derivedAuthorAgentId: bestMatch.agentId,
+            derivedCreatedByRunId: bestMatch.runId,
+            derivedAuthorSource: "run_log_comment_post",
+        });
+    }
+    return derivedByCommentId;
+}
 function sameRunLock(checkoutRunId, actorRunId) {
     if (actorRunId)
         return checkoutRunId === actorRunId;
@@ -1272,6 +1323,94 @@ export function issueService(db) {
             metadata: issueCommentMetadataSchema.nullable().catch(null).parse(comment.metadata ?? null),
         };
     }
+    async function readRunLogText(run) {
+        if (run.logStore !== "local_file" || !run.logRef)
+            return "";
+        const logBytes = Number(run.logBytes ?? 0);
+        if (!Number.isFinite(logBytes) || logBytes <= 0)
+            return "";
+        const store = getRunLogStore();
+        let offset = 0;
+        let content = "";
+        let nextOffset = 0;
+        while (nextOffset !== undefined) {
+            const remainingBytes = ISSUE_COMMENT_RUN_LOG_DERIVATION_MAX_LOG_BYTES - Buffer.byteLength(content, "utf8");
+            if (remainingBytes <= 0)
+                break;
+            const chunk = await store.read({ store: "local_file", logRef: run.logRef }, {
+                offset,
+                limitBytes: Math.min(ISSUE_COMMENT_RUN_LOG_DERIVATION_CHUNK_BYTES, remainingBytes),
+            });
+            content += chunk.content;
+            nextOffset = chunk.nextOffset;
+            offset = chunk.nextOffset ?? 0;
+        }
+        return content;
+    }
+    async function enrichCommentsWithDerivedAgentAttribution(comments) {
+        const candidates = comments.filter((comment) => !comment.authorAgentId
+            && !!comment.authorUserId
+            && !comment.createdByRunId);
+        if (candidates.length === 0)
+            return comments;
+        const companyId = comments[0]?.companyId ?? null;
+        const issueId = comments[0]?.issueId ?? null;
+        if (!companyId || !issueId)
+            return comments;
+        const minCommentCreatedAtMs = candidates.reduce((min, comment) => {
+            const timestamp = toTimestampMs(comment.createdAt);
+            if (timestamp === null)
+                return min;
+            return min === null ? timestamp : Math.min(min, timestamp);
+        }, null);
+        const maxCommentCreatedAtMs = candidates.reduce((max, comment) => {
+            const timestamp = toTimestampMs(comment.createdAt);
+            if (timestamp === null)
+                return max;
+            return max === null ? timestamp : Math.max(max, timestamp);
+        }, null);
+        if (minCommentCreatedAtMs === null || maxCommentCreatedAtMs === null)
+            return comments;
+        const runs = await db
+            .select({
+            runId: heartbeatRuns.id,
+            agentId: heartbeatRuns.agentId,
+            createdAt: heartbeatRuns.createdAt,
+            startedAt: heartbeatRuns.startedAt,
+            finishedAt: heartbeatRuns.finishedAt,
+            logStore: heartbeatRuns.logStore,
+            logRef: heartbeatRuns.logRef,
+            logBytes: heartbeatRuns.logBytes,
+        })
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.companyId, companyId), or(sql `${heartbeatRuns.contextSnapshot} ->> 'issueId' = ${issueId}`, sql `exists (
+              select 1
+              from ${activityLog}
+              where ${activityLog.companyId} = ${companyId}
+                and ${activityLog.entityType} = 'issue'
+                and ${activityLog.entityId} = ${issueId}
+                and ${activityLog.runId} = ${heartbeatRuns.id}
+            )`), sql `coalesce(${heartbeatRuns.finishedAt}, ${heartbeatRuns.createdAt}) >= ${new Date(minCommentCreatedAtMs)}`, sql `coalesce(${heartbeatRuns.startedAt}, ${heartbeatRuns.createdAt}) <= ${new Date(maxCommentCreatedAtMs + ISSUE_COMMENT_RUN_LOG_DERIVATION_END_SLACK_MS)}`))
+            .orderBy(desc(heartbeatRuns.createdAt));
+        if (runs.length === 0)
+            return comments;
+        const runsWithLogs = [];
+        for (let index = 0; index < runs.length; index += ISSUE_COMMENT_RUN_LOG_DERIVATION_MAX_PARALLEL_READS) {
+            const batch = runs.slice(index, index + ISSUE_COMMENT_RUN_LOG_DERIVATION_MAX_PARALLEL_READS);
+            const batchWithLogs = await Promise.all(batch.map(async (run) => ({
+                ...run,
+                logContent: await readRunLogText(run),
+            })));
+            runsWithLogs.push(...batchWithLogs);
+        }
+        const derivedByCommentId = deriveIssueCommentRunLogAttribution(candidates, runsWithLogs);
+        if (derivedByCommentId.size === 0)
+            return comments;
+        return comments.map((comment) => {
+            const derived = derivedByCommentId.get(comment.id);
+            return derived ? { ...comment, ...derived } : comment;
+        });
+    }
     async function assertAssignableAgent(companyId, agentId) {
         const assignee = await db
             .select({
@@ -2857,7 +2996,8 @@ export function issueService(db) {
                 .orderBy(order === "asc" ? asc(issueComments.createdAt) : desc(issueComments.createdAt), order === "asc" ? asc(issueComments.id) : desc(issueComments.id));
             const comments = limit ? await query.limit(limit) : await query;
             const { censorUsernameInLogs } = await instanceSettings.getGeneral();
-            return comments.map((comment) => redactIssueComment(comment, censorUsernameInLogs));
+            const enrichedComments = await enrichCommentsWithDerivedAgentAttribution(comments);
+            return enrichedComments.map((comment) => redactIssueComment(comment, censorUsernameInLogs));
         },
         getCommentCursor: async (issueId) => {
             const [latest, countRow] = await Promise.all([
@@ -2885,14 +3025,18 @@ export function issueService(db) {
                 latestCommentAt: latest?.latestCommentAt ?? null,
             };
         },
-        getComment: (commentId) => instanceSettings.getGeneral().then(({ censorUsernameInLogs }) => db
-            .select()
-            .from(issueComments)
-            .where(eq(issueComments.id, commentId))
-            .then((rows) => {
-            const comment = rows[0] ?? null;
-            return comment ? redactIssueComment(comment, censorUsernameInLogs) : null;
-        })),
+        getComment: async (commentId) => {
+            const { censorUsernameInLogs } = await instanceSettings.getGeneral();
+            const comment = await db
+                .select()
+                .from(issueComments)
+                .where(eq(issueComments.id, commentId))
+                .then((rows) => rows[0] ?? null);
+            if (!comment)
+                return null;
+            const [enrichedComment] = await enrichCommentsWithDerivedAgentAttribution([comment]);
+            return redactIssueComment(enrichedComment ?? comment, censorUsernameInLogs);
+        },
         removeComment: async (commentId) => {
             const currentUserRedactionOptions = {
                 enabled: (await instanceSettings.getGeneral()).censorUsernameInLogs,