@penclipai/server 2026.704.0 → 2026.714.0

package/dist/services/issues.js

@@ -1,11 +1,11 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
-import { and, asc, desc, eq, gt, inArray, isNull, like, lt, ne, notInArray, or, sql } from "drizzle-orm";
-import { activityLog, agentWakeupRequests, agents, authUsers, approvals, assets, companies, companyMemberships, documentRevisions, documents, goals, heartbeatRuns, executionWorkspaces, issueApprovals, issueAttachments, issueInboxArchives, issueLabels, issueWatchdogs, issuePlanDecompositions, issueRecoveryActions, issueRelations, issueComments, issueDocuments, issueReadStates, issueThreadInteractions, issues, labels, projectWorkspaces, projects, workspaceOperations, } from "@penclipai/db";
+import { and, asc, desc, eq, gt, gte, inArray, isNull, like, lt, ne, notInArray, or, sql } from "drizzle-orm";
+import { activityLog, agentWakeupRequests, agents, authUsers, approvals, assets, companies, companyMemberships, documentRevisions, documents, goals, heartbeatRuns, routineRuns, executionWorkspaces, issueApprovals, issueAttachments, issueInboxArchives, issueLabels, issueWatchdogs, issuePlanDecompositions, issueRecoveryActions, issueRelations, issueComments, issueDocuments, issueReadStates, issueThreadInteractions, issues, labels, projectWorkspaces, projects, workspaceOperations, } from "@penclipai/db";
 import { clampIssueRequestDepth, extractAgentMentionIds, extractProjectMentionIds, issueCommentAuthorTypeSchema, issueCommentMetadataSchema, issueCommentPresentationSchema, isUuidLike, normalizeIssueIdentifier as normalizeIssueReferenceIdentifier, } from "@penclipai/shared";
 import { conflict, HttpError, notFound, unprocessable } from "../errors.js";
 import { logger } from "../middleware/logger.js";
-import { defaultIssueExecutionWorkspaceSettingsForProject, gateProjectExecutionWorkspacePolicy, issueExecutionWorkspaceModeForPersistedWorkspace, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, } from "./execution-workspace-policy.js";
+import { defaultIssueExecutionWorkspaceSettingsForProject, gateProjectExecutionWorkspacePolicy, issueExecutionWorkspaceModeForPersistedWorkspace, isUnrunnableWorktreeCombo, parseIssueExecutionWorkspaceSettings, parseProjectExecutionWorkspacePolicy, resolvePinnedIssueWorkspaceStrategyType, WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE, WORKSPACE_WORKTREE_REQUIRES_PROJECT_MESSAGE, WORKSPACE_WORKTREE_REQUIRES_PROJECT_REMEDIATION, } 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";
@@ -19,10 +19,20 @@ import { summarizeIssueWatchdog, upsertIssueWatchdogForIssue, } from "./task-wat
 import { isVerifiedIssueTreeControlInteractionWake, issueTreeControlService, } from "./issue-tree-control.js";
 import { parseIssueGraphLivenessIncidentKey, RECOVERY_ORIGIN_KINDS, } from "./recovery/origins.js";
 import { classifyIssueGraphLiveness } from "./recovery/issue-graph-liveness.js";
+import { visibleIssueCondition } from "./issue-visibility.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;
 export const ISSUE_LIST_MAX_LIMIT = 1000;
+export const ISSUE_BLOCKER_DIAGNOSTICS_MAX_BLOCKERS = 100;
+export const ISSUE_WAKE_DIAGNOSTICS_MAX_WAKE_REQUESTS = 50;
+export const ISSUE_WAKE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS = 50;
+export const ISSUE_WAKE_DIAGNOSTICS_LOOKBACK_DAYS = 14;
+export const ISSUE_SUBTREE_DIAGNOSTICS_MAX_DEPTH = 8;
+export const ISSUE_SUBTREE_DIAGNOSTICS_MAX_NODES = 100;
+export const ISSUE_SUBTREE_DIAGNOSTICS_MAX_BLOCKERS_PER_NODE = 20;
+export const ISSUE_SUBTREE_DIAGNOSTICS_MAX_WAKE_REQUESTS_PER_NODE = 5;
+export const ISSUE_SUBTREE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS_PER_NODE = 5;
 const ISSUE_LIST_RELATED_QUERY_CHUNK_SIZE = 500;
 export const MAX_CHILD_ISSUES_CREATED_BY_HELPER = 25;
 const MAX_CHILD_COMPLETION_SUMMARIES = 20;
@@ -37,6 +47,22 @@ 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;
 const DELETED_ISSUE_COMMENT_BODY = "";
+const ISSUE_WAKE_DIAGNOSTICS_ACTIVITY_ACTIONS = ["issue.tree_hold_wakeup_deferred"];
+function wakeRequestTargetsIssue(issueId) {
+    return sql `(
+    ${agentWakeupRequests.payload} ->> 'issueId' = ${issueId}
+    or ${agentWakeupRequests.payload} ->> 'taskId' = ${issueId}
+    or ${agentWakeupRequests.payload} -> '_paperclipWakeContext' ->> 'issueId' = ${issueId}
+    or ${agentWakeupRequests.payload} -> '_paperclipWakeContext' ->> 'taskId' = ${issueId}
+  )`;
+}
+function wakeDiagnosticActivityTargetsIssue(issueId) {
+    return sql `(
+    (${activityLog.entityType} = 'issue' and ${activityLog.entityId} = ${issueId})
+    or ${activityLog.details} ->> 'issueId' = ${issueId}
+    or ${activityLog.details} ->> 'rootIssueId' = ${issueId}
+  )`;
+}
 function assertTransition(from, to) {
     if (from === to)
         return;
@@ -58,12 +84,82 @@ function applyStatusSideEffects(status, patch) {
     }
     return patch;
 }
