feat(settings): inactivity auto-settle can keep threads with a PR#14642

@@ -2192,6 +2207,31 @@ export function GeneralSettingsPanel() {
     connectedEnvironments.every(
       (target) => target.serverConfig?.environment.capabilities.threadAutoSettlement === true,
     );
+  const mixedAutoSettle = useScopedSettingsMixed([
+    "sidebarAutoSettleAfterDays",
+    "sidebarAutoSettleScope",
+  ]);
+  const supportsAutoSettleScope = connectedEnvironments.every(
+    (environment) =>
+      environment.serverConfig?.environment.capabilities.threadAutoSettlementScope === true,
+  );
+  const autoSettleAfterDays = settings.sidebarAutoSettleAfterDays;
+  const autoSettleScope = settings.sidebarAutoSettleScope;
+  const autoSettleMode = autoSettleAfterDays === null ? "off" : autoSettleScope;
+  const autoSettleChanged =
+    autoSettleAfterDays !== DEFAULT_INACTIVITY_SETTINGS.sidebarAutoSettleAfterDays ||
+    autoSettleScope !== DEFAULT_INACTIVITY_SETTINGS.sidebarAutoSettleScope;
+
+  function changeAutoSettleMode(value: AutoSettleMode | null) {
+    if (value === null) return;
+    const sidebarAutoSettleAfterDays =
+      value === "off" ? null : (autoSettleAfterDays ?? AUTO_SETTLE_DEFAULT_DAYS);

@@ -0,0 +1,121 @@
+import { CheckpointScopeId, ProjectId, RunId, ThreadId } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+
+import * as PullRequestService from "../pullRequest/PullRequestService.ts";
+import * as VcsStatusBroadcaster from "../vcs/VcsStatusBroadcaster.ts";
+import * as WorkspaceEntries from "../workspace/WorkspaceEntries.ts";
+import * as CheckpointCapture from "./CheckpointCaptureService.ts";
+import * as ProjectionStore from "./ProjectionStore.ts";
+
+export class RunFinalizationError extends Schema.TaggedError<RunFinalizationError>()(
+  "RunFinalizationError",
+  {
+    threadId: ThreadId,
+    runId: RunId,
+    scopeId: CheckpointScopeId,
+    operation: Schema.Literals(["capture-checkpoint", "refresh-workspace"]),
+    cause: Schema.Defect(),
+  },
+) {}
+
+export class RunFinalizationRefreshError extends Schema.TaggedError<RunFinalizationRefreshError>()(
+  "RunFinalizationRefreshError",
+  { cwd: Schema.String, cause: Schema.Defect() },
+) {}
+
+export class RunFinalizationObserver extends Context.Reference<{
+  readonly refreshAfterTurn: (projectId: ProjectId) => Effect.Effect<void>;
+  readonly refresh: (input: {
+    readonly cwd: string;
+    readonly threadId: ThreadId;
+    readonly runId: RunId;
+  }) => Effect.Effect<void, RunFinalizationRefreshError>;
+}>("t3/orchestration-v2/RunFinalizationObserver", {
+  defaultValue: () => ({ refresh: () => Effect.void, refreshAfterTurn: () => Effect.void }),
+}) {}
+
+export class RunFinalizationService extends Context.Service<
+  RunFinalizationService,
+  {
+    readonly finalize: (input: {
+      readonly threadId: ThreadId;
+      readonly runId: RunId;
+      readonly scopeId: CheckpointScopeId;
+    }) => Effect.Effect<void, RunFinalizationError>;
+  }
+>()("t3/orchestration-v2/RunFinalizationService") {}
+
+const make = Effect.gen(function* () {
+  const checkpointCapture = yield* CheckpointCapture.CheckpointCaptureServiceV2;
+  const projections = yield* ProjectionStore.ProjectionStoreV2;
+  const observer = yield* RunFinalizationObserver;
+
+  const finalize: RunFinalizationService["Service"]["finalize"] = Effect.fn(
+    "RunFinalizationService.finalize",
+  )(function* (input) {
+    yield* checkpointCapture
+      .execute(input)
+      .pipe(
+        Effect.mapError(
+          (cause) => new RunFinalizationError({ ...input, operation: "capture-checkpoint", cause }),
+        ),
+      );
+    const projection = yield* projections
+      .getCheckpointContext(input.threadId)
+      .pipe(
+        Effect.mapError(
+          (cause) => new RunFinalizationError({ ...input, operation: "refresh-workspace", cause }),
+        ),
+      );
+    const cwd = projection.checkpointScopes.find((scope) => scope.id === input.scopeId)?.cwd;
+    if (cwd !== undefined) {
+      yield* observer
+        .refresh({ cwd, threadId: input.threadId, runId: input.runId })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new RunFinalizationError({ ...input, operation: "refresh-workspace", cause }),
+          ),
+        );
+    }
+  });
+  return RunFinalizationService.of({ finalize });
+});
+
+export const layer = Layer.effect(RunFinalizationService, make);
+
+export const observerLive = Layer.effect(
+  RunFinalizationObserver,
+  Effect.gen(function* () {
+    const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
+    const vcsStatus = yield* VcsStatusBroadcaster.VcsStatusBroadcaster;
+    const projections = yield* ProjectionStore.ProjectionStoreV2;
+    const pullRequests = yield* PullRequestService.PullRequestService;
+    return {
+      refreshAfterTurn: pullRequests.refreshAfterTurn,
+      refresh: ({ cwd, threadId, runId }) =>
+        Effect.gen(function* () {
+          const [, local] = yield* Effect.all(
+            [workspaceEntries.refresh(cwd), vcsStatus.refreshLocalStatus(cwd)],
+            { concurrency: "unbounded" },
+          );
+          if (local.refName === null || local.isDefaultRef) return;
+          const thread = yield* projections.getThreadShell(threadId);
+          if (!thread || thread.branch !== local.refName) return;
+          if (thread.activeRunId !== null && thread.activeRunId !== runId) return;
+          yield* vcsStatus.refreshPullRequestStatus(cwd).pipe(
+            Effect.catch((error) =>
+              Effect.logWarning("failed to refresh pull request status after run completion", {
+                threadId,
+                cwd,
+                detail: error.message,

@@ -2331,34 +2371,46 @@ export function GeneralSettingsPanel() {
 
             <SettingsRow
               serverScoped
-              settingKeys={["sidebarAutoSettleAfterDays"]}
+              settingKeys={["sidebarAutoSettleAfterDays", "sidebarAutoSettleScope"]}
               {...searchableSetting("auto-settle-inactive-threads")}
-              description="Sidebar threads with no activity for this long settle automatically."
+              description={

@@ -138,7 +153,10 @@ export function findSharedSettingsMismatches(input: {
   readonly primaryEnvironmentId: EnvironmentId | null;
   readonly primarySettings: ServerSettings | null;
   readonly primaryCapabilities?:
-    | Pick<ExecutionEnvironmentCapabilities, "threadRestartContinuation">
+    | Pick<
+        ExecutionEnvironmentCapabilities,
+        "threadRestartContinuation" | "threadAutoSettlementScope"
+      >

@@ -337,6 +356,8 @@ export const make = Effect.gen(function* () {
           nowMs: DateTime.toEpochMillis(decisionNow),
           autoSettleAfterDays: currentSettings.sidebarAutoSettleAfterDays,
           autoSettleOnMerge: currentSettings.sidebarAutoSettleOnMerge,
+          autoSettleScope: currentSettings.sidebarAutoSettleScope,

@@ -196,6 +197,11 @@ export function resolveAutoSettlementAt(input: {
   if (pullRequest !== null && pullRequestSettles(thread, pullRequest, input.autoSettleOnMerge)) {
     return activityAtMs === null ? thread.createdAt : DateTime.makeUnsafe(activityAtMs);
   }
+  if (
+    input.autoSettleScope === "without-pr" &&
+    (links.length > 0 || thread.linkedPullRequest != null || thread.branchPullRequest != null)

@@ -2201,6 +2216,40 @@ export function GeneralSettingsPanel() {
     connectedEnvironments.every(
       (target) => target.serverConfig?.environment.capabilities.threadAutoSettlement === true,
     );
+  const mixedAutoSettle = useScopedSettingsMixed([
+    "sidebarAutoSettleAfterDays",
+    "sidebarAutoSettleScope",
+  ]);
+  const supportsAutoSettleScope = connectedEnvironments.every(
+    (environment) =>
+      environment.serverConfig?.environment.capabilities.threadAutoSettlementScope === true,
+  );
+  const autoSettleAfterDays = settings.sidebarAutoSettleAfterDays;
+  const autoSettleScope = settings.sidebarAutoSettleScope;
+  const autoSettleMode = autoSettleAfterDays === null ? "off" : autoSettleScope;
+  const autoSettleChanged =
+    autoSettleAfterDays !== DEFAULT_INACTIVITY_SETTINGS.sidebarAutoSettleAfterDays ||
+    autoSettleScope !== DEFAULT_INACTIVITY_SETTINGS.sidebarAutoSettleScope;
+
+  function changeAutoSettleMode(value: AutoSettleMode | null) {
+    if (value === null) return;
+    if (value === "off") {
+      updateSettings({ sidebarAutoSettleAfterDays: null, sidebarAutoSettleScope: "all" });
+      return;
+    }
+    // A scope change keeps each target's own duration. Only a selection that
+    // includes a target with inactivity off needs a duration written.
+    const turnsOn =
+      autoSettleAfterDays === null ||
+      targets.some((target) => target.settings.sidebarAutoSettleAfterDays === null);
+    updateSettings({
+      ...(turnsOn
+        ? { sidebarAutoSettleAfterDays: autoSettleAfterDays ?? AUTO_SETTLE_DEFAULT_DAYS }

@@ -114,12 +116,17 @@ function AutoSettleSettingsRows() {
       environmentId: reference.environment.environmentId,
       projectId: reference.projectId,
       settings: referenceSettings,
+      supportsScope:

@@ -0,0 +1,616 @@
+import { resolveProjectSettings } from "@t3tools/shared/projectSettings";
+import { visibleThreadPullRequests } from "@t3tools/shared/threadPullRequests";
+import {
+  CommandId,
+  type ThreadId,
+  type OrchestrationV2DomainEvent,
+  type OrchestrationV2ThreadShell,
+} from "@t3tools/contracts";
+import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import type * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+
+import * as GitManager from "../git/GitManager.ts";
+import * as PullRequestService from "../pullRequest/PullRequestService.ts";
+import * as ServerSettings from "../serverSettings.ts";
+import { forkParked } from "../serverActivation.ts";
+import * as TerminalManager from "../terminal/Manager.ts";
+import * as ProjectStore from "./ProjectStore.ts";
+import * as Orchestrator from "./Orchestrator.ts";
+import * as ProjectionStore from "./ProjectionStore.ts";
+
+export interface SettlementPullRequest {
+  readonly state: "open" | "closed" | "merged";
+  readonly closedAt?: string | null;
+  readonly mergedAt?: string | null;
+}
+
+const DAY_MS = 24 * 60 * 60 * 1_000;
+export const QUEUED_TURN_START_GRACE_MS = 2 * 60 * 1_000;
+
+function toMillis(value: DateTime.Utc | null | undefined): number | null {
+  return value == null ? null : DateTime.toEpochMillis(value);
+}
+
+function latestMillis(values: ReadonlyArray<number | null>): number | null {
+  let latest: number | null = null;
+  for (const value of values) {
+    if (value === null) continue;
+    if (latest === null || value > latest) latest = value;
+  }
+  return latest;
+}
+
+function canonicalRepositoryKey(key: string): string {
+  return key
+    .replace(
+      /^(?:ssh\.dev\.azure\.com|vs-ssh\.visualstudio\.com)\/v3\/([^/]+)\/([^/]+)\/([^/]+)$/u,
+      "dev.azure.com/$1/$2/_git/$3",
+    )
+    .replace(
+      /^([^.]+)\.visualstudio\.com\/(?:defaultcollection\/)?([^/]+)\/_git\/([^/]+)$/u,
+      "dev.azure.com/$1/$2/_git/$3",
+    );
+}
+
+function pullRequestMatchesProject(
+  pullRequest: GitManager.GitBranchPullRequest,
+  project: {
+    readonly repositoryIdentity?: { readonly canonicalKey: string } | null | undefined;
+  },
+): boolean {
+  return (
+    pullRequest.repositoryKey !== null &&
+    project.repositoryIdentity != null &&
+    canonicalRepositoryKey(pullRequest.repositoryKey) ===
+      canonicalRepositoryKey(project.repositoryIdentity.canonicalKey)
+  );
+}
+
+/**
+ * A recent user message stays queued until a run adopts its timestamp.
+ * Absolute age bounds client clock skew in both directions and stops stale
+ * pre-adoption data from blocking the thread forever. A failed run start
+ * clears the block immediately (mirrors the v1 session "error" rule).
+ */
+export function threadHasQueuedTurnStart(
+  thread: Pick<
+    OrchestrationV2ThreadShell,
+    | "latestUserMessageAt"
+    | "latestRunRequestedAt"
+    | "latestRunStartedAt"
+    | "latestRunCompletedAt"
+    | "latestRunId"
+    | "status"
+  >,
+  nowMs: number,
+): boolean {
+  const messageAtMs = toMillis(thread.latestUserMessageAt);
+  if (messageAtMs === null || thread.status === "failed") return false;
+  const age = nowMs - messageAtMs;
+  if (Number.isNaN(age) || Math.abs(age) > QUEUED_TURN_START_GRACE_MS) return false;
+  if (thread.latestRunId === null) return true;
+  return [
+    toMillis(thread.latestRunRequestedAt),
+    toMillis(thread.latestRunStartedAt),
+    toMillis(thread.latestRunCompletedAt),
+  ].every((value) => value === null || value < messageAtMs);
+}
+
+function pullRequestSettles(
+  thread: Pick<
+    OrchestrationV2ThreadShell,
+    "createdAt" | "latestUserMessageAt" | "latestRunRequestedAt"
+  >,
+  pullRequest: SettlementPullRequest,
+  autoSettleOnMerge: boolean,
+): boolean {
+  if (pullRequest.state !== "closed" && (pullRequest.state !== "merged" || !autoSettleOnMerge)) {
+    return false;
+  }
+  const terminalAt = pullRequest.state === "merged" ? pullRequest.mergedAt : pullRequest.closedAt;
+  if (terminalAt == null) return false;
+  const userAnchorMs = latestMillis([
+    toMillis(thread.createdAt),
+    toMillis(thread.latestUserMessageAt),
+    toMillis(thread.latestRunRequestedAt),
+  ]);
+  if (userAnchorMs === null) return false;
+  const pullRequestAtMs = Date.parse(terminalAt);
+  if (Number.isNaN(pullRequestAtMs)) return false;
+  return pullRequestAtMs >= userAnchorMs;
+}
+
+/** Cheap checks that run before any source control lookup. */
+export function isAutoSettlementCandidate(
+  thread: ProjectionStore.ProjectionSettlementCandidate,
+  nowMs: number,
+): boolean {
+  if (thread.archivedAt !== null || thread.settledOverride !== null) return false;
+  if (thread.pinnedAt != null || thread.autoSettleDisabledAt != null) return false;
+  // Blocked-on-you work must never park behind a settled override.
+  if (thread.pendingRuntimeRequest !== null) return false;
+  // A live run — or post-settlement background work — is not staleness.
+  if (thread.activityRunStatus != null) return false;
+  if ((thread.pendingBackgroundTasks?.length ?? 0) > 0) return false;
+  if (threadHasQueuedTurnStart(thread, nowMs)) return false;
+  const snoozedUntilMs = toMillis(thread.snoozedUntil);
+  if (snoozedUntilMs === null || snoozedUntilMs <= nowMs) return true;
+  // A snoozed thread that woke early (error or completed work) can settle;
+  // one still parked on its wake time keeps its stronger statement.
+  const snoozedAtMs = toMillis(thread.snoozedAt);
+  const completedAtMs = toMillis(thread.latestRunCompletedAt);
+  const wokeOnError =
+    thread.status === "failed" &&
+    (snoozedAtMs === null || (completedAtMs !== null && completedAtMs > snoozedAtMs));
+  const wokeOnCompletion =
+    snoozedAtMs !== null && completedAtMs !== null && completedAtMs > snoozedAtMs;
+  return wokeOnError || wokeOnCompletion;
+}
+
+export function resolveAutoSettlementAt(input: {
+  readonly thread: ProjectionStore.ProjectionSettlementCandidate;
+  readonly pullRequest: SettlementPullRequest | null;
+  readonly nowMs: number;
+  readonly autoSettleAfterDays: number | null;
+  readonly autoSettleOnMerge: boolean;
+  readonly autoSettleScope?: "all" | "without-pr";
+  /** The thread's branch has not been looked up yet, so `pullRequest: null` is not an answer. */
+  readonly pullRequestLookupPending?: boolean;
+}): DateTime.Utc | null {
+  const { thread } = input;
+  let pullRequest = input.pullRequest;
+  const links = visibleThreadPullRequests(thread.pullRequests ?? []);
+  if (links.some((link) => link.snapshot === null || link.snapshot.state === "open")) return null;
+  if (links.length > 0) {
+    const terminalAt = (link: (typeof links)[number]) => {
+      const snapshot = link.snapshot;
+      const value = snapshot?.state === "merged" ? snapshot.mergedAt : snapshot?.closedAt;
+      const timestamp = Date.parse(value ?? "");
+      return Number.isNaN(timestamp) ? Number.NEGATIVE_INFINITY : timestamp;
+    };
+    const latest = links.reduce((current, candidate) =>
+      terminalAt(candidate) > terminalAt(current) ? candidate : current,
+    );
+    pullRequest =
+      latest.snapshot === null
+        ? null
+        : {
+            state: latest.snapshot.state,
+            mergedAt: latest.snapshot.mergedAt ?? null,
+            closedAt: latest.snapshot.closedAt ?? null,
+          };
+  }
+  if (!isAutoSettlementCandidate(thread, input.nowMs)) return null;
+  const activityAtMs = latestMillis([
+    toMillis(thread.latestUserMessageAt),
+    toMillis(thread.latestRunRequestedAt),
+    toMillis(thread.latestRunStartedAt),
+    toMillis(thread.latestRunCompletedAt),
+  ]);
+  if (pullRequest !== null && pullRequestSettles(thread, pullRequest, input.autoSettleOnMerge)) {
+    return activityAtMs === null ? thread.createdAt : DateTime.makeUnsafe(activityAtMs);
+  }
+  if (
+    input.autoSettleScope === "without-pr" &&
+    (input.pullRequestLookupPending === true ||
+      pullRequest !== null ||
+      links.length > 0 ||
+      thread.linkedPullRequest != null ||
+      thread.branchPullRequest != null)
+  )
+    return null;
+  if (input.autoSettleAfterDays === null || activityAtMs === null) return null;
+  return activityAtMs < input.nowMs - input.autoSettleAfterDays * DAY_MS
+    ? DateTime.makeUnsafe(activityAtMs)
+    : null;
+}
+
+export class ThreadSettlementServiceV2 extends Context.Service<
+  ThreadSettlementServiceV2,
+  {
+    readonly start: () => Effect.Effect<void, never, Scope.Scope>;
+    readonly drain: Effect.Effect<void>;
+  }
+>()("t3/orchestration-v2/ThreadSettlementService/ThreadSettlementServiceV2") {}
+
+function autoSettlementConfigured(settings: import("@t3tools/contracts").ServerSettings): boolean {
+  if (settings.sidebarAutoSettleOnMerge || settings.sidebarAutoSettleAfterDays !== null) {
+    return true;
+  }
+  return Object.values(settings.projectSettingsOverrides).some(
+    (entry) =>
+      entry.sidebarAutoSettleOnMerge === true ||
+      (entry.sidebarAutoSettleAfterDays !== undefined && entry.sidebarAutoSettleAfterDays !== null),
+  );
+}
+
+/** Identity of every settlement input, so unrelated settings edits do not trigger a sweep. */
+/** @internal Exported for tests. */
+export function autoSettlementSettingsKey(
+  settings: import("@t3tools/contracts").ServerSettings,
+): string {
+  return JSON.stringify([
+    settings.sidebarAutoSettleOnMerge,
+    settings.sidebarAutoSettleAfterDays,
+    settings.sidebarAutoSettleScope,
+    // Only entries that touch settlement, in a stable order, so a project
+    // override on an unrelated key does not queue a sweep. JSON drops
+    // undefined, so inherit (absent) and never (null) need distinct marks.
+    Object.entries(settings.projectSettingsOverrides)
+      .filter(
+        ([, entry]) =>
+          entry.sidebarAutoSettleOnMerge !== undefined ||
+          entry.sidebarAutoSettleAfterDays !== undefined ||
+          entry.sidebarAutoSettleScope !== undefined,
+      )
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([projectId, entry]) => [
+        projectId,
+        entry.sidebarAutoSettleOnMerge ?? "inherit",
+        entry.sidebarAutoSettleAfterDays === undefined
+          ? "inherit"
+          : entry.sidebarAutoSettleAfterDays,
+        entry.sidebarAutoSettleScope ?? "inherit",
+      ]),
+  ]);
+}
+
+export const make = Effect.gen(function* () {
+  const orchestrator = yield* Orchestrator.OrchestratorV2;
+  const projections = yield* ProjectionStore.ProjectionStoreV2;
+  const projectStore = yield* ProjectStore.ProjectStoreV2;
+  const settingsService = yield* ServerSettings.ServerSettingsService;
+  const git = yield* GitManager.GitManager;
+  const pullRequests = yield* PullRequestService.PullRequestService;
+  const crypto = yield* Crypto.Crypto;
+  const fileSystem = yield* FileSystem.FileSystem;
+  const terminals = yield* TerminalManager.TerminalManager;
+
+  const sweep = Effect.fn("ThreadSettlementServiceV2.sweep")(function* (
+    mergedPullRequest: PullRequestService.PullRequestMergeEvent | null,
+    threadId?: ThreadId,
+  ) {
+    const settings = yield* settingsService.getSettings;
+    if (!autoSettlementConfigured(settings)) {
+      return;
+    }
+    // A sweep for one thread reads only that thread's candidate row.
+    const threads = yield* projections.getSettlementCandidates(threadId);
+    if (threads.length === 0) return;
+    const projectShells = yield* projectStore.listShells();
+    const nowMs = DateTime.toEpochMillis(yield* DateTime.now);
+    const projects = new Map(projectShells.map((project) => [project.id, project]));
+    // A merge event re-sweeps every candidate, not just the threads linked to
+    // the merged pull request: most threads carry no link and settle from
+    // their branch lookup, which would otherwise wait for the next minute's
+    // sweep on a possibly stale cached answer.
+    const candidates = threads.filter((thread) => isAutoSettlementCandidate(thread, nowMs));
+
+    const settleThread = Effect.fn("ThreadSettlementServiceV2.settleThread")(
+      function* (
+        thread: (typeof candidates)[number],
+        pullRequest: SettlementPullRequest | null,
+        pullRequestLookupPending = false,
+      ) {
+        const currentSettings = resolveProjectSettings(
+          yield* settingsService.getSettings,
+          thread.projectId,
+        ).settings;
+        const decisionNow = yield* DateTime.now;
+        const settledAt = resolveAutoSettlementAt({
+          thread,
+          pullRequest,
+          nowMs: DateTime.toEpochMillis(decisionNow),
+          autoSettleAfterDays: currentSettings.sidebarAutoSettleAfterDays,
+          autoSettleOnMerge: currentSettings.sidebarAutoSettleOnMerge,
+          autoSettleScope: currentSettings.sidebarAutoSettleScope,
+          pullRequestLookupPending,
+        });
+        if (settledAt === null) return thread;
+        const uuid = yield* crypto.randomUUIDv4;
+        yield* orchestrator.dispatch({
+          type: "thread.auto-settle",
+          commandId: CommandId.make(`server:auto-settle:${thread.id}:${uuid}`),
+          threadId: thread.id,
+          snapshotAt: thread.updatedAt,
+          settledAt,
+        });
+        return null;
+      },
+      (effect, thread) =>
+        effect.pipe(
+          Effect.catchCause((cause) =>
+            Cause.hasInterruptsOnly(cause)
+              ? Effect.failCause(cause)
+              : Effect.logWarning("automatic thread settlement skipped", {
+                  threadId: thread.id,
+                  cause: Cause.pretty(cause),