@penclipai/server 2026.426.0 → 2026.505.0

package/dist/services/issues.js

@@ -1,14 +1,18 @@
 import { Buffer } from "node:buffer";
-import { and, asc, desc, eq, inArray, isNull, ne, or, sql } from "drizzle-orm";
-import { activityLog, agentWakeupRequests, agents, assets, companies, companyMemberships, documents, goals, heartbeatRuns, executionWorkspaces, issueAttachments, issueInboxArchives, issueLabels, issueRelations, issueComments, issueDocuments, issueReadStates, issues, labels, projectWorkspaces, projects, } from "@penclipai/db";
-import { extractAgentMentionIds, extractProjectMentionIds, isUuidLike } from "@penclipai/shared";
+import { and, asc, desc, eq, gt, inArray, isNull, lt, ne, notInArray, or, sql } from "drizzle-orm";
+import { activityLog, agentWakeupRequests, agents, approvals, assets, companies, companyMemberships, documents, goals, heartbeatRuns, executionWorkspaces, issueApprovals, issueAttachments, issueInboxArchives, issueLabels, issueRelations, issueComments, issueDocuments, issueReadStates, issueThreadInteractions, issues, labels, projectWorkspaces, projects, } from "@penclipai/db";
+import { clampIssueRequestDepth, extractAgentMentionIds, extractProjectMentionIds, isUuidLike, normalizeIssueIdentifier as normalizeIssueReferenceIdentifier, } from "@penclipai/shared";
 import { conflict, notFound, unprocessable } from "../errors.js";
+import { parseObject } from "../adapters/utils.js";
 import { defaultIssueExecutionWorkspaceSettingsForProject, gateProjectExecutionWorkspacePolicy, issueExecutionWorkspaceModeForPersistedWorkspace, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, } from "./execution-workspace-policy.js";
+import { mergeExecutionWorkspaceConfig } from "./execution-workspaces.js";
+import { buildInitialIssueMonitorFields, normalizeIssueExecutionPolicy } from "./issue-execution-policy.js";
 import { instanceSettingsService } from "./instance-settings.js";
 import { redactCurrentUserText } from "../log-redaction.js";
 import { resolveIssueGoalId, resolveNextIssueGoalId } from "./issue-goal-fallback.js";
 import { getDefaultCompanyGoal } from "./goals.js";
 import { isVerifiedIssueTreeControlInteractionWake, issueTreeControlService, } from "./issue-tree-control.js";
+import { parseIssueGraphLivenessIncidentKey } from "./recovery/origins.js";
 const ALL_ISSUE_STATUSES = ["backlog", "todo", "in_progress", "in_review", "blocked", "done", "cancelled"];
 const MAX_ISSUE_COMMENT_PAGE_LIMIT = 500;
 export const ISSUE_LIST_DEFAULT_LIMIT = 500;
