@usine/agents 0.4.0 → 0.5.0

package/dist/pi/{claude.js → claude/claude.js}

@@ -1,73 +1,18 @@
-import { query as openClaudeQuery, } from "@anthropic-ai/claude-agent-sdk";
+import {} from "@anthropic-ai/claude-agent-sdk";
 import { spawn } from "node:child_process";
 import { ModelId } from "@usine/core/agent/brain";
-import { AgentSessionEvent, ChildSession, HarnessSession, HarnessSessionId, ProviderRecovered, ProviderRetries, ProviderRetrying, SessionStarted, SessionTokensUpdated, TextOutput, ToolFinished, ToolStarted, } from "@usine/core/agent/session";
-import { Context, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, Queue, Ref, Result, Schema, Scope, Stream, } from "effect";
-import { AgentResultError, ClaudeChildBackend, ClaudeLoginLock, ChildBackend, SessionOperationError, UnknownModelError, } from "../runtime.js";
-import { childPidFile, sshArguments } from "../child-host/child-host.js";
-import { sessionChannel } from "./session.js";
-import { sessionConversation } from "./conversation.js";
-import { claudeTokenMeter } from "./usage.js";
-/** The service that opens Claude Code sessions. */
-export class ClaudeSdk extends Context.Service()("@usine/agents/pi/ClaudeSdk") {
-}
-const decodeVendorMessage = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Json));
-const vendorMessageJson = (message) => decodeVendorMessage(JSON.stringify(message));
-export const claudeSdkLive = Layer.succeed(ClaudeSdk)({
-    open: (input, options) => {
-        // SAFETY: ClaudeUserMessage is the streaming-input subset of SDKUserMessage.
-        const query = openClaudeQuery({ prompt: input, options });
-        return {
-            close: () => query.close(),
-            interrupt: async () => {
-                await query.interrupt();
-            },
-            supportedModels: () => query.supportedModels(),
-            async *[Symbol.asyncIterator]() {
-                for await (const message of query)
-                    yield vendorMessageJson(message);
-            },
-        };
-    },
-});
-class AsyncInput {
-    #buffer = [];
-    #waiters = [];
-    #ended = false;
-    offer(message) {
-        if (this.#ended)
-            throw new Error("Claude input is closed");
-        const waiter = this.#waiters.shift();
-        if (waiter === undefined)
-            this.#buffer.push(message);
-        else
-            waiter({ done: false, value: message });
-    }
-    end() {
-        if (this.#ended)
-            return;
-        this.#ended = true;
-        for (const waiter of this.#waiters.splice(0))
-            waiter({ done: true, value: undefined });
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                const value = this.#buffer.shift();
-                if (value !== undefined)
-                    return Promise.resolve({ done: false, value });
-                if (this.#ended)
-                    return Promise.resolve({ done: true, value: undefined });
-                return new Promise((resolve) => this.#waiters.push(resolve));
-            },
-        };
-    }
-}
-const userMessage = (content) => ({
-    type: "user",
-    message: { role: "user", content },
-    parent_tool_use_id: null,
-});
+import { HarnessSession, HarnessSessionId, ProviderRecovered, ProviderRetries, ProviderRetrying, SessionStarted, SessionTokensUpdated, ToolFinished, } from "@usine/core/agent/session";
+import { Deferred, Duration, Effect, Exit, Fiber, Layer, Option, Queue, Ref, Result, Schema, Scope, Stream, } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+import { AgentResultError, ClaudeChildBackend, ClaudeLoginLock, ChildBackend, SessionOperationError, UnknownModelError, } from "../../runtime.js";
+import { CHILD_STOP_SCRIPT, childPidFile, SSH_FAILURE, sshArguments, } from "../../child-host/child-host.js";
+import { hostOutput } from "../../child-host/command.js";
+import { sessionChannel } from "../session.js";
+import { sessionConversation } from "../conversation.js";
+import { claudeSessionMeter, claudeTokenMeter } from "../usage.js";
+import { apiRetryMessage, ClaudeApiRetry, ClaudeCompletionHeader, ClaudeResultMessage, decodeApiRetry, decodeClaudeInit, decodeCompletionUpdate, isAssistantMessage, loginCheck, sessionEventsFrom, } from "./codec.js";
+import { AsyncInput, ClaudeSdk, userMessage, } from "./sdk.js";
+export { ClaudeSdk, claudeSdkLive, } from "./sdk.js";
 const operationError = (operation, request, message, cause) => new SessionOperationError({
     operation,
     sessionId: Option.some(request.session.id),
@@ -77,9 +22,9 @@ const operationError = (operation, request, message, cause) => new SessionOperat
 /**
  * Returns a spawner that runs Claude Code on the remote host as one SSH command, with the SDK's
  * command, arguments, working directory, and environment in the remote command line. The abort
- * signal stops the SSH client.
+ * signal stops the SSH client; `onExit` gets its exit code, or `null` if a signal stopped it.
  */
-const sshSpawner = (host, pidFile, onStderr) => (options) => {
+const sshSpawner = (host, pidFile, onStderr, onExit) => (options) => {
     const child = spawn(host.ssh.command, sshArguments(host, {
         cwd: options.cwd,
         environment: options.env,
@@ -93,9 +38,11 @@ const sshSpawner = (host, pidFile, onStderr) => (options) => {
         windowsHide: true,
     });
     child.stderr.setEncoding("utf8").on("data", onStderr);
+    child.once("exit", (code) => onExit(code));
     return child;
 };
-const optionsFor = (request, onStderr) => {
+/** Returns the options of every launch for `request`; each launch adds its remote spawner. */
+const optionsFor = (request) => {
     const effort = request.session.brain.effort;
     const shared = {
         allowDangerouslySkipPermissions: true,
@@ -110,10 +57,6 @@ const optionsFor = (request, onStderr) => {
         // The worktree is untrusted, so its project and local settings (hooks, env) are not loaded into
         // a child that has the App credential; only the Worker user's settings apply.
         settingSources: ["user"],
-        // On a local host, the SDK spawns the process itself.
-        ...(request.host._tag === "RemoteShell" && {
-            spawnClaudeCodeProcess: sshSpawner(request.host, childPidFile(request.cwd, request.session.id), onStderr),
-        }),
     };
     return effort === "off"
         ? { ...shared, thinking: { type: "disabled" } }
@@ -124,81 +67,6 @@ const optionsFor = (request, onStderr) => {
         };
 };
 const modelExists = (models, model) => models.some((candidate) => candidate.value === model || candidate.resolvedModel === model);
-const decodeClaudeInit = Schema.decodeUnknownOption(Schema.Struct({
-    type: Schema.Literal("system"),
-    subtype: Schema.Literal("init"),
-    session_id: HarnessSessionId,
-}));
-const ClaudeTextBlock = Schema.Struct({
-    type: Schema.Literal("text"),
-    text: Schema.NonEmptyString,
-});
-const ClaudeContentMessage = Schema.Struct({
-    type: Schema.Literals(["assistant", "user"]),
-    message: Schema.Struct({ content: Schema.Array(Schema.Json) }),
-});
-const ClaudeToolUseBlock = Schema.Struct({
-    type: Schema.Literal("tool_use"),
-    id: Schema.NonEmptyString,
-    name: Schema.NonEmptyString,
-    input: Schema.Json,
-});
-const ClaudeToolResultBlock = Schema.Struct({
-    type: Schema.Literal("tool_result"),
-    tool_use_id: Schema.NonEmptyString,
-    content: Schema.Json,
-    is_error: Schema.optionalKey(Schema.Boolean),
-});
-const ClaudeResultMessage = Schema.Struct({
-    type: Schema.Literal("result"),
-    subtype: Schema.String,
-    result: Schema.optionalKey(Schema.String),
-    errors: Schema.optionalKey(Schema.Array(Schema.String)),
-    queued_turn_count: Schema.optionalKey(Schema.Number),
-});
-const ClaudeBackgroundTasks = Schema.Struct({
-    type: Schema.Literal("system"),
-    subtype: Schema.Literal("background_tasks_changed"),
-    tasks: Schema.Array(Schema.Struct({
-        task_id: Schema.NonEmptyString,
-        ambient: Schema.optionalKey(Schema.Boolean),
-    })),
-});
-const ClaudeSessionState = Schema.Struct({
-    type: Schema.Literal("system"),
-    subtype: Schema.Literal("session_state_changed"),
-    state: Schema.Literals(["idle", "running", "requires_action"]),
-});
-const ClaudeCompletionHeader = Schema.Struct({
-    type: Schema.Literal("system"),
-    subtype: Schema.Literals(["background_tasks_changed", "session_state_changed"]),
-});
-const decodeCompletionUpdate = Schema.decodeUnknownEffect(Schema.Union([ClaudeBackgroundTasks, ClaudeSessionState]));
-/** Claude Code's report of a failed API request that it retries; a `null` status means no response was received. */
-const ClaudeApiRetry = Schema.Struct({
-    type: Schema.Literal("system"),
-    subtype: Schema.Literal("api_retry"),
-    attempt: Schema.Number,
-    max_retries: Schema.Number,
-    retry_delay_ms: Schema.Number,
-    error_status: Schema.NullOr(Schema.Number),
-    error: Schema.String,
-});
-const decodeApiRetry = Schema.decodeUnknownOption(ClaudeApiRetry);
-const isAssistantMessage = Schema.is(Schema.Struct({ type: Schema.Literal("assistant") }));
-/** Returns an API retry's fields as one sentence, because Claude Code includes no message. */
-const apiRetryMessage = (retry) => {
-    const failure = retry.error_status === null ? "without a response" : `with HTTP ${retry.error_status}`;
-    const delay = retry.retry_delay_ms < 1_000
-        ? `${retry.retry_delay_ms}ms`
-        : `${Math.round(retry.retry_delay_ms / 1_000)}s`;
-    return `API request failed ${failure} (${retry.error}); retry ${retry.attempt} of ${retry.max_retries} in ${delay}`;
-};
-/**
- * The text Claude Code ends a turn with if another Claude process has the login refresh lock, or
- * exited while it had the lock.
- */
-const LOGIN_CONTENDED = "Failed to refresh OAuth token: another Claude Code process";
 /**
  * The delays before each relaunch after a Claude process loses the login refresh lock; Claude's
  * error says to retry in a minute. If the last launch fails the same way, the parent gets the error
@@ -210,91 +78,76 @@ const LOGIN_RETRY_DELAYS = [
     Duration.seconds(60),
 ];
 /**
- * The maximum time a launch keeps the Worker's Claude login lock while waiting for a message that
- * decides the login state. If no such message arrives, the launch continues as a started session.
+ * The maximum time a launch keeps its Claude login lock while waiting for a message that decides
+ * the login state. If no such message arrives, the launch continues as a started session.
  */
 const LOGIN_WINDOW = Duration.seconds(60);
-/** Messages that arrive only after an API request was sent with a working login. */
-const ClaudeLoginEvidence = Schema.Union([
-    Schema.Struct({ type: Schema.Literals(["rate_limit_event", "stream_event"]) }),
-    Schema.Struct({
-        type: Schema.Literal("system"),
-        subtype: Schema.Literals(["api_retry", "thinking_tokens"]),
-    }),
-]);
-const mentionsLoginContention = (text) => text.includes(LOGIN_CONTENDED);
 /**
- * Returns the login state shown by one of a launch's first messages. `init` and other session
- * notices can arrive before the first API request, where Claude refreshes an expired login, so they
- * return `waiting`. A model answer, rate-limit or thinking update, API retry, or result returns
- * `loggedIn`, except a result with the refresh lock error and no tokens used, which returns
- * `contended`. The synthetic answer with the same error returns `waiting` until that result.
+ * The delays before each try to resume a remote child whose SSH connection broke, such as when the
+ * orchestrator's machine slept. A message from Claude resets the count. When the delays run out,
+ * the child fails with the broken connection's error (#603).
  */
-const loginCheck = (message, spentTokens) => {
-    if (Schema.is(ClaudeResultMessage)(message)) {
-        const reported = [
-            ...(message.result === undefined ? [] : [message.result]),
-            ...(message.errors ?? []),
-        ];
-        return !spentTokens && reported.some(mentionsLoginContention) ? "contended" : "loggedIn";
-    }
-    if (Schema.is(ClaudeContentMessage)(message) && message.type === "assistant") {
-        const contended = message.message.content.some((block) => Schema.is(ClaudeTextBlock)(block) && mentionsLoginContention(block.text));
-        return contended && !spentTokens ? "waiting" : "loggedIn";
-    }
-    return Schema.is(ClaudeLoginEvidence)(message) ? "loggedIn" : "waiting";
-};
-const sessionEventsFrom = (message, session, tools) => {
-    if (!Schema.is(ClaudeContentMessage)(message))
-        return [];
-    const events = [];
-    for (const block of message.message.content) {
-        // Emits only text blocks of completed assistant messages; streaming deltas are not recorded.
-        if (message.type === "assistant" && Schema.is(ClaudeTextBlock)(block)) {
-            events.push(new TextOutput({ session, text: block.text }));
-        }
-        else if (Schema.is(ClaudeToolUseBlock)(block)) {
-            tools.set(block.id, block.name);
-            events.push(new ToolStarted({
-                session,
-                callId: block.id,
-                tool: block.name,
-                input: block.input,
-            }));
-        }
-        else if (Schema.is(ClaudeToolResultBlock)(block)) {
-            events.push(new ToolFinished({
-                session,
-                callId: block.tool_use_id,
-                tool: tools.get(block.tool_use_id) ?? "unknown",
-                output: block.content,
-                isError: block.is_error === true,
-            }));
-        }
-    }
-    return events;
-};
+const RESUME_DELAYS = [
+    Duration.seconds(5),
+    Duration.seconds(15),
+    Duration.seconds(30),
+    Duration.minutes(1),
+    Duration.minutes(2),
+    Duration.minutes(5),
+];
+/** The time a broken launch waits for its SSH client's exit code before it gives up resuming. */
+const SSH_EXIT_WAIT = Duration.seconds(5);
+/** The time limit for stopping a broken launch's Claude process on the Worker. */
+const STOP_TIMEOUT = Duration.seconds(30);
+/** The message that starts the next turn of a resumed child that was working. */
+const RESUME_PROMPT = "usine lost its connection to this session and resumed it. Your last step may not have finished: check the worktree and any command you started before you go on. Then continue the task and end with your final answer. If the task is done, give your final answer again.";
 const makeClaudeChild = Effect.gen(function* () {
     const sdk = yield* ClaudeSdk;
     const logins = yield* ClaudeLoginLock;
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    /**
+     * Stops the Claude process of `request` on the remote `host` through its PID file, so that a
+     * resumed launch is the only process in the session. Fails with `SessionOperationError` if the
+     * Worker can't be reached or the stop fails.
+     */
+    const stopRemote = Effect.fn("ClaudeChildBackend.stopRemote")(function* (request, host) {
+        yield* Effect.annotateCurrentSpan({ sessionId: request.session.id, worker: request.worker });
+        const failed = (message, cause) => operationError("launch", request, message, cause);
+        const { stdout, exitCode } = yield* hostOutput(host, {
+            environment: {},
+            command: "sh",
+            args: ["-c", CHILD_STOP_SCRIPT, "sh", childPidFile(request.cwd, request.session.id)],
+        }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.timeout(STOP_TIMEOUT), Effect.mapError((cause) => failed(`Can't stop the Claude child on ${host.destination}`, cause)));
+        if (exitCode !== 0)
+            return yield* failed(exitCode === SSH_FAILURE
+                ? `Can't reach ${host.destination} to stop the Claude child`
+                : `Stopping the Claude child on ${host.destination} exited with code ${exitCode}`, new Error(`exit code ${exitCode}`));
+        yield* Effect.logInfo("Stopped what was left of the Claude child on its Worker", {
+            sessionId: request.session.id,
+            worker: request.worker,
+            outcome: stdout,
+        });
+    });
     /**
-     * Acquires the request Worker's login lock in a fiber of the current scope and returns an effect
+     * Acquires the request's Claude login lock in a fiber of the current scope and returns an effect
      * that releases it. The lock is also released after `LOGIN_WINDOW`, so a hung launch does not
-     * block other Claude launches and preflights on the Worker.
+     * block other Claude launches and preflights on that login.
      */
     const holdLogin = Effect.fn("ClaudeChildBackend.holdLogin")(function* (request) {
-        yield* Effect.annotateCurrentSpan({ sessionId: request.session.id, worker: request.worker });
+        const fields = {
+            sessionId: request.session.id,
+            worker: request.worker,
+            ...Option.match(request.machine, { onNone: () => ({}), onSome: (machine) => ({ machine }) }),
+        };
+        yield* Effect.annotateCurrentSpan(fields);
         const held = yield* Deferred.make();
         const released = yield* Deferred.make();
-        yield* Effect.forkScoped(logins.withLock(request.worker)(Deferred.succeed(held, undefined).pipe(Effect.andThen(Deferred.await(released)), Effect.timeoutOption(LOGIN_WINDOW), Effect.flatMap(Option.match({
+        yield* Effect.forkScoped(logins.withLock(request.worker, request.machine)(Deferred.succeed(held, undefined).pipe(Effect.andThen(Deferred.await(released)), Effect.timeoutOption(LOGIN_WINDOW), Effect.flatMap(Option.match({
             onSome: () => Effect.void,
-            onNone: () => Effect.logWarning("Claude child showed no sign of its login in time; releasing the Worker's Claude login lock", { sessionId: request.session.id, worker: request.worker }),
+            onNone: () => Effect.logWarning("Claude child showed no sign of its login in time; releasing its Claude login lock", fields),
         })))));
         yield* Deferred.await(held);
-        yield* Effect.logDebug("Holding the Worker's Claude login lock to launch the child", {
-            sessionId: request.session.id,
-            worker: request.worker,
-        });
+        yield* Effect.logDebug("Holding the Claude login lock to launch the child", fields);
         return Deferred.succeed(released, undefined).pipe(Effect.asVoid);
     });
     /** Reads messages from `output` into `read` until one decides the login state. */
@@ -314,15 +167,31 @@ const makeClaudeChild = Effect.gen(function* () {
         }
     });
     /**
-     * Launches Claude Code once for `request` and sends the task, keeping the Worker's login lock until
-     * the first messages decide the login state. Resources are added to the current scope.
+     * Launches Claude Code once for `request` and sends `messages`, keeping its Claude login lock
+     * until the first messages decide the login state. With no messages, the launch waits for input
+     * and skips the login check. Resources are added to the current scope.
      */
-    const launchOnce = Effect.fn("ClaudeChildBackend.launchOnce")(function* (request, options) {
+    const launchOnce = Effect.fn("ClaudeChildBackend.launchOnce")(function* (request, options, messages) {
         yield* Effect.annotateCurrentSpan({ sessionId: request.session.id, worker: request.worker });
+        const context = yield* Effect.context();
         const release = yield* holdLogin(request);
         return yield* Effect.gen(function* () {
             const input = new AsyncInput();
-            const query = sdk.open(input, options);
+            const sshExit = yield* Deferred.make();
+            const query = sdk.open(input, request.host._tag === "RemoteShell"
+                ? {
+                    ...options,
+                    spawnClaudeCodeProcess: sshSpawner(request.host, childPidFile(request.cwd, request.session.id), (text) => {
+                        Effect.runForkWith(context)(Effect.logDebug("Claude child stderr", {
+                            sessionId: request.session.id,
+                            text: text.trimEnd(),
+                        }));
+                    }, (code) => {
+                        Deferred.doneUnsafe(sshExit, Exit.succeed(code));
+                    }),
+                }
+                : // On a local host, the SDK spawns the process itself.
+                    options);
             const output = yield* Queue.make();
             yield* Effect.forkScoped(Stream.fromAsyncIterable(query, (cause) => operationError("stream", request, "Claude output stream failed", cause)).pipe(Stream.runIntoQueue(output)));
             // Finalizers run newest first, so this closes the query before the scope stops the output
@@ -344,39 +213,50 @@ const makeClaudeChild = Effect.gen(function* () {
                     message: `Claude has no model "${request.session.brain.model}"`,
                 });
             }
-            input.offer(userMessage(request.prompt));
+            for (const message of messages)
+                input.offer(userMessage(message));
             const read = [];
-            const login = Option.getOrElse(yield* checkLogin(output, read).pipe(Effect.timeoutOption(LOGIN_WINDOW)), () => "undecided");
+            const login = messages.length === 0
+                ? "undecided"
+                : Option.getOrElse(yield* checkLogin(output, read).pipe(Effect.timeoutOption(LOGIN_WINDOW)), () => "undecided");
             yield* Effect.logDebug("Claude child's first messages settled its login check", {
                 sessionId: request.session.id,
                 worker: request.worker,
                 login,
                 messages: read.length,
             });
-            return { input, query, read, output, login };
+            const lostConnection = request.host._tag === "RemoteShell"
+                ? Deferred.await(sshExit).pipe(Effect.timeoutOption(SSH_EXIT_WAIT), Effect.map((code) => Option.contains(code, SSH_FAILURE)))
+                : Effect.succeed(false);
+            return { input, query, read, output, login, lostConnection };
         }).pipe(Effect.ensuring(release));
     });
     /**
      * Launches Claude Code for `request`, relaunching after each delay in `LOGIN_RETRY_DELAYS` while it
      * fails on the login refresh lock. Each launch has its own scope inside `scope`, closed before the
-     * next, so a failed launch's process and messages do not reach the session.
+     * next or when the launch fails, so a failed launch's process and messages do not reach the
+     * session. Returns the launch with its scope.
      */
-    const launchWithRetries = Effect.fn("ClaudeChildBackend.launchWithRetries")(function* (request, options, scope) {
+    const launchWithRetries = Effect.fn("ClaudeChildBackend.launchWithRetries")(function* (request, options, messages, scope) {
         yield* Effect.annotateCurrentSpan({ sessionId: request.session.id, worker: request.worker });
         for (let retry = 0;; retry += 1) {
             const launchScope = yield* Scope.fork(scope);
-            const opened = yield* launchOnce(request, options).pipe(Scope.provide(launchScope));
+            const opened = {
+                ...(yield* launchOnce(request, options, messages).pipe(Scope.provide(launchScope), Effect.onError((cause) => Scope.close(launchScope, Exit.failCause(cause))))),
+                scope: launchScope,
+            };
             if (opened.login !== "contended") {
                 if (opened.login === "undecided")
                     yield* Effect.logInfo("Claude child started without showing whether its login worked", {
                         sessionId: request.session.id,
                         worker: request.worker,
+                        messages: messages.length,
                     });
                 return opened;
             }
             const delay = LOGIN_RETRY_DELAYS[retry];
             if (delay === undefined) {
-                yield* Effect.logWarning("Claude child still could not refresh the Worker's Claude login; returning the error to the parent", {
+                yield* Effect.logWarning("Claude child still could not refresh its Claude login; returning the error to the parent", {
                     sessionId: request.session.id,
                     parentSessionId: request.session.parentId,
                     worker: request.worker,
@@ -385,7 +265,7 @@ const makeClaudeChild = Effect.gen(function* () {
                 return opened;
             }
             yield* Scope.close(launchScope, Exit.void);
-            yield* Effect.logInfo("Claude child could not refresh the Worker's Claude login; launching it again", {
+            yield* Effect.logInfo("Claude child could not refresh its Claude login; launching it again", {
                 sessionId: request.session.id,
                 parentSessionId: request.session.parentId,
                 worker: request.worker,
@@ -414,31 +294,28 @@ const makeClaudeChild = Effect.gen(function* () {
             await Effect.runPromiseWith(context)(Effect.acquireUseRelease(Effect.forkIn(Effect.suspend(() => boundary), scope), Fiber.join, Fiber.interrupt), { signal: options.signal });
             return {};
         };
-        const { input, query, read, output } = yield* launchWithRetries(request, {
-            ...optionsFor(request, (text) => {
-                Effect.runForkWith(context)(Effect.logDebug("Claude child stderr", {
-                    sessionId: request.session.id,
-                    text: text.trimEnd(),
-                }));
-            }),
+        const options = {
+            ...optionsFor(request),
             hooks: {
                 PreToolUse: [{ hooks: [pauseAtBoundary], timeout: 86_400 }],
                 PostToolUse: [{ hooks: [pauseAtBoundary], timeout: 86_400 }],
             },
-        }, scope);
+        };
+        // The launch that runs the session; a resume replaces it.
+        let current = yield* launchWithRetries(request, options, [request.prompt], scope);
         const channel = yield* sessionChannel({
             label: "Claude child session",
             sessionId: request.session.id,
         });
         channel.onTerminal(() => {
-            input.end();
+            current.input.end();
         });
         const conversation = yield* sessionConversation({
             session: request.session,
             channel,
             // A message sent during a turn is queued until a tool call returns or the turn ends.
             send: (message, activity) => Effect.try({
-                try: () => input.offer(userMessage(message)),
+                try: () => current.input.offer(userMessage(message)),
                 catch: (cause) => operationError("steer", request, "Can't send a message to Claude", cause),
             }).pipe(Effect.as(activity === "idle" ? "read" : "queued")),
             pause: Effect.void,
@@ -446,7 +323,11 @@ const makeClaudeChild = Effect.gen(function* () {
         });
         boundary = conversation.awaitUnpaused;
         const tools = new Map();
-        const tokens = claudeTokenMeter();
+        const usage = claudeSessionMeter();
+        // The latest session ID from Claude, which a resume loads.
+        let harnessSessionId = Option.none();
+        // Resumes since Claude last sent a message.
+        let resumes = 0;
         let backgroundTasks = [];
         let reportsSessionState = false;
         let completedTurn = Option.none();
@@ -485,7 +366,8 @@ const makeClaudeChild = Effect.gen(function* () {
                 retries: ProviderRetries.make(retries),
             }));
         });
-        const consume = Stream.concat(Stream.fromIterable(read), Stream.fromQueue(output)).pipe(Stream.runForEach((message) => Effect.gen(function* () {
+        /** Applies one message from Claude to the session. */
+        const handle = (message) => Effect.gen(function* () {
             const retry = decodeApiRetry(message);
             if (Option.isSome(retry))
                 return yield* reportRetry(retry.value);
@@ -524,6 +406,8 @@ const makeClaudeChild = Effect.gen(function* () {
                 return;
             }
             const init = decodeClaudeInit(message);
+            if (Option.isSome(init))
+                harnessSessionId = Option.some(init.value.session_id);
             if (Option.isSome(init) && !(yield* Ref.getAndSet(launched, true))) {
                 const harnessSession = new HarnessSession({
                     id: init.value.session_id,
@@ -540,9 +424,9 @@ const makeClaudeChild = Effect.gen(function* () {
                     cwd: harnessSession.cwd,
                 });
             }
-            const usage = tokens(message);
-            if (Option.isSome(usage))
-                yield* channel.emit(new SessionTokensUpdated({ session: request.session, ...usage.value }));
+            const used = usage.read(message);
+            if (Option.isSome(used))
+                yield* channel.emit(new SessionTokensUpdated({ session: request.session, ...used.value }));
             for (const event of sessionEventsFrom(message, request.session, tools)) {
                 yield* channel.emit(event);
             }
@@ -584,22 +468,130 @@ const makeClaudeChild = Effect.gen(function* () {
                 // Older Claude Code versions on Workers do not send session-state messages.
                 yield* conversation.finish(answer);
             }
-        })), Effect.flatMap(() => channel.isTerminal.pipe(Effect.flatMap((done) => done
-            ? Effect.void
-            : channel.fail(operationError("stream", request, "Claude output closed without a result", new Error("unexpected end of output")))))), Effect.catch((error) => channel.fail(error)));
+        });
+        /**
+         * Applies `launch`'s messages until its output ends. Returns the error that broke the output,
+         * or `None` if the output closed.
+         */
+        const drain = (launch) => Effect.gen(function* () {
+            let broken = Option.none();
+            yield* Stream.concat(Stream.fromIterable(launch.read), Stream.fromQueue(launch.output)).pipe(Stream.map((message) => Result.succeed(message)), Stream.catch((error) => Stream.make(Result.fail(error))), Stream.runForEach(Result.match({
+                onSuccess: (message) => Effect.suspend(() => {
+                    resumes = 0;
+                    return handle(message);
+                }),
+                onFailure: (error) => Effect.sync(() => {
+                    broken = Option.some(error);
+                }),
+            })));
+            return broken;
+        });
+        /**
+         * Resumes the session in a new launch after `broken` lost its SSH connection to the Worker:
+         * stops what is left of its Claude process there, then launches Claude with the saved session,
+         * retrying after each delay in `RESUME_DELAYS`. Returns `None` if the session can't be resumed.
+         */
+        const resume = Effect.fn("ClaudeChildBackend.resume")(function* (broken, error) {
+            yield* Effect.annotateCurrentSpan({
+                sessionId: request.session.id,
+                worker: request.worker,
+            });
+            const fields = {
+                sessionId: request.session.id,
+                parentSessionId: request.session.parentId,
+                worker: request.worker,
+            };
+            const notResumed = (reason) => Effect.logInfo("Not resuming the Claude child after its output ended", {
+                ...fields,
+                reason,
+                message: error.message,
+            }).pipe(Effect.as(Option.none()));
+            const host = request.host;
+            const harnessSession = harnessSessionId;
+            if (host._tag !== "RemoteShell")
+                return yield* notResumed("it runs on this machine");
+            if (Option.isNone(harnessSession))
+                return yield* notResumed("Claude saved no session");
+            if (!(yield* broken.lostConnection))
+                return yield* notResumed("its SSH connection didn't break");
+            yield* Effect.logWarning("Claude child lost its SSH connection to the Worker; resuming its session", { ...fields, harnessSessionId: harnessSession.value, message: error.message });
+            yield* Scope.close(broken.scope, Exit.void);
+            // The broken launch's process took its background work and open tool calls with it.
+            backgroundTasks = [];
+            completedTurn = Option.none();
+            for (const [callId, tool] of tools)
+                yield* channel.emit(new ToolFinished({
+                    session: request.session,
+                    callId,
+                    tool,
+                    output: "usine lost its connection to the Worker before this call returned",
+                    isError: true,
+                }));
+            tools.clear();
+            usage.restart();
+            for (;;) {
+                const delay = RESUME_DELAYS[resumes];
+                if (delay === undefined) {
+                    yield* Effect.logWarning("Could not resume the Claude child; it fails", {
+                        ...fields,
+                        tries: resumes,
+                    });
+                    return Option.none();
+                }
+                resumes += 1;
+                yield* Effect.logInfo("Resuming the Claude child after a pause", {
+                    ...fields,
+                    try: resumes,
+                    maxTries: RESUME_DELAYS.length,
+                    delay: Duration.format(delay),
+                });
+                yield* Effect.sleep(delay);
+                if (yield* channel.isTerminal)
+                    return Option.none();
+                // A paused or idle child waits for the operator, so only a working child gets a turn.
+                const working = !((yield* conversation.isPaused) || (yield* conversation.isIdle));
+                const messages = [...(working ? [RESUME_PROMPT] : []), ...(yield* conversation.unread)];
+                const resumed = yield* stopRemote(request, host).pipe(Effect.andThen(launchWithRetries(request, { ...options, resume: harnessSession.value }, messages, scope)), Effect.map(Option.some), Effect.catchTag("SessionOperationError", (failure) => Effect.logWarning("Could not resume the Claude child yet", {
+                    ...fields,
+                    try: resumes,
+                    message: failure.message,
+                }).pipe(Effect.as(Option.none()))));
+                if (Option.isSome(resumed)) {
+                    yield* Effect.logInfo("Resumed the Claude child's session", {
+                        ...fields,
+                        harnessSessionId: harnessSession.value,
+                        working,
+                        messages: messages.length,
+                    });
+                    return resumed;
+                }
+            }
+        });
+        const consume = Effect.gen(function* () {
+            for (;;) {
+                const broken = yield* drain(current);
+                if (yield* channel.isTerminal)
+                    return;
+                const error = Option.getOrElse(broken, () => operationError("stream", request, "Claude output closed without a result", new Error("unexpected end of output")));
+                const resumed = yield* resume(current, error);
+                if (Option.isNone(resumed))
+                    return yield* channel.fail(error);
+                current = resumed.value;
+            }
+        }).pipe(Effect.catch((error) => channel.fail(error)));
         yield* Effect.forkScoped(consume);
         const steer = Effect.fn("ClaudeChildBackend.steer")((message) => Effect.logDebug("Steering Claude child session", {
             sessionId: request.session.id,
         }).pipe(Effect.andThen(Effect.try({
-            try: () => input.offer(userMessage(message)),
+            try: () => current.input.offer(userMessage(message)),
             catch: (cause) => operationError("steer", request, "Can't steer Claude", cause),
         }))));
         const interrupt = Effect.logInfo("Interrupting Claude child session", {
             sessionId: request.session.id,
         }).pipe(Effect.andThen(Effect.tryPromise({
-            try: () => query.interrupt(),
+            try: () => current.query.interrupt(),
             catch: (cause) => operationError("interrupt", request, "Can't interrupt Claude", cause),
-        })), Effect.tap(() => Effect.sync(() => input.end())), Effect.asVoid);
+        })), Effect.tap(() => Effect.sync(() => current.input.end())), Effect.asVoid);
         return {
             session: request.session,
             events: Stream.fromQueue(channel.events),