agent-tempo 1.7.0 → 2.0.0-beta.2

package/dist/workflows/session.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.agentSessionWorkflow = agentSessionWorkflow;
 const workflow_1 = require("@temporalio/workflow");
 const search_attributes_1 = require("../utils/search-attributes");
+const constants_1 = require("../constants");
 const common_1 = require("@temporalio/common");
 /**
  * Workflow-deterministic clock. The Temporal TS SDK intercepts `new Date()` at the
@@ -61,15 +62,6 @@ async function agentSessionWorkflow(input) {
     // PR-C commit 6 (#119a): each attachment carries its own `leaseMs` (negotiated at
     // claim time). No workflow-side default constant — heartbeats extend `expiresAt`
     // by `currentAttachment.leaseMs`.
-    /**
-     * Legacy CAN-extension constant. Retained solely so sessions that ran on a
-     * pre-#249 workflow bundle replay deterministically: the `patched()` branch at
-     * the CAN-boundary extension site selects this constant on the non-patched
-     * side, matching the exact arg sequence those histories recorded. New runs
-     * (and all post-#249 CAN transitions) use `currentAttachment.leaseMs` instead
-     * — see the call site below.
-     */
-    const HEARTBEAT_INTERVAL_MS = 30_000;
     /**
      * Default grace period for `draining → detached` transition after requestDetach. Used when a
      * `requestDetach` signal omits `deadlineMs`. Per-signal overrides are honored via the
@@ -78,65 +70,51 @@ async function agentSessionWorkflow(input) {
     const DEFAULT_DRAINING_DEADLINE_MS = 5_000;
     /** Max duration a messageId can stay in-flight before the safety timer ejects it. */
     const PROCESSING_DEADLINE_MS = 15 * 60 * 1000;
