claude-tempo 0.26.0-beta.2 → 0.26.0-beta.3

package/CLAUDE.md

@@ -20,12 +20,15 @@ src/
 ├── cli.ts             # CLI entry point (claude-tempo command)
 ├── daemon.ts          # Daemon entry point — runs Temporal workers as a detached background process
 ├── cli/
-│   ├── commands.ts    # CLI command implementations (up, start, conduct, status, stop, upgrade, …)
-│   ├── config-command.ts # config subcommand (interactive + set/show)
-│   ├── daemon.ts      # Daemon management utilities (start, stop, status, logs, isDaemonRunning)
+│   ├── commands.ts    # CLI command implementations (up, start, conduct, status, stop, …)
+│   ├── config-command.ts # config subcommand (interactive + set/show) — crash-proof for show/set
+│   ├── daemon.ts      # Daemon management utilities (start, stop, status, heartbeat, isDaemonRunning)
+│   ├── daemon-command.ts # daemon subcommand handler — crash-proof, no Temporal deps
+│   ├── help-text.ts   # help output — crash-proof, no Temporal deps
 │   ├── mcp.ts         # MCP server registration helpers (init, global vs project)
 │   ├── output.ts      # Shared CLI output formatting helpers
-│   └── preflight.ts   # Environment preflight checks
+│   ├── preflight.ts   # Environment preflight checks
+│   └── upgrade-command.ts # upgrade subcommand — crash-proof; dynamic-imports Temporal only for active-session warning
 ├── adapters/
 │   ├── README.md      # Adapter contract documentation
 │   ├── index.ts       # Adapter registry bootstrap + barrel exports

package/dist/adapters/base.d.ts

