@gh-symphony/cli 0.0.18 → 0.0.20

package/dist/worker-entry.js

@@ -3,7 +3,7 @@ import {
   classifySessionExit,
   parseWorkflowMarkdown,
   readEnvFile
-} from "./chunk-OL73UN2X.js";
+} from "./chunk-M3IFVLQS.js";
 
 // ../worker/dist/index.js
 import { spawn as spawn2 } from "child_process";
@@ -92,8 +92,7 @@ function buildCodexRuntimePlan(config) {
       ...gitCredentialHelper,
       ...tool.env
     },
-    tools: [tool],
-    resumeThreadId: config.resumeThreadId?.trim() || null
+    tools: [tool]
   };
 }
 function launchCodexAppServer(plan, spawnImpl = spawn) {
@@ -196,8 +195,7 @@ function resolveLocalRuntimeLaunchConfig(env = process.env) {
     agentCredentialCachePath: env.AGENT_CREDENTIAL_CACHE_PATH,
     githubProjectId: env.GITHUB_PROJECT_ID,
     githubGraphqlApiUrl: env.GITHUB_GRAPHQL_API_URL,
-    agentCommand: env.SYMPHONY_AGENT_COMMAND,
-    resumeThreadId: env.SYMPHONY_RESUME_THREAD_ID
+    agentCommand: env.SYMPHONY_AGENT_COMMAND
   };
 }
 async function runLocalRuntimeLauncher(env = process.env) {
@@ -556,111 +554,20 @@ function resolveExitRunPhase(currentRunPhase, exit) {
   return exit.code === 0 && !exit.signal ? "succeeded" : "failed";
 }
 
-// ../worker/dist/session-budget.js
-function resolveSessionBudgetState(env) {
-  return {
-    cumulativeTurnCount: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_TURN_COUNT),
-    tokenUsageBaseline: {
-      inputTokens: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_INPUT_TOKENS),
-      outputTokens: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_OUTPUT_TOKENS),
-      totalTokens: parseNonNegativeInteger(env.SYMPHONY_CUMULATIVE_TOTAL_TOKENS)
-    },
-    sessionStartedAt: normalizeTimestamp(env.SYMPHONY_SESSION_STARTED_AT),
-    globalMaxTurns: parsePositiveInteger(env.SYMPHONY_GLOBAL_MAX_TURNS),
-    maxTokens: parsePositiveInteger(env.SYMPHONY_MAX_TOKENS),
-    sessionTimeoutMs: parsePositiveInteger(env.SYMPHONY_SESSION_TIMEOUT_MS)
-  };
-}
-function resolveBudgetExceededReason(budget, currentSessionTurnCount, currentTokenUsage, now) {
-  const totalTurns = budget.cumulativeTurnCount + currentSessionTurnCount;
-  if (budget.globalMaxTurns !== null && totalTurns >= budget.globalMaxTurns) {
-    return "global-turns";
-  }
-  const totalTokens = budget.tokenUsageBaseline.totalTokens + currentTokenUsage.totalTokens;
-  if (budget.maxTokens !== null && totalTokens >= budget.maxTokens) {
-    return "tokens";
-  }
-  if (budget.sessionTimeoutMs !== null && budget.sessionStartedAt !== null && now.getTime() - new Date(budget.sessionStartedAt).getTime() >= budget.sessionTimeoutMs) {
-    return "session-timeout";
-  }
-  return null;
-}
-function parsePositiveInteger(value) {
-  if (!value) {
-    return null;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    return null;
-  }
-  return Math.floor(parsed);
-}
-function parseNonNegativeInteger(value) {
-  if (!value) {
-    return 0;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    return 0;
-  }
-  return Math.floor(parsed);
-}
-function normalizeTimestamp(value) {
-  if (!value) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
-}
-
 // ../worker/dist/thread-resume.js
 var DEFAULT_CONTINUATION_GUIDANCE = "Continue working on the issue. Review your progress and complete any remaining tasks.";
