@rallycry/conveyor-agent 11.0.2 → 11.0.4

package/dist/{chunk-JQVAWRVL.js → chunk-URYBO32C.js}

@@ -5,21 +5,21 @@ import {
   readWorkspaceBytes,
   statWorkspacePath,
   workspacePathExists
-} from "./chunk-N4WSUTGV.js";
+} from "./chunk-SLUBOIYE.js";
 import {
   reportBootMilestone
 } from "./chunk-GL2DIQEQ.js";
+import {
+  runSetupCommand,
+  runStartCommand,
+  terminateProcessGroup
+} from "./chunk-W4LZ7R6Z.js";
 import {
   getWorkbenchClient
 } from "./chunk-EXQ6AHOY.js";
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
-import {
-  runSetupCommand,
-  runStartCommand,
-  terminateProcessGroup
-} from "./chunk-W4LZ7R6Z.js";
 
 // src/setup/db-schema-sync.ts
 import { basename, dirname, join } from "path";
@@ -226,6 +226,30 @@ async function runDepsSync(options) {
   }
 }
 
+// src/setup/turbo-cache-diagnostic.ts
+import { join as join3 } from "path";
+var TURBO_CACHE_ENV_VARS = [
+  "TURBO_API",
+  "TURBO_TOKEN",
+  "TURBO_TEAM",
+  "TURBO_REMOTE_CACHE_SIGNATURE_KEY"
+];
+function describeTurboCacheEnv(env) {
+  const missing = TURBO_CACHE_ENV_VARS.filter((name) => !env[name]?.trim());
+  if (missing.length === 0) return "[turbo-cache] remote cache: configured";
+  return `[turbo-cache] remote cache: absent (missing ${missing.join(", ")}) \u2014 gates run turbo-cold; set the TURBO_* project secrets to restore remote cache hits`;
+}
+async function reportTurboCacheEnv(options) {
+  const pathExists = options.pathExists ?? workspacePathExists;
+  try {
+    if (!await pathExists(join3(options.workspaceDir, "turbo.json"))) return;
+  } catch {
+    return;
+  }
+  options.onOutput("stdout", `${describeTurboCacheEnv(options.env)}
+`);
+}
+
 // src/setup/sidecars.ts
 import net from "net";
 var POSTGRES_TIMEOUT_MS = 12e4;
@@ -409,6 +433,7 @@ var WorkspaceCommandSupervisor = class {
   runStartCommandFn;
   syncDbSchemaFn;
   syncDepsFn;
+  reportTurboCacheFn;
   loadForwardPortsFn;
   writeOutput;
   terminateStartCommand;
@@ -461,6 +486,11 @@ var WorkspaceCommandSupervisor = class {
       onOutput: opts.onOutput,
       signal: opts.signal
     }));
+    this.reportTurboCacheFn = options.reportTurboCache ?? ((opts) => reportTurboCacheEnv({
+      workspaceDir: this.workspaceDir,
+      env: this.env,
+      onOutput: opts.onOutput
+    }));
     this.loadForwardPortsFn = options.loadForwardPorts ?? loadForwardPorts;
     this.writeOutput = options.writeOutput ?? defaultWriteOutput;
     this.terminateStartCommand = options.terminateStartCommand ?? terminateProcessGroup;
@@ -521,6 +551,10 @@ var WorkspaceCommandSupervisor = class {
     this.reportBootMilestoneFn("sidecars_ready");
     await this.loopReady;
     if (this.stopped) return;
+    await this.reportTurboCacheFn({
+      onOutput: (stream, data) => this.forwardSetupOutput(stream, data)
+    });
+    if (this.stopped) return;
     await this.syncDeps();
     if (this.stopped) return;
     await this.syncDbSchema();

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   WorkspaceCommandSupervisor,
   startWorkspaceCommandsAfterConnect,
   stopWorkspaceCommands
-} from "./chunk-JQVAWRVL.js";
+} from "./chunk-URYBO32C.js";
 import {
   DEFAULT_SONNET_MODEL,
   PtyHarness,
@@ -27,8 +27,13 @@ import {
   resolveTuiKindFromEnv,
   runUsageProbe,
   sampleKeyUsage
-} from "./chunk-QETNCXIR.js";
+} from "./chunk-HYPX6FEX.js";
 import "./chunk-XORJ6SII.js";