@@ -44,6 +48,14 @@ function readStringFromRecord(record, key) {
     const value = record[key];
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function buildReusedExecutionWorkspaceConfigPatchFromIssueSettings(settings) {
+    return {
+        environmentId: settings?.environmentId ?? null,
+        provisionCommand: settings?.workspaceStrategy?.provisionCommand ?? null,
+        teardownCommand: settings?.workspaceStrategy?.teardownCommand ?? null,
+        workspaceRuntime: settings?.workspaceRuntime ?? null,
+    };
+}
 function sameRunLock(checkoutRunId, actorRunId) {
     if (actorRunId)
         return checkoutRunId === actorRunId;
@@ -463,6 +475,21 @@ async function withIssueLabels(dbOrTx, rows) {
 const ACTIVE_RUN_STATUSES = ["queued", "running"];
 const BLOCKER_ATTENTION_ACTIVE_RUN_STATUSES = ["queued", "running"];
 const BLOCKER_ATTENTION_ACTIVE_WAKE_STATUSES = ["queued", "deferred_issue_execution"];
+const BLOCKER_ATTENTION_PENDING_INTERACTION_STATUSES = ["pending"];
+const BLOCKER_ATTENTION_PENDING_APPROVAL_STATUSES = ["pending", "revision_requested"];
+const BLOCKER_ATTENTION_OPEN_RECOVERY_ORIGIN_KIND = "harness_liveness_escalation";
+const PRODUCTIVITY_REVIEW_ORIGIN_KIND = "issue_productivity_review";
+const PRODUCTIVITY_REVIEW_TERMINAL_STATUSES = ["done", "cancelled"];
+const PRODUCTIVITY_REVIEW_ACTIVITY_ACTIONS = [
+    "issue.productivity_review_created",
+    "issue.productivity_review_updated",
+];
+const PRODUCTIVITY_REVIEW_TRIGGERS = [
+    "no_comment_streak",
+    "long_active_duration",
+    "high_churn",
+];
+const BLOCKER_ATTENTION_OPEN_RECOVERY_TERMINAL_STATUSES = ["done", "cancelled"];
 const BLOCKER_ATTENTION_MAX_DEPTH = 8;
 const BLOCKER_ATTENTION_MAX_NODES = 2000;
 const BLOCKER_ATTENTION_INVOKABLE_AGENT_STATUSES = new Set(["active", "idle", "running", "error"]);
@@ -499,8 +526,10 @@ function createIssueBlockerAttention(input = {}) {
         reason: input.reason ?? null,
         unresolvedBlockerCount: input.unresolvedBlockerCount ?? 0,
         coveredBlockerCount: input.coveredBlockerCount ?? 0,
+        stalledBlockerCount: input.stalledBlockerCount ?? 0,
         attentionBlockerCount: input.attentionBlockerCount ?? 0,
         sampleBlockerIdentifier: input.sampleBlockerIdentifier ?? null,
+        sampleStalledBlockerIdentifier: input.sampleStalledBlockerIdentifier ?? null,
     };
 }
 function blockerSampleIdentifier(node) {
@@ -594,6 +623,81 @@ async function terminalExplicitBlockersByRoot(companyId, roots, dbOrTx) {
     }
     return terminalByRoot;
 }
+function readProductivityReviewTrigger(value) {
+    if (typeof value !== "string")
+        return null;
+    return PRODUCTIVITY_REVIEW_TRIGGERS.includes(value)
+        ? value
+        : null;
+}
+function readProductivityReviewStreak(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        return null;
+    return Math.floor(value);
+}
+async function listIssueProductivityReviewMap(dbOrTx, companyId, sourceIssueIds) {
+    const map = new Map();
+    if (sourceIssueIds.length === 0)
+        return map;
+    const reviewRows = [];
+    for (const chunk of chunkList([...new Set(sourceIssueIds)], ISSUE_LIST_RELATED_QUERY_CHUNK_SIZE)) {
+        const rows = await dbOrTx
+            .select({
+            sourceIssueId: issues.originId,
+            reviewIssueId: issues.id,
+            reviewIdentifier: issues.identifier,
+            status: issues.status,
+            priority: issues.priority,
+            createdAt: issues.createdAt,
+            updatedAt: issues.updatedAt,
+        })
+            .from(issues)
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, PRODUCTIVITY_REVIEW_ORIGIN_KIND), inArray(issues.originId, chunk), isNull(issues.hiddenAt), notInArray(issues.status, PRODUCTIVITY_REVIEW_TERMINAL_STATUSES)))
+            .orderBy(desc(issues.createdAt), desc(issues.id));
+        reviewRows.push(...rows);
+    }
+    if (reviewRows.length === 0)
+        return map;
+    const reviewIssueIds = reviewRows.map((row) => row.reviewIssueId);
+    const triggerByReviewIssueId = new Map();
+    for (const chunk of chunkList(reviewIssueIds, ISSUE_LIST_RELATED_QUERY_CHUNK_SIZE)) {
+        const detailRows = await dbOrTx
+            .select({
+            entityId: activityLog.entityId,
+            details: activityLog.details,
+            createdAt: activityLog.createdAt,
+        })
+            .from(activityLog)
+            .where(and(eq(activityLog.companyId, companyId), eq(activityLog.entityType, "issue"), inArray(activityLog.entityId, chunk), inArray(activityLog.action, PRODUCTIVITY_REVIEW_ACTIVITY_ACTIONS)))
+            .orderBy(desc(activityLog.createdAt));
+        for (const row of detailRows) {
+            if (triggerByReviewIssueId.has(row.entityId))
+                continue;
+            triggerByReviewIssueId.set(row.entityId, {
+                trigger: readProductivityReviewTrigger(row.details?.trigger),
+                noCommentStreak: readProductivityReviewStreak(row.details?.noCommentStreak),
+            });
+        }
+    }
+    for (const row of reviewRows) {
+        if (!row.sourceIssueId)
+            continue;
+        if (map.has(row.sourceIssueId))
+            continue;
+        const detail = triggerByReviewIssueId.get(row.reviewIssueId);
+        map.set(row.sourceIssueId, {
+            reviewIssueId: row.reviewIssueId,
+            reviewIdentifier: row.reviewIdentifier,
+            status: row.status,
+            priority: row.priority,
+            trigger: detail?.trigger ?? null,
+            noCommentStreak: detail?.noCommentStreak ?? null,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        });
+    }
+    return map;
+}
 async function listIssueBlockerAttentionMap(dbOrTx, companyId, issueRows) {
     const roots = issueRows.filter((row) => row.companyId === companyId && row.status === "blocked");
     const attentionMap = new Map();
@@ -719,6 +823,42 @@ async function listIssueBlockerAttentionMap(dbOrTx, companyId, issueRows) {
                 activeIssueIds.add(row.issueId);
         }
     }