-function parseNonNegativeInteger2(value) {
+function parseNonNegativeInteger(value) {
   const parsed = typeof value === "number" ? value : Number.parseInt(value ?? "", 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
     return 0;
   }
   return Math.floor(parsed);
 }
-function resolveRemainingTurns(maxTurns, cumulativeTurnCount) {
-  return Math.max(0, parseNonNegativeInteger2(maxTurns) - parseNonNegativeInteger2(cumulativeTurnCount));
-}
-function buildInitialTurnInput({ renderedPrompt, mode, lastTurnSummary, cumulativeTurnCount = 0, continuationGuidance }) {
-  if (mode === "fresh") {
-    return renderedPrompt;
-  }
-  const renderedContinuationGuidance = buildContinuationTurnInput({
-    continuationGuidance,
-    lastTurnSummary,
-    cumulativeTurnCount
-  });
-  const normalizedSummary = normalizeContinuationVariable(lastTurnSummary) ?? "No previous turn summary was captured.";
-  const normalizedCumulativeTurnCount = Math.max(0, parseNonNegativeInteger2(cumulativeTurnCount));
-  if (mode === "resume") {
-    return [
-      "Resume work on this issue using the existing thread context.",
-      `Previous worker turns completed: ${normalizedCumulativeTurnCount}.`,
-      `Previous session summary: ${normalizedSummary}`,
-      renderedContinuationGuidance
-    ].join("\n");
-  }
-  return [
-    "Resume work on this issue from a previous worker session.",
-    "",
-    "Original issue instructions:",
-    renderedPrompt,
-    "",
-    "Previous session summary:",
-    normalizedSummary,
-    "",
-    renderedContinuationGuidance
-  ].join("\n");
-}
 function buildContinuationTurnInput({ continuationGuidance, lastTurnSummary, cumulativeTurnCount = 0 }) {
   const template = continuationGuidance?.trim() || DEFAULT_CONTINUATION_GUIDANCE;
   return renderContinuationGuidance(template, {
     lastTurnSummary: normalizeContinuationVariable(lastTurnSummary) ?? "No previous turn summary was captured.",
-    cumulativeTurnCount: String(Math.max(0, parseNonNegativeInteger2(cumulativeTurnCount)))
+    cumulativeTurnCount: String(Math.max(0, parseNonNegativeInteger(cumulativeTurnCount)))
   });
 }
 function normalizeContinuationVariable(value) {
@@ -668,7 +575,52 @@ function normalizeContinuationVariable(value) {
   return normalized ? normalized : null;
 }
 function renderContinuationGuidance(template, variables) {
-  return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (match, key) => variables[key] ?? match);
+  if (template.includes("{%") || template.includes("%}")) {
+    throw new Error("template_parse_error: continuation guidance does not support Liquid tags.");
+  }
+  let rendered = "";
+  let lastIndex = 0;
+  const pattern = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/g;
+  for (const match of template.matchAll(pattern)) {
+    const matchedText = match[0];
+    const expression = match[1];
+    const index = match.index ?? 0;
+    rendered += template.slice(lastIndex, index);
+    if (!(expression in variables)) {
+      throw new Error(`template_render_error: unsupported continuation guidance variable '${expression}'.`);
+    }
+    rendered += variables[expression] ?? "";
+    lastIndex = index + matchedText.length;
+  }
+  rendered += template.slice(lastIndex);
+  const strayLiquidExpression = rendered.match(/\{\{[^}]*\}\}/);
+  if (strayLiquidExpression) {
+    throw new Error(`template_parse_error: invalid continuation guidance expression '${strayLiquidExpression[0]}'.`);
+  }
+  return rendered;
+}
+
+// ../worker/dist/turn-limits.js
+var DEFAULT_SESSION_MAX_TURNS = 20;
+function resolveMaxTurns(value) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) {
+    return {
+      maxTurns: DEFAULT_SESSION_MAX_TURNS,
+      exhaustedBeforeStart: false
+    };
+  }
+  const normalized = Math.trunc(parsed);
+  if (normalized <= 0) {
+    return {
+      maxTurns: 0,
+      exhaustedBeforeStart: true
+    };
+  }
+  return {
+    maxTurns: normalized,
+    exhaustedBeforeStart: false
+  };
 }
 
 // ../worker/dist/token-usage.js
