patchrelay 0.48.0 → 0.49.1

package/dist/orchestration-parent-wake.js

@@ -1,16 +1,74 @@
 import { classifyIssue } from "./issue-class.js";
+export const ORCHESTRATION_SETTLE_WINDOW_MS = 10_000;
+export function computeOrchestrationSettleUntil(now = Date.now()) {
+    return new Date(now + ORCHESTRATION_SETTLE_WINDOW_MS).toISOString();
+}
+function resolveOrchestrationIssueClass(db, issue) {
+    return classifyIssue({
+        issue,
+        childIssueCount: db.issues.listChildIssues(issue.projectId, issue.linearIssueId).length,
+    }).issueClass;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function resolveParentIssueIds(db, child) {
+    const parentIds = [];
+    if (child.parentLinearIssueId) {
+        parentIds.push(child.parentLinearIssueId);
+    }
+    for (const blocker of db.issues.listIssueDependencies(child.projectId, child.linearIssueId)) {
+        parentIds.push(blocker.blockerLinearIssueId);
+    }
+    return unique(parentIds);
+}
+export function startOrchestrationSettleWindow(db, issue, now = Date.now()) {
+    const settleUntil = computeOrchestrationSettleUntil(now);
+    db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        orchestrationSettleUntil: settleUntil,
+    });
+    return settleUntil;
+}
+export function queueSettledOrchestrationIssue(params) {
+    params.db.issues.upsertIssue({
+        projectId: params.issue.projectId,
+        linearIssueId: params.issue.linearIssueId,
+        orchestrationSettleUntil: null,
+    });
+    params.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.issue.projectId, params.issue.linearIssueId, {
+        projectId: params.issue.projectId,
+        linearIssueId: params.issue.linearIssueId,
+        eventType: "delegated",
+        eventJson: JSON.stringify({
+            ...(params.promptContext
+                ? { promptContext: params.promptContext }
+                : { promptContext: "The orchestration child set has settled enough to begin planning." }),
+        }),
+        dedupeKey: `delegated:orchestration_settle:${params.issue.linearIssueId}`,
+    });
+    if (params.db.issueSessions.peekIssueSessionWake(params.issue.projectId, params.issue.linearIssueId)) {
+        params.enqueueIssue?.(params.issue.projectId, params.issue.linearIssueId);
+        return true;
+    }
+    return false;
+}
 export function wakeOrchestrationParentsForChildEvent(params) {
     const parentIds = [];
-    for (const blocker of params.db.issues.listIssueDependencies(params.child.projectId, params.child.linearIssueId)) {
-        const parent = params.db.issues.getIssue(params.child.projectId, blocker.blockerLinearIssueId);
+    for (const parentIssueId of resolveParentIssueIds(params.db, params.child)) {
+        const parent = params.db.issues.getIssue(params.child.projectId, parentIssueId);
         if (!parent || !parent.delegatedToPatchRelay) {
             continue;
         }
-        const classification = classifyIssue({
-            issue: parent,
-            trackedDependentCount: params.db.issues.listDependents(parent.projectId, parent.linearIssueId).length,
-        });
-        if (classification.issueClass !== "orchestration") {
+        if (resolveOrchestrationIssueClass(params.db, parent) !== "orchestration") {
+            continue;
+        }
+        // Before the umbrella has started its first turn, keep absorbing nearby
+        // child-set changes into the settle window instead of launching too early.
+        if (!parent.threadId && parent.activeRunId === undefined && parent.orchestrationSettleUntil) {
+            startOrchestrationSettleWindow(params.db, parent, params.now);
+            parentIds.push(parent.linearIssueId);
             continue;
         }
         params.db.issueSessions.appendIssueSessionEventRespectingActiveLease(parent.projectId, parent.linearIssueId, {
@@ -25,13 +83,14 @@ export function wakeOrchestrationParentsForChildEvent(params) {
                 ...(params.child.currentLinearState ? { currentLinearState: params.child.currentLinearState } : {}),
                 ...(params.child.prNumber !== undefined ? { prNumber: params.child.prNumber } : {}),
                 ...(params.child.prState ? { prState: params.child.prState } : {}),
+                ...(params.changeKind ? { changeKind: params.changeKind } : {}),
             }),
-            dedupeKey: `${params.eventType}:${parent.linearIssueId}:${params.child.linearIssueId}:${params.child.factoryState}:${params.child.prState ?? "no-pr"}`,
+            dedupeKey: `${params.eventType}:${parent.linearIssueId}:${params.child.linearIssueId}:${params.child.factoryState}:${params.changeKind ?? params.child.prState ?? "no-pr"}`,
         });
         if (params.db.issueSessions.peekIssueSessionWake(parent.projectId, parent.linearIssueId)) {
             params.enqueueIssue?.(parent.projectId, parent.linearIssueId);
         }
         parentIds.push(parent.linearIssueId);
     }
-    return parentIds;
+    return unique(parentIds);
 }

package/dist/prompting/patchrelay.js

@@ -106,9 +106,11 @@ function buildCoordinationGuidance(context) {
     const unresolvedBlockers = Array.isArray(context?.unresolvedBlockers)
         ? context.unresolvedBlockers.filter((entry) => Boolean(entry) && typeof entry === "object")
         : [];
-    const trackedDependents = Array.isArray(context?.trackedDependents)
-        ? context.trackedDependents.filter((entry) => Boolean(entry) && typeof entry === "object")
-        : [];
+    const childIssues = Array.isArray(context?.childIssues)
+        ? context.childIssues.filter((entry) => Boolean(entry) && typeof entry === "object")
+        : Array.isArray(context?.trackedDependents)
+            ? context.trackedDependents.filter((entry) => Boolean(entry) && typeof entry === "object")
+            : [];
     const lines = [
         "### Coordination / Issue Topology",
         "",
@@ -117,7 +119,7 @@ function buildCoordinationGuidance(context) {
         "When child issues already own the concrete code slices, use this issue to coordinate, create or refine follow-up issues, or verify convergence. Only ship code here if this issue still has unique implementation scope that is not already owned elsewhere.",
         "Prefer one PR per concrete implementation issue over a broad parent branch that restates overlapping child work.",
     ];
-    if (unresolvedBlockers.length === 0 && trackedDependents.length === 0) {
+    if (unresolvedBlockers.length === 0 && childIssues.length === 0) {
         return lines;
     }
     lines.push("", "Known relations from PatchRelay:");
@@ -125,12 +127,12 @@ function buildCoordinationGuidance(context) {
         lines.push("Unresolved blockers:");
         lines.push(...summarizeRelationEntries(unresolvedBlockers));
     }
-    if (trackedDependents.length > 0) {
+    if (childIssues.length > 0) {
         if (unresolvedBlockers.length > 0) {
             lines.push("");
         }
-        lines.push("Tracked dependent issues:");
-        lines.push(...summarizeRelationEntries(trackedDependents));
+        lines.push("Canonical child issues:");
+        lines.push(...summarizeRelationEntries(childIssues));
     }
     return lines;
 }
@@ -166,15 +168,19 @@ function buildOrchestrationScopeDiscipline(context) {
     const unresolvedBlockers = Array.isArray(context?.unresolvedBlockers)
         ? context.unresolvedBlockers.filter((entry) => Boolean(entry) && typeof entry === "object")
         : [];
-    const trackedDependents = Array.isArray(context?.trackedDependents)
-        ? context.trackedDependents.filter((entry) => Boolean(entry) && typeof entry === "object")
-        : [];
+    const childIssues = Array.isArray(context?.childIssues)
+        ? context.childIssues.filter((entry) => Boolean(entry) && typeof entry === "object")
+        : Array.isArray(context?.trackedDependents)
+            ? context.trackedDependents.filter((entry) => Boolean(entry) && typeof entry === "object")
+            : [];
     return [
         "## Scope Discipline",
         "",
         "This issue is orchestration work.",
         "Treat it as the owner of convergence across related issues rather than as a normal code-owning implementation branch.",
         "Inspect why this wake happened before acting.",
+        "Adopt already-existing canonical child issues when they cover the intended split.",
+        "Do not recreate child issues that already exist under this parent unless a genuinely missing required slice remains.",
         "Do not create an overlapping umbrella PR unless this parent clearly owns unique direct cleanup work that child issues do not already cover.",
         "If child work is still in motion, babysit the plan, record useful observations, and return to waiting.",
         "If child work looks delivered, audit whether the original parent goal is actually satisfied.",
@@ -183,8 +189,8 @@ function buildOrchestrationScopeDiscipline(context) {
         "",
         "### Child Issue Summaries",
         "",
-        ...(trackedDependents.length > 0
-            ? summarizeRelationEntries(trackedDependents, { emptyText: "No child issues are currently tracked." })
+        ...(childIssues.length > 0
+            ? summarizeRelationEntries(childIssues, { emptyText: "No child issues are currently tracked." })
             : ["No child issues are currently tracked."]),
         "",
         ...(unresolvedBlockers.length > 0

package/dist/run-orchestrator.js

@@ -150,10 +150,8 @@ export class RunOrchestrator {
             ...(entry.blockerCurrentLinearState ? { stateName: entry.blockerCurrentLinearState } : {}),
             ...(entry.blockerCurrentLinearStateType ? { stateType: entry.blockerCurrentLinearStateType } : {}),
         }));
-        const trackedDependents = this.db.issues
-            .listDependents(issue.projectId, issue.linearIssueId)
-            .map((entry) => this.db.issues.getIssue(issue.projectId, entry.linearIssueId))
-            .filter((entry) => Boolean(entry))
+        const childIssues = this.db.issues
+            .listChildIssues(issue.projectId, issue.linearIssueId)
             .map((entry) => ({
             linearIssueId: entry.linearIssueId,
             ...(entry.issueKey ? { issueKey: entry.issueKey } : {}),
@@ -163,17 +161,17 @@ export class RunOrchestrator {
             delegatedToPatchRelay: entry.delegatedToPatchRelay,
             hasOpenPr: entry.prNumber !== undefined && entry.prState !== "closed" && entry.prState !== "merged",
         }));
-        if (unresolvedBlockers.length === 0 && trackedDependents.length === 0) {
+        if (unresolvedBlockers.length === 0 && childIssues.length === 0) {
             return {};
         }
         return {
             ...(unresolvedBlockers.length > 0 ? { unresolvedBlockers } : {}),
-            ...(trackedDependents.length > 0 ? { trackedDependents } : {}),
+            ...(childIssues.length > 0 ? { childIssues } : {}),
         };
     }
     classifyTrackedIssue(issue) {
-        const trackedDependentCount = this.db.issues.listDependents(issue.projectId, issue.linearIssueId).length;
-        const classification = classifyIssue({ issue, trackedDependentCount });
+        const childIssueCount = this.db.issues.listChildIssues(issue.projectId, issue.linearIssueId).length;
+        const classification = classifyIssue({ issue, childIssueCount });
         if (issue.issueClass === classification.issueClass && issue.issueClassSource === classification.issueClassSource) {
             return issue;
         }

package/dist/run-reconciler.js

@@ -4,6 +4,7 @@ import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { getThreadTurns } from "./codex-thread-utils.js";
 import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
+import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 export class RunReconciler {
     db;
     logger;
@@ -33,6 +34,19 @@ export class RunReconciler {
         const { run, issue, recoveryLease } = params;
         const acquiredRecoveryLease = recoveryLease === true;
         let effectiveIssue = issue;
+        const effectiveActiveRun = resolveEffectiveActiveRun({
+            activeRun: issue.activeRunId === run.id ? run : undefined,
+            latestRun: run,
+        });
+        if (effectiveActiveRun?.id === run.id && issue.activeRunId !== run.id) {
+            effectiveIssue = this.withHeldLease(run.projectId, run.linearIssueId, () => this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: run.id,
+                ...(run.threadId ? { threadId: run.threadId } : {}),
+            })) ?? effectiveIssue;
+            this.logger.info({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Reattached detached active run during reconciliation");
+        }
         if (!effectiveIssue.delegatedToPatchRelay) {
             const authority = await this.confirmDelegationAuthorityBeforeRelease(run, effectiveIssue);
             effectiveIssue = authority.issue;

package/dist/tracked-issue-list-query.js

@@ -2,6 +2,7 @@ import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./gith
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { hasDetachedActiveLatestRun } from "./effective-active-run.js";
 function shouldSuppressStatusNote(params) {
     if (!params.activeRunType && params.sessionState !== "running")
         return false;
@@ -82,6 +83,7 @@ export class TrackedIssueListQuery {
           s.project_id, s.linear_issue_id, s.issue_key, i.title,
           i.current_linear_state, i.factory_state, i.delegated_to_patchrelay, s.session_state, s.waiting_reason, s.summary_text, s.display_updated_at,
           i.pending_run_type,
+          i.orchestration_settle_until,
           i.pr_number, i.pr_state, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
           i.last_github_ci_snapshot_json,
           i.last_github_failure_source,
@@ -154,14 +156,28 @@ export class TrackedIssueListQuery {
             const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
             const hasPendingWake = hasPendingSessionEvents
                 || this.db.issueSessions.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+            const detachedActiveRun = hasDetachedActiveLatestRun({
+                activeRunId: row.active_run_type !== null ? 1 : undefined,
+                latestRun: row.latest_run_status !== null
+                    ? { id: 0, status: String(row.latest_run_status) }
+                    : undefined,
+            });
+            const effectiveActiveRunType = row.active_run_type !== null
+                ? String(row.active_run_type)
+                : detachedActiveRun && row.latest_run_type !== null
+                    ? String(row.latest_run_type)
+                    : undefined;
             const readyForExecution = isIssueSessionReadyForExecution({
-                ...(typeof row.session_state === "string" ? { sessionState: String(row.session_state) } : {}),
+                ...(typeof row.session_state === "string"
+                    ? { sessionState: detachedActiveRun ? "running" : String(row.session_state) }
+                    : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
                 ...(row.delegated_to_patchrelay !== null ? { delegatedToPatchRelay: Number(row.delegated_to_patchrelay) !== 0 } : {}),
-                ...(row.active_run_type !== null ? { activeRunId: 1 } : {}),
+                ...((row.active_run_type !== null || detachedActiveRun) ? { activeRunId: 1 } : {}),
                 blockedByCount,
                 hasPendingWake,
                 hasLegacyPendingRun: row.pending_run_type !== null && row.pending_run_type !== undefined,
+                ...(row.orchestration_settle_until !== null ? { orchestrationSettleUntil: String(row.orchestration_settle_until) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
                 ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
@@ -175,12 +191,13 @@ export class TrackedIssueListQuery {
             const sessionSummary = typeof row.summary_text === "string" && row.summary_text.trim().length > 0
                 ? row.summary_text
                 : undefined;
-            const waitingReason = sessionWaitingReason ?? derivePatchRelayWaitingReason({
+            const derivedWaitingReason = derivePatchRelayWaitingReason({
                 ...(row.delegated_to_patchrelay !== null ? { delegatedToPatchRelay: Number(row.delegated_to_patchrelay) !== 0 } : {}),
-                ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+                ...((row.active_run_type !== null || detachedActiveRun) ? { activeRunId: 1 } : {}),
                 blockedByKeys,
                 factoryState: String(row.factory_state ?? "delegated"),
                 ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
+                ...(row.orchestration_settle_until !== null ? { orchestrationSettleUntil: String(row.orchestration_settle_until) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
                 ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
                 ...(row.pr_head_sha !== null ? { prHeadSha: String(row.pr_head_sha) } : {}),
@@ -189,6 +206,7 @@ export class TrackedIssueListQuery {
                 ...(row.last_blocking_review_head_sha !== null ? { lastBlockingReviewHeadSha: String(row.last_blocking_review_head_sha) } : {}),
                 ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
             });
+            const waitingReason = detachedActiveRun ? derivedWaitingReason : sessionWaitingReason ?? derivedWaitingReason;
             const latestRun = row.latest_run_type !== null && row.latest_run_status !== null
                 ? {
                     id: 0,
@@ -219,29 +237,39 @@ export class TrackedIssueListQuery {
                 waitingReason,
             }) ?? waitingReason;
             const statusNoteForReturn = shouldSuppressStatusNote({
-                activeRunType: row.active_run_type,
-                sessionState: row.session_state,
+                activeRunType: effectiveActiveRunType,
+                sessionState: detachedActiveRun ? "running" : row.session_state,
                 statusNote: statusNoteCandidate,
             })
                 ? undefined
                 : statusNoteCandidate;
-            const completionCheckActive = typeof row.active_completion_check_thread_id === "string"
-                && row.active_completion_check_thread_id.length > 0
-                && row.active_completion_check_outcome === null
-                && row.active_run_type !== null;
+            const activeCompletionCheckThreadId = row.active_run_type !== null
+                ? row.active_completion_check_thread_id
+                : detachedActiveRun
+                    ? row.latest_run_completion_check_thread_id
+                    : null;
+            const activeCompletionCheckOutcome = row.active_run_type !== null
+                ? row.active_completion_check_outcome
+                : detachedActiveRun
+                    ? row.latest_run_completion_check_outcome
+                    : null;
+            const completionCheckActive = typeof activeCompletionCheckThreadId === "string"
+                && activeCompletionCheckThreadId.length > 0
+                && activeCompletionCheckOutcome === null
+                && effectiveActiveRunType !== undefined;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
                 ...(statusNoteForReturn ? { statusNote: statusNoteForReturn } : {}),
                 projectId: String(row.project_id),
                 delegatedToPatchRelay: row.delegated_to_patchrelay === null ? true : Number(row.delegated_to_patchrelay) !== 0,
-                ...(row.session_state !== null ? { sessionState: String(row.session_state) } : {}),
+                ...(row.session_state !== null ? { sessionState: detachedActiveRun ? "running" : String(row.session_state) } : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
                 blockedByCount,
                 blockedByKeys,
                 readyForExecution,
                 ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
-                ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+                ...(effectiveActiveRunType ? { activeRunType: effectiveActiveRunType } : {}),
                 ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
                 ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
                 ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),

package/dist/tracked-issue-projector.js

@@ -2,6 +2,7 @@ import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+import { hasDetachedActiveLatestRun, resolveEffectiveActiveRun } from "./effective-active-run.js";
 export function isResolvedLinearState(stateType, stateName) {
     return stateType === "completed" || stateName?.trim().toLowerCase() === "done";
 }
@@ -9,12 +10,21 @@ export function buildTrackedIssueRecord(params) {
     const unresolvedBlockedBy = params.blockedBy.filter((entry) => !isResolvedLinearState(entry.blockerCurrentLinearStateType, entry.blockerCurrentLinearState));
     const failureContext = parseGitHubFailureContext(params.issue.lastGitHubFailureContextJson);
     const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
+    const effectiveActiveRun = resolveEffectiveActiveRun({
+        activeRun: params.issue.activeRunId !== undefined && params.latestRun?.id === params.issue.activeRunId ? params.latestRun : undefined,
+        latestRun: params.latestRun,
+    });
+    const detachedActiveRun = hasDetachedActiveLatestRun({
+        activeRunId: params.issue.activeRunId,
+        latestRun: params.latestRun,
+    });
     const waitingReason = derivePatchRelayWaitingReason({
         delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
-        ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
+        ...(effectiveActiveRun ? { activeRunId: effectiveActiveRun.id } : {}),
         blockedByKeys,
         factoryState: params.issue.factoryState,
         pendingRunType: params.issue.pendingRunType,
+        orchestrationSettleUntil: params.issue.orchestrationSettleUntil,
         prNumber: params.issue.prNumber,
         prState: params.issue.prState,
         prHeadSha: params.issue.prHeadSha,
@@ -32,11 +42,9 @@ export function buildTrackedIssueRecord(params) {
         blockedByKeys,
         waitingReason,
     });
-    const completionCheckActive = Boolean(params.issue.activeRunId !== undefined
-        && params.latestRun?.id === params.issue.activeRunId
-        && params.latestRun.status === "running"
-        && params.latestRun.completionCheckThreadId
-        && !params.latestRun.completionCheckOutcome);
+    const completionCheckActive = Boolean(effectiveActiveRun?.status === "running"
+        && effectiveActiveRun.completionCheckThreadId
+        && !effectiveActiveRun.completionCheckOutcome);
     return {
         id: params.issue.id,
         projectId: params.issue.projectId,
@@ -60,10 +68,11 @@ export function buildTrackedIssueRecord(params) {
             sessionState: params.session?.sessionState,
             factoryState: params.issue.factoryState,
             delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
-            activeRunId: params.issue.activeRunId,
+            ...(effectiveActiveRun ? { activeRunId: effectiveActiveRun.id } : {}),
             blockedByCount: unresolvedBlockedBy.length,
             hasPendingWake: params.hasPendingWake,
             hasLegacyPendingRun: params.issue.pendingRunType !== undefined,
+            orchestrationSettleUntil: params.issue.orchestrationSettleUntil,
             ...(params.issue.prNumber !== undefined ? { prNumber: params.issue.prNumber } : {}),
             ...(params.issue.prState ? { prState: params.issue.prState } : {}),
             ...(params.issue.prReviewState ? { prReviewState: params.issue.prReviewState } : {}),
@@ -77,8 +86,9 @@ export function buildTrackedIssueRecord(params) {
         ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
         ...(waitingReason ? { waitingReason } : {}),
         ...(completionCheckActive ? { completionCheckActive } : {}),
-        ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
+        ...(effectiveActiveRun ? { activeRunId: effectiveActiveRun.id } : {}),
         ...(params.issue.agentSessionId ? { activeAgentSessionId: params.issue.agentSessionId } : {}),
+        ...(detachedActiveRun && params.session?.sessionState ? { sessionState: "running" } : {}),
         updatedAt: params.issue.updatedAt,
     };
 }

package/dist/tracked-issue-query.js

@@ -1,5 +1,6 @@
 import { buildTrackedIssueRecord } from "./tracked-issue-projector.js";
 import { deriveIssueSessionState, isIssueSessionReadyForExecution } from "./issue-session.js";
+import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 export class TrackedIssueQuery {
     issues;
     issueSessions;
@@ -55,7 +56,10 @@ export class TrackedIssueQuery {
         if (!issue)
             return undefined;
         const tracked = this.issueToTrackedIssue(issue);
-        const activeRun = issue.activeRunId ? this.runs.getRunById(issue.activeRunId) : undefined;
+        const activeRun = resolveEffectiveActiveRun({
+            activeRun: issue.activeRunId ? this.runs.getRunById(issue.activeRunId) : undefined,
+            latestRun: this.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId),
+        });
         return {
             issue: tracked,
             ...(activeRun ? { activeRun } : {}),

package/dist/waiting-reason.js

@@ -11,6 +11,7 @@ export const PATCHRELAY_WAITING_REASONS = {
     sameHeadStillBlocked: "Requested changes still block the current head",
     waitingForMergeStewardRepair: "Waiting to repair a merge-steward incident",
     waitingForDownstreamAutomation: "PatchRelay work is done; waiting on downstream review/merge automation",
+    waitingForChildSettle: "Waiting briefly for child issues to settle before orchestration starts",
     workComplete: "PatchRelay work is complete",
     waitingForOperatorIntervention: "Waiting on operator intervention",
     waitingForExternalReview: "Waiting on external review",
@@ -33,6 +34,12 @@ export function derivePatchRelayWaitingReason(params) {
     if (params.activeRunId !== undefined) {
         return PATCHRELAY_WAITING_REASONS.activeWork;
     }
+    if (params.orchestrationSettleUntil) {
+        const settleAt = Date.parse(params.orchestrationSettleUntil);
+        if (Number.isFinite(settleAt) && settleAt > Date.now()) {
+            return PATCHRELAY_WAITING_REASONS.waitingForChildSettle;
+        }
+    }
     const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
     if (blockedByKeys.length > 0) {
         return `Blocked by ${blockedByKeys.join(", ")}`;

package/dist/webhooks/comment-wake-handler.js

@@ -27,7 +27,7 @@ export class CommentWakeHandler {
             return;
         const issueClass = classifyIssue({
             issue,
-            trackedDependentCount: this.db.issues.listDependents(project.id, normalized.issue.id).length,
+            childIssueCount: this.db.issues.listChildIssues(project.id, normalized.issue.id).length,
         }).issueClass;
         const trimmedBody = normalized.comment.body.trim();
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);

package/dist/webhooks/decision-helpers.js

@@ -104,6 +104,9 @@ export function hasCompleteIssueContext(issue) {
 export function mergeIssueMetadata(issue, liveIssue) {
     return {
         ...issue,
+        ...(issue.parentId ? {} : liveIssue.parentId ? { parentId: liveIssue.parentId } : {}),
+        ...(issue.parentIdentifier ? {} : liveIssue.parentIdentifier ? { parentIdentifier: liveIssue.parentIdentifier } : {}),
+        ...(issue.parentTitle ? {} : liveIssue.parentTitle ? { parentTitle: liveIssue.parentTitle } : {}),
         ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
         ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
         ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),

package/dist/webhooks/desired-stage-recorder.js

@@ -1,7 +1,9 @@
+import { classifyIssue } from "../issue-class.js";
+import { computeOrchestrationSettleUntil, wakeOrchestrationParentsForChildEvent, } from "../orchestration-parent-wake.js";
 import { triggerEventAllowed } from "../project-resolution.js";
 import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
 import { appendDelegationObservedEvent } from "../delegation-audit.js";
-import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
+import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isResolvedLinearState, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 import { resolveLinkedPullRequest } from "../linear-linked-pr-reconciliation.js";
 import { readRemotePrState } from "../remote-pr-state.js";
@@ -70,6 +72,24 @@ export class DesiredStageRecorder {
                 terminal,
                 currentState: existingIssue?.factoryState,
             });
+        const childIssueCount = this.db.issues.listChildIssues(params.project.id, normalizedIssue.id).length;
+        const classification = classifyIssue({
+            issue: {
+                issueClass: existingIssue?.issueClass,
+                issueClassSource: existingIssue?.issueClassSource,
+                title: hydratedIssue.title ?? existingIssue?.title,
+                description: hydratedIssue.description ?? existingIssue?.description,
+                parentLinearIssueId: hydratedIssue.parentId ?? existingIssue?.parentLinearIssueId,
+            },
+            childIssueCount,
+        });
+        const shouldEnterOrchestrationSettle = Boolean(delegated
+            && desiredStage === "implementation"
+            && classification.issueClass === "orchestration"
+            && childIssueCount === 0
+            && !existingIssue?.threadId
+            && !activeRun
+            && !terminal);
         const runRelease = decideActiveRunRelease({
             hasActiveRun: Boolean(activeRun),
             terminal,
@@ -126,6 +146,10 @@ export class DesiredStageRecorder {
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
                 ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+                ...(hydratedIssue.parentId !== undefined ? { parentLinearIssueId: hydratedIssue.parentId ?? null } : {}),
+                ...(hydratedIssue.parentIdentifier !== undefined ? { parentIssueKey: hydratedIssue.parentIdentifier ?? null } : {}),
+                issueClass: classification.issueClass,
+                issueClassSource: classification.issueClassSource,
                 ...(hydratedIssue.title ? { title: hydratedIssue.title } : {}),
                 ...(hydratedIssue.description ? { description: hydratedIssue.description } : {}),
                 ...(hydratedIssue.url ? { url: hydratedIssue.url } : {}),
@@ -152,6 +176,7 @@ export class DesiredStageRecorder {
                 ...(terminalRunRelease ? { factoryState: "done", pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(blockerPausedImplementation ? { factoryState: "delegated" } : {}),
                 ...(undelegation.factoryState ? { factoryState: undelegation.factoryState } : {}),
+                ...(shouldEnterOrchestrationSettle ? { orchestrationSettleUntil: computeOrchestrationSettleUntil() } : {}),
             });
             if (effectiveRunRelease.release && activeRun && effectiveRunRelease.reason) {
                 this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: effectiveRunRelease.reason });
@@ -166,6 +191,10 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
             }))
             : this.db.transaction(commitIssueUpdate);
+        const previousParentIssueId = existingIssue?.parentLinearIssueId;
+        const currentParentIssueId = issue.parentLinearIssueId;
+        const wasResolved = isResolvedLinearState(existingIssue?.currentLinearStateType, existingIssue?.currentLinearState);
+        const isResolved = isResolvedLinearState(issue.currentLinearStateType, issue.currentLinearState);
         if (undelegation.factoryState) {
             if (activeRun?.threadId && activeRun.turnId) {
                 await params.stopActiveRun(activeRun, "STOP: The issue was un-delegated from PatchRelay. Stop working immediately and exit.");
@@ -213,6 +242,17 @@ export class DesiredStageRecorder {
                 ...buildOperatorRetryEvent(issue, startupResume.pendingRunType, startupResume.source),
             });
         }
+        else if (shouldEnterOrchestrationSettle) {
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: params.project.id,
+                stage: issue.factoryState,
+                status: "settling_children",
+                summary: "Waiting briefly for child issues to settle before orchestration starts",
+            });
+        }
         else if (!startupResume.factoryState
             && !startupResume.pendingRunType
             &&
@@ -232,6 +272,46 @@ export class DesiredStageRecorder {
                 dedupeKey: `delegated:${normalizedIssue.id}`,
             });
         }
+        if (previousParentIssueId && previousParentIssueId !== currentParentIssueId) {
+            wakeOrchestrationParentsForChildEvent({
+                db: this.db,
+                child: {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    parentLinearIssueId: previousParentIssueId,
+                    ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                    ...(issue.title ? { title: issue.title } : {}),
+                    factoryState: issue.factoryState,
+                    ...(issue.currentLinearState ? { currentLinearState: issue.currentLinearState } : {}),
+                    ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+                    ...(issue.prState ? { prState: issue.prState } : {}),
+                },
+                eventType: "child_changed",
+                changeKind: "detached",
+            });
+        }
+        if (currentParentIssueId) {
+            const changeKind = previousParentIssueId !== currentParentIssueId
+                ? "attached"
+                : issue.currentLinearState?.trim().toLowerCase() === "duplicate"
+                    ? "duplicate"
+                    : issue.currentLinearStateType === "canceled"
+                        ? "canceled"
+                        : "updated";
+            const eventType = previousParentIssueId !== currentParentIssueId
+                ? "child_changed"
+                : !wasResolved && isResolved
+                    ? "child_delivered"
+                    : wasResolved && !isResolved
+                        ? "child_regressed"
+                        : "child_changed";
+            wakeOrchestrationParentsForChildEvent({
+                db: this.db,
+                child: issue,
+                eventType,
+                changeKind,
+            });
+        }
         return {
             issue: this.db.issueToTrackedIssue(issue),
             wakeRunType: params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id),
@@ -310,6 +390,11 @@ export class DesiredStageRecorder {
                 })),
             });
         }
+        this.db.issues.replaceIssueParentLink({
+            projectId,
+            childLinearIssueId: source.id,
+            parentLinearIssueId: source.parentId ?? null,
+        });
         return { issue: source, hydration };
     }
     async resolveLinkedPrAdoption(params) {