agent-relay-server 0.110.0 → 0.112.0

package/src/db/task-entity.ts

@@ -592,6 +592,7 @@ export interface ListDeliverableTasksFilter {
   status?: string;
   deliverableStage?: string;
   teamId?: string;
+  createdBy?: string;
   limit?: number;
 }
 
@@ -601,6 +602,7 @@ export function listDeliverableTasks(filter: ListDeliverableTasksFilter = {}): T
   if (filter.status) { conditions.push("status = ?"); params.push(filter.status); }
   if (filter.deliverableStage) { conditions.push("deliverable_stage = ?"); params.push(filter.deliverableStage); }
   if (filter.teamId) { conditions.push("team_id = ?"); params.push(filter.teamId); }
+  if (filter.createdBy) { conditions.push("created_by = ?"); params.push(filter.createdBy); }
   const limit = Math.min(Math.max(filter.limit ?? 100, 1), 500);
   params.push(limit);
   return (getDb().query(`${TASK_SELECT} WHERE ${conditions.join(" AND ")} ORDER BY updated_at DESC LIMIT ?`).all(...params as any[]) as any[]).map(rowToTask);

package/src/mcp-notification-subscription-tools.ts

@@ -21,8 +21,9 @@ import { getTaskEntity } from "./services/task-entity";
 import { cleanString } from "./validation";
 import { NOTIFICATION_TYPES, type NotificationScope, type NotificationType } from "./notification-types";
 import { previewNotificationRouting, whyNotified } from "./notification-router";
+import { TASK_SEMANTIC_NOTIFICATION_TYPES } from "./services/task-semantic-events";
 