@@ -698,7 +650,6 @@ function resolveTokenUsageArtifactPath(env) {
 
 // ../worker/dist/index.js
 var launcherEnv = loadLauncherEnvironment(process.env);
-var sessionBudgetState = resolveSessionBudgetState(launcherEnv);
 var runtimeState = {
   status: launcherEnv.SYMPHONY_RUN_ID ? "starting" : "idle",
   executionPhase: null,
@@ -719,9 +670,9 @@ var runtimeState = {
     lastError: null
   } : null,
   tokenUsage: {
-    inputTokens: sessionBudgetState.tokenUsageBaseline.inputTokens,
-    outputTokens: sessionBudgetState.tokenUsageBaseline.outputTokens,
-    totalTokens: sessionBudgetState.tokenUsageBaseline.totalTokens
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
   },
   lastEventAt: null,
   rateLimits: null,
@@ -916,7 +867,7 @@ function resolveTurnTokenUsageDelta(baseline) {
   };
 }
 function resolveSessionTokenUsageDelta() {
-  return resolveTurnTokenUsageDelta(sessionBudgetState.tokenUsageBaseline);
+  return cloneTokenUsageSnapshot();
 }
 async function persistSessionTokenUsageArtifact(env) {
   await persistTokenUsageArtifact(env, resolveSessionTokenUsageDelta());
@@ -1049,17 +1000,13 @@ async function runCodexClientProtocol(child, plan, env, options) {
     process.stderr.write("[worker] codex process has no stdio pipes; cannot run client protocol\n");
     return;
   }
-  const maxTurns = Number(env.SYMPHONY_MAX_TURNS) || 20;
-  const cumulativeTurnCount = parseNonNegativeInteger2(env.SYMPHONY_CUMULATIVE_TURN_COUNT);
-  const remainingTurns = resolveRemainingTurns(maxTurns, cumulativeTurnCount);
+  const { maxTurns, exhaustedBeforeStart } = resolveMaxTurns(env.SYMPHONY_MAX_TURNS);
   const readTimeoutMs = Number(env.SYMPHONY_READ_TIMEOUT_MS) || 5e3;
   const turnTimeoutMs = Number(env.SYMPHONY_TURN_TIMEOUT_MS) || 36e5;
   const maxNonProductiveTurns = resolveMaxNonProductiveTurns(env);
   const issueIdentifier = env.SYMPHONY_ISSUE_IDENTIFIER ?? "";
-  const lastTurnSummary = env.SYMPHONY_LAST_TURN_SUMMARY ?? null;
   const continuationGuidance = env.SYMPHONY_CONTINUATION_GUIDANCE ?? options.continuationGuidance;
   const { approvalPolicy, threadSandbox, turnSandboxPolicy } = resolveCodexPolicySettings(env);
-  const budgetState = resolveSessionBudgetState(env);
   let previousTurnProgressSnapshot = {
     ...captureTurnWorkspaceSnapshot(plan.cwd),
     lastError: runtimeState.run?.lastError ?? null
@@ -1079,16 +1026,8 @@ async function runCodexClientProtocol(child, plan, env, options) {
   let userInputRequired = false;
   let turnTerminalFailurePhase = null;
   let activeTurnTelemetry = null;
-  let budgetExceededReason = null;
   let consecutiveNonProductiveTurns = 0;
   let convergenceDetected = false;
-  function checkSessionBudgets(currentSessionTurnCount) {
-    return resolveBudgetExceededReason(budgetState, currentSessionTurnCount, {
-      inputTokens: runtimeState.tokenUsage.inputTokens - budgetState.tokenUsageBaseline.inputTokens,
-      outputTokens: runtimeState.tokenUsage.outputTokens - budgetState.tokenUsageBaseline.outputTokens,
-      totalTokens: runtimeState.tokenUsage.totalTokens - budgetState.tokenUsageBaseline.totalTokens
-    }, /* @__PURE__ */ new Date());
-  }
   function resolvePendingTurnCompletion() {
     if (turnCompletedResolve) {
       turnCompletedResolve();
@@ -1406,27 +1345,6 @@ async function runCodexClientProtocol(child, plan, env, options) {
         env: t.env
       };
     }
-    if (remainingTurns <= 0) {
-      process.stderr.write(`[worker] max_turns already exhausted by previous sessions (${cumulativeTurnCount}/${maxTurns})
-`);
-      runtimeState.status = "completed";
-      runtimeState.runPhase = "succeeded";
-      runtimeState.sessionInfo.exitClassification = classifySessionExit({
-        runPhase: runtimeState.runPhase,
-        userInputRequired: false,
-        budgetExceeded: false,
-        convergenceDetected: false,
-        maxTurnsReached: true
-      });
-      stopOrchestratorHeartbeatTimer();
-      emitOrchestratorHeartbeat();
-      await persistSessionTokenUsageArtifact(env);
-      await waitForPendingOrchestratorChannelFlush(resolveTerminalOrchestratorChannelFlushTimeoutMs());
-      setTimeout(() => {
-        process.exit(0);
-      }, 1500);
-      return;
-    }
     const baseThreadParams = {
       cwd: plan.cwd,
       developerInstructions: renderedPrompt,
@@ -1436,36 +1354,12 @@ async function runCodexClientProtocol(child, plan, env, options) {
         mcp_servers: mcpServers
       }
     };
-    const resumeThreadId = plan.resumeThreadId;
-    let threadBootstrapMode = "fresh";
     process.stderr.write(`[worker] starting codex thread (mcp_servers: ${Object.keys(mcpServers).join(", ")})
 `);
-    let threadResult;
-    if (resumeThreadId) {
-      process.stderr.write(`[worker] attempting thread/resume for ${resumeThreadId}
-`);
-      try {
-        threadResult = await sendRequestWithTimeout("thread-resume-1", "thread/resume", {
-          ...baseThreadParams,
-          threadId: resumeThreadId
-        });
-        threadBootstrapMode = "resume";
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error ?? "unknown");
-        threadBootstrapMode = "soft-resume";
-        process.stderr.write(`[worker] thread/resume failed for ${resumeThreadId}: ${message}; falling back to thread/start
-`);
-        threadResult = await sendRequestWithTimeout("thread-1", "thread/start", {
-          ...baseThreadParams,
-          ephemeral: false
-        });
-      }
-    } else {
-      threadResult = await sendRequestWithTimeout("thread-1", "thread/start", {
-        ...baseThreadParams,
-        ephemeral: false
-      });
-    }
+    const threadResult = await sendRequestWithTimeout("thread-1", "thread/start", {
+      ...baseThreadParams,
+      ephemeral: false
+    });
     const threadId = threadResult.thread_id ?? threadResult.thread?.id;
     runtimeState.sessionInfo.threadId = threadId ?? null;
     runtimeState.sessionInfo.turnId = null;
@@ -1480,31 +1374,21 @@ async function runCodexClientProtocol(child, plan, env, options) {
     }
     let turnCount = 0;
     let requestIdCounter = 0;
-    let maxTurnsReached = false;
-    for (let turn = 0; turn < remainingTurns; turn++) {
-      budgetExceededReason = checkSessionBudgets(turn);
-      if (budgetExceededReason) {
-        process.stderr.write(`[worker] session budget exceeded (${budgetExceededReason}) \u2014 exiting
+    let maxTurnsReached = exhaustedBeforeStart;
+    if (exhaustedBeforeStart) {
+      process.stderr.write(`[worker] max_turns (${String(env.SYMPHONY_MAX_TURNS ?? maxTurns)}) does not allow any turns for this worker session \u2014 exiting
 `);
-        break;
-      }
+    }
+    for (let turn = 0; turn < maxTurns; turn++) {
       turnCount = turn + 1;
-      const globalTurnCount = cumulativeTurnCount + turnCount;
       runtimeState.sessionInfo.turnCount = turnCount;
       runtimeState.runPhase = "streaming_turn";
       const isFirstTurn = turn === 0;
-      const turnInput = isFirstTurn ? buildInitialTurnInput({
-        renderedPrompt,
-        mode: threadBootstrapMode,
-        lastTurnSummary,
-        cumulativeTurnCount,
-        continuationGuidance
-      }) : buildContinuationTurnInput({
+      const turnInput = isFirstTurn ? renderedPrompt : buildContinuationTurnInput({
         continuationGuidance,
-        lastTurnSummary,
-        cumulativeTurnCount: globalTurnCount - 1
+        cumulativeTurnCount: turn
       });
-      process.stderr.write(`[worker] starting codex turn ${globalTurnCount}/${maxTurns}${isFirstTurn ? " (initial)" : " (continuation)"}
+      process.stderr.write(`[worker] starting codex turn ${turnCount}/${maxTurns}${isFirstTurn ? " (initial)" : " (continuation)"}
 `);
       requestIdCounter += 1;
       const turnRequestId = `turn-${requestIdCounter}`;
@@ -1544,15 +1428,9 @@ async function runCodexClientProtocol(child, plan, env, options) {
 `);
         break;
       }
-      budgetExceededReason = checkSessionBudgets(turnCount);
-      if (budgetExceededReason) {
-        process.stderr.write(`[worker] session budget exceeded (${budgetExceededReason}) \u2014 exiting
-`);
-        break;
-      }
-      if (turn + 1 >= remainingTurns) {
+      if (turn + 1 >= maxTurns) {
         maxTurnsReached = true;
-        process.stderr.write(`[worker] max_turns (${maxTurns}) reached across sessions \u2014 exiting
+        process.stderr.write(`[worker] max_turns (${maxTurns}) reached for this worker session \u2014 exiting
 `);
         break;
       }
@@ -1600,7 +1478,7 @@ async function runCodexClientProtocol(child, plan, env, options) {
     runtimeState.sessionInfo.exitClassification = classifySessionExit({
       runPhase: runtimeState.runPhase,
       userInputRequired,
-      budgetExceeded: budgetExceededReason !== null,
+      budgetExceeded: false,
       convergenceDetected,
       maxTurnsReached
     });