+function workspaceWorktreeRequiresProjectDetails() {
+    return {
+        code: WORKSPACE_WORKTREE_REQUIRES_PROJECT_CODE,
+        remediation: WORKSPACE_WORKTREE_REQUIRES_PROJECT_REMEDIATION,
+    };
+}
+function assertExplicitPinnedWorktreeIssueRunnable(input) {
+    const settings = parseIssueExecutionWorkspaceSettings(input.executionWorkspaceSettings);
+    const mode = settings?.mode;
+    if (mode !== "isolated_workspace" && mode !== "operator_branch")
+        return;
+    const resolvedMode = mode;
+    if (isUnrunnableWorktreeCombo({
+        issue: {
+            projectId: input.projectId ?? null,
+            projectWorkspaceId: input.projectWorkspaceId ?? null,
+            executionWorkspaceId: input.executionWorkspaceId ?? null,
+            executionWorkspacePreference: input.executionWorkspacePreference ?? null,
+        },
+        resolvedMode,
+        resolvedStrategy: resolvePinnedIssueWorkspaceStrategyType({
+            mode: resolvedMode,
+            issueSettings: settings,
+        }),
+        hasResolvablePriorSessionWorkspace: false,
+    })) {
+        throw unprocessable(WORKSPACE_WORKTREE_REQUIRES_PROJECT_MESSAGE, workspaceWorktreeRequiresProjectDetails());
+    }
+}
 function readStringFromRecord(record, key) {
     if (!record || typeof record !== "object")
         return null;
     const value = record[key];
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+async function resolveResponsibleUserIdForIssueCreate(reader, companyId, input) {
+    const explicitResponsibleUserId = readStringFromRecord(input, "explicitResponsibleUserId");
+    if (explicitResponsibleUserId && input.trustExplicitResponsibleUserId === true)
+        return explicitResponsibleUserId;
+    if (input.originKind === "routine_execution" && input.originRunId) {
+        const routineRun = await reader
+            .select({ responsibleUserId: routineRuns.responsibleUserId })
+            .from(routineRuns)
+            .where(and(eq(routineRuns.companyId, companyId), eq(routineRuns.id, input.originRunId)))
+            .then((rows) => rows[0] ?? null);
+        if (routineRun?.responsibleUserId)
+            return routineRun.responsibleUserId;
+    }
+    const actorResponsibleUserId = readStringFromRecord(input, "actorResponsibleUserId");
+    if (actorResponsibleUserId)
+        return actorResponsibleUserId;
+    if (input.actorRunId) {
+        const actorRun = await reader
+            .select({ responsibleUserId: heartbeatRuns.responsibleUserId })
+            .from(heartbeatRuns)
+            .where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.id, input.actorRunId)))
+            .then((rows) => rows[0] ?? null);
+        if (actorRun?.responsibleUserId)
+            return actorRun.responsibleUserId;
+    }
+    if (input.parentId) {
+        const parent = await reader
+            .select({
+            responsibleUserId: issues.responsibleUserId,
+            createdByUserId: issues.createdByUserId,
+        })
+            .from(issues)
+            .where(and(eq(issues.companyId, companyId), eq(issues.id, input.parentId)))
+            .then((rows) => rows[0] ?? null);
+        if (parent?.responsibleUserId)
+            return parent.responsibleUserId;
+        if (parent?.createdByUserId)
+            return parent.createdByUserId;
+    }
+    return input.createdByUserId ?? null;
+}
 function buildReusedExecutionWorkspaceConfigPatchFromIssueSettings(settings) {
     return {
         environmentId: settings?.environmentId ?? null,
@@ -72,6 +168,34 @@ function buildReusedExecutionWorkspaceConfigPatchFromIssueSettings(settings) {
         workspaceRuntime: settings?.workspaceRuntime ?? null,
     };
 }
+// Accepted-plan children are not realized yet, so carry only unresolved
+// workspace intent and let the first child run render/persist its own branch.
+function buildPreRealizationExecutionWorkspaceSettings(raw) {
+    const settings = parseIssueExecutionWorkspaceSettings(raw, { includeEnvironmentId: true });
+    if (!settings)
+        return null;
+    const mode = settings.mode && settings.mode !== "inherit" && settings.mode !== "reuse_existing"
+        ? settings.mode
+        : null;
+    const next = {};
+    if (mode)
+        next.mode = mode;
+    if (settings.environmentId !== undefined)
+        next.environmentId = settings.environmentId;
+    if (settings.workspaceRuntime)
+        next.workspaceRuntime = settings.workspaceRuntime;
+    if (settings.workspaceStrategy) {
+        next.workspaceStrategy = {
+            type: settings.workspaceStrategy.type,
+            ...(settings.workspaceStrategy.baseRef ? { baseRef: settings.workspaceStrategy.baseRef } : {}),
+            ...(settings.workspaceStrategy.branchTemplate ? { branchTemplate: settings.workspaceStrategy.branchTemplate } : {}),
+            ...(settings.workspaceStrategy.worktreeParentDir ? { worktreeParentDir: settings.workspaceStrategy.worktreeParentDir } : {}),
+            ...(settings.workspaceStrategy.provisionCommand ? { provisionCommand: settings.workspaceStrategy.provisionCommand } : {}),
+            ...(settings.workspaceStrategy.teardownCommand ? { teardownCommand: settings.workspaceStrategy.teardownCommand } : {}),
+        };
+    }
+    return Object.keys(next).length > 0 ? next : null;
+}
 function toTimestampMs(value) {
     if (!value)
         return null;
@@ -195,7 +319,7 @@ function sameRunLock(checkoutRunId, actorRunId) {
         return checkoutRunId === actorRunId;
     return checkoutRunId == null;
 }
-export const TERMINAL_HEARTBEAT_RUN_STATUSES = new Set(["succeeded", "failed", "cancelled", "timed_out"]);
+export const TERMINAL_HEARTBEAT_RUN_STATUSES = new Set(["succeeded", "interrupted", "failed", "cancelled", "timed_out"]);
 const ISSUE_LIST_DESCRIPTION_MAX_CHARS = 1200;
 const ISSUE_LIST_DESCRIPTION_MAX_BYTES = ISSUE_LIST_DESCRIPTION_MAX_CHARS * 4;
 function escapeLikePattern(value) {
@@ -277,6 +401,8 @@ const ACCEPTED_PLAN_DECOMPOSITION_FINGERPRINT_CHILD_METADATA_KEYS = new Set([
     "updatedByUserId",
     "actorAgentId",
     "actorUserId",
+    "executionWorkspaceInheritanceMode",
+    "skipExecutionWorkspaceInheritance",
 ]);
 function normalizeAcceptedPlanDecompositionFingerprintChild(child) {
     return Object.fromEntries(Object.entries(child).filter(([key]) => !ACCEPTED_PLAN_DECOMPOSITION_FINGERPRINT_CHILD_METADATA_KEYS.has(key)));
@@ -1017,6 +1143,7 @@ async function liveDescendantCountMapForIssues(dbOrTx, companyId, issueIds) {
           JOIN heartbeat_runs live_run ON live_run.id = live_issue.execution_run_id
           WHERE live_issue.company_id = ${companyId}
             AND live_issue.hidden_at IS NULL
+            AND live_issue.harness_kind IS NULL
             AND live_run.company_id = ${companyId}
             AND live_run.status IN ('queued', 'running')
           UNION
@@ -1025,6 +1152,7 @@ async function liveDescendantCountMapForIssues(dbOrTx, companyId, issueIds) {
           JOIN issues live_issue ON live_issue.id::text = (live_run.context_snapshot ->> 'issueId')
           WHERE live_issue.company_id = ${companyId}
             AND live_issue.hidden_at IS NULL
+            AND live_issue.harness_kind IS NULL
             AND live_run.company_id = ${companyId}
             AND live_run.status IN ('queued', 'running')
         ),
@@ -1034,6 +1162,7 @@ async function liveDescendantCountMapForIssues(dbOrTx, companyId, issueIds) {
           JOIN issues parent ON parent.id = live_issues.parent_id
           WHERE parent.company_id = ${companyId}
             AND parent.hidden_at IS NULL
+            AND parent.harness_kind IS NULL
           UNION ALL
           SELECT
             live_ancestors.live_issue_id,
@@ -1044,6 +1173,7 @@ async function liveDescendantCountMapForIssues(dbOrTx, companyId, issueIds) {
           JOIN issues parent ON parent.id = live_ancestors.next_parent_id
           WHERE parent.company_id = ${companyId}
             AND parent.hidden_at IS NULL
+            AND parent.harness_kind IS NULL
             AND NOT parent.id = ANY(live_ancestors.visited_issue_ids)
         )
       SELECT
@@ -1203,7 +1333,7 @@ async function listIssueProductivityReviewMap(dbOrTx, companyId, sourceIssueIds)
             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)))
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, PRODUCTIVITY_REVIEW_ORIGIN_KIND), inArray(issues.originId, chunk), visibleIssueCondition(), notInArray(issues.status, PRODUCTIVITY_REVIEW_TERMINAL_STATUSES)))
             .orderBy(desc(issues.createdAt), desc(issues.id));
         reviewRows.push(...rows);
     }
