Preserve Claude sessions and roll back failed updates

- Enable Claude session persistence and surface transcript persistence warnings
- Restore the previous Claude executable when an update or verification fails
- Update workspace dependency metadata and lockfile

Author: badcuban

apps/server/src/provider/Drivers/ClaudeDriver.ts

@@ -166,15 +166,40 @@ try {
 
     $installDir = Split-Path -Parent $installPath
     New-Item -ItemType Directory -Force -Path $installDir | Out-Null
-    Move-Item -LiteralPath $downloadPath -Destination $installPath -Force
-
-    $installedVersion = & $installPath --version
-    if ($LASTEXITCODE -ne 0 -or $installedVersion -notmatch [regex]::Escape($version)) {
-        Write-Error "Claude Code was replaced, but version verification failed: $installedVersion"
-        exit 1
+    $backupPath = Join-Path $downloadDir "claude-backup-$PID-$([guid]::NewGuid().ToString('N')).exe"
+    $preservedExistingExecutable = Test-Path -LiteralPath $installPath
+    if ($preservedExistingExecutable) {
+        Copy-Item -LiteralPath $installPath -Destination $backupPath -Force
     }
 
-    Write-Output "Installed Claude Code $installedVersion at $installPath"
+    try {
+        Move-Item -LiteralPath $downloadPath -Destination $installPath -Force
+
+        $installedVersion = & $installPath --version
+        if ($LASTEXITCODE -ne 0 -or $installedVersion -notmatch [regex]::Escape($version)) {
+            throw "Claude Code was replaced, but version verification failed: $installedVersion"
+        }
+
+        if (Test-Path -LiteralPath $backupPath) {
+            Remove-Item -LiteralPath $backupPath -Force -ErrorAction SilentlyContinue
+        }
+        Write-Output "Installed Claude Code $installedVersion at $installPath"
+    } catch {
+        $updateFailure = $_
+        if ($preservedExistingExecutable -and (Test-Path -LiteralPath $backupPath)) {
+            try {
+                Copy-Item -LiteralPath $backupPath -Destination $installPath -Force
+                Remove-Item -LiteralPath $backupPath -Force -ErrorAction SilentlyContinue
+                Write-Warning "Claude update failed; restored the previous executable at $installPath."
+            } catch {
+                Write-Error "Claude update failed and Threadlines could not restore the previous executable. The backup remains at $backupPath."
+                throw
+            }
+        } elseif (Test-Path -LiteralPath $installPath) {
+            Remove-Item -LiteralPath $installPath -Force -ErrorAction SilentlyContinue
+        }
+        throw $updateFailure
+    }
 } finally {
     if (Test-Path -LiteralPath $downloadPath) {
         Remove-Item -LiteralPath $downloadPath -Force

apps/server/src/provider/Layers/ClaudeAdapter.test.ts

@@ -549,6 +549,7 @@ describe("ClaudeAdapterLive", () => {
       assert.deepEqual(createInput?.options.settingSources, ["user", "project", "local"]);
       assert.equal(createInput?.options.enableFileCheckpointing, true);
       assert.equal(createInput?.options.promptSuggestions, true);
+      assert.equal(createInput?.options.persistSession, true);
       assert.equal(createInput?.options.permissionMode, undefined);
       assert.equal(createInput?.options.allowDangerouslySkipPermissions, undefined);
     }).pipe(
@@ -4681,6 +4682,90 @@ describe("ClaudeAdapterLive", () => {
     );
   });
 
+  it.effect("warns once when the inherited environment disables session persistence", () => {
+    const harness = makeHarness({
+      environment: {
+        ...missingClaudeConfigEnvironment(),
+        CLAUDE_CODE_SKIP_PROMPT_HISTORY: "1",
+      },
+    });
+    return Effect.gen(function* () {
+      const adapter = yield* ClaudeAdapter;
+
+      const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 5).pipe(
+        Stream.runCollect,
+        Effect.forkChild,
+      );
+
+      yield* adapter.startSession({
+        threadId: THREAD_ID,
+        provider: ProviderDriverKind.make("claudeAgent"),
+        runtimeMode: "full-access",
+      });
+
+      harness.query.emit({
+        type: "system",
+        subtype: "informational",
+        content:
+          "CLAUDE_CODE_SKIP_PROMPT_HISTORY is set --resume will not find this session; if unintended, unset it and restart",
+        level: "warning",
+        session_id: "sdk-session-persistence-disabled",
+        uuid: "persistence-disabled-1",
+      } as unknown as SDKMessage);
+      harness.query.finish();
+
+      const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
+      const warnings = runtimeEvents.filter((event) => event.type === "runtime.warning");
+      assert.equal(warnings.length, 1);
+      assert.include(warnings[0]?.payload.message ?? "", "CLAUDE_CODE_SKIP_PROMPT_HISTORY");
+      assert.equal(warnings[0]?.payload.warningKind, "session-persistence");
+    }).pipe(
+      Effect.provideService(Random.Random, makeDeterministicRandomService()),
+      Effect.provide(harness.layer),
+    );
+  });
+
+  it.effect("surfaces Claude transcript-write informational warnings", () => {
+    const harness = makeHarness();
+    return Effect.gen(function* () {
+      const adapter = yield* ClaudeAdapter;
+
+      const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 5).pipe(
+        Stream.runCollect,
+        Effect.forkChild,
+      );
+
+      yield* adapter.startSession({
+        threadId: THREAD_ID,
+        provider: ProviderDriverKind.make("claudeAgent"),
+        runtimeMode: "full-access",
+      });
+
+      harness.query.emit({
+        type: "system",
+        subtype: "informational",
+        content:
+          "Transcript writes are failing (disk full); recent messages may not be saved for resume",
+        level: "warning",
+        session_id: "sdk-session-transcript-write-failed",
+        uuid: "transcript-write-failed-1",
+      } as unknown as SDKMessage);
+      harness.query.finish();
+
+      const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
+      const warnings = runtimeEvents.filter((event) => event.type === "runtime.warning");
+      assert.equal(warnings.length, 1);
+      assert.equal(
+        warnings[0]?.payload.message,
+        "Transcript writes are failing (disk full); recent messages may not be saved for resume",
+      );
+      assert.equal(warnings[0]?.payload.warningKind, "session-persistence");
+    }).pipe(
+      Effect.provideService(Random.Random, makeDeterministicRandomService()),
+      Effect.provide(harness.layer),
+    );
+  });
+
   it.effect(
     "consumes command_lifecycle and unknown SDK message types without runtime warnings",
     () => {

apps/server/src/provider/Layers/ClaudeAdapter.ts

@@ -110,13 +110,54 @@ const decodeUnknownJsonStringExit = Schema.decodeUnknownExit(Schema.UnknownFromJ
 const PROVIDER = ProviderDriverKind.make("claudeAgent");
 const COMPACT_CONTEXT_COMMAND = "/compact";
 const MAX_CLAUDE_FALLBACK_MODELS = 3;
+const CLAUDE_SKIP_PROMPT_HISTORY_ENV = "CLAUDE_CODE_SKIP_PROMPT_HISTORY";
+const CLAUDE_FORCE_SESSION_PERSISTENCE_ENV = "CLAUDE_CODE_FORCE_SESSION_PERSISTENCE";
+const CLAUDE_SESSION_PERSISTENCE_WARNING_KIND = "session-persistence";
 type ClaudeTextStreamKind = Extract<RuntimeContentStreamKind, "assistant_text" | "reasoning_text">;
 type ClaudeToolResultStreamKind = Extract<
   RuntimeContentStreamKind,
   "command_output" | "file_change_output"
 >;
 type ClaudeSdkEffort = NonNullable<ClaudeQueryOptions["effort"]>;
 
+function isEnabledEnvironmentFlag(value: string | undefined): boolean {
+  switch (value?.trim().toLowerCase()) {
+    case "1":
+    case "true":
+    case "yes":
+    case "on":
+      return true;
+    default:
+      return false;
+  }
+}
+
+function claudeSessionPersistenceEnvironmentWarning(
+  environment: NodeJS.ProcessEnv,
+): string | undefined {
+  if (
+    !isEnabledEnvironmentFlag(environment[CLAUDE_SKIP_PROMPT_HISTORY_ENV]) ||
+    isEnabledEnvironmentFlag(environment[CLAUDE_FORCE_SESSION_PERSISTENCE_ENV])
+  ) {
+    return undefined;
+  }
+  return (
+    `Claude session persistence is disabled by ${CLAUDE_SKIP_PROMPT_HISTORY_ENV}. ` +
+    "Threadlines will retain its activity history, but Claude cannot resume the saved model context. " +
+    `Unset ${CLAUDE_SKIP_PROMPT_HISTORY_ENV} or set ${CLAUDE_FORCE_SESSION_PERSISTENCE_ENV}=1, then restart Threadlines.`
+  );
+}
+
+function isClaudeSessionPersistenceWarning(message: string): boolean {
+  return /transcript|session persistence|saved for resume|--resume will not find/i.test(message);
+}
+
+function isClaudeDisabledSessionPersistenceWarning(message: string): boolean {
+  return /session persistence.*(?:disabled|off)|--resume will not find|keep future transcripts/i.test(
+    message,
+  );
+}
+
 function encodeJsonStringForDiagnostics(input: unknown): string | undefined {
   const result = encodeUnknownJsonStringExit(input);
   return Exit.isSuccess(result) ? result.value : undefined;
@@ -314,6 +355,7 @@ interface ClaudeSessionContext {
   // turn and cleared once consumed. Set only when a session starts from a
   // context seed (no native resume).
   pendingContextSeedText: string | undefined;
+  sessionPersistenceDisabledWarningEmitted: boolean;
   stopped: boolean;
 }
 
@@ -4446,6 +4488,38 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
         yield* emitRuntimeError(context, `Claude workspace mirror error: ${detail}`, message);
         return;
       }
+      case "informational": {
+        const content = nonEmptyString(message.content);
+        if (!content || message.level !== "warning") {
+          yield* Effect.logDebug("claude.sdk.informational", {
+            threadId: context.session.threadId,
+            level: message.level,
+            content: message.content,
+          });
+          return;
+        }
+        const isPersistenceWarning = isClaudeSessionPersistenceWarning(content);
+        if (
+          isPersistenceWarning &&
+          isClaudeDisabledSessionPersistenceWarning(content) &&
+          context.sessionPersistenceDisabledWarningEmitted
+        ) {
+          yield* Effect.logInfo("claude.session-persistence.warning-duplicate", {
+            threadId: context.session.threadId,
+            content,
+          });
+          return;
+        }
+        if (isClaudeDisabledSessionPersistenceWarning(content)) {
+          context.sessionPersistenceDisabledWarningEmitted = true;
+        }
+        yield* emitRuntimeWarning(context, content, message, {
+          warningKind: isPersistenceWarning
+            ? CLAUDE_SESSION_PERSISTENCE_WARNING_KIND
+            : "claude-informational",
+        });
+        return;
+      }
       case "api_retry": {
         // First-attempt retries are routine stream hiccups the SDK absorbs on
         // its own; keep those in server diagnostics only. Cascades that reach
@@ -5373,6 +5447,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
         includePartialMessages: true,
         enableFileCheckpointing: true,
         promptSuggestions: true,
+        persistSession: true,
         // Subagent conversations arrive as messages tagged with
         // parent_tool_use_id; routing keeps them out of the main transcript
         // and streams them into the collab tool item instead. Travels via the
@@ -5494,11 +5569,21 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
           input.contextSeed !== undefined && resumeState === undefined
             ? renderThreadContextSeed(input.contextSeed)
             : undefined,
+        sessionPersistenceDisabledWarningEmitted: false,
         stopped: false,
       };
       yield* Ref.set(contextRef, context);
       sessions.set(threadId, context);
 
+      const sessionPersistenceWarning =
+        claudeSessionPersistenceEnvironmentWarning(claudeEnvironment);
+      if (sessionPersistenceWarning !== undefined) {
+        context.sessionPersistenceDisabledWarningEmitted = true;
+        yield* emitRuntimeWarning(context, sessionPersistenceWarning, undefined, {
+          warningKind: CLAUDE_SESSION_PERSISTENCE_WARNING_KIND,
+        });
+      }
+
       const sessionStartedStamp = yield* makeEventStamp();
       yield* offerRuntimeEvent({
         type: "session.started",