patchrelay 0.48.0 → 0.49.0

package/README.md

@@ -119,8 +119,8 @@ See the [merge-steward package README](./packages/merge-steward/README.md) for t
 - [Prompting](./docs/prompting.md) — how workflow files and the built-in scaffold compose
 - [Secrets](./docs/secrets.md) — systemd credentials, resolution order
 - [review-quill reference](./docs/review-quill.md) · [merge-steward reference](./docs/merge-steward.md)
-- [Design docs](./docs/design-docs/index.md) · [Core beliefs](./docs/design-docs/core-beliefs.md)
-- [Security policy](./SECURITY.md)
+- [Product specs](./docs/product-specs/index.md) · [Design docs](./docs/design-docs/index.md) · [Core beliefs](./docs/design-docs/core-beliefs.md)
+- [Contributing](./CONTRIBUTING.md) · [Security policy](./SECURITY.md)
 
 ## Status
 

package/dist/agent-session-plan.js

@@ -104,6 +104,17 @@ function resolvePlanRunType(params) {
 }
 export function buildAgentSessionPlan(params) {
     if (params.issueClass === "orchestration") {
+        const settling = params.orchestrationSettleUntil
+            ? Number.isFinite(Date.parse(params.orchestrationSettleUntil)) && Date.parse(params.orchestrationSettleUntil) > Date.now()
+            : false;
+        if (settling) {
+            return [
+                { content: "Wait for child set to settle", status: "inProgress" },
+                { content: "Review umbrella goal and child set", status: "pending" },
+                { content: "Wait for or inspect child progress", status: "pending" },
+                { content: "Audit delivered outcome", status: "pending" },
+            ];
+        }
         switch (params.factoryState) {
             case "done":
                 return setStatuses(orchestrationPlan(), ["completed", "completed", "completed", "completed"]);
@@ -181,6 +192,7 @@ export function buildAgentSessionPlanForIssue(issue, options) {
         ciRepairAttempts: issue.ciRepairAttempts,
         queueRepairAttempts: issue.queueRepairAttempts,
         ...(issue.issueClass ? { issueClass: issue.issueClass } : {}),
+        ...(issue.orchestrationSettleUntil ? { orchestrationSettleUntil: issue.orchestrationSettleUntil } : {}),
         ...(issue.pendingRunType ? { pendingRunType: issue.pendingRunType } : {}),
         ...(options?.activeRunType ? { activeRunType: options.activeRunType } : {}),
     });

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.48.0",
-  "commit": "a606bc8b729a",
-  "builtAt": "2026-04-18T14:29:29.224Z"
+  "version": "0.49.0",
+  "commit": "e4ca4c92eb96",
+  "builtAt": "2026-04-19T10:24:09.505Z"
 }

package/dist/db/issue-store.js

@@ -28,6 +28,14 @@ export class IssueStore {
                 sets.push("issue_class_source = @issueClassSource");
                 values.issueClassSource = params.issueClassSource;
             }
+            if (params.parentLinearIssueId !== undefined) {
+                sets.push("parent_linear_issue_id = @parentLinearIssueId");
+                values.parentLinearIssueId = params.parentLinearIssueId;
+            }
+            if (params.parentIssueKey !== undefined) {
+                sets.push("parent_issue_key = @parentIssueKey");
+                values.parentIssueKey = params.parentIssueKey;
+            }
             if (params.issueKey !== undefined) {
                 sets.push("issue_key = COALESCE(@issueKey, issue_key)");
                 values.issueKey = params.issueKey;
@@ -224,12 +232,16 @@ export class IssueStore {
                 sets.push("last_zombie_recovery_at = @lastZombieRecoveryAt");
                 values.lastZombieRecoveryAt = params.lastZombieRecoveryAt;
             }
+            if (params.orchestrationSettleUntil !== undefined) {
+                sets.push("orchestration_settle_until = @orchestrationSettleUntil");
+                values.orchestrationSettleUntil = params.orchestrationSettleUntil;
+            }
             this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
         }
         else {
             this.connection.prepare(`
         INSERT INTO issues (
-          project_id, linear_issue_id, delegated_to_patchrelay, issue_class, issue_class_source, issue_key, title, description, url,
+          project_id, linear_issue_id, delegated_to_patchrelay, issue_class, issue_class_source, parent_linear_issue_id, parent_issue_key, issue_key, title, description, url,
           priority, estimate,
           current_linear_state, current_linear_state_type, factory_state, pending_run_type, pending_run_context_json,
           branch_name, worktree_path, thread_id, active_run_id, status_comment_id,
@@ -239,10 +251,10 @@ export class IssueStore {
           last_github_ci_snapshot_head_sha, last_github_ci_snapshot_gate_check_name, last_github_ci_snapshot_gate_check_status, last_github_ci_snapshot_json, last_github_ci_snapshot_settled_at,
           last_queue_signal_at, last_queue_incident_json,
           last_attempted_failure_head_sha, last_attempted_failure_signature, last_attempted_failure_at,
-          ci_repair_attempts, queue_repair_attempts, review_fix_attempts, zombie_recovery_attempts, last_zombie_recovery_at,
+          ci_repair_attempts, queue_repair_attempts, review_fix_attempts, zombie_recovery_attempts, last_zombie_recovery_at, orchestration_settle_until,
           updated_at
         ) VALUES (
-          @projectId, @linearIssueId, @delegatedToPatchRelay, @issueClass, @issueClassSource, @issueKey, @title, @description, @url,
+          @projectId, @linearIssueId, @delegatedToPatchRelay, @issueClass, @issueClassSource, @parentLinearIssueId, @parentIssueKey, @issueKey, @title, @description, @url,
           @priority, @estimate,
           @currentLinearState, @currentLinearStateType, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId, @statusCommentId,
@@ -252,7 +264,7 @@ export class IssueStore {
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
           @lastQueueSignalAt, @lastQueueIncidentJson,
           @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature, @lastAttemptedFailureAt,
-          @ciRepairAttempts, @queueRepairAttempts, @reviewFixAttempts, @zombieRecoveryAttempts, @lastZombieRecoveryAt,
+          @ciRepairAttempts, @queueRepairAttempts, @reviewFixAttempts, @zombieRecoveryAttempts, @lastZombieRecoveryAt, @orchestrationSettleUntil,
           @now
         )
       `).run({
@@ -261,6 +273,8 @@ export class IssueStore {
                 delegatedToPatchRelay: params.delegatedToPatchRelay === false ? 0 : 1,
                 issueClass: params.issueClass ?? null,
                 issueClassSource: params.issueClassSource ?? null,
+                parentLinearIssueId: params.parentLinearIssueId ?? null,
+                parentIssueKey: params.parentIssueKey ?? null,
                 issueKey: params.issueKey ?? null,
                 title: params.title ?? null,
                 description: params.description ?? null,
@@ -310,6 +324,7 @@ export class IssueStore {
                 reviewFixAttempts: params.reviewFixAttempts ?? 0,
                 zombieRecoveryAttempts: params.zombieRecoveryAttempts ?? 0,
                 lastZombieRecoveryAt: params.lastZombieRecoveryAt ?? null,
+                orchestrationSettleUntil: params.orchestrationSettleUntil ?? null,
                 now,
             });
         }
@@ -456,6 +471,67 @@ export class IssueStore {
             linearIssueId: String(row.linear_issue_id),
         }));
     }
