patchrelay 0.47.2 → 0.49.0

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;
 }
@@ -162,6 +164,45 @@ function buildScopeDiscipline(issue, context) {
         "- A review repair should fix the concrete concern on the current head, not silently expand the Linear issue into a broader rewrite.",
     ].join("\n");
 }
+function buildOrchestrationScopeDiscipline(context) {
+    const unresolvedBlockers = Array.isArray(context?.unresolvedBlockers)
+        ? context.unresolvedBlockers.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.",
+        "Create blocking follow-up work only when it is necessary to satisfy the original parent goal.",
+        "Prefer non-blocking follow-up issues over keeping the umbrella open for optional polish or adjacent expansion.",
+        "",
+        "### Child Issue Summaries",
+        "",
+        ...(childIssues.length > 0
+            ? summarizeRelationEntries(childIssues, { emptyText: "No child issues are currently tracked." })
+            : ["No child issues are currently tracked."]),
+        "",
+        ...(unresolvedBlockers.length > 0
+            ? ["### Unresolved Blockers", "", ...summarizeRelationEntries(unresolvedBlockers), ""]
+            : []),
+        "### Convergence Rule",
+        "",
+        "- Close the umbrella when the original parent goal is satisfied.",
+        "- If you discover one missing required slice, you may create a justified blocking follow-up.",
+        "- Do not invent optional expansion without explicit human approval.",
+    ].join("\n");
+}
 function buildHumanContext(context) {
     const promptContext = typeof context?.promptContext === "string" ? context.promptContext.trim() : "";
     const latestPrompt = typeof context?.promptBody === "string" ? context.promptBody.trim() : "";
@@ -357,18 +398,30 @@ function buildFollowUpPromptPrelude(issue, runType, context) {
         "",
         wakeReason === "direct_reply"
             ? "Why this turn exists: A human reply arrived for the outstanding question from the previous turn."
-            : wakeReason === "completion_check_continue"
-                ? "Why this turn exists: The previous turn ended without a PR, and PatchRelay's completion check decided the work should continue automatically."
-                : wakeReason === "branch_upkeep"
-                    ? "Why this turn exists: GitHub still shows the PR branch as needing upkeep after the requested code change was addressed."
-                    : wakeReason === "followup_comment"
-                        ? "Why this turn exists: A human follow-up comment arrived after the previous turn."
-                        : `Why this turn exists: Continue the existing ${runType} run from the latest issue state.`,
+            : wakeReason === "initial_delegate"
+                ? "Why this turn exists: This orchestration issue was just delegated and needs an initial plan."
+                : wakeReason === "child_delivered"
+                    ? "Why this turn exists: A child issue was delivered and the umbrella needs to review the outcome."
+                    : wakeReason === "child_changed"
+                        ? "Why this turn exists: A child issue changed state and the umbrella may need to adjust."
+                        : wakeReason === "child_regressed"
+                            ? "Why this turn exists: A previously progressing child issue regressed and the umbrella needs to reassess."
+                            : wakeReason === "human_instruction"
+                                ? "Why this turn exists: A human added new guidance for this orchestration issue."
+                                : wakeReason === "completion_check_continue"
+                                    ? "Why this turn exists: The previous turn ended without a PR, and PatchRelay's completion check decided the work should continue automatically."
+                                    : wakeReason === "branch_upkeep"
+                                        ? "Why this turn exists: GitHub still shows the PR branch as needing upkeep after the requested code change was addressed."
+                                        : wakeReason === "followup_comment"
+                                            ? "Why this turn exists: A human follow-up comment arrived after the previous turn."
+                                            : `Why this turn exists: Continue the existing ${runType} run from the latest issue state.`,
         wakeReason === "direct_reply"
             ? "Required action now: Apply the latest human answer, continue from the current branch/session context, and publish the next concrete result."
-            : wakeReason === "completion_check_continue"
-                ? "Required action now: Continue from the current branch and thread context, finish the task, and publish the next concrete result."
-                : "Required action now: Continue from the latest branch state, refresh any stale assumptions, and publish the next concrete result.",
+            : wakeReason === "initial_delegate"
+                ? "Required action now: Inspect the umbrella goal, review the child set, and record the next orchestration step."
+                : wakeReason === "completion_check_continue"
+                    ? "Required action now: Continue from the current branch and thread context, finish the task, and publish the next concrete result."
+                    : "Required action now: Continue from the latest branch state, refresh any stale assumptions, and publish the next concrete result.",
         "",
     ];
     if (wakeReason === "completion_check_continue" && typeof context?.completionCheckSummary === "string" && context.completionCheckSummary.trim()) {
@@ -417,14 +470,32 @@ function buildWorkflowGuidance(repoPath, runType) {
     }
     return "";
 }
-function buildPublicationContract(runType) {
+function buildOrchestrationWorkflowGuidance() {
+    return [
+        "## Workflow Guidance",
+        "",
+        "Use the wake reason and current child issue summaries to decide what kind of orchestration work is needed now.",
+        "Typical orchestration phases are: initial setup, waiting on child progress, reviewing delivered child work, final audit, creating a justified follow-up, or closing the umbrella.",
+        "Keep outputs concise and observable in Linear.",
+    ].join("\n");
+}
+function buildPublicationContract(runType, issueClass) {
+    if (issueClass === "orchestration") {
+        return [
+            "## Publication Requirements",
+            "",
+            "Before finishing, publish the orchestration outcome rather than leaving it implicit.",
+            "By default, orchestration work should finish without opening an overlapping umbrella PR.",
+            "Valid orchestration outcomes include: recording an observation, updating the rollout plan, creating follow-up issues, opening a small cleanup PR that the parent clearly owns, or closing the umbrella.",
+            "If you create new blocking follow-up work, justify it against the original parent goal rather than optional polish.",
+        ].join("\n");
+    }
     if (runType === "implementation") {
         return [
             "## Publication Requirements",
             "",
             "Before finishing, publish the result instead of leaving it only in the worktree.",
             "If the task is genuinely complete without a PR, say so clearly in your normal summary instead of inventing one.",
-            "If the issue is acting as coordination-only work and the real implementation belongs in child issues, finish without opening an overlapping umbrella PR.",
             "If the worktree already contains relevant changes for this issue, verify them and publish them.",
             "If you changed files for this issue, commit them, push the issue branch, and open or update the PR before stopping.",
             "Do not stop with only local commits or uncommitted changes.",
@@ -456,6 +527,7 @@ function buildPublicationContract(runType) {
     ].join("\n");
 }
 function buildSections(issue, runType, repoPath, context, followUp = false) {
+    const issueClass = issue.issueClass;
     const sections = [
         { id: "header", content: buildPromptHeader(issue) },
     ];
@@ -463,7 +535,10 @@ function buildSections(issue, runType, repoPath, context, followUp = false) {
     if (followUp && reactiveContext) {
         sections.push({ id: "follow-up-turn", content: reactiveContext });
     }
-    sections.push({ id: "task-objective", content: buildTaskObjective(issue) }, { id: "scope-discipline", content: buildScopeDiscipline(issue, context) });
+    sections.push({ id: "task-objective", content: buildTaskObjective(issue) }, {
+        id: "scope-discipline",
+        content: issueClass === "orchestration" ? buildOrchestrationScopeDiscipline(context) : buildScopeDiscipline(issue, context),
+    });
     const humanContext = buildHumanContext(context);
     if (humanContext) {
         sections.push({ id: "human-context", content: humanContext });
@@ -471,11 +546,13 @@ function buildSections(issue, runType, repoPath, context, followUp = false) {
     if (!followUp && reactiveContext) {
         sections.push({ id: "reactive-context", content: reactiveContext });
     }
-    const workflow = buildWorkflowGuidance(repoPath, runType);
+    const workflow = issueClass === "orchestration"
+        ? buildOrchestrationWorkflowGuidance()
+        : buildWorkflowGuidance(repoPath, runType);
     if (workflow) {
         sections.push({ id: "workflow-guidance", content: workflow });
     }
-    sections.push({ id: "publication-contract", content: buildPublicationContract(runType) });
+    sections.push({ id: "publication-contract", content: buildPublicationContract(runType, issueClass) });
     return sections;
 }
 function filterAllowedReplacements(promptLayer) {

package/dist/run-orchestrator.js

@@ -16,6 +16,7 @@ import { RunReconciler } from "./run-reconciler.js";
 import { RunRecoveryService } from "./run-recovery-service.js";
 import { RunWakePlanner } from "./run-wake-planner.js";
 import { getRemainingZombieRecoveryDelayMs } from "./zombie-recovery.js";
+import { classifyIssue } from "./issue-class.js";
 import { loadConfig } from "./config.js";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
@@ -138,7 +139,7 @@ export class RunOrchestrator {
     materializeLegacyPendingWake(issue, lease) {
         return this.runWakePlanner.materializeLegacyPendingWake(issue, lease);
     }
-    buildImplementationCoordinationContext(issue) {
+    buildRelatedIssueContext(issue) {
         const unresolvedBlockers = this.db.issues
             .listIssueDependencies(issue.projectId, issue.linearIssueId)
             .filter((entry) => !isResolvedDependencyState(entry.blockerCurrentLinearStateType))
@@ -149,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 } : {}),
@@ -162,14 +161,27 @@ 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 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;
+        }
+        return this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            issueClass: classification.issueClass,
+            issueClassSource: classification.issueClassSource,
+        });
+    }
     // ─── Run ────────────────────────────────────────────────────────
     async run(item) {
         await this.refreshCodexRuntimeConfig();
@@ -179,7 +191,8 @@ export class RunOrchestrator {
         if (this.leaseService.hasLocalLease(item.projectId, item.issueId)) {
             return;
         }
-        const issue = this.db.issues.getIssue(item.projectId, item.issueId);
+        const initialIssue = this.db.issues.getIssue(item.projectId, item.issueId);
+        const issue = initialIssue ? this.classifyTrackedIssue(initialIssue) : undefined;
         if (!issue || issue.activeRunId !== undefined)
             return;
         const issueSession = this.db.issueSessions.getIssueSession(item.projectId, item.issueId);
@@ -216,7 +229,7 @@ export class RunOrchestrator {
             ? await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context)
             : context;
         const coordinationContext = runType === "implementation"
-            ? this.buildImplementationCoordinationContext(issue)
+            ? this.buildRelatedIssueContext(issue)
             : undefined;
         const effectiveContext = coordinationContext
             ? { ...coordinationContext, ...(baseContext ?? {}) }

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,
@@ -42,6 +43,7 @@ export function buildTrackedIssueRecord(params) {
         projectId: params.issue.projectId,
         linearIssueId: params.issue.linearIssueId,
         delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
+        ...(params.issue.issueClass ? { issueClass: params.issue.issueClass } : {}),
         ...(params.issue.issueKey ? { issueKey: params.issue.issueKey } : {}),
         ...(params.issue.title ? { title: params.issue.title } : {}),
         ...(params.issue.url ? { issueUrl: params.issue.url } : {}),
@@ -63,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

@@ -1,5 +1,6 @@
 import { triggerEventAllowed } from "../project-resolution.js";
 import { hasExplicitPatchRelayWakeIntent, isInertPatchRelayComment, isPatchRelayManagedCommentAuthor, } from "./comment-policy.js";
+import { classifyIssue } from "../issue-class.js";
 const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated", "awaiting_input"]);
 export class CommentWakeHandler {
     db;
@@ -24,6 +25,10 @@ export class CommentWakeHandler {
         const issue = this.db.issues.getIssue(project.id, normalized.issue.id);
         if (!issue)
             return;
+        const issueClass = classifyIssue({
+            issue,
+            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);
         const selfAuthored = isPatchRelayManagedCommentAuthor(installation, normalized.actor, normalized.comment.userName);
@@ -55,7 +60,7 @@ export class CommentWakeHandler {
         if (!issue.activeRunId) {
             if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
                 const directReply = params.isDirectReplyToOutstandingQuestion(issue);
-                const wakeIntent = directReply || hasExplicitPatchRelayWakeIntent(trimmedBody);
+                const wakeIntent = issueClass === "orchestration" || directReply || hasExplicitPatchRelayWakeIntent(trimmedBody);
                 if (!wakeIntent) {
                     this.feed?.publish({
                         level: "info",

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.47.2",
+  "version": "0.49.0",
   "license": "MIT",
   "type": "module",
   "repository": {