-const TASK_NOTIFICATION_TYPES = ["task.created", "task.started", "task.blocked", "task.needs_decision", "task.landed", "task.closed"] as const satisfies readonly NotificationType[];
+const TASK_NOTIFICATION_TYPES = TASK_SEMANTIC_NOTIFICATION_TYPES as readonly NotificationType[];
 
 export const NOTIFICATION_SUBSCRIPTION_TOOLS = [
   {

package/src/mcp-task-tools.ts

@@ -121,7 +121,8 @@ function commitArg(value: unknown): TaskCommitRef | undefined {
 }
 
 export function relayTaskTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Record<string, unknown> {
-  const actor = authContextFromMcp(auth).actor.id;
+  const ctx = authContextFromMcp(auth);
+  const actor = ctx.callerAgentId ?? ctx.actor.id;
   if (!isRecord(args)) throw new ValidationError("arguments must be an object");
 
   if (name === "relay_task_create") {

package/src/notification-rules.ts

@@ -272,6 +272,22 @@ registerDefaultAudienceRules("message.new", [
   audiencePredicates.threadParticipant(),
 ]);
 
-for (const type of ["task.created", "task.started", "task.blocked", "task.needs_decision", "task.landed", "task.closed"] as const) {
+for (const type of [
+  "task.created",
+  "task.started",
+  "task.blocked",
+  "task.needs_decision",
+  "task.gate_failed",
+  "task.committed_on_branch",
+  "task.review_requested",
+  "task.land_conflict",
+  "task.landed",
+  "task.landed_on_main",
+  "task.closed",
+  "task.working",
+  "task.done",
+  "task.deploying",
+  "task.deployed",
+] as const) {
   registerDefaultAudienceRules(type, []);
 }

package/src/notification-types.ts

@@ -7,8 +7,17 @@ export type NotificationType =
   | "task.started"
   | "task.blocked"
   | "task.needs_decision"
+  | "task.gate_failed"
+  | "task.committed_on_branch"
+  | "task.review_requested"
+  | "task.land_conflict"
   | "task.landed"
+  | "task.landed_on_main"
   | "task.closed"
+  | "task.working"
+  | "task.done"
+  | "task.deploying"
+  | "task.deployed"
   | "agent.ready"
   | "agent.exited"
   | "agent.spawn_failed"
@@ -94,8 +103,17 @@ export const DEFAULT_TTL_MS: Record<NotificationType, number | null> = {
   "task.started": null,
   "task.blocked": null,
   "task.needs_decision": null,
+  "task.gate_failed": null,
+  "task.committed_on_branch": null,
+  "task.review_requested": null,
+  "task.land_conflict": null,
   "task.landed": null,
+  "task.landed_on_main": null,
   "task.closed": null,
+  "task.working": null,
+  "task.done": null,
+  "task.deploying": null,
+  "task.deployed": null,
   "agent.ready": null,
   "agent.exited": null,
   "agent.spawn_failed": null,

package/src/reviewer-pipeline.ts

@@ -5,6 +5,7 @@ import { getSpawnPolicy } from "./config-store";
 import { getLifecycleManager } from "./lifecycle-manager";
 import { routeNotification } from "./notification-router";
 import { getWorkspace, listAgents, patchWorkspaceMetadata, updateWorkspaceStatus } from "./db";
+import { emitWorkspaceTaskSemanticNotifications } from "./services/task-lifecycle";
 import type { Command, WorkspaceMergePreview, WorkspaceRecord } from "./types";
 
 type ReviewDecision = "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED";
@@ -59,6 +60,18 @@ export function handleReviewerMergeResult(command: Command, result: Record<strin
     compareRef,
   });
   if (!updated) return false;
+  emitWorkspaceTaskSemanticNotifications({
+    workspace: updated,
+    transition: "review-requested",
+    actor: "reviewer-pipeline",
+    occurrenceKey: `workspace-review:${workspace.id}:${command.id}`,
+    outcome: {
+      reviewer: target,
+      prUrl,
+      prNumber,
+      compareRef,
+    },
+  });
 
   // Obligation (ttl null by type default): a review request must reach the reviewer even if they're
   // offline a while — it's not a bystander notice.

package/src/routes/commands.ts

@@ -11,6 +11,7 @@ import { getCompactionWatch } from "../compaction-watch";
 import { isRecord } from "agent-relay-sdk";
 import { authContextFromRequest } from "../services/auth-context";
 import { commandAuthorizationResource as dispatchCommandAuthorizationResource, dispatchCommand } from "../services/dispatch-command";
+import { emitWorkspaceTaskSemanticNotifications } from "../services/task-lifecycle";
 import { ServiceAuthError } from "../services/errors";
 import { notifyBaseWorktreeStrand, notifyBranchLandFailed, notifyBranchLanded } from "../branch-landed";
 import { applyIdleRefreshResult } from "../maintenance/workspaces";
@@ -305,6 +306,19 @@ export const patchCommand: Handler = async (req, params) => {
             mergeError: command.error ?? "merge failed",
             ...noteMergeNoProgress(current.metadata),
           });
+          if (nextStatus === "conflict") {
+            emitWorkspaceTaskSemanticNotifications({
+              workspace: current,
+              transition: "land-conflict",
+              actor: "workspace-merge",
+              occurrenceKey: `workspace-merge-conflict:${current.id}:${command.id}`,
+              outcome: {
+                reason: command.error ?? "merge failed",
+                commandId: command.id,
+                status: nextStatus,
+              },
+            });
+          }
           notifyBranchLandFailed({
             workspace: current,
             commandId: command.id,

package/src/routes/tasks.ts

@@ -76,6 +76,7 @@ export const getTaskEntities: Handler = (req) => {
     status: url.searchParams.get("status") ?? undefined,
     deliverableStage: url.searchParams.get("deliverableStage") ?? undefined,
     teamId: url.searchParams.get("teamId") ?? undefined,
+    createdBy: url.searchParams.get("createdBy") ?? undefined,
     limit: limitRaw ?? 100,
   }));
 };

package/src/services/spawn-agent.ts

@@ -42,6 +42,7 @@ import { applyDefaultSharedMcp, type SharedMcpSpawnOverride } from "../shared-mc
 import { autoSeedProjectForCwd } from "./project";
 import { hydrateTaskContext, projectTaskHydration } from "./task-context-hydration";
 import { recordTaskEntityDispatchDecision } from "./task-entity";
+import { autoSubscribeTaskCoordinator } from "./task-semantic-events";
 import { dispatchTask } from "../task-dispatcher";
 import { hasComponentScope, isComponentAuthorizedFor } from "../security";
 import { isPathWithinBase } from "../utils";
@@ -586,6 +587,7 @@ export async function spawnAgent(input: SpawnAgentInput, ctx: AuthContext): Prom
         requestedBy,
         ...(hydratedTask?.steer ? { steer: hydratedTask.steer } : {}),
       });
+      autoSubscribeTaskCoordinator(requestedBy, input.taskId);
     } catch (err) {
       console.warn(`task ${input.taskId} spawn attribution skipped: ${errMessage(err)}`);
     }

