agent-relay-server 0.111.0 → 0.112.0

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

@@ -30,6 +30,7 @@ import {
 import { emitTaskChanged } from "../sse";
 import type { Task, TaskDetail, TaskEvent, TaskGateState } from "../types";
 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 {
@@ -82,7 +83,7 @@ function isTerminalTaskStatus(status: Task["status"]): boolean {
 
 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");
   const transition = taskTransitionForStage(detail.deliverableStage);
   if (input.actor !== "task-lifecycle" && transition && before?.deliverableStage !== detail.deliverableStage) {
@@ -94,6 +95,14 @@ export function setTaskEntityStage(id: number, input: SetTaskStageInput): TaskDe
       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;
 }
 

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,12 +30,13 @@ 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 { 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 {
@@ -310,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.
@@ -341,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,