titan-agent 6.2.1 → 6.3.0

package/dist/agent/goalDriver.js

@@ -200,7 +200,149 @@ async function tickPlanning(goal, state) {
   state.phase = "delegating";
   appendHistory(state, "delegating", `Planned: ${Object.keys(state.subtaskStates).length} subtasks classified`);
 }
+const MAX_BURST_PARALLEL = 4;
+async function tryBurstDispatch(goal, state) {
+  const ready = await pickAllReadySubtasks(goal, state, MAX_BURST_PARALLEL);
+  if (ready.length < 2) return "fallthrough";
+  const validated = [];
+  for (const sub of ready) {
+    const subState = state.subtaskStates[sub.id];
+    if (!subState) continue;
+    const cap = subState.maxAttempts ?? 5;
+    if (subState.attempts + 1 > cap) continue;
+    const strategy = nextFallback(subState.kind, subState.attempts, subState.lastError, cap);
+    if (!strategy) continue;
+    validated.push({ subtask: sub, subState, strategy });
+  }
+  if (validated.length < 2) return "fallthrough";
+  const batchStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.parallelBatch = {
+    ids: validated.map((v) => v.subtask.id),
+    startedAt: batchStartedAt
+  };
+  for (const v of validated) {
+    v.subState.attempts += 1;
+    v.subState.specialist = v.strategy.specialist;
+    v.subState.pendingSpawn = {
+      attemptedAt: batchStartedAt,
+      specialist: v.strategy.specialist
+    };
+    try {
+      emitAgentEvent({
+        type: "agent_spawn",
+        agentId: v.strategy.specialist,
+        agentName: v.strategy.specialist,
+        timestamp: Date.now(),
+        data: {
+          goalId: goal.id,
+          subtaskId: v.subtask.id,
+          subtaskTitle: v.subtask.title,
+          subtaskKind: v.subState.kind,
+          attempt: v.subState.attempts,
+          burst: true,
+          burstSize: validated.length
+        }
+      });
+    } catch {
+    }
+  }
+  appendHistory(
+    state,
+    "observing",
+    `Burst dispatch: ${validated.length} subtasks in parallel (${validated.map((v) => v.subtask.title.slice(0, 32)).join(" | ")})`
+  );
+  state.phase = "observing";
+  const burstStartMs = Date.now();
+  const settled = await Promise.allSettled(
+    validated.map((v) => structuredSpawn({
+      specialistId: v.strategy.specialist,
+      task: `${v.subtask.title}
+
+${v.subtask.description}${v.strategy.promptAdjustment ?? ""}`,
+      modelOverride: v.strategy.modelOverride,
+      toolAllowlist: routeForKind(v.subState.kind).toolAllowlist,
+      maxRounds: v.strategy.maxRounds,
+      goalId: goal.id
+    }))
+  );
+  const burstDurationMs = Date.now() - burstStartMs;
+  let happyCount = 0;
+  for (let i = 0; i < validated.length; i++) {
+    const v = validated[i];
+    const outcome = settled[i];
+    v.subState.pendingSpawn = void 0;
+    if (outcome.status === "rejected") {
+      v.subState.lastError = outcome.reason?.message ?? String(outcome.reason);
+      appendHistory(state, "iterating", `Burst spawn threw for ${v.subtask.id}: ${v.subState.lastError.slice(0, 100)}`);
+      continue;
+    }
+    const result = outcome.value;
+    recordSpend(state, {
+      elapsedMs: burstDurationMs / validated.length,
+      // amortized; the wall-clock saving is the point
+      tokens: result.tokensUsed ?? 0,
+      costUsd: result.costUsd ?? 0
+    });
+    v.subState.artifacts = [.../* @__PURE__ */ new Set([
+      ...v.subState.artifacts,
+      ...result.artifacts.map((a) => a.ref)
+    ])];
+    try {
+      emitAgentEvent({
+        type: "agent_done",
+        agentId: v.strategy.specialist,
+        agentName: v.strategy.specialist,
+        timestamp: Date.now(),
+        data: {
+          goalId: goal.id,
+          subtaskId: v.subtask.id,
+          subtaskTitle: v.subtask.title,
+          status: result.status,
+          reasoning: result.reasoning,
+          artifactCount: result.artifacts.length,
+          artifacts: result.artifacts.map((a) => ({ ref: a.ref, type: a.type })),
+          toolsUsed: result.toolsUsed ?? [],
+          tokensUsed: result.tokensUsed ?? 0,
+          costUsd: result.costUsd ?? 0,
+          durationMs: burstDurationMs,
+          model: v.strategy.modelOverride ?? v.strategy.specialist,
+          burst: true
+        }
+      });
+    } catch {
+    }
+    if (result.status === "done") {
+      v.subState.consecutiveNeedsInfoCount = 0;
+      v.subState.lastSpawnResult = result;
+      try {
+        const { completeSubtask } = await import("./goals.js");
+        completeSubtask(goal.id, v.subtask.id, result.reasoning || "completed via burst");
+      } catch (err) {
+        v.subState.lastError = `Burst completion persist failed: ${err.message}`;
+        continue;
+      }
+      happyCount++;
+    } else if (result.status === "failed") {
+      v.subState.lastError = result.reasoning || "failed";
+      v.subState.consecutiveNeedsInfoCount = 0;
+    } else {
+      v.subState.lastError = result.reasoning || `Burst returned ${result.status}; deferring to single-path retry.`;
+    }
+  }
+  state.parallelBatch = void 0;
+  appendHistory(
+    state,
+    "delegating",
+    `Burst complete: ${happyCount}/${validated.length} succeeded in ${burstDurationMs}ms (parallel)`
+  );
+  state.phase = "delegating";
+  return "handled";
+}
 async function tickDelegating(goal, state) {
+  if (!state.parallelBatch) {
+    const burst = await tryBurstDispatch(goal, state);
+    if (burst === "handled") return;
+  }
   const next = await pickNextReadySubtask(goal, state);
   if (!next) {
     let freshGoal = goal;
@@ -900,12 +1042,19 @@ async function tickCancelled(goal, state) {
   appendHistory(state, "cancelled", "Cancelled by user");
 }
 async function pickNextReadySubtask(goal, state) {
-  const cap = (id) => state.subtaskStates[id]?.maxAttempts ?? 5;
+  const ready = await pickAllReadySubtasks(goal, state, 1);
+  return ready[0] ?? null;
+}
+async function pickAllReadySubtasks(goal, state, cap) {
+  if (cap < 1) return [];
+  const attemptCap = (id) => state.subtaskStates[id]?.maxAttempts ?? 5;
+  const ready = [];
   for (const sub of goal.subtasks || []) {
+    if (ready.length >= cap) break;
     if (sub.status !== "pending") continue;
     const subState = state.subtaskStates[sub.id];
     if (!subState) continue;
-    const exhaustedAttempts = subState.attempts >= cap(sub.id) || subState.attempts >= state.budgetCaps.maxRetries;
+    const exhaustedAttempts = subState.attempts >= attemptCap(sub.id) || subState.attempts >= state.budgetCaps.maxRetries;
     if (subState.verificationResult?.passed === false && exhaustedAttempts) {
       try {
         const { failSubtask } = await import("./goals.js");
@@ -920,9 +1069,9 @@ async function pickNextReadySubtask(goal, state) {
       return dep?.status === "done";
     });
     if (!depsSatisfied) continue;
-    return sub;
+    ready.push(sub);
   }
-  return null;
+  return ready;
 }
 function slugForGoal(title) {
   return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "report";
@@ -1229,6 +1378,7 @@ export {
   listActiveDrivers,
   listAllDrivers,
   pauseDriver,
+  pickAllReadySubtasks,
   reprioritizeDriver,
   resumeDriverControl,
   shouldAutoCancelOnRecurringBlock,