-    // Version marker for v0.10 — records a patch marker in workflow history.
-    // Future workflow changes that alter the command sequence should use
-    // patched('v0.10-<change-name>') to protect in-flight sessions from
-    // non-determinism errors during rolling deploys.
-    (0, workflow_1.patched)('v0.10-initial');
-    (0, workflow_1.patched)('v0.11-check-and-set-status');
-    (0, workflow_1.patched)('v0.13-quality-gates');
-    (0, workflow_1.patched)('v0.14-worktrees');
-    (0, workflow_1.patched)('v0.15-blocked-detection');
-    (0, workflow_1.patched)('v0.18-stages');
-    (0, workflow_1.patched)('v0.23-hold-release');
-    (0, workflow_1.patched)('v0.25-attachment-lifecycle');
-    // Issue #172: kept as a replay marker for workflows that predate the
-    // simpler hold-on-startup design (v0.26). The state field + interceptor
-    // were removed in favor of baking the banner/directive into
-    // `SessionInput.messages` at workflow creation, but leaving the patched
-    // marker ensures existing replay histories that recorded this command
-    // still deserialize cleanly. Safe no-op today.
-    (0, workflow_1.patched)('v0.26-pending-startup-context');
-    // ── T0.5 SA diet (#747) — ONE marker gates the whole diet ──
-    //
-    // New runs (incl. post-deploy CAN successors — fresh executions re-record
-    // the marker) stop writing the read-only/write-only search attributes:
-    //   - AgentTempoGitRoot / AgentTempoPlayerType / AgentTempoIsConductor
-    //     migrate to the workflow MEMO (low-churn fields only — NEVER memo
-    //     counters like activityCount/lastActivityAt: memo upserts are
-    //     billable actions, that would trade query actions for upsert actions).
-    //   - AgentTempoAttachmentId is dropped outright (zero readers anywhere;
-    //     adapters correlate via the claimAttachment token).
-    // Old histories replay the recorded SA-write branch unchanged — safe,
-    // because any namespace with such histories has the legacy SAs registered.
-    // Readers go through the dual-read helpers in utils/search-attributes.ts
-    // (memo preferred, SA fallback). Filter SAs (Ensemble, PlayerId, Hostname,
-    // AttachedHost, AttachmentState) are untouched — they appear in visibility
-    // query expressions and MUST stay search attributes.
-    const saDiet = (0, workflow_1.patched)('v1.8-sa-diet');
-    // T0.1 (#748) — the observation-path memo extension: workDir / agentType /
-    // gitBranch join the memo so the cloud-profile maestro scan can read the
-    // full player row from visibility list results (zero per-player queries).
-    // Payload-only upsertMemo change, but gated behind its own marker per the
-    // repo's conservative determinism policy. All three pass the low-churn bar
-    // (workDir/agentType set-at-start; gitBranch via rare updateMetadata).
-    const memoObservationFields = (0, workflow_1.patched)('v1.8-memo-observation-fields');
+    /**
+     * #704 — max duration a session may sit in `booting` (no attachment claimed)
+     * before the watchdog fails the recruit. Default 180s (architect OQ-3: 120s
+     * floor; 180s clears a cold launch + cross-host recruit handshake). Workflows
+     * can't read process.env, so an operator/test override rides durable metadata
+     * (`bootingDeadlineMs`, sourced from `AGENT_TEMPO_BOOTING_DEADLINE_MS` at
+     * spawn). Only ARMED for headless adapters on a fresh (non-handoff) boot —
+     * see `armBootingWatchdog` below.
+     */
+    const BOOTING_DEADLINE_MS = typeof input.metadata.bootingDeadlineMs === 'number' && input.metadata.bootingDeadlineMs > 0
+        ? input.metadata.bootingDeadlineMs
+        : 180_000;
+    /**
+     * #704 Item 2 — generous main-loop wake backstop (architect-ruled FINAL).
+     * Every deadline-mutating handler now bumps `wakeEpoch`, so in steady state
+     * the loop wakes on exactly `nextDeadlineMs()`. This backstop is defense-in-
+     * depth for a FUTURE handler that mutates wake-relevant state but forgets the
+     * bump: the loop still re-evaluates at least every `BACKSTOP_MS` instead of
+     * sleeping forever (we deliberately do NOT add an `Infinity → no-timer` branch
+     * — a silent indefinite sleep is the exact failure class #704 exists to kill).
+     * A fallback-cap wake that finds actionable state emits a loud WARN (below) so
+     * a missed bump is detectable, not masked. 30min is large enough that it never
+     * fires in correct steady state yet bounds any regression.
+     */
+    const BACKSTOP_MS = 30 * 60 * 1000;
+    // ── 2.0 clean-slate (#787) ──
+    // The replay-only `patched()` markers that protected in-flight 1.x sessions
+    // across rolling deploys are gone: 2.0 is a hard cutover (the #786 boot guard
+    // refuses to replay any 1.x history), so there are no pre-patch histories left
+    // to protect. The SA-diet (#747) and observation-field memo (#748) behavior is
+    // now unconditional — the new path IS the only path.
     /**
      * T0.5 — the memo mirror of the migrated read-only metadata fields.
      * Shared by the run-start upsert and the updateMetadata handler so the
      * two write sites can't drift. Key names come from the shared
      * {@link MEMO_KEYS} registry (also used by the client-side
-     * `workflow.start({ memo })` seeds and the dual-read helpers).
+     * `workflow.start({ memo })` seeds and the memo readers).
      */
     const metaMemo = () => ({
         ...(input.metadata.gitRoot ? { [search_attributes_1.MEMO_KEYS.gitRoot]: input.metadata.gitRoot } : {}),
         ...(input.metadata.playerType ? { [search_attributes_1.MEMO_KEYS.playerType]: input.metadata.playerType } : {}),
         [search_attributes_1.MEMO_KEYS.isConductor]: input.metadata.isConductor === true,
-        ...(memoObservationFields ? {
-            [search_attributes_1.MEMO_KEYS.workDir]: input.metadata.workDir,
-            [search_attributes_1.MEMO_KEYS.agentType]: input.metadata.agentType || 'claude',
-            ...(input.metadata.gitBranch ? { [search_attributes_1.MEMO_KEYS.gitBranch]: input.metadata.gitBranch } : {}),
-        } : {}),
+        [search_attributes_1.MEMO_KEYS.workDir]: input.metadata.workDir,
+        [search_attributes_1.MEMO_KEYS.agentType]: input.metadata.agentType || 'claude',
+        ...(input.metadata.gitBranch ? { [search_attributes_1.MEMO_KEYS.gitBranch]: input.metadata.gitBranch } : {}),
     });
     // Ensure search attributes are always current — critical when reconnecting
     // via WorkflowIdConflictPolicy.USE_EXISTING, which skips the attributes
@@ -145,17 +123,20 @@ async function agentSessionWorkflow(input) {
         AgentTempoEnsemble: [input.metadata.ensemble],
         AgentTempoPlayerId: [input.metadata.playerId],
         AgentTempoHostname: [input.metadata.hostname],
-        ...(saDiet ? {} : {
-            ...(input.metadata.gitRoot ? { AgentTempoGitRoot: [input.metadata.gitRoot] } : {}),
-            ...(input.metadata.playerType ? { AgentTempoPlayerType: [input.metadata.playerType] } : {}),
-            AgentTempoIsConductor: [input.metadata.isConductor === true],
-        }),
         // v0.25 attachment search attributes — initial values for a fresh/restored workflow.
         // Updated on every phase transition below.
         AgentTempoAttachedHost: [input.currentAttachment?.hostname ?? ''],
         AgentTempoAttachmentState: [input.phase ?? 'booting'],
-        ...(saDiet ? {} : { AgentTempoAttachmentId: [input.currentAttachment?.attachmentId ?? ''] }),
     });