+    const explicitWaitCandidateIds = [...nodesById.values()]
+        .filter((node) => node.status !== "done")
+        .map((node) => node.id);
+    const explicitWaitingIssueIds = new Set();
+    if (explicitWaitCandidateIds.length > 0) {
+        for (const chunk of chunkList(explicitWaitCandidateIds, ISSUE_LIST_RELATED_QUERY_CHUNK_SIZE)) {
+            const interactionRows = await dbOrTx
+                .select({ issueId: issueThreadInteractions.issueId })
+                .from(issueThreadInteractions)
+                .where(and(eq(issueThreadInteractions.companyId, companyId), inArray(issueThreadInteractions.status, BLOCKER_ATTENTION_PENDING_INTERACTION_STATUSES), inArray(issueThreadInteractions.issueId, chunk)));
+            for (const row of interactionRows)
+                explicitWaitingIssueIds.add(row.issueId);
+            const approvalRows = await dbOrTx
+                .select({ issueId: issueApprovals.issueId })
+                .from(issueApprovals)
+                .innerJoin(approvals, eq(issueApprovals.approvalId, approvals.id))
+                .where(and(eq(issueApprovals.companyId, companyId), inArray(approvals.status, BLOCKER_ATTENTION_PENDING_APPROVAL_STATUSES), inArray(issueApprovals.issueId, chunk)));
+            for (const row of approvalRows)
+                explicitWaitingIssueIds.add(row.issueId);
+        }
+        // Recovery rows are intentionally company-wide: a liveness escalation for
+        // the same leaf blocker represents an active waiting path even when that
+        // blocker is reached through another blocked graph.
+        const recoveryRows = await dbOrTx
+            .select({ id: issues.id, originId: issues.originId })
+            .from(issues)
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, BLOCKER_ATTENTION_OPEN_RECOVERY_ORIGIN_KIND), isNull(issues.hiddenAt), notInArray(issues.status, BLOCKER_ATTENTION_OPEN_RECOVERY_TERMINAL_STATUSES)));
+        for (const row of recoveryRows) {
+            const parsed = parseIssueGraphLivenessIncidentKey(row.originId);
+            if (!parsed || parsed.companyId !== companyId)
+                continue;
+            explicitWaitingIssueIds.add(row.id);
+            explicitWaitingIssueIds.add(parsed.issueId);
+            explicitWaitingIssueIds.add(parsed.leafIssueId);
+        }
+    }
     const agentRows = agentIds.size > 0
         ? await dbOrTx
             .select({
@@ -731,37 +871,73 @@ async function listIssueBlockerAttentionMap(dbOrTx, companyId, issueRows) {
         : [];
     const agentsById = new Map(agentRows.map((agent) => [agent.id, agent]));
     const classifyPath = (nodeId, seen) => {
-        if (truncated || seen.has(nodeId))
-            return { covered: false, sampleBlockerIdentifier: blockerSampleIdentifier(nodesById.get(nodeId)) };
+        const sample = blockerSampleIdentifier(nodesById.get(nodeId));
+        if (truncated || seen.has(nodeId)) {
+            return { covered: false, stalled: false, sampleBlockerIdentifier: sample, sampleStalledBlockerIdentifier: null };
+        }
         const node = nodesById.get(nodeId);
-        if (!node || node.companyId !== companyId)
-            return { covered: false, sampleBlockerIdentifier: nodeId };
-        if (node.status === "done")
-            return { covered: true, sampleBlockerIdentifier: blockerSampleIdentifier(node) };
-        if (activeIssueIds.has(node.id))
-            return { covered: true, sampleBlockerIdentifier: blockerSampleIdentifier(node) };
-        if (node.status === "cancelled")
-            return { covered: false, sampleBlockerIdentifier: blockerSampleIdentifier(node) };
+        if (!node || node.companyId !== companyId) {
+            return { covered: false, stalled: false, sampleBlockerIdentifier: nodeId, sampleStalledBlockerIdentifier: null };
+        }
+        const nodeSample = blockerSampleIdentifier(node);
+        if (node.status === "done") {
+            return { covered: true, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
+        }
+        if (explicitWaitingIssueIds.has(node.id)) {
+            return { covered: true, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
+        }
+        if (node.status === "in_review") {
+            const hasWaitingPath = activeIssueIds.has(node.id) || Boolean(node.assigneeUserId);
+            if (hasWaitingPath) {
+                return { covered: true, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
+            }
+            return { covered: false, stalled: true, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: nodeSample };
+        }
+        if (activeIssueIds.has(node.id)) {
+            return { covered: true, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
+        }
+        if (node.status === "cancelled") {
+            return { covered: false, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
+        }
         const downstream = (edgesByIssueId.get(node.id) ?? []).filter((edge) => nodesById.get(edge.blockerIssueId)?.status !== "done");
         if (downstream.length > 0) {
             const nextSeen = new Set(seen);
             nextSeen.add(nodeId);
             const classified = downstream.map((edge) => classifyPath(edge.blockerIssueId, nextSeen));
-            const attention = classified.find((result) => !result.covered);
-            if (attention)
-                return attention;
+            const stalledChild = classified.find((result) => result.stalled || result.sampleStalledBlockerIdentifier);
+            const sampleStalled = stalledChild?.sampleStalledBlockerIdentifier ?? null;
+            const hardAttention = classified.find((result) => !result.covered && !result.stalled);
+            if (hardAttention) {
+                return {
+                    covered: false,
+                    stalled: false,
+                    sampleBlockerIdentifier: hardAttention.sampleBlockerIdentifier,
+                    sampleStalledBlockerIdentifier: sampleStalled,
+                };
+            }
+            const stalledEntry = classified.find((result) => result.stalled);
+            if (stalledEntry) {
+                return {
+                    covered: false,
+                    stalled: true,
+                    sampleBlockerIdentifier: stalledEntry.sampleBlockerIdentifier,
+                    sampleStalledBlockerIdentifier: sampleStalled,
+                };
+            }
             return {
                 covered: true,
-                sampleBlockerIdentifier: classified[0]?.sampleBlockerIdentifier ?? blockerSampleIdentifier(node),
+                stalled: false,
+                sampleBlockerIdentifier: classified[0]?.sampleBlockerIdentifier ?? nodeSample,
+                sampleStalledBlockerIdentifier: null,
             };
         }
         if (node.assigneeAgentId) {
             const assignee = agentsById.get(node.assigneeAgentId);
             if (!assignee || assignee.companyId !== companyId || !BLOCKER_ATTENTION_INVOKABLE_AGENT_STATUSES.has(assignee.status)) {
-                return { covered: false, sampleBlockerIdentifier: blockerSampleIdentifier(node) };
+                return { covered: false, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
             }
         }
-        return { covered: false, sampleBlockerIdentifier: blockerSampleIdentifier(node) };
+        return { covered: false, stalled: false, sampleBlockerIdentifier: nodeSample, sampleStalledBlockerIdentifier: null };
     };
     for (const root of roots) {
         const topLevelEdges = (edgesByIssueId.get(root.id) ?? []).filter((edge) => nodesById.get(edge.blockerIssueId)?.status !== "done");
@@ -777,21 +953,40 @@ async function listIssueBlockerAttentionMap(dbOrTx, companyId, issueRows) {
             result: classifyPath(edge.blockerIssueId, new Set([root.id])),
         }));
         const coveredBlockerCount = classified.filter((entry) => entry.result.covered).length;
-        const attentionBlockerCount = classified.length - coveredBlockerCount;
-        const attentionEntry = classified.find((entry) => !entry.result.covered);
-        const sampleEntry = attentionEntry ?? classified[0] ?? null;
+        const stalledBlockerCount = classified.filter((entry) => entry.result.stalled).length;
+        const attentionBlockerCount = classified.length - coveredBlockerCount - stalledBlockerCount;
+        const hardAttentionEntry = classified.find((entry) => !entry.result.covered && !entry.result.stalled);
+        const stalledEntry = classified.find((entry) => entry.result.stalled);
+        const sampleEntry = hardAttentionEntry ?? stalledEntry ?? classified[0] ?? null;
         const sampleNode = sampleEntry ? nodesById.get(sampleEntry.edge.blockerIssueId) : null;
+        const sampleStalledFromChain = classified
+            .map((entry) => entry.result.sampleStalledBlockerIdentifier)
+            .find((value) => value);
+        let state;
+        let reason;
+        if (attentionBlockerCount > 0) {
+            state = "needs_attention";
+            reason = "attention_required";
+        }
+        else if (stalledBlockerCount > 0) {
+            state = "stalled";
+            reason = "stalled_review";
+        }
+        else {
+            state = "covered";
+            reason = topLevelEdges.every((edge) => nodesById.get(edge.blockerIssueId)?.parentId === root.id)
+                ? "active_child"
+                : "active_dependency";
+        }
         attentionMap.set(root.id, createIssueBlockerAttention({
-            state: attentionBlockerCount === 0 ? "covered" : "needs_attention",
-            reason: attentionBlockerCount === 0
-                ? topLevelEdges.every((edge) => nodesById.get(edge.blockerIssueId)?.parentId === root.id)
-                    ? "active_child"
-                    : "active_dependency"
-                : "attention_required",
+            state,
+            reason,
             unresolvedBlockerCount: topLevelEdges.length,
             coveredBlockerCount,
+            stalledBlockerCount,
             attentionBlockerCount,
             sampleBlockerIdentifier: sampleEntry?.result.sampleBlockerIdentifier ?? blockerSampleIdentifier(sampleNode),
+            sampleStalledBlockerIdentifier: stalledEntry?.result.sampleStalledBlockerIdentifier ?? sampleStalledFromChain ?? null,
         }));
     }
     return attentionMap;
@@ -837,6 +1032,12 @@ const issueListSelect = {
     assigneeAdapterOverrides: issues.assigneeAdapterOverrides,
     executionPolicy: sql `null`,
     executionState: sql `null`,
+    monitorNextCheckAt: issues.monitorNextCheckAt,
+    monitorWakeRequestedAt: issues.monitorWakeRequestedAt,
+    monitorLastTriggeredAt: issues.monitorLastTriggeredAt,
+    monitorAttemptCount: issues.monitorAttemptCount,
+    monitorNotes: issues.monitorNotes,
+    monitorScheduledBy: issues.monitorScheduledBy,
     executionWorkspaceId: issues.executionWorkspaceId,
     executionWorkspacePreference: issues.executionWorkspacePreference,
     executionWorkspaceSettings: sql `null`,
@@ -935,6 +1136,49 @@ async function lastActivityStatsForIssues(dbOrTx, companyId, issueIds) {
     }
     return [...byIssueId.values()];
 }
+async function blockedByMapForIssues(dbOrTx, companyId, issueIds) {
+    const map = new Map();
+    const uniqueIssueIds = [...new Set(issueIds)];
+    if (uniqueIssueIds.length === 0)
+        return map;
+    for (const issueId of uniqueIssueIds) {
+        map.set(issueId, []);
+    }
+    for (const issueIdChunk of chunkList(uniqueIssueIds, ISSUE_LIST_RELATED_QUERY_CHUNK_SIZE)) {
+        const rows = await dbOrTx
+            .select({
+            currentIssueId: issueRelations.relatedIssueId,
+            relatedId: issues.id,
+            identifier: issues.identifier,
+            title: issues.title,
+            status: issues.status,
+            priority: issues.priority,
+            assigneeAgentId: issues.assigneeAgentId,
+            assigneeUserId: issues.assigneeUserId,
+        })
+            .from(issueRelations)
+            .innerJoin(issues, eq(issueRelations.issueId, issues.id))
+            .where(and(eq(issueRelations.companyId, companyId), eq(issueRelations.type, "blocks"), inArray(issueRelations.relatedIssueId, issueIdChunk)));
+        for (const row of rows) {
+            const blockedBy = map.get(row.currentIssueId);
+            if (!blockedBy)
+                continue;
+            blockedBy.push({
+                id: row.relatedId,
+                identifier: row.identifier,
+                title: row.title,
+                status: row.status,
+                priority: row.priority,
+                assigneeAgentId: row.assigneeAgentId,
+                assigneeUserId: row.assigneeUserId,
+            });
+        }
+    }
+    for (const blockedBy of map.values()) {
+        blockedBy.sort((a, b) => a.title.localeCompare(b.title));
+    }
+    return map;
+}
 export function issueService(db) {
     const instanceSettings = instanceSettingsService(db);
     const treeControlSvc = issueTreeControlService(db);
@@ -1298,10 +1542,14 @@ export function issueService(db) {
             const limit = typeof filters?.limit === "number" && Number.isFinite(filters.limit)
                 ? Math.max(1, Math.floor(filters.limit))
                 : undefined;
+            const offset = typeof filters?.offset === "number" && Number.isFinite(filters.offset)
+                ? Math.max(0, Math.floor(filters.offset))
+                : 0;
             const touchedByUserId = filters?.touchedByUserId?.trim() || undefined;
             const inboxArchivedByUserId = filters?.inboxArchivedByUserId?.trim() || undefined;
             const unreadForUserId = filters?.unreadForUserId?.trim() || undefined;
             const contextUserId = unreadForUserId ?? touchedByUserId ?? inboxArchivedByUserId;
+            const includeBlockedBy = filters?.includeBlockedBy === true;
             const rawSearch = filters?.q?.trim() ?? "";
             const hasSearch = rawSearch.length > 0;
             const escapedSearch = hasSearch ? escapeLikePattern(rawSearch) : "";
@@ -1408,8 +1656,11 @@ export function issueService(db) {
                 .select(issueListSelect)
                 .from(issues)
                 .where(and(...conditions))
-                .orderBy(hasSearch ? asc(searchOrder) : asc(priorityOrder), asc(priorityOrder), desc(canonicalLastActivityAt), desc(issues.updatedAt));
-            const rows = (limit === undefined ? await baseQuery : await baseQuery.limit(limit)).map((row) => ({
+                .orderBy(hasSearch ? asc(searchOrder) : asc(priorityOrder), asc(priorityOrder), desc(canonicalLastActivityAt), desc(issues.updatedAt), desc(issues.id));
+            const pageQuery = offset > 0
+                ? (limit === undefined ? baseQuery.offset(offset) : baseQuery.limit(limit).offset(offset))
+                : (limit === undefined ? baseQuery : baseQuery.limit(limit));
+            const rows = (await pageQuery).map((row) => ({
                 ...row,
                 description: decodeDatabaseTextPreview(row.description, ISSUE_LIST_DESCRIPTION_MAX_CHARS),
             }));
@@ -1420,7 +1671,7 @@ export function issueService(db) {
                 return withRuns;
             }
             const issueIds = withRuns.map((row) => row.id);
-            const [statsRows, readRows, lastActivityRows] = await Promise.all([
+            const [statsRows, readRows, lastActivityRows, blockedByMap] = await Promise.all([
                 contextUserId
                     ? userCommentStatsForIssues(db, companyId, contextUserId, issueIds)
                     : Promise.resolve([]),
@@ -1428,18 +1679,28 @@ export function issueService(db) {
                     ? userReadStatsForIssues(db, companyId, contextUserId, issueIds)
                     : Promise.resolve([]),
                 lastActivityStatsForIssues(db, companyId, issueIds),
+                includeBlockedBy
+                    ? blockedByMapForIssues(db, companyId, issueIds)
+                    : Promise.resolve(new Map()),
             ]);
             const statsByIssueId = new Map(statsRows.map((row) => [row.issueId, row]));
             const lastActivityByIssueId = new Map(lastActivityRows.map((row) => [row.issueId, row]));
-            const blockerAttentionByIssueId = await listIssueBlockerAttentionMap(db, companyId, withRuns);
+            const [blockerAttentionByIssueId, productivityReviewByIssueId] = await Promise.all([
+                listIssueBlockerAttentionMap(db, companyId, withRuns),
+                listIssueProductivityReviewMap(db, companyId, issueIds),
+            ]);
             if (!contextUserId) {
                 return withRuns.map((row) => {
                     const activity = lastActivityByIssueId.get(row.id);
                     const lastActivityAt = latestIssueActivityAt(row.updatedAt, activity?.latestCommentAt ?? null, activity?.latestLogAt ?? null) ?? row.updatedAt;
                     return {
                         ...row,
+                        ...(includeBlockedBy ? { blockedBy: blockedByMap.get(row.id) ?? [] } : {}),
                         lastActivityAt,
                         ...(blockerAttentionByIssueId.has(row.id) ? { blockerAttention: blockerAttentionByIssueId.get(row.id) } : {}),
+                        ...(productivityReviewByIssueId.has(row.id)
+                            ? { productivityReview: productivityReviewByIssueId.get(row.id) }
+                            : {}),
                     };
                 });
             }
@@ -1449,8 +1710,12 @@ export function issueService(db) {
                 const lastActivityAt = latestIssueActivityAt(row.updatedAt, activity?.latestCommentAt ?? null, activity?.latestLogAt ?? null) ?? row.updatedAt;
                 return {
                     ...row,
+                    ...(includeBlockedBy ? { blockedBy: blockedByMap.get(row.id) ?? [] } : {}),
                     lastActivityAt,
                     ...(blockerAttentionByIssueId.has(row.id) ? { blockerAttention: blockerAttentionByIssueId.get(row.id) } : {}),
+                    ...(productivityReviewByIssueId.has(row.id)
+                        ? { productivityReview: productivityReviewByIssueId.get(row.id) }
+                        : {}),
                     ...deriveIssueUserContext(row, contextUserId, {
                         myLastCommentAt: statsByIssueId.get(row.id)?.myLastCommentAt ?? null,
                         myLastReadAt: readByIssueId.get(row.id) ?? null,
@@ -1538,8 +1803,9 @@ export function issueService(db) {
         },
         getById: async (raw) => {
             const id = raw.trim();
-            if (/^[A-Z]+-\d+$/i.test(id)) {
-                return getIssueByIdentifier(id);
+            const identifier = normalizeIssueReferenceIdentifier(id);
+            if (identifier) {
+                return getIssueByIdentifier(identifier);
             }
             if (!isUuidLike(id)) {
                 return null;
@@ -1577,6 +1843,9 @@ export function issueService(db) {
         listBlockerAttention: async (companyId, issueRows, dbOrTx = db) => {
             return listIssueBlockerAttentionMap(dbOrTx, companyId, issueRows);
         },
+        listProductivityReviews: async (companyId, sourceIssueIds, dbOrTx = db) => {
+            return listIssueProductivityReviewMap(dbOrTx, companyId, sourceIssueIds);
+        },
         listWakeableBlockedDependents: async (blockerIssueId) => {
             const blockerIssue = await db
                 .select({ id: issues.id, companyId: issues.companyId })
@@ -1715,7 +1984,7 @@ export function issueService(db) {
                 parentId: parent.id,
                 projectId: issueData.projectId ?? parent.projectId,
                 goalId: issueData.goalId ?? parent.goalId,
-                requestDepth: Math.max(parent.requestDepth + 1, issueData.requestDepth ?? 0),
+                requestDepth: clampIssueRequestDepth(Math.max(clampIssueRequestDepth(parent.requestDepth) + 1, issueData.requestDepth ?? 0)),
                 description: appendAcceptanceCriteriaToDescription(issueData.description, acceptanceCriteria),
                 inheritExecutionWorkspaceFromIssueId: parent.id,
             });
@@ -1788,16 +2057,60 @@ export function issueService(db) {
                         }
                     }
                 }
-                if (executionWorkspaceSettings == null &&
-                    executionWorkspaceId == null &&
-                    issueData.projectId) {
-                    const project = await tx
+                // Cache the project policy lookup for this insert. Both the
+                // default-settings block and the assignee-environment-promotion block
+                // need the same row; without caching they'd issue two round-trips.
+                let projectPolicyCached = null;
+                let projectPolicyLoaded = false;
+                const loadProjectPolicyOnce = async () => {
+                    if (projectPolicyLoaded)
+                        return projectPolicyCached;
+                    projectPolicyLoaded = true;
+                    if (!issueData.projectId)
+                        return null;
+                    const projectRow = await tx
                         .select({ executionWorkspacePolicy: projects.executionWorkspacePolicy })
                         .from(projects)
                         .where(and(eq(projects.id, issueData.projectId), eq(projects.companyId, companyId)))
                         .then((rows) => rows[0] ?? null);
+                    projectPolicyCached = parseProjectExecutionWorkspacePolicy(projectRow?.executionWorkspacePolicy);
+                    return projectPolicyCached;
+                };
+                if (executionWorkspaceSettings == null &&
+                    executionWorkspaceId == null &&
+                    issueData.projectId) {
                     executionWorkspaceSettings =
-                        defaultIssueExecutionWorkspaceSettingsForProject(gateProjectExecutionWorkspacePolicy(parseProjectExecutionWorkspacePolicy(project?.executionWorkspacePolicy), isolatedWorkspacesEnabled));
+                        defaultIssueExecutionWorkspaceSettingsForProject(gateProjectExecutionWorkspacePolicy(await loadProjectPolicyOnce(), isolatedWorkspacesEnabled));
+                }
+                if (data.assigneeAgentId && isolatedWorkspacesEnabled) {
+                    const currentWorkspaceSettings = executionWorkspaceSettings == null
+                        ? {}
+                        : parseObject(executionWorkspaceSettings);
+                    const issueHasEnvironmentSelection = Object.prototype.hasOwnProperty.call(currentWorkspaceSettings, "environmentId");
+                    // Don't promote the assignee agent's defaultEnvironmentId if either
+                    // the issue or the project policy already specifies an environment.
+                    // resolveExecutionWorkspaceEnvironmentId treats issue settings as
+                    // higher priority than project policy, so promoting the agent's
+                    // default to issue settings would invert the documented priority
+                    // (project policy must win over agent default when explicitly set).
+                    let projectHasEnvironmentSelection = false;
+                    if (!issueHasEnvironmentSelection && issueData.projectId) {
+                        const projectPolicy = await loadProjectPolicyOnce();
+                        projectHasEnvironmentSelection = projectPolicy?.environmentId !== undefined;
+                    }
+                    if (!issueHasEnvironmentSelection && !projectHasEnvironmentSelection) {
+                        const assigneeAgent = await tx
+                            .select({ defaultEnvironmentId: agents.defaultEnvironmentId })
+                            .from(agents)
+                            .where(and(eq(agents.id, data.assigneeAgentId), eq(agents.companyId, companyId)))
+                            .then((rows) => rows[0] ?? null);
+                        if (typeof assigneeAgent?.defaultEnvironmentId === "string" && assigneeAgent.defaultEnvironmentId.length > 0) {
+                            executionWorkspaceSettings = {
+                                ...currentWorkspaceSettings,
+                                environmentId: assigneeAgent.defaultEnvironmentId,
+                            };
+                        }
+                    }
                 }
                 if (!projectWorkspaceId && issueData.projectId) {
                     const project = await tx
@@ -1842,6 +2155,7 @@ export function issueService(db) {
                 const identifier = `${company.issuePrefix}-${issueNumber}`;
                 const values = {
                     ...issueData,
+                    requestDepth: clampIssueRequestDepth(issueData.requestDepth),
                     originKind: issueData.originKind ?? "manual",
                     goalId: resolveIssueGoalId({
                         projectId: issueData.projectId,
@@ -1866,6 +2180,12 @@ export function issueService(db) {
                 if (values.status === "cancelled") {
                     values.cancelledAt = new Date();
                 }
+                Object.assign(values, buildInitialIssueMonitorFields({
+                    policy: normalizeIssueExecutionPolicy(issueData.executionPolicy ?? null),
+                    status: values.status ?? "backlog",
+                    assigneeAgentId: values.assigneeAgentId ?? null,
+                    assigneeUserId: values.assigneeUserId ?? null,
+                }));
                 const [issue] = await tx.insert(issues).values(values).returning();
                 if (inputLabelIds) {
                     await syncIssueLabels(issue.id, companyId, inputLabelIds, tx);
@@ -1902,6 +2222,9 @@ export function issueService(db) {
                 ...issueData,
                 updatedAt: new Date(),
             };
+            if (issueData.requestDepth !== undefined) {
+                patch.requestDepth = clampIssueRequestDepth(issueData.requestDepth);
+            }
             const nextAssigneeAgentId = issueData.assigneeAgentId !== undefined ? issueData.assigneeAgentId : existing.assigneeAgentId;
             const nextAssigneeUserId = issueData.assigneeUserId !== undefined ? issueData.assigneeUserId : existing.assigneeUserId;
             if (nextAssigneeAgentId && nextAssigneeUserId) {
@@ -1927,6 +2250,12 @@ export function issueService(db) {
             const nextProjectId = issueData.projectId !== undefined ? issueData.projectId : existing.projectId;
             const nextProjectWorkspaceId = issueData.projectWorkspaceId !== undefined ? issueData.projectWorkspaceId : existing.projectWorkspaceId;
             const nextExecutionWorkspaceId = issueData.executionWorkspaceId !== undefined ? issueData.executionWorkspaceId : existing.executionWorkspaceId;
+            const nextExecutionWorkspacePreference = issueData.executionWorkspacePreference !== undefined
+                ? issueData.executionWorkspacePreference
+                : existing.executionWorkspacePreference;
+            const nextExecutionWorkspaceSettings = issueData.executionWorkspaceSettings !== undefined
+                ? parseIssueExecutionWorkspaceSettings(issueData.executionWorkspaceSettings)
+                : parseIssueExecutionWorkspaceSettings(existing.executionWorkspaceSettings);
             if (nextProjectWorkspaceId) {
                 await assertValidProjectWorkspace(existing.companyId, nextProjectId, nextProjectWorkspaceId);
             }
@@ -1961,6 +2290,66 @@ export function issueService(db) {
                     getProjectDefaultGoalId(tx, existing.companyId, existing.projectId),
                     getProjectDefaultGoalId(tx, existing.companyId, issueData.projectId !== undefined ? issueData.projectId : existing.projectId),
                 ]);
+                // Mirror the create() path: when the assignee changes to a non-null
+                // agent, default the issue's executionWorkspaceSettings.environmentId
+                // to the new agent's defaultEnvironmentId. Skip when:
+                //   - this update explicitly sets executionWorkspaceSettings.environmentId
+                //     (caller is making a deliberate override; respect it), OR
+                //   - the project policy already specifies an environmentId (project
+                //     policy must win over agent default per the documented priority
+                //     order in resolveExecutionWorkspaceEnvironmentId), OR
+                //   - the issue already has an environmentId that was *not* the prior
+                //     assignee's default (i.e., the operator set it explicitly in an
+                //     earlier update; preserve their choice). When the existing
+                //     environmentId matches the prior assignee's default, treat it as
+                //     auto-promoted and refresh it to the new assignee's default.
+                const assigneeChanged = issueData.assigneeAgentId !== undefined &&
+                    issueData.assigneeAgentId !== null &&
+                    issueData.assigneeAgentId !== existing.assigneeAgentId;
+                const explicitEnvInThisUpdate = issueData.executionWorkspaceSettings !== undefined &&
+                    Object.prototype.hasOwnProperty.call(parseObject(issueData.executionWorkspaceSettings), "environmentId");
+                if (assigneeChanged && isolatedWorkspacesEnabled && !explicitEnvInThisUpdate) {
+                    let projectHasEnvironmentSelection = false;
+                    if (nextProjectId) {
+                        const projectRow = await tx
+                            .select({ executionWorkspacePolicy: projects.executionWorkspacePolicy })
+                            .from(projects)
+                            .where(and(eq(projects.id, nextProjectId), eq(projects.companyId, existing.companyId)))
+                            .then((rows) => rows[0] ?? null);
+                        const projectPolicy = parseProjectExecutionWorkspacePolicy(projectRow?.executionWorkspacePolicy);
+                        projectHasEnvironmentSelection = projectPolicy?.environmentId !== undefined;
+                    }
+                    if (!projectHasEnvironmentSelection) {
+                        const baseSettings = nextExecutionWorkspaceSettings == null
+                            ? {}
+                            : parseObject(nextExecutionWorkspaceSettings);
+                        const existingEnvId = typeof baseSettings.environmentId === "string"
+                            ? baseSettings.environmentId
+                            : null;
+                        const agentRows = await tx
+                            .select({ id: agents.id, defaultEnvironmentId: agents.defaultEnvironmentId })
+                            .from(agents)
+                            .where(and(eq(agents.companyId, existing.companyId), inArray(agents.id, [issueData.assigneeAgentId, existing.assigneeAgentId].filter((value) => typeof value === "string"))));
+                        const newAssignee = agentRows.find((row) => row.id === issueData.assigneeAgentId);
+                        const previousAssignee = existing.assigneeAgentId
+                            ? agentRows.find((row) => row.id === existing.assigneeAgentId)
+                            : null;
+                        const newDefaultEnvId = typeof newAssignee?.defaultEnvironmentId === "string" && newAssignee.defaultEnvironmentId.length > 0
+                            ? newAssignee.defaultEnvironmentId
+                            : null;
+                        const previousDefaultEnvId = typeof previousAssignee?.defaultEnvironmentId === "string" && previousAssignee.defaultEnvironmentId.length > 0
+                            ? previousAssignee.defaultEnvironmentId
+                            : null;
+                        const existingEnvWasAutoPromoted = existingEnvId === null ||
+                            (previousDefaultEnvId !== null && existingEnvId === previousDefaultEnvId);
+                        if (newDefaultEnvId && existingEnvWasAutoPromoted) {
+                            patch.executionWorkspaceSettings = {
+                                ...baseSettings,
+                                environmentId: newDefaultEnvId,
+                            };
+                        }
+                    }
+                }
                 patch.goalId = resolveNextIssueGoalId({
                     currentProjectId: existing.projectId,
                     currentGoalId: existing.goalId,
@@ -1987,6 +2376,27 @@ export function issueService(db) {
                         userId: actorUserId ?? null,
                     }, tx);
                 }
+                if (issueData.executionWorkspaceSettings !== undefined &&
+                    nextExecutionWorkspaceId &&
+                    nextExecutionWorkspacePreference === "reuse_existing") {
+                    const workspace = await tx
+                        .select({
+                        id: executionWorkspaces.id,
+                        metadata: executionWorkspaces.metadata,
+                    })
+                        .from(executionWorkspaces)
+                        .where(and(eq(executionWorkspaces.id, nextExecutionWorkspaceId), eq(executionWorkspaces.companyId, existing.companyId)))
+                        .then((rows) => rows[0] ?? null);
+                    if (workspace) {
+                        await tx
+                            .update(executionWorkspaces)
+                            .set({
+                            metadata: mergeExecutionWorkspaceConfig(workspace.metadata ?? null, buildReusedExecutionWorkspaceConfigPatchFromIssueSettings(nextExecutionWorkspaceSettings)),
+                            updatedAt: new Date(),
+                        })
+                            .where(eq(executionWorkspaces.id, workspace.id));
+                    }
+                }
                 const [enriched] = await withIssueLabels(tx, [updated]);
                 return enriched;
             };
@@ -2359,14 +2769,8 @@ export function issueService(db) {
                 if (!anchor)
                     return [];
                 conditions.push(order === "asc"
-                    ? sql `(
-                ${issueComments.createdAt} > ${anchor.createdAt}
-                OR (${issueComments.createdAt} = ${anchor.createdAt} AND ${issueComments.id} > ${anchor.id})
-              )`
-                    : sql `(
-                ${issueComments.createdAt} < ${anchor.createdAt}
-                OR (${issueComments.createdAt} = ${anchor.createdAt} AND ${issueComments.id} < ${anchor.id})
-              )`);
+                    ? or(gt(issueComments.createdAt, anchor.createdAt), and(eq(issueComments.createdAt, anchor.createdAt), gt(issueComments.id, anchor.id)))
+                    : or(lt(issueComments.createdAt, anchor.createdAt), and(eq(issueComments.createdAt, anchor.createdAt), lt(issueComments.id, anchor.id))));
             }
             const query = db
                 .select()