+import {
+  inheritedEnv,
+  resolvePtySpawn,
+  sessionTempBase
+} from "./chunk-3F4ZZKCA.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -39,17 +44,13 @@ import {
   createServiceLogger,
   fetchBootstrap,
   loadConveyorConfig
-} from "./chunk-N4WSUTGV.js";
+} from "./chunk-SLUBOIYE.js";
 import "./chunk-GL2DIQEQ.js";
+import "./chunk-W4LZ7R6Z.js";
+import "./chunk-7P6QZHXZ.js";
 import "./chunk-IA45XHOA.js";
 import "./chunk-EXQ6AHOY.js";
 import "./chunk-KMB3BU4S.js";
-import {
-  inheritedEnv,
-  resolvePtySpawn,
-  sessionTempBase
-} from "./chunk-3F4ZZKCA.js";
-import "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 
 // src/cli.ts
@@ -237,7 +238,10 @@ var ProjectSessionRunner = class {
   async sampleAndReportKeyUsage() {
     if (this.stopped) return;
     const codingAgentKeyId = process.env.CONVEYOR_CODING_AGENT_KEY_ID;
-    const { samples, unmeasurable } = await sampleKeyUsage(process.env.CLAUDE_CODE_OAUTH_TOKEN);
+    const { samples, unmeasurable } = await sampleKeyUsage(
+      process.env.CLAUDE_CODE_OAUTH_TOKEN,
+      () => runUsageProbe({ cwd: this.config.workspaceDir })
+    );
     if (unmeasurable) {
       this.connection.sendEvent(buildUnmeasurableEvent(unmeasurable.reason, codingAgentKeyId));
       return;
@@ -281,7 +285,7 @@ function gaugesToSamples(stdout) {
   }
   return samples;
 }
-async function isolatedProbe(token, now) {
+async function isolatedProbe(token, now, cwd) {
   let dir = null;
   try {
     dir = await mkdtemp(join(sessionTempBase(), "conveyor-usage-"));
@@ -291,7 +295,7 @@ async function isolatedProbe(token, now) {
     });
     await copyFile(claudeJsonPath(), join(dir, ".claude.json")).catch(() => {
     });
-    return await runUsageProbe({ env: { ...process.env, CLAUDE_CONFIG_DIR: dir } });
+    return await runUsageProbe({ cwd, env: { ...process.env, CLAUDE_CONFIG_DIR: dir } });
   } catch (error) {
     logger.info("isolated usage probe failed", {
       error: error instanceof Error ? error.message : String(error)
@@ -304,7 +308,7 @@ async function isolatedProbe(token, now) {
 }
 async function probeKeysUsage(keys, deps = {}) {
   const now = deps.now ?? Date.now;
-  const probeOne = deps.probeOne ?? ((token) => isolatedProbe(token, now()));
+  const probeOne = deps.probeOne ?? ((token) => isolatedProbe(token, now(), deps.cwd));
   const results = [];
   for (const key of keys) {
     if (!key.oauthToken) continue;
@@ -558,7 +562,7 @@ var AdhocSessionRunner = class {
       await this.sampleAndReportOwnKey();
       return;
     }
-    const probed = await probeKeysUsage(keys);
+    const probed = await probeKeysUsage(keys, { cwd: this.config.workspaceDir });
     for (const { codingAgentKeyId, samples } of probed) {
       for (const event of buildRateLimitEvents(samples, codingAgentKeyId)) {
         this.connection.sendEvent(event);
@@ -569,7 +573,10 @@ var AdhocSessionRunner = class {
   async sampleAndReportOwnKey() {
     if (this.stopped) return;
     const codingAgentKeyId = process.env.CONVEYOR_CODING_AGENT_KEY_ID;
-    const { samples, unmeasurable } = await sampleKeyUsage(process.env.CLAUDE_CODE_OAUTH_TOKEN);
+    const { samples, unmeasurable } = await sampleKeyUsage(
+      process.env.CLAUDE_CODE_OAUTH_TOKEN,
+      () => runUsageProbe({ cwd: this.config.workspaceDir })
+    );
     if (unmeasurable) {
       this.connection.sendEvent(buildUnmeasurableEvent(unmeasurable.reason, codingAgentKeyId));
       return;
@@ -1194,7 +1201,7 @@ function wireSpawnChildren(mode, connection, supervisors, logger7) {
 
 // src/cli.ts
 if (process.argv[2] === "boot") {
-  const { runBoot } = await import("./boot-PKQ2I66D.js");
+  const { runBoot } = await import("./boot-SWUVT5B4.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -1398,6 +1405,7 @@ if (!CONVEYOR_TASK_ID && projectIdentity) {
         runnerMode: "pm"
       },
       projectId: projectIdentity.projectId,
+      workspaceDir: CONVEYOR_WORKSPACE,
       // Same extended idle window claudespace task pods get.
       ...process.env.CLAUDESPACE_NAME ? { lifecycle: { idleTimeoutMs: 60 * 60 * 1e3 } } : {}
     },
@@ -1446,7 +1454,7 @@ if (!RUNNER_MODES.includes(CONVEYOR_MODE)) {
   process.exit(1);
 }
 if (CONVEYOR_MODE === "serving") {
-  const { runServingSession } = await import("./serve-boot-YPAUKENG.js");
+  const { runServingSession } = await import("./serve-boot-B4BIZMNB.js");
   exitContext.runnerMode = "serving";
   exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? exitContext.sessionId;
   const outcome = await runServingSession({

package/dist/gate-cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/gate-cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import {
+  gatesDir
+} from "./chunk-7P6QZHXZ.js";
+
+// src/runner/gate-wrapper.ts
+import { mkdirSync, rmSync, writeFileSync } from "fs";
+import { constants as osConstants } from "os";
+import path from "path";
+import { spawn } from "child_process";
+var LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function parseGateArgs(argv) {
+  const usage = "usage: conveyor-gate <label> -- <cmd> [args\u2026]";
+  const [label, separator, command, ...args] = argv;
+  if (!label || separator !== "--" || !command) throw new Error(usage);
+  if (!LABEL_RE.test(label)) {
+    throw new Error(`invalid gate label '${label}' \u2014 use letters, digits, '.', '_', '-'`);
+  }
+  return { label, command, args };
+}
+function exitCodeFor(code, signal) {
+  if (code !== null) return code;
+  if (signal) {
+    const num = osConstants.signals[signal];
+    if (typeof num === "number") return 128 + num;
+  }
+  return 1;
+}
+var FORWARDED_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+function runGate(argv, options = {}) {
+  const log = options.log ?? ((message) => process.stderr.write(message));
+  const { label, command, args } = parseGateArgs(argv);
+  const dir = gatesDir();
+  mkdirSync(dir, { recursive: true });
+  const pidFile = path.join(dir, `${label}.pid`);
+  const exitFile = path.join(dir, `${label}.exit`);
+  rmSync(exitFile, { force: true });
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { stdio: "inherit" });
+    const forward = (signal) => {
+      child.kill(signal);
+    };
+    const listeners = FORWARDED_SIGNALS.map((signal) => {
+      const listener = () => forward(signal);
+      process.on(signal, listener);
+      return { signal, listener };
+    });
+    const finish = (code) => {
+      for (const { signal, listener } of listeners) process.removeListener(signal, listener);
+      try {
+        writeFileSync(exitFile, `${JSON.stringify({ code, finishedAtMs: Date.now() })}
+`);
+      } catch (error) {
+        log(`[conveyor-gate] failed to write ${exitFile}: ${String(error)}
+`);
+      }
+      rmSync(pidFile, { force: true });
+      resolve(code);
+    };
+    child.once("error", (error) => {
+      log(`[conveyor-gate] failed to run ${command}: ${error.message}
+`);
+      finish(127);
+    });
+    child.once("exit", (code, signal) => finish(exitCodeFor(code, signal)));
+    if (child.pid !== void 0) {
+      try {
+        writeFileSync(pidFile, `${child.pid}
+`);
+      } catch (error) {
+        log(`[conveyor-gate] failed to write ${pidFile}: ${String(error)}
+`);
+      }
+    }
+  });
+}
+
+// src/gate-cli.ts
+try {
+  process.exitCode = await runGate(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(`conveyor-gate: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 2;
+}

package/dist/index.d.ts

@@ -758,6 +758,53 @@ declare class SessionRunner {
      * live build costs work.
      */
     private deferShutdownForLiveChild;
+    /** Epoch ms of the first idle-shutdown deferral for background work in the
+     *  current idle episode; null when nothing has deferred. Reset when a turn
+     *  runs, so each idle episode gets its own bounded hold. */
+    private backgroundDeferStartedAt;
+    /**
+     * Suppress an idle shutdown while backgrounded work (`run_in_background`
+     * launches tracked by `BackgroundWorkTracker`) or a live gate process
+     * (`isHeavyGateActive` — singleton pidfiles plus the `conveyor-gate`
+     * contract dir) is still running. Without this the 30-minute idle timeout
+     * stopped the runner mid-gate: `shutdown()` cleared the tracker, heartbeats
+     * stopped, the activity clock expired, and the reconciler slept the pod and
+     * reverted the card to Open.
+     *
+     * Bounded: deferrals past the first one cap at `BACKGROUND_WORK_MAX_MS`, so
+     * a wedged gate process cannot pin a pod forever. Only the IDLE timeout is
+     * deferred — post-`completed` dormancy keeps today's behavior, and a parked
+     * prefill (`waiting_for_input`) contributes nothing here, so those cards
+     * still sleep on the ordinary window.
+     */
+    private deferShutdownForBackgroundWork;
+    /** When orphan evidence (tracked work pending, no live gate process) began
+     *  holding continuously; null while the evidence is absent. */
+    private orphanGraceStartedAt;
+    /** One-shot latch: at most one watchdog wake per idle episode. Reset when a
+     *  turn runs. */
+    private backgroundWakeFiredThisIdle;
+    /** When the current idle episode began — an exit sentinel older than this
+     *  appeared while a turn could still have consumed it, so it never wakes. */
+    private idleEpisodeStartedAt;
+    /**
+     * Wake a parked agent whose background work finished — or died — without a
+     * consumed completion callback. Completion normally arrives as the CLI's
+     * `<task-notification>` transcript record; when that record is lost (SDK
+     * harness, torn transcript, a gate killed out from under the CLI) the
+     * tracker entry silently expires and the agent waits forever.
+     *
+     * This is NOT the removed auto-mode stuck-nudge: it fires only on positive
+     * evidence of orphaned background work — a tracked launch with no live gate
+     * process continuously past `ORPHAN_WAKE_GRACE_MS`, or an unconsumed
+     * `gates/<label>.exit` sentinel that appeared this idle episode — never on
+     * "the agent seems stuck". A `completed` agent is never woken (the
+     * completion guard holds), and a live pid always suppresses the wake.
+     */
+    private maybeWakeForOrphanedBackgroundWork;
+    /** Orphan evidence that has held past the grace, or null. Maintains the
+     *  grace clock for the tracked-work condition as a side effect. */
+    private findOrphanEvidence;
     get sessionId(): string;
     get isStopped(): boolean;
     /** Wire the boot supervisor handle post-construction — cli.ts constructs it
@@ -802,18 +849,41 @@ declare class SessionRunner {
     /** Returns true if an initial query was executed, false otherwise. */
     private executeInitialMode;
     /**
-     * The mid-turn wedge watchdog aborts a turn that produced no events for 30
-     * minutes. Its documented recovery — "the next message respawns with
-     * `--resume`" — assumes a human or a follow-up is coming, which is exactly
-     * what an autonomous card does NOT have: after the abort the runner goes
-     * idle and the card parks until a pack watchdog or a human notices.
+     * The mid-turn watchdog aborts a turn that produced no events for 30 minutes
+     * (or one whose config-home mount died). Its documented recovery — "the next
+     * message respawns with `--resume`" — assumes a human or a follow-up is
+     * coming. A KICKOFF turn has neither by construction: it is the turn that
+     * starts the conversation, so there is no next message, and the runner goes
+     * idle with the card parked until a human notices.
+     *
+     * Observed live 2026-08-28 (card cmtd78iql): a spawned builder child's
+     * kickoff turn produced nothing for 30 minutes, was aborted, and the child
+     * then heartbeated idle for another 43 minutes until a human typed
+     * "@[agent:builder] continue".
+     *
+     * So any submit-delivery INITIAL query killed by the watchdog is re-run once
+     * against the (durable, on-disk) resumed session. Bounded to a single retry:
+     * a second wedge is a real failure that should surface as a parked card
+     * rather than loop the pod.
+     *
+     * Nothing recovers a card from there automatically, and that is the honest
+     * state of it. The server's session sweep does NOT catch this shape: its
+     * predicate is `agentRunningAt` still null, and a turn that started and then
+     * wedged has already stamped it. The sweep covers a builder that never took a
+     * turn at all; this retry covers one whose first turn stalled. Twice-wedged
+     * needs a human, and a card left that way keeps its Builder tab and its
+     * heartbeat, so it is visible rather than silently gone.
+     *
+     * Skipped when a pending message already exists, because the core loop
+     * delivers that instead, which is the path the watchdog's original recovery
+     * assumed.
+     *
+     * A mount-death abort retries too, and must: the repair for a dead config
+     * home is the respawn that follows the abort, so a kickoff with nothing
+     * behind it would otherwise never get one.
      *
-     * So for an autonomous card whose INITIAL query was killed as wedged, re-run
-     * that initial query once against the (durable, on-disk) resumed session.
-     * Bounded to a single retry: a second wedge is a real failure that should
-     * surface as a parked card rather than loop the pod. Skipped when a pending
-     * message already exists — the core loop delivers that instead, which is the
-     * path the watchdog's original recovery assumed.
+     * NOT for follow-up turns — there "the conversation resumes on the next
+     * message" is exactly right.
      */
     private requeueWedgedInitialQuery;
     /**
@@ -957,6 +1027,8 @@ declare class SessionRunner {
     private _finalState;
     /** The final status after run() completes. Use to determine exit code. */
     get finalState(): AgentRunnerStatus | null;
+    /** Does a transcript already exist for this session's lineage? */
+    private resolvesToTranscriptResume;
     private buildTaskContextSnapshot;
     private buildInitializationContext;
     private logInitialization;

package/dist/index.js

@@ -1,8 +1,9 @@
 import {
   SessionRunner,
   unshallowRepo
-} from "./chunk-QETNCXIR.js";
+} from "./chunk-HYPX6FEX.js";
 import "./chunk-XORJ6SII.js";
+import "./chunk-3F4ZZKCA.js";
 import {
   AgentConnection,
   GIT_TIMEOUT_MS,
@@ -16,8 +17,14 @@ import {
   stageAndCommit,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-N4WSUTGV.js";
+} from "./chunk-SLUBOIYE.js";
 import "./chunk-GL2DIQEQ.js";
+import {
+  runAuthTokenCommand,
+  runSetupCommand,
+  runStartCommand
+} from "./chunk-W4LZ7R6Z.js";
+import "./chunk-7P6QZHXZ.js";
 import "./chunk-IA45XHOA.js";
 import {
   getWorkbenchClient
@@ -25,12 +32,6 @@ import {
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
-import "./chunk-3F4ZZKCA.js";
-import {
-  runAuthTokenCommand,
-  runSetupCommand,
-  runStartCommand
-} from "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 
 // src/runner/worktree.ts

package/dist/{serve-boot-YPAUKENG.js → serve-boot-B4BIZMNB.js}

@@ -1,6 +1,6 @@
 import {
   WorkspaceCommandSupervisor
-} from "./chunk-JQVAWRVL.js";
+} from "./chunk-URYBO32C.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -11,12 +11,12 @@ import {
   createServiceLogger,
   ensureOnTaskBranch,
   loadConveyorConfig
-} from "./chunk-N4WSUTGV.js";
+} from "./chunk-SLUBOIYE.js";
 import "./chunk-GL2DIQEQ.js";
+import "./chunk-W4LZ7R6Z.js";
 import "./chunk-IA45XHOA.js";
 import "./chunk-EXQ6AHOY.js";
 import "./chunk-KMB3BU4S.js";
-import "./chunk-W4LZ7R6Z.js";
 import "./chunk-6Q6LQBWO.js";
 
 // src/runner/serve-session-runner.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "11.0.2",
+  "version": "11.0.4",
   "description": "Conveyor Agent Runner v10 - PTY harness for the task chat (SDK harness for audit/project-chat). Agent-as-User architecture with BaseService patterns. Works locally too.",
   "keywords": [
     "agent",
@@ -11,7 +11,8 @@
   ],
   "license": "MIT",
   "bin": {
-    "conveyor-agent": "dist/cli.js"
+    "conveyor-agent": "dist/cli.js",
+    "conveyor-gate": "dist/gate-cli.js"
   },
   "files": [
     "dist",

package/skills/conveyor-build/SKILL.md

@@ -149,6 +149,16 @@ and never silence a failure with a filter, a `.skip`, or a "known flake" note:
 either your diff broke it, or the test is broken or environment-dependent and
 you fix the test.
 
+**Long gates in a pod: background them the sanctioned way.** Launch a long
+gate with the harness's `run_in_background` Bash option and end the turn — the
+runner tracks the launch, holds pod liveness while a gate process is alive,
+and wakes you when it finishes (or if its completion callback is lost). In a
+repo without Conveyor's `scripts/singleton.sh`, wrap the command in the
+shipped `conveyor-gate` bin — `conveyor-gate <label> -- <cmd…>` — which writes
+the same pid/exit contract under `$CONVEYOR_RUN_DIR/gates/` so the runner can
+see it. Hand-rolled backgrounding (`nohup`, `&`, `disown`) is invisible to the
+runner: the pod can sleep mid-run and nothing will wake you.
+
 **A UI-visible change needs visual proof before the PR**, in both environments:
 capture a screenshot (static) or a short recording (interaction) with the host
 repo's own tooling and attach it with `mcp__conveyor__upload_attachment`, then

package/dist/{boot-PKQ2I66D.js → boot-SWUVT5B4.js}

@@ -1,3 +1,6 @@
+import {
+  startWorkbenchServer
+} from "./chunk-UBDSLM44.js";
 import {
   TOMBSTONE_MESSAGE,
   isLegacyEntrypointLaunch
@@ -5,6 +8,7 @@ import {
 import {
   readAgentVersion
 } from "./chunk-XORJ6SII.js";
+import "./chunk-3F4ZZKCA.js";
 import {
   GitPrepJob,
   defaultGit,
@@ -12,14 +16,10 @@ import {
   redactToken,
   reportBootMilestone
 } from "./chunk-GL2DIQEQ.js";
+import "./chunk-W4LZ7R6Z.js";
 import {
   workbenchPort
 } from "./chunk-KMB3BU4S.js";
-import {
-  startWorkbenchServer
-} from "./chunk-UBDSLM44.js";
-import "./chunk-3F4ZZKCA.js";
-import "./chunk-W4LZ7R6Z.js";
 import {
   DEFAULT_WORKBENCH_PORT
 } from "./chunk-6Q6LQBWO.js";

package/dist/{chunk-N4WSUTGV.js → chunk-SLUBOIYE.js}

@@ -4,6 +4,12 @@ import {
   FETCH_TIMEOUT_MS,
   GIT_PREP_MAX_RETRIES
 } from "./chunk-GL2DIQEQ.js";
+import {
+  gitCredentialHelper,
+  sleep,
+  syncGithubTokenFiles,
+  writeGitCredential
+} from "./chunk-W4LZ7R6Z.js";
 import {
   buildConveyorSocketOptions,
   callWithAck,
@@ -18,12 +24,6 @@ import {
 import {
   workbenchEnabled
 } from "./chunk-KMB3BU4S.js";
-import {
-  gitCredentialHelper,
-  sleep,
-  syncGithubTokenFiles,
-  writeGitCredential
-} from "./chunk-W4LZ7R6Z.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;