@blogic-cz/agent-tools 1.7.2 → 1.7.4

package/src/gh-tool/pr/commands.ts

@@ -1,4 +1,4 @@
-import { Command, Flag, Param } from "effect/unstable/cli";
+import { Command, Flag, Param } from "effect/cli";
 import { Console, Effect, Option } from "effect";
 
 import type { CheckResult, PRStatusResult } from "#gh/types";
@@ -22,6 +22,7 @@ import {
 } from "#gh/text-input";
 import {
   CI_CHECK_WATCH_TIMEOUT_MS,
+  PR_WATCH_TIMEOUT_SECONDS,
   DEFAULT_DELETE_BRANCH,
   DEFAULT_MERGE_STRATEGY,
   DEFAULT_REVIEW_EVENT,
@@ -913,18 +914,20 @@ export const prChecksFailedCommand = Command.make(
     ),
     repo: repoOption,
     withLogs: Flag.Boolean("with-logs").pipe(
-      Flag.withDescription(
-        "Inline the failed-step logs for each failed check so no follow-up job-logs call is needed",
-      ),
+      Flag.withDescription("Inline a short summary from each failed step"),
+      Flag.withDefault(false),
+    ),
+    fullLogs: Flag.Boolean("full-logs").pipe(
+      Flag.withDescription("Inline all failed-step log lines; implies --with-logs"),
       Flag.withDefault(false),
     ),
   },
-  ({ format, pr, repo, withLogs }) =>
+  ({ format, pr, repo, withLogs, fullLogs }) =>
     withRepo(
       repo,
       Effect.gen(function* () {
         const prNumber = Option.getOrNull(pr);
-        const checks = yield* fetchFailedChecks(prNumber, withLogs);
+        const checks = yield* fetchFailedChecks(prNumber, withLogs, fullLogs);
         yield* logFormatted(checks, format);
       }),
     ),