@@ -137,13 +137,49 @@ export declare abstract class BaseAttachment {
     private schedulePhaseWatcher;
     private tickPhaseWatcher;
     /**
-     * Classify an error as terminal (WorkflowNotFound / ExecutionAlreadyCompleted / phase gone).
+     * Classify a Temporal error as terminal-class vs transient.
      *
-     * Uses name-sniffing rather than `instanceof` to avoid tight coupling to
-     * `@temporalio/client` internals — errors surface through both the Client SDK
-     * and the server's gRPC layer with slightly different shapes.
+     * **Gotcha the caller must know:** the Temporal Node SDK conflates the two
+     * terminal sub-kinds on pinned-runId signal/query failures. Both
+     *   (a) the closed run's specific runId no longer accepting traffic (CAN or
+     *       true COMPLETE / TERMINATED), and
+     *   (b) the workflow id having been fully GC'd
+     * surface as `WorkflowNotFoundError` with message "workflow execution already
+     * completed". We therefore can't tell them apart by error shape alone — the
+     * authoritative differentiator is `fetchHistory` ({@link findCanSuccessorRunId}).
+     * This method only says "yes, this is a terminal-class error; caller must
+     * decide sub-kind" vs "transient, keep retrying."
+     *
+     * Uses name/message-sniffing rather than `instanceof` to tolerate the slightly
+     * different shapes that errors take between `@temporalio/client` and the raw
+     * gRPC layer.
+     */
+    private isTerminalErr;
+    /**
+     * Shared error-classification path for the heartbeat + phase-watcher ticks (#226).
+     *
+     * Returns `true` if the error was a terminal-class (handled inline: CAN rebind
+     * kicked off, or destroy fired). Returns `false` when the caller should treat
+     * the error as transient and continue its backoff.
+     *
+     * Always consults `fetchHistory` on any terminal-class error, because the
+     * Temporal SDK can't distinguish CAN-close from true-complete at the error
+     * level — see {@link isTerminalErr}. The history lookup is cheap (only runs
+     * on terminal, so at most once per adapter lifetime per terminal) and safer
+     * than re-querying by workflow id (which could race a fresh session reusing
+     * the id).
      */
-    private isWorkflowGone;
+    private handleRunEndError;
+    /**
+     * Fetch the closed pinned run's history and return the runId of a CAN successor
+     * if present, else `null`. Scoped to the pinned (old) run via `this.pinnedHandle`,
+     * so it can't be fooled by a fresh session that happens to reuse the workflow id.
+     *
+     * Called only on the terminal path from {@link handleRunEndError}, so the cost
+     * of `fetchHistory` (a full event stream for the closed run) is paid at most
+     * once per terminal — not on every tick.
+     */
+    private findCanSuccessorRunId;
     private fireTerminal;
     /**
      * Opt-in reconnect policy. Default: return `false` — the base class behaves
@@ -194,6 +230,24 @@ export declare abstract class BaseAttachment {
      * when the reason is potentially recoverable.
      */
     private fireTerminalOrReconnect;
+    /**
+     * #226 CAN rebind. Transparently repoints `pinnedHandle` at the successor run,
+     * keeps the existing `attachmentId` / `leaseMs` (the workflow extended the lease
+     * by one heartbeat interval during the CAN transition per §2.3, so the lease is
+     * still live on the new run), notifies the subclass to restart its delivery
+     * loop, and resumes heartbeat + phase-watcher.
+     *
+     * Why this is safe without re-claiming:
+     *  - The new run carries forward `currentAttachment` verbatim from the old run.
+     *  - The adapter's `attachmentId` still matches, so the next `heartbeat` /
+     *    `markDelivered` / `adapterExited` signal on the new pinned handle will be
+     *    accepted unchanged by the workflow's handlers.
+     *  - If the lease actually did expire before we got here (e.g. adapter was
+     *    offline through multiple CAN cycles), the next phase-watcher tick on the
+     *    new pinned handle will see `phase=detached` + no current attachment and
+     *    fall through to the existing #201 reclaim path — belt-and-suspenders.
+     */
+    private runCanRebind;
     /**
      * Budget-bounded reconnect loop.
      *

package/dist/adapters/base.js

@@ -214,14 +214,8 @@ class BaseAttachment {
             this.heartbeatBackoff = 0;
         }
         catch (err) {
-            if (this.isWorkflowGone(err)) {
-                // C1 (PR-C dual-QA follow-up): WorkflowNotFound means the session workflow
-                // has COMPLETEd — that's the `destroy` terminal, not `agent-exited` (which
-                // means our local process died). Matches the phase-watcher `phase === 'gone'
-                // → fireTerminal('destroy')` branch below.
-                this.fireTerminal('destroy');
+            if (await this.handleRunEndError(err))
                 return;
-            }
             this.heartbeatBackoff = Math.min(this.heartbeatBackoff ? this.heartbeatBackoff * LOOP_BACKOFF_FACTOR : this.descriptor.heartbeatMs, LOOP_BACKOFF_MAX_MS);
             log(`heartbeat transient error (retry in ${Math.round(this.heartbeatBackoff)}ms):`, err?.message ?? err);
         }
@@ -292,13 +286,8 @@ class BaseAttachment {
             }
         }
         catch (err) {
-            if (this.isWorkflowGone(err)) {
-                // C1 (PR-C dual-QA follow-up): WorkflowNotFound on the phase-watcher query
-                // has the same meaning as on the heartbeat signal — the workflow is gone,
-                // so the terminal reason is `destroy`.
-                this.fireTerminal('destroy');
+            if (await this.handleRunEndError(err))
                 return;
-            }
             this.phaseBackoff = Math.min(this.phaseBackoff ? this.phaseBackoff * LOOP_BACKOFF_FACTOR : this.descriptor.heartbeatMs, LOOP_BACKOFF_MAX_MS);
             log(`phase watcher transient error (retry in ${Math.round(this.phaseBackoff)}ms):`, err?.message ?? err);
         }
@@ -306,20 +295,90 @@ class BaseAttachment {
             this.schedulePhaseWatcher();
     }
     /**
-     * Classify an error as terminal (WorkflowNotFound / ExecutionAlreadyCompleted / phase gone).
+     * Classify a Temporal error as terminal-class vs transient.
      *
-     * Uses name-sniffing rather than `instanceof` to avoid tight coupling to
-     * `@temporalio/client` internals — errors surface through both the Client SDK
-     * and the server's gRPC layer with slightly different shapes.
+     * **Gotcha the caller must know:** the Temporal Node SDK conflates the two
+     * terminal sub-kinds on pinned-runId signal/query failures. Both
+     *   (a) the closed run's specific runId no longer accepting traffic (CAN or
+     *       true COMPLETE / TERMINATED), and
+     *   (b) the workflow id having been fully GC'd
+     * surface as `WorkflowNotFoundError` with message "workflow execution already
+     * completed". We therefore can't tell them apart by error shape alone — the
+     * authoritative differentiator is `fetchHistory` ({@link findCanSuccessorRunId}).
+     * This method only says "yes, this is a terminal-class error; caller must
+     * decide sub-kind" vs "transient, keep retrying."
+     *
+     * Uses name/message-sniffing rather than `instanceof` to tolerate the slightly
+     * different shapes that errors take between `@temporalio/client` and the raw
+     * gRPC layer.
      */
-    isWorkflowGone(err) {
+    isTerminalErr(err) {
         const e = err;
         const name = e?.name ?? '';
         const msg = e?.message ?? '';
         return (name.includes('WorkflowNotFound') ||
             name.includes('WorkflowExecutionAlreadyCompleted') ||
             msg.includes('WorkflowGone') ||
-            msg.includes('NOT_FOUND'));
+            msg.includes('NOT_FOUND') ||
+            msg.includes('workflow execution already completed'));
+    }
+    /**
+     * Shared error-classification path for the heartbeat + phase-watcher ticks (#226).
+     *
+     * Returns `true` if the error was a terminal-class (handled inline: CAN rebind
+     * kicked off, or destroy fired). Returns `false` when the caller should treat
+     * the error as transient and continue its backoff.
+     *
+     * Always consults `fetchHistory` on any terminal-class error, because the
+     * Temporal SDK can't distinguish CAN-close from true-complete at the error
+     * level — see {@link isTerminalErr}. The history lookup is cheap (only runs
+     * on terminal, so at most once per adapter lifetime per terminal) and safer
+     * than re-querying by workflow id (which could race a fresh session reusing
+     * the id).
+     */
+    async handleRunEndError(err) {
+        if (!this.isTerminalErr(err))
+            return false;
+        // Always try to find a CAN successor — the Temporal SDK's error shape is
+        // ambiguous between CAN and true-destroy, so history is the only reliable
+        // disambiguator (option 1 from the #226 design brief).
+        const successorRunId = await this.findCanSuccessorRunId();
+        if (successorRunId) {
+            this.fireTerminalOrReconnect('continued-as-new', successorRunId);
+            return true;
+        }
+        // No CAN event in the closed run's history → truly terminal (COMPLETED /
+        // TERMINATED / FAILED / workflow-id GC'd).
+        this.fireTerminal('destroy');
+        return true;
+    }
+    /**
+     * Fetch the closed pinned run's history and return the runId of a CAN successor
+     * if present, else `null`. Scoped to the pinned (old) run via `this.pinnedHandle`,
+     * so it can't be fooled by a fresh session that happens to reuse the workflow id.
+     *
+     * Called only on the terminal path from {@link handleRunEndError}, so the cost
+     * of `fetchHistory` (a full event stream for the closed run) is paid at most
+     * once per terminal — not on every tick.
+     */
+    async findCanSuccessorRunId() {
+        if (!this.pinnedHandle)
+            return null;
+        try {
+            const history = await this.pinnedHandle.fetchHistory();
+            const events = history?.events ?? [];
+            for (const ev of events) {
+                const attrs = ev.workflowExecutionContinuedAsNewEventAttributes;
+                const newRunId = attrs?.newExecutionRunId;
+                if (newRunId)
+                    return newRunId;
+            }
+            return null;
+        }
+        catch (err) {
+            log('findCanSuccessorRunId: fetchHistory failed:', err?.message ?? err);
+            return null;
+        }
     }
     fireTerminal(reason) {
         if (this.terminalFired)
@@ -431,7 +490,7 @@ class BaseAttachment {
      * Called by the heartbeat / phase-watcher ticks instead of `fireTerminal`
      * when the reason is potentially recoverable.
      */
-    fireTerminalOrReconnect(reason) {
+    fireTerminalOrReconnect(reason, canSuccessorRunId) {
         if (this.stopped || this.terminalFired || this.reconnecting)
             return;
         if (!this.shouldReconnect(reason)) {
@@ -449,12 +508,87 @@ class BaseAttachment {
             this.phaseWatcherTimer = null;
         }
         log(`reconnect requested (reason=${reason})`);
+        // #226: CAN takes the short-circuit rebind path (no backoff, no re-claim —
+        // the workflow's §2.3 CAN-boundary lease extension keeps the lease alive
+        // across the transition). Every other recoverable reason goes through the
+        // full #201 budget-bounded re-claim loop.
+        if (reason === 'continued-as-new' && canSuccessorRunId) {
+            void this.runCanRebind(canSuccessorRunId).catch((err) => {
+                log(`CAN rebind crashed:`, err?.message ?? err);
+                this.reconnecting = false;
+                this.fireTerminal('reconnect-exhausted');
+            });
+            return;
+        }
         void this.runReconnectLoop(reason).catch((err) => {
             log(`reconnect loop crashed:`, err?.message ?? err);
             this.reconnecting = false;
             this.fireTerminal('reconnect-exhausted');
         });
     }
+    /**
+     * #226 CAN rebind. Transparently repoints `pinnedHandle` at the successor run,
+     * keeps the existing `attachmentId` / `leaseMs` (the workflow extended the lease
+     * by one heartbeat interval during the CAN transition per §2.3, so the lease is
+     * still live on the new run), notifies the subclass to restart its delivery
+     * loop, and resumes heartbeat + phase-watcher.
+     *
+     * Why this is safe without re-claiming:
+     *  - The new run carries forward `currentAttachment` verbatim from the old run.
+     *  - The adapter's `attachmentId` still matches, so the next `heartbeat` /
+     *    `markDelivered` / `adapterExited` signal on the new pinned handle will be
+     *    accepted unchanged by the workflow's handlers.
+     *  - If the lease actually did expire before we got here (e.g. adapter was
+     *    offline through multiple CAN cycles), the next phase-watcher tick on the
+     *    new pinned handle will see `phase=detached` + no current attachment and
+     *    fall through to the existing #201 reclaim path — belt-and-suspenders.
+     */
+    async runCanRebind(newRunId) {
+        try {
+            if (!this.client || !this.pinnedHandle || !this.token) {
+                log('runCanRebind: missing client/handle/token — firing terminal');
+                this.fireTerminal('reconnect-exhausted');
+                return;
+            }
+            const workflowId = this.pinnedHandle.workflowId;
+            const oldRunId = this.token.runId;
+            try {
+                // Tear down any subclass-owned stream against the stale pinned handle
+                // before repointing, so the subclass doesn't race itself on the rebuild.
+                await this.onReconnectStart('continued-as-new');
+            }
+            catch (err) {
+                log('onReconnectStart threw:', err?.message ?? err);
+            }
+            const newHandle = this.client.workflow.getHandle(workflowId, newRunId);
+            this.pinnedHandle = newHandle;
+            // Keep attachmentId + leaseMs (lease carried across CAN); refresh runId so
+            // diagnostic logging and any token-based debug output reflect the live run.
+            this.token = { ...this.token, runId: newRunId };
+            this.knownPhase = null; // force next phase-watcher tick to re-emit phaseChange
+            this.heartbeatBackoff = 0;
+            this.phaseBackoff = 0;
+            log(`rebound ${workflowId} to CAN successor ` +
+                `(attachmentId=${this.token.attachmentId}, oldRunId=${oldRunId}, newRunId=${newRunId})`);
+            try {
+                await this.onReconnected(newHandle);
+            }
+            catch (err) {
+                log('onReconnected threw:', err?.message ?? err);
+            }
+            // Clear reconnecting BEFORE rescheduling so the first tick after rebind
+            // doesn't short-circuit on its own reconnecting-guard. Mirrors the pattern
+            // in `runReconnectLoop`'s success path (#206).
+            this.reconnecting = false;
+            if (!this.stopped) {
+                this.scheduleHeartbeat();
+                this.schedulePhaseWatcher();
+            }
+        }
+        finally {
+            this.reconnecting = false;
+        }
+    }
     /**
      * Budget-bounded reconnect loop.
      *
@@ -476,119 +610,141 @@ class BaseAttachment {
      * firing terminal) on abort — `stopV2Lifecycle` owns teardown messaging.
      */
     async runReconnectLoop(initialReason) {
-        if (!this.client || !this.host || !this.token || !this.pinnedHandle) {
-            log('runReconnectLoop: missing client/host/token/handle — aborting');
-            this.reconnecting = false;
-            this.fireTerminal('reconnect-exhausted');
-            return;
-        }
-        const workflowId = this.pinnedHandle.workflowId;
-        const oldAttachmentId = this.token.attachmentId;
+        // Single try/finally so `reconnecting` always resets no matter how we exit
+        // — success path, any fireTerminal, abort-during-sleep, or an unexpected
+        // throw. #206 fixed the prior abort-catch path that leaked `reconnecting=true`
+        // if `stopV2Lifecycle` aborted the backoff sleep.
         try {
-            await this.onReconnectStart(initialReason);
-        }
-        catch (err) {
-            log('onReconnectStart threw:', err?.message ?? err);
-        }
-        const deadline = Date.now() + this.reconnectBudgetMs;
-        let backoff = this.reconnectBaseMs;
-        let attempt = 0;
-        while (!this.stopped && Date.now() < deadline) {
-            attempt++;
-            log(`reconnect attempt ${attempt} (sleep ${Math.round(backoff)}ms)`);
-            try {
-                await this.abortableSleep(backoff);
-            }
-            catch {
-                // User-initiated stop during sleep — teardown already owns the rest.
-                log('reconnect aborted by stop during backoff');
+            if (!this.client || !this.host || !this.token || !this.pinnedHandle) {
+                log('runReconnectLoop: missing client/host/token/handle — aborting');
+                this.fireTerminal('reconnect-exhausted');
                 return;
             }
-            if (this.stopped)
-                return;
-            // §Pre-check (architect §1): query attachmentInfo via a fresh unpinned handle.
-            // The old pinned handle's runId may be stale after a continueAsNew.
-            const unpinned = this.client.workflow.getHandle(workflowId);
-            let info;
+            const workflowId = this.pinnedHandle.workflowId;
+            const oldAttachmentId = this.token.attachmentId;
             try {
-                info = await unpinned.query(signals_1.attachmentInfoQuery);
+                await this.onReconnectStart(initialReason);
             }
             catch (err) {
-                if (this.isWorkflowGone(err)) {
-                    log('reconnect: workflow gone during pre-check');
-                    this.reconnecting = false;
-                    this.fireTerminal('destroy');
+                log('onReconnectStart threw:', err?.message ?? err);
+            }
+            const deadline = Date.now() + this.reconnectBudgetMs;
+            let backoff = this.reconnectBaseMs;
+            let attempt = 0;
+            while (!this.stopped && Date.now() < deadline) {
+                attempt++;
+                log(`reconnect attempt ${attempt} (sleep ${Math.round(backoff)}ms)`);
+                try {
+                    await this.abortableSleep(backoff);
+                }
+                catch {
+                    // User-initiated stop during sleep — teardown already owns the rest.
+                    // The finally block still resets `reconnecting` so a subsequent
+                    // reclaim attempt (hypothetical — stop normally ends the adapter) would
+                    // find clean state. #206.
+                    log('reconnect aborted by stop during backoff');
                     return;
                 }
-                backoff = Math.min(backoff * this.reconnectBackoffFactor, this.reconnectMaxMs);
-                log(`reconnect pre-check transient error (next backoff ${Math.round(backoff)}ms):`, err?.message ?? err);
-                continue;
-            }
-            if (info.phase === 'gone') {
-                log('reconnect: phase=gone — giving up');
-                this.reconnecting = false;
-                this.fireTerminal('destroy');
-                return;
-            }
-            if (info.currentAttachment && info.currentAttachment.attachmentId !== oldAttachmentId) {
-                log(`reconnect: another adapter holds the lease (${info.currentAttachment.attachmentId}) — bailing`);
-                this.reconnecting = false;
-                this.fireTerminal('superseded');
-                return;
-            }
-            if (info.phase === 'draining') {
-                // About to reap — give the workflow one more tick to finish collapsing.
-                backoff = Math.min(backoff * this.reconnectBackoffFactor, this.reconnectMaxMs);
-                log(`reconnect: phase=draining, waiting (next backoff ${Math.round(backoff)}ms)`);
-                continue;
-            }
-            // §Claim: attempt a fresh `claimAttachment` (no expectedAttachmentId — our
-            // previous lease is revoked, this is a fresh claim from the workflow's POV).
-            try {
-                const newToken = await unpinned.executeUpdate(signals_1.claimAttachmentUpdate, {
-                    args: [{
-                            host: this.host,
-                            adapterId: this.descriptor.adapterId,
-                            adapterClass: this.descriptor.adapterClass,
-                            leaseMs: 3 * this.descriptor.heartbeatMs,
-                        }],
-                });
-                // Success — rebuild pinned handle from the NEW runId and hand it to the subclass.
-                this.token = newToken;
-                this.pinnedHandle = this.client.workflow.getHandle(workflowId, newToken.runId);
-                this.knownPhase = null; // force the next phase-watcher tick to re-emit phaseChange
-                this.heartbeatBackoff = 0;
-                this.phaseBackoff = 0;
-                log(`reconnected to ${workflowId} after ${attempt} attempt(s) ` +
-                    `(new attachmentId=${newToken.attachmentId}, runId=${newToken.runId})`);
+                if (this.stopped)
+                    return;
+                // §Pre-check (architect §1): query attachmentInfo via a fresh unpinned handle.
+                // The old pinned handle's runId may be stale after a continueAsNew.
+                const unpinned = this.client.workflow.getHandle(workflowId);
+                let info;
                 try {
-                    await this.onReconnected(this.pinnedHandle);
+                    info = await unpinned.query(signals_1.attachmentInfoQuery);
                 }
                 catch (err) {
-                    log('onReconnected threw:', err?.message ?? err);
+                    if (this.isTerminalErr(err)) {
+                        // #226: either terminal kind inside the reconnect loop's pre-check
+                        // ends the loop. We don't recurse into another CAN rebind here —
+                        // that path is only for the pinned-handle tick ticks where we can
+                        // read the closed run's history. Inside the loop the unpinned
+                        // query has already followed any CAN chain, so a gone error means
+                        // the workflow id is truly absent.
+                        log('reconnect: workflow gone during pre-check');
+                        this.fireTerminal('destroy');
+                        return;
+                    }
+                    backoff = Math.min(backoff * this.reconnectBackoffFactor, this.reconnectMaxMs);
+                    log(`reconnect pre-check transient error (next backoff ${Math.round(backoff)}ms):`, err?.message ?? err);
+                    continue;
                 }
-                this.reconnecting = false;
-                if (!this.stopped) {
-                    this.scheduleHeartbeat();
-                    this.schedulePhaseWatcher();
+                if (info.phase === 'gone') {
+                    log('reconnect: phase=gone — giving up');
+                    this.fireTerminal('destroy');
+                    return;
                 }
-                return;
-            }
-            catch (err) {
-                if (this.isWorkflowGone(err)) {
-                    log('reconnect: workflow gone during claim');
+                if (info.currentAttachment && info.currentAttachment.attachmentId !== oldAttachmentId) {
+                    log(`reconnect: another adapter holds the lease (${info.currentAttachment.attachmentId}) — bailing`);
+                    this.fireTerminal('superseded');
+                    return;
+                }
+                if (info.phase === 'draining') {
+                    // About to reap — give the workflow one more tick to finish collapsing.
+                    backoff = Math.min(backoff * this.reconnectBackoffFactor, this.reconnectMaxMs);
+                    log(`reconnect: phase=draining, waiting (next backoff ${Math.round(backoff)}ms)`);
+                    continue;
+                }
+                // §Claim: attempt a fresh `claimAttachment` (no expectedAttachmentId — our
+                // previous lease is revoked, this is a fresh claim from the workflow's POV).
+                try {
+                    const newToken = await unpinned.executeUpdate(signals_1.claimAttachmentUpdate, {
+                        args: [{
+                                host: this.host,
+                                adapterId: this.descriptor.adapterId,
+                                adapterClass: this.descriptor.adapterClass,
+                                leaseMs: 3 * this.descriptor.heartbeatMs,
+                            }],
+                    });
+                    // Success — rebuild pinned handle from the NEW runId and hand it to the subclass.
+                    this.token = newToken;
+                    this.pinnedHandle = this.client.workflow.getHandle(workflowId, newToken.runId);
+                    this.knownPhase = null; // force the next phase-watcher tick to re-emit phaseChange
+                    this.heartbeatBackoff = 0;
+                    this.phaseBackoff = 0;
+                    log(`reconnected to ${workflowId} after ${attempt} attempt(s) ` +
+                        `(new attachmentId=${newToken.attachmentId}, runId=${newToken.runId})`);
+                    try {
+                        await this.onReconnected(this.pinnedHandle);
+                    }
+                    catch (err) {
+                        log('onReconnected threw:', err?.message ?? err);
+                    }
+                    // Clear the reconnecting flag BEFORE rescheduling so the first
+                    // heartbeat/watcher tick after reconnect doesn't short-circuit on
+                    // its own `this.reconnecting` guard. The finally block reasserts
+                    // `reconnecting=false` after return; this early assignment is the
+                    // one that matters for loop wiring.
                     this.reconnecting = false;
-                    this.fireTerminal('destroy');
+                    if (!this.stopped) {
+                        this.scheduleHeartbeat();
+                        this.schedulePhaseWatcher();
+                    }
                     return;
                 }
-                backoff = Math.min(backoff * this.reconnectBackoffFactor, this.reconnectMaxMs);
-                log(`reconnect claim failed (next backoff ${Math.round(backoff)}ms):`, err?.message ?? err);
+                catch (err) {
+                    if (this.isTerminalErr(err)) {
+                        log('reconnect: workflow gone during claim');
+                        this.fireTerminal('destroy');
+                        return;
+                    }
+                    backoff = Math.min(backoff * this.reconnectBackoffFactor, this.reconnectMaxMs);
+                    log(`reconnect claim failed (next backoff ${Math.round(backoff)}ms):`, err?.message ?? err);
+                }
             }
+            // Budget exhausted — give up cleanly.
+            log(`reconnect budget exhausted after ${attempt} attempt(s)`);
+            this.fireTerminal('reconnect-exhausted');
+        }
+        finally {
+            // Guarantee state reset regardless of which path we exited on. Safe to
+            // assign unconditionally — a successful reconnect also ends up here after
+            // the early assignment inside the success path (the early one is needed
+            // so tick reschedulers see `reconnecting=false`; this one is belt-and-
+            // suspenders for the abort/throw/terminal paths).
+            this.reconnecting = false;
         }
-        // Budget exhausted — give up cleanly.
-        log(`reconnect budget exhausted after ${attempt} attempt(s)`);
-        this.reconnecting = false;
-        this.fireTerminal('reconnect-exhausted');
     }
 }
 exports.BaseAttachment = BaseAttachment;

package/dist/adapters/claude-code/adapter.d.ts

@@ -50,6 +50,14 @@ export declare const claudeCodeDescriptor: AdapterDescriptor;
  * can resume. Truly terminal events (`destroy`, `reconnect-exhausted`)
  * still tear the adapter down permanently.
  *
+ * CAN rebind (#226): when the session workflow continues-as-new, the pinned
+ * runId starts returning `WorkflowExecutionAlreadyCompleted`. The base class
+ * reads the closed run's history, extracts the successor runId from the
+ * `WorkflowExecutionContinuedAsNewEvent`, rebinds `pinnedHandle` in place (no
+ * re-claim — the workflow's §2.3 CAN-boundary lease extension keeps the lease
+ * alive across the transition), and calls {@link onReconnected} so we restart
+ * the poller on the live run. Transparent to upstream.
+ *
  * PR-H (#132): the legacy unpinned-poll fallback (gated on
  * `CLAUDE_TEMPO_LIFECYCLE_V2=0`) has been removed. V2 is the only path.
  */
@@ -89,15 +97,21 @@ export declare class InteractiveAttachment extends BaseAttachment {
      */
     private startV2;
     /**
-     * #201: reconnect opt-in. The interactive adapter is stateless wrt in-flight
-     * messages (no processing-signal pairing; `markDelivered` is idempotent), so
-     * both recoverable reasons are safe to replay on a fresh lease:
+     * #201 / #226: reconnect opt-in. The interactive adapter is stateless wrt
+     * in-flight messages (no processing-signal pairing; `markDelivered` is
+     * idempotent), so every recoverable reason is safe to replay on a fresh or
+     * re-bound lease:
      *
-     *   - `heartbeat-timeout`: the workflow reaped our lease (e.g. laptop slept).
-     *     Re-claim and resume — this is the #201 happy path.
-     *   - `superseded`: another adapter currently holds our slot. The reconnect
-     *     loop's pre-check will re-query and bail cleanly if that's still true;
-     *     we enter the loop in case the competitor releases during our backoff.
+     *   - `heartbeat-timeout` (#201): the workflow reaped our lease (e.g. laptop
+     *     slept). Re-claim and resume — full budget-bounded reconnect loop.
+     *   - `superseded` (#201): another adapter currently holds our slot. The
+     *     reconnect loop's pre-check will re-query and bail cleanly if that's
+     *     still true; we enter the loop in case the competitor releases during
+     *     our backoff.
+     *   - `continued-as-new` (#226): the session workflow's CAN transition closed
+     *     our pinned runId while the workflow id kept running on a successor. The
+     *     base class transparently rebinds to the successor runId (no re-claim —
+     *     the lease is carried across CAN per §2.3) and our poller resumes.
      *
      * Unrecoverable reasons (`destroy`, `gone`, anything else) fall through to
      * the default `false`, firing terminal directly.