@joshski/dust 0.1.84 → 0.1.86

package/dist/dust.js

@@ -319,7 +319,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.84";
+var DUST_VERSION = "0.1.86";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";
@@ -1740,7 +1740,7 @@ async function defaultExchangeCode(code, fetchFn = fetch) {
   return body.token;
 }
 async function authenticate(authDeps) {
-  const exchange = authDeps.exchangeCode ?? defaultExchangeCode;
+  const exchange = authDeps.exchangeCode ?? ((code) => defaultExchangeCode(code, authDeps.fetch));
   return new Promise((resolve, reject) => {
     let timer = null;
     let serverHandle = null;
@@ -1840,6 +1840,264 @@ function openBrowser(url) {
   nodeSpawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
 }
 
+// lib/bucket/bucket-state.ts
+function handleServerMessage(state, message) {
+  const effects = [];
+  effects.push({
+    type: "debugLog",
+    message: `ws message: ${message.type}`
+  });
+  switch (message.type) {
+    case "repository-list": {
+      const repos = message.repositories;
+      effects.push({
+        type: "log",
+        message: `Received repository list (${repos.length} repositories):`,
+        stream: "stdout"
+      });
+      if (repos.length === 0) {
+        effects.push({
+          type: "log",
+          message: "  (empty)",
+          stream: "stdout"
+        });
+      } else {
+        for (const r of repos) {
+          effects.push({
+            type: "log",
+            message: `  - name=${r.name}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    id=${r.id}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    gitUrl=${r.gitUrl}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    gitSshUrl=${r.gitSshUrl ?? "(none)"}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    url=${r.url}`,
+            stream: "stdout"
+          });
+          effects.push({
+            type: "log",
+            message: `    hasTask=${r.hasTask}`,
+            stream: "stdout"
+          });
+          if (r.agentProvider) {
+            effects.push({
+              type: "log",
+              message: `    agentProvider=${r.agentProvider}`,
+              stream: "stdout"
+            });
+          }
+        }
+      }
+      effects.push({
+        type: "syncUI",
+        repositories: repos
+      });
+      effects.push({
+        type: "handleRepositoryList",
+        repositories: repos
+      });
+      break;
+    }
+    case "task-available": {
+      const repoName = message.repository;
+      effects.push({
+        type: "log",
+        message: `Received task-available for ${repoName}`,
+        stream: "stdout"
+      });
+      if (state.repositoryNames.includes(repoName)) {
+        effects.push({
+          type: "signalTaskAvailable",
+          repositoryName: repoName
+        });
+      } else {
+        effects.push({
+          type: "log",
+          message: `No repository state found for ${repoName}`,
+          stream: "stderr"
+        });
+      }
+      break;
+    }
+  }
+  return { effects };
+}
+function handleMessageParseError(rawData) {
+  return {
+    effects: [
+      {
+        type: "log",
+        message: `Failed to parse WebSocket message: ${rawData}`,
+        stream: "stderr"
+      }
+    ]
+  };
+}
+function handleInvalidMessageFormat(rawData) {
+  return {
+    effects: [
+      {
+        type: "log",
+        message: `Invalid WebSocket message format: ${rawData}`,
+        stream: "stderr"
+      }
+    ]
+  };
+}
+var KEYS = {
+  UP: "\x1B[A",
+  DOWN: "\x1B[B",
+  RIGHT: "\x1B[C",
+  LEFT: "\x1B[D",
+  PAGE_UP: "\x1B[5~",
+  PAGE_DOWN: "\x1B[6~",
+  HOME: "\x1B[H",
+  END: "\x1B[F",
+  CTRL_C: "\x03"
+};
+var SGR_MOUSE_RE = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
+function parseSGRMouse(key) {
+  const match = key.match(SGR_MOUSE_RE);
+  if (!match)
+    return null;
+  return Number.parseInt(match[1], 10);
+}
+function handleKeypress(state, key) {
+  const effects = [];
+  const mouseButton = parseSGRMouse(key);
+  if (mouseButton !== null) {
+    if (mouseButton === 64) {
+      effects.push({ type: "scroll", direction: "up" });
+      effects.push({ type: "scroll", direction: "up" });
+      effects.push({ type: "scroll", direction: "up" });
+    } else if (mouseButton === 65) {
+      effects.push({ type: "scroll", direction: "down" });
+      effects.push({ type: "scroll", direction: "down" });
+      effects.push({ type: "scroll", direction: "down" });
+    }
+    return { effects };
+  }
+  switch (key) {
+    case "q":
+    case KEYS.CTRL_C:
+      effects.push({ type: "quit" });
+      break;
+    case KEYS.LEFT:
+      effects.push({ type: "selectPrevious" });
+      break;
+    case KEYS.RIGHT:
+      effects.push({ type: "selectNext" });
+      break;
+    case KEYS.UP:
+      effects.push({ type: "scroll", direction: "up" });
+      break;
+    case KEYS.DOWN:
+      effects.push({ type: "scroll", direction: "down" });
+      break;
+    case KEYS.PAGE_UP:
+      effects.push({ type: "scroll", direction: "pageUp" });
+      break;
+    case KEYS.PAGE_DOWN:
+      effects.push({ type: "scroll", direction: "pageDown" });
+      break;
+    case "g":
+    case KEYS.HOME:
+      effects.push({ type: "scroll", direction: "top" });
+      break;
+    case "G":
+    case KEYS.END:
+      effects.push({ type: "scroll", direction: "bottom" });
+      break;
+    case "o": {
+      if (state.selectedIndex === -1) {
+        break;
+      }
+      const repoName = state.repositories[state.selectedIndex];
+      if (!repoName)
+        break;
+      const url = state.repositoryUrls[repoName];
+      if (url) {
+        effects.push({ type: "openBrowser", url });
+      }
+      break;
+    }
+  }
+  return { effects };
+}
+var INITIAL_RECONNECT_DELAY_MS = 1000;
+var MAX_RECONNECT_DELAY_MS = 30000;
+function handleClose(state, code, reason) {
+  const effects = [];
+  effects.push({
+    type: "log",
+    message: `bucket.disconnected code=${code} reason=${reason || "none"}`,
+    stream: "stdout"
+  });
+  if (code === 4000) {
+    effects.push({
+      type: "log",
+      message: "Another connection replaced this one. Not reconnecting.",
+      stream: "stdout"
+    });
+    return { state, effects };
+  }
+  if (!state.shuttingDown) {
+    effects.push({
+      type: "log",
+      message: `Reconnecting in ${state.reconnectDelay / 1000} seconds...`,
+      stream: "stdout"
+    });
+    effects.push({
+      type: "scheduleReconnect",
+      delayMs: state.reconnectDelay
+    });
+    const nextDelay = Math.min(state.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+    return {
+      state: { ...state, reconnectDelay: nextDelay },
+      effects
+    };
+  }
+  return { state, effects };
+}
+function handleError(state, errorMessage) {
+  return {
+    state,
+    effects: [
+      {
+        type: "log",
+        message: `WebSocket error: ${errorMessage}`,
+        stream: "stderr"
+      }
+    ]
+  };
+}
+function handleOpen(state) {
+  return {
+    state: { ...state, reconnectDelay: INITIAL_RECONNECT_DELAY_MS },
+    effects: [
+      {
+        type: "log",
+        message: "bucket.connected",
+        stream: "stdout"
+      }
+    ]
+  };
+}
+
 // lib/bucket/events.ts
 var WS_OPEN = 1;
 function formatBucketEvent(event) {
@@ -1965,7 +2223,8 @@ class FileSink {
 
 // lib/logging/index.ts
 var DUST_LOG_FILE = "DUST_LOG_FILE";
-function createLoggingService() {
+function createLoggingService(options) {
+  const writeStdout = options?.stdout ?? process.stdout.write.bind(process.stdout);
   let patterns = null;
   let initialized = false;
   let activeFileSink = null;
@@ -1995,12 +2254,12 @@ function createLoggingService() {
       }
       activeFileSink = sinkForTesting ?? new FileSink(path);
     },
-    createLogger(name, options) {
+    createLogger(name, options2) {
       let perLoggerSink;
-      if (options?.file === false) {
+      if (options2?.file === false) {
         perLoggerSink = null;
-      } else if (typeof options?.file === "string") {
-        perLoggerSink = getOrCreateFileSink(options.file);
+      } else if (typeof options2?.file === "string") {
+        perLoggerSink = getOrCreateFileSink(options2.file);
       }
       return (...messages) => {
         init();
@@ -2013,7 +2272,7 @@ function createLoggingService() {
           activeFileSink.write(line);
         }
         if (patterns && matchesAny(name, patterns)) {
-          process.stdout.write(line);
+          writeStdout(line);
         }
       };
     },
@@ -2548,22 +2807,21 @@ async function removeRepository(path, spawn, context) {
 // lib/bucket/repository-loop.ts
 import { existsSync as fsExistsSync } from "node:fs";
 import os2 from "node:os";
-import path3 from "node:path";
 
 // lib/agent-events.ts
-function rawEventToAgentEvent(rawEvent) {
+function rawEventToAgentEvent(rawEvent, provider) {
   if (typeof rawEvent.type === "string" && rawEvent.type === "stream_event") {
     return { type: "agent-session-activity" };
   }
-  return { type: "claude-event", rawEvent };
+  return { type: "agent-event", provider, rawEvent };
 }
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
-function createHeartbeatThrottler(onAgentEvent, options) {
+function createHeartbeatThrottler(onAgentEvent, provider, options) {
   const intervalMs = options?.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
   const now = options?.now ?? Date.now;
   let lastHeartbeatTime;
   return (rawEvent) => {
-    const event = rawEventToAgentEvent(rawEvent);
+    const event = rawEventToAgentEvent(rawEvent, provider);
     if (event.type === "agent-session-activity") {
       const currentTime = now();
       if (lastHeartbeatTime !== undefined && currentTime - lastHeartbeatTime < intervalMs) {
@@ -2588,7 +2846,7 @@ function formatAgentEvent(event) {
     case "agent-session-ended":
       return event.success ? "\uD83E\uDD16 Agent session ended (success)" : `\uD83E\uDD16 Agent session ended (error: ${event.error})`;
     case "agent-session-activity":
-    case "claude-event":
+    case "agent-event":
       return null;
   }
 }
@@ -2597,7 +2855,6 @@ function formatAgentEvent(event) {
 import { spawn as nodeSpawn3 } from "node:child_process";
 import { existsSync } from "node:fs";
 import os from "node:os";
-import path2 from "node:path";
 
 // lib/docker/docker-agent.ts
 import path from "node:path";
@@ -2655,6 +2912,36 @@ function hasDockerfile(repoPath, dependencies) {
   const dockerfilePath = path.join(repoPath, ".dust", "Dockerfile");
   return dependencies.existsSync(dockerfilePath);
 }
+async function prepareDockerConfig(repoPath, dependencies, onEvent) {
+  log(`checking for .dust/Dockerfile in ${repoPath}`);
+  if (!hasDockerfile(repoPath, dependencies)) {
+    log("no .dust/Dockerfile found, running without Docker");
+    return {};
+  }
+  const imageTag = generateImageTag(repoPath);
+  log(`Dockerfile found, image tag: ${imageTag}`);
+  onEvent({ type: "loop.docker_detected", imageTag });
+  if (!await isDockerAvailable(dependencies)) {
+    const error = "Docker not available. Install Docker or remove .dust/Dockerfile to run without Docker.";
+    return { error };
+  }
+  onEvent({ type: "loop.docker_building", imageTag });
+  const buildResult = await buildDockerImage({ repoPath, imageTag }, dependencies);
+  if (!buildResult.success) {
+    onEvent({ type: "loop.docker_error", error: buildResult.error });
+    return { error: buildResult.error };
+  }
+  onEvent({ type: "loop.docker_built", imageTag });
+  const homeDir = dependencies.homedir();
+  const config = {
+    imageTag,
+    repoPath,
+    homeDir,
+    hasGitconfig: dependencies.existsSync(path.join(homeDir, ".gitconfig"))
+  };
+  log(`Docker config ready: ${JSON.stringify(config)}`);
+  return { config };
+}
 
 // lib/artifacts/workflow-tasks.ts
 var IDEA_TRANSITION_PREFIXES = [
@@ -3181,36 +3468,17 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
     homedir: loopDependencies.dockerDeps?.homedir ?? os.homedir,
     existsSync: loopDependencies.dockerDeps?.existsSync ?? existsSync
   };
-  log2(`checking for .dust/Dockerfile in ${context.cwd}`);
-  if (hasDockerfile(context.cwd, dockerDeps)) {
-    const imageTag = generateImageTag(context.cwd);
-    log2(`Dockerfile found, image tag: ${imageTag}`);
-    onLoopEvent({ type: "loop.docker_detected", imageTag });
-    if (!await isDockerAvailable(dockerDeps)) {
-      context.stderr("Docker not available. Install Docker or remove .dust/Dockerfile to run without Docker.");
-      return { exitCode: 1 };
-    }
-    onLoopEvent({ type: "loop.docker_building", imageTag });
-    const buildResult = await buildDockerImage({ repoPath: context.cwd, imageTag }, dockerDeps);
-    if (!buildResult.success) {
-      onLoopEvent({ type: "loop.docker_error", error: buildResult.error });
-      context.stderr(buildResult.error);
-      return { exitCode: 1 };
-    }
-    onLoopEvent({ type: "loop.docker_built", imageTag });
-    const homeDir = os.homedir();
-    dockerConfig = {
-      imageTag,
-      repoPath: context.cwd,
-      homeDir,
-      hasGitconfig: existsSync(path2.join(homeDir, ".gitconfig"))
-    };
+  const dockerResult = await prepareDockerConfig(context.cwd, dockerDeps, onLoopEvent);
+  if ("error" in dockerResult) {
+    context.stderr(dockerResult.error);
+    return { exitCode: 1 };
+  }
+  if ("config" in dockerResult) {
+    dockerConfig = dockerResult.config;
     if (!process.env.CLAUDE_CODE_OAUTH_TOKEN) {
       context.stderr("Docker mode requires CLAUDE_CODE_OAUTH_TOKEN. Run `claude setup-token` and export the token.");
       return { exitCode: 1 };
     }
-  } else {
-    log2("no .dust/Dockerfile found, running without Docker");
   }
   log2(`starting loop, maxIterations=${maxIterations}, sessionId=${sessionId}`);
   onLoopEvent({ type: "loop.warning" });
@@ -3227,7 +3495,7 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
     docker: dockerConfig
   };
   if (eventsUrl) {
-    iterationOptions.onRawEvent = createHeartbeatThrottler(onAgentEvent);
+    iterationOptions.onRawEvent = createHeartbeatThrottler(onAgentEvent, loopDependencies.agentType ?? "claude");
   }
   while (completedIterations < maxIterations) {
     agentSessionId = crypto.randomUUID();
@@ -3287,6 +3555,7 @@ async function* spawnCodex(prompt, options = {}, dependencies = defaultDependenc
     });
     proc.on("error", reject);
   });
+  closePromise.catch(() => {});
   const abortHandler = () => {
     if (!proc.killed) {
       proc.kill();
@@ -3439,9 +3708,15 @@ function createBufferStdoutSink(loopState, logBuffer) {
     }
   };
 }
+function createStdoutSinkFactory(loopState, logBuffer) {
+  return () => createBufferStdoutSink(loopState, logBuffer);
+}
 function createBufferRun(run3, bufferSinkDeps) {
   return (prompt, options) => run3(prompt, options, bufferSinkDeps);
 }
+function createCodexBufferRun(run3, codexBufferSinkDeps) {
+  return (prompt, options) => run3(prompt, options, codexBufferSinkDeps);
+}
 async function noOpPostEvent() {}
 function createLoopEventHandler(logBuffer) {
   return function onLoopEvent(event) {
@@ -3508,30 +3783,6 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
     sequence: 0,
     agentSessionId: undefined
   };
-  const isCodex = repoState.repository.agentProvider === "codex";
-  const agentType = isCodex ? "codex" : "claude";
-  const createStdoutSink2 = () => createBufferStdoutSink(loopState, repoState.logBuffer);
-  let bufferRun;
-  if (isCodex) {
-    const codexBufferSinkDeps = {
-      ...defaultRunnerDependencies2,
-      createStdoutSink: createStdoutSink2
-    };
-    bufferRun = (prompt, options) => run2(prompt, options, codexBufferSinkDeps);
-  } else {
-    const bufferSinkDeps = {
-      ...defaultRunnerDependencies,
-      createStdoutSink: createStdoutSink2
-    };
-    bufferRun = createBufferRun(run3, bufferSinkDeps);
-  }
-  const loopDeps = {
-    spawn,
-    run: bufferRun,
-    sleep,
-    postEvent: noOpPostEvent,
-    agentType
-  };
   const onLoopEvent = createLoopEventHandler(repoState.logBuffer);
   const onAgentEvent = createAgentEventHandler({
     repoState,
@@ -3547,43 +3798,53 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
     homedir: repoDeps.dockerDeps?.homedir ?? os2.homedir,
     existsSync: repoDeps.dockerDeps?.existsSync ?? fsExistsSync
   };
-  log3(`checking for .dust/Dockerfile in ${repoState.path}`);
-  if (hasDockerfile(repoState.path, dockerDeps)) {
-    const imageTag = generateImageTag(repoState.path);
-    log3(`Dockerfile found, image tag: ${imageTag}`);
-    onLoopEvent({ type: "loop.docker_detected", imageTag });
-    if (!await isDockerAvailable(dockerDeps)) {
-      log3("Docker not available");
-      appendLogLine(repoState.logBuffer, createLogLine("Docker not available. Install Docker or remove .dust/Dockerfile.", "stderr"));
-    } else {
-      onLoopEvent({ type: "loop.docker_building", imageTag });
-      const buildResult = await buildDockerImage({ repoPath: repoState.path, imageTag }, dockerDeps);
-      if (!buildResult.success) {
-        onLoopEvent({ type: "loop.docker_error", error: buildResult.error });
-        log3(`Docker build failed: ${buildResult.error}`);
-      } else {
-        onLoopEvent({ type: "loop.docker_built", imageTag });
-        const homeDir = dockerDeps.homedir();
-        dockerConfig = {
-          imageTag,
-          repoPath: repoState.path,
-          homeDir,
-          hasGitconfig: dockerDeps.existsSync(path3.join(homeDir, ".gitconfig"))
-        };
-        log3(`Docker config ready: ${JSON.stringify(dockerConfig)}`);
-        if (!process.env.CLAUDE_CODE_OAUTH_TOKEN) {
-          log3("CLAUDE_CODE_OAUTH_TOKEN is not set, cannot run in Docker mode");
-          appendLogLine(repoState.logBuffer, createLogLine("Docker mode requires CLAUDE_CODE_OAUTH_TOKEN. Run `claude setup-token` and export the token.", "stderr"));
-          return;
-        }
-      }
+  const dockerResult = await prepareDockerConfig(repoState.path, dockerDeps, onLoopEvent);
+  if ("error" in dockerResult) {
+    log3(`Docker error: ${dockerResult.error}`);
+    appendLogLine(repoState.logBuffer, createLogLine(dockerResult.error, "stderr"));
+  } else if ("config" in dockerResult) {
+    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+      log3("CLAUDE_CODE_OAUTH_TOKEN is not set, cannot run in Docker mode");
+      appendLogLine(repoState.logBuffer, createLogLine("Docker mode requires CLAUDE_CODE_OAUTH_TOKEN. Run `claude setup-token` and export the token.", "stderr"));
+      return;
     }
-  } else {
-    log3("no .dust/Dockerfile found, running without Docker");
+    dockerConfig = dockerResult.config;
   }
   log3(`loop started for ${repoName} at ${repoState.path}`);
   while (!repoState.stopRequested) {
     loopState.agentSessionId = crypto.randomUUID();
+    const isCodex = repoState.repository.agentProvider === "codex";
+    const agentType = isCodex ? "codex" : "claude";
+    log3(`${repoName}: agentProvider=${repoState.repository.agentProvider ?? "(unset)"}, using ${agentType}`);
+    const createStdoutSink2 = createStdoutSinkFactory(loopState, repoState.logBuffer);
+    let bufferRun;
+    if (isCodex) {
+      const codexBufferSinkDeps = {
+        ...defaultRunnerDependencies2,
+        spawnCodex: (prompt, options = {}) => {
+          const spawnDeps = {
+            ...defaultDependencies2,
+            spawn
+          };
+          return defaultRunnerDependencies2.spawnCodex(prompt, options, spawnDeps);
+        },
+        createStdoutSink: createStdoutSink2
+      };
+      bufferRun = createCodexBufferRun(run2, codexBufferSinkDeps);
+    } else {
+      const bufferSinkDeps = {
+        ...defaultRunnerDependencies,
+        createStdoutSink: createStdoutSink2
+      };
+      bufferRun = createBufferRun(run3, bufferSinkDeps);
+    }
+    const loopDeps = {
+      spawn,
+      run: bufferRun,
+      sleep,
+      postEvent: noOpPostEvent,
+      agentType
+    };
     const abortController = new AbortController;
     const cancelCurrentIteration = createCancelHandler(abortController);
     repoState.cancelCurrentIteration = cancelCurrentIteration;
@@ -3593,7 +3854,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
         hooksInstalled,
         signal: abortController.signal,
         repositoryId: repoState.repository.id.toString(),
-        onRawEvent: createHeartbeatThrottler(onAgentEvent),
+        onRawEvent: createHeartbeatThrottler(onAgentEvent, agentType),
         docker: dockerConfig
       });
     } catch (error) {
@@ -3653,7 +3914,8 @@ function parseRepository(data) {
         gitUrl: repositoryData.gitUrl,
         gitSshUrl: typeof repositoryData.gitSshUrl === "string" ? repositoryData.gitSshUrl : undefined,
         url: repositoryData.url,
-        id: repositoryData.id
+        id: repositoryData.id,
+        agentProvider: typeof repositoryData.agentProvider === "string" ? repositoryData.agentProvider : undefined
       };
     }
   }
@@ -3729,8 +3991,14 @@ async function handleRepositoryList(repositories, manager, repoDeps, context) {
     }
   }
   for (const [name, repo] of incomingRepos) {
-    if (!manager.repositories.has(name)) {
+    const existing = manager.repositories.get(name);
+    if (!existing) {
       await addRepository(repo, manager, repoDeps, context);
+    } else if (existing.repository.agentProvider !== repo.agentProvider) {
+      const from = existing.repository.agentProvider ?? "(unset)";
+      const to = repo.agentProvider ?? "(unset)";
+      log4(`${name}: agentProvider changed from ${from} to ${to}`);
+      existing.repository.agentProvider = repo.agentProvider;
     }
   }
   for (const name of manager.repositories.keys()) {
@@ -3843,18 +4111,19 @@ function visibleLength(text) {
 function truncateLine(text, maxWidth) {
   if (maxWidth <= 0)
     return "";
-  if (visibleLength(text) <= maxWidth)
+  const textLength = visibleLength(text);
+  if (textLength <= maxWidth)
     return text;
   const ansiRegex = /\x1b\[[0-9;]*m/g;
+  const truncateAt = maxWidth - CHARS.ellipsis.length;
   let visibleCount = 0;
   let result = "";
   let lastIndex = 0;
   for (let match = ansiRegex.exec(text);match !== null; match = ansiRegex.exec(text)) {
     const textBefore = text.slice(lastIndex, match.index);
     for (const char of textBefore) {
-      if (visibleCount >= maxWidth - CHARS.ellipsis.length) {
-        result += CHARS.ellipsis;
-        return result + ANSI.RESET;
+      if (visibleCount >= truncateAt) {
+        return result + CHARS.ellipsis + ANSI.RESET;
       }
       result += char;
       visibleCount++;
@@ -3864,14 +4133,13 @@ function truncateLine(text, maxWidth) {
   }
   const remaining = text.slice(lastIndex);
   for (const char of remaining) {
-    if (visibleCount >= maxWidth - CHARS.ellipsis.length) {
-      result += CHARS.ellipsis;
-      return result + ANSI.RESET;
+    if (visibleCount >= truncateAt) {
+      return result + CHARS.ellipsis + ANSI.RESET;
     }
     result += char;
     visibleCount++;
   }
-  return result;
+  return result + ANSI.RESET;
 }
 function createTerminalUIState() {
   return {
@@ -4001,7 +4269,7 @@ function getVisibleLogs(state) {
       const buffer2 = state.logBuffers.get(repoName2);
       if (!buffer2)
         continue;
-      const color2 = repoColors.get(repoName2) ?? ANSI.FG_WHITE;
+      const color2 = repoColors.get(repoName2);
       const lines = getLogLines(buffer2);
       for (const line of lines) {
         allLogs.push({ ...line, repository: repoName2, color: color2 });
@@ -4136,90 +4404,37 @@ function enterAlternateScreen() {
 function exitAlternateScreen() {
   return `\x1B[?1006l\x1B[?1000l${ANSI.EXIT_ALT_SCREEN}${ANSI.SHOW_CURSOR}`;
 }
-var KEYS = {
-  UP: "\x1B[A",
-  DOWN: "\x1B[B",
-  RIGHT: "\x1B[C",
-  LEFT: "\x1B[D",
-  PAGE_UP: "\x1B[5~",
-  PAGE_DOWN: "\x1B[6~",
-  HOME: "\x1B[H",
-  END: "\x1B[F",
-  CTRL_C: "\x03"
-};
-var SGR_MOUSE_RE = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
-function parseSGRMouse(key) {
-  const match = key.match(SGR_MOUSE_RE);
-  if (!match)
-    return null;
-  return Number.parseInt(match[1], 10);
-}
-function handleKeyInput(state, key, options) {
-  const mouseButton = parseSGRMouse(key);
-  if (mouseButton !== null) {
-    if (mouseButton === 64) {
-      scrollUp(state, 3);
-    } else if (mouseButton === 65) {
-      scrollDown(state, 3);
-    }
-    return false;
-  }
-  switch (key) {
-    case "q":
-    case KEYS.CTRL_C:
-      return true;
-    case KEYS.LEFT:
-      selectPrevious(state);
-      state.scrollOffset = 0;
-      state.autoScroll = true;
-      break;
-    case KEYS.RIGHT:
-      selectNext(state);
-      state.scrollOffset = 0;
-      state.autoScroll = true;
-      break;
-    case KEYS.UP:
-      scrollUp(state, 1);
-      break;
-    case KEYS.DOWN:
-      scrollDown(state, 1);
-      break;
-    case KEYS.PAGE_UP:
-      scrollUp(state, getLogAreaHeight(state));
-      break;
-    case KEYS.PAGE_DOWN:
-      scrollDown(state, getLogAreaHeight(state));
-      break;
-    case "g":
-    case KEYS.HOME:
-      scrollToTop(state);
-      break;
-    case "G":
-    case KEYS.END:
-      scrollToBottom(state);
-      break;
-    case "o": {
-      if (state.selectedIndex === -1) {
-        break;
-      }
-      const repoName = state.repositories[state.selectedIndex];
-      if (!repoName)
-        break;
-      const url = state.repositoryUrls.get(repoName);
-      if (url && options?.openBrowser) {
-        options.openBrowser(url);
-      }
-      break;
-    }
-  }
-  return false;
-}
+var SGR_MOUSE_RE2 = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
 
 // lib/cli/commands/bucket.ts
 var log5 = createLogger("dust:cli:commands:bucket");
 var DEFAULT_DUSTBUCKET_WS_URL = "wss://dustbucket.com/agent/connect";
-var INITIAL_RECONNECT_DELAY_MS = 1000;
-var MAX_RECONNECT_DELAY_MS = 30000;
+function createAuthFileSystem(dependencies) {
+  return {
+    exists: (path2) => {
+      try {
+        dependencies.accessSync(path2);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    isDirectory: (path2) => {
+      try {
+        return dependencies.statSync(path2).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    getFileCreationTime: (path2) => dependencies.statSync(path2).birthtimeMs,
+    readFile: (path2) => dependencies.readFile(path2, "utf8"),
+    writeFile: (path2, content) => dependencies.writeFile(path2, content, "utf8"),
+    mkdir: (path2, options) => dependencies.mkdir(path2, options).then(() => {}),
+    readdir: (path2) => dependencies.readdir(path2),
+    chmod: (path2, mode) => dependencies.chmod(path2, mode),
+    rename: (oldPath, newPath) => dependencies.rename(oldPath, newPath)
+  };
+}
 function defaultCreateWebSocket(url, token) {
   const ws = new WebSocket(url, {
     headers: {
@@ -4274,32 +4489,6 @@ function defaultGetTerminalSize() {
 function defaultWriteStdout(data) {
   process.stdout.write(data);
 }
-function createAuthFileSystem(dependencies) {
-  return {
-    exists: (path4) => {
-      try {
-        dependencies.accessSync(path4);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    isDirectory: (path4) => {
-      try {
-        return dependencies.statSync(path4).isDirectory();
-      } catch {
-        return false;
-      }
-    },
-    getFileCreationTime: (path4) => dependencies.statSync(path4).birthtimeMs,
-    readFile: (path4) => dependencies.readFile(path4, "utf8"),
-    writeFile: (path4, content) => dependencies.writeFile(path4, content, "utf8"),
-    mkdir: (path4, options) => dependencies.mkdir(path4, options).then(() => {}),
-    readdir: (path4) => dependencies.readdir(path4),
-    chmod: (path4, mode) => dependencies.chmod(path4, mode),
-    rename: (oldPath, newPath) => dependencies.rename(oldPath, newPath)
-  };
-}
 function createDefaultBucketDependencies() {
   const authFileSystem = createAuthFileSystem({
     accessSync,
@@ -4423,6 +4612,20 @@ function syncTUI(state) {
     }
   }
 }
+function handleRepositoryListSuccess(state, repos, repoDeps, context, useTUI) {
+  syncTUI(state);
+  for (const repoData of repos) {
+    if (repoData.hasTask) {
+      const repoState = state.repositories.get(repoData.name);
+      if (repoState) {
+        signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
+      }
+    }
+  }
+}
+function handleRepositoryListError(state, context, useTUI, error) {
+  logMessage(state, context, useTUI, `Failed to handle repository list: ${error.message}`, "stderr");
+}
 function logMessage(state, context, useTUI, message, stream = "stdout") {
   if (useTUI) {
     const systemBuffer = state.logBuffers.get("system");
@@ -4470,8 +4673,13 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
     state.ws = ws;
     ws.onopen = () => {
       state.emit({ type: "bucket.connected" });
-      logMessage(state, context, useTUI, formatBucketEvent({ type: "bucket.connected" }));
-      state.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+      const lifecycleState = {
+        reconnectDelay: state.reconnectDelay,
+        shuttingDown: state.shuttingDown
+      };
+      const result = handleOpen(lifecycleState);
+      state.reconnectDelay = result.state.reconnectDelay;
+      executeLifecycleEffects(result.effects, { state, context, useTUI, bucketDependencies, fileSystem }, token);
     };
   }
   ws.onclose = (event) => {
@@ -4481,80 +4689,110 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
       reason: event.reason || "none"
     };
     state.emit(disconnectEvent);
-    logMessage(state, context, useTUI, formatBucketEvent(disconnectEvent));
     state.ws = null;
-    if (event.code === 4000) {
-      logMessage(state, context, useTUI, "Another connection replaced this one. Not reconnecting.");
-      return;
-    }
-    if (!state.shuttingDown) {
-      logMessage(state, context, useTUI, `Reconnecting in ${state.reconnectDelay / 1000} seconds...`);
-      state.reconnectTimer = setTimeout(() => {
-        connectWebSocket(token, state, bucketDependencies, context, fileSystem, useTUI);
-      }, state.reconnectDelay);
-      state.reconnectDelay = Math.min(state.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
-    }
+    const lifecycleState = {
+      reconnectDelay: state.reconnectDelay,
+      shuttingDown: state.shuttingDown
+    };
+    const result = handleClose(lifecycleState, event.code, event.reason || "");
+    state.reconnectDelay = result.state.reconnectDelay;
+    executeLifecycleEffects(result.effects, { state, context, useTUI, bucketDependencies, fileSystem }, token);
   };
   ws.onerror = (error) => {
-    logMessage(state, context, useTUI, `WebSocket error: ${error.message}`, "stderr");
+    const lifecycleState = {
+      reconnectDelay: state.reconnectDelay,
+      shuttingDown: state.shuttingDown
+    };
+    const result = handleError(lifecycleState, error.message);
+    executeLifecycleEffects(result.effects, { state, context, useTUI, bucketDependencies, fileSystem }, token);
   };
   ws.onmessage = (event) => {
     let rawData;
     try {
       rawData = JSON.parse(event.data);
     } catch {
-      logMessage(state, context, useTUI, `Failed to parse WebSocket message: ${event.data}`, "stderr");
+      const result2 = handleMessageParseError(event.data);
+      executeEffects(result2.effects, {
+        state,
+        context,
+        useTUI,
+        bucketDependencies,
+        fileSystem
+      });
       return;
     }
     const message = parseServerMessage(rawData);
     if (!message) {
-      logMessage(state, context, useTUI, `Invalid WebSocket message format: ${event.data}`, "stderr");
+      const result2 = handleInvalidMessageFormat(event.data);
+      executeEffects(result2.effects, {
+        state,
+        context,
+        useTUI,
+        bucketDependencies,
+        fileSystem
+      });
       return;
     }
-    log5(`ws message: ${message.type}`);
-    if (message.type === "repository-list") {
-      const repos = message.repositories;
-      logMessage(state, context, useTUI, `Received repository list (${repos.length} repositories):`);
-      if (repos.length === 0) {
-        logMessage(state, context, useTUI, "  (empty)");
-      } else {
-        for (const r of repos) {
-          logMessage(state, context, useTUI, `  - name=${r.name}`);
-          logMessage(state, context, useTUI, `    id=${r.id}`);
-          logMessage(state, context, useTUI, `    gitUrl=${r.gitUrl}`);
-          logMessage(state, context, useTUI, `    gitSshUrl=${r.gitSshUrl ?? "(none)"}`);
-          logMessage(state, context, useTUI, `    url=${r.url}`);
-          logMessage(state, context, useTUI, `    hasTask=${r.hasTask}`);
-        }
+    const handlerState = {
+      repositoryNames: Array.from(state.repositories.keys())
+    };
+    const result = handleServerMessage(handlerState, message);
+    executeEffects(result.effects, {
+      state,
+      context,
+      useTUI,
+      bucketDependencies,
+      fileSystem
+    });
+  };
+}
+function executeEffects(effects, dependencies) {
+  const { state, context, useTUI, bucketDependencies, fileSystem } = dependencies;
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "log":
+        logMessage(state, context, useTUI, effect.message, effect.stream);
+        break;
+      case "debugLog":
+        log5(effect.message);
+        break;
+      case "syncUI":
+        syncUIWithRepoList(state, effect.repositories);
+        break;
+      case "handleRepositoryList": {
+        const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
+        const repoContext = createTUIContext(state, context, useTUI);
+        const repos = effect.repositories;
+        handleRepositoryList(repos, state, repoDeps, repoContext).then(() => handleRepositoryListSuccess(state, repos, repoDeps, context, useTUI)).catch((error) => handleRepositoryListError(state, context, useTUI, error));
+        break;
       }
-      syncUIWithRepoList(state, repos);
-      const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
-      const repoContext = createTUIContext(state, context, useTUI);
-      handleRepositoryList(repos, state, repoDeps, repoContext).then(() => {
-        syncTUI(state);
-        for (const repoData of repos) {
-          if (repoData.hasTask) {
-            const repoState = state.repositories.get(repoData.name);
-            if (repoState) {
-              signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
-            }
-          }
+      case "signalTaskAvailable": {
+        const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
+        const repoState = state.repositories.get(effect.repositoryName);
+        if (repoState) {
+          signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
         }
-      }).catch((error) => {
-        logMessage(state, context, useTUI, `Failed to handle repository list: ${error.message}`, "stderr");
-      });
-    } else if (message.type === "task-available") {
-      const repoName = message.repository;
-      const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
-      logMessage(state, context, useTUI, `Received task-available for ${repoName}`);
-      const repoState = state.repositories.get(repoName);
-      if (repoState) {
-        signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
-      } else {
-        logMessage(state, context, useTUI, `No repository state found for ${repoName}`, "stderr");
+        break;
       }
+      case "scheduleReconnect":
+        break;
     }
-  };
+  }
+}
+function executeLifecycleEffects(effects, dependencies, token) {
+  const { state, context, useTUI, bucketDependencies, fileSystem } = dependencies;
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "log":
+        logMessage(state, context, useTUI, effect.message, effect.stream);
+        break;
+      case "scheduleReconnect":
+        state.reconnectTimer = setTimeout(() => {
+          connectWebSocket(token, state, bucketDependencies, context, fileSystem, useTUI);
+        }, effect.delayMs);
+        break;
+    }
+  }
 }
 async function shutdown(state, bucketDeps, context) {
   if (state.shuttingDown)
@@ -4608,17 +4846,80 @@ function setupTUI(state, bucketDeps) {
     }
   };
 }
+function createKeypressHandlerState(ui) {
+  const repositoryUrls = {};
+  for (const [name, url] of ui.repositoryUrls) {
+    repositoryUrls[name] = url;
+  }
+  return {
+    selectedIndex: ui.selectedIndex,
+    repositories: ui.repositories,
+    repositoryUrls
+  };
+}
+function executeKeypressEffects(ui, effects, onQuit, options) {
+  for (const effect of effects) {
+    switch (effect.type) {
+      case "quit":
+        onQuit();
+        break;
+      case "openBrowser":
+        if (options?.openBrowser) {
+          options.openBrowser(effect.url);
+        }
+        break;
+      case "selectNext":
+        selectNext(ui);
+        ui.scrollOffset = 0;
+        ui.autoScroll = true;
+        break;
+      case "selectPrevious":
+        selectPrevious(ui);
+        ui.scrollOffset = 0;
+        ui.autoScroll = true;
+        break;
+      case "scroll":
+        switch (effect.direction) {
+          case "up":
+            scrollUp(ui, 1);
+            break;
+          case "down":
+            scrollDown(ui, 1);
+            break;
+          case "pageUp":
+            scrollUp(ui, getLogAreaHeight(ui));
+            break;
+          case "pageDown":
+            scrollDown(ui, getLogAreaHeight(ui));
+            break;
+          case "top":
+            scrollToTop(ui);
+            break;
+          case "bottom":
+            scrollToBottom(ui);
+            break;
+        }
+        break;
+    }
+  }
+}
 function createKeypressHandler(useTUI, state, onQuit, options) {
   if (useTUI) {
     return (key) => {
-      const shouldQuit = handleKeyInput(state.ui, key, options);
-      if (shouldQuit)
-        onQuit();
+      const keypressState = createKeypressHandlerState(state.ui);
+      const { effects } = handleKeypress(keypressState, key);
+      executeKeypressEffects(state.ui, effects, onQuit, options);
     };
   }
   return (key) => {
-    if (key === "q" || key === "\x03")
-      onQuit();
+    const keypressState = createKeypressHandlerState(state.ui);
+    const { effects } = handleKeypress(keypressState, key);
+    for (const effect of effects) {
+      if (effect.type === "quit") {
+        onQuit();
+        break;
+      }
+    }
   };
 }
 async function resolveToken(authDeps, context) {
@@ -4763,16 +5064,16 @@ function createDefaultUploadDependencies() {
       getHomeDir: () => homedir2(),
       fileSystem: authFileSystem
     },
-    readFileBytes: async (path4) => {
-      const buffer = await Bun.file(path4).arrayBuffer();
+    readFileBytes: async (path2) => {
+      const buffer = await Bun.file(path2).arrayBuffer();
       return new Uint8Array(buffer);
     },
-    getFileSize: async (path4) => {
-      const file = Bun.file(path4);
+    getFileSize: async (path2) => {
+      const file = Bun.file(path2);
       return file.size;
     },
-    fileExists: async (path4) => {
-      const file = Bun.file(path4);
+    fileExists: async (path2) => {
+      const file = Bun.file(path2);
       return file.exists();
     },
     uploadFile: async (url, token, fileBytes, contentType, fileName) => {
@@ -4868,7 +5169,8 @@ async function bucketAssetUpload(dependencies, uploadDeps = createDefaultUploadD
   }
   const fileBytes = await uploadDeps.readFileBytes(filePath);
   const contentType = getContentType(filePath);
-  const fileName = filePath.split("/").pop();
+  const parts = filePath.split("/");
+  const fileName = parts[parts.length - 1];
   const uploadUrl = `${getDustbucketHost()}/api/assets?repositoryId=${encodeURIComponent(repositoryId)}`;
   try {
     const result = await uploadDeps.uploadFile(uploadUrl, token, fileBytes, contentType, fileName);
@@ -5566,12 +5868,12 @@ function validateNoCycles(allPrincipleRelationships) {
   }
   for (const rel of allPrincipleRelationships) {
     const visited = new Set;
-    const path4 = [];
+    const path2 = [];
     let current = rel.filePath;
     while (current) {
       if (visited.has(current)) {
-        const cycleStart = path4.indexOf(current);
-        const cyclePath = path4.slice(cycleStart).concat(current);
+        const cycleStart = path2.indexOf(current);
+        const cyclePath = path2.slice(cycleStart).concat(current);
         violations.push({
           file: rel.filePath,
           message: `Cycle detected in principle hierarchy: ${cyclePath.join(" -> ")}`
@@ -5579,7 +5881,7 @@ function validateNoCycles(allPrincipleRelationships) {
         break;
       }
       visited.add(current);
-      path4.push(current);
+      path2.push(current);
       const currentRel = relationshipMap.get(current);
       if (currentRel && currentRel.parentPrinciples.length > 0) {
         current = currentRel.parentPrinciples[0];
@@ -5801,13 +6103,13 @@ function truncateOutput(output) {
   ].join(`
 `);
 }
-async function runSingleCheck(check, cwd, runner, emitEvent) {
+async function runSingleCheck(check, cwd, runner, emitEvent, clock = Date.now) {
   const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
   log6(`running check ${check.name}: ${check.command}`);
   emitEvent?.({ type: "check-started", name: check.name });
-  const startTime = Date.now();
+  const startTime = clock();
   const result = await runner.run(check.command, cwd, timeoutMs);
-  const durationMs = Date.now() - startTime;
+  const durationMs = clock() - startTime;
   const status = result.timedOut ? "timed out" : result.exitCode === 0 ? "passed" : "failed";
   log6(`check ${check.name} ${status} (${durationMs}ms)`);
   if (result.exitCode === 0) {
@@ -5833,18 +6135,18 @@ async function runSingleCheck(check, cwd, runner, emitEvent) {
     timeoutSeconds: timeoutMs / 1000
   };
 }
-async function runConfiguredChecks(checks, cwd, runner, emitEvent) {
-  const promises = checks.map((check) => runSingleCheck(check, cwd, runner, emitEvent));
+async function runConfiguredChecks(checks, cwd, runner, emitEvent, clock = Date.now) {
+  const promises = checks.map((check) => runSingleCheck(check, cwd, runner, emitEvent, clock));
   return Promise.all(promises);
 }
-async function runConfiguredChecksSerially(checks, cwd, runner, emitEvent) {
+async function runConfiguredChecksSerially(checks, cwd, runner, emitEvent, clock = Date.now) {
   const results = [];
   for (const check of checks) {
-    results.push(await runSingleCheck(check, cwd, runner, emitEvent));
+    results.push(await runSingleCheck(check, cwd, runner, emitEvent, clock));
   }
   return results;
 }
-async function runValidationCheck(dependencies, emitEvent) {
+async function runValidationCheck(dependencies, emitEvent, clock = Date.now) {
   const outputLines = [];
   const bufferedContext = {
     cwd: dependencies.context.cwd,
@@ -5853,13 +6155,13 @@ async function runValidationCheck(dependencies, emitEvent) {
   };
   log6("running built-in check: dust lint");
   emitEvent?.({ type: "check-started", name: "lint" });
-  const startTime = Date.now();
+  const startTime = clock();
   const result = await lintMarkdown({
     ...dependencies,
     context: bufferedContext,
     arguments: []
   });
-  const durationMs = Date.now() - startTime;
+  const durationMs = clock() - startTime;
   const lintStatus = result.exitCode === 0 ? "passed" : "failed";
   log6(`built-in check dust lint ${lintStatus} (${durationMs}ms)`);
   const output = outputLines.join(`
@@ -5867,14 +6169,12 @@ async function runValidationCheck(dependencies, emitEvent) {
   if (result.exitCode === 0) {
     emitEvent?.({ type: "check-passed", name: "lint", durationMs });
   } else {
-    const failedEvent = {
+    emitEvent?.({
       type: "check-failed",
       name: "lint",
-      durationMs
-    };
-    if (output)
-      failedEvent.output = output;
-    emitEvent?.(failedEvent);
+      durationMs,
+      output
+    });
   }
   return {
     name: "lint",
@@ -5923,7 +6223,7 @@ function displayResults(results, context) {
   context.stdout(`${indicator} ${passed.length}/${results.length} checks passed`);
   return failed.length > 0 ? 1 : 0;
 }
-async function check(dependencies, shellRunner = defaultShellRunner) {
+async function check(dependencies, shellRunner = defaultShellRunner, clock = Date.now) {
   const {
     arguments: commandArguments,
     context,
@@ -5949,18 +6249,18 @@ async function check(dependencies, shellRunner = defaultShellRunner) {
   if (serial) {
     const results2 = [];
     if (hasDustDir) {
-      results2.push(await runValidationCheck(dependencies, context.emitEvent));
+      results2.push(await runValidationCheck(dependencies, context.emitEvent, clock));
     }
-    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner, context.emitEvent);
+    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner, context.emitEvent, clock);
     results2.push(...configuredResults);
     const exitCode2 = displayResults(results2, context);
     return { exitCode: exitCode2 };
   }
   const checkPromises = [];
   if (hasDustDir) {
-    checkPromises.push(runValidationCheck(dependencies, context.emitEvent));
+    checkPromises.push(runValidationCheck(dependencies, context.emitEvent, clock));
   }
-  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner, context.emitEvent));
+  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner, context.emitEvent, clock));
   const promiseResults = await Promise.all(checkPromises);
   const results = [];
   for (const result of promiseResults) {
@@ -6299,7 +6599,7 @@ async function list(dependencies) {
         ideas: collectedItems.map((i) => ({
           path: i.path,
           title: i.title,
-          status: i.status ?? "draft"
+          status: i.status
         }))
       });
     } else if (type === "principles") {
@@ -6566,8 +6866,8 @@ function parseGitDiffNameStatus(output) {
     const parts = line.split("\t");
     if (parts.length >= 2) {
       const statusChar = parts[0].charAt(0);
-      const path4 = parts.length > 2 ? parts[2] : parts[1];
-      changes.push({ status: statusChar, path: path4 });
+      const path2 = parts.length > 2 ? parts[2] : parts[1];
+      changes.push({ status: statusChar, path: path2 });
     }
   }
   return changes;
@@ -6628,12 +6928,12 @@ async function getUncommittedFiles(cwd, gitRunner) {
 `).filter((line) => line.length > 0);
   for (const line of lines) {
     if (line.length > 3) {
-      const path4 = line.substring(3);
-      const arrowIndex = path4.indexOf(" -> ");
+      const path2 = line.substring(3);
+      const arrowIndex = path2.indexOf(" -> ");
       if (arrowIndex !== -1) {
-        files.push(path4.substring(arrowIndex + 4));
+        files.push(path2.substring(arrowIndex + 4));
       } else {
-        files.push(path4);
+        files.push(path2);
       }
     }
   }
@@ -6784,24 +7084,24 @@ async function main(options) {
 function createFileSystem(primitives) {
   return {
     exists: primitives.existsSync,
-    isDirectory: (path4) => {
+    isDirectory: (path2) => {
       try {
-        return primitives.statSync(path4).isDirectory();
+        return primitives.statSync(path2).isDirectory();
       } catch {
         return false;
       }
     },
-    readFile: (path4) => primitives.readFile(path4, "utf-8"),
-    writeFile: (path4, content, options) => primitives.writeFile(path4, content, {
+    readFile: (path2) => primitives.readFile(path2, "utf-8"),
+    writeFile: (path2, content, options) => primitives.writeFile(path2, content, {
       encoding: "utf-8",
       flag: options?.flag
     }),
-    mkdir: async (path4, options) => {
-      await primitives.mkdir(path4, options);
+    mkdir: async (path2, options) => {
+      await primitives.mkdir(path2, options);
     },
-    getFileCreationTime: (path4) => primitives.statSync(path4).birthtimeMs,
-    readdir: (path4) => primitives.readdir(path4),
-    chmod: (path4, mode) => primitives.chmod(path4, mode),
+    getFileCreationTime: (path2) => primitives.statSync(path2).birthtimeMs,
+    readdir: (path2) => primitives.readdir(path2),
+    chmod: (path2, mode) => primitives.chmod(path2, mode),
     rename: (oldPath, newPath) => primitives.rename(oldPath, newPath)
   };
 }