patchrelay 0.47.2 → 0.49.0

package/dist/db/issue-store.js

@@ -20,6 +20,22 @@ export class IssueStore {
                 sets.push("delegated_to_patchrelay = @delegatedToPatchRelay");
                 values.delegatedToPatchRelay = params.delegatedToPatchRelay ? 1 : 0;
             }
+            if (params.issueClass !== undefined) {
+                sets.push("issue_class = @issueClass");
+                values.issueClass = params.issueClass;
+            }
+            if (params.issueClassSource !== undefined) {
+                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;
@@ -216,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_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,
@@ -231,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, @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,
@@ -244,13 +264,17 @@ 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({
                 projectId: params.projectId,
                 linearIssueId: params.linearIssueId,
                 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,
@@ -300,6 +324,7 @@ export class IssueStore {
                 reviewFixAttempts: params.reviewFixAttempts ?? 0,
                 zombieRecoveryAttempts: params.zombieRecoveryAttempts ?? 0,
                 lastZombieRecoveryAt: params.lastZombieRecoveryAt ?? null,
+                orchestrationSettleUntil: params.orchestrationSettleUntil ?? null,
                 now,
             });
         }
@@ -446,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
@@ -479,6 +565,14 @@ export function mapIssueRow(row) {
         projectId: String(row.project_id),
         linearIssueId: String(row.linear_issue_id),
         delegatedToPatchRelay: Number(row.delegated_to_patchrelay ?? 1) !== 0,
+        ...(row.issue_class !== null && row.issue_class !== undefined ? { issueClass: String(row.issue_class) } : {}),
+        ...(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) } : {}),
@@ -569,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

@@ -4,6 +4,10 @@ CREATE TABLE IF NOT EXISTS issues (
   project_id TEXT NOT NULL,
   linear_issue_id TEXT NOT NULL,
   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,
@@ -30,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)
 );
@@ -216,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);
@@ -236,12 +249,28 @@ 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);
     // Clean up stale dedupe-only webhook records (no payload, never processable)
     connection.prepare("UPDATE webhook_events SET processing_status = 'processed' WHERE processing_status = 'pending' AND payload_json IS NULL").run();
     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
@@ -324,6 +353,10 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         project_id TEXT NOT NULL,
         linear_issue_id TEXT NOT NULL,
         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,
@@ -373,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)
       );
@@ -382,6 +416,10 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         project_id,
         linear_issue_id,
         delegated_to_patchrelay,
+        issue_class,
+        issue_class_source,
+        parent_linear_issue_id,
+        parent_issue_key,
         issue_key,
         title,
         description,
@@ -431,6 +469,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         review_fix_attempts,
         zombie_recovery_attempts,
         last_zombie_recovery_at,
+        orchestration_settle_until,
         updated_at
       )
       SELECT
@@ -438,6 +477,10 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         project_id,
         linear_issue_id,
         COALESCE(delegated_to_patchrelay, 1),
+        issue_class,
+        issue_class_source,
+        parent_linear_issue_id,
+        parent_issue_key,
         issue_key,
         title,
         description,
@@ -487,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/github-webhook-terminal-handler.js

@@ -1,6 +1,7 @@
 import { resolveClosedPrDisposition, resolveClosedPrFactoryState } from "./pr-state.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