@@ -938,13 +941,17 @@ export const prWatchCommand = Command.make(
     format: Flag.Literals("format", ["jsonl"]).pipe(Flag.withDefault("jsonl")),
     interval: Flag.Int("interval").pipe(
       Flag.withDefault(5),
+      Flag.withDescription("Polling interval in seconds (default: 5, range: 1..86400)"),
       Flag.filter(
-        (n) => n >= 1 && n <= 60,
-        () => "--interval must be 1..60 seconds",
+        (n) => n >= 1 && n <= 86400,
+        () => "--interval must be 1..86400 seconds",
       ),
     ),
     timeout: Flag.Int("timeout").pipe(
-      Flag.withDefault(CI_CHECK_WATCH_TIMEOUT_MS / 1000),
+      Flag.withDefault(PR_WATCH_TIMEOUT_SECONDS),
+      Flag.withDescription(
+        "Timeout in seconds (default: 1800, minimum 1); timeout is not a CI verdict",
+      ),
       Flag.filter(
         (n) => n >= 1,
         () => "--timeout must be at least 1 second",

package/src/gh-tool/pr/core.ts

@@ -1,4 +1,5 @@
 import { Clock, Console, Duration, Effect, Option, Result } from "effect";
+import { createHash } from "node:crypto";
 
 import type {
   BranchPRDetail,
@@ -17,10 +18,11 @@ import type {
 } from "#gh/types";
 
 import type { GitHubAuthError, GitHubNotFoundError } from "#gh/errors";
-import { GitHubCommandError, GitHubMergeError } from "#gh/errors";
+import { GitHubCommandError, GitHubMergeError, GitHubTimeoutError } from "#gh/errors";
 import { GitHubService } from "#gh/service";
+import { resolveGitHubToken } from "#gh/api";
 import type { GhResult } from "#gh/service";
-import { logText } from "#shared";
+import { logFormatted, logText } from "#shared";
 import { redactSensitiveText } from "#shared/content-security";
 
 import type { ButStatusJson, PRViewJsonResult } from "./helpers";
@@ -37,6 +39,11 @@ import {
   parseRawJobLogs,
   readJobLogApi,
 } from "#gh/workflow";
+import {
+  CheckStatusCacheDirectory,
+  readCheckStatusCache,
+  writeCheckStatusCache,
+} from "./check-status-cache";
 
 const CHECK_JSON_FIELDS = "name,state,bucket,link";
 const LONG_LIVED_BRANCHES = new Set(["main", "master", "develop", "staging", "production"]);
@@ -219,7 +226,7 @@ const fetchWorkflowRunFailureContext = Effect.fn("pr.fetchWorkflowRunFailureCont
       "view",
       String(runId),
       "--json",
-      "databaseId,attempt,url,workflowName,status,conclusion,jobs",
+      "databaseId,attempt,headSha,url,workflowName,status,conclusion,jobs",
     ])
     .pipe(Effect.catchTag("GitHubCommandError", () => Effect.succeed(null)));
 
@@ -245,6 +252,7 @@ const fetchWorkflowRunFailureContext = Effect.fn("pr.fetchWorkflowRunFailureCont
   const context: FailedCheckRunContext = {
     runId: run.databaseId,
     attempt: run.attempt ?? null,
+    headSha: run.headSha ?? null,
     url: run.url,
     workflowName: run.workflowName,
     status: run.status,
@@ -267,7 +275,35 @@ export const NO_CHECKS_REPORTED_RE = /no checks reported/i;
 const CHECK_REGISTRATION_POLL_SECONDS = 5;
 const CHECK_REGISTRATION_GRACE_SECONDS = 60;
 
-export const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr: number | null) {
+const summarizeFailedStepEntries = (entries: Array<{ step: string; message: string }>) => {
+  const selected = entries
+    .map((entry, index) => ({
+      entry,
+      index,
+      rank: /assert|expected|received|actual|failed|failure|error|exception|fatal/i.test(
+        entry.message,
+      )
+        ? 0
+        : 1,
+    }))
+    .toSorted((a, b) => a.rank - b.rank || b.index - a.index)
+    .slice(0, 20)
+    .toSorted((a, b) => a.index - b.index);
+  const kept: Array<{ step: string; message: string }> = [];
+  for (const { entry } of selected.toReversed()) {
+    const clipped = { step: entry.step.slice(0, 80), message: entry.message.slice(0, 150) };
+    if (formatLogEntries([clipped, ...kept]).length <= 3_900) kept.unshift(clipped);
+  }
+  let output = formatLogEntries(kept);
+  if (kept.length < entries.length)
+    output += `\n… ${entries.length - kept.length} log lines omitted`;
+  return output;
+};
+
+export const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (
+  pr: number | null,
+  cache?: { headSha: string; watchPending?: boolean },
+) {
   const gh = yield* GitHubService;
 
   const args = ["pr", "checks"];
@@ -275,7 +311,43 @@ export const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr
     args.push(String(pr));
   }
 
-  return yield* gh
+  const directory = yield* CheckStatusCacheDirectory;
+  const now = yield* Clock.currentTimeMillis;
+  let repo: string | null = null;
+  let identity: string | null = null;
+  if (cache !== undefined && pr !== null && directory !== undefined) {
+    const repoInfo = yield* gh.getRepoInfo().pipe(Effect.result);
+    const token = yield* resolveGitHubToken().pipe(Effect.result);
+    if (Result.isSuccess(repoInfo) && Result.isSuccess(token)) {
+      const host = yield* Effect.try({
+        try: () => new URL(repoInfo.success.url).host,
+        catch: () => "",
+      }).pipe(Effect.orElseSucceed(() => ""));
+      if (host.length > 0) {
+        const cacheRepo = `${host}/${repoInfo.success.owner}/${repoInfo.success.name}`;
+        const cacheIdentity = createHash("sha256").update(token.success).digest("hex");
+        const cached = yield* Effect.tryPromise({
+          try: () =>
+            readCheckStatusCache(
+              cacheIdentity,
+              cacheRepo,
+              pr,
+              cache.headSha,
+              now,
+              cache.watchPending,
+              directory,
+            ),
+          catch: () => null,
+        }).pipe(Effect.orElseSucceed(() => null));
+        if (cached !== null) return cached;
+        repo = cacheRepo;
+        identity = cacheIdentity;
+      }
+    }
+  }
+
+  const fetchedAt = yield* Clock.currentTimeMillis;
+  const checks = yield* gh
     .runGhJson<CheckResult[]>([...args, "--json", CHECK_JSON_FIELDS])
     .pipe(
       Effect.catchTag("GitHubCommandError", (error) =>
@@ -284,6 +356,20 @@ export const fetchCheckResults = Effect.fn("pr.fetchCheckResults")(function* (pr
           : Effect.fail(error),
       ),
     );
+  if (
+    cache !== undefined &&
+    pr !== null &&
+    repo !== null &&
+    identity !== null &&
+    checks.length > 0
+  ) {
+    yield* Effect.tryPromise({
+      try: () =>
+        writeCheckStatusCache(identity, repo, pr, cache.headSha, checks, fetchedAt, directory),
+      catch: () => undefined,
+    }).pipe(Effect.orElseSucceed(() => undefined));
+  }
+  return checks;
 });
 
 const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function* (
@@ -291,6 +377,7 @@ const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function
   checks: CheckResult[],
   options: {
     withLogs: boolean;
+    fullLogs?: boolean;
     evidence?: { headSha: string | null; baseSha: string | null } | null;
   } = { withLogs: false },
 ) {
@@ -354,12 +441,20 @@ const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function
         if (failedStepLogs === null || !("entries" in failedStepLogs) || !failedStepLogs.entries) {
           return detail;
         }
-        const formatted = formatLogEntries(failedStepLogs.entries);
+        const formatted = options.fullLogs
+          ? formatLogEntries(failedStepLogs.entries)
+          : summarizeFailedStepEntries(failedStepLogs.entries);
         return formatted.length > 0
           ? {
               ...detail,
               failedStepLogs: formatted,
-              diagnosis: diagnoseLogEntries(failedStepLogs.entries),
+              ...(run?.headSha !== null &&
+              run?.headSha !== undefined &&
+              evidence?.headSha !== null &&
+              evidence?.headSha !== undefined &&
+              run.headSha !== evidence.headSha
+                ? {}
+                : { diagnosis: diagnoseLogEntries(failedStepLogs.entries) }),
             }
           : detail;
       }),
@@ -375,10 +470,12 @@ const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function
         }
 
         const commands = [`bun agent-tools-gh workflow view --run ${check.runId}`];
-        const firstFailedJob = check.run?.failedJobs[0];
-        if (firstFailedJob) {
+        const matchedJob = check.run
+          ? matchFailedJobForCheck(check.name, check.run.failedJobs)
+          : null;
+        if (matchedJob) {
           commands.push(
-            `bun agent-tools-gh workflow job-logs --run ${check.runId} --job ${JSON.stringify(firstFailedJob.name)} --failed-steps-only`,
+            `bun agent-tools-gh workflow job-logs --run ${check.runId} --job ${JSON.stringify(matchedJob.name)} --failed-steps-only`,
           );
         }
 
@@ -397,6 +494,20 @@ const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function
         ? `Detected ${failedChecks.length} failed check(s) while ${pendingChecks.length} check(s) are still running.`
         : `Detected ${failedChecks.length} failed check(s).`;
 
+  let remainingLogCharacters = 16_000;
+  const reportFailedChecks = options.fullLogs
+    ? enrichedFailedChecks
+    : enrichedFailedChecks.map((check) => {
+        if (check.failedStepLogs === undefined) return check;
+        const limit = Math.max(0, remainingLogCharacters);
+        remainingLogCharacters -= check.failedStepLogs.length;
+        return check.failedStepLogs.length <= limit
+          ? check
+          : Object.assign({}, check, {
+              failedStepLogs: `${check.failedStepLogs.slice(0, Math.max(0, limit - 40))}\n… report log summary omitted`,
+            });
+      });
+
   const hint =
     failedChecks.length === 0
       ? pendingChecks.length > 0
@@ -416,7 +527,7 @@ const buildFailedChecksReport = Effect.fn("pr.buildFailedChecksReport")(function
       pending: pendingChecks.length,
       passed: passedChecks.length,
     },
-    failedChecks: enrichedFailedChecks,
+    failedChecks: reportFailedChecks,
     pendingChecks,
     hint,
     nextCommands,
@@ -1431,13 +1542,8 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
       watchArgs.push("--fail-fast");
     }
 
-    // Block for the caller's requested --timeout (no artificial cap — blocking isn't the problem;
-    // --timeout is validated >= 1s at the CLI boundary). On timeout return a snapshot, never
-    // nothing — that was the actual token-wasting bug.
-    // A push registers its checks a moment after the ref lands, and `gh pr checks --watch`
-    // exits non-zero in that window. A watch was asked to wait, so keep waiting: the outer
-    // timeout still bounds it, and a PR that genuinely has no checks returns an empty
-    // snapshot at that deadline rather than an error.
+    // A push can register checks after the ref lands. Wait through that window
+    // within the caller's timeout, then report the final snapshot.
     let watchResult: GhResult | null = null;
     let registered = false;
     let graceExpired = false;
@@ -1488,12 +1594,14 @@ export const fetchChecks = Effect.fn("pr.fetchChecks")(function* (
           `likely dropped, and re-watching will find nothing again — dispatch them on the PR ` +
           `head instead:\n   agent-tools-gh pr trigger-checks --pr ${prRef} --workflow <file.yml>`,
       );
-    } else if (!quiet && watchOutcome === null && results.some((c) => c.bucket === "pending")) {
-      const pending = results.filter((c) => c.bucket === "pending").length;
-      yield* Console.warn(
-        `ℹ️  Watch timed out after ${timeoutSeconds}s; ${pending} check(s) still pending (snapshot returned). ` +
-          `Re-run to keep watching:\n   ${buildChecksCommand(pr, true)}`,
-      );
+    }
+    if (watchOutcome === null && results.some((check) => check.bucket === "pending")) {
+      const pending = results.filter((check) => check.bucket === "pending").length;
+      yield* logFormatted(results, quiet ? "json" : "toon");
+      return yield* new GitHubTimeoutError({
+        message: `Watch timed out, ${pending} pending after ${timeoutSeconds}s. This is not a CI verdict.`,
+        timeoutMs: timeoutSeconds * 1000,
+      });
     }
     return results;
   }
@@ -1591,6 +1699,7 @@ export const collectWithStableState = <S, A, E1, R1, E2, R2>(
 export const fetchFailedChecks = Effect.fn("pr.fetchFailedChecks")(function* (
   pr: number | null,
   withLogs = false,
+  fullLogs = false,
 ) {
   const initial = yield* viewPR(pr);
   const snapshot = yield* collectWithStableState(
@@ -1604,7 +1713,8 @@ export const fetchFailedChecks = Effect.fn("pr.fetchFailedChecks")(function* (
   );
   if (snapshot !== null) {
     return yield* buildFailedChecksReport(snapshot.state.number, snapshot.value, {
-      withLogs,
+      withLogs: withLogs || fullLogs,
+      fullLogs,
       evidence: { headSha: snapshot.state.headSha, baseSha: snapshot.state.baseSha },
     });
   }
@@ -1710,7 +1820,14 @@ export const watchPRs = Effect.fn("pr.watchPRs")(function* (
       const initial = yield* watchPRState(pr);
       const stableResult = yield* collectWithStableState(
         initial,
-        () => requireDeadline.pipe(Effect.andThen(fetchCheckResults(pr))),
+        (state) =>
+          requireDeadline.pipe(
+            Effect.andThen(
+              state.headRefOid
+                ? fetchCheckResults(pr, { headSha: state.headRefOid, watchPending: true })
+                : fetchCheckResults(pr),
+            ),
+          ),
         () => requireDeadline.pipe(Effect.andThen(watchPRState(pr))),
         (before, after) => before.headRefOid === after.headRefOid && before.state === after.state,
       ).pipe(Effect.result);
@@ -1769,7 +1886,13 @@ export const watchPRs = Effect.fn("pr.watchPRs")(function* (
             timedOut = true;
             break;
           }
-          const state = yield* snapshot(number);
+          const remainingMs = Math.max(1, deadline - Number(yield* Clock.currentTimeMillis));
+          const state = yield* snapshot(number).pipe(
+            Effect.timeoutOrElse({
+              duration: remainingMs,
+              orElse: () => Effect.succeed("timeout" as const),
+            }),
+          );
           if (state === "timeout") {
             timedOut = true;
             break;
@@ -1869,12 +1992,27 @@ export const watchPRs = Effect.fn("pr.watchPRs")(function* (
       }),
     step: () => undefined,
   });
+  const watcherTimedOut = terminal.size < prs.length;
   yield* emit({
     type: "watcher_terminal",
     repo: `${repo.owner}/${repo.name}`,
-    status: terminal.size === prs.length ? "terminal" : "timeout",
+    status: watcherTimedOut ? "timeout" : "terminal",
     terminal: [...terminal].toSorted((a, b) => a - b),
+    ...(watcherTimedOut
+      ? {
+          verdict: null,
+          message: `Watch timed out, ${prs.length - terminal.size} pending. This is not a CI verdict.`,
+          timeoutSeconds: options.timeoutSeconds,
+          pending: prs.filter((number) => !terminal.has(number)).toSorted((a, b) => a - b),
+        }
+      : {}),
   });
+  if (watcherTimedOut) {
+    return yield* new GitHubTimeoutError({
+      message: `Watch timed out, ${prs.length - terminal.size} pending. This is not a CI verdict.`,
+      timeoutMs: options.timeoutSeconds * 1000,
+    });
+  }
 });
 
 type RerunDiscovery = RerunCheckAttempt & { status?: string };

package/src/gh-tool/pr/helpers.ts

@@ -1,4 +1,4 @@
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Effect, Stream } from "effect";
 
 import { GitHubCommandError } from "#gh/errors";

package/src/gh-tool/release.ts

@@ -1,4 +1,4 @@
-import { Command, Flag } from "effect/unstable/cli";
+import { Command, Flag } from "effect/cli";
 import { Effect, Option } from "effect";
 
 import { formatOption, logFormatted } from "#shared";

package/src/gh-tool/repo.ts

@@ -1,4 +1,4 @@
-import { Command, Flag } from "effect/unstable/cli";
+import { Command, Flag } from "effect/cli";
 import { Effect, Option } from "effect";
 
 import { formatOption, logFormatted } from "#shared";

package/src/gh-tool/service.ts

@@ -1,4 +1,4 @@
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Context, Effect, Layer, Stream } from "effect";
 
 import type { GitHubRepoConfig } from "#config";
@@ -224,6 +224,35 @@ export class GitHubService extends Context.Service<
               });
             }
 
+            if (/rate limit|abuse detection|HTTP 429/i.test(result.stderr)) {
+              const resource =
+                args[0] === "api"
+                  ? args[1]?.replace(/^\//, "") === "graphql"
+                    ? "graphql"
+                    : args[1]?.replace(/^\//, "").startsWith("search/")
+                      ? "search"
+                      : "core"
+                  : undefined;
+              const quotaFilter =
+                resource === undefined
+                  ? '.resources | to_entries[] | "\\(.key): reset time: \\(.value.reset | todateiso8601); remaining quota: \\(.value.remaining)"'
+                  : `.resources.${resource} | "reset time: \\(.reset | todateiso8601); remaining quota: \\(.remaining)"`;
+              const quota = yield* executeGh(["api", "rate_limit", "--jq", quotaFilter]).pipe(
+                Effect.orElseSucceed(() => null),
+              );
+              const detail =
+                quota?.exitCode === 0 && quota.stdout.trim()
+                  ? quota.stdout.trim()
+                  : "reset time: unavailable; remaining quota: unavailable (quota lookup failed)";
+              return yield* new GitHubCommandError({
+                message: `${result.stderr.trim()}; ${detail}`,
+                command: `gh ${args.join(" ")}`,
+                exitCode: result.exitCode,
+                stderr: result.stderr,
+                hint: "Wait until the quota resets before you retry. The failed command was not replayed.",
+              });
+            }
+
             // Transient network/5xx — flag retryable so the wrapper below can replay safe reads.
             if (NETWORK_ERROR_RE.test(result.stderr)) {
               return yield* new GitHubCommandError({

package/src/gh-tool/types.ts

@@ -121,6 +121,7 @@ export type FailedCheckJob = {
 export type FailedCheckRunContext = {
   runId: number;
   attempt: number | null;
+  headSha: string | null;
   url: string | null;
   workflowName: string | null;
   status: string;
@@ -226,6 +227,7 @@ export type FailedChecksReport = {
 export type WorkflowRunDetail = {
   databaseId: number;
   attempt: number | null;
+  headSha: string | null;
   url: string;
   workflowName: string | null;
   status: string;

package/src/gh-tool/workflow.ts

@@ -1,4 +1,4 @@
-import { Command, Flag, Param } from "effect/unstable/cli";
+import { Command, Flag, Param } from "effect/cli";
 import { Duration, Effect, Option } from "effect";
 
 import { formatOption, logFormatted, logText } from "#shared";
@@ -567,7 +567,15 @@ const normalizeFingerprint = (message: string) =>
     .slice(0, 240);
 
 export const diagnoseLogEntries = (entries: readonly LogEntry[]): LogDiagnosis => {
-  const lines = entries.map((entry) => entry.message);
+  const fetchProgress =
+    /^(?:\s*(?:\*\s+\[new branch\]|\[new branch\]|From\s+\S+|\*\s+\[new tag\]|\s*->\s+origin\/)|\s*\+?git fetch\b|.*refs\/(?:heads|remotes)\/)/i;
+  const lines = entries
+    .filter(
+      ({ message }) =>
+        /fatal:|error:|failed|exception|could not resolve|connection|timed out/i.test(message) ||
+        !fetchProgress.test(message),
+    )
+    .map((entry) => entry.message);
   const text = lines.join("\n");
   const find = (pattern: RegExp) => lines.find((line) => pattern.test(line)) ?? null;
   const testsStarted =

package/src/k8s-tool/main.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { Command, Flag } from "effect/unstable/cli";
+import { Command, Flag } from "effect/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Effect, Layer, Option } from "effect";
 

package/src/k8s-tool/service.ts

@@ -1,6 +1,6 @@
 import { posix } from "node:path";
 
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Context, Effect, Layer, Option, Ref } from "effect";
 
 import type { CommandResult, Environment } from "./types";

package/src/logs-tool/main.ts

@@ -14,7 +14,7 @@
  * Use --format toon for LLM-optimized output (fewer tokens).
  */
 
-import { Command, Flag } from "effect/unstable/cli";
+import { Command, Flag } from "effect/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Effect, Layer, Option, Result } from "effect";
 

package/src/observability-tool/logs.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Argument, Command, Flag } from "effect/cli";
 
 import { formatOption, formatOutput, logText } from "#shared";
 

package/src/observability-tool/main.ts

@@ -2,7 +2,7 @@
 
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Effect, Layer } from "effect";
-import { Command } from "effect/unstable/cli";
+import { Command } from "effect/cli";
 
 import { ConfigServiceLayer } from "#config";
 import { AuditServiceLayer, withAudit } from "#shared/audit";

package/src/observability-tool/metrics.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Argument, Command, Flag } from "effect/cli";
 
 import { formatOption, formatOutput, logText } from "#shared";
 

package/src/observability-tool/shared.ts

@@ -1,5 +1,5 @@
 import { Effect, Option } from "effect";
-import { Flag } from "effect/unstable/cli";
+import { Flag } from "effect/cli";
 
 import { ConfigService, getToolConfig } from "#config";
 import type { ObservabilityConfig } from "#config";

package/src/observability-tool/trace.ts

@@ -1,5 +1,5 @@
 import { Effect, type Option } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Argument, Command, Flag } from "effect/cli";
 
 import { formatOption, formatOutput, logText } from "#shared";
 import type { OutputFormat } from "#shared";

package/src/session-tool/main.ts

@@ -7,7 +7,7 @@
  * Uses current project scope by default, or all projects with --all.
  */
 
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Argument, Command, Flag } from "effect/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Effect, Layer, Result } from "effect";
 

package/src/shared/exec.ts

@@ -1,4 +1,4 @@
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { Effect, Schema, Stream } from "effect";
 
 const DEFAULT_TIMEOUT_MS = 30000;

package/src/shared/format.ts

@@ -1,4 +1,4 @@
-import { Flag } from "effect/unstable/cli";
+import { Flag } from "effect/cli";
 import { decode as decodeToon, encode as encodeToon } from "@toon-format/toon";
 import { Effect } from "effect";
 

package/src/shared/prerequisites/driver-commands.ts

@@ -1,4 +1,4 @@
-import { ChildProcess } from "effect/unstable/process";
+import { ChildProcess } from "effect/process";
 
 import type { ResolvedVpnDriver } from "#shared/prerequisites/types";
 import type { SanitizedVpnDriver } from "#shared/prerequisites/store";

package/src/shared/prerequisites/types.ts

@@ -1,5 +1,5 @@
 import { Schema, type Effect } from "effect";
-import type { ChildProcess } from "effect/unstable/process";
+import type { ChildProcess } from "effect/process";
 
 import type {
   LinuxNmcliVpnDriverConfig,

package/src/shared/retry-transient.ts

@@ -6,6 +6,7 @@ export const retryTransient = <A, E, R>(opts: {
   attempt: () => Effect.Effect<A, E, R>;
   isTransient: (error: E) => boolean;
   maxRetries: number;
+  retryDelayMs?: (error: E, attempt: number, fallbackMs: number) => number;
 }): Effect.Effect<A, E, R> => {
   const loop = (attempt: number): Effect.Effect<A, E, R> =>
     opts
@@ -13,9 +14,12 @@ export const retryTransient = <A, E, R>(opts: {
       .pipe(
         Effect.catch((error: E) =>
           opts.isTransient(error) && attempt < opts.maxRetries
-            ? Effect.sleep(Duration.millis(BASE_DELAY_MS * 2 ** attempt)).pipe(
-                Effect.flatMap(() => loop(attempt + 1)),
-              )
+            ? Effect.sleep(
+                Duration.millis(
+                  opts.retryDelayMs?.(error, attempt, BASE_DELAY_MS * 2 ** attempt) ??
+                    BASE_DELAY_MS * 2 ** attempt,
+                ),
+              ).pipe(Effect.flatMap(() => loop(attempt + 1)))
             : Effect.fail(error),
         ),
       );