package/src/services/spawn-registration-watchdog.ts

@@ -9,7 +9,7 @@ interface SpawnCommandRow {
   id: string;
   params: string;
   correlation_id: string | null;
-  created_at: number;
+  updated_at: number;
 }
 
 interface SpawnRegistrationWatchdogResult extends Record<string, unknown> {
@@ -26,12 +26,12 @@ export function reapUnregisteredSpawnCommands(
   const cutoff = now - deadlineMs;
   const notifyCutoff = now - notifyMaxAgeMs;
   const rows = getDb().query(`
-    SELECT id, params, correlation_id, created_at
+    SELECT id, params, correlation_id, updated_at
     FROM commands
     WHERE type = 'agent.spawn'
       AND status = 'succeeded'
-      AND created_at <= ?
-    ORDER BY created_at ASC
+      AND updated_at <= ?
+    ORDER BY updated_at ASC
   `).all(cutoff) as SpawnCommandRow[];
 
   const failedSpawnCommandIds: string[] = [];
@@ -48,7 +48,7 @@ export function reapUnregisteredSpawnCommands(
     const failed = updateCommand(row.id, { status: "failed", error: reason });
     if (!failed || failed.status !== "failed") continue;
     failedSpawnCommandIds.push(failed.id);
-    if (row.created_at >= notifyCutoff) {
+    if (row.updated_at >= notifyCutoff) {
       notifiedSpawnCommandIds.push(failed.id);
       notifyAgentSpawnFailed({
         parent,

package/src/services/task-done-when.ts

@@ -0,0 +1,21 @@
+import { TASK_DELIVERABLE_STAGES } from "agent-relay-sdk";
+import type { TaskDeliverableStage } from "../types";
+
+const STAGE_INDEX = new Map<string, number>(TASK_DELIVERABLE_STAGES.map((stage, i) => [stage, i]));
+
+// `doneWhen` is free text, but these lifecycle tokens have durable semantics.
+export function doneWhenTargetStage(doneWhen: string | undefined): TaskDeliverableStage {
+  const value = doneWhen?.trim().toLowerCase();
+  if (!value) return "landed-on-main";
+  if (value === "deliverable-attached" || value.includes("deliverable attached")) return "committed-on-branch";
+  if (value === "landed" || value === "landed-on-main" || value.includes("landed")) return "landed-on-main";
+  if (value.includes("deploying")) return "deploying";
+  if (value.includes("deploy")) return "deployed";
+  return "landed-on-main";
+}
+
+export function stageSatisfiesDoneWhen(stage: TaskDeliverableStage, doneWhen: string | undefined): boolean {
+  const current = STAGE_INDEX.get(stage) ?? 0;
+  const target = STAGE_INDEX.get(doneWhenTargetStage(doneWhen)) ?? STAGE_INDEX.get("landed-on-main")!;
+  return current >= target;
+}

package/src/services/task-entity.ts

@@ -29,16 +29,18 @@ import {
 } from "../db";
 import { emitTaskChanged } from "../sse";
 import type { Task, TaskDetail, TaskEvent, TaskGateState } from "../types";
-import { emitTaskSemanticNotification, taskTransitionForStatus } from "./task-semantic-events";
+import { removeSubscriptionsForTask } from "../db/notification-subscriptions";
+import { stageSatisfiesDoneWhen } from "./task-done-when";
+import { autoSubscribeTaskCoordinator, emitTaskSemanticNotification, taskTransitionForStage, taskTransitionForStatus } from "./task-semantic-events";
 
 export function createTaskEntity(input: CreateDeliverableTaskInput): TaskDetail {
   const detail = createDeliverableTask(input);
+  autoSubscribeTaskCoordinator(input.createdBy, detail.id);
   emitTaskChanged(detail, "task.created");
   emitTaskSemanticNotification({
     task: detail,
     transition: "created",
     actor: input.createdBy,
-    recipients: input.createdBy ? [input.createdBy] : [],
     occurrenceKey: latestTaskEventOccurrence(detail.id, "task.created"),
   });
   return detail;
@@ -68,27 +70,39 @@ export function setTaskEntityStatus(id: number, input: SetTaskStatusInput): Task
       task: detail,
       transition,
       actor: input.actor,
-      recipients: detail.createdBy ? [detail.createdBy] : [],
       occurrenceKey: latestTaskEventOccurrence(detail.id, `status:${detail.status}`),
     });
   }
+  if (isTerminalTaskStatus(detail.status)) removeSubscriptionsForTask(detail.id);
   return detail;
 }
 
+function isTerminalTaskStatus(status: Task["status"]): boolean {
+  return status === "done" || status === "failed" || status === "canceled";
+}
+
 export function setTaskEntityStage(id: number, input: SetTaskStageInput): TaskDetail {
   const before = getTaskDetail(id);
-  const detail = setTaskStage(id, input);
+  let detail = setTaskStage(id, input);
   emitTaskChanged(detail, "task.stage");
-  if (input.actor !== "task-lifecycle" && before?.deliverableStage !== "landed-on-main" && detail.deliverableStage === "landed-on-main") {
+  const transition = taskTransitionForStage(detail.deliverableStage);
+  if (input.actor !== "task-lifecycle" && transition && before?.deliverableStage !== detail.deliverableStage) {
     emitTaskSemanticNotification({
       task: detail,
-      transition: "landed",
+      transition,
       actor: input.actor,
-      recipients: detail.createdBy ? [detail.createdBy] : [],
       branch: detail.branch,
       occurrenceKey: latestTaskEventOccurrence(detail.id, `stage:${detail.deliverableStage}`),
     });
   }
+  const deliverableStage = detail.deliverableStage ?? "none";
+  if (detail.status !== "done" && stageSatisfiesDoneWhen(deliverableStage, detail.doneWhen)) {
+    detail = setTaskEntityStatus(id, {
+      status: "done",
+      note: `doneWhen reached at stage ${deliverableStage}`,
+      actor: input.actor,
+    });
+  }
   return detail;
 }
 
@@ -111,6 +125,15 @@ export function recordTaskEntityGate(id: number, input: RecordGateInput): { gate
   const gate = recordGate(id, input);
   const detail = getTaskDetail(id);
   if (detail) emitTaskChanged(detail, "task.gate");
+  if (detail && gate.status === "fail") {
+    emitTaskSemanticNotification({
+      task: detail,
+      transition: "gate-failed",
+      actor: input.actor,
+      occurrenceKey: latestTaskEventOccurrence(detail.id, `gate:${gate.gate}`),
+      outcome: { gate: gate.gate, status: gate.status, ...(gate.detail ? { detail: gate.detail } : {}) },
+    });
+  }
   return { gate, gates: detail?.gates ?? [] };
 }
 

package/src/services/task-lifecycle.ts

@@ -21,7 +21,7 @@
 // owns execution telemetry. Issue CLOSE is the canonical #482/#474 path (which runs just before
 // this in `notifyBranchLanded`) — we do NOT re-close; we PROJECT it via #833's `taskCloseBridge`.
 // The one write-through we make is the single milestone summary (#833's milestone exception).
-import { errMessage, TASK_DELIVERABLE_STAGES } from "agent-relay-sdk";
+import { errMessage } from "agent-relay-sdk";
 import {
   deliverableTaskIdsByBranch,
   deliverableTaskIdsByOwnerAgent,
@@ -30,13 +30,14 @@ import {
   getTaskDetail,
   markTaskAgentReaped,
 } from "../db";
-import { setTaskEntityStage, setTaskEntityStatus } from "./task-entity";
+import { setTaskEntityStage } from "./task-entity";
 import { postTaskMilestoneComment, taskCloseBridge, type TaskCloseBridgeEntry } from "./task-issue-weave";
 import { requestTransientAgentShutdown } from "./transient-agent-reaper";
 import { emitRelayEvent } from "../events";
 import { routeNotification } from "../notification-router";
 import { resolveCoordinatorAgentId } from "../steward-identity";
-import { emitTaskSemanticNotification } from "./task-semantic-events";
+import { stageSatisfiesDoneWhen } from "./task-done-when";
+import { emitTaskSemanticNotification, type TaskSemanticTransition } from "./task-semantic-events";
 import type { IssueRef, TaskDeliverableStage, TaskGateState, WorkspaceRecord } from "../types";
 import type { IssueTrackerAdapter } from "../issue-tracker";
 
@@ -120,33 +121,12 @@ function landedDiffSummary(input: LandedTaskLifecycleInput, log: LogFn): string
   }
 }
 
-// --- doneWhen → deliverable-stage mapping -------------------------------------------------------
-const STAGE_INDEX = new Map<string, number>(TASK_DELIVERABLE_STAGES.map((stage, i) => [stage, i]));
-
-// Which deliverable stage satisfies a Task's `doneWhen`. `doneWhen` is free text (#834): we map
-// the small known vocabulary (`landed` | `deployed` | `deliverable-attached`, with synonyms) and
-// default an UNSET doneWhen to `landed-on-main` — the common case where a Task is done when it
-// lands. An unrecognized value falls back to the landed default rather than blocking forever.
-function doneWhenTargetStage(doneWhen: string | undefined): TaskDeliverableStage {
-  const value = doneWhen?.trim().toLowerCase();
-  if (!value) return "landed-on-main";
-  if (value.includes("deploying")) return "deploying";
-  if (value.includes("deploy")) return "deployed";
-  return "landed-on-main";
-}
-
-function stageSatisfiesDoneWhen(stage: TaskDeliverableStage, doneWhen: string | undefined): boolean {
-  const current = STAGE_INDEX.get(stage) ?? 0;
-  const target = STAGE_INDEX.get(doneWhenTargetStage(doneWhen)) ?? STAGE_INDEX.get("landed-on-main")!;
-  return current >= target;
-}
-
 // --- gate verdict ------------------------------------------------------------------------------
-// "Gates passed" is the signal that frees the agent (reap) AND closes the Task (doneWhen). The
+// "Gates passed" is the signal that frees the agent (reap). The
 // merge landing green is necessary but NOT sufficient (Codex #831 review): a worker that crashed
 // before reporting gates, or reported only a subset, must NOT read as green on a vacuous `[]`.
 // So a pass REQUIRES the expected gates present-and-passing AND no recorded gate failing. An
-// empty / missing / partial / failed ledger is NOT passed → no reap, no close, no green report.
+// empty / missing / partial / failed ledger is NOT passed → no reap, no green report.
 export const EXPECTED_GATES = ["typecheck", "test"] as const;
 
 interface GateVerdict {
@@ -179,7 +159,7 @@ function landKeyFor(input: LandedTaskLifecycleInput): string {
 // `agent.spawn_requested` attribution keyed on the worker's meta.spawnRequestId (fire-and-forget,
 // owner not yet backfilled), and the Task's recorded branch column. Deduped + ordered. Returns []
 // for an ordinary non-task branch → the land is a strict no-op (behavior byte-identical).
-function resolveBoundTaskIds(workspace: LifecycleWorkspace): number[] {
+export function boundTaskIdsForWorkspace(workspace: LifecycleWorkspace): number[] {
   const ids = new Set<number>();
   const owner = workspace.ownerAgentId?.trim();
   if (owner) {
@@ -195,6 +175,35 @@ function resolveBoundTaskIds(workspace: LifecycleWorkspace): number[] {
   return [...ids].sort((a, b) => a - b);
 }
 
+export function emitWorkspaceTaskSemanticNotifications(input: {
+  workspace: LifecycleWorkspace;
+  transition: TaskSemanticTransition;
+  actor?: string;
+  occurrenceKey?: string;
+  outcome?: Record<string, unknown>;
+  sha?: string;
+}): number[] {
+  const emitted: number[] = [];
+  const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
+  for (const taskId of boundTaskIdsForWorkspace(input.workspace)) {
+    const task = getTaskDetail(taskId);
+    if (!task) continue;
+    emitTaskSemanticNotification({
+      task,
+      transition: input.transition,
+      actor: input.actor,
+      recipients: coordinator ? [coordinator] : [],
+      workspaceId: input.workspace.id,
+      branch: input.workspace.branch,
+      ...(input.sha ? { sha: input.sha } : {}),
+      ...(input.occurrenceKey ? { occurrenceKey: input.occurrenceKey } : {}),
+      ...(input.outcome ? { outcome: input.outcome } : {}),
+    });
+    emitted.push(taskId);
+  }
+  return emitted;
+}
+
 // --- reap signal (decoupled from task-done) ----------------------------------------------------
 interface ReapResult {
   reaped: boolean;
@@ -281,20 +290,10 @@ async function driveTaskOnLand(
   const gatesPassed = gateVerdict.passed;
 
   // 3 (doneWhen axis) — reaching the Task's doneWhen target CLOSES the Task (execution status →
-  // done) — but ONLY with verified gates (Codex #831): a failed/incomplete gate keeps the Task
-  // open, never `done`, even at/after the doneWhen stage. Otherwise it stays where it was ("landed
-  // but not done", e.g. doneWhen=deployed waits on deploy). Idempotent: an already-done Task isn't
-  // re-written.
+  // done). Gates are intentionally separate: they guard reaping and green reporting, not the
+  // execution status completion predicate. Otherwise empty gates can strand a landed Task forever.
   const doneWhenSatisfied = stageSatisfiesDoneWhen("landed-on-main", before.doneWhen);
-  let statusAdvanced = false;
-  if (doneWhenSatisfied && gatesPassed && before.status !== "done") {
-    detail = setTaskEntityStatus(taskId, {
-      status: "done",
-      note: `doneWhen reached on land (${input.mergedSha?.slice(0, 12) ?? input.workspace.branch ?? "merged"})`,
-      actor: "task-lifecycle",
-    });
-    statusAdvanced = true;
-  }
+  const statusAdvanced = before.status !== "done" && detail.status === "done";
 
   // 3b (close projection) — the linked issue is closed by the canonical #482/#474 path (which ran
   // immediately before this in notifyBranchLanded). We PROJECT that ledger via #833, never re-close.
@@ -312,7 +311,7 @@ async function driveTaskOnLand(
     const summaryBits = [`Landed to \`${input.workspace.baseRef ?? "main"}\``];
     if (diffSummary) summaryBits.push(diffSummary);
     if (!gatesPassed) summaryBits.push(`gates not verified (${gateVerdict.reason ?? "incomplete"})`);
-    summaryBits.push(statusAdvanced ? "Task done (doneWhen reached)" : `Task at \`landed-on-main\` (doneWhen \`${before.doneWhen ?? "landed"}\` not yet reached)`);
+    summaryBits.push(doneWhenSatisfied ? "Task done (doneWhen reached)" : `Task at \`landed-on-main\` (doneWhen \`${before.doneWhen ?? "landed"}\` not yet reached)`);
     const milestone = await postTaskMilestoneComment(
       {
         taskId,
@@ -382,7 +381,7 @@ function emitDeliverableLandedEvent(input: LandedTaskLifecycleInput, outcome: Ta
   const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
   emitTaskSemanticNotification({
     task,
-    transition: "landed",
+    transition: "landed-on-main",
     actor: "task-lifecycle",
     recipients: coordinator ? [coordinator] : [],
     workspaceId: input.workspace.id,
@@ -401,7 +400,7 @@ function emitDeliverableErrorReceipt(input: LandedTaskLifecycleInput, outcome: T
     type: "task.landed",
     scope: {
       taskId: String(outcome.taskId),
-      transition: "landed",
+      transition: "landed-on-main",
       landKey,
       ...(input.workspace.ownerAgentId ? { agentId: input.workspace.ownerAgentId, author: input.workspace.ownerAgentId } : {}),
       ...(task?.createdBy ? { parent: task.createdBy } : {}),
@@ -417,8 +416,8 @@ function emitDeliverableErrorReceipt(input: LandedTaskLifecycleInput, outcome: T
         kind: "task.lifecycle-error",
         notification: "task-lifecycle-error",
         taskId: outcome.taskId,
-        transition: "landed",
-        semanticEvent: "task.landed",
+        transition: "landed-on-main",
+        semanticEvent: "task.landed-on-main",
         workspaceId: input.workspace.id,
         branch: input.workspace.branch,
         ...(input.mergedSha ? { sha: input.mergedSha } : {}),
@@ -442,7 +441,7 @@ export async function handleLandedTaskLifecycle(
   const log = opts.log ?? ((message: string) => console.warn(message));
   // Non-default-base lands never drive a deliverable (mirror the issue-lifecycle guard).
   if ((input.workspace.baseRef ?? "main") !== "main") return { handled: false, reason: "non-default-branch", tasks: [] };
-  const taskIds = resolveBoundTaskIds(input.workspace);
+  const taskIds = boundTaskIdsForWorkspace(input.workspace);
   if (taskIds.length === 0) return { handled: false, reason: "no-bound-task", tasks: [] };
 
   const diffSummary = landedDiffSummary(input, log);