+import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
 export async function handleGitHubTerminalPrEvent(params) {
     const { db, linearProvider, enqueueIssue, logger, codex, issue, event, config } = params;
     const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
@@ -66,6 +67,12 @@ export async function handleGitHubTerminalPrEvent(params) {
         }
     }
     if (event.triggerEvent === "pr_merged") {
+        wakeOrchestrationParentsForChildEvent({
+            db,
+            child: updatedIssue,
+            eventType: "child_delivered",
+            enqueueIssue,
+        });
         await completeLinearIssueAfterMerge(params, updatedIssue);
     }
     void syncGitHubLinearSession({

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

@@ -0,0 +1,35 @@
+function normalizeText(value) {
+    return value?.trim().toLowerCase() ?? "";
+}
+function looksLikeUmbrellaText(issue) {
+    const haystack = `${normalizeText(issue.title)}\n${normalizeText(issue.description)}`;
+    if (!haystack.trim())
+        return false;
+    return [
+        "umbrella",
+        "tracker",
+        "tracking",
+        "rollout",
+        "migration",
+        "convergence",
+        "audit",
+        "follow-up issues",
+        "planning/specification issue only",
+    ].some((token) => haystack.includes(token));
+}
+export function classifyIssue(params) {
+    if (params.issue.issueClassSource === "explicit"
+        && (params.issue.issueClass === "implementation" || params.issue.issueClass === "orchestration")) {
+        return { issueClass: params.issue.issueClass, issueClassSource: "explicit" };
+    }
+    if (params.issue.parentLinearIssueId) {
+        return { issueClass: "implementation", issueClassSource: "hierarchy" };
+    }
+    if (params.childIssueCount > 0) {
+        return { issueClass: "orchestration", issueClassSource: "hierarchy" };
+    }
+    if (looksLikeUmbrellaText(params.issue)) {
+        return { issueClass: "orchestration", issueClassSource: "heuristic" };
+    }
+    return { issueClass: "implementation", issueClassSource: "heuristic" };
+}

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-events.js

@@ -52,7 +52,7 @@ export function deriveSessionWakePlan(issue, events) {
             case "delegated":
                 if (!runType) {
                     runType = "implementation";
-                    wakeReason = "delegated";
+                    wakeReason = issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
                 }
                 if (payload?.promptContext !== undefined) {
                     context.promptContext = payload.promptContext;
@@ -61,6 +61,16 @@ export function deriveSessionWakePlan(issue, events) {
                     context.promptBody = payload.promptBody;
                 }
                 break;
+            case "child_changed":
+            case "child_delivered":
+            case "child_regressed":
+                if (!runType) {
+                    runType = "implementation";
+                    wakeReason = event.eventType;
+                }
+                Object.assign(context, payload ?? {});
+                resumeThread = true;
+                break;
             case "direct_reply": {
                 if (!runType) {
                     runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
@@ -98,7 +108,7 @@ export function deriveSessionWakePlan(issue, events) {
             case "operator_prompt": {
                 if (!runType) {
                     runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
-                    wakeReason = event.eventType;
+                    wakeReason = issue.issueClass === "orchestration" ? "human_instruction" : event.eventType;
                 }
                 const text = typeof payload?.text === "string"
                     ? payload.text

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

@@ -1,4 +1,5 @@
 import { buildCompletionCheckActivity } from "./linear-session-reporting.js";
+import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
 function shouldContinueForUnpublishedLocalChanges(message) {
     const normalized = message.trim().toLowerCase();
     if (!normalized)
@@ -167,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);
@@ -175,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,
@@ -202,10 +207,20 @@ 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;
+        wakeOrchestrationParentsForChildEvent({
+            db: params.db,
+            child: doneIssue,
+            eventType: "child_delivered",
+        });
         return;
     }
     const failureReason = `No PR observed and the completion check failed this run: ${completionCheck.summary}`;

package/dist/orchestration-parent-wake.js

@@ -0,0 +1,96 @@
+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 parentIssueId of resolveParentIssueIds(params.db, params.child)) {
+        const parent = params.db.issues.getIssue(params.child.projectId, parentIssueId);
+        if (!parent || !parent.delegatedToPatchRelay) {
+            continue;
+        }
+        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, {
+            projectId: parent.projectId,
+            linearIssueId: parent.linearIssueId,
+            eventType: params.eventType,
+            eventJson: JSON.stringify({
+                childIssueId: params.child.linearIssueId,
+                ...(params.child.issueKey ? { childIssueKey: params.child.issueKey } : {}),
+                ...(params.child.title ? { childTitle: params.child.title } : {}),
+                factoryState: params.child.factoryState,
+                ...(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.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 unique(parentIds);
+}