@@ -1400,7 +1530,7 @@ async function listIssueBlockerAttentionMap(dbOrTx, companyId, issueRows) {
         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)));
+            .where(and(eq(issues.companyId, companyId), eq(issues.originKind, BLOCKER_ATTENTION_OPEN_RECOVERY_ORIGIN_KIND), visibleIssueCondition(), notInArray(issues.status, BLOCKER_ATTENTION_OPEN_RECOVERY_TERMINAL_STATUSES)));
         for (const row of recoveryRows) {
             const parsed = parseIssueGraphLivenessIncidentKey(row.originId);
             if (!parsed || parsed.companyId !== companyId)
@@ -1576,6 +1706,7 @@ const issueListSelect = {
   `,
     status: issues.status,
     workMode: issues.workMode,
+    harnessKind: issues.harnessKind,
     priority: issues.priority,
     assigneeAgentId: issues.assigneeAgentId,
     assigneeUserId: issues.assigneeUserId,
@@ -1585,6 +1716,7 @@ const issueListSelect = {
     executionLockedAt: issues.executionLockedAt,
     createdByAgentId: issues.createdByAgentId,
     createdByUserId: issues.createdByUserId,
+    responsibleUserId: issues.responsibleUserId,
     issueNumber: issues.issueNumber,
     identifier: issues.identifier,
     originKind: issues.originKind,
@@ -1984,7 +2116,7 @@ async function listIssueBlockedInboxAttentionMap(dbOrTx, companyId, issueRows) {
         dbOrTx
             .select()
             .from(issues)
-            .where(and(eq(issues.companyId, companyId), isNull(issues.hiddenAt), notInArray(issues.status, [...BLOCKED_INBOX_TERMINAL_STATUSES]))),
+            .where(and(eq(issues.companyId, companyId), visibleIssueCondition(), notInArray(issues.status, [...BLOCKED_INBOX_TERMINAL_STATUSES]))),
         dbOrTx
             .select({
             companyId: issueRelations.companyId,
@@ -2345,7 +2477,7 @@ function assertValidAssigneeAgentFilter(assigneeAgentFilter) {
 async function blockedInboxIssueConditions(dbOrTx, companyId, filters) {
     const conditions = [
         eq(issues.companyId, companyId),
-        isNull(issues.hiddenAt),
+        visibleIssueCondition(),
         notInArray(issues.status, [...BLOCKED_INBOX_TERMINAL_STATUSES]),
     ];
     const touchedByUserId = filters?.touchedByUserId?.trim() || undefined;
@@ -3268,7 +3400,7 @@ export function issueService(db) {
                     includeBlockedInboxAttention: true,
                 });
             }
-            const conditions = [eq(issues.companyId, companyId)];
+            const conditions = [eq(issues.companyId, companyId), visibleIssueCondition()];
             const assigneeAgentFilter = parseIssueAssigneeAgentFilter(filters?.assigneeAgentId);
             assertValidAssigneeAgentFilter(assigneeAgentFilter);
             const limit = typeof filters?.limit === "number" && Number.isFinite(filters.limit)
@@ -3390,7 +3522,6 @@ export function issueService(db) {
             if (filters?.excludeRoutineExecutions && !filters?.originKind && !filters?.originId) {
                 conditions.push(ne(issues.originKind, "routine_execution"));
             }
-            conditions.push(isNull(issues.hiddenAt));
             const priorityOrder = sql `CASE ${issues.priority} WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 ELSE 4 END`;
             const searchOrder = sql `
         CASE
@@ -3495,7 +3626,7 @@ export function issueService(db) {
             if (filters?.attention === "blocked") {
                 return countBlockedInboxIssues(db, companyId, filters);
             }
-            const conditions = [eq(issues.companyId, companyId), isNull(issues.hiddenAt)];
+            const conditions = [eq(issues.companyId, companyId), visibleIssueCondition()];
             const statuses = parseStatusFilter(filters?.status);
             if (statuses.length === 1)
                 conditions.push(eq(issues.status, statuses[0]));
@@ -3540,7 +3671,7 @@ export function issueService(db) {
         countUnreadTouchedByUser: async (companyId, userId, status) => {
             const conditions = [
                 eq(issues.companyId, companyId),
-                isNull(issues.hiddenAt),
+                visibleIssueCondition(),
                 nonPluginOperationIssueCondition(),
                 unreadForUserCondition(companyId, userId),
             ];
@@ -3648,6 +3779,348 @@ export function issueService(db) {
             const relations = await getIssueRelationSummaryMap(issue.companyId, [issueId], db);
             return relations.get(issueId) ?? { blockedBy: [], blocks: [] };
         },
+        getBlockerDiagnostics: async (issueId, maxBlockers = ISSUE_BLOCKER_DIAGNOSTICS_MAX_BLOCKERS) => {
+            const issue = await db
+                .select({ id: issues.id, companyId: issues.companyId })
+                .from(issues)
+                .where(eq(issues.id, issueId))
+                .then((rows) => rows[0] ?? null);
+            if (!issue)
+                throw notFound("Issue not found");
+            const cappedMax = Math.max(0, Math.min(maxBlockers, ISSUE_BLOCKER_DIAGNOSTICS_MAX_BLOCKERS));
+            const blockerRows = await db
+                .select({
+                id: issues.id,
+                companyId: issues.companyId,
+                projectId: issues.projectId,
+                parentId: issues.parentId,
+                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, issue.companyId), eq(issueRelations.type, "blocks"), eq(issueRelations.relatedIssueId, issue.id), eq(issues.companyId, issue.companyId)))
+                .orderBy(asc(issues.title), asc(issues.id))
+                .limit(cappedMax + 1);
+            const readiness = await listIssueDependencyReadinessMap(db, issue.companyId, [issue.id]);
+            return {
+                blockers: blockerRows.slice(0, cappedMax),
+                readiness: readiness.get(issue.id) ?? createIssueDependencyReadiness(issue.id),
+                truncated: blockerRows.length > cappedMax,
+            };
+        },
+        getWakeDiagnostics: async (issueId, opts) => {
+            const issue = await db
+                .select({ id: issues.id, companyId: issues.companyId })
+                .from(issues)
+                .where(eq(issues.id, issueId))
+                .then((rows) => rows[0] ?? null);
+            if (!issue)
+                throw notFound("Issue not found");
+            const maxWakeRequests = Math.max(0, Math.min(opts?.maxWakeRequests ?? ISSUE_WAKE_DIAGNOSTICS_MAX_WAKE_REQUESTS, ISSUE_WAKE_DIAGNOSTICS_MAX_WAKE_REQUESTS));
+            const maxActivityRecords = Math.max(0, Math.min(opts?.maxActivityRecords ?? ISSUE_WAKE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS, ISSUE_WAKE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS));
+            const lookbackDays = Math.max(1, Math.min(opts?.lookbackDays ?? ISSUE_WAKE_DIAGNOSTICS_LOOKBACK_DAYS, ISSUE_WAKE_DIAGNOSTICS_LOOKBACK_DAYS));
+            const since = new Date(Date.now() - lookbackDays * 24 * 60 * 60 * 1000);
+            const wakeRows = await db
+                .select({
+                agentId: agentWakeupRequests.agentId,
+                source: agentWakeupRequests.source,
+                reason: agentWakeupRequests.reason,
+                status: agentWakeupRequests.status,
+                coalescedCount: agentWakeupRequests.coalescedCount,
+                runId: agentWakeupRequests.runId,
+                requestedAt: agentWakeupRequests.requestedAt,
+                claimedAt: agentWakeupRequests.claimedAt,
+                finishedAt: agentWakeupRequests.finishedAt,
+                error: agentWakeupRequests.error,
+            })
+                .from(agentWakeupRequests)
+                .where(and(eq(agentWakeupRequests.companyId, issue.companyId), gte(agentWakeupRequests.requestedAt, since), wakeRequestTargetsIssue(issue.id)))
+                .orderBy(desc(agentWakeupRequests.requestedAt), desc(agentWakeupRequests.createdAt))
+                .limit(maxWakeRequests + 1);
+            const activityRows = await db
+                .select({
+                action: activityLog.action,
+                entityType: activityLog.entityType,
+                entityId: activityLog.entityId,
+                agentId: activityLog.agentId,
+                runId: activityLog.runId,
+                details: activityLog.details,
+                createdAt: activityLog.createdAt,
+            })
+                .from(activityLog)
+                .where(and(eq(activityLog.companyId, issue.companyId), gte(activityLog.createdAt, since), inArray(activityLog.action, [...ISSUE_WAKE_DIAGNOSTICS_ACTIVITY_ACTIONS]), wakeDiagnosticActivityTargetsIssue(issue.id)))
+                .orderBy(desc(activityLog.createdAt))
+                .limit(maxActivityRecords + 1);
+            return {
+                wakeRequests: wakeRows.slice(0, maxWakeRequests),
+                activityRecords: activityRows.slice(0, maxActivityRecords),
+                truncatedWakeRequests: wakeRows.length > maxWakeRequests,
+                truncatedActivityRecords: activityRows.length > maxActivityRecords,
+                caps: {
+                    maxWakeRequests: ISSUE_WAKE_DIAGNOSTICS_MAX_WAKE_REQUESTS,
+                    maxActivityRecords: ISSUE_WAKE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS,
+                    lookbackDays: ISSUE_WAKE_DIAGNOSTICS_LOOKBACK_DAYS,
+                },
+            };
+        },
+        getSubtreeDiagnostics: async (issueId, opts) => {
+            const issue = await db
+                .select({ id: issues.id, companyId: issues.companyId })
+                .from(issues)
+                .where(eq(issues.id, issueId))
+                .then((rows) => rows[0] ?? null);
+            if (!issue)
+                throw notFound("Issue not found");
+            const maxDepth = Math.max(0, Math.min(opts?.maxDepth ?? ISSUE_SUBTREE_DIAGNOSTICS_MAX_DEPTH, ISSUE_SUBTREE_DIAGNOSTICS_MAX_DEPTH));
+            const maxNodes = Math.max(1, Math.min(opts?.maxNodes ?? ISSUE_SUBTREE_DIAGNOSTICS_MAX_NODES, ISSUE_SUBTREE_DIAGNOSTICS_MAX_NODES));
+            const maxBlockersPerNode = Math.max(0, Math.min(opts?.maxBlockersPerNode ?? ISSUE_SUBTREE_DIAGNOSTICS_MAX_BLOCKERS_PER_NODE, ISSUE_SUBTREE_DIAGNOSTICS_MAX_BLOCKERS_PER_NODE));
+            const maxWakeRequestsPerNode = Math.max(0, Math.min(opts?.maxWakeRequestsPerNode ?? ISSUE_SUBTREE_DIAGNOSTICS_MAX_WAKE_REQUESTS_PER_NODE, ISSUE_SUBTREE_DIAGNOSTICS_MAX_WAKE_REQUESTS_PER_NODE));
+            const maxActivityRecordsPerNode = Math.max(0, Math.min(opts?.maxActivityRecordsPerNode ?? ISSUE_SUBTREE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS_PER_NODE, ISSUE_SUBTREE_DIAGNOSTICS_MAX_ACTIVITY_RECORDS_PER_NODE));
+            const lookbackDays = Math.max(1, Math.min(opts?.lookbackDays ?? ISSUE_WAKE_DIAGNOSTICS_LOOKBACK_DAYS, ISSUE_WAKE_DIAGNOSTICS_LOOKBACK_DAYS));
+            const since = new Date(Date.now() - lookbackDays * 24 * 60 * 60 * 1000);
+            const sinceIso = since.toISOString();
+            const rawSubtreeRows = await db.execute(sql `
+        WITH RECURSIVE issue_tree AS (
+          SELECT
+            id,
+            company_id,
+            project_id,
+            parent_id,
+            identifier,
+            title,
+            status,
+            priority,
+            assignee_agent_id,
+            assignee_user_id,
+            created_at,
+            updated_at,
+            0 AS depth,
+            ARRAY[id] AS path
+          FROM issues
+          WHERE company_id = ${issue.companyId}
+            AND id = ${issue.id}
+            AND hidden_at IS NULL
+            AND harness_kind IS NULL
+          UNION ALL
+          SELECT
+            child.id,
+            child.company_id,
+            child.project_id,
+            child.parent_id,
+            child.identifier,
+            child.title,
+            child.status,
+            child.priority,
+            child.assignee_agent_id,
+            child.assignee_user_id,
+            child.created_at,
+            child.updated_at,
+            issue_tree.depth + 1,
+            issue_tree.path || child.id
+          FROM issues child
+          JOIN issue_tree ON child.parent_id = issue_tree.id
+          WHERE child.company_id = ${issue.companyId}
+            AND child.hidden_at IS NULL
+            AND child.harness_kind IS NULL
+            AND issue_tree.depth < ${maxDepth + 1}
+            AND NOT child.id = ANY(issue_tree.path)
+        )
+        SELECT
+          id,
+          company_id AS "companyId",
+          project_id AS "projectId",
+          parent_id AS "parentId",
+          identifier,
+          title,
+          status,
+          priority,
+          assignee_agent_id AS "assigneeAgentId",
+          assignee_user_id AS "assigneeUserId",
+          created_at AS "createdAt",
+          updated_at AS "updatedAt",
+          depth::int AS depth
+        FROM issue_tree
+        ORDER BY depth ASC, created_at ASC, id ASC
+        LIMIT ${maxNodes + 1}
+      `);
+            const subtreeRows = Array.from(rawSubtreeRows)
+                .map((row) => ({ ...row, depth: Number(row.depth) }));
+            const rowsWithinDepth = subtreeRows.filter((row) => row.depth <= maxDepth);
+            const nodes = rowsWithinDepth.slice(0, maxNodes);
+            const truncatedNodes = rowsWithinDepth.length > maxNodes;
+            const truncatedDepth = truncatedNodes || subtreeRows.some((row) => row.depth > maxDepth);
+            const nodeIds = nodes.map((node) => node.id);
+            const readiness = nodeIds.length > 0
+                ? await listIssueDependencyReadinessMap(db, issue.companyId, nodeIds)
+                : new Map();
+            const blockersByIssueId = new Map();
+            const wakeRequestsByIssueId = new Map();
+            const activityRecordsByIssueId = new Map();
+            const truncatedBlockerIssueIds = new Set();
+            const truncatedWakeIssueIds = new Set();
+            const truncatedActivityIssueIds = new Set();
+            if (nodeIds.length > 0) {
+                const nodeIdValues = sql.join(nodeIds.map((id) => sql `${id}`), sql `, `);
+                const rawBlockerRows = Array.from(await db.execute(sql `
+          WITH blocker_rows AS (
+            SELECT
+              blocker.id,
+              blocker.company_id AS "companyId",
+              blocker.project_id AS "projectId",
+              blocker.parent_id AS "parentId",
+              blocker.identifier,
+              blocker.title,
+              blocker.status,
+              blocker.priority,
+              blocker.assignee_agent_id AS "assigneeAgentId",
+              blocker.assignee_user_id AS "assigneeUserId",
+              relation.related_issue_id AS "blockedIssueId",
+              relation.created_at AS "relationCreatedAt",
+              row_number() OVER (
+                PARTITION BY relation.related_issue_id
+                ORDER BY blocker.title ASC, blocker.id ASC
+              )::int AS "rowNumber"
+            FROM issue_relations relation
+            INNER JOIN issues blocker ON blocker.id = relation.issue_id
+            WHERE relation.company_id = ${issue.companyId}
+              AND relation.type = 'blocks'
+              AND blocker.company_id = ${issue.companyId}
+              AND blocker.hidden_at IS NULL
+              AND blocker.harness_kind IS NULL
+              AND relation.related_issue_id::text IN (${nodeIdValues})
+          )
+          SELECT *
+          FROM blocker_rows
+          WHERE "rowNumber" <= ${maxBlockersPerNode + 1}
+          ORDER BY "blockedIssueId" ASC, "rowNumber" ASC
+        `));
+                for (const row of rawBlockerRows) {
+                    const normalized = { ...row, rowNumber: Number(row.rowNumber) };
+                    if (normalized.rowNumber > maxBlockersPerNode) {
+                        truncatedBlockerIssueIds.add(normalized.blockedIssueId);
+                        continue;
+                    }
+                    const rows = blockersByIssueId.get(normalized.blockedIssueId) ?? [];
+                    rows.push(normalized);
+                    blockersByIssueId.set(normalized.blockedIssueId, rows);
+                }
+                const wakeTargetIssueIdSql = sql `
+          coalesce(
+            wake.payload ->> 'issueId',
+            wake.payload ->> 'taskId',
+            wake.payload -> '_paperclipWakeContext' ->> 'issueId',
+            wake.payload -> '_paperclipWakeContext' ->> 'taskId'
+          )
+        `;
+                const rawWakeRows = Array.from(await db.execute(sql `
+          WITH wake_rows AS (
+            SELECT
+              ${wakeTargetIssueIdSql} AS "issueId",
+              wake.agent_id AS "agentId",
+              wake.source,
+              wake.reason,
+              wake.status,
+              wake.coalesced_count AS "coalescedCount",
+              wake.run_id AS "runId",
+              wake.requested_at AS "requestedAt",
+              wake.claimed_at AS "claimedAt",
+              wake.finished_at AS "finishedAt",
+              wake.error,
+              row_number() OVER (
+                PARTITION BY ${wakeTargetIssueIdSql}
+                ORDER BY wake.requested_at DESC, wake.created_at DESC
+              )::int AS "rowNumber"
+            FROM agent_wakeup_requests wake
+            WHERE wake.company_id = ${issue.companyId}
+              AND wake.requested_at >= ${sinceIso}::timestamptz
+              AND ${wakeTargetIssueIdSql} IN (${nodeIdValues})
+          )
+          SELECT *
+          FROM wake_rows
+          WHERE "rowNumber" <= ${maxWakeRequestsPerNode + 1}
+          ORDER BY "issueId" ASC, "requestedAt" DESC
+        `));
+                for (const row of rawWakeRows) {
+                    const normalized = { ...row, rowNumber: Number(row.rowNumber) };
+                    if (normalized.rowNumber > maxWakeRequestsPerNode) {
+                        truncatedWakeIssueIds.add(normalized.issueId);
+                        continue;
+                    }
+                    const rows = wakeRequestsByIssueId.get(normalized.issueId) ?? [];
+                    rows.push(normalized);
+                    wakeRequestsByIssueId.set(normalized.issueId, rows);
+                }
+                const activityTargetIssueIdSql = sql `
+          coalesce(
+            CASE WHEN activity.entity_type = 'issue' THEN activity.entity_id ELSE NULL END,
+            activity.details ->> 'issueId',
+            activity.details ->> 'rootIssueId'
+          )
+        `;
+                const activityActionValues = sql.join(ISSUE_WAKE_DIAGNOSTICS_ACTIVITY_ACTIONS.map((action) => sql `${action}`), sql `, `);
+                const rawActivityRows = Array.from(await db.execute(sql `
+          WITH activity_rows AS (
+            SELECT
+              ${activityTargetIssueIdSql} AS "issueId",
+              activity.action,
+              activity.entity_type AS "entityType",
+              activity.entity_id AS "entityId",
+              activity.agent_id AS "agentId",
+              activity.run_id AS "runId",
+              activity.details,
+              activity.created_at AS "createdAt",
+              row_number() OVER (
+                PARTITION BY ${activityTargetIssueIdSql}
+                ORDER BY activity.created_at DESC, activity.id DESC
+              )::int AS "rowNumber"
+            FROM activity_log activity
+            WHERE activity.company_id = ${issue.companyId}
+              AND activity.created_at >= ${sinceIso}::timestamptz
+              AND activity.action IN (${activityActionValues})
+              AND ${activityTargetIssueIdSql} IN (${nodeIdValues})
+          )
+          SELECT *
+          FROM activity_rows
+          WHERE "rowNumber" <= ${maxActivityRecordsPerNode + 1}
+          ORDER BY "issueId" ASC, "createdAt" DESC
+        `));
+                for (const row of rawActivityRows) {
+                    const normalized = { ...row, rowNumber: Number(row.rowNumber) };
+                    if (normalized.rowNumber > maxActivityRecordsPerNode) {
+                        truncatedActivityIssueIds.add(normalized.issueId);
+                        continue;
+                    }
+                    const rows = activityRecordsByIssueId.get(normalized.issueId) ?? [];
+                    rows.push(normalized);
+                    activityRecordsByIssueId.set(normalized.issueId, rows);
+                }
+            }
+            return {
+                nodes,
+                blockersByIssueId,
+                readinessByIssueId: readiness,
+                wakeRequestsByIssueId,
+                activityRecordsByIssueId,
+                truncatedNodes,
+                truncatedDepth,
+                truncatedBlockerIssueIds,
+                truncatedWakeIssueIds,
+                truncatedActivityIssueIds,
+                caps: {
+                    maxDepth,
+                    maxNodes,
+                    maxBlockersPerNode,
+                    maxWakeRequestsPerNode,
+                    maxActivityRecordsPerNode,
+                    lookbackDays,
+                },
+            };
+        },
         getDependencyReadiness: async (issueId, dbOrTx = db) => {
             const issue = await dbOrTx
                 .select({ id: issues.id, companyId: issues.companyId })
@@ -3788,15 +4261,30 @@ export function issueService(db) {
             if (childCount >= MAX_CHILD_ISSUES_CREATED_BY_HELPER) {
                 throw unprocessable(`Parent issue already has the maximum ${MAX_CHILD_ISSUES_CREATED_BY_HELPER} child issues for this helper`);
             }
-            const { acceptanceCriteria, blockParentUntilDone, actorAgentId, actorUserId, ...issueData } = data;
+            const { acceptanceCriteria, blockParentUntilDone, executionWorkspaceInheritanceMode = "linkage", actorAgentId, actorUserId, ...issueData } = data;
+            const inheritStrategyOnly = executionWorkspaceInheritanceMode === "strategy_only";
+            const hasExplicitExecutionWorkspaceOverride = issueData.executionWorkspaceId !== undefined ||
+                issueData.executionWorkspacePreference !== undefined ||
+                issueData.executionWorkspaceSettings !== undefined;
+            const inheritedPreRealizationWorkspaceSettings = inheritStrategyOnly && !hasExplicitExecutionWorkspaceOverride
+                ? buildPreRealizationExecutionWorkspaceSettings(parent.executionWorkspaceSettings)
+                : null;
             let child = await issueService(db).create(parent.companyId, {
                 ...issueData,
                 parentId: parent.id,
                 projectId: issueData.projectId ?? parent.projectId,
+                projectWorkspaceId: issueData.projectWorkspaceId ?? (inheritStrategyOnly ? parent.projectWorkspaceId : undefined),
                 goalId: issueData.goalId ?? parent.goalId,
+                actorResponsibleUserId: issueData.actorResponsibleUserId ?? null,
+                trustExplicitResponsibleUserId: issueData.trustExplicitResponsibleUserId === true,
                 requestDepth: clampIssueRequestDepth(Math.max(clampIssueRequestDepth(parent.requestDepth) + 1, issueData.requestDepth ?? 0)),
                 description: appendAcceptanceCriteriaToDescription(issueData.description, acceptanceCriteria),
-                inheritExecutionWorkspaceFromIssueId: parent.id,
+                ...(inheritedPreRealizationWorkspaceSettings
+                    ? { executionWorkspaceSettings: inheritedPreRealizationWorkspaceSettings }
+                    : {}),
+                ...(inheritStrategyOnly
+                    ? { skipExecutionWorkspaceInheritance: true }
+                    : { inheritExecutionWorkspaceFromIssueId: parent.id }),
             });
             if (blockParentUntilDone) {
                 const existingBlockers = await db
@@ -3938,7 +4426,10 @@ export function issueService(db) {
                     if (!nextChildInput) {
                         throw new Error("Accepted-plan decomposition child cursor moved past the requested children");
                     }
-                    const createdChild = await issueService(tx).createChild(sourceIssue.id, nextChildInput);
+                    const createdChild = await issueService(tx).createChild(sourceIssue.id, {
+                        ...nextChildInput,
+                        executionWorkspaceInheritanceMode: "strategy_only",
+                    });
                     const nextIds = [...existingChildIssueIds, createdChild.issue.id];
                     const now = new Date();
                     const nextStatus = nextIds.length === data.children.length ? "completed" : "in_flight";
@@ -4046,7 +4537,7 @@ export function issueService(db) {
             });
         },
         create: async (companyId, data) => {
-            const { labelIds: inputLabelIds, blockedByIssueIds, inheritExecutionWorkspaceFromIssueId, watchdog, watchdogActorRunId, ...issueData } = data;
+            const { labelIds: inputLabelIds, blockedByIssueIds, inheritExecutionWorkspaceFromIssueId, skipExecutionWorkspaceInheritance, watchdog, watchdogActorRunId, actorRunId, actorResponsibleUserId, trustExplicitResponsibleUserId, ...issueData } = data;
             const isolatedWorkspacesEnabled = (await instanceSettings.getExperimental()).enableIsolatedWorkspaces;
             if (!isolatedWorkspacesEnabled) {
                 delete issueData.executionWorkspaceId;
@@ -4071,7 +4562,9 @@ export function issueService(db) {
                 let executionWorkspaceId = issueData.executionWorkspaceId ?? null;
                 let executionWorkspacePreference = issueData.executionWorkspacePreference ?? null;
                 let executionWorkspaceSettings = issueData.executionWorkspaceSettings ?? null;
-                const workspaceInheritanceIssueId = inheritExecutionWorkspaceFromIssueId ?? issueData.parentId ?? null;
+                const workspaceInheritanceIssueId = skipExecutionWorkspaceInheritance
+                    ? null
+                    : inheritExecutionWorkspaceFromIssueId ?? issueData.parentId ?? null;
                 const hasExplicitExecutionWorkspaceOverride = issueData.executionWorkspaceId !== undefined ||
                     issueData.executionWorkspacePreference !== undefined ||
                     issueData.executionWorkspaceSettings !== undefined;
@@ -4162,6 +4655,15 @@ export function issueService(db) {
                 if (executionWorkspaceId) {
                     await assertValidExecutionWorkspace(companyId, issueData.projectId, executionWorkspaceId, tx);
                 }
+                if (isolatedWorkspacesEnabled && issueData.executionWorkspaceSettings !== undefined) {
+                    assertExplicitPinnedWorktreeIssueRunnable({
+                        projectId: issueData.projectId ?? null,
+                        projectWorkspaceId,
+                        executionWorkspaceId,
+                        executionWorkspacePreference,
+                        executionWorkspaceSettings: issueData.executionWorkspaceSettings,
+                    });
+                }
                 // Self-correcting counter: use MAX(issue_number) + 1 if the counter
                 // has drifted below the actual max, preventing identifier collisions.
                 const [maxRow] = await tx
@@ -4178,8 +4680,19 @@ export function issueService(db) {
                     .returning({ issueCounter: companies.issueCounter, issuePrefix: companies.issuePrefix });
                 const issueNumber = company.issueCounter;
                 const identifier = `${company.issuePrefix}-${issueNumber}`;
+                const responsibleUserId = await resolveResponsibleUserIdForIssueCreate(tx, companyId, {
+                    explicitResponsibleUserId: issueData.responsibleUserId ?? null,
+                    createdByUserId: issueData.createdByUserId ?? null,
+                    parentId: issueData.parentId ?? null,
+                    originKind: issueData.originKind ?? "manual",
+                    originRunId: issueData.originRunId ?? null,
+                    actorRunId: actorRunId ?? null,
+                    actorResponsibleUserId: actorResponsibleUserId ?? null,
+                    trustExplicitResponsibleUserId: trustExplicitResponsibleUserId === true,
+                });
                 const values = {
                     ...issueData,
+                    responsibleUserId,
                     requestDepth: clampIssueRequestDepth(issueData.requestDepth),
                     originKind: issueData.originKind ?? "manual",
                     goalId: resolveIssueGoalId({
@@ -4324,6 +4837,15 @@ export function issueService(db) {
                     await assertValidExecutionWorkspace(existing.companyId, nextProjectId, nextExecutionWorkspaceId);
                 }
             }
+            if (isolatedWorkspacesEnabled && issueData.executionWorkspaceSettings !== undefined) {
+                assertExplicitPinnedWorktreeIssueRunnable({
+                    projectId: nextProjectId ?? null,
+                    projectWorkspaceId: nextProjectWorkspaceId ?? null,
+                    executionWorkspaceId: nextExecutionWorkspaceId ?? null,
+                    executionWorkspacePreference: nextExecutionWorkspacePreference ?? null,
+                    executionWorkspaceSettings: issueData.executionWorkspaceSettings,
+                });
+            }
             applyStatusSideEffects(issueData.status, patch);
             if (issueData.status && issueData.status !== "done") {
                 patch.completedAt = null;
@@ -4422,7 +4944,7 @@ export function issueService(db) {
                 .where(eq(issues.companyId, companyId));
             let cleared = 0;
             for (const row of rows) {
-                const settings = parseIssueExecutionWorkspaceSettings(row.executionWorkspaceSettings);
+                const settings = parseIssueExecutionWorkspaceSettings(row.executionWorkspaceSettings, { includeEnvironmentId: true });
                 if (settings?.environmentId !== environmentId)
                     continue;
                 await db