@rallycry/conveyor-agent 8.2.0 → 8.3.0

package/dist/{chunk-W4NCD23G.js → chunk-WNPFZC3I.js}

@@ -7,8 +7,9 @@ import {
 import {
   createHarness,
   createServiceLogger,
-  defineTool
-} from "./chunk-KTNGU2WU.js";
+  defineTool,
+  sessionTranscriptPath
+} from "./chunk-ND473JTK.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -1154,28 +1155,118 @@ function updateRemoteToken(cwd, token) {
   } catch {
   }
 }
-async function flushPendingChanges(cwd, opts) {
-  let committed = false;
-  let pushed = false;
-  let hadWork = false;
+function wipRefForBranch(branch) {
+  return `conveyor-wip/${branch}`;
+}
+var wipRefPushed = /* @__PURE__ */ new Set();
+function createWipSnapshot(cwd, message) {
+  try {
+    execSync("git add -A", { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    const sha = execSync(`git stash create ${JSON.stringify(message)}`, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return sha || null;
+  } catch {
+    return null;
+  } finally {
+    try {
+      execSync("git reset -q", { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+    }
+  }
+}
+function tryPushRefspec(cwd, refspec, force = false) {
+  try {
+    execSync(`git push ${force ? "--force " : ""}origin ${JSON.stringify(refspec)}`, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 3e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function refreshRemoteToken(cwd, refreshToken) {
+  if (!refreshToken) return;
   try {
-    if (hasUncommittedChanges(cwd)) {
-      hadWork = true;
-      const message = opts?.wipMessage ?? "WIP: auto-commit on conveyor-agent shutdown";
-      const hash = stageAndCommit(cwd, message);
-      committed = hash !== null;
+    const token = await refreshToken();
+    if (token) {
+      updateRemoteToken(cwd, token);
+      process.env.GITHUB_TOKEN = token;
+      process.env.GH_TOKEN = token;
     }
   } catch {
   }
+}
+function restoreWipSnapshot(cwd, branch) {
+  if (!branch) return "none";
+  const ref = wipRefForBranch(branch);
   try {
-    if (hasUnpushedCommits(cwd)) {
-      hadWork = true;
+    execSync(`git fetch origin +refs/heads/${ref}:refs/remotes/origin/${ref}`, {
+      cwd,
+      stdio: "ignore",
+      timeout: 6e4
+    });
+  } catch {
+    return "none";
+  }
+  wipRefPushed.add(cwd);
+  try {
+    const sha = execSync(`git rev-parse refs/remotes/origin/${ref}`, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    const parent = execSync(`git rev-parse "${sha}^"`, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    const head = execSync("git rev-parse HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    if (parent !== head) return "stale";
+    execSync(`git stash apply ${sha}`, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    return "applied";
+  } catch {
+    return "failed";
+  }
+}
+async function flushPendingChanges(cwd, opts) {
+  let committed = false;
+  let pushed = false;
+  let hadWork = false;
+  try {
+    const branch = getCurrentBranch(cwd);
+    if (!branch) return { committed, pushed, hadWork };
+    const dirty = hasUncommittedChanges(cwd);
+    const unpushed = hasUnpushedCommits(cwd);
+    if (!dirty && !unpushed) {
+      await dropStaleWipRef(cwd, branch, opts?.refreshToken);
+      return { committed, pushed, hadWork };
+    }
+    hadWork = true;
+    await refreshRemoteToken(cwd, opts?.refreshToken);
+    if (unpushed) {
       pushed = await pushToOrigin(cwd, opts?.refreshToken);
     }
+    if (dirty) {
+      const message = opts?.wipMessage ?? "WIP: conveyor-agent snapshot";
+      const sha = createWipSnapshot(cwd, message);
+      if (sha) {
+        committed = tryPushRefspec(cwd, `${sha}:refs/heads/${wipRefForBranch(branch)}`, true);
+        if (committed) wipRefPushed.add(cwd);
+      }
+    }
   } catch {
   }
   return { committed, pushed, hadWork };
 }
+async function dropStaleWipRef(cwd, branch, refreshToken) {
+  if (!wipRefPushed.has(cwd)) return;
+  await refreshRemoteToken(cwd, refreshToken);
+  if (tryPushRefspec(cwd, `:refs/heads/${wipRefForBranch(branch)}`)) {
+    wipRefPushed.delete(cwd);
+  }
+}
 async function pushToOrigin(cwd, refreshToken) {
   try {
     const currentBranch = getCurrentBranch(cwd);
@@ -1302,9 +1393,7 @@ var PlanSync = class {
 
 // src/execution/query-executor.ts
 import { createHash } from "crypto";
-import { existsSync } from "fs";
-import { homedir } from "os";
-import { join as join3 } from "path";
+import { existsSync, readFileSync as readFileSync2, truncateSync } from "fs";
 
 // ../shared/dist/index.js
 import { z } from "zod";
@@ -1313,6 +1402,7 @@ import { z as z3 } from "zod";
 var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
 var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
 var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
+var IDLE_HEARTBEAT_MS = 90 * 1e3;
 var AgentHeartbeatSchema = z.object({
   sessionId: z.string().optional(),
   timestamp: z.string(),
@@ -6389,19 +6479,63 @@ function buildHooks(host) {
     ]
   };
 }
-function taskIdToSessionUuid(taskId) {
-  const hash = createHash("sha256").update(taskId).digest("hex");
+function taskIdToSessionUuid(lineageKey) {
+  const hash = createHash("sha256").update(lineageKey).digest("hex");
   return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-8${hash.slice(13, 16)}-a${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
 }
+function sessionLineageKey(taskId, agentMode, runnerMode) {
+  return agentMode === "review" || runnerMode === "code-review" ? `${taskId}:review` : taskId;
+}
 function sessionFileExists(sessionUuid, cwd) {
   try {
-    const cwdSlug = cwd.replace(/\//g, "-");
-    const sessionFile = join3(homedir(), ".claude", "projects", cwdSlug, `${sessionUuid}.jsonl`);
-    return existsSync(sessionFile);
+    return existsSync(sessionTranscriptPath(cwd, sessionUuid));
+  } catch {
+    return false;
+  }
+}
+function hasExistingSessionFile(taskId, cwd, lineage) {
+  const key = sessionLineageKey(taskId, lineage.agentMode, lineage.runnerMode);
+  return sessionFileExists(taskIdToSessionUuid(key), cwd);
+}
+function repairTornSessionFile(path2) {
+  try {
+    if (!existsSync(path2)) return false;
+    const content = readFileSync2(path2, "utf8");
+    if (content.length === 0) return false;
+    let keepEnd = content.length;
+    if (!content.endsWith("\n")) {
+      keepEnd = content.lastIndexOf("\n") + 1;
+    }
+    while (keepEnd > 0) {
+      const prevNewline = content.lastIndexOf("\n", keepEnd - 2);
+      const line = content.slice(prevNewline + 1, keepEnd - 1).trim();
+      if (line.length > 0) {
+        try {
+          JSON.parse(line);
+          break;
+        } catch {
+        }
+      }
+      keepEnd = prevNewline + 1;
+    }
+    if (keepEnd === content.length) return false;
+    truncateSync(path2, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
+    logger2.warn("Repaired torn transcript before resume", {
+      path: path2,
+      trimmedBytes: content.length - keepEnd
+    });
+    return true;
   } catch {
     return false;
   }
 }
+function resolvePromptDelivery(inputs) {
+  if (inputs.harnessKind !== "pty") return "submit";
+  if ((inputs.runnerMode ?? "task") !== "task") return "submit";
+  if (inputs.isFollowUp || inputs.hasExistingSession) return "submit";
+  if (inputs.isAuto || inputs.agentMode === "auto") return "submit";
+  return "prefill";
+}
 function isReadOnlyMode(mode, hasExitedPlanMode) {
   return mode === "discovery" || mode === "help" || mode === "auto" && !hasExitedPlanMode;
 }
@@ -6514,7 +6648,17 @@ ${followUpText}` : followUpText;
   }
   return textPrompt;
 }
-async function runSdkQuery(host, context, followUpContent) {
+async function* notifyOnFirstEvent(inner, onFirst) {
+  let fired = false;
+  for await (const event of inner) {
+    if (!fired && event.type !== "system") {
+      fired = true;
+      await onFirst();
+    }
+    yield event;
+  }
+}
+async function runSdkQuery(host, context, followUpContent, promptDeliveryOverride) {
   if (host.isStopped()) return;
   const mode = host.agentMode;
   const isDiscoveryLike = mode === "discovery" || mode === "help";
@@ -6522,10 +6666,24 @@ async function runSdkQuery(host, context, followUpContent) {
   if (needsPlanSync) {
     host.snapshotPlanFiles();
   }
-  const sessionUuid = taskIdToSessionUuid(context.taskId);
+  const sessionUuid = taskIdToSessionUuid(
+    sessionLineageKey(context.taskId, mode, host.config.mode)
+  );
   const hasExistingSession = sessionFileExists(sessionUuid, host.config.workspaceDir);
+  if (hasExistingSession) {
+    repairTornSessionFile(sessionTranscriptPath(host.config.workspaceDir, sessionUuid));
+  }
+  const promptDelivery = promptDeliveryOverride ?? resolvePromptDelivery({
+    harnessKind: host.harnessKind,
+    runnerMode: host.config.mode,
+    isAuto: host.isAuto,
+    agentMode: mode,
+    isFollowUp: !!followUpContent,
+    hasExistingSession
+  });
   const options = {
     ...buildQueryOptions(host, context),
+    promptDelivery,
     ...hasExistingSession ? {} : { sessionId: sessionUuid }
   };
   const resume = hasExistingSession ? sessionUuid : void 0;
@@ -6536,33 +6694,45 @@ async function runSdkQuery(host, context, followUpContent) {
       options: { ...options },
       resume
     });
-    host.activeQuery = agentQuery;
-    try {
-      await runWithRetry(agentQuery, context, host, options);
-    } finally {
-      host.activeQuery = null;
-    }
-  } else if (isDiscoveryLike) {
+    await trackAndRun(host, context, options, agentQuery);
+  } else if (isDiscoveryLike && promptDelivery !== "prefill") {
     return;
   } else {
-    const initialPrompt = await buildInitialPrompt(host.config.mode, context, host.isAuto, mode);
-    const prompt = buildMultimodalPrompt(initialPrompt, context);
-    const agentQuery = host.harness.executeQuery({
-      prompt: host.createInputStream(prompt),
-      options: { ...options },
-      resume
-    });
-    host.activeQuery = agentQuery;
-    try {
-      await runWithRetry(agentQuery, context, host, options);
-    } finally {
-      host.activeQuery = null;
-    }
+    await runInitialQuery(host, context, options, resume, promptDelivery);
   }
   if (needsPlanSync) {
     await host.syncPlanFile();
   }
 }
+async function trackAndRun(host, context, options, agentQuery) {
+  host.activeQuery = agentQuery;
+  try {
+    await runWithRetry(agentQuery, context, host, options);
+  } finally {
+    host.activeQuery = null;
+  }
+}
+async function runInitialQuery(host, context, options, resume, promptDelivery) {
+  const initialPrompt = await buildInitialPrompt(
+    host.config.mode,
+    context,
+    host.isAuto,
+    host.agentMode
+  );
+  const prompt = buildMultimodalPrompt(initialPrompt, context);
+  let agentQuery = host.harness.executeQuery({
+    prompt: host.createInputStream(prompt),
+    options: { ...options },
+    resume
+  });
+  if (promptDelivery === "prefill") {
+    agentQuery = notifyOnFirstEvent(agentQuery, async () => {
+      host.connection.emitStatus("running");
+      await host.callbacks.onStatusChange("running");
+    });
+  }
+  await trackAndRun(host, context, options, agentQuery);
+}
 async function buildRetryQuery(host, context, options, lastErrorWasImage) {
   if (lastErrorWasImage) {
     host.connection.postChatMessage(
@@ -6901,6 +7071,7 @@ var QueryBridge = class {
     this.runnerConfig = runnerConfig;
     this.callbacks = callbacks;
     const harnessKind = resolveHarnessKind();
+    this.harnessKind = harnessKind;
     this.harness = createHarness(
       harnessKind,
       harnessKind === "pty" ? buildPtyBridge(connection) : void 0
@@ -6913,6 +7084,7 @@ var QueryBridge = class {
   runnerConfig;
   callbacks;
   harness;
+  harnessKind;
   costTracker;
   planSync;
   sessionIds = /* @__PURE__ */ new Map();
@@ -6956,18 +7128,40 @@ var QueryBridge = class {
   seedCostTracker(totalCostUsd, modelUsage) {
     this.costTracker.seed(totalCostUsd, modelUsage);
   }
+  /**
+   * How the INITIAL instructions for this task would be delivered — "prefill"
+   * means the TUI input is pre-filled but unsubmitted, awaiting the human.
+   * Mirrors the decision runSdkQuery makes for the initial (non-follow-up)
+   * query so SessionRunner can pick the matching state/timers.
+   */
+  initialPromptDelivery(context) {
+    return resolvePromptDelivery({
+      harnessKind: this.harnessKind,
+      runnerMode: this.runnerConfig.mode,
+      isAuto: this.mode.isAuto,
+      agentMode: this.mode.effectiveMode,
+      isFollowUp: false,
+      hasExistingSession: hasExistingSessionFile(context.taskId, this.runnerConfig.workspaceDir, {
+        agentMode: this.mode.effectiveMode,
+        runnerMode: this.runnerConfig.mode
+      })
+    });
+  }
   /**
    * Execute a Claude SDK query.
    * Without followUpContent: runs initial mode execution (build/plan).
    * With followUpContent: processes a follow-up user message.
+   * `promptDelivery` overrides the executor's submit-vs-prefill resolution —
+   * SessionRunner forces "submit" when pending chat messages already direct
+   * the agent (prefilling would park them until a human touched the TUI).
    */
-  async execute(context, followUpContent) {
+  async execute(context, followUpContent, promptDelivery) {
     this._stopped = false;
     this._wasRateLimited = false;
     this._abortController = new AbortController();
     const host = this.buildHost();
     try {
-      await runSdkQuery(host, context, followUpContent);
+      await runSdkQuery(host, context, followUpContent, promptDelivery);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       const isAbort = this._stopped || /abort/i.test(msg);
@@ -6990,6 +7184,7 @@ var QueryBridge = class {
       connection: this.connection,
       callbacks: this.callbacks,
       harness: this.harness,
+      harnessKind: this.harnessKind,
       setupLog: [],
       costTracker: this.costTracker,
       explorationTracker: bridge.mode.effectiveMode === "discovery" || bridge.mode.effectiveMode === "auto" && !bridge.mode.hasExitedPlanMode ? new ExplorationTracker(bridge._isParentTask) : null,
@@ -7061,8 +7256,8 @@ var QueryBridge = class {
 };
 
 // src/runner/session-runner-helpers.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join4 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 function mapChatHistory(messages) {
   if (!messages) return [];
@@ -7091,7 +7286,7 @@ function readAgentVersion() {
     const here = dirname(fileURLToPath(import.meta.url));
     for (const rel of ["../package.json", "../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync2(join4(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync3(join3(here, rel), "utf-8"));
         if (pkg.version) return pkg.version;
       } catch {
       }
@@ -7183,6 +7378,7 @@ var SessionRunner = class _SessionRunner {
       onIdleTimeout: () => {
         process.stderr.write("[conveyor-agent] Idle timeout reached, stopping agent\n");
         this.stopped = true;
+        this.queryBridge?.stop();
         if (this.inputResolver) {
           const resolver = this.inputResolver;
           this.inputResolver = null;
@@ -7192,6 +7388,7 @@ var SessionRunner = class _SessionRunner {
       onDormantTimeout: () => {
         process.stderr.write("[conveyor-agent] Dormant idle timeout reached, shutting down\n");
         this.stopped = true;
+        this.queryBridge?.stop();
         if (this.inputResolver) {
           const resolver = this.inputResolver;
           this.inputResolver = null;
@@ -7276,6 +7473,13 @@ var SessionRunner = class _SessionRunner {
         syncWithBaseBranch(this.config.workspaceDir, this.fullContext.baseBranch);
       }
     }
+    if (this.fullContext?.githubBranch) {
+      const restored = restoreWipSnapshot(this.config.workspaceDir, this.fullContext.githubBranch);
+      if (restored !== "none") {
+        process.stderr.write(`[conveyor-agent] WIP snapshot restore: ${restored}
+`);
+      }
+    }
     this.mode.applyServerMode(this.fullContext?.agentMode, this.fullContext?.isAuto);
     this.mode.resolveInitialMode(this.taskContext);
     if (this.fullContext?.isAuto && this.taskContext.status === "Open" && this.mode.isBuildCapable) {
@@ -7290,6 +7494,12 @@ var SessionRunner = class _SessionRunner {
     if (staleMessageCount > 0 && didExecuteInitialQuery) {
       this.pendingMessages.splice(0, staleMessageCount);
     }
+    if (this.queryBridge?.isDiscoveryCompleted) {
+      process.stderr.write(
+        "[conveyor-agent] Discovery completed during initial query \u2014 entering idle\n"
+      );
+      this.queryBridge.isDiscoveryCompleted = false;
+    }
     if (!this.stopped && this.pendingMessages.length === 0) {
       await this.maybeSendPRNudge();
     }
@@ -7410,16 +7620,32 @@ var SessionRunner = class _SessionRunner {
   async executeInitialMode() {
     if (!this.taskContext || !this.fullContext) return false;
     const effectiveMode = this.mode.effectiveMode;
-    const shouldRun = effectiveMode === "building" || effectiveMode === "auto" || effectiveMode === "review";
-    if (shouldRun) {
+    const delivery = this.pendingMessages.length > 0 ? "submit" : this.queryBridge?.initialPromptDelivery(this.fullContext) ?? "submit";
+    const shouldRun = effectiveMode === "building" || effectiveMode === "auto" || effectiveMode === "review" || delivery === "prefill";
+    if (!shouldRun) {
+      await this.setState("idle");
+      return false;
+    }
+    if (delivery === "prefill") {
+      await this.setState("waiting_for_input");
+      await this.callbacks.onEvent({ type: "execute_mode", mode: effectiveMode, delivery });
+      if (this.pendingMessages.length > 0) {
+        if (!this.stopped) await this.setState("idle");
+        return false;
+      }
+      this.lifecycle.startIdleTimer();
+      try {
+        await this.executeQuery(void 0, delivery);
+      } finally {
+        this.lifecycle.cancelIdleTimer();
+      }
+    } else {
       await this.setState("running");
       await this.callbacks.onEvent({ type: "execute_mode", mode: effectiveMode });
-      await this.executeQuery();
-      if (!this.stopped) await this.setState("idle");
-      return true;
+      await this.executeQuery(void 0, delivery);
     }
-    await this.setState("idle");
-    return false;
+    if (!this.stopped) await this.setState("idle");
+    return true;
   }
   // ── Message waiting ────────────────────────────────────────────────
   waitForMessage() {
@@ -7438,17 +7664,17 @@ var SessionRunner = class _SessionRunner {
       resolve2(msg);
     } else {
       this.pendingMessages.push(msg);
-      if (this._state === "running") {
+      if (this._state === "running" || this._state === "waiting_for_input") {
         this.queryBridge?.stop();
       }
     }
   }
   // ── Query execution with abort handling ────────────────────────────
   /** Run queryBridge.execute, swallowing abort errors from stop/softStop. */
-  async executeQuery(followUpContent) {
+  async executeQuery(followUpContent, promptDelivery) {
     if (!this.fullContext || !this.queryBridge) return;
     try {
-      await this.queryBridge.execute(this.fullContext, followUpContent);
+      await this.queryBridge.execute(this.fullContext, followUpContent, promptDelivery);
     } catch (err) {
       if (this.interrupted || this.stopped) {
         process.stderr.write("[conveyor-agent] Query aborted by stop/softStop signal\n");
@@ -7647,7 +7873,13 @@ var SessionRunner = class _SessionRunner {
       this.mode,
       runnerConfig,
       {
-        onStatusChange: (status) => this.callbacks.onStatusChange(status),
+        onStatusChange: (status) => {
+          if (status === "running" && this._state === "waiting_for_input") {
+            this._state = "running";
+            this.lifecycle.cancelIdleTimer();
+          }
+          return this.callbacks.onStatusChange(status);
+        },
         onEvent: (event) => {
           if (event.type === "completed") {
             this.completedThisTurn = true;
@@ -8104,13 +8336,13 @@ var CommitWatcher = class {
 // src/runner/worktree.ts
 import { execSync as execSync4 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 var WORKTREE_DIR = ".worktrees";
 function ensureWorktree(projectDir, taskId, branch) {
   if (projectDir.includes(`/${WORKTREE_DIR}/`)) {
     return projectDir;
   }
-  const worktreePath = join5(projectDir, WORKTREE_DIR, taskId);
+  const worktreePath = join4(projectDir, WORKTREE_DIR, taskId);
   if (existsSync2(worktreePath)) {
     if (branch) {
       if (hasUncommittedChanges(worktreePath)) {
@@ -8156,7 +8388,7 @@ function detachWorktreeBranch(projectDir, branch) {
   }
 }
 function removeWorktree(projectDir, taskId) {
-  const worktreePath = join5(projectDir, WORKTREE_DIR, taskId);
+  const worktreePath = join4(projectDir, WORKTREE_DIR, taskId);
   if (!existsSync2(worktreePath)) return;
   try {
     execSync4(`git worktree remove "${worktreePath}" --force`, {
@@ -9838,7 +10070,7 @@ var ProjectRunner = class {
   async handleAuditTags(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTagAudit } = await import("./tag-audit-handler-E6BZGVIG.js");
+      const { handleTagAudit } = await import("./tag-audit-handler-RFGGQWG6.js");
       await handleTagAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -9861,7 +10093,7 @@ var ProjectRunner = class {
   async handleAuditTasks(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTaskAudit } = await import("./task-audit-handler-MXSNTY22.js");
+      const { handleTaskAudit } = await import("./task-audit-handler-BN42VOYM.js");
       await handleTaskAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -9910,12 +10142,12 @@ var ProjectRunner = class {
 
 // src/setup/config.ts
 import { readFile as readFile3 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
 async function loadForwardPorts(workspaceDir) {
   try {
-    const raw = await readFile3(join6(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const raw = await readFile3(join5(workspaceDir, DEVCONTAINER_PATH), "utf-8");
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
@@ -10002,4 +10234,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-W4NCD23G.js.map
+//# sourceMappingURL=chunk-WNPFZC3I.js.map