+    // #786 — 2.0 cutover protocol STAMP. Authoritative from the constant (this IS
+    // the 2.0 bundle → always PROTOCOL_VERSION, regardless of `input.protocol`).
+    // Re-upserted on EVERY run, incl. continueAsNew successors, so visibility
+    // always shows the stamp for the daemon boot guard — no need to thread a memo
+    // arg through the CAN payload. A 1.x run never executes this, so the guard
+    // sees its memo as undefined → un-stamped → refuse. Unconditional (no
+    // `patched()` marker): #786 is the first change on the 2.0 line, so there are
+    // no pre-stamp v2 histories to protect from this new command.
+    (0, workflow_1.upsertMemo)({ [search_attributes_1.MEMO_KEYS.protocol]: constants_1.PROTOCOL_VERSION });
     // ── State (carried across continue-as-new) ──
     let part = input.part ?? input.autoSummary ?? 'No description set';
     // T0.5 (#747) — memo carrier for the migrated read-only fields + part.
@@ -164,9 +145,7 @@ async function agentSessionWorkflow(input) {
     // `memo` option so the fields are visible before the first workflow task
     // (and on standard-visibility servers whose list results may lag memo
     // upserts — see PR #747 T0.5 notes). Low-churn fields ONLY.
-    if (saDiet) {
-        (0, workflow_1.upsertMemo)({ ...metaMemo(), [search_attributes_1.MEMO_KEYS.part]: part });
-    }
+    (0, workflow_1.upsertMemo)({ ...metaMemo(), [search_attributes_1.MEMO_KEYS.part]: part });
     const messages = input.messages ?? [];
     const sentMessages = input.sentMessages ?? [];
     const outbox = input.outbox ?? [];
@@ -234,6 +213,44 @@ async function agentSessionWorkflow(input) {
         : undefined;
     /** ISO timestamp of when the workflow most recently entered `detached`. */
     let detachedSince = null;
+    // ── #704 — Booting attach-timeout watchdog ──
+    // A session that starts FRESH in `booting` (no attachment handoff) and never
+    // reaches `claimAttachment` within `BOOTING_DEADLINE_MS` is a failed recruit:
+    // the adapter never launched, wedged on a launch dialog, or crashed pre-attach.
+    // We ARM a deadline only when ALL THREE hold:
+    //   1. `startedFresh` — no handoff. A restart/migrate carries `currentAttachment`
+    //      (and a non-`booting` phase), so its successor must NEVER arm — it already
+    //      has an adapter contract. Detached/other CAN successors are likewise skipped.
+    //   2. `recruitedBy` present — this is an actual RECRUIT (a spawn is coming and is
+    //      expected to attach). The watchdog is a failed-recruit detector — it even
+    //      notifies `recruitedBy` ("recruit of <name> never attached"). Skeletons created
+    //      WITHOUT a recruiter intentionally sit in `booting` awaiting a manual attach and
+    //      must NOT be swept: from-upgrade re-attach skeletons (#786 — the designed
+    //      await-per-player-restart behavior), conductor/`up`, manual self-bootstrap. A
+    //      positive allowlist ("arm only real recruits") rather than a per-skeleton-path
+    //      blocklist, so future adapterless-skeleton paths inherit the safe default.
+    //   3. `canBlockOnDialog !== true` — the adapter can't park on a blocking
+    //      launch-time dialog. Interactive `claude-code` (dev-channels dialog) sets
+    //      this true and is DISARMED until #890 dissolves the dialog: an operator-away
+    //      false-kill of a legitimately-waiting recruit is worse than the hang.
+    // The structural `canBlockOnDialog` (resolved from the adapter descriptor at
+    // spawn, threaded via metadata) is the contract — NOT an `agentType` hardcode.
+    const startedFresh = !input.currentAttachment && (input.phase === undefined || input.phase === 'booting');
+    const armBootingWatchdog = startedFresh && !!input.metadata.recruitedBy && input.metadata.canBlockOnDialog !== true;
+    /**
+     * ISO timestamp of when this run entered `booting`, or `null` when the watchdog
+     * is disarmed (handoff / non-recruit skeleton / interactive / already attached).
+     * Cleared on the first successful fresh claim. Only non-null ⟹ armed, so
+     * `nextDeadlineMs()` and the main-loop reap can gate on `bootingSince !== null` alone.
+     */
+    let bootingSince = armBootingWatchdog ? workflowNow().toISOString() : null;
+    if (startedFresh && input.metadata.recruitedBy && input.metadata.canBlockOnDialog === true) {
+        // Visibility for the known, bounded gap (companion brief §1): interactive
+        // claude-code RECRUITS keep today's indefinite-`booting` behavior until #890.
+        // (Non-recruit skeletons are disarmed for a different reason — no recruiter —
+        // and don't log this #890 notice.)
+        workflow_1.log.info('booting watchdog DISARMED for interactive claude-code recruit (canBlockOnDialog) — pending #890');
+    }
     // ── Processing Lifecycle State (fixes #99) ──
     // Tracks messages currently being processed by a blocking adapter. While non-empty,
     // stale detection is suppressed AND the phase refines to `processing`.
@@ -316,6 +333,11 @@ async function agentSessionWorkflow(input) {
     function nextDeadlineMs() {
         const nowMs = workflowNow().getTime();
         const candidates = [];
+        // #704 — booting attach-timeout. `bootingSince` is non-null only while the
+        // watchdog is armed AND the session is still booting (cleared on fresh claim).
+        if (phase === 'booting' && bootingSince) {
+            candidates.push(new Date(bootingSince).getTime() + BOOTING_DEADLINE_MS);
+        }
         if (currentAttachment) {
             candidates.push(new Date(currentAttachment.expiresAt).getTime());
         }
@@ -408,7 +430,7 @@ async function agentSessionWorkflow(input) {
         // #399 W2 — every inbound cue counts as received traffic.
         receivedCount++;
         // Track inbound messages that expect a response (default: true for backward compat)
-        if ((0, workflow_1.patched)('v0.20-response-requested-blocked') && msg.responseRequested !== false) {
+        if (msg.responseRequested !== false) {
             lastInboundRRTime = workflowNow().getTime();
         }
     });
@@ -418,8 +440,7 @@ async function agentSessionWorkflow(input) {
         // daemon aggregate — T0.1) can read it from visibility list results
         // instead of a per-player getPart query. Low-churn by nature: part
         // changes when a player re-describes its work, not per message.
-        if (saDiet)
-            (0, workflow_1.upsertMemo)({ [search_attributes_1.MEMO_KEYS.part]: newPart });
+        (0, workflow_1.upsertMemo)({ [search_attributes_1.MEMO_KEYS.part]: newPart });
         lastActivityTime = workflowNow().getTime();
         activityCount++;
         lastOutboundTime = workflowNow().getTime();
@@ -461,7 +482,6 @@ async function agentSessionWorkflow(input) {
         lastActivityTime = workflowNow().getTime();
         activityCount++;
     });
-    (0, workflow_1.setHandler)(signals_1.pendingResetQuery, () => pendingReset);
     (0, workflow_1.setHandler)(signals_1.ackResetSignal, (resetId) => {
         // Race-safe: only clear if the ack matches the current pending reset, so a
         // newer reset landing during the extension's wipe isn't silently dropped.
@@ -494,16 +514,10 @@ async function agentSessionWorkflow(input) {
             AgentTempoEnsemble: [input.metadata.ensemble],
             AgentTempoPlayerId: [input.metadata.playerId],
             AgentTempoHostname: [input.metadata.hostname],
-            ...(saDiet ? {} : {
-                ...(input.metadata.gitRoot ? { AgentTempoGitRoot: [input.metadata.gitRoot] } : {}),
-                ...(input.metadata.playerType ? { AgentTempoPlayerType: [input.metadata.playerType] } : {}),
-                AgentTempoIsConductor: [input.metadata.isConductor === true],
-            }),
         });
         // T0.5 — keep the memo mirror current (low-churn: metadata updates are
         // rare lifecycle events, not per-message traffic).
-        if (saDiet)
-            (0, workflow_1.upsertMemo)(metaMemo());
+        (0, workflow_1.upsertMemo)(metaMemo());
         lastActivityTime = workflowNow().getTime();
         activityCount++;
     });
@@ -588,6 +602,10 @@ async function agentSessionWorkflow(input) {
             // Phase refinement: if we're attached (or awaiting), move to `processing`.
             if (phase === 'attached' || phase === 'awaiting')
                 setPhase('processing');
+            // #704 Item 2 — setting `processingSince` adds a new `PROCESSING_DEADLINE_MS`
+            // deadline; bump `wakeEpoch` so the main loop arms it immediately rather than
+            // relying on the backstop cap (the historical reason for the 5-min cap).
+            wakeEpoch++;
         }
         lastActivityTime = workflowNow().getTime();
         activityCount++;
@@ -618,6 +636,10 @@ async function agentSessionWorkflow(input) {
                 const outboxIdle = !outbox.some((e) => e.status === 'pending' || e.status === 'processing');
                 setPhase(outboxIdle ? 'awaiting' : 'attached');
             }
+            // #704 Item 2 — clearing `processingSince` removes the processing deadline;
+            // bump `wakeEpoch` so the main loop re-evaluates (and dispatches any pending
+            // outbox) immediately rather than waiting on the backstop cap.
+            wakeEpoch++;
         }
         lastActivityTime = workflowNow().getTime();
         activityCount++;
@@ -711,8 +733,12 @@ async function agentSessionWorkflow(input) {
         }
         (0, workflow_1.upsertSearchAttributes)({
             AgentTempoAttachedHost: [''],
-            ...(saDiet ? {} : { AgentTempoAttachmentId: [''] }),
         });
+        // #704 Item 1b — stamp the typed close-reason MEMO on this terminal
+        // completion. The bootstrap orphan-guard (`server.ts`) reads it via
+        // `describe().memo` to self-tombstone a late-launching orphan process whose
+        // run was destroyed and never recreated (no running run + this reason).
+        (0, workflow_1.upsertMemo)({ [search_attributes_1.MEMO_KEYS.closeReason]: 'destroyed' });
         setPhase('gone');
         // Inject a final audit message so the old adapter-completion path has something to show.
         messages.push({
@@ -724,6 +750,10 @@ async function agentSessionWorkflow(input) {
         });
         lastActivityTime = workflowNow().getTime();
         activityCount++;
+        // #704 Item 2 — `destroyRequested` (set above) is in the main-loop predicate,
+        // but bump `wakeEpoch` too so a loop asleep on a far deadline wakes promptly
+        // to run the terminal exit path.
+        wakeEpoch++;
     });
     (0, workflow_1.setHandler)(signals_1.isDestroyedQuery, () => destroyed || destroyRequested);
     // ── Test-only CAN trigger (#226) ──
@@ -767,6 +797,10 @@ async function agentSessionWorkflow(input) {
             currentAttachment.leaseMs = leaseMs;
             lastActivityTime = nowMs;
             activityCount++;
+            // #704 Item 2 — this mutates `expiresAt` (a `nextDeadlineMs()` input); bump
+            // `wakeEpoch` so the main loop re-evaluates the new lease deadline instead
+            // of relying on the backstop cap.
+            wakeEpoch++;
             return attachmentTokenFrom(currentAttachment, leaseMs);
         }
         // Conflict: active lease held by someone else.
@@ -796,16 +830,33 @@ async function agentSessionWorkflow(input) {
         drainingSince = null;
         drainingDeadlineMs = null;
         detachedSince = null;
+        // #704 Item 1a — first successful claim: disarm the booting watchdog so
+        // `nextDeadlineMs()` drops the booting deadline (the lease deadline takes over).
+        bootingSince = null;
         setPhase('attached');
         (0, workflow_1.upsertSearchAttributes)({
             AgentTempoAttachedHost: [host],
-            ...(saDiet ? {} : { AgentTempoAttachmentId: [newAttachment.attachmentId] }),
         });
         lastActivityTime = nowMs;
         activityCount++;
+        // #704 Item 2 — a fresh claim moves a `booting`/`detached` session to a
+        // finite lease deadline (often from `+Infinity`); bump `wakeEpoch` so the
+        // main loop picks up the new deadline immediately.
+        wakeEpoch++;
         return attachmentTokenFrom(newAttachment, leaseMs);
     }, {
-        validator: ({ leaseMs }) => {
+        validator: ({ host, leaseMs, protocolVersion }) => {
+            // #786 — cross-host cutover safety, checked FIRST (pure, synchronous, no
+            // IO, no history event — rejects pre-admission). A v1 adapter omits
+            // `protocolVersion` (→ undefined); any value other than PROTOCOL_VERSION is
+            // a stale/foreign adapter that must not claim this 2.0 workflow. Actionable
+            // error names the host + the fix.
+            if (protocolVersion !== constants_1.PROTOCOL_VERSION) {
+                throw common_1.ApplicationFailure.nonRetryable(`claimAttachment rejected on ${(0, workflow_1.workflowInfo)().workflowId}: adapter on host ` +
+                    `'${host}' speaks protocol ${protocolVersion ?? '(v1/unset)'}, but this is a ` +
+                    `protocol-${constants_1.PROTOCOL_VERSION} (2.0) workflow. Upgrade the agent-tempo install on ` +
+                    `that host to 2.0 (it cannot drive a 2.0 session).`, 'ProtocolMismatch');
+            }
             if (!Number.isInteger(leaseMs) || leaseMs < 1_000 || leaseMs > 600_000) {
                 throw common_1.ApplicationFailure.nonRetryable(`leaseMs must be between 1000 and 600000, got ${leaseMs}`, 'InvalidLease');
             }
@@ -881,7 +932,7 @@ async function agentSessionWorkflow(input) {
         // mismatch any history that recorded the race — conservative tiebreak.
         // Evaluated lazily (the v0.26-can-lease-from-attachment single-use
         // precedent): only histories that hit forceDetach record the marker.
-        if ((0, workflow_1.patched)('v0.27-force-detach-recheck') && currentAttachment?.attachmentId !== reaped.attachmentId) {
+        if (currentAttachment?.attachmentId !== reaped.attachmentId) {
             workflow_1.log.info(`forceDetach: attachment changed during hard-terminate await ` +
                 `(expected ${reaped.attachmentId}, now ${currentAttachment?.attachmentId ?? 'none'}) — ` +
                 `not clobbering the fresh claim`);
@@ -898,7 +949,6 @@ async function agentSessionWorkflow(input) {
         setPhase('detached');
         (0, workflow_1.upsertSearchAttributes)({
             AgentTempoAttachedHost: [''],
-            ...(saDiet ? {} : { AgentTempoAttachmentId: [''] }),
         });
         // #159 Gap 1b: wake the main loop — `phase === 'detached'` isn't in the predicate
         // and the condition would otherwise sleep on the now-stale lease-expiry deadline.
@@ -1025,7 +1075,6 @@ async function agentSessionWorkflow(input) {
         setPhase('detached');
         (0, workflow_1.upsertSearchAttributes)({
             AgentTempoAttachedHost: [''],
-            ...(saDiet ? {} : { AgentTempoAttachmentId: [''] }),
         });
         lastActivityTime = workflowNow().getTime();
         activityCount++;
@@ -1356,12 +1405,10 @@ async function agentSessionWorkflow(input) {
             // live handler. Reconciled entries keep the ORIGINAL receipt time as
             // `reportedAt` and carry `reconciled: true`.
             //
-            // patched() gate: stage state itself drives no commands, but the
-            // completion/failure messages pushed here join `messages`, which
-            // participates in main-loop condition predicates whose resolution
-            // interleaves with recorded timer commands — a command-sequence
-            // dependency on replay. Conservative tiebreak per the ruling: marker.
-            if ((0, workflow_1.patched)('v0.27-stage-reconcile-reports')) {
+            // Stage reconciliation — fold each player's latest result/blocker report
+            // into stage status, then apply the stage's completion/failure transitions.
+            // (2.0: was patched()-gated for 1.x replay determinism; now unconditional — #787.)
+            {
                 const nowMs = workflowNow().getTime();
                 for (const playerEntry of entry.players) {
                     // Most recent stage-relevant (result|blocker) report from this
@@ -1481,52 +1528,36 @@ async function agentSessionWorkflow(input) {
         // timer would leave the workflow in `draining` until that old timer fired.
         const epochAtWait = wakeEpoch;
         const deadlineMs = nextDeadlineMs();
-        // NOTE: This 5-min fallback wake is LOAD-BEARING despite an old "PR-C shim"
-        // framing that surfaced in researcher's tier-2 cleanup audit (2026-04-26).
-        // While #175 removed the legacy stale/blocked detection block this originally
-        // fed (see ~§1527 below), the wake itself remains essential as the loop's
-        // periodic re-evaluation tick for state changes from handlers that mutate
-        // `nextDeadlineMs()` inputs WITHOUT bumping `wakeEpoch`:
-        //
-        //   - `claimAttachmentUpdate` (renewal + fresh paths) — sets
-        //     `currentAttachment.expiresAt` → new lease-expiry deadline
-        //   - `processingStartUpdate` — sets `processingSince` → new
-        //     `PROCESSING_DEADLINE_MS` deadline
-        //   - `processingEndUpdate` — clears `processingSince` → cancels processing
-        //     deadline
-        //   - `destroyUpdate` (async hard-terminate-then-flip path)
-        //
-        // Without the fallback wake, a workflow waiting in `condition(predicate)` on
-        // an `Infinity` deadline (booting / detached, no draining, no processing)
-        // never re-evaluates `nextDeadlineMs()` after one of these handlers fires —
-        // the freshly-set lease-expiry timer is never picked up, lease expiry is
-        // never reaped, and the workflow stalls until external state forces the
-        // predicate true. Smoking-gun test that fails without the fallback:
-        // `test/session-phase-processing.test.ts:54` "attached -> processing ->
-        // awaiting via processingStart/End (#117 fix)" — times out at 10s because
-        // the loop never makes progress after `processingStart` lands on a fresh
-        // claim.
-        //
-        // Removing this fallback safely is a "main-loop wake-discipline cleanup"
-        // separate from the audit's framing — adds `wakeEpoch++` to each affected
-        // handler, gates with `patched()` markers for replay-determinism (live
-        // workflow histories already recorded the existing `Timer 5min` events),
-        // and adds a regression test covering the handler-induced-deadline pickup.
-        // Estimated 4–6 handler edits + tests, separate dedicated PR. See the
-        // 2026-04-26 forensics for the full mechanism walkthrough — link from this
-        // file's PR history.
-        //
-        // Until that cleanup happens, DO NOT remove this fallback. The
-        // `Math.min(deadlineMs, 5 * 60 * 1000)` cap is part of the same mechanism:
-        // it ensures every deadline (even hour-long lease-expiry timers) is
-        // re-evaluated at least every 5 min so handler-induced deadline shortenings
-        // can't be missed.
-        const conditionPromise = (0, workflow_1.condition)(() => destroyRequested ||
+        // #704 Item 2 — wake discipline. Every handler that mutates a `nextDeadlineMs()`
+        // input now bumps `wakeEpoch` (claim renew+fresh, processingStart/End, the
+        // draining/detach paths, destroy), so in steady state the loop wakes on exactly
+        // `nextDeadlineMs()`. `BACKSTOP_MS` is defense-in-depth for a FUTURE handler that
+        // mutates wake-relevant state but forgets the bump: the loop still re-evaluates
+        // at least every 30 min instead of sleeping forever. We deliberately keep the
+        // backstop even when `deadlineMs === Infinity` (idle booting-disarmed / detached)
+        // — a silent indefinite sleep is the exact failure class #704 exists to kill, so
+        // there is NO `Infinity → no-timer` branch. A backstop wake that finds actionable
+        // state emits a loud WARN below so a missed bump is detectable, not masked.
+        // Canary: `test/session-phase-processing.test.ts` ("attached → processing →
+        // awaiting via processingStart/End") fails if a deadline-mutating handler drops
+        // its bump.
+        const wokeByPredicate = await (0, workflow_1.condition)(() => destroyRequested ||
             canDispatch() ||
             hasPendingStop() ||
             phase === 'gone' ||
-            wakeEpoch !== epochAtWait, deadlineMs === Number.POSITIVE_INFINITY ? '5 minutes' : Math.min(deadlineMs, 5 * 60 * 1000));
-        await conditionPromise;
+            wakeEpoch !== epochAtWait, Math.min(deadlineMs, BACKSTOP_MS));
+        // #704 Item 2 — missed-bump breadcrumb. If we woke on the backstop cap (NOT the
+        // predicate) yet a deadline is already overdue or the predicate is now actionable,
+        // a handler likely mutated wake-relevant state without bumping `wakeEpoch`.
+        // Surface it loudly instead of letting the backstop silently mask the regression.
+        if (!wokeByPredicate) {
+            const overdue = nextDeadlineMs() <= 0;
+            const actionable = destroyRequested || canDispatch() || hasPendingStop() || phase === 'gone';
+            if (overdue || actionable) {
+                workflow_1.log.warn(`main-loop woke via fallback backstop with actionable state — possible missed ` +
+                    `wakeEpoch bump (phase=${phase}, overdue=${overdue}, actionable=${actionable})`);
+            }
+        }
         if (destroyRequested)
             break;
         // ── §9.5.a: Lease expiry — reap attachment and transition to `detached`. ──
@@ -1543,10 +1574,73 @@ async function agentSessionWorkflow(input) {
             setPhase('detached');
             (0, workflow_1.upsertSearchAttributes)({
                 AgentTempoAttachedHost: [''],
-                ...(saDiet ? {} : { AgentTempoAttachmentId: [''] }),
             });
             workflow_1.log.warn(`lease expired for attachment ${reaped.attachmentId} (host=${reaped.hostname})`);
         }
+        // ── §9.5.a2: booting attach-timeout (#704). ──
+        // A fresh, armed session that never reached `claimAttachment` within
+        // `BOOTING_DEADLINE_MS` is a failed recruit (adapter never launched / wedged /
+        // crashed pre-attach). Fail it LOUDLY: sweep any orphan process, notify the
+        // recruiter, stamp the close-reason tombstone MEMO, and COMPLETE terminal
+        // `gone`. `bootingSince !== null` ⟹ the watchdog is armed (headless adapter on
+        // a fresh, non-handoff boot). The bootstrap orphan-guard backstops the case
+        // where the swept process (or a never-swept one) re-launches later.
+        if (phase === 'booting' &&
+            bootingSince !== null &&
+            workflowNow().getTime() - new Date(bootingSince).getTime() >= BOOTING_DEADLINE_MS) {
+            lastDetachReason = 'boot-timeout';
+            workflow_1.log.warn(`boot-timeout: session never attached within ${Math.round(BOOTING_DEADLINE_MS / 1000)}s — failing recruit`);
+            // Best-effort orphan sweep. At the deadline the spawned process usually
+            // EXISTS (still booting), so this command-line kill is MORE likely to land
+            // than the destroy-time sweep. No-op if nothing launched.
+            const killHost = preferredHost ?? input.metadata.hostname;
+            if (killHost) {
+                try {
+                    const killResult = await getHardTerminateProxyForDestroy(killHost)({
+                        ensemble: input.metadata.ensemble,
+                        playerName: input.metadata.playerId,
+                        agent: (input.metadata.agentType ?? 'claude'),
+                        workDir: input.metadata.workDir,
+                    });
+                    workflow_1.log.info(`boot-timeout hard-terminate on ${killHost}: strategy=${killResult.strategy}, ` +
+                        `killedPids=[${killResult.killedPids.join(',')}]`);
+                }
+                catch (err) {
+                    workflow_1.log.warn(`boot-timeout hard-terminate failed on ${killHost} (best-effort): ` +
+                        `${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Notify the recruiter (if any) — reuses the outbox `deliverCue` activity.
+            const recruiter = input.metadata.recruitedBy;
+            if (recruiter) {
+                try {
+                    await deliverCue({
+                        ensemble: input.metadata.ensemble,
+                        fromPlayerId: input.metadata.playerId,
+                        targetPlayerId: recruiter,
+                        message: `Recruit of "${input.metadata.playerId}" never attached within ` +
+                            `${Math.round(BOOTING_DEADLINE_MS / 1000)}s — failed; the spawned process (if any) was swept.`,
+                    });
+                }
+                catch (err) {
+                    workflow_1.log.warn(`boot-timeout recruiter-notify failed (best-effort): ` +
+                        `${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Tombstone MEMO (shared with the orphan-guard) + terminal `gone`.
+            (0, workflow_1.upsertMemo)({ [search_attributes_1.MEMO_KEYS.closeReason]: 'boot-timeout' });
+            lastAdapterMeta = lastAdapterMeta ?? {
+                hostname: killHost ?? input.metadata.hostname,
+                adapterId: '',
+            };
+            bootingSince = null;
+            setPhase('gone');
+            (0, workflow_1.upsertSearchAttributes)({ AgentTempoAttachedHost: [''] });
+            // Route through the terminal exit path (mirrors `destroy`): isDestroyed
+            // queries read true, then the loop breaks to COMPLETE.
+            destroyRequested = true;
+            break;
+        }
         // ── §9.5.b: processingDeadline — force exit from `processing` if a messageId is wedged. ──
         if (processingSince !== null &&
             workflowNow().getTime() - new Date(processingSince).getTime() > PROCESSING_DEADLINE_MS) {
@@ -1607,7 +1701,6 @@ async function agentSessionWorkflow(input) {
             setPhase('detached');
             (0, workflow_1.upsertSearchAttributes)({
                 AgentTempoAttachedHost: [''],
-                ...(saDiet ? {} : { AgentTempoAttachmentId: [''] }),
             });
             if (reaped) {
                 workflow_1.log.info(`drainingDeadline exceeded (${Math.round(window / 1000)}s); ` +
@@ -1821,6 +1914,12 @@ async function agentSessionWorkflow(input) {
                         adapterId: currentAttachment.adapterId,
                     };
                     lastDetachReason = 'spawn-failed';
+                    // #704 Item 2 — no `wakeEpoch++` needed here despite clearing
+                    // `nextDeadlineMs()` inputs (currentAttachment/processingSince/draining):
+                    // this rollback runs INLINE in the main-loop body (outbox dispatch), not
+                    // in a signal/update handler, so the very next loop iteration recomputes
+                    // `nextDeadlineMs()` before the next `condition()` wait. (The bump
+                    // discipline is for HANDLERS that mutate these while the loop is parked.)
                     currentAttachment = null;
                     inFlightMessages.clear();
                     processingSince = null;
@@ -1830,7 +1929,6 @@ async function agentSessionWorkflow(input) {
                     setPhase('detached');
                     (0, workflow_1.upsertSearchAttributes)({
                         AgentTempoAttachedHost: [''],
-                        ...(saDiet ? {} : { AgentTempoAttachmentId: [''] }),
                     });
                     workflow_1.log.warn(`spawn failed for "${entry.targetName}"; rolled back attachment ${entry.attachmentId} → detached`);
                 }
@@ -1873,25 +1971,11 @@ async function agentSessionWorkflow(input) {
             // matches what the adapter signed up for and covers at least one full heartbeat
             // interval for every adapter class.
             //
-            // The `patched()` gate keeps replay of pre-#249 workflow runs deterministic:
-            // histories that CAN'd on the old bundle recorded `extendAttachmentForCAN(…, 30_000, …)`,
-            // so replaying those runs must pick the legacy constant. New runs (and in-flight
-            // runs that CAN *after* the deploy) take the patched branch.
-            //
             // Math lives in `./attachment-math.ts` for direct unit testability (#127).
-            //
-            // #255 cleanup: the `patched()` call stays at the eager/unconditional
-            // position it was introduced in — relocating it inside the
-            // `currentAttachment ?` branch would skip marker recording on histories
-            // that hit the CAN site with a null attachment, risking replay
-            // non-determinism against those recordings. The dead-code cleanup is
-            // strictly the removal of the `?? HEARTBEAT_INTERVAL_MS` fallback that
-            // used to sit inside the ternary: on the patched branch it never fires
-            // (Attachment.leaseMs is required), and on the pre-patched branch the
-            // fallback is replaced by the bare constant — same value either way.
-            const usePatchedLease = (0, workflow_1.patched)('v0.26-can-lease-from-attachment');
+            // (2.0: the v0.26-can-lease-from-attachment patched() gate is gone — #787 —
+            // so CAN always extends by `currentAttachment.leaseMs` = 3 × heartbeatMs.)
             const extendedAttachment = currentAttachment
-                ? (0, attachment_math_1.extendAttachmentForCAN)(currentAttachment, usePatchedLease ? currentAttachment.leaseMs : HEARTBEAT_INTERVAL_MS, workflowNow().getTime())
+                ? (0, attachment_math_1.extendAttachmentForCAN)(currentAttachment, currentAttachment.leaseMs, workflowNow().getTime())
                 : undefined;
             await (0, workflow_1.continueAsNew)({
                 ...input,