+    replaceIssueParentLink(params) {
+        const now = isoNow();
+        this.connection
+            .prepare("DELETE FROM issue_children WHERE project_id = ? AND child_linear_issue_id = ?")
+            .run(params.projectId, params.childLinearIssueId);
+        if (!params.parentLinearIssueId) {
+            return;
+        }
+        this.connection.prepare(`
+      INSERT INTO issue_children (
+        project_id,
+        parent_linear_issue_id,
+        child_linear_issue_id,
+        updated_at
+      ) VALUES (?, ?, ?, ?)
+    `).run(params.projectId, params.parentLinearIssueId, params.childLinearIssueId, now);
+    }
+    listChildLinks(projectId, parentLinearIssueId) {
+        const rows = this.connection.prepare(`
+      SELECT project_id, parent_linear_issue_id, child_linear_issue_id, updated_at
+      FROM issue_children
+      WHERE project_id = ? AND parent_linear_issue_id = ?
+      ORDER BY child_linear_issue_id ASC
+    `).all(projectId, parentLinearIssueId);
+        return rows.map((row) => ({
+            projectId: String(row.project_id),
+            parentLinearIssueId: String(row.parent_linear_issue_id),
+            childLinearIssueId: String(row.child_linear_issue_id),
+            updatedAt: String(row.updated_at),
+        }));
+    }
+    listChildIssues(projectId, parentLinearIssueId) {
+        const rows = this.connection.prepare(`
+      SELECT child.*
+      FROM issue_children edges
+      JOIN issues child
+        ON child.project_id = edges.project_id
+       AND child.linear_issue_id = edges.child_linear_issue_id
+      WHERE edges.project_id = ? AND edges.parent_linear_issue_id = ?
+      ORDER BY COALESCE(child.issue_key, child.linear_issue_id) ASC
+    `).all(projectId, parentLinearIssueId);
+        return rows.map(mapIssueRow);
+    }
+    countOpenChildIssues(projectId, parentLinearIssueId) {
+        const row = this.connection.prepare(`
+      SELECT COUNT(*) AS count
+      FROM issue_children edges
+      LEFT JOIN issues child
+        ON child.project_id = edges.project_id
+       AND child.linear_issue_id = edges.child_linear_issue_id
+      WHERE edges.project_id = ? AND edges.parent_linear_issue_id = ?
+        AND (
+          child.linear_issue_id IS NULL
+          OR (
+            COALESCE(child.current_linear_state_type, '') NOT IN ('completed', 'canceled')
+            AND LOWER(TRIM(COALESCE(child.current_linear_state, ''))) NOT IN ('done', 'duplicate', 'canceled')
+          )
+        )
+    `).get(projectId, parentLinearIssueId);
+        return Number(row?.count ?? 0);
+    }
     countUnresolvedBlockers(projectId, linearIssueId) {
         const row = this.connection.prepare(`
       SELECT COUNT(*) AS count
@@ -493,6 +569,10 @@ export function mapIssueRow(row) {
         ...(row.issue_class_source !== null && row.issue_class_source !== undefined
             ? { issueClassSource: String(row.issue_class_source) }
             : {}),
+        ...(row.parent_linear_issue_id !== null && row.parent_linear_issue_id !== undefined
+            ? { parentLinearIssueId: String(row.parent_linear_issue_id) }
+            : {}),
+        ...(row.parent_issue_key !== null && row.parent_issue_key !== undefined ? { parentIssueKey: String(row.parent_issue_key) } : {}),
         ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
         ...(row.title !== null ? { title: String(row.title) } : {}),
         ...(row.description !== null && row.description !== undefined ? { description: String(row.description) } : {}),
@@ -583,5 +663,8 @@ export function mapIssueRow(row) {
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
         ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
+        ...(row.orchestration_settle_until !== null && row.orchestration_settle_until !== undefined
+            ? { orchestrationSettleUntil: String(row.orchestration_settle_until) }
+            : {}),
     };
 }

package/dist/db/migrations.js

@@ -6,6 +6,8 @@ CREATE TABLE IF NOT EXISTS issues (
   delegated_to_patchrelay INTEGER NOT NULL DEFAULT 1,
   issue_class TEXT,
   issue_class_source TEXT,
+  parent_linear_issue_id TEXT,
+  parent_issue_key TEXT,
   issue_key TEXT,
   title TEXT,
   url TEXT,
@@ -32,6 +34,7 @@ CREATE TABLE IF NOT EXISTS issues (
   last_blocking_review_head_sha TEXT,
   ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
   queue_repair_attempts INTEGER NOT NULL DEFAULT 0,
+  orchestration_settle_until TEXT,
   updated_at TEXT NOT NULL,
   UNIQUE(project_id, linear_issue_id)
 );
@@ -218,6 +221,14 @@ CREATE TABLE IF NOT EXISTS issue_dependencies (
   PRIMARY KEY (project_id, linear_issue_id, blocker_linear_issue_id)
 );
 
+CREATE TABLE IF NOT EXISTS issue_children (
+  project_id TEXT NOT NULL,
+  parent_linear_issue_id TEXT NOT NULL,
+  child_linear_issue_id TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, parent_linear_issue_id, child_linear_issue_id)
+);
+
 CREATE INDEX IF NOT EXISTS idx_issues_project ON issues(project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issues_key ON issues(issue_key);
 CREATE INDEX IF NOT EXISTS idx_issues_ready ON issues(pending_run_type, active_run_id);
@@ -238,6 +249,8 @@ CREATE INDEX IF NOT EXISTS idx_linear_catalog_teams_installation ON linear_catal
 CREATE INDEX IF NOT EXISTS idx_linear_catalog_projects_installation ON linear_catalog_projects(installation_id, project_name);
 CREATE INDEX IF NOT EXISTS idx_issue_dependencies_issue ON issue_dependencies(project_id, linear_issue_id);
 CREATE INDEX IF NOT EXISTS idx_issue_dependencies_blocker ON issue_dependencies(project_id, blocker_linear_issue_id);
+CREATE INDEX IF NOT EXISTS idx_issue_children_parent ON issue_children(project_id, parent_linear_issue_id);
+CREATE INDEX IF NOT EXISTS idx_issue_children_child ON issue_children(project_id, child_linear_issue_id);
 `;
 export function runPatchRelayMigrations(connection) {
     connection.exec(schema);
@@ -246,6 +259,18 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "delegated_to_patchrelay", "INTEGER NOT NULL DEFAULT 1");
     addColumnIfMissing(connection, "issues", "issue_class", "TEXT");
     addColumnIfMissing(connection, "issues", "issue_class_source", "TEXT");
+    addColumnIfMissing(connection, "issues", "parent_linear_issue_id", "TEXT");
+    addColumnIfMissing(connection, "issues", "parent_issue_key", "TEXT");
+    addColumnIfMissing(connection, "issues", "orchestration_settle_until", "TEXT");
+    // Earlier releases persisted derived classifications as "explicit", which
+    // made bad umbrella guesses sticky forever. We do not have a user-authored
+    // explicit classification path yet, so downgrade old rows back to heuristic
+    // and let current classification logic recompute them.
+    connection.prepare(`
+    UPDATE issues
+    SET issue_class_source = 'heuristic'
+    WHERE issue_class_source = 'explicit'
+  `).run();
     // Add pending_merge_prep column for merge queue stewardship
     addColumnIfMissing(connection, "issues", "pending_merge_prep", "INTEGER NOT NULL DEFAULT 0");
     // Add merge_prep_attempts for retry budget / escalation
@@ -330,6 +355,8 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         delegated_to_patchrelay INTEGER NOT NULL DEFAULT 1,
         issue_class TEXT,
         issue_class_source TEXT,
+        parent_linear_issue_id TEXT,
+        parent_issue_key TEXT,
         issue_key TEXT,
         title TEXT,
         description TEXT,
@@ -379,6 +406,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         review_fix_attempts INTEGER NOT NULL DEFAULT 0,
         zombie_recovery_attempts INTEGER NOT NULL DEFAULT 0,
         last_zombie_recovery_at TEXT,
+        orchestration_settle_until TEXT,
         updated_at TEXT NOT NULL,
         UNIQUE(project_id, linear_issue_id)
       );
@@ -390,6 +418,8 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         delegated_to_patchrelay,
         issue_class,
         issue_class_source,
+        parent_linear_issue_id,
+        parent_issue_key,
         issue_key,
         title,
         description,
@@ -439,6 +469,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         review_fix_attempts,
         zombie_recovery_attempts,
         last_zombie_recovery_at,
+        orchestration_settle_until,
         updated_at
       )
       SELECT
@@ -448,6 +479,8 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         COALESCE(delegated_to_patchrelay, 1),
         issue_class,
         issue_class_source,
+        parent_linear_issue_id,
+        parent_issue_key,
         issue_key,
         title,
         description,
@@ -497,6 +530,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         COALESCE(review_fix_attempts, 0),
         COALESCE(zombie_recovery_attempts, 0),
         last_zombie_recovery_at,
+        orchestration_settle_until,
         updated_at
       FROM issues;
 

package/dist/db.js

@@ -154,6 +154,18 @@ export class PatchRelayDatabase {
     listDependents(projectId, blockerLinearIssueId) {
         return this.issues.listDependents(projectId, blockerLinearIssueId);
     }
+    replaceIssueParentLink(params) {
+        this.issues.replaceIssueParentLink(params);
+    }
+    listChildLinks(projectId, parentLinearIssueId) {
+        return this.issues.listChildLinks(projectId, parentLinearIssueId);
+    }
+    listChildIssues(projectId, parentLinearIssueId) {
+        return this.issues.listChildIssues(projectId, parentLinearIssueId);
+    }
+    countOpenChildIssues(projectId, parentLinearIssueId) {
+        return this.issues.countOpenChildIssues(projectId, parentLinearIssueId);
+    }
     getLatestGitHubCiSnapshot(projectId, linearIssueId) {
         return this.issues.getLatestGitHubCiSnapshot(projectId, linearIssueId);
     }

package/dist/idle-reconciliation.js

@@ -5,6 +5,7 @@ import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
 import { getReviewFixBudget } from "./run-budgets.js";
+import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
 import { execCommand } from "./utils.js";
 function isFailingCheckStatus(status) {
     return status === "failed" || status === "failure";
@@ -170,6 +171,24 @@ export class IdleIssueReconciler {
                 }
             }
         }
+        const now = Date.now();
+        for (const issue of this.db.issues.listIssues()) {
+            if (issue.issueClass !== "orchestration"
+                || !issue.orchestrationSettleUntil
+                || issue.activeRunId !== undefined
+                || !issue.delegatedToPatchRelay) {
+                continue;
+            }
+            const settleAt = Date.parse(issue.orchestrationSettleUntil);
+            if (!Number.isFinite(settleAt) || settleAt > now) {
+                continue;
+            }
+            queueSettledOrchestrationIssue({
+                db: this.db,
+                issue,
+                enqueueIssue: this.deps.enqueueIssue,
+            });
+        }
     }
     shouldProbeTerminalIssueFromGitHub(issue) {
         if (issue.prNumber === undefined)

package/dist/issue-class.js

@@ -18,10 +18,14 @@ function looksLikeUmbrellaText(issue) {
     ].some((token) => haystack.includes(token));
 }
 export function classifyIssue(params) {
-    if (params.issue.issueClass === "implementation" || params.issue.issueClass === "orchestration") {
+    if (params.issue.issueClassSource === "explicit"
+        && (params.issue.issueClass === "implementation" || params.issue.issueClass === "orchestration")) {
         return { issueClass: params.issue.issueClass, issueClassSource: "explicit" };
     }
-    if (params.trackedDependentCount > 0) {
+    if (params.issue.parentLinearIssueId) {
+        return { issueClass: "implementation", issueClassSource: "hierarchy" };
+    }
+    if (params.childIssueCount > 0) {
         return { issueClass: "orchestration", issueClassSource: "hierarchy" };
     }
     if (looksLikeUmbrellaText(params.issue)) {

package/dist/issue-overview-query.js

@@ -94,6 +94,7 @@ export class IssueOverviewQuery {
             blockedByKeys,
             factoryState: issueRecord?.factoryState ?? "delegated",
             pendingRunType: issueRecord?.pendingRunType,
+            orchestrationSettleUntil: issueRecord?.orchestrationSettleUntil,
             prNumber: session.prNumber,
             prState: issueRecord?.prState,
             prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
@@ -128,6 +129,7 @@ export class IssueOverviewQuery {
                 blockedByCount: unresolvedBlockedBy.length,
                 hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
                 hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
+                orchestrationSettleUntil: issueRecord?.orchestrationSettleUntil,
                 ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
                 ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
                 ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),

package/dist/issue-session.js

@@ -88,6 +88,12 @@ export function isIssueSessionReadyForExecution(params) {
         return false;
     if (params.blockedByCount > 0)
         return false;
+    if (params.orchestrationSettleUntil) {
+        const settleAt = Date.parse(params.orchestrationSettleUntil);
+        if (Number.isFinite(settleAt) && settleAt > Date.now()) {
+            return false;
+        }
+    }
     if (params.sessionState === "done" || params.sessionState === "waiting_input") {
         return false;
     }

package/dist/linear-client.js

@@ -2,6 +2,16 @@ import { refreshLinearOAuthToken } from "./linear-oauth.js";
 import { decryptSecret, encryptSecret } from "./token-crypto.js";
 const LINEAR_ISSUE_SELECTION = `
   id
+  parent {
+    id
+    identifier
+    title
+    state {
+      id
+      name
+      type
+    }
+  }
   identifier
   title
   description
@@ -334,6 +344,9 @@ export class LinearGraphqlClient {
         }));
         return {
             id: issue.id,
+            ...(issue.parent?.id ? { parentId: issue.parent.id } : {}),
+            ...(issue.parent?.identifier ? { parentIdentifier: issue.parent.identifier } : {}),
+            ...(issue.parent?.title ? { parentTitle: issue.parent.title } : {}),
             ...(issue.identifier ? { identifier: issue.identifier } : {}),
             ...(issue.title ? { title: issue.title } : {}),
             ...(issue.description ? { description: issue.description } : {}),

package/dist/linear-status-comment-sync.js

@@ -40,6 +40,7 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
         factoryState: issue.factoryState,
         pendingRunType: issue.pendingRunType,
+        orchestrationSettleUntil: issue.orchestrationSettleUntil,
         ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
         ...(issue.prState ? { prState: issue.prState } : {}),
         prHeadSha: issue.prHeadSha,

package/dist/no-pr-completion-check.js

@@ -168,6 +168,9 @@ export async function handleNoPrCompletionCheck(params) {
             });
             return;
         }
+        const orchestrationOpenChildren = params.issue.issueClass === "orchestration"
+            ? params.db.issues.countOpenChildIssues(params.run.projectId, params.run.linearIssueId)
+            : 0;
         const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
             params.db.runs.finishRun(params.run.id, completedRunUpdate);
             params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
@@ -176,9 +179,10 @@ export async function handleNoPrCompletionCheck(params) {
                 projectId: params.run.projectId,
                 linearIssueId: params.run.linearIssueId,
                 activeRunId: null,
-                factoryState: "done",
+                factoryState: params.issue.issueClass === "orchestration" && orchestrationOpenChildren > 0 ? "delegated" : "done",
                 pendingRunType: null,
                 pendingRunContextJson: null,
+                orchestrationSettleUntil: null,
                 lastGitHubFailureSource: null,
                 lastGitHubFailureHeadSha: null,
                 lastGitHubFailureSignature: null,
@@ -203,8 +207,12 @@ export async function handleNoPrCompletionCheck(params) {
             fallbackIssue: params.issue,
             level: "info",
             status: "completion_check_done",
-            summary: "No PR found; confirmed done",
-            detail: completionCheck.summary,
+            summary: params.issue.issueClass === "orchestration" && orchestrationOpenChildren > 0
+                ? "No PR found; orchestration will wait on child deliveries"
+                : "No PR found; confirmed done",
+            detail: params.issue.issueClass === "orchestration" && orchestrationOpenChildren > 0
+                ? `${completionCheck.summary} Waiting on ${orchestrationOpenChildren} open child issue(s) before final convergence.`
+                : completionCheck.summary,
             activity: buildCompletionCheckActivity("done", completionCheck),
         });
         const doneIssue = params.db.issues.getIssue(params.run.projectId, params.run.linearIssueId) ?? params.issue;

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/tracked-issue-list-query.js

@@ -82,6 +82,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,
@@ -162,6 +163,7 @@ export class TrackedIssueListQuery {
                 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) } : {}),
@@ -181,6 +183,7 @@ export class TrackedIssueListQuery {
                 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) } : {}),

package/dist/tracked-issue-projector.js

@@ -15,6 +15,7 @@ export function buildTrackedIssueRecord(params) {
         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,
@@ -64,6 +65,7 @@ export function buildTrackedIssueRecord(params) {
             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 } : {}),

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) {

package/dist/webhooks.js

@@ -195,6 +195,7 @@ function extractIssueMetadata(payload) {
         return undefined;
     }
     const teamRecord = asRecord(issueRecord.team);
+    const parentRecord = asRecord(issueRecord.parent);
     const identifier = getString(issueRecord, "identifier");
     const title = getString(issueRecord, "title");
     const url = getString(issueRecord, "url") ?? payload.url;
@@ -208,12 +209,18 @@ function extractIssueMetadata(payload) {
     const delegateId = getString(issueRecord, "delegateId") ?? getString(delegateRecord ?? {}, "id");
     const delegateName = getString(delegateRecord ?? {}, "name");
     const description = getString(issueRecord, "description");
+    const parentId = getString(issueRecord, "parentId") ?? getString(parentRecord ?? {}, "id");
+    const parentIdentifier = getString(parentRecord ?? {}, "identifier");
+    const parentTitle = getString(parentRecord ?? {}, "title");
     const rawPriority = issueRecord.priority;
     const priority = typeof rawPriority === "number" ? rawPriority : undefined;
     const rawEstimate = issueRecord.estimate;
     const estimate = typeof rawEstimate === "number" ? rawEstimate : undefined;
     return {
         id,
+        ...(parentId ? { parentId } : {}),
+        ...(parentIdentifier ? { parentIdentifier } : {}),
+        ...(parentTitle ? { parentTitle } : {}),
         ...(identifier ? { identifier } : {}),
         ...(title ? { title } : {}),
         ...(description ? { description } : {}